truffle: src/share/vm/runtime/deoptimization.hpp annotate

annotate src/share/vm/runtime/deoptimization.hpp @ 9126:bc26f978b0ce

HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly don't use the (wrong) cached value, but ask the runtime on each request. Fixes regression on xml.* benchmarks @ specjvm2008. The problem was: After the constructor of Object was deoptimized due to an assumption violation, it was recompiled again after some time. However, on recompilation, the value of hasFinalizeSubclass for the class was not updated and it was compiled again with a, now wrong, assumption, which then triggers deoptimization again. This was repeated until it hit the recompilation limit (defined by PerMethodRecompilationCutoff), and therefore only executed by the interpreter from now on, causing the performance regression.

author	Bernhard Urban <bernhard.urban@jku.at>
date	Mon, 15 Apr 2013 19:54:58 +0200
parents	d343737786fe
children	359f7e70ae7f

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: 6197 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: 1206 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1206 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: 1206 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: 1905 diff changeset	25 #ifndef SHARE_VM_RUNTIME_DEOPTIMIZATION_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	26 #define SHARE_VM_RUNTIME_DEOPTIMIZATION_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	28 #include "memory/allocation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	29 #include "runtime/frame.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	30
0 a61af66fc99e Initial load duke parents: diff changeset	31 class ProfileData;
a61af66fc99e Initial load duke parents: diff changeset	32 class vframeArray;
a61af66fc99e Initial load duke parents: diff changeset	33 class MonitorValue;
a61af66fc99e Initial load duke parents: diff changeset	34 class ObjectValue;
a61af66fc99e Initial load duke parents: diff changeset	35
a61af66fc99e Initial load duke parents: diff changeset	36 class Deoptimization : AllStatic {
3939 f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3931 diff changeset	37 friend class VMStructs;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3931 diff changeset	38
0 a61af66fc99e Initial load duke parents: diff changeset	39 public:
8151 b8f261ba79c6 Minimize diff to plain HotSpot version. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 7154 diff changeset	40 // What condition caused the deoptimization?
0 a61af66fc99e Initial load duke parents: diff changeset	41 enum DeoptReason {
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	42 Reason_many = -1, // indicates presence of several reasons
0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	43 Reason_none = 0, // indicates absence of a relevant deopt.
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	44 // Next 7 reasons are recorded per bytecode in DataLayout::trap_bits.
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	45 // This is more complicated for Graal as Graal may deoptimize to some bytecode before the
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	46 // bytecode that actually caused the deopt (with inlining, Graal may even deoptimize to a
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	47 // bytecode in another method):
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	48 // - bytecode y in method b() causes deopt
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	49 // - Graal deoptimizes to bytecode x in method a()
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	50 // -> the deopt reason will be recorded for method a() at bytecode x
0 a61af66fc99e Initial load duke parents: diff changeset	51 Reason_null_check, // saw unexpected null or zero divisor (@bci)
a61af66fc99e Initial load duke parents: diff changeset	52 Reason_null_assert, // saw unexpected non-null or non-zero (@bci)
a61af66fc99e Initial load duke parents: diff changeset	53 Reason_range_check, // saw unexpected array index (@bci)
a61af66fc99e Initial load duke parents: diff changeset	54 Reason_class_check, // saw unexpected object class (@bci)
a61af66fc99e Initial load duke parents: diff changeset	55 Reason_array_check, // saw unexpected array class (aastore @bci)
a61af66fc99e Initial load duke parents: diff changeset	56 Reason_intrinsic, // saw unexpected operand to intrinsic (@bci)
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1172 diff changeset	57 Reason_bimorphic, // saw unexpected object class in bimorphic inlining (@bci)
87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1172 diff changeset	58
7154 5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	59 #ifdef GRAAL
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	60 Reason_unreached0 = Reason_null_assert,
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	61 Reason_type_checked_inlining = Reason_intrinsic,
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	62 Reason_optimized_type_check = Reason_bimorphic,
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	63 #endif
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	64
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	65 // recorded per method
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	66 Reason_unloaded, // unloaded or class constant pool entry
0 a61af66fc99e Initial load duke parents: diff changeset	67 Reason_uninitialized, // bad class state (uninitialized)
a61af66fc99e Initial load duke parents: diff changeset	68 Reason_unreached, // code is not reached, compiler
a61af66fc99e Initial load duke parents: diff changeset	69 Reason_unhandled, // arbitrary compiler limitation
a61af66fc99e Initial load duke parents: diff changeset	70 Reason_constraint, // arbitrary runtime constraint violated
a61af66fc99e Initial load duke parents: diff changeset	71 Reason_div0_check, // a null_check due to division by zero
a61af66fc99e Initial load duke parents: diff changeset	72 Reason_age, // nmethod too old; tier threshold reached
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 196 diff changeset	73 Reason_predicate, // compiler generated predicate failed
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	74 Reason_loop_limit_check, // compiler generated loop limits check failed
0 a61af66fc99e Initial load duke parents: diff changeset	75 Reason_LIMIT,
7154 5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	76
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	77 #ifdef GRAAL
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	78 Reason_not_compiled_exception_handler = Reason_unhandled,
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	79 Reason_unresolved = Reason_uninitialized,
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	80 Reason_jsr_mismatch = Reason_age,
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	81 #endif
5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	82
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1172 diff changeset	83 Reason_RECORDED_LIMIT = Reason_bimorphic // some are not recorded per bc
0 a61af66fc99e Initial load duke parents: diff changeset	84 // Note: Keep this enum in sync. with _trap_reason_name.
a61af66fc99e Initial load duke parents: diff changeset	85 // Note: Reason_RECORDED_LIMIT should be < 8 to fit into 3 bits of
a61af66fc99e Initial load duke parents: diff changeset	86 // DataLayout::trap_bits. This dependency is enforced indirectly
a61af66fc99e Initial load duke parents: diff changeset	87 // via asserts, to avoid excessive direct header-to-header dependencies.
8151 b8f261ba79c6 Minimize diff to plain HotSpot version. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 7154 diff changeset	88 // See Deoptimization::trap_state_reason and class DataLayout.
0 a61af66fc99e Initial load duke parents: diff changeset	89 };
a61af66fc99e Initial load duke parents: diff changeset	90
a61af66fc99e Initial load duke parents: diff changeset	91 // What action must be taken by the runtime?
a61af66fc99e Initial load duke parents: diff changeset	92 enum DeoptAction {
a61af66fc99e Initial load duke parents: diff changeset	93 Action_none, // just interpret, do not invalidate nmethod
a61af66fc99e Initial load duke parents: diff changeset	94 Action_maybe_recompile, // recompile the nmethod; need not invalidate
a61af66fc99e Initial load duke parents: diff changeset	95 Action_reinterpret, // invalidate the nmethod, reset IC, maybe recompile
a61af66fc99e Initial load duke parents: diff changeset	96 Action_make_not_entrant, // invalidate the nmethod, recompile (probably)
a61af66fc99e Initial load duke parents: diff changeset	97 Action_make_not_compilable, // invalidate the nmethod and do not compile
a61af66fc99e Initial load duke parents: diff changeset	98 Action_LIMIT
a61af66fc99e Initial load duke parents: diff changeset	99 // Note: Keep this enum in sync. with _trap_action_name.
a61af66fc99e Initial load duke parents: diff changeset	100 };
a61af66fc99e Initial load duke parents: diff changeset	101
a61af66fc99e Initial load duke parents: diff changeset	102 enum {
a61af66fc99e Initial load duke parents: diff changeset	103 _action_bits = 3,
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2426 diff changeset	104 _reason_bits = 5,
0 a61af66fc99e Initial load duke parents: diff changeset	105 _action_shift = 0,
a61af66fc99e Initial load duke parents: diff changeset	106 _reason_shift = _action_shift+_action_bits,
a61af66fc99e Initial load duke parents: diff changeset	107 BC_CASE_LIMIT = PRODUCT_ONLY(1) NOT_PRODUCT(4) // for _deoptimization_hist
a61af66fc99e Initial load duke parents: diff changeset	108 };
a61af66fc99e Initial load duke parents: diff changeset	109
a61af66fc99e Initial load duke parents: diff changeset	110 enum UnpackType {
a61af66fc99e Initial load duke parents: diff changeset	111 Unpack_deopt = 0, // normal deoptimization, use pc computed in unpack_vframe_on_stack
a61af66fc99e Initial load duke parents: diff changeset	112 Unpack_exception = 1, // exception is pending
a61af66fc99e Initial load duke parents: diff changeset	113 Unpack_uncommon_trap = 2, // redo last byte code (C2 only)
a61af66fc99e Initial load duke parents: diff changeset	114 Unpack_reexecute = 3 // reexecute bytecode (C1 only)
a61af66fc99e Initial load duke parents: diff changeset	115 };
a61af66fc99e Initial load duke parents: diff changeset	116
a61af66fc99e Initial load duke parents: diff changeset	117 // Checks all compiled methods. Invalid methods are deleted and
a61af66fc99e Initial load duke parents: diff changeset	118 // corresponding activations are deoptimized.
a61af66fc99e Initial load duke parents: diff changeset	119 static int deoptimize_dependents();
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121 // Deoptimizes a frame lazily. nmethod gets patched deopt happens on return to the frame
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	122 static void deoptimize(JavaThread* thread, frame fr, RegisterMap *reg_map, DeoptReason reason);
0 a61af66fc99e Initial load duke parents: diff changeset	123
a61af66fc99e Initial load duke parents: diff changeset	124 private:
a61af66fc99e Initial load duke parents: diff changeset	125 // Does the actual work for deoptimizing a single frame
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	126 static void deoptimize_single_frame(JavaThread* thread, frame fr, DeoptReason reason);
0 a61af66fc99e Initial load duke parents: diff changeset	127
a61af66fc99e Initial load duke parents: diff changeset	128 // Helper function to revoke biases of all monitors in frame if UseBiasedLocking
a61af66fc99e Initial load duke parents: diff changeset	129 // is enabled
a61af66fc99e Initial load duke parents: diff changeset	130 static void revoke_biases_of_monitors(JavaThread* thread, frame fr, RegisterMap* map);
a61af66fc99e Initial load duke parents: diff changeset	131 // Helper function to revoke biases of all monitors in frames
a61af66fc99e Initial load duke parents: diff changeset	132 // executing in a particular CodeBlob if UseBiasedLocking is enabled
a61af66fc99e Initial load duke parents: diff changeset	133 static void revoke_biases_of_monitors(CodeBlob* cb);
a61af66fc99e Initial load duke parents: diff changeset	134
8151 b8f261ba79c6 Minimize diff to plain HotSpot version. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 7154 diff changeset	135 #if defined(COMPILER2) \|\| defined(GRAAL)
0 a61af66fc99e Initial load duke parents: diff changeset	136 // Support for restoring non-escaping objects
a61af66fc99e Initial load duke parents: diff changeset	137 static bool realloc_objects(JavaThread* thread, frame* fr, GrowableArray<ScopeValue> objects, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	138 static void reassign_type_array_elements(frame* fr, RegisterMap* reg_map, ObjectValue* sv, typeArrayOop obj, BasicType type);
a61af66fc99e Initial load duke parents: diff changeset	139 static void reassign_object_array_elements(frame* fr, RegisterMap* reg_map, ObjectValue* sv, objArrayOop obj);
a61af66fc99e Initial load duke parents: diff changeset	140 static void reassign_fields(frame* fr, RegisterMap* reg_map, GrowableArray<ScopeValue> objects);
83 d3cd40645d0d 6681646: Relocking of a scalar replaced object during deoptimization is broken kvn parents: 0 diff changeset	141 static void relock_objects(GrowableArray<MonitorInfo> monitors, JavaThread* thread);
0 a61af66fc99e Initial load duke parents: diff changeset	142 NOT_PRODUCT(static void print_objects(GrowableArray<ScopeValue> objects);)
8151 b8f261ba79c6 Minimize diff to plain HotSpot version. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 7154 diff changeset	143 #endif // COMPILER2 \|\| GRAAL
0 a61af66fc99e Initial load duke parents: diff changeset	144
a61af66fc99e Initial load duke parents: diff changeset	145 public:
a61af66fc99e Initial load duke parents: diff changeset	146 static vframeArray* create_vframeArray(JavaThread* thread, frame fr, RegisterMap reg_map, GrowableArray<compiledVFrame>* chunk);
a61af66fc99e Initial load duke parents: diff changeset	147
a61af66fc99e Initial load duke parents: diff changeset	148 // Interface used for unpacking deoptimized frames
a61af66fc99e Initial load duke parents: diff changeset	149
a61af66fc99e Initial load duke parents: diff changeset	150 // UnrollBlock is returned by fetch_unroll_info() to the deoptimization handler (blob).
a61af66fc99e Initial load duke parents: diff changeset	151 // This is only a CheapObj to ease debugging after a deopt failure
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	152 class UnrollBlock : public CHeapObj<mtCompiler> {
0 a61af66fc99e Initial load duke parents: diff changeset	153 private:
a61af66fc99e Initial load duke parents: diff changeset	154 int _size_of_deoptimized_frame; // Size, in bytes, of current deoptimized frame
a61af66fc99e Initial load duke parents: diff changeset	155 int _caller_adjustment; // Adjustment, in bytes, to caller's SP by initial interpreted frame
a61af66fc99e Initial load duke parents: diff changeset	156 int _number_of_frames; // Number frames to unroll
a61af66fc99e Initial load duke parents: diff changeset	157 int _total_frame_sizes; // Total of number*sizes frames
a61af66fc99e Initial load duke parents: diff changeset	158 intptr_t* _frame_sizes; // Array of frame sizes, in bytes, for unrolling the stack
a61af66fc99e Initial load duke parents: diff changeset	159 address* _frame_pcs; // Array of frame pc's, in bytes, for unrolling the stack
a61af66fc99e Initial load duke parents: diff changeset	160 intptr_t* _register_block; // Block for storing callee-saved registers.
a61af66fc99e Initial load duke parents: diff changeset	161 BasicType _return_type; // Tells if we have to restore double or long return value
3931 5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3369 diff changeset	162 intptr_t _initial_info; // Platform dependent data for the sender frame (was FP on x86)
3369 3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3345 diff changeset	163 int _caller_actual_parameters; // The number of actual arguments at the
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3345 diff changeset	164 // interpreted caller of the deoptimized frame
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3345 diff changeset	165
0 a61af66fc99e Initial load duke parents: diff changeset	166 // The following fields are used as temps during the unpacking phase
a61af66fc99e Initial load duke parents: diff changeset	167 // (which is tight on registers, especially on x86). They really ought
a61af66fc99e Initial load duke parents: diff changeset	168 // to be PD variables but that involves moving this class into its own
a61af66fc99e Initial load duke parents: diff changeset	169 // file to use the pd include mechanism. Maybe in a later cleanup ...
a61af66fc99e Initial load duke parents: diff changeset	170 intptr_t _counter_temp; // SHOULD BE PD VARIABLE (x86 frame count temp)
a61af66fc99e Initial load duke parents: diff changeset	171 intptr_t _unpack_kind; // SHOULD BE PD VARIABLE (x86 unpack kind)
a61af66fc99e Initial load duke parents: diff changeset	172 intptr_t _sender_sp_temp; // SHOULD BE PD VARIABLE (x86 sender_sp)
a61af66fc99e Initial load duke parents: diff changeset	173 public:
a61af66fc99e Initial load duke parents: diff changeset	174 // Constructor
a61af66fc99e Initial load duke parents: diff changeset	175 UnrollBlock(int size_of_deoptimized_frame,
a61af66fc99e Initial load duke parents: diff changeset	176 int caller_adjustment,
3369 3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3345 diff changeset	177 int caller_actual_parameters,
0 a61af66fc99e Initial load duke parents: diff changeset	178 int number_of_frames,
a61af66fc99e Initial load duke parents: diff changeset	179 intptr_t* frame_sizes,
a61af66fc99e Initial load duke parents: diff changeset	180 address* frames_pcs,
a61af66fc99e Initial load duke parents: diff changeset	181 BasicType return_type);
a61af66fc99e Initial load duke parents: diff changeset	182 ~UnrollBlock();
a61af66fc99e Initial load duke parents: diff changeset	183
a61af66fc99e Initial load duke parents: diff changeset	184 // Returns where a register is located.
a61af66fc99e Initial load duke parents: diff changeset	185 intptr_t* value_addr_at(int register_number) const;
a61af66fc99e Initial load duke parents: diff changeset	186
a61af66fc99e Initial load duke parents: diff changeset	187 // Accessors
a61af66fc99e Initial load duke parents: diff changeset	188 intptr_t* frame_sizes() const { return _frame_sizes; }
a61af66fc99e Initial load duke parents: diff changeset	189 int number_of_frames() const { return _number_of_frames; }
a61af66fc99e Initial load duke parents: diff changeset	190 address* frame_pcs() const { return _frame_pcs ; }
a61af66fc99e Initial load duke parents: diff changeset	191
a61af66fc99e Initial load duke parents: diff changeset	192 // Returns the total size of frames
a61af66fc99e Initial load duke parents: diff changeset	193 int size_of_frames() const;
a61af66fc99e Initial load duke parents: diff changeset	194
3931 5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3369 diff changeset	195 void set_initial_info(intptr_t info) { _initial_info = info; }
2338 4f148718983e 7025485: leverage shared x86-only deoptimization code bdelsart parents: 1972 diff changeset	196
3369 3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3345 diff changeset	197 int caller_actual_parameters() const { return _caller_actual_parameters; }
3d2ab563047a 7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method never parents: 3345 diff changeset	198
0 a61af66fc99e Initial load duke parents: diff changeset	199 // Accessors used by the code generator for the unpack stub.
a61af66fc99e Initial load duke parents: diff changeset	200 static int size_of_deoptimized_frame_offset_in_bytes() { return offset_of(UnrollBlock, _size_of_deoptimized_frame); }
a61af66fc99e Initial load duke parents: diff changeset	201 static int caller_adjustment_offset_in_bytes() { return offset_of(UnrollBlock, _caller_adjustment); }
a61af66fc99e Initial load duke parents: diff changeset	202 static int number_of_frames_offset_in_bytes() { return offset_of(UnrollBlock, _number_of_frames); }
a61af66fc99e Initial load duke parents: diff changeset	203 static int frame_sizes_offset_in_bytes() { return offset_of(UnrollBlock, _frame_sizes); }
a61af66fc99e Initial load duke parents: diff changeset	204 static int total_frame_sizes_offset_in_bytes() { return offset_of(UnrollBlock, _total_frame_sizes); }
a61af66fc99e Initial load duke parents: diff changeset	205 static int frame_pcs_offset_in_bytes() { return offset_of(UnrollBlock, _frame_pcs); }
a61af66fc99e Initial load duke parents: diff changeset	206 static int register_block_offset_in_bytes() { return offset_of(UnrollBlock, _register_block); }
a61af66fc99e Initial load duke parents: diff changeset	207 static int return_type_offset_in_bytes() { return offset_of(UnrollBlock, _return_type); }
a61af66fc99e Initial load duke parents: diff changeset	208 static int counter_temp_offset_in_bytes() { return offset_of(UnrollBlock, _counter_temp); }
3931 5432047c7db7 7087445: Improve platform independence of JSR292 shared code bdelsart parents: 3369 diff changeset	209 static int initial_info_offset_in_bytes() { return offset_of(UnrollBlock, _initial_info); }
0 a61af66fc99e Initial load duke parents: diff changeset	210 static int unpack_kind_offset_in_bytes() { return offset_of(UnrollBlock, _unpack_kind); }
a61af66fc99e Initial load duke parents: diff changeset	211 static int sender_sp_temp_offset_in_bytes() { return offset_of(UnrollBlock, _sender_sp_temp); }
a61af66fc99e Initial load duke parents: diff changeset	212
a61af66fc99e Initial load duke parents: diff changeset	213 BasicType return_type() const { return _return_type; }
a61af66fc99e Initial load duke parents: diff changeset	214 void print();
a61af66fc99e Initial load duke parents: diff changeset	215 };
a61af66fc99e Initial load duke parents: diff changeset	216
a61af66fc99e Initial load duke parents: diff changeset	217 //** Returns an UnrollBlock continuing information
a61af66fc99e Initial load duke parents: diff changeset	218 // how to make room for the resulting interpreter frames.
a61af66fc99e Initial load duke parents: diff changeset	219 // Called by assembly stub after execution has returned to
a61af66fc99e Initial load duke parents: diff changeset	220 // deoptimized frame.
a61af66fc99e Initial load duke parents: diff changeset	221 // @argument thread. Thread where stub_frame resides.
a61af66fc99e Initial load duke parents: diff changeset	222 // @see OptoRuntime::deoptimization_fetch_unroll_info_C
a61af66fc99e Initial load duke parents: diff changeset	223 static UnrollBlock* fetch_unroll_info(JavaThread* thread);
a61af66fc99e Initial load duke parents: diff changeset	224
a61af66fc99e Initial load duke parents: diff changeset	225 //** Unpacks vframeArray onto execution stack
a61af66fc99e Initial load duke parents: diff changeset	226 // Called by assembly stub after execution has returned to
a61af66fc99e Initial load duke parents: diff changeset	227 // deoptimized frame and after the stack unrolling.
a61af66fc99e Initial load duke parents: diff changeset	228 // @argument thread. Thread where stub_frame resides.
a61af66fc99e Initial load duke parents: diff changeset	229 // @argument exec_mode. Determines how execution should be continuted in top frame.
a61af66fc99e Initial load duke parents: diff changeset	230 // 0 means continue after current byte code
a61af66fc99e Initial load duke parents: diff changeset	231 // 1 means exception has happened, handle exception
a61af66fc99e Initial load duke parents: diff changeset	232 // 2 means reexecute current bytecode (for uncommon traps).
a61af66fc99e Initial load duke parents: diff changeset	233 // @see OptoRuntime::deoptimization_unpack_frames_C
a61af66fc99e Initial load duke parents: diff changeset	234 // Return BasicType of call return type, if any
a61af66fc99e Initial load duke parents: diff changeset	235 static BasicType unpack_frames(JavaThread* thread, int exec_mode);
a61af66fc99e Initial load duke parents: diff changeset	236
a61af66fc99e Initial load duke parents: diff changeset	237 // Cleans up deoptimization bits on thread after unpacking or in the
a61af66fc99e Initial load duke parents: diff changeset	238 // case of an exception.
a61af66fc99e Initial load duke parents: diff changeset	239 static void cleanup_deopt_info(JavaThread *thread,
a61af66fc99e Initial load duke parents: diff changeset	240 vframeArray * array);
a61af66fc99e Initial load duke parents: diff changeset	241
a61af66fc99e Initial load duke parents: diff changeset	242 // Restores callee saved values from deoptimized frame into oldest interpreter frame
a61af66fc99e Initial load duke parents: diff changeset	243 // so caller of the deoptimized frame will get back the values it expects.
a61af66fc99e Initial load duke parents: diff changeset	244 static void unwind_callee_save_values(frame* f, vframeArray* vframe_array);
a61af66fc99e Initial load duke parents: diff changeset	245
a61af66fc99e Initial load duke parents: diff changeset	246 //** Performs an uncommon trap for compiled code.
a61af66fc99e Initial load duke parents: diff changeset	247 // The top most compiler frame is converted into interpreter frames
a61af66fc99e Initial load duke parents: diff changeset	248 static UnrollBlock* uncommon_trap(JavaThread* thread, jint unloaded_class_index);
a61af66fc99e Initial load duke parents: diff changeset	249 // Helper routine that enters the VM and may block
a61af66fc99e Initial load duke parents: diff changeset	250 static void uncommon_trap_inner(JavaThread* thread, jint unloaded_class_index);
a61af66fc99e Initial load duke parents: diff changeset	251
a61af66fc99e Initial load duke parents: diff changeset	252 //** Deoptimizes the frame identified by id.
a61af66fc99e Initial load duke parents: diff changeset	253 // Only called from VMDeoptimizeFrame
a61af66fc99e Initial load duke parents: diff changeset	254 // @argument thread. Thread where stub_frame resides.
a61af66fc99e Initial load duke parents: diff changeset	255 // @argument id. id of frame that should be deoptimized.
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	256 static void deoptimize_frame_internal(JavaThread* thread, intptr_t* id, DeoptReason reason);
1905 ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1783 diff changeset	257
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	258 // if thread is not the current thread then execute
1905 ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1783 diff changeset	259 // VM_DeoptimizeFrame otherwise deoptimize directly.
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	260 static void deoptimize_frame(JavaThread* thread, intptr_t* id, DeoptReason reason);
0 a61af66fc99e Initial load duke parents: diff changeset	261
a61af66fc99e Initial load duke parents: diff changeset	262 // Statistics
a61af66fc99e Initial load duke parents: diff changeset	263 static void gather_statistics(DeoptReason reason, DeoptAction action,
a61af66fc99e Initial load duke parents: diff changeset	264 Bytecodes::Code bc = Bytecodes::_illegal);
a61af66fc99e Initial load duke parents: diff changeset	265 static void print_statistics();
a61af66fc99e Initial load duke parents: diff changeset	266
a61af66fc99e Initial load duke parents: diff changeset	267 // How much room to adjust the last frame's SP by, to make space for
a61af66fc99e Initial load duke parents: diff changeset	268 // the callee's interpreter frame (which expects locals to be next to
a61af66fc99e Initial load duke parents: diff changeset	269 // incoming arguments)
a61af66fc99e Initial load duke parents: diff changeset	270 static int last_frame_adjust(int callee_parameters, int callee_locals);
a61af66fc99e Initial load duke parents: diff changeset	271
a61af66fc99e Initial load duke parents: diff changeset	272 // trap_request codes
a61af66fc99e Initial load duke parents: diff changeset	273 static DeoptReason trap_request_reason(int trap_request) {
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	274 if (trap_request < 0) {
0 a61af66fc99e Initial load duke parents: diff changeset	275 return (DeoptReason)
a61af66fc99e Initial load duke parents: diff changeset	276 ((~(trap_request) >> _reason_shift) & right_n_bits(_reason_bits));
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	277 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	278 // standard reason for unloaded CP entry
a61af66fc99e Initial load duke parents: diff changeset	279 return Reason_unloaded;
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	280 }
0 a61af66fc99e Initial load duke parents: diff changeset	281 }
a61af66fc99e Initial load duke parents: diff changeset	282 static DeoptAction trap_request_action(int trap_request) {
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	283 if (trap_request < 0) {
0 a61af66fc99e Initial load duke parents: diff changeset	284 return (DeoptAction)
a61af66fc99e Initial load duke parents: diff changeset	285 ((~(trap_request) >> _action_shift) & right_n_bits(_action_bits));
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	286 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	287 // standard action for unloaded CP entry
a61af66fc99e Initial load duke parents: diff changeset	288 return _unloaded_action;
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	289 }
0 a61af66fc99e Initial load duke parents: diff changeset	290 }
a61af66fc99e Initial load duke parents: diff changeset	291 static int trap_request_index(int trap_request) {
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	292 if (trap_request < 0) {
0 a61af66fc99e Initial load duke parents: diff changeset	293 return -1;
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	294 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	295 return trap_request;
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	296 }
0 a61af66fc99e Initial load duke parents: diff changeset	297 }
a61af66fc99e Initial load duke parents: diff changeset	298 static int make_trap_request(DeoptReason reason, DeoptAction action,
a61af66fc99e Initial load duke parents: diff changeset	299 int index = -1) {
7154 5d0bb7d52783 changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API Doug Simon <doug.simon@oracle.com> parents: 6948 diff changeset	300 #ifdef GRAALVM
5110 0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	301 assert(index == -1, "Graal does not use index");
0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	302 #endif
0ebca2e35ca5 more preparations for disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 4137 diff changeset	303
0 a61af66fc99e Initial load duke parents: diff changeset	304 assert((1 << _reason_bits) >= Reason_LIMIT, "enough bits");
a61af66fc99e Initial load duke parents: diff changeset	305 assert((1 << _action_bits) >= Action_LIMIT, "enough bits");
a61af66fc99e Initial load duke parents: diff changeset	306 int trap_request;
8151 b8f261ba79c6 Minimize diff to plain HotSpot version. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 7154 diff changeset	307 if (index != -1)
0 a61af66fc99e Initial load duke parents: diff changeset	308 trap_request = index;
8151 b8f261ba79c6 Minimize diff to plain HotSpot version. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 7154 diff changeset	309 else
0 a61af66fc99e Initial load duke parents: diff changeset	310 trap_request = (~(((reason) << _reason_shift)
a61af66fc99e Initial load duke parents: diff changeset	311 + ((action) << _action_shift)));
a61af66fc99e Initial load duke parents: diff changeset	312 assert(reason == trap_request_reason(trap_request), "valid reason");
a61af66fc99e Initial load duke parents: diff changeset	313 assert(action == trap_request_action(trap_request), "valid action");
a61af66fc99e Initial load duke parents: diff changeset	314 assert(index == trap_request_index(trap_request), "valid index");
a61af66fc99e Initial load duke parents: diff changeset	315 return trap_request;
a61af66fc99e Initial load duke parents: diff changeset	316 }
a61af66fc99e Initial load duke parents: diff changeset	317
a61af66fc99e Initial load duke parents: diff changeset	318 // The trap_state stored in a MDO is decoded here.
a61af66fc99e Initial load duke parents: diff changeset	319 // It records two items of information.
a61af66fc99e Initial load duke parents: diff changeset	320 // reason: If a deoptimization happened here, what its reason was,
a61af66fc99e Initial load duke parents: diff changeset	321 // or if there were multiple deopts with differing reasons.
a61af66fc99e Initial load duke parents: diff changeset	322 // recompiled: If a deoptimization here triggered a recompilation.
a61af66fc99e Initial load duke parents: diff changeset	323 // Note that not all reasons are recorded per-bci.
a61af66fc99e Initial load duke parents: diff changeset	324 static DeoptReason trap_state_reason(int trap_state);
a61af66fc99e Initial load duke parents: diff changeset	325 static int trap_state_has_reason(int trap_state, int reason);
a61af66fc99e Initial load duke parents: diff changeset	326 static int trap_state_add_reason(int trap_state, int reason);
a61af66fc99e Initial load duke parents: diff changeset	327 static bool trap_state_is_recompiled(int trap_state);
a61af66fc99e Initial load duke parents: diff changeset	328 static int trap_state_set_recompiled(int trap_state, bool z);
a61af66fc99e Initial load duke parents: diff changeset	329 static const char* format_trap_state(char* buf, size_t buflen,
a61af66fc99e Initial load duke parents: diff changeset	330 int trap_state);
a61af66fc99e Initial load duke parents: diff changeset	331
a61af66fc99e Initial load duke parents: diff changeset	332 static bool reason_is_recorded_per_bytecode(DeoptReason reason) {
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 1172 diff changeset	333 return reason > Reason_none && reason <= Reason_RECORDED_LIMIT;
0 a61af66fc99e Initial load duke parents: diff changeset	334 }
a61af66fc99e Initial load duke parents: diff changeset	335
a61af66fc99e Initial load duke parents: diff changeset	336 static DeoptReason reason_recorded_per_bytecode_if_any(DeoptReason reason) {
a61af66fc99e Initial load duke parents: diff changeset	337 if (reason_is_recorded_per_bytecode(reason))
a61af66fc99e Initial load duke parents: diff changeset	338 return reason;
a61af66fc99e Initial load duke parents: diff changeset	339 else if (reason == Reason_div0_check) // null check due to divide-by-zero?
a61af66fc99e Initial load duke parents: diff changeset	340 return Reason_null_check; // recorded per BCI as a null check
a61af66fc99e Initial load duke parents: diff changeset	341 else
a61af66fc99e Initial load duke parents: diff changeset	342 return Reason_none;
a61af66fc99e Initial load duke parents: diff changeset	343 }
a61af66fc99e Initial load duke parents: diff changeset	344
a61af66fc99e Initial load duke parents: diff changeset	345 static const char* trap_reason_name(int reason);
a61af66fc99e Initial load duke parents: diff changeset	346 static const char* trap_action_name(int action);
a61af66fc99e Initial load duke parents: diff changeset	347 // Format like reason='foo' action='bar' index='123'.
a61af66fc99e Initial load duke parents: diff changeset	348 // This is suitable both for XML and for tty output.
a61af66fc99e Initial load duke parents: diff changeset	349 static const char* format_trap_request(char* buf, size_t buflen,
a61af66fc99e Initial load duke parents: diff changeset	350 int trap_request);
a61af66fc99e Initial load duke parents: diff changeset	351
a61af66fc99e Initial load duke parents: diff changeset	352 static jint total_deoptimization_count();
a61af66fc99e Initial load duke parents: diff changeset	353 static jint deoptimization_count(DeoptReason reason);
a61af66fc99e Initial load duke parents: diff changeset	354
a61af66fc99e Initial load duke parents: diff changeset	355 // JVMTI PopFrame support
a61af66fc99e Initial load duke parents: diff changeset	356
a61af66fc99e Initial load duke parents: diff changeset	357 // Preserves incoming arguments to the popped frame when it is
a61af66fc99e Initial load duke parents: diff changeset	358 // returning to a deoptimized caller
a61af66fc99e Initial load duke parents: diff changeset	359 static void popframe_preserve_args(JavaThread* thread, int bytes_to_save, void* start_address);
a61af66fc99e Initial load duke parents: diff changeset	360
a61af66fc99e Initial load duke parents: diff changeset	361 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	362 static MethodData* get_method_data(JavaThread* thread, methodHandle m, bool create_if_missing);
0 a61af66fc99e Initial load duke parents: diff changeset	363 // Update the mdo's count and per-BCI reason bits, returning previous state:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	364 static ProfileData* query_update_method_data(MethodData* trap_mdo,
0 a61af66fc99e Initial load duke parents: diff changeset	365 int trap_bci,
a61af66fc99e Initial load duke parents: diff changeset	366 DeoptReason reason,
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5110 diff changeset	367 bool update_total_trap_count,
0 a61af66fc99e Initial load duke parents: diff changeset	368 //outputs:
a61af66fc99e Initial load duke parents: diff changeset	369 uint& ret_this_trap_count,
a61af66fc99e Initial load duke parents: diff changeset	370 bool& ret_maybe_prior_trap,
a61af66fc99e Initial load duke parents: diff changeset	371 bool& ret_maybe_prior_recompile);
a61af66fc99e Initial load duke parents: diff changeset	372 // class loading support for uncommon trap
a61af66fc99e Initial load duke parents: diff changeset	373 static void load_class_by_index(constantPoolHandle constant_pool, int index, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	374 static void load_class_by_index(constantPoolHandle constant_pool, int index);
a61af66fc99e Initial load duke parents: diff changeset	375
a61af66fc99e Initial load duke parents: diff changeset	376 static UnrollBlock* fetch_unroll_info_helper(JavaThread* thread);
a61af66fc99e Initial load duke parents: diff changeset	377
a61af66fc99e Initial load duke parents: diff changeset	378 static DeoptAction _unloaded_action; // == Action_reinterpret;
a61af66fc99e Initial load duke parents: diff changeset	379 static const char* _trap_reason_name[Reason_LIMIT];
a61af66fc99e Initial load duke parents: diff changeset	380 static const char* _trap_action_name[Action_LIMIT];
a61af66fc99e Initial load duke parents: diff changeset	381
a61af66fc99e Initial load duke parents: diff changeset	382 static juint _deoptimization_hist[Reason_LIMIT][1+Action_LIMIT][BC_CASE_LIMIT];
a61af66fc99e Initial load duke parents: diff changeset	383 // Note: Histogram array size is 1-2 Kb.
a61af66fc99e Initial load duke parents: diff changeset	384
a61af66fc99e Initial load duke parents: diff changeset	385 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	386 static void update_method_data_from_interpreter(MethodData* trap_mdo, int trap_bci, int reason);
0 a61af66fc99e Initial load duke parents: diff changeset	387 };
a61af66fc99e Initial load duke parents: diff changeset	388
a61af66fc99e Initial load duke parents: diff changeset	389 class DeoptimizationMarker : StackObj { // for profiling
a61af66fc99e Initial load duke parents: diff changeset	390 static bool _is_active;
a61af66fc99e Initial load duke parents: diff changeset	391 public:
a61af66fc99e Initial load duke parents: diff changeset	392 DeoptimizationMarker() { _is_active = true; }
a61af66fc99e Initial load duke parents: diff changeset	393 ~DeoptimizationMarker() { _is_active = false; }
a61af66fc99e Initial load duke parents: diff changeset	394 static bool is_active() { return _is_active; }
a61af66fc99e Initial load duke parents: diff changeset	395 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	396
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1905 diff changeset	397 #endif // SHARE_VM_RUNTIME_DEOPTIMIZATION_HPP

Mercurial > hg > truffle

annotate src/share/vm/runtime/deoptimization.hpp @ 9126:bc26f978b0ce