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

annotate src/share/vm/code/compiledIC.hpp @ 12294:891687731b59

7009641: Don't fail VM when CodeCache is full Summary: Allocation in the code cache returns NULL instead of failing the entire VM Reviewed-by: kvn, iveresov

author	anoll
date	Tue, 24 Sep 2013 15:56:25 +0200
parents	a6e09d6dd8e5
children	de6a9e811145

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	2 * Copyright (c) 1997, 2012, 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);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	153
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	154 static bool is_icholder_entry(address entry);
0 a61af66fc99e Initial load duke parents: diff changeset	155
a61af66fc99e Initial load duke parents: diff changeset	156 // low-level inline-cache manipulation. Cannot be accessed directly, since it might not be MT-safe
a61af66fc99e Initial load duke parents: diff changeset	157 // to change an inline-cache. These changes the underlying inline-cache directly. They newer make
a61af66fc99e Initial load duke parents: diff changeset	158 // changes to a transition stub.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	159 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	160 void set_ic_destination(ICStub* stub);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	161 void set_ic_destination(address entry_point) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	162 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	163 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	164 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	165 // 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	166 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	167 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	168 }
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, Metadata* 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, false);
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, CompiledICHolder* 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, true);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	174 }
0 a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 // 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	177 // associated with the inline cache.
a61af66fc99e Initial load duke parents: diff changeset	178 address stub_address() const;
a61af66fc99e Initial load duke parents: diff changeset	179 bool is_in_transition_state() const; // Use InlineCacheBuffer
a61af66fc99e Initial load duke parents: diff changeset	180
a61af66fc99e Initial load duke parents: diff changeset	181 public:
a61af66fc99e Initial load duke parents: diff changeset	182 // conversion (machine PC to CompiledIC*)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	183 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	184 friend CompiledIC* CompiledIC_at(nmethod* nm, address call_site);
0 a61af66fc99e Initial load duke parents: diff changeset	185 friend CompiledIC* CompiledIC_at(Relocation* call_site);
a61af66fc99e Initial load duke parents: diff changeset	186
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	187 // 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	188 // 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	189 // 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	190 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	191 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	192
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	193 // Return the cached_metadata/destination associated with this inline cache. If the cache currently points
0 a61af66fc99e Initial load duke parents: diff changeset	194 // 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	195 void* cached_value() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	196 CompiledICHolder* cached_icholder() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	197 assert(is_icholder_call(), "must be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	198 return (CompiledICHolder*) cached_value();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	199 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	200 Metadata* cached_metadata() 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 (Metadata*) 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
0 a61af66fc99e Initial load duke parents: diff changeset	205 address ic_destination() const;
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 bool is_optimized() const { return _is_optimized; }
a61af66fc99e Initial load duke parents: diff changeset	208
a61af66fc99e Initial load duke parents: diff changeset	209 // State
a61af66fc99e Initial load duke parents: diff changeset	210 bool is_clean() const;
a61af66fc99e Initial load duke parents: diff changeset	211 bool is_megamorphic() const;
a61af66fc99e Initial load duke parents: diff changeset	212 bool is_call_to_compiled() const;
a61af66fc99e Initial load duke parents: diff changeset	213 bool is_call_to_interpreted() const;
a61af66fc99e Initial load duke parents: diff changeset	214
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	215 bool is_icholder_call() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	216
0 a61af66fc99e Initial load duke parents: diff changeset	217 address end_of_call() { return _ic_call->return_address(); }
a61af66fc99e Initial load duke parents: diff changeset	218
a61af66fc99e Initial load duke parents: diff changeset	219 // 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	220 // so you are guaranteed that no patching takes place. The same goes for verify.
a61af66fc99e Initial load duke parents: diff changeset	221 //
a61af66fc99e Initial load duke parents: diff changeset	222 // 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	223 // to manipulate the inline cache in MT-unsafe ways.
a61af66fc99e Initial load duke parents: diff changeset	224 //
a61af66fc99e Initial load duke parents: diff changeset	225 // 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	226 //
a61af66fc99e Initial load duke parents: diff changeset	227 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	228 void set_to_monomorphic(CompiledICInfo& info);
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 10168 diff changeset	229
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 10168 diff changeset	230 // 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	231 // allocation in the code cache fails.
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 10168 diff changeset	232 bool set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	233
a61af66fc99e Initial load duke parents: diff changeset	234 static void compute_monomorphic_entry(methodHandle method, KlassHandle receiver_klass,
a61af66fc99e Initial load duke parents: diff changeset	235 bool is_optimized, bool static_bound, CompiledICInfo& info, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	236
a61af66fc99e Initial load duke parents: diff changeset	237 // Location
a61af66fc99e Initial load duke parents: diff changeset	238 address instruction_address() const { return _ic_call->instruction_address(); }
a61af66fc99e Initial load duke parents: diff changeset	239
a61af66fc99e Initial load duke parents: diff changeset	240 // Misc
a61af66fc99e Initial load duke parents: diff changeset	241 void print() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	242 void print_compiled_ic() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	243 void verify() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	244 };
a61af66fc99e Initial load duke parents: diff changeset	245
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	246 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	247 CompiledIC* c_ic = new CompiledIC(nm, nativeCall_before(return_addr));
0 a61af66fc99e Initial load duke parents: diff changeset	248 c_ic->verify();
a61af66fc99e Initial load duke parents: diff changeset	249 return c_ic;
a61af66fc99e Initial load duke parents: diff changeset	250 }
a61af66fc99e Initial load duke parents: diff changeset	251
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	252 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	253 CompiledIC* c_ic = new CompiledIC(nm, nativeCall_at(call_site));
0 a61af66fc99e Initial load duke parents: diff changeset	254 c_ic->verify();
a61af66fc99e Initial load duke parents: diff changeset	255 return c_ic;
a61af66fc99e Initial load duke parents: diff changeset	256 }
a61af66fc99e Initial load duke parents: diff changeset	257
a61af66fc99e Initial load duke parents: diff changeset	258 inline CompiledIC* CompiledIC_at(Relocation* call_site) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	259 assert(call_site->type() == relocInfo::virtual_call_type \|\|
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	260 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	261 CompiledIC* c_ic = new CompiledIC(call_site->code(), nativeCall_at(call_site->addr()));
0 a61af66fc99e Initial load duke parents: diff changeset	262 c_ic->verify();
a61af66fc99e Initial load duke parents: diff changeset	263 return c_ic;
a61af66fc99e Initial load duke parents: diff changeset	264 }
a61af66fc99e Initial load duke parents: diff changeset	265
a61af66fc99e Initial load duke parents: diff changeset	266
a61af66fc99e Initial load duke parents: diff changeset	267 //-----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	268 // The CompiledStaticCall represents a call to a static method in the compiled
a61af66fc99e Initial load duke parents: diff changeset	269 //
a61af66fc99e Initial load duke parents: diff changeset	270 // Transition diagram of a static call site is somewhat simpler than for an inlined cache:
a61af66fc99e Initial load duke parents: diff changeset	271 //
a61af66fc99e Initial load duke parents: diff changeset	272 //
a61af66fc99e Initial load duke parents: diff changeset	273 // -----<----- Clean ----->-----
a61af66fc99e Initial load duke parents: diff changeset	274 // / \
a61af66fc99e Initial load duke parents: diff changeset	275 // / \
a61af66fc99e Initial load duke parents: diff changeset	276 // compilled code <------------> interpreted code
a61af66fc99e Initial load duke parents: diff changeset	277 //
a61af66fc99e Initial load duke parents: diff changeset	278 // Clean: Calls directly to runtime method for fixup
a61af66fc99e Initial load duke parents: diff changeset	279 // Compiled code: Calls directly to compiled code
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2426 diff changeset	280 // Interpreted code: Calls to stub that set Method* reference
0 a61af66fc99e Initial load duke parents: diff changeset	281 //
a61af66fc99e Initial load duke parents: diff changeset	282 //
a61af66fc99e Initial load duke parents: diff changeset	283 class CompiledStaticCall;
a61af66fc99e Initial load duke parents: diff changeset	284
a61af66fc99e Initial load duke parents: diff changeset	285 class StaticCallInfo {
a61af66fc99e Initial load duke parents: diff changeset	286 private:
a61af66fc99e Initial load duke parents: diff changeset	287 address _entry; // Entrypoint
a61af66fc99e Initial load duke parents: diff changeset	288 methodHandle _callee; // Callee (used when calling interpreter)
a61af66fc99e Initial load duke parents: diff changeset	289 bool _to_interpreter; // call to interpreted method (otherwise compiled)
a61af66fc99e Initial load duke parents: diff changeset	290
a61af66fc99e Initial load duke parents: diff changeset	291 friend class CompiledStaticCall;
a61af66fc99e Initial load duke parents: diff changeset	292 public:
a61af66fc99e Initial load duke parents: diff changeset	293 address entry() const { return _entry; }
a61af66fc99e Initial load duke parents: diff changeset	294 methodHandle callee() const { return _callee; }
a61af66fc99e Initial load duke parents: diff changeset	295 };
a61af66fc99e Initial load duke parents: diff changeset	296
a61af66fc99e Initial load duke parents: diff changeset	297
a61af66fc99e Initial load duke parents: diff changeset	298 class CompiledStaticCall: public NativeCall {
a61af66fc99e Initial load duke parents: diff changeset	299 friend class CompiledIC;
a61af66fc99e Initial load duke parents: diff changeset	300
a61af66fc99e Initial load duke parents: diff changeset	301 // Also used by CompiledIC
a61af66fc99e Initial load duke parents: diff changeset	302 void set_to_interpreted(methodHandle callee, address entry);
a61af66fc99e Initial load duke parents: diff changeset	303 bool is_optimized_virtual();
a61af66fc99e Initial load duke parents: diff changeset	304
a61af66fc99e Initial load duke parents: diff changeset	305 public:
a61af66fc99e Initial load duke parents: diff changeset	306 friend CompiledStaticCall* compiledStaticCall_before(address return_addr);
a61af66fc99e Initial load duke parents: diff changeset	307 friend CompiledStaticCall* compiledStaticCall_at(address native_call);
a61af66fc99e Initial load duke parents: diff changeset	308 friend CompiledStaticCall* compiledStaticCall_at(Relocation* call_site);
a61af66fc99e Initial load duke parents: diff changeset	309
10168 a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub dlong parents: 6725 diff changeset	310 // Code
a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub dlong parents: 6725 diff changeset	311 static void emit_to_interp_stub(CodeBuffer &cbuf);
a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub dlong parents: 6725 diff changeset	312 static int to_interp_stub_size();
a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub dlong parents: 6725 diff changeset	313 static int reloc_to_interp_stub();
a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub dlong parents: 6725 diff changeset	314
0 a61af66fc99e Initial load duke parents: diff changeset	315 // State
a61af66fc99e Initial load duke parents: diff changeset	316 bool is_clean() const;
a61af66fc99e Initial load duke parents: diff changeset	317 bool is_call_to_compiled() const;
a61af66fc99e Initial load duke parents: diff changeset	318 bool is_call_to_interpreted() const;
a61af66fc99e Initial load duke parents: diff changeset	319
a61af66fc99e Initial load duke parents: diff changeset	320 // Clean static call (will force resolving on next use)
a61af66fc99e Initial load duke parents: diff changeset	321 void set_to_clean();
a61af66fc99e Initial load duke parents: diff changeset	322
a61af66fc99e Initial load duke parents: diff changeset	323 // Set state. The entry must be the same, as computed by compute_entry.
a61af66fc99e Initial load duke parents: diff changeset	324 // Computation and setting is split up, since the actions are separate during
a61af66fc99e Initial load duke parents: diff changeset	325 // a OptoRuntime::resolve_xxx.
a61af66fc99e Initial load duke parents: diff changeset	326 void set(const StaticCallInfo& info);
a61af66fc99e Initial load duke parents: diff changeset	327
a61af66fc99e Initial load duke parents: diff changeset	328 // Compute entry point given a method
a61af66fc99e Initial load duke parents: diff changeset	329 static void compute_entry(methodHandle m, StaticCallInfo& info);
a61af66fc99e Initial load duke parents: diff changeset	330
a61af66fc99e Initial load duke parents: diff changeset	331 // Stub support
a61af66fc99e Initial load duke parents: diff changeset	332 address find_stub();
a61af66fc99e Initial load duke parents: diff changeset	333 static void set_stub_to_clean(static_stub_Relocation* static_stub);
a61af66fc99e Initial load duke parents: diff changeset	334
a61af66fc99e Initial load duke parents: diff changeset	335 // Misc.
a61af66fc99e Initial load duke parents: diff changeset	336 void print() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	337 void verify() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	338 };
a61af66fc99e Initial load duke parents: diff changeset	339
a61af66fc99e Initial load duke parents: diff changeset	340
a61af66fc99e Initial load duke parents: diff changeset	341 inline CompiledStaticCall* compiledStaticCall_before(address return_addr) {
a61af66fc99e Initial load duke parents: diff changeset	342 CompiledStaticCall* st = (CompiledStaticCall*)nativeCall_before(return_addr);
a61af66fc99e Initial load duke parents: diff changeset	343 st->verify();
a61af66fc99e Initial load duke parents: diff changeset	344 return st;
a61af66fc99e Initial load duke parents: diff changeset	345 }
a61af66fc99e Initial load duke parents: diff changeset	346
a61af66fc99e Initial load duke parents: diff changeset	347 inline CompiledStaticCall* compiledStaticCall_at(address native_call) {
a61af66fc99e Initial load duke parents: diff changeset	348 CompiledStaticCall* st = (CompiledStaticCall*)native_call;
a61af66fc99e Initial load duke parents: diff changeset	349 st->verify();
a61af66fc99e Initial load duke parents: diff changeset	350 return st;
a61af66fc99e Initial load duke parents: diff changeset	351 }
a61af66fc99e Initial load duke parents: diff changeset	352
a61af66fc99e Initial load duke parents: diff changeset	353 inline CompiledStaticCall* compiledStaticCall_at(Relocation* call_site) {
a61af66fc99e Initial load duke parents: diff changeset	354 return compiledStaticCall_at(call_site->addr());
a61af66fc99e Initial load duke parents: diff changeset	355 }
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	356
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	357 #endif // SHARE_VM_CODE_COMPILEDIC_HPP

Mercurial > hg > truffle

annotate src/share/vm/code/compiledIC.hpp @ 12294:891687731b59