truffle: src/share/vm/code/compiledIC.hpp annotate

annotate src/share/vm/code/compiledIC.hpp @ 21205:f34ae5c01864

include reexecute, rethrow_exception and return_oop info when disassembling debug scopes

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 04 May 2015 10:39:12 +0200
parents	7848fc12602b
children

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
14223 de6a9e811145 8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013 mikael parents: 12294 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 0 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 0 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 0 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #ifndef SHARE_VM_CODE_COMPILEDIC_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #define SHARE_VM_CODE_COMPILEDIC_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "interpreter/linkResolver.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	29 #include "oops/compiledICHolder.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 # include "nativeInst_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 # include "nativeInst_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	35 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	36 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	37 # include "nativeInst_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	38 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	39 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	40 # include "nativeInst_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	41 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	42 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	43 # include "nativeInst_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	44 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	45
0 a61af66fc99e Initial load duke parents: diff changeset	46 //-----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	47 // The CompiledIC represents a compiled inline cache.
a61af66fc99e Initial load duke parents: diff changeset	48 //
a61af66fc99e Initial load duke parents: diff changeset	49 // In order to make patching of the inline cache MT-safe, we only allow the following
a61af66fc99e Initial load duke parents: diff changeset	50 // transitions (when not at a safepoint):
a61af66fc99e Initial load duke parents: diff changeset	51 //
a61af66fc99e Initial load duke parents: diff changeset	52 //
a61af66fc99e Initial load duke parents: diff changeset	53 // [1] --<-- Clean -->--- [1]
a61af66fc99e Initial load duke parents: diff changeset	54 // / (null) \
a61af66fc99e Initial load duke parents: diff changeset	55 // / \ /-<-\
a61af66fc99e Initial load duke parents: diff changeset	56 // / [2] \ / \
a61af66fc99e Initial load duke parents: diff changeset	57 // Interpreted ---------> Monomorphic \| [3]
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	58 // (CompiledICHolder) (Klass) \|
0 a61af66fc99e Initial load duke parents: diff changeset	59 // \ / \ /
a61af66fc99e Initial load duke parents: diff changeset	60 // [4] \ / [4] \->-/
a61af66fc99e Initial load duke parents: diff changeset	61 // \->- Megamorphic -<-/
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	62 // (Method*)
0 a61af66fc99e Initial load duke parents: diff changeset	63 //
a61af66fc99e Initial load duke parents: diff changeset	64 // The text in paranteses () refere to the value of the inline cache receiver (mov instruction)
a61af66fc99e Initial load duke parents: diff changeset	65 //
a61af66fc99e Initial load duke parents: diff changeset	66 // The numbers in square brackets refere to the kind of transition:
a61af66fc99e Initial load duke parents: diff changeset	67 // [1]: Initial fixup. Receiver it found from debug information
a61af66fc99e Initial load duke parents: diff changeset	68 // [2]: Compilation of a method
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	69 // [3]: Recompilation of a method (note: only entry is changed. The Klass* must stay the same)
0 a61af66fc99e Initial load duke parents: diff changeset	70 // [4]: Inline cache miss. We go directly to megamorphic call.
a61af66fc99e Initial load duke parents: diff changeset	71 //
a61af66fc99e Initial load duke parents: diff changeset	72 // The class automatically inserts transition stubs (using the InlineCacheBuffer) when an MT-unsafe
a61af66fc99e Initial load duke parents: diff changeset	73 // transition is made to a stub.
a61af66fc99e Initial load duke parents: diff changeset	74 //
a61af66fc99e Initial load duke parents: diff changeset	75 class CompiledIC;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	76 class ICStub;
0 a61af66fc99e Initial load duke parents: diff changeset	77
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	78 class CompiledICInfo : public StackObj {
0 a61af66fc99e Initial load duke parents: diff changeset	79 private:
a61af66fc99e Initial load duke parents: diff changeset	80 address _entry; // entry point for call
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	81 void* _cached_value; // Value of cached_value (either in stub or inline cache)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	82 bool _is_icholder; // Is the cached value a CompiledICHolder*
0 a61af66fc99e Initial load duke parents: diff changeset	83 bool _is_optimized; // it is an optimized virtual call (i.e., can be statically bound)
a61af66fc99e Initial load duke parents: diff changeset	84 bool _to_interpreter; // Call it to interpreter
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	85 bool _release_icholder;
0 a61af66fc99e Initial load duke parents: diff changeset	86 public:
a61af66fc99e Initial load duke parents: diff changeset	87 address entry() const { return _entry; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	88 Metadata* cached_metadata() const { assert(!_is_icholder, ""); return (Metadata*)_cached_value; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	89 CompiledICHolder* claim_cached_icholder() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	90 assert(_is_icholder, "");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	91 assert(_cached_value != NULL, "must be non-NULL");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	92 _release_icholder = false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	93 CompiledICHolder* icholder = (CompiledICHolder*)_cached_value;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	94 icholder->claim();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	95 return icholder;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	96 }
0 a61af66fc99e Initial load duke parents: diff changeset	97 bool is_optimized() const { return _is_optimized; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	98 bool to_interpreter() const { return _to_interpreter; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	99
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	100 void set_compiled_entry(address entry, Klass* klass, bool is_optimized) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	101 _entry = entry;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	102 _cached_value = (void*)klass;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	103 _to_interpreter = false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	104 _is_icholder = false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	105 _is_optimized = is_optimized;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	106 _release_icholder = false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	107 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	108
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	109 void set_interpreter_entry(address entry, Method* method) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	110 _entry = entry;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	111 _cached_value = (void*)method;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	112 _to_interpreter = true;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	113 _is_icholder = false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	114 _is_optimized = true;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	115 _release_icholder = false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	116 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	117
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	118 void set_icholder_entry(address entry, CompiledICHolder* icholder) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	119 _entry = entry;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	120 _cached_value = (void*)icholder;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	121 _to_interpreter = true;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	122 _is_icholder = true;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	123 _is_optimized = false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	124 _release_icholder = true;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	125 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	126
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	127 CompiledICInfo(): _entry(NULL), _cached_value(NULL), _is_icholder(false),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	128 _to_interpreter(false), _is_optimized(false), _release_icholder(false) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	129 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	130 ~CompiledICInfo() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	131 // In rare cases the info is computed but not used, so release any
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	132 // CompiledICHolder* that was created
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	133 if (_release_icholder) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	134 assert(_is_icholder, "must be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	135 CompiledICHolder* icholder = (CompiledICHolder*)_cached_value;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	136 icholder->claim();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	137 delete icholder;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	138 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	139 }
0 a61af66fc99e Initial load duke parents: diff changeset	140 };
a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 class CompiledIC: public ResourceObj {
a61af66fc99e Initial load duke parents: diff changeset	143 friend class InlineCacheBuffer;
a61af66fc99e Initial load duke parents: diff changeset	144 friend class ICStub;
a61af66fc99e Initial load duke parents: diff changeset	145
a61af66fc99e Initial load duke parents: diff changeset	146
a61af66fc99e Initial load duke parents: diff changeset	147 private:
a61af66fc99e Initial load duke parents: diff changeset	148 NativeCall* _ic_call; // the call instruction
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	149 NativeMovConstReg* _value; // patchable value cell for this IC
0 a61af66fc99e Initial load duke parents: diff changeset	150 bool _is_optimized; // an optimized virtual call (i.e., no compiled IC)
a61af66fc99e Initial load duke parents: diff changeset	151
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	152 CompiledIC(nmethod* nm, NativeCall* ic_call);
20277 882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 14223 diff changeset	153 CompiledIC(RelocIterator* iter);
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 14223 diff changeset	154
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 14223 diff changeset	155 void initialize_from_iter(RelocIterator* iter);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	156
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	157 static bool is_icholder_entry(address entry);
0 a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 // low-level inline-cache manipulation. Cannot be accessed directly, since it might not be MT-safe
a61af66fc99e Initial load duke parents: diff changeset	160 // to change an inline-cache. These changes the underlying inline-cache directly. They newer make
a61af66fc99e Initial load duke parents: diff changeset	161 // changes to a transition stub.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	162 void internal_set_ic_destination(address entry_point, bool is_icstub, void* cache, bool is_icholder);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	163 void set_ic_destination(ICStub* stub);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	164 void set_ic_destination(address entry_point) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	165 assert(_is_optimized, "use set_ic_destination_and_value instead");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	166 internal_set_ic_destination(entry_point, false, NULL, false);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	167 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	168 // This only for use by ICStubs where the type of the value isn't known
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	169 void set_ic_destination_and_value(address entry_point, void* value) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	170 internal_set_ic_destination(entry_point, false, value, is_icholder_entry(entry_point));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	171 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	172 void set_ic_destination_and_value(address entry_point, Metadata* value) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	173 internal_set_ic_destination(entry_point, false, value, false);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	174 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	175 void set_ic_destination_and_value(address entry_point, CompiledICHolder* value) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	176 internal_set_ic_destination(entry_point, false, value, true);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	177 }
0 a61af66fc99e Initial load duke parents: diff changeset	178
a61af66fc99e Initial load duke parents: diff changeset	179 // Reads the location of the transition stub. This will fail with an assertion, if no transition stub is
a61af66fc99e Initial load duke parents: diff changeset	180 // associated with the inline cache.
a61af66fc99e Initial load duke parents: diff changeset	181 address stub_address() const;
a61af66fc99e Initial load duke parents: diff changeset	182 bool is_in_transition_state() const; // Use InlineCacheBuffer
a61af66fc99e Initial load duke parents: diff changeset	183
a61af66fc99e Initial load duke parents: diff changeset	184 public:
a61af66fc99e Initial load duke parents: diff changeset	185 // conversion (machine PC to CompiledIC*)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	186 friend CompiledIC* CompiledIC_before(nmethod* nm, address return_addr);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	187 friend CompiledIC* CompiledIC_at(nmethod* nm, address call_site);
0 a61af66fc99e Initial load duke parents: diff changeset	188 friend CompiledIC* CompiledIC_at(Relocation* call_site);
20277 882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 14223 diff changeset	189 friend CompiledIC* CompiledIC_at(RelocIterator* reloc_iter);
0 a61af66fc99e Initial load duke parents: diff changeset	190
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	191 // This is used to release CompiledICHolder*s from nmethods that
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	192 // are about to be freed. The callsite might contain other stale
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	193 // values of other kinds so it must be careful.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	194 static void cleanup_call_site(virtual_call_Relocation* call_site);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	195 static bool is_icholder_call_site(virtual_call_Relocation* call_site);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	196
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	197 // Return the cached_metadata/destination associated with this inline cache. If the cache currently points
0 a61af66fc99e Initial load duke parents: diff changeset	198 // to a transition stub, it will read the values from the transition stub.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	199 void* cached_value() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	200 CompiledICHolder* cached_icholder() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	201 assert(is_icholder_call(), "must be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	202 return (CompiledICHolder*) cached_value();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	203 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	204 Metadata* cached_metadata() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	205 assert(!is_icholder_call(), "must be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	206 return (Metadata*) cached_value();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	207 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	208
0 a61af66fc99e Initial load duke parents: diff changeset	209 address ic_destination() const;
a61af66fc99e Initial load duke parents: diff changeset	210
a61af66fc99e Initial load duke parents: diff changeset	211 bool is_optimized() const { return _is_optimized; }
a61af66fc99e Initial load duke parents: diff changeset	212
a61af66fc99e Initial load duke parents: diff changeset	213 // State
a61af66fc99e Initial load duke parents: diff changeset	214 bool is_clean() const;
a61af66fc99e Initial load duke parents: diff changeset	215 bool is_megamorphic() const;
a61af66fc99e Initial load duke parents: diff changeset	216 bool is_call_to_compiled() const;
a61af66fc99e Initial load duke parents: diff changeset	217 bool is_call_to_interpreted() const;
a61af66fc99e Initial load duke parents: diff changeset	218
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	219 bool is_icholder_call() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	220
0 a61af66fc99e Initial load duke parents: diff changeset	221 address end_of_call() { return _ic_call->return_address(); }
a61af66fc99e Initial load duke parents: diff changeset	222
a61af66fc99e Initial load duke parents: diff changeset	223 // MT-safe patching of inline caches. Note: Only safe to call is_xxx when holding the CompiledIC_ock
a61af66fc99e Initial load duke parents: diff changeset	224 // so you are guaranteed that no patching takes place. The same goes for verify.
a61af66fc99e Initial load duke parents: diff changeset	225 //
a61af66fc99e Initial load duke parents: diff changeset	226 // Note: We do not provide any direct access to the stub code, to prevent parts of the code
a61af66fc99e Initial load duke parents: diff changeset	227 // to manipulate the inline cache in MT-unsafe ways.
a61af66fc99e Initial load duke parents: diff changeset	228 //
a61af66fc99e Initial load duke parents: diff changeset	229 // They all takes a TRAP argument, since they can cause a GC if the inline-cache buffer is full.
a61af66fc99e Initial load duke parents: diff changeset	230 //
a61af66fc99e Initial load duke parents: diff changeset	231 void set_to_clean(); // Can only be called during a safepoint operation
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	232 void set_to_monomorphic(CompiledICInfo& info);
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 10168 diff changeset	233
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 10168 diff changeset	234 // Returns true if successful and false otherwise. The call can fail if memory
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 10168 diff changeset	235 // allocation in the code cache fails.
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 10168 diff changeset	236 bool set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	237
a61af66fc99e Initial load duke parents: diff changeset	238 static void compute_monomorphic_entry(methodHandle method, KlassHandle receiver_klass,
a61af66fc99e Initial load duke parents: diff changeset	239 bool is_optimized, bool static_bound, CompiledICInfo& info, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	240
a61af66fc99e Initial load duke parents: diff changeset	241 // Location
a61af66fc99e Initial load duke parents: diff changeset	242 address instruction_address() const { return _ic_call->instruction_address(); }
a61af66fc99e Initial load duke parents: diff changeset	243
a61af66fc99e Initial load duke parents: diff changeset	244 // Misc
a61af66fc99e Initial load duke parents: diff changeset	245 void print() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	246 void print_compiled_ic() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	247 void verify() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	248 };
a61af66fc99e Initial load duke parents: diff changeset	249
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	250 inline CompiledIC* CompiledIC_before(nmethod* nm, address return_addr) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	251 CompiledIC* c_ic = new CompiledIC(nm, nativeCall_before(return_addr));
0 a61af66fc99e Initial load duke parents: diff changeset	252 c_ic->verify();
a61af66fc99e Initial load duke parents: diff changeset	253 return c_ic;
a61af66fc99e Initial load duke parents: diff changeset	254 }
a61af66fc99e Initial load duke parents: diff changeset	255
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	256 inline CompiledIC* CompiledIC_at(nmethod* nm, address call_site) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	257 CompiledIC* c_ic = new CompiledIC(nm, nativeCall_at(call_site));
0 a61af66fc99e Initial load duke parents: diff changeset	258 c_ic->verify();
a61af66fc99e Initial load duke parents: diff changeset	259 return c_ic;
a61af66fc99e Initial load duke parents: diff changeset	260 }
a61af66fc99e Initial load duke parents: diff changeset	261
a61af66fc99e Initial load duke parents: diff changeset	262 inline CompiledIC* CompiledIC_at(Relocation* call_site) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	263 assert(call_site->type() == relocInfo::virtual_call_type \|\|
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	264 call_site->type() == relocInfo::opt_virtual_call_type, "wrong reloc. info");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	265 CompiledIC* c_ic = new CompiledIC(call_site->code(), nativeCall_at(call_site->addr()));
0 a61af66fc99e Initial load duke parents: diff changeset	266 c_ic->verify();
a61af66fc99e Initial load duke parents: diff changeset	267 return c_ic;
a61af66fc99e Initial load duke parents: diff changeset	268 }
a61af66fc99e Initial load duke parents: diff changeset	269
20277 882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 14223 diff changeset	270 inline CompiledIC* CompiledIC_at(RelocIterator* reloc_iter) {
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 14223 diff changeset	271 assert(reloc_iter->type() == relocInfo::virtual_call_type \|\|
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 14223 diff changeset	272 reloc_iter->type() == relocInfo::opt_virtual_call_type, "wrong reloc. info");
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 14223 diff changeset	273 CompiledIC* c_ic = new CompiledIC(reloc_iter);
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 14223 diff changeset	274 c_ic->verify();
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 14223 diff changeset	275 return c_ic;
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 14223 diff changeset	276 }
0 a61af66fc99e Initial load duke parents: diff changeset	277
a61af66fc99e Initial load duke parents: diff changeset	278 //-----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	279 // The CompiledStaticCall represents a call to a static method in the compiled
a61af66fc99e Initial load duke parents: diff changeset	280 //
a61af66fc99e Initial load duke parents: diff changeset	281 // Transition diagram of a static call site is somewhat simpler than for an inlined cache:
a61af66fc99e Initial load duke parents: diff changeset	282 //
a61af66fc99e Initial load duke parents: diff changeset	283 //
a61af66fc99e Initial load duke parents: diff changeset	284 // -----<----- Clean ----->-----
a61af66fc99e Initial load duke parents: diff changeset	285 // / \
a61af66fc99e Initial load duke parents: diff changeset	286 // / \
a61af66fc99e Initial load duke parents: diff changeset	287 // compilled code <------------> interpreted code
a61af66fc99e Initial load duke parents: diff changeset	288 //
a61af66fc99e Initial load duke parents: diff changeset	289 // Clean: Calls directly to runtime method for fixup
a61af66fc99e Initial load duke parents: diff changeset	290 // Compiled code: Calls directly to compiled code
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	291 // Interpreted code: Calls to stub that set Method* reference
0 a61af66fc99e Initial load duke parents: diff changeset	292 //
a61af66fc99e Initial load duke parents: diff changeset	293 //
a61af66fc99e Initial load duke parents: diff changeset	294 class CompiledStaticCall;
a61af66fc99e Initial load duke parents: diff changeset	295
a61af66fc99e Initial load duke parents: diff changeset	296 class StaticCallInfo {
a61af66fc99e Initial load duke parents: diff changeset	297 private:
a61af66fc99e Initial load duke parents: diff changeset	298 address _entry; // Entrypoint
a61af66fc99e Initial load duke parents: diff changeset	299 methodHandle _callee; // Callee (used when calling interpreter)
a61af66fc99e Initial load duke parents: diff changeset	300 bool _to_interpreter; // call to interpreted method (otherwise compiled)
a61af66fc99e Initial load duke parents: diff changeset	301
a61af66fc99e Initial load duke parents: diff changeset	302 friend class CompiledStaticCall;
a61af66fc99e Initial load duke parents: diff changeset	303 public:
a61af66fc99e Initial load duke parents: diff changeset	304 address entry() const { return _entry; }
a61af66fc99e Initial load duke parents: diff changeset	305 methodHandle callee() const { return _callee; }
a61af66fc99e Initial load duke parents: diff changeset	306 };
a61af66fc99e Initial load duke parents: diff changeset	307
a61af66fc99e Initial load duke parents: diff changeset	308
a61af66fc99e Initial load duke parents: diff changeset	309 class CompiledStaticCall: public NativeCall {
a61af66fc99e Initial load duke parents: diff changeset	310 friend class CompiledIC;
a61af66fc99e Initial load duke parents: diff changeset	311
a61af66fc99e Initial load duke parents: diff changeset	312 // Also used by CompiledIC
a61af66fc99e Initial load duke parents: diff changeset	313 void set_to_interpreted(methodHandle callee, address entry);
a61af66fc99e Initial load duke parents: diff changeset	314 bool is_optimized_virtual();
a61af66fc99e Initial load duke parents: diff changeset	315
a61af66fc99e Initial load duke parents: diff changeset	316 public:
a61af66fc99e Initial load duke parents: diff changeset	317 friend CompiledStaticCall* compiledStaticCall_before(address return_addr);
a61af66fc99e Initial load duke parents: diff changeset	318 friend CompiledStaticCall* compiledStaticCall_at(address native_call);
a61af66fc99e Initial load duke parents: diff changeset	319 friend CompiledStaticCall* compiledStaticCall_at(Relocation* call_site);
a61af66fc99e Initial load duke parents: diff changeset	320
10168 a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub dlong parents: 6725 diff changeset	321 // Code
15046 5c71dcf0915d use hotspot static stubs for call sites Tom Rodriguez <tom.rodriguez@oracle.com> parents: 14909 diff changeset	322 static void emit_to_interp_stub(CodeBuffer &cbuf, address mark = NULL);
10168 a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub dlong parents: 6725 diff changeset	323 static int to_interp_stub_size();
a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub dlong parents: 6725 diff changeset	324 static int reloc_to_interp_stub();
a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub dlong parents: 6725 diff changeset	325
0 a61af66fc99e Initial load duke parents: diff changeset	326 // State
a61af66fc99e Initial load duke parents: diff changeset	327 bool is_clean() const;
a61af66fc99e Initial load duke parents: diff changeset	328 bool is_call_to_compiled() const;
a61af66fc99e Initial load duke parents: diff changeset	329 bool is_call_to_interpreted() const;
a61af66fc99e Initial load duke parents: diff changeset	330
a61af66fc99e Initial load duke parents: diff changeset	331 // Clean static call (will force resolving on next use)
a61af66fc99e Initial load duke parents: diff changeset	332 void set_to_clean();
a61af66fc99e Initial load duke parents: diff changeset	333
a61af66fc99e Initial load duke parents: diff changeset	334 // Set state. The entry must be the same, as computed by compute_entry.
a61af66fc99e Initial load duke parents: diff changeset	335 // Computation and setting is split up, since the actions are separate during
a61af66fc99e Initial load duke parents: diff changeset	336 // a OptoRuntime::resolve_xxx.
a61af66fc99e Initial load duke parents: diff changeset	337 void set(const StaticCallInfo& info);
a61af66fc99e Initial load duke parents: diff changeset	338
a61af66fc99e Initial load duke parents: diff changeset	339 // Compute entry point given a method
a61af66fc99e Initial load duke parents: diff changeset	340 static void compute_entry(methodHandle m, StaticCallInfo& info);
a61af66fc99e Initial load duke parents: diff changeset	341
a61af66fc99e Initial load duke parents: diff changeset	342 // Stub support
a61af66fc99e Initial load duke parents: diff changeset	343 address find_stub();
a61af66fc99e Initial load duke parents: diff changeset	344 static void set_stub_to_clean(static_stub_Relocation* static_stub);
a61af66fc99e Initial load duke parents: diff changeset	345
a61af66fc99e Initial load duke parents: diff changeset	346 // Misc.
a61af66fc99e Initial load duke parents: diff changeset	347 void print() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	348 void verify() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	349 };
a61af66fc99e Initial load duke parents: diff changeset	350
a61af66fc99e Initial load duke parents: diff changeset	351
a61af66fc99e Initial load duke parents: diff changeset	352 inline CompiledStaticCall* compiledStaticCall_before(address return_addr) {
a61af66fc99e Initial load duke parents: diff changeset	353 CompiledStaticCall* st = (CompiledStaticCall*)nativeCall_before(return_addr);
a61af66fc99e Initial load duke parents: diff changeset	354 st->verify();
a61af66fc99e Initial load duke parents: diff changeset	355 return st;
a61af66fc99e Initial load duke parents: diff changeset	356 }
a61af66fc99e Initial load duke parents: diff changeset	357
a61af66fc99e Initial load duke parents: diff changeset	358 inline CompiledStaticCall* compiledStaticCall_at(address native_call) {
a61af66fc99e Initial load duke parents: diff changeset	359 CompiledStaticCall* st = (CompiledStaticCall*)native_call;
a61af66fc99e Initial load duke parents: diff changeset	360 st->verify();
a61af66fc99e Initial load duke parents: diff changeset	361 return st;
a61af66fc99e Initial load duke parents: diff changeset	362 }
a61af66fc99e Initial load duke parents: diff changeset	363
a61af66fc99e Initial load duke parents: diff changeset	364 inline CompiledStaticCall* compiledStaticCall_at(Relocation* call_site) {
a61af66fc99e Initial load duke parents: diff changeset	365 return compiledStaticCall_at(call_site->addr());
a61af66fc99e Initial load duke parents: diff changeset	366 }
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	367
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	368 #endif // SHARE_VM_CODE_COMPILEDIC_HPP

Mercurial > hg > truffle

annotate src/share/vm/code/compiledIC.hpp @ 21205:f34ae5c01864