truffle: src/share/vm/oops/methodData.hpp annotate

annotate src/share/vm/oops/methodData.hpp @ 13212:eb03a7335eb0

Use fixed instead of virtual register for target in far foreign call, since the register allocator does not support virtual registers to be used at call sites.

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Mon, 02 Dec 2013 14:20:32 -0800
parents	389d40d7d99f
children	51e97f88c771

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	2 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1251 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1251 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: 1251 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: 1783 diff changeset	25 #ifndef SHARE_VM_OOPS_METHODDATAOOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	26 #define SHARE_VM_OOPS_METHODDATAOOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	28 #include "interpreter/bytecodes.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	29 #include "memory/universe.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	30 #include "oops/method.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	31 #include "oops/oop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	32 #include "runtime/orderAccess.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	33
0 a61af66fc99e Initial load duke parents: diff changeset	34 class BytecodeStream;
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	35 class KlassSizeStats;
0 a61af66fc99e Initial load duke parents: diff changeset	36
a61af66fc99e Initial load duke parents: diff changeset	37 // The MethodData object collects counts and other profile information
a61af66fc99e Initial load duke parents: diff changeset	38 // during zeroth-tier (interpretive) and first-tier execution.
a61af66fc99e Initial load duke parents: diff changeset	39 // The profile is used later by compilation heuristics. Some heuristics
a61af66fc99e Initial load duke parents: diff changeset	40 // enable use of aggressive (or "heroic") optimizations. An aggressive
a61af66fc99e Initial load duke parents: diff changeset	41 // optimization often has a down-side, a corner case that it handles
a61af66fc99e Initial load duke parents: diff changeset	42 // poorly, but which is thought to be rare. The profile provides
a61af66fc99e Initial load duke parents: diff changeset	43 // evidence of this rarity for a given method or even BCI. It allows
a61af66fc99e Initial load duke parents: diff changeset	44 // the compiler to back out of the optimization at places where it
a61af66fc99e Initial load duke parents: diff changeset	45 // has historically been a poor choice. Other heuristics try to use
a61af66fc99e Initial load duke parents: diff changeset	46 // specific information gathered about types observed at a given site.
a61af66fc99e Initial load duke parents: diff changeset	47 //
a61af66fc99e Initial load duke parents: diff changeset	48 // All data in the profile is approximate. It is expected to be accurate
a61af66fc99e Initial load duke parents: diff changeset	49 // on the whole, but the system expects occasional inaccuraces, due to
a61af66fc99e Initial load duke parents: diff changeset	50 // counter overflow, multiprocessor races during data collection, space
a61af66fc99e Initial load duke parents: diff changeset	51 // limitations, missing MDO blocks, etc. Bad or missing data will degrade
a61af66fc99e Initial load duke parents: diff changeset	52 // optimization quality but will not affect correctness. Also, each MDO
a61af66fc99e Initial load duke parents: diff changeset	53 // is marked with its birth-date ("creation_mileage") which can be used
a61af66fc99e Initial load duke parents: diff changeset	54 // to assess the quality ("maturity") of its data.
a61af66fc99e Initial load duke parents: diff changeset	55 //
a61af66fc99e Initial load duke parents: diff changeset	56 // Short (<32-bit) counters are designed to overflow to a known "saturated"
a61af66fc99e Initial load duke parents: diff changeset	57 // state. Also, certain recorded per-BCI events are given one-bit counters
a61af66fc99e Initial load duke parents: diff changeset	58 // which overflow to a saturated state which applied to all counters at
a61af66fc99e Initial load duke parents: diff changeset	59 // that BCI. In other words, there is a small lattice which approximates
a61af66fc99e Initial load duke parents: diff changeset	60 // the ideal of an infinite-precision counter for each event at each BCI,
a61af66fc99e Initial load duke parents: diff changeset	61 // and the lattice quickly "bottoms out" in a state where all counters
a61af66fc99e Initial load duke parents: diff changeset	62 // are taken to be indefinitely large.
a61af66fc99e Initial load duke parents: diff changeset	63 //
a61af66fc99e Initial load duke parents: diff changeset	64 // The reader will find many data races in profile gathering code, starting
a61af66fc99e Initial load duke parents: diff changeset	65 // with invocation counter incrementation. None of these races harm correct
a61af66fc99e Initial load duke parents: diff changeset	66 // execution of the compiled code.
a61af66fc99e Initial load duke parents: diff changeset	67
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	68 // forward decl
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	69 class ProfileData;
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	70
0 a61af66fc99e Initial load duke parents: diff changeset	71 // DataLayout
a61af66fc99e Initial load duke parents: diff changeset	72 //
a61af66fc99e Initial load duke parents: diff changeset	73 // Overlay for generic profiling data.
a61af66fc99e Initial load duke parents: diff changeset	74 class DataLayout VALUE_OBJ_CLASS_SPEC {
12258 69f26e8e09f9 8024760: add more types, fields and constants to VMStructs twisti parents: 10265 diff changeset	75 friend class VMStructs;
69f26e8e09f9 8024760: add more types, fields and constants to VMStructs twisti parents: 10265 diff changeset	76
0 a61af66fc99e Initial load duke parents: diff changeset	77 private:
a61af66fc99e Initial load duke parents: diff changeset	78 // Every data layout begins with a header. This header
a61af66fc99e Initial load duke parents: diff changeset	79 // contains a tag, which is used to indicate the size/layout
a61af66fc99e Initial load duke parents: diff changeset	80 // of the data, 4 bits of flags, which can be used in any way,
a61af66fc99e Initial load duke parents: diff changeset	81 // 4 bits of trap history (none/one reason/many reasons),
a61af66fc99e Initial load duke parents: diff changeset	82 // and a bci, which is used to tie this piece of data to a
a61af66fc99e Initial load duke parents: diff changeset	83 // specific bci in the bytecodes.
a61af66fc99e Initial load duke parents: diff changeset	84 union {
a61af66fc99e Initial load duke parents: diff changeset	85 intptr_t _bits;
a61af66fc99e Initial load duke parents: diff changeset	86 struct {
a61af66fc99e Initial load duke parents: diff changeset	87 u1 _tag;
a61af66fc99e Initial load duke parents: diff changeset	88 u1 _flags;
a61af66fc99e Initial load duke parents: diff changeset	89 u2 _bci;
a61af66fc99e Initial load duke parents: diff changeset	90 } _struct;
a61af66fc99e Initial load duke parents: diff changeset	91 } _header;
a61af66fc99e Initial load duke parents: diff changeset	92
a61af66fc99e Initial load duke parents: diff changeset	93 // The data layout has an arbitrary number of cells, each sized
a61af66fc99e Initial load duke parents: diff changeset	94 // to accomodate a pointer or an integer.
a61af66fc99e Initial load duke parents: diff changeset	95 intptr_t _cells[1];
a61af66fc99e Initial load duke parents: diff changeset	96
a61af66fc99e Initial load duke parents: diff changeset	97 // Some types of data layouts need a length field.
a61af66fc99e Initial load duke parents: diff changeset	98 static bool needs_array_len(u1 tag);
a61af66fc99e Initial load duke parents: diff changeset	99
a61af66fc99e Initial load duke parents: diff changeset	100 public:
a61af66fc99e Initial load duke parents: diff changeset	101 enum {
a61af66fc99e Initial load duke parents: diff changeset	102 counter_increment = 1
a61af66fc99e Initial load duke parents: diff changeset	103 };
a61af66fc99e Initial load duke parents: diff changeset	104
a61af66fc99e Initial load duke parents: diff changeset	105 enum {
a61af66fc99e Initial load duke parents: diff changeset	106 cell_size = sizeof(intptr_t)
a61af66fc99e Initial load duke parents: diff changeset	107 };
a61af66fc99e Initial load duke parents: diff changeset	108
a61af66fc99e Initial load duke parents: diff changeset	109 // Tag values
a61af66fc99e Initial load duke parents: diff changeset	110 enum {
a61af66fc99e Initial load duke parents: diff changeset	111 no_tag,
a61af66fc99e Initial load duke parents: diff changeset	112 bit_data_tag,
a61af66fc99e Initial load duke parents: diff changeset	113 counter_data_tag,
a61af66fc99e Initial load duke parents: diff changeset	114 jump_data_tag,
a61af66fc99e Initial load duke parents: diff changeset	115 receiver_type_data_tag,
a61af66fc99e Initial load duke parents: diff changeset	116 virtual_call_data_tag,
a61af66fc99e Initial load duke parents: diff changeset	117 ret_data_tag,
a61af66fc99e Initial load duke parents: diff changeset	118 branch_data_tag,
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	119 multi_branch_data_tag,
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	120 arg_info_data_tag,
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	121 call_type_data_tag,
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	122 virtual_call_type_data_tag,
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	123 parameters_type_data_tag
0 a61af66fc99e Initial load duke parents: diff changeset	124 };
a61af66fc99e Initial load duke parents: diff changeset	125
a61af66fc99e Initial load duke parents: diff changeset	126 enum {
a61af66fc99e Initial load duke parents: diff changeset	127 // The _struct._flags word is formatted as [trap_state:4 \| flags:4].
a61af66fc99e Initial load duke parents: diff changeset	128 // The trap state breaks down further as [recompile:1 \| reason:3].
a61af66fc99e Initial load duke parents: diff changeset	129 // This further breakdown is defined in deoptimization.cpp.
a61af66fc99e Initial load duke parents: diff changeset	130 // See Deoptimization::trap_state_reason for an assert that
a61af66fc99e Initial load duke parents: diff changeset	131 // trap_bits is big enough to hold reasons < Reason_RECORDED_LIMIT.
a61af66fc99e Initial load duke parents: diff changeset	132 //
a61af66fc99e Initial load duke parents: diff changeset	133 // The trap_state is collected only if ProfileTraps is true.
a61af66fc99e Initial load duke parents: diff changeset	134 trap_bits = 1+3, // 3: enough to distinguish [0..Reason_RECORDED_LIMIT].
a61af66fc99e Initial load duke parents: diff changeset	135 trap_shift = BitsPerByte - trap_bits,
a61af66fc99e Initial load duke parents: diff changeset	136 trap_mask = right_n_bits(trap_bits),
a61af66fc99e Initial load duke parents: diff changeset	137 trap_mask_in_place = (trap_mask << trap_shift),
a61af66fc99e Initial load duke parents: diff changeset	138 flag_limit = trap_shift,
a61af66fc99e Initial load duke parents: diff changeset	139 flag_mask = right_n_bits(flag_limit),
a61af66fc99e Initial load duke parents: diff changeset	140 first_flag = 0
a61af66fc99e Initial load duke parents: diff changeset	141 };
a61af66fc99e Initial load duke parents: diff changeset	142
a61af66fc99e Initial load duke parents: diff changeset	143 // Size computation
a61af66fc99e Initial load duke parents: diff changeset	144 static int header_size_in_bytes() {
a61af66fc99e Initial load duke parents: diff changeset	145 return cell_size;
a61af66fc99e Initial load duke parents: diff changeset	146 }
a61af66fc99e Initial load duke parents: diff changeset	147 static int header_size_in_cells() {
a61af66fc99e Initial load duke parents: diff changeset	148 return 1;
a61af66fc99e Initial load duke parents: diff changeset	149 }
a61af66fc99e Initial load duke parents: diff changeset	150
a61af66fc99e Initial load duke parents: diff changeset	151 static int compute_size_in_bytes(int cell_count) {
a61af66fc99e Initial load duke parents: diff changeset	152 return header_size_in_bytes() + cell_count * cell_size;
a61af66fc99e Initial load duke parents: diff changeset	153 }
a61af66fc99e Initial load duke parents: diff changeset	154
a61af66fc99e Initial load duke parents: diff changeset	155 // Initialization
a61af66fc99e Initial load duke parents: diff changeset	156 void initialize(u1 tag, u2 bci, int cell_count);
a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158 // Accessors
a61af66fc99e Initial load duke parents: diff changeset	159 u1 tag() {
a61af66fc99e Initial load duke parents: diff changeset	160 return _header._struct._tag;
a61af66fc99e Initial load duke parents: diff changeset	161 }
a61af66fc99e Initial load duke parents: diff changeset	162
a61af66fc99e Initial load duke parents: diff changeset	163 // Return a few bits of trap state. Range is [0..trap_mask].
a61af66fc99e Initial load duke parents: diff changeset	164 // The state tells if traps with zero, one, or many reasons have occurred.
a61af66fc99e Initial load duke parents: diff changeset	165 // It also tells whether zero or many recompilations have occurred.
a61af66fc99e Initial load duke parents: diff changeset	166 // The associated trap histogram in the MDO itself tells whether
a61af66fc99e Initial load duke parents: diff changeset	167 // traps are common or not. If a BCI shows that a trap X has
a61af66fc99e Initial load duke parents: diff changeset	168 // occurred, and the MDO shows N occurrences of X, we make the
a61af66fc99e Initial load duke parents: diff changeset	169 // simplifying assumption that all N occurrences can be blamed
a61af66fc99e Initial load duke parents: diff changeset	170 // on that BCI.
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	171 int trap_state() const {
0 a61af66fc99e Initial load duke parents: diff changeset	172 return ((_header._struct._flags >> trap_shift) & trap_mask);
a61af66fc99e Initial load duke parents: diff changeset	173 }
a61af66fc99e Initial load duke parents: diff changeset	174
a61af66fc99e Initial load duke parents: diff changeset	175 void set_trap_state(int new_state) {
a61af66fc99e Initial load duke parents: diff changeset	176 assert(ProfileTraps, "used only under +ProfileTraps");
a61af66fc99e Initial load duke parents: diff changeset	177 uint old_flags = (_header._struct._flags & flag_mask);
a61af66fc99e Initial load duke parents: diff changeset	178 _header._struct._flags = (new_state << trap_shift) \| old_flags;
a61af66fc99e Initial load duke parents: diff changeset	179 }
a61af66fc99e Initial load duke parents: diff changeset	180
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	181 u1 flags() const {
0 a61af66fc99e Initial load duke parents: diff changeset	182 return _header._struct._flags;
a61af66fc99e Initial load duke parents: diff changeset	183 }
a61af66fc99e Initial load duke parents: diff changeset	184
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	185 u2 bci() const {
0 a61af66fc99e Initial load duke parents: diff changeset	186 return _header._struct._bci;
a61af66fc99e Initial load duke parents: diff changeset	187 }
a61af66fc99e Initial load duke parents: diff changeset	188
a61af66fc99e Initial load duke parents: diff changeset	189 void set_header(intptr_t value) {
a61af66fc99e Initial load duke parents: diff changeset	190 _header._bits = value;
a61af66fc99e Initial load duke parents: diff changeset	191 }
a61af66fc99e Initial load duke parents: diff changeset	192 void release_set_header(intptr_t value) {
a61af66fc99e Initial load duke parents: diff changeset	193 OrderAccess::release_store_ptr(&_header._bits, value);
a61af66fc99e Initial load duke parents: diff changeset	194 }
a61af66fc99e Initial load duke parents: diff changeset	195 intptr_t header() {
a61af66fc99e Initial load duke parents: diff changeset	196 return _header._bits;
a61af66fc99e Initial load duke parents: diff changeset	197 }
a61af66fc99e Initial load duke parents: diff changeset	198 void set_cell_at(int index, intptr_t value) {
a61af66fc99e Initial load duke parents: diff changeset	199 _cells[index] = value;
a61af66fc99e Initial load duke parents: diff changeset	200 }
a61af66fc99e Initial load duke parents: diff changeset	201 void release_set_cell_at(int index, intptr_t value) {
a61af66fc99e Initial load duke parents: diff changeset	202 OrderAccess::release_store_ptr(&_cells[index], value);
a61af66fc99e Initial load duke parents: diff changeset	203 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	204 intptr_t cell_at(int index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	205 return _cells[index];
a61af66fc99e Initial load duke parents: diff changeset	206 }
a61af66fc99e Initial load duke parents: diff changeset	207
a61af66fc99e Initial load duke parents: diff changeset	208 void set_flag_at(int flag_number) {
a61af66fc99e Initial load duke parents: diff changeset	209 assert(flag_number < flag_limit, "oob");
a61af66fc99e Initial load duke parents: diff changeset	210 _header._struct._flags \|= (0x1 << flag_number);
a61af66fc99e Initial load duke parents: diff changeset	211 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	212 bool flag_at(int flag_number) const {
0 a61af66fc99e Initial load duke parents: diff changeset	213 assert(flag_number < flag_limit, "oob");
a61af66fc99e Initial load duke parents: diff changeset	214 return (_header._struct._flags & (0x1 << flag_number)) != 0;
a61af66fc99e Initial load duke parents: diff changeset	215 }
a61af66fc99e Initial load duke parents: diff changeset	216
a61af66fc99e Initial load duke parents: diff changeset	217 // Low-level support for code generation.
a61af66fc99e Initial load duke parents: diff changeset	218 static ByteSize header_offset() {
a61af66fc99e Initial load duke parents: diff changeset	219 return byte_offset_of(DataLayout, _header);
a61af66fc99e Initial load duke parents: diff changeset	220 }
a61af66fc99e Initial load duke parents: diff changeset	221 static ByteSize tag_offset() {
a61af66fc99e Initial load duke parents: diff changeset	222 return byte_offset_of(DataLayout, _header._struct._tag);
a61af66fc99e Initial load duke parents: diff changeset	223 }
a61af66fc99e Initial load duke parents: diff changeset	224 static ByteSize flags_offset() {
a61af66fc99e Initial load duke parents: diff changeset	225 return byte_offset_of(DataLayout, _header._struct._flags);
a61af66fc99e Initial load duke parents: diff changeset	226 }
a61af66fc99e Initial load duke parents: diff changeset	227 static ByteSize bci_offset() {
a61af66fc99e Initial load duke parents: diff changeset	228 return byte_offset_of(DataLayout, _header._struct._bci);
a61af66fc99e Initial load duke parents: diff changeset	229 }
a61af66fc99e Initial load duke parents: diff changeset	230 static ByteSize cell_offset(int index) {
2333 f767174aac14 7021653: Parfait issue in hotspot/src/share/vm/oops/methodDataOops.hpp coleenp parents: 2264 diff changeset	231 return byte_offset_of(DataLayout, _cells) + in_ByteSize(index * cell_size);
0 a61af66fc99e Initial load duke parents: diff changeset	232 }
a61af66fc99e Initial load duke parents: diff changeset	233 // Return a value which, when or-ed as a byte into _flags, sets the flag.
a61af66fc99e Initial load duke parents: diff changeset	234 static int flag_number_to_byte_constant(int flag_number) {
a61af66fc99e Initial load duke parents: diff changeset	235 assert(0 <= flag_number && flag_number < flag_limit, "oob");
a61af66fc99e Initial load duke parents: diff changeset	236 DataLayout temp; temp.set_header(0);
a61af66fc99e Initial load duke parents: diff changeset	237 temp.set_flag_at(flag_number);
a61af66fc99e Initial load duke parents: diff changeset	238 return temp._header._struct._flags;
a61af66fc99e Initial load duke parents: diff changeset	239 }
a61af66fc99e Initial load duke parents: diff changeset	240 // Return a value which, when or-ed as a word into _header, sets the flag.
a61af66fc99e Initial load duke parents: diff changeset	241 static intptr_t flag_mask_to_header_mask(int byte_constant) {
a61af66fc99e Initial load duke parents: diff changeset	242 DataLayout temp; temp.set_header(0);
a61af66fc99e Initial load duke parents: diff changeset	243 temp._header._struct._flags = byte_constant;
a61af66fc99e Initial load duke parents: diff changeset	244 return temp._header._bits;
a61af66fc99e Initial load duke parents: diff changeset	245 }
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	246
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	247 ProfileData* data_in();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	248
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	249 // GC support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	250 void clean_weak_klass_links(BoolObjectClosure* cl);
0 a61af66fc99e Initial load duke parents: diff changeset	251 };
a61af66fc99e Initial load duke parents: diff changeset	252
a61af66fc99e Initial load duke parents: diff changeset	253
a61af66fc99e Initial load duke parents: diff changeset	254 // ProfileData class hierarchy
a61af66fc99e Initial load duke parents: diff changeset	255 class ProfileData;
a61af66fc99e Initial load duke parents: diff changeset	256 class BitData;
a61af66fc99e Initial load duke parents: diff changeset	257 class CounterData;
a61af66fc99e Initial load duke parents: diff changeset	258 class ReceiverTypeData;
a61af66fc99e Initial load duke parents: diff changeset	259 class VirtualCallData;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	260 class VirtualCallTypeData;
0 a61af66fc99e Initial load duke parents: diff changeset	261 class RetData;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	262 class CallTypeData;
0 a61af66fc99e Initial load duke parents: diff changeset	263 class JumpData;
a61af66fc99e Initial load duke parents: diff changeset	264 class BranchData;
a61af66fc99e Initial load duke parents: diff changeset	265 class ArrayData;
a61af66fc99e Initial load duke parents: diff changeset	266 class MultiBranchData;
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	267 class ArgInfoData;
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	268 class ParametersTypeData;
0 a61af66fc99e Initial load duke parents: diff changeset	269
a61af66fc99e Initial load duke parents: diff changeset	270 // ProfileData
a61af66fc99e Initial load duke parents: diff changeset	271 //
a61af66fc99e Initial load duke parents: diff changeset	272 // A ProfileData object is created to refer to a section of profiling
a61af66fc99e Initial load duke parents: diff changeset	273 // data in a structured way.
a61af66fc99e Initial load duke parents: diff changeset	274 class ProfileData : public ResourceObj {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	275 friend class TypeEntries;
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	276 friend class ReturnTypeEntry;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	277 friend class TypeStackSlotEntries;
0 a61af66fc99e Initial load duke parents: diff changeset	278 private:
a61af66fc99e Initial load duke parents: diff changeset	279 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	280 enum {
a61af66fc99e Initial load duke parents: diff changeset	281 tab_width_one = 16,
a61af66fc99e Initial load duke parents: diff changeset	282 tab_width_two = 36
a61af66fc99e Initial load duke parents: diff changeset	283 };
a61af66fc99e Initial load duke parents: diff changeset	284 #endif // !PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	285
a61af66fc99e Initial load duke parents: diff changeset	286 // This is a pointer to a section of profiling data.
a61af66fc99e Initial load duke parents: diff changeset	287 DataLayout* _data;
a61af66fc99e Initial load duke parents: diff changeset	288
a61af66fc99e Initial load duke parents: diff changeset	289 protected:
a61af66fc99e Initial load duke parents: diff changeset	290 DataLayout* data() { return _data; }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	291 const DataLayout* data() const { return _data; }
0 a61af66fc99e Initial load duke parents: diff changeset	292
a61af66fc99e Initial load duke parents: diff changeset	293 enum {
a61af66fc99e Initial load duke parents: diff changeset	294 cell_size = DataLayout::cell_size
a61af66fc99e Initial load duke parents: diff changeset	295 };
a61af66fc99e Initial load duke parents: diff changeset	296
a61af66fc99e Initial load duke parents: diff changeset	297 public:
a61af66fc99e Initial load duke parents: diff changeset	298 // How many cells are in this?
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	299 virtual int cell_count() const {
0 a61af66fc99e Initial load duke parents: diff changeset	300 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	301 return -1;
a61af66fc99e Initial load duke parents: diff changeset	302 }
a61af66fc99e Initial load duke parents: diff changeset	303
a61af66fc99e Initial load duke parents: diff changeset	304 // Return the size of this data.
a61af66fc99e Initial load duke parents: diff changeset	305 int size_in_bytes() {
a61af66fc99e Initial load duke parents: diff changeset	306 return DataLayout::compute_size_in_bytes(cell_count());
a61af66fc99e Initial load duke parents: diff changeset	307 }
a61af66fc99e Initial load duke parents: diff changeset	308
a61af66fc99e Initial load duke parents: diff changeset	309 protected:
a61af66fc99e Initial load duke parents: diff changeset	310 // Low-level accessors for underlying data
a61af66fc99e Initial load duke parents: diff changeset	311 void set_intptr_at(int index, intptr_t value) {
a61af66fc99e Initial load duke parents: diff changeset	312 assert(0 <= index && index < cell_count(), "oob");
a61af66fc99e Initial load duke parents: diff changeset	313 data()->set_cell_at(index, value);
a61af66fc99e Initial load duke parents: diff changeset	314 }
a61af66fc99e Initial load duke parents: diff changeset	315 void release_set_intptr_at(int index, intptr_t value) {
a61af66fc99e Initial load duke parents: diff changeset	316 assert(0 <= index && index < cell_count(), "oob");
a61af66fc99e Initial load duke parents: diff changeset	317 data()->release_set_cell_at(index, value);
a61af66fc99e Initial load duke parents: diff changeset	318 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	319 intptr_t intptr_at(int index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	320 assert(0 <= index && index < cell_count(), "oob");
a61af66fc99e Initial load duke parents: diff changeset	321 return data()->cell_at(index);
a61af66fc99e Initial load duke parents: diff changeset	322 }
a61af66fc99e Initial load duke parents: diff changeset	323 void set_uint_at(int index, uint value) {
a61af66fc99e Initial load duke parents: diff changeset	324 set_intptr_at(index, (intptr_t) value);
a61af66fc99e Initial load duke parents: diff changeset	325 }
a61af66fc99e Initial load duke parents: diff changeset	326 void release_set_uint_at(int index, uint value) {
a61af66fc99e Initial load duke parents: diff changeset	327 release_set_intptr_at(index, (intptr_t) value);
a61af66fc99e Initial load duke parents: diff changeset	328 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	329 uint uint_at(int index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	330 return (uint)intptr_at(index);
a61af66fc99e Initial load duke parents: diff changeset	331 }
a61af66fc99e Initial load duke parents: diff changeset	332 void set_int_at(int index, int value) {
a61af66fc99e Initial load duke parents: diff changeset	333 set_intptr_at(index, (intptr_t) value);
a61af66fc99e Initial load duke parents: diff changeset	334 }
a61af66fc99e Initial load duke parents: diff changeset	335 void release_set_int_at(int index, int value) {
a61af66fc99e Initial load duke parents: diff changeset	336 release_set_intptr_at(index, (intptr_t) value);
a61af66fc99e Initial load duke parents: diff changeset	337 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	338 int int_at(int index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	339 return (int)intptr_at(index);
a61af66fc99e Initial load duke parents: diff changeset	340 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	341 int int_at_unchecked(int index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	342 return (int)data()->cell_at(index);
a61af66fc99e Initial load duke parents: diff changeset	343 }
a61af66fc99e Initial load duke parents: diff changeset	344 void set_oop_at(int index, oop value) {
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12258 diff changeset	345 set_intptr_at(index, cast_from_oop<intptr_t>(value));
0 a61af66fc99e Initial load duke parents: diff changeset	346 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	347 oop oop_at(int index) const {
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12258 diff changeset	348 return cast_to_oop(intptr_at(index));
0 a61af66fc99e Initial load duke parents: diff changeset	349 }
a61af66fc99e Initial load duke parents: diff changeset	350
a61af66fc99e Initial load duke parents: diff changeset	351 void set_flag_at(int flag_number) {
a61af66fc99e Initial load duke parents: diff changeset	352 data()->set_flag_at(flag_number);
a61af66fc99e Initial load duke parents: diff changeset	353 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	354 bool flag_at(int flag_number) const {
0 a61af66fc99e Initial load duke parents: diff changeset	355 return data()->flag_at(flag_number);
a61af66fc99e Initial load duke parents: diff changeset	356 }
a61af66fc99e Initial load duke parents: diff changeset	357
a61af66fc99e Initial load duke parents: diff changeset	358 // two convenient imports for use by subclasses:
a61af66fc99e Initial load duke parents: diff changeset	359 static ByteSize cell_offset(int index) {
a61af66fc99e Initial load duke parents: diff changeset	360 return DataLayout::cell_offset(index);
a61af66fc99e Initial load duke parents: diff changeset	361 }
a61af66fc99e Initial load duke parents: diff changeset	362 static int flag_number_to_byte_constant(int flag_number) {
a61af66fc99e Initial load duke parents: diff changeset	363 return DataLayout::flag_number_to_byte_constant(flag_number);
a61af66fc99e Initial load duke parents: diff changeset	364 }
a61af66fc99e Initial load duke parents: diff changeset	365
a61af66fc99e Initial load duke parents: diff changeset	366 ProfileData(DataLayout* data) {
a61af66fc99e Initial load duke parents: diff changeset	367 _data = data;
a61af66fc99e Initial load duke parents: diff changeset	368 }
a61af66fc99e Initial load duke parents: diff changeset	369
a61af66fc99e Initial load duke parents: diff changeset	370 public:
a61af66fc99e Initial load duke parents: diff changeset	371 // Constructor for invalid ProfileData.
a61af66fc99e Initial load duke parents: diff changeset	372 ProfileData();
a61af66fc99e Initial load duke parents: diff changeset	373
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	374 u2 bci() const {
0 a61af66fc99e Initial load duke parents: diff changeset	375 return data()->bci();
a61af66fc99e Initial load duke parents: diff changeset	376 }
a61af66fc99e Initial load duke parents: diff changeset	377
a61af66fc99e Initial load duke parents: diff changeset	378 address dp() {
a61af66fc99e Initial load duke parents: diff changeset	379 return (address)_data;
a61af66fc99e Initial load duke parents: diff changeset	380 }
a61af66fc99e Initial load duke parents: diff changeset	381
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	382 int trap_state() const {
0 a61af66fc99e Initial load duke parents: diff changeset	383 return data()->trap_state();
a61af66fc99e Initial load duke parents: diff changeset	384 }
a61af66fc99e Initial load duke parents: diff changeset	385 void set_trap_state(int new_state) {
a61af66fc99e Initial load duke parents: diff changeset	386 data()->set_trap_state(new_state);
a61af66fc99e Initial load duke parents: diff changeset	387 }
a61af66fc99e Initial load duke parents: diff changeset	388
a61af66fc99e Initial load duke parents: diff changeset	389 // Type checking
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	390 virtual bool is_BitData() const { return false; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	391 virtual bool is_CounterData() const { return false; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	392 virtual bool is_JumpData() const { return false; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	393 virtual bool is_ReceiverTypeData()const { return false; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	394 virtual bool is_VirtualCallData() const { return false; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	395 virtual bool is_RetData() const { return false; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	396 virtual bool is_BranchData() const { return false; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	397 virtual bool is_ArrayData() const { return false; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	398 virtual bool is_MultiBranchData() const { return false; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	399 virtual bool is_ArgInfoData() const { return false; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	400 virtual bool is_CallTypeData() const { return false; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	401 virtual bool is_VirtualCallTypeData()const { return false; }
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	402 virtual bool is_ParametersTypeData() const { return false; }
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	403
0 a61af66fc99e Initial load duke parents: diff changeset	404
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	405 BitData* as_BitData() const {
0 a61af66fc99e Initial load duke parents: diff changeset	406 assert(is_BitData(), "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	407 return is_BitData() ? (BitData*) this : NULL;
a61af66fc99e Initial load duke parents: diff changeset	408 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	409 CounterData* as_CounterData() const {
0 a61af66fc99e Initial load duke parents: diff changeset	410 assert(is_CounterData(), "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	411 return is_CounterData() ? (CounterData*) this : NULL;
a61af66fc99e Initial load duke parents: diff changeset	412 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	413 JumpData* as_JumpData() const {
0 a61af66fc99e Initial load duke parents: diff changeset	414 assert(is_JumpData(), "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	415 return is_JumpData() ? (JumpData*) this : NULL;
a61af66fc99e Initial load duke parents: diff changeset	416 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	417 ReceiverTypeData* as_ReceiverTypeData() const {
0 a61af66fc99e Initial load duke parents: diff changeset	418 assert(is_ReceiverTypeData(), "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	419 return is_ReceiverTypeData() ? (ReceiverTypeData*)this : NULL;
a61af66fc99e Initial load duke parents: diff changeset	420 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	421 VirtualCallData* as_VirtualCallData() const {
0 a61af66fc99e Initial load duke parents: diff changeset	422 assert(is_VirtualCallData(), "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	423 return is_VirtualCallData() ? (VirtualCallData*)this : NULL;
a61af66fc99e Initial load duke parents: diff changeset	424 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	425 RetData* as_RetData() const {
0 a61af66fc99e Initial load duke parents: diff changeset	426 assert(is_RetData(), "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	427 return is_RetData() ? (RetData*) this : NULL;
a61af66fc99e Initial load duke parents: diff changeset	428 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	429 BranchData* as_BranchData() const {
0 a61af66fc99e Initial load duke parents: diff changeset	430 assert(is_BranchData(), "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	431 return is_BranchData() ? (BranchData*) this : NULL;
a61af66fc99e Initial load duke parents: diff changeset	432 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	433 ArrayData* as_ArrayData() const {
0 a61af66fc99e Initial load duke parents: diff changeset	434 assert(is_ArrayData(), "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	435 return is_ArrayData() ? (ArrayData*) this : NULL;
a61af66fc99e Initial load duke parents: diff changeset	436 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	437 MultiBranchData* as_MultiBranchData() const {
0 a61af66fc99e Initial load duke parents: diff changeset	438 assert(is_MultiBranchData(), "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	439 return is_MultiBranchData() ? (MultiBranchData*)this : NULL;
a61af66fc99e Initial load duke parents: diff changeset	440 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	441 ArgInfoData* as_ArgInfoData() const {
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	442 assert(is_ArgInfoData(), "wrong type");
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	443 return is_ArgInfoData() ? (ArgInfoData*)this : NULL;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	444 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	445 CallTypeData* as_CallTypeData() const {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	446 assert(is_CallTypeData(), "wrong type");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	447 return is_CallTypeData() ? (CallTypeData*)this : NULL;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	448 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	449 VirtualCallTypeData* as_VirtualCallTypeData() const {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	450 assert(is_VirtualCallTypeData(), "wrong type");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	451 return is_VirtualCallTypeData() ? (VirtualCallTypeData*)this : NULL;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	452 }
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	453 ParametersTypeData* as_ParametersTypeData() const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	454 assert(is_ParametersTypeData(), "wrong type");
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	455 return is_ParametersTypeData() ? (ParametersTypeData*)this : NULL;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	456 }
0 a61af66fc99e Initial load duke parents: diff changeset	457
a61af66fc99e Initial load duke parents: diff changeset	458
a61af66fc99e Initial load duke parents: diff changeset	459 // Subclass specific initialization
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	460 virtual void post_initialize(BytecodeStream* stream, MethodData* mdo) {}
0 a61af66fc99e Initial load duke parents: diff changeset	461
a61af66fc99e Initial load duke parents: diff changeset	462 // GC support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	463 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure) {}
0 a61af66fc99e Initial load duke parents: diff changeset	464
a61af66fc99e Initial load duke parents: diff changeset	465 // CI translation: ProfileData can represent both MethodDataOop data
a61af66fc99e Initial load duke parents: diff changeset	466 // as well as CIMethodData data. This function is provided for translating
a61af66fc99e Initial load duke parents: diff changeset	467 // an oop in a ProfileData to the ci equivalent. Generally speaking,
a61af66fc99e Initial load duke parents: diff changeset	468 // most ProfileData don't require any translation, so we provide the null
a61af66fc99e Initial load duke parents: diff changeset	469 // translation here, and the required translators are in the ci subclasses.
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	470 virtual void translate_from(const ProfileData* data) {}
0 a61af66fc99e Initial load duke parents: diff changeset	471
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	472 virtual void print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	473 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	474 }
a61af66fc99e Initial load duke parents: diff changeset	475
a61af66fc99e Initial load duke parents: diff changeset	476 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	477 void print_shared(outputStream* st, const char* name) const;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	478 void tab(outputStream* st, bool first = false) const;
0 a61af66fc99e Initial load duke parents: diff changeset	479 #endif
a61af66fc99e Initial load duke parents: diff changeset	480 };
a61af66fc99e Initial load duke parents: diff changeset	481
a61af66fc99e Initial load duke parents: diff changeset	482 // BitData
a61af66fc99e Initial load duke parents: diff changeset	483 //
a61af66fc99e Initial load duke parents: diff changeset	484 // A BitData holds a flag or two in its header.
a61af66fc99e Initial load duke parents: diff changeset	485 class BitData : public ProfileData {
a61af66fc99e Initial load duke parents: diff changeset	486 protected:
a61af66fc99e Initial load duke parents: diff changeset	487 enum {
a61af66fc99e Initial load duke parents: diff changeset	488 // null_seen:
a61af66fc99e Initial load duke parents: diff changeset	489 // saw a null operand (cast/aastore/instanceof)
8616 d343737786fe changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM Christian Haeubl <haeubl@ssw.jku.at> parents: 8611 diff changeset	490 null_seen_flag = DataLayout::first_flag + 0
d343737786fe changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM Christian Haeubl <haeubl@ssw.jku.at> parents: 8611 diff changeset	491 #ifdef GRAAL
d343737786fe changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM Christian Haeubl <haeubl@ssw.jku.at> parents: 8611 diff changeset	492 // bytecode threw any exception
d343737786fe changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM Christian Haeubl <haeubl@ssw.jku.at> parents: 8611 diff changeset	493 , exception_seen_flag = null_seen_flag + 1
d343737786fe changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM Christian Haeubl <haeubl@ssw.jku.at> parents: 8611 diff changeset	494 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	495 };
a61af66fc99e Initial load duke parents: diff changeset	496 enum { bit_cell_count = 0 }; // no additional data fields needed.
a61af66fc99e Initial load duke parents: diff changeset	497 public:
a61af66fc99e Initial load duke parents: diff changeset	498 BitData(DataLayout* layout) : ProfileData(layout) {
a61af66fc99e Initial load duke parents: diff changeset	499 }
a61af66fc99e Initial load duke parents: diff changeset	500
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	501 virtual bool is_BitData() const { return true; }
0 a61af66fc99e Initial load duke parents: diff changeset	502
a61af66fc99e Initial load duke parents: diff changeset	503 static int static_cell_count() {
a61af66fc99e Initial load duke parents: diff changeset	504 return bit_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	505 }
a61af66fc99e Initial load duke parents: diff changeset	506
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	507 virtual int cell_count() const {
0 a61af66fc99e Initial load duke parents: diff changeset	508 return static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	509 }
a61af66fc99e Initial load duke parents: diff changeset	510
a61af66fc99e Initial load duke parents: diff changeset	511 // Accessor
a61af66fc99e Initial load duke parents: diff changeset	512
a61af66fc99e Initial load duke parents: diff changeset	513 // The null_seen flag bit is specially known to the interpreter.
a61af66fc99e Initial load duke parents: diff changeset	514 // Consulting it allows the compiler to avoid setting up null_check traps.
a61af66fc99e Initial load duke parents: diff changeset	515 bool null_seen() { return flag_at(null_seen_flag); }
a61af66fc99e Initial load duke parents: diff changeset	516 void set_null_seen() { set_flag_at(null_seen_flag); }
8616 d343737786fe changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM Christian Haeubl <haeubl@ssw.jku.at> parents: 8611 diff changeset	517 #ifdef GRAAL
d343737786fe changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM Christian Haeubl <haeubl@ssw.jku.at> parents: 8611 diff changeset	518 // true if an exception was thrown at the specific BCI
d343737786fe changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM Christian Haeubl <haeubl@ssw.jku.at> parents: 8611 diff changeset	519 bool exception_seen() { return flag_at(exception_seen_flag); }
d343737786fe changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM Christian Haeubl <haeubl@ssw.jku.at> parents: 8611 diff changeset	520 void set_exception_seen() { set_flag_at(exception_seen_flag); }
d343737786fe changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM Christian Haeubl <haeubl@ssw.jku.at> parents: 8611 diff changeset	521 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	522
a61af66fc99e Initial load duke parents: diff changeset	523 // Code generation support
a61af66fc99e Initial load duke parents: diff changeset	524 static int null_seen_byte_constant() {
a61af66fc99e Initial load duke parents: diff changeset	525 return flag_number_to_byte_constant(null_seen_flag);
a61af66fc99e Initial load duke parents: diff changeset	526 }
a61af66fc99e Initial load duke parents: diff changeset	527
a61af66fc99e Initial load duke parents: diff changeset	528 static ByteSize bit_data_size() {
a61af66fc99e Initial load duke parents: diff changeset	529 return cell_offset(bit_cell_count);
a61af66fc99e Initial load duke parents: diff changeset	530 }
a61af66fc99e Initial load duke parents: diff changeset	531
a61af66fc99e Initial load duke parents: diff changeset	532 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	533 void print_data_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	534 #endif
a61af66fc99e Initial load duke parents: diff changeset	535 };
a61af66fc99e Initial load duke parents: diff changeset	536
a61af66fc99e Initial load duke parents: diff changeset	537 // CounterData
a61af66fc99e Initial load duke parents: diff changeset	538 //
a61af66fc99e Initial load duke parents: diff changeset	539 // A CounterData corresponds to a simple counter.
a61af66fc99e Initial load duke parents: diff changeset	540 class CounterData : public BitData {
a61af66fc99e Initial load duke parents: diff changeset	541 protected:
a61af66fc99e Initial load duke parents: diff changeset	542 enum {
a61af66fc99e Initial load duke parents: diff changeset	543 count_off,
a61af66fc99e Initial load duke parents: diff changeset	544 counter_cell_count
a61af66fc99e Initial load duke parents: diff changeset	545 };
a61af66fc99e Initial load duke parents: diff changeset	546 public:
a61af66fc99e Initial load duke parents: diff changeset	547 CounterData(DataLayout* layout) : BitData(layout) {}
a61af66fc99e Initial load duke parents: diff changeset	548
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	549 virtual bool is_CounterData() const { return true; }
0 a61af66fc99e Initial load duke parents: diff changeset	550
a61af66fc99e Initial load duke parents: diff changeset	551 static int static_cell_count() {
a61af66fc99e Initial load duke parents: diff changeset	552 return counter_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	553 }
a61af66fc99e Initial load duke parents: diff changeset	554
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	555 virtual int cell_count() const {
0 a61af66fc99e Initial load duke parents: diff changeset	556 return static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	557 }
a61af66fc99e Initial load duke parents: diff changeset	558
a61af66fc99e Initial load duke parents: diff changeset	559 // Direct accessor
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	560 uint count() const {
0 a61af66fc99e Initial load duke parents: diff changeset	561 return uint_at(count_off);
a61af66fc99e Initial load duke parents: diff changeset	562 }
a61af66fc99e Initial load duke parents: diff changeset	563
a61af66fc99e Initial load duke parents: diff changeset	564 // Code generation support
a61af66fc99e Initial load duke parents: diff changeset	565 static ByteSize count_offset() {
a61af66fc99e Initial load duke parents: diff changeset	566 return cell_offset(count_off);
a61af66fc99e Initial load duke parents: diff changeset	567 }
a61af66fc99e Initial load duke parents: diff changeset	568 static ByteSize counter_data_size() {
a61af66fc99e Initial load duke parents: diff changeset	569 return cell_offset(counter_cell_count);
a61af66fc99e Initial load duke parents: diff changeset	570 }
a61af66fc99e Initial load duke parents: diff changeset	571
1251 576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	572 void set_count(uint count) {
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	573 set_uint_at(count_off, count);
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	574 }
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	575
0 a61af66fc99e Initial load duke parents: diff changeset	576 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	577 void print_data_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	578 #endif
a61af66fc99e Initial load duke parents: diff changeset	579 };
a61af66fc99e Initial load duke parents: diff changeset	580
a61af66fc99e Initial load duke parents: diff changeset	581 // JumpData
a61af66fc99e Initial load duke parents: diff changeset	582 //
a61af66fc99e Initial load duke parents: diff changeset	583 // A JumpData is used to access profiling information for a direct
a61af66fc99e Initial load duke parents: diff changeset	584 // branch. It is a counter, used for counting the number of branches,
a61af66fc99e Initial load duke parents: diff changeset	585 // plus a data displacement, used for realigning the data pointer to
a61af66fc99e Initial load duke parents: diff changeset	586 // the corresponding target bci.
a61af66fc99e Initial load duke parents: diff changeset	587 class JumpData : public ProfileData {
a61af66fc99e Initial load duke parents: diff changeset	588 protected:
a61af66fc99e Initial load duke parents: diff changeset	589 enum {
a61af66fc99e Initial load duke parents: diff changeset	590 taken_off_set,
a61af66fc99e Initial load duke parents: diff changeset	591 displacement_off_set,
a61af66fc99e Initial load duke parents: diff changeset	592 jump_cell_count
a61af66fc99e Initial load duke parents: diff changeset	593 };
a61af66fc99e Initial load duke parents: diff changeset	594
a61af66fc99e Initial load duke parents: diff changeset	595 void set_displacement(int displacement) {
a61af66fc99e Initial load duke parents: diff changeset	596 set_int_at(displacement_off_set, displacement);
a61af66fc99e Initial load duke parents: diff changeset	597 }
a61af66fc99e Initial load duke parents: diff changeset	598
a61af66fc99e Initial load duke parents: diff changeset	599 public:
a61af66fc99e Initial load duke parents: diff changeset	600 JumpData(DataLayout* layout) : ProfileData(layout) {
a61af66fc99e Initial load duke parents: diff changeset	601 assert(layout->tag() == DataLayout::jump_data_tag \|\|
a61af66fc99e Initial load duke parents: diff changeset	602 layout->tag() == DataLayout::branch_data_tag, "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	603 }
a61af66fc99e Initial load duke parents: diff changeset	604
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	605 virtual bool is_JumpData() const { return true; }
0 a61af66fc99e Initial load duke parents: diff changeset	606
a61af66fc99e Initial load duke parents: diff changeset	607 static int static_cell_count() {
a61af66fc99e Initial load duke parents: diff changeset	608 return jump_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	609 }
a61af66fc99e Initial load duke parents: diff changeset	610
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	611 virtual int cell_count() const {
0 a61af66fc99e Initial load duke parents: diff changeset	612 return static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	613 }
a61af66fc99e Initial load duke parents: diff changeset	614
a61af66fc99e Initial load duke parents: diff changeset	615 // Direct accessor
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	616 uint taken() const {
0 a61af66fc99e Initial load duke parents: diff changeset	617 return uint_at(taken_off_set);
a61af66fc99e Initial load duke parents: diff changeset	618 }
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3345 diff changeset	619
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3345 diff changeset	620 void set_taken(uint cnt) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3345 diff changeset	621 set_uint_at(taken_off_set, cnt);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3345 diff changeset	622 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3345 diff changeset	623
0 a61af66fc99e Initial load duke parents: diff changeset	624 // Saturating counter
a61af66fc99e Initial load duke parents: diff changeset	625 uint inc_taken() {
a61af66fc99e Initial load duke parents: diff changeset	626 uint cnt = taken() + 1;
a61af66fc99e Initial load duke parents: diff changeset	627 // Did we wrap? Will compiler screw us??
a61af66fc99e Initial load duke parents: diff changeset	628 if (cnt == 0) cnt--;
a61af66fc99e Initial load duke parents: diff changeset	629 set_uint_at(taken_off_set, cnt);
a61af66fc99e Initial load duke parents: diff changeset	630 return cnt;
a61af66fc99e Initial load duke parents: diff changeset	631 }
a61af66fc99e Initial load duke parents: diff changeset	632
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	633 int displacement() const {
0 a61af66fc99e Initial load duke parents: diff changeset	634 return int_at(displacement_off_set);
a61af66fc99e Initial load duke parents: diff changeset	635 }
a61af66fc99e Initial load duke parents: diff changeset	636
a61af66fc99e Initial load duke parents: diff changeset	637 // Code generation support
a61af66fc99e Initial load duke parents: diff changeset	638 static ByteSize taken_offset() {
a61af66fc99e Initial load duke parents: diff changeset	639 return cell_offset(taken_off_set);
a61af66fc99e Initial load duke parents: diff changeset	640 }
a61af66fc99e Initial load duke parents: diff changeset	641
a61af66fc99e Initial load duke parents: diff changeset	642 static ByteSize displacement_offset() {
a61af66fc99e Initial load duke parents: diff changeset	643 return cell_offset(displacement_off_set);
a61af66fc99e Initial load duke parents: diff changeset	644 }
a61af66fc99e Initial load duke parents: diff changeset	645
a61af66fc99e Initial load duke parents: diff changeset	646 // Specific initialization.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	647 void post_initialize(BytecodeStream* stream, MethodData* mdo);
0 a61af66fc99e Initial load duke parents: diff changeset	648
a61af66fc99e Initial load duke parents: diff changeset	649 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	650 void print_data_on(outputStream* st) const;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	651 #endif
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	652 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	653
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	654 // Entries in a ProfileData object to record types: it can either be
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	655 // none (no profile), unknown (conflicting profile data) or a klass if
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	656 // a single one is seen. Whether a null reference was seen is also
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	657 // recorded. No counter is associated with the type and a single type
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	658 // is tracked (unlike VirtualCallData).
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	659 class TypeEntries {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	660
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	661 public:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	662
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	663 // A single cell is used to record information for a type:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	664 // - the cell is initialized to 0
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	665 // - when a type is discovered it is stored in the cell
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	666 // - bit zero of the cell is used to record whether a null reference
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	667 // was encountered or not
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	668 // - bit 1 is set to record a conflict in the type information
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	669
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	670 enum {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	671 null_seen = 1,
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	672 type_mask = ~null_seen,
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	673 type_unknown = 2,
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	674 status_bits = null_seen \| type_unknown,
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	675 type_klass_mask = ~status_bits
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	676 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	677
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	678 // what to initialize a cell to
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	679 static intptr_t type_none() {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	680 return 0;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	681 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	682
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	683 // null seen = bit 0 set?
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	684 static bool was_null_seen(intptr_t v) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	685 return (v & null_seen) != 0;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	686 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	687
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	688 // conflicting type information = bit 1 set?
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	689 static bool is_type_unknown(intptr_t v) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	690 return (v & type_unknown) != 0;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	691 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	692
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	693 // not type information yet = all bits cleared, ignoring bit 0?
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	694 static bool is_type_none(intptr_t v) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	695 return (v & type_mask) == 0;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	696 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	697
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	698 // recorded type: cell without bit 0 and 1
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	699 static intptr_t klass_part(intptr_t v) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	700 intptr_t r = v & type_klass_mask;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	701 return r;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	702 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	703
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	704 // type recorded
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	705 static Klass* valid_klass(intptr_t k) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	706 if (!is_type_none(k) &&
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	707 !is_type_unknown(k)) {
13080 6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12962 diff changeset	708 Klass* res = (Klass*)klass_part(k);
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12962 diff changeset	709 assert(res != NULL, "invalid");
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12962 diff changeset	710 return res;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	711 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	712 return NULL;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	713 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	714 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	715
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	716 static intptr_t with_status(intptr_t k, intptr_t in) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	717 return k \| (in & status_bits);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	718 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	719
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	720 static intptr_t with_status(Klass* k, intptr_t in) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	721 return with_status((intptr_t)k, in);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	722 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	723
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	724 #ifndef PRODUCT
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	725 static void print_klass(outputStream* st, intptr_t k);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	726 #endif
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	727
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	728 // GC support
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	729 static bool is_loader_alive(BoolObjectClosure* is_alive_cl, intptr_t p);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	730
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	731 protected:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	732 // ProfileData object these entries are part of
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	733 ProfileData* _pd;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	734 // offset within the ProfileData object where the entries start
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	735 const int _base_off;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	736
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	737 TypeEntries(int base_off)
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	738 : _base_off(base_off), _pd(NULL) {}
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	739
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	740 void set_intptr_at(int index, intptr_t value) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	741 _pd->set_intptr_at(index, value);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	742 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	743
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	744 intptr_t intptr_at(int index) const {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	745 return _pd->intptr_at(index);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	746 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	747
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	748 public:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	749 void set_profile_data(ProfileData* pd) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	750 _pd = pd;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	751 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	752 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	753
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	754 // Type entries used for arguments passed at a call and parameters on
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	755 // method entry. 2 cells per entry: one for the type encoded as in
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	756 // TypeEntries and one initialized with the stack slot where the
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	757 // profiled object is to be found so that the interpreter can locate
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	758 // it quickly.
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	759 class TypeStackSlotEntries : public TypeEntries {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	760
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	761 private:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	762 enum {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	763 stack_slot_entry,
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	764 type_entry,
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	765 per_arg_cell_count
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	766 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	767
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	768 // offset of cell for stack slot for entry i within ProfileData object
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	769 int stack_slot_offset(int i) const {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	770 return _base_off + stack_slot_local_offset(i);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	771 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	772
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	773 protected:
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	774 const int _number_of_entries;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	775
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	776 // offset of cell for type for entry i within ProfileData object
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	777 int type_offset(int i) const {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	778 return _base_off + type_local_offset(i);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	779 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	780
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	781 public:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	782
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	783 TypeStackSlotEntries(int base_off, int nb_entries)
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	784 : TypeEntries(base_off), _number_of_entries(nb_entries) {}
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	785
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	786 static int compute_cell_count(Symbol* signature, bool include_receiver, int max);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	787
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	788 void post_initialize(Symbol* signature, bool has_receiver, bool include_receiver);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	789
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	790 // offset of cell for stack slot for entry i within this block of cells for a TypeStackSlotEntries
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	791 static int stack_slot_local_offset(int i) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	792 return i * per_arg_cell_count + stack_slot_entry;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	793 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	794
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	795 // offset of cell for type for entry i within this block of cells for a TypeStackSlotEntries
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	796 static int type_local_offset(int i) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	797 return i * per_arg_cell_count + type_entry;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	798 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	799
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	800 // stack slot for entry i
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	801 uint stack_slot(int i) const {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	802 assert(i >= 0 && i < _number_of_entries, "oob");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	803 return _pd->uint_at(stack_slot_offset(i));
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	804 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	805
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	806 // set stack slot for entry i
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	807 void set_stack_slot(int i, uint num) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	808 assert(i >= 0 && i < _number_of_entries, "oob");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	809 _pd->set_uint_at(stack_slot_offset(i), num);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	810 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	811
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	812 // type for entry i
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	813 intptr_t type(int i) const {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	814 assert(i >= 0 && i < _number_of_entries, "oob");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	815 return _pd->intptr_at(type_offset(i));
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	816 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	817
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	818 // set type for entry i
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	819 void set_type(int i, intptr_t k) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	820 assert(i >= 0 && i < _number_of_entries, "oob");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	821 _pd->set_intptr_at(type_offset(i), k);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	822 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	823
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	824 static ByteSize per_arg_size() {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	825 return in_ByteSize(per_arg_cell_count * DataLayout::cell_size);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	826 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	827
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	828 static int per_arg_count() {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	829 return per_arg_cell_count ;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	830 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	831
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	832 // GC support
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	833 void clean_weak_klass_links(BoolObjectClosure* is_alive_closure);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	834
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	835 #ifndef PRODUCT
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	836 void print_data_on(outputStream* st) const;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	837 #endif
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	838 };
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	839
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	840 // Type entry used for return from a call. A single cell to record the
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	841 // type.
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	842 class ReturnTypeEntry : public TypeEntries {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	843
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	844 private:
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	845 enum {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	846 cell_count = 1
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	847 };
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	848
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	849 public:
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	850 ReturnTypeEntry(int base_off)
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	851 : TypeEntries(base_off) {}
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	852
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	853 void post_initialize() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	854 set_type(type_none());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	855 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	856
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	857 intptr_t type() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	858 return _pd->intptr_at(_base_off);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	859 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	860
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	861 void set_type(intptr_t k) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	862 _pd->set_intptr_at(_base_off, k);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	863 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	864
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	865 static int static_cell_count() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	866 return cell_count;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	867 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	868
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	869 static ByteSize size() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	870 return in_ByteSize(cell_count * DataLayout::cell_size);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	871 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	872
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	873 ByteSize type_offset() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	874 return DataLayout::cell_offset(_base_off);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	875 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	876
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	877 // GC support
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	878 void clean_weak_klass_links(BoolObjectClosure* is_alive_closure);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	879
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	880 #ifndef PRODUCT
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	881 void print_data_on(outputStream* st) const;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	882 #endif
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	883 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	884
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	885 // Entries to collect type information at a call: contains arguments
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	886 // (TypeStackSlotEntries), a return type (ReturnTypeEntry) and a
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	887 // number of cells. Because the number of cells for the return type is
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	888 // smaller than the number of cells for the type of an arguments, the
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	889 // number of cells is used to tell how many arguments are profiled and
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	890 // whether a return value is profiled. See has_arguments() and
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	891 // has_return().
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	892 class TypeEntriesAtCall {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	893 private:
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	894 static int stack_slot_local_offset(int i) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	895 return header_cell_count() + TypeStackSlotEntries::stack_slot_local_offset(i);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	896 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	897
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	898 static int argument_type_local_offset(int i) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	899 return header_cell_count() + TypeStackSlotEntries::type_local_offset(i);;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	900 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	901
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	902 public:
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	903
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	904 static int header_cell_count() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	905 return 1;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	906 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	907
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	908 static int cell_count_local_offset() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	909 return 0;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	910 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	911
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	912 static int compute_cell_count(BytecodeStream* stream);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	913
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	914 static void initialize(DataLayout* dl, int base, int cell_count) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	915 int off = base + cell_count_local_offset();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	916 dl->set_cell_at(off, cell_count - base - header_cell_count());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	917 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	918
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	919 static bool arguments_profiling_enabled();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	920 static bool return_profiling_enabled();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	921
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	922 // Code generation support
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	923 static ByteSize cell_count_offset() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	924 return in_ByteSize(cell_count_local_offset() * DataLayout::cell_size);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	925 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	926
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	927 static ByteSize args_data_offset() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	928 return in_ByteSize(header_cell_count() * DataLayout::cell_size);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	929 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	930
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	931 static ByteSize stack_slot_offset(int i) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	932 return in_ByteSize(stack_slot_local_offset(i) * DataLayout::cell_size);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	933 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	934
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	935 static ByteSize argument_type_offset(int i) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	936 return in_ByteSize(argument_type_local_offset(i) * DataLayout::cell_size);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	937 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	938 };
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	939
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	940 // CallTypeData
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	941 //
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	942 // A CallTypeData is used to access profiling information about a non
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	943 // virtual call for which we collect type information about arguments
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	944 // and return value.
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	945 class CallTypeData : public CounterData {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	946 private:
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	947 // entries for arguments if any
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	948 TypeStackSlotEntries _args;
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	949 // entry for return type if any
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	950 ReturnTypeEntry _ret;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	951
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	952 int cell_count_global_offset() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	953 return CounterData::static_cell_count() + TypeEntriesAtCall::cell_count_local_offset();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	954 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	955
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	956 // number of cells not counting the header
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	957 int cell_count_no_header() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	958 return uint_at(cell_count_global_offset());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	959 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	960
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	961 void check_number_of_arguments(int total) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	962 assert(number_of_arguments() == total, "should be set in DataLayout::initialize");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	963 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	964
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	965 public:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	966 CallTypeData(DataLayout* layout) :
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	967 CounterData(layout),
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	968 _args(CounterData::static_cell_count()+TypeEntriesAtCall::header_cell_count(), number_of_arguments()),
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	969 _ret(cell_count() - ReturnTypeEntry::static_cell_count())
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	970 {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	971 assert(layout->tag() == DataLayout::call_type_data_tag, "wrong type");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	972 // Some compilers (VC++) don't want this passed in member initialization list
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	973 _args.set_profile_data(this);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	974 _ret.set_profile_data(this);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	975 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	976
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	977 const TypeStackSlotEntries* args() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	978 assert(has_arguments(), "no profiling of arguments");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	979 return &_args;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	980 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	981
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	982 const ReturnTypeEntry* ret() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	983 assert(has_return(), "no profiling of return value");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	984 return &_ret;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	985 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	986
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	987 virtual bool is_CallTypeData() const { return true; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	988
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	989 static int static_cell_count() {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	990 return -1;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	991 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	992
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	993 static int compute_cell_count(BytecodeStream* stream) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	994 return CounterData::static_cell_count() + TypeEntriesAtCall::compute_cell_count(stream);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	995 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	996
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	997 static void initialize(DataLayout* dl, int cell_count) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	998 TypeEntriesAtCall::initialize(dl, CounterData::static_cell_count(), cell_count);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	999 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1000
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1001 virtual void post_initialize(BytecodeStream* stream, MethodData* mdo);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1002
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1003 virtual int cell_count() const {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1004 return CounterData::static_cell_count() +
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1005 TypeEntriesAtCall::header_cell_count() +
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1006 int_at_unchecked(cell_count_global_offset());
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1007 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1008
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1009 int number_of_arguments() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1010 return cell_count_no_header() / TypeStackSlotEntries::per_arg_count();
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1011 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1012
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1013 void set_argument_type(int i, Klass* k) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1014 assert(has_arguments(), "no arguments!");
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1015 intptr_t current = _args.type(i);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1016 _args.set_type(i, TypeEntries::with_status(k, current));
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1017 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1018
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1019 void set_return_type(Klass* k) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1020 assert(has_return(), "no return!");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1021 intptr_t current = _ret.type();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1022 _ret.set_type(TypeEntries::with_status(k, current));
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1023 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1024
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1025 // An entry for a return value takes less space than an entry for an
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1026 // argument so if the number of cells exceeds the number of cells
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1027 // needed for an argument, this object contains type information for
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1028 // at least one argument.
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1029 bool has_arguments() const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1030 bool res = cell_count_no_header() >= TypeStackSlotEntries::per_arg_count();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1031 assert (!res \|\| TypeEntriesAtCall::arguments_profiling_enabled(), "no profiling of arguments");
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1032 return res;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1033 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1034
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1035 // An entry for a return value takes less space than an entry for an
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1036 // argument, so if the remainder of the number of cells divided by
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1037 // the number of cells for an argument is not null, a return value
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1038 // is profiled in this object.
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1039 bool has_return() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1040 bool res = (cell_count_no_header() % TypeStackSlotEntries::per_arg_count()) != 0;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1041 assert (!res \|\| TypeEntriesAtCall::return_profiling_enabled(), "no profiling of return values");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1042 return res;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1043 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1044
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1045 // Code generation support
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1046 static ByteSize args_data_offset() {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1047 return cell_offset(CounterData::static_cell_count()) + TypeEntriesAtCall::args_data_offset();
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1048 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1049
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1050 // GC support
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1051 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1052 if (has_arguments()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1053 _args.clean_weak_klass_links(is_alive_closure);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1054 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1055 if (has_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1056 _ret.clean_weak_klass_links(is_alive_closure);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1057 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1058 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1059
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1060 #ifndef PRODUCT
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1061 virtual void print_data_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	1062 #endif
a61af66fc99e Initial load duke parents: diff changeset	1063 };
a61af66fc99e Initial load duke parents: diff changeset	1064
a61af66fc99e Initial load duke parents: diff changeset	1065 // ReceiverTypeData
a61af66fc99e Initial load duke parents: diff changeset	1066 //
a61af66fc99e Initial load duke parents: diff changeset	1067 // A ReceiverTypeData is used to access profiling information about a
a61af66fc99e Initial load duke parents: diff changeset	1068 // dynamic type check. It consists of a counter which counts the total times
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1069 // that the check is reached, and a series of (Klass*, count) pairs
0 a61af66fc99e Initial load duke parents: diff changeset	1070 // which are used to store a type profile for the receiver of the check.
a61af66fc99e Initial load duke parents: diff changeset	1071 class ReceiverTypeData : public CounterData {
a61af66fc99e Initial load duke parents: diff changeset	1072 protected:
a61af66fc99e Initial load duke parents: diff changeset	1073 enum {
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	1074 #ifdef GRAAL
9762 57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1075 // Description of the different counters
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1076 // ReceiverTypeData for instanceof/checkcast/aastore:
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1077 // C1/C2: count is incremented on type overflow and decremented for failed type checks
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1078 // Graal: count decremented for failed type checks and nonprofiled_count is incremented on type overflow
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1079 // TODO (chaeubl): in fact, Graal should also increment the count for failed type checks to mimic the C1/C2 behavior
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1080 // VirtualCallData for invokevirtual/invokeinterface:
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1081 // C1/C2: count is incremented on type overflow
13108 d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1082 // Graal: count is incremented on type overflow, nonprofiled_count is incremented on method overflow
9762 57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1083
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1084 // Graal is interested in knowing the percentage of type checks involving a type not explicitly in the profile
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1085 nonprofiled_count_off_set = counter_cell_count,
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	1086 receiver0_offset,
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	1087 #else
0 a61af66fc99e Initial load duke parents: diff changeset	1088 receiver0_offset = counter_cell_count,
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	1089 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	1090 count0_offset,
a61af66fc99e Initial load duke parents: diff changeset	1091 receiver_type_row_cell_count = (count0_offset + 1) - receiver0_offset
a61af66fc99e Initial load duke parents: diff changeset	1092 };
a61af66fc99e Initial load duke parents: diff changeset	1093
a61af66fc99e Initial load duke parents: diff changeset	1094 public:
a61af66fc99e Initial load duke parents: diff changeset	1095 ReceiverTypeData(DataLayout* layout) : CounterData(layout) {
a61af66fc99e Initial load duke parents: diff changeset	1096 assert(layout->tag() == DataLayout::receiver_type_data_tag \|\|
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1097 layout->tag() == DataLayout::virtual_call_data_tag \|\|
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1098 layout->tag() == DataLayout::virtual_call_type_data_tag, "wrong type");
0 a61af66fc99e Initial load duke parents: diff changeset	1099 }
a61af66fc99e Initial load duke parents: diff changeset	1100
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1101 virtual bool is_ReceiverTypeData() const { return true; }
0 a61af66fc99e Initial load duke parents: diff changeset	1102
a61af66fc99e Initial load duke parents: diff changeset	1103 static int static_cell_count() {
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	1104 return counter_cell_count + (uint) TypeProfileWidth * receiver_type_row_cell_count GRAAL_ONLY(+ 1);
0 a61af66fc99e Initial load duke parents: diff changeset	1105 }
a61af66fc99e Initial load duke parents: diff changeset	1106
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1107 virtual int cell_count() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1108 return static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	1109 }
a61af66fc99e Initial load duke parents: diff changeset	1110
a61af66fc99e Initial load duke parents: diff changeset	1111 // Direct accessors
a61af66fc99e Initial load duke parents: diff changeset	1112 static uint row_limit() {
a61af66fc99e Initial load duke parents: diff changeset	1113 return TypeProfileWidth;
a61af66fc99e Initial load duke parents: diff changeset	1114 }
a61af66fc99e Initial load duke parents: diff changeset	1115 static int receiver_cell_index(uint row) {
a61af66fc99e Initial load duke parents: diff changeset	1116 return receiver0_offset + row * receiver_type_row_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	1117 }
a61af66fc99e Initial load duke parents: diff changeset	1118 static int receiver_count_cell_index(uint row) {
a61af66fc99e Initial load duke parents: diff changeset	1119 return count0_offset + row * receiver_type_row_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	1120 }
a61af66fc99e Initial load duke parents: diff changeset	1121
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1122 Klass* receiver(uint row) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1123 assert(row < row_limit(), "oob");
a61af66fc99e Initial load duke parents: diff changeset	1124
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1125 Klass* recv = (Klass*)intptr_at(receiver_cell_index(row));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1126 assert(recv == NULL \|\| recv->is_klass(), "wrong type");
0 a61af66fc99e Initial load duke parents: diff changeset	1127 return recv;
a61af66fc99e Initial load duke parents: diff changeset	1128 }
a61af66fc99e Initial load duke parents: diff changeset	1129
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1130 void set_receiver(uint row, Klass* k) {
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1131 assert((uint)row < row_limit(), "oob");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1132 set_intptr_at(receiver_cell_index(row), (uintptr_t)k);
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1133 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1134
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1135 uint receiver_count(uint row) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1136 assert(row < row_limit(), "oob");
a61af66fc99e Initial load duke parents: diff changeset	1137 return uint_at(receiver_count_cell_index(row));
a61af66fc99e Initial load duke parents: diff changeset	1138 }
a61af66fc99e Initial load duke parents: diff changeset	1139
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1140 void set_receiver_count(uint row, uint count) {
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1141 assert(row < row_limit(), "oob");
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1142 set_uint_at(receiver_count_cell_index(row), count);
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1143 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1144
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1145 void clear_row(uint row) {
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1146 assert(row < row_limit(), "oob");
1251 576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1147 // Clear total count - indicator of polymorphic call site.
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1148 // The site may look like as monomorphic after that but
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1149 // it allow to have more accurate profiling information because
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1150 // there was execution phase change since klasses were unloaded.
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1151 // If the site is still polymorphic then MDO will be updated
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1152 // to reflect it. But it could be the case that the site becomes
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1153 // only bimorphic. Then keeping total count not 0 will be wrong.
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1154 // Even if we use monomorphic (when it is not) for compilation
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1155 // we will only have trap, deoptimization and recompile again
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1156 // with updated MDO after executing method in Interpreter.
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1157 // An additional receiver will be recorded in the cleaned row
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1158 // during next call execution.
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1159 //
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1160 // Note: our profiling logic works with empty rows in any slot.
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1161 // We do sorting a profiling info (ciCallProfile) for compilation.
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1162 //
576e77447e3c 6923002: assert(false,"this call site should not be polymorphic") kvn parents: 1206 diff changeset	1163 set_count(0);
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1164 set_receiver(row, NULL);
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1165 set_receiver_count(row, 0);
9762 57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1166 #ifdef GRAAL
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1167 if (!this->is_VirtualCallData()) {
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1168 // if this is a ReceiverTypeData for Graal, the nonprofiled_count
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1169 // must also be reset (see "Description of the different counters" above)
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1170 set_nonprofiled_count(0);
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1171 }
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1172 #endif
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1173 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 196 diff changeset	1174
0 a61af66fc99e Initial load duke parents: diff changeset	1175 // Code generation support
a61af66fc99e Initial load duke parents: diff changeset	1176 static ByteSize receiver_offset(uint row) {
a61af66fc99e Initial load duke parents: diff changeset	1177 return cell_offset(receiver_cell_index(row));
a61af66fc99e Initial load duke parents: diff changeset	1178 }
a61af66fc99e Initial load duke parents: diff changeset	1179 static ByteSize receiver_count_offset(uint row) {
a61af66fc99e Initial load duke parents: diff changeset	1180 return cell_offset(receiver_count_cell_index(row));
a61af66fc99e Initial load duke parents: diff changeset	1181 }
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	1182 #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	1183 static ByteSize nonprofiled_receiver_count_offset() {
9762 57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1184 return cell_offset(nonprofiled_count_off_set);
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1185 }
13108 d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1186 uint nonprofiled_count() const {
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1187 return uint_at(nonprofiled_count_off_set);
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1188 }
9762 57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1189 void set_nonprofiled_count(uint count) {
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1190 set_uint_at(nonprofiled_count_off_set, count);
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	1191 }
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	1192 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	1193 static ByteSize receiver_type_data_size() {
a61af66fc99e Initial load duke parents: diff changeset	1194 return cell_offset(static_cell_count());
a61af66fc99e Initial load duke parents: diff changeset	1195 }
a61af66fc99e Initial load duke parents: diff changeset	1196
a61af66fc99e Initial load duke parents: diff changeset	1197 // GC support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1198 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure);
0 a61af66fc99e Initial load duke parents: diff changeset	1199
a61af66fc99e Initial load duke parents: diff changeset	1200 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1201 void print_receiver_data_on(outputStream* st) const;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1202 void print_data_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	1203 #endif
a61af66fc99e Initial load duke parents: diff changeset	1204 };
a61af66fc99e Initial load duke parents: diff changeset	1205
a61af66fc99e Initial load duke parents: diff changeset	1206 // VirtualCallData
a61af66fc99e Initial load duke parents: diff changeset	1207 //
a61af66fc99e Initial load duke parents: diff changeset	1208 // A VirtualCallData is used to access profiling information about a
a61af66fc99e Initial load duke parents: diff changeset	1209 // virtual call. For now, it has nothing more than a ReceiverTypeData.
a61af66fc99e Initial load duke parents: diff changeset	1210 class VirtualCallData : public ReceiverTypeData {
a61af66fc99e Initial load duke parents: diff changeset	1211 public:
a61af66fc99e Initial load duke parents: diff changeset	1212 VirtualCallData(DataLayout* layout) : ReceiverTypeData(layout) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1213 assert(layout->tag() == DataLayout::virtual_call_data_tag \|\|
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1214 layout->tag() == DataLayout::virtual_call_type_data_tag, "wrong type");
0 a61af66fc99e Initial load duke parents: diff changeset	1215 }
a61af66fc99e Initial load duke parents: diff changeset	1216
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1217 virtual bool is_VirtualCallData() const { return true; }
0 a61af66fc99e Initial load duke parents: diff changeset	1218
a61af66fc99e Initial load duke parents: diff changeset	1219 static int static_cell_count() {
a61af66fc99e Initial load duke parents: diff changeset	1220 // At this point we could add more profile state, e.g., for arguments.
a61af66fc99e Initial load duke parents: diff changeset	1221 // But for now it's the same size as the base record type.
9760 c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1222 return ReceiverTypeData::static_cell_count() GRAAL_ONLY(+ (uint) MethodProfileWidth * receiver_type_row_cell_count);
0 a61af66fc99e Initial load duke parents: diff changeset	1223 }
a61af66fc99e Initial load duke parents: diff changeset	1224
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1225 virtual int cell_count() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1226 return static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	1227 }
a61af66fc99e Initial load duke parents: diff changeset	1228
a61af66fc99e Initial load duke parents: diff changeset	1229 // Direct accessors
a61af66fc99e Initial load duke parents: diff changeset	1230 static ByteSize virtual_call_data_size() {
a61af66fc99e Initial load duke parents: diff changeset	1231 return cell_offset(static_cell_count());
a61af66fc99e Initial load duke parents: diff changeset	1232 }
a61af66fc99e Initial load duke parents: diff changeset	1233
9760 c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1234 #ifdef GRAAL
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1235 static ByteSize method_offset(uint row) {
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1236 return cell_offset(method_cell_index(row));
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1237 }
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1238 static ByteSize method_count_offset(uint row) {
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1239 return cell_offset(method_count_cell_index(row));
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1240 }
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1241 static int method_cell_index(uint row) {
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1242 return receiver0_offset + (row + TypeProfileWidth) * receiver_type_row_cell_count;
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1243 }
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1244 static int method_count_cell_index(uint row) {
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1245 return count0_offset + (row + TypeProfileWidth) * receiver_type_row_cell_count;
c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1246 }
9762 57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1247 static uint method_row_limit() {
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1248 return MethodProfileWidth;
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1249 }
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1250
13108 d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1251 Method* method(uint row) const {
9762 57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1252 assert(row < method_row_limit(), "oob");
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1253
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1254 Method* method = (Method*)intptr_at(method_cell_index(row));
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1255 assert(method == NULL \|\| method->is_method(), "must be");
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1256 return method;
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1257 }
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1258
13108 d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1259 uint method_count(uint row) const {
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1260 assert(row < method_row_limit(), "oob");
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1261 return uint_at(method_count_cell_index(row));
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1262 }
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1263
9762 57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1264 void set_method(uint row, Method* m) {
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1265 assert((uint)row < method_row_limit(), "oob");
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1266 set_intptr_at(method_cell_index(row), (uintptr_t)m);
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1267 }
9760 c76b43ed5089 Added infrastructure for recording invoked methods in the profiling information. Christian Haeubl <haeubl@ssw.jku.at> parents: 9088 diff changeset	1268
9762 57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1269 void set_method_count(uint row, uint count) {
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1270 assert(row < method_row_limit(), "oob");
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1271 set_uint_at(method_count_cell_index(row), count);
0 a61af66fc99e Initial load duke parents: diff changeset	1272 }
a61af66fc99e Initial load duke parents: diff changeset	1273
9762 57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1274 void clear_method_row(uint row) {
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1275 assert(row < method_row_limit(), "oob");
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1276 // Clear total count - indicator of polymorphic call site (see comment for clear_row() in ReceiverTypeData).
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1277 set_nonprofiled_count(0);
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1278 set_method(row, NULL);
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1279 set_method_count(row, 0);
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1280 }
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1281
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1282 // GC support
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1283 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure);
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1284 #endif
57e5211846f9 Added class unloading support to the method profiling infrastructure. Christian Haeubl <haeubl@ssw.jku.at> parents: 9760 diff changeset	1285
0 a61af66fc99e Initial load duke parents: diff changeset	1286 #ifndef PRODUCT
13108 d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1287 #ifdef GRAAL
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1288 void print_method_data_on(outputStream* st) const;
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13086 diff changeset	1289 #endif
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1290 void print_data_on(outputStream* st) const;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1291 #endif
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1292 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1293
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1294 // VirtualCallTypeData
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1295 //
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1296 // A VirtualCallTypeData is used to access profiling information about
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1297 // a virtual call for which we collect type information about
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1298 // arguments and return value.
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1299 class VirtualCallTypeData : public VirtualCallData {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1300 private:
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1301 // entries for arguments if any
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1302 TypeStackSlotEntries _args;
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1303 // entry for return type if any
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1304 ReturnTypeEntry _ret;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1305
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1306 int cell_count_global_offset() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1307 return VirtualCallData::static_cell_count() + TypeEntriesAtCall::cell_count_local_offset();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1308 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1309
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1310 // number of cells not counting the header
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1311 int cell_count_no_header() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1312 return uint_at(cell_count_global_offset());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1313 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1314
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1315 void check_number_of_arguments(int total) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1316 assert(number_of_arguments() == total, "should be set in DataLayout::initialize");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1317 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1318
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1319 public:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1320 VirtualCallTypeData(DataLayout* layout) :
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1321 VirtualCallData(layout),
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1322 _args(VirtualCallData::static_cell_count()+TypeEntriesAtCall::header_cell_count(), number_of_arguments()),
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1323 _ret(cell_count() - ReturnTypeEntry::static_cell_count())
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1324 {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1325 assert(layout->tag() == DataLayout::virtual_call_type_data_tag, "wrong type");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1326 // Some compilers (VC++) don't want this passed in member initialization list
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1327 _args.set_profile_data(this);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1328 _ret.set_profile_data(this);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1329 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1330
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1331 const TypeStackSlotEntries* args() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1332 assert(has_arguments(), "no profiling of arguments");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1333 return &_args;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1334 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1335
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1336 const ReturnTypeEntry* ret() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1337 assert(has_return(), "no profiling of return value");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1338 return &_ret;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1339 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1340
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1341 virtual bool is_VirtualCallTypeData() const { return true; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1342
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1343 static int static_cell_count() {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1344 return -1;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1345 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1346
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1347 static int compute_cell_count(BytecodeStream* stream) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1348 return VirtualCallData::static_cell_count() + TypeEntriesAtCall::compute_cell_count(stream);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1349 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1350
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1351 static void initialize(DataLayout* dl, int cell_count) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1352 TypeEntriesAtCall::initialize(dl, VirtualCallData::static_cell_count(), cell_count);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1353 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1354
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1355 virtual void post_initialize(BytecodeStream* stream, MethodData* mdo);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1356
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1357 virtual int cell_count() const {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1358 return VirtualCallData::static_cell_count() +
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1359 TypeEntriesAtCall::header_cell_count() +
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1360 int_at_unchecked(cell_count_global_offset());
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1361 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1362
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1363 int number_of_arguments() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1364 return cell_count_no_header() / TypeStackSlotEntries::per_arg_count();
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1365 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1366
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1367 void set_argument_type(int i, Klass* k) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1368 assert(has_arguments(), "no arguments!");
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1369 intptr_t current = _args.type(i);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1370 _args.set_type(i, TypeEntries::with_status(k, current));
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1371 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1372
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1373 void set_return_type(Klass* k) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1374 assert(has_return(), "no return!");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1375 intptr_t current = _ret.type();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1376 _ret.set_type(TypeEntries::with_status(k, current));
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1377 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1378
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1379 // An entry for a return value takes less space than an entry for an
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1380 // argument, so if the remainder of the number of cells divided by
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1381 // the number of cells for an argument is not null, a return value
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1382 // is profiled in this object.
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1383 bool has_return() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1384 bool res = (cell_count_no_header() % TypeStackSlotEntries::per_arg_count()) != 0;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1385 assert (!res \|\| TypeEntriesAtCall::return_profiling_enabled(), "no profiling of return values");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1386 return res;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1387 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1388
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1389 // An entry for a return value takes less space than an entry for an
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1390 // argument so if the number of cells exceeds the number of cells
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1391 // needed for an argument, this object contains type information for
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1392 // at least one argument.
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1393 bool has_arguments() const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1394 bool res = cell_count_no_header() >= TypeStackSlotEntries::per_arg_count();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1395 assert (!res \|\| TypeEntriesAtCall::arguments_profiling_enabled(), "no profiling of arguments");
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1396 return res;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1397 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1398
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1399 // Code generation support
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1400 static ByteSize args_data_offset() {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1401 return cell_offset(VirtualCallData::static_cell_count()) + TypeEntriesAtCall::args_data_offset();
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1402 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1403
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1404 // GC support
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1405 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1406 ReceiverTypeData::clean_weak_klass_links(is_alive_closure);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1407 if (has_arguments()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1408 _args.clean_weak_klass_links(is_alive_closure);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1409 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1410 if (has_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1411 _ret.clean_weak_klass_links(is_alive_closure);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1412 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1413 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1414
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1415 #ifndef PRODUCT
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1416 virtual void print_data_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	1417 #endif
a61af66fc99e Initial load duke parents: diff changeset	1418 };
a61af66fc99e Initial load duke parents: diff changeset	1419
a61af66fc99e Initial load duke parents: diff changeset	1420 // RetData
a61af66fc99e Initial load duke parents: diff changeset	1421 //
a61af66fc99e Initial load duke parents: diff changeset	1422 // A RetData is used to access profiling information for a ret bytecode.
a61af66fc99e Initial load duke parents: diff changeset	1423 // It is composed of a count of the number of times that the ret has
a61af66fc99e Initial load duke parents: diff changeset	1424 // been executed, followed by a series of triples of the form
a61af66fc99e Initial load duke parents: diff changeset	1425 // (bci, count, di) which count the number of times that some bci was the
a61af66fc99e Initial load duke parents: diff changeset	1426 // target of the ret and cache a corresponding data displacement.
a61af66fc99e Initial load duke parents: diff changeset	1427 class RetData : public CounterData {
a61af66fc99e Initial load duke parents: diff changeset	1428 protected:
a61af66fc99e Initial load duke parents: diff changeset	1429 enum {
a61af66fc99e Initial load duke parents: diff changeset	1430 bci0_offset = counter_cell_count,
a61af66fc99e Initial load duke parents: diff changeset	1431 count0_offset,
a61af66fc99e Initial load duke parents: diff changeset	1432 displacement0_offset,
a61af66fc99e Initial load duke parents: diff changeset	1433 ret_row_cell_count = (displacement0_offset + 1) - bci0_offset
a61af66fc99e Initial load duke parents: diff changeset	1434 };
a61af66fc99e Initial load duke parents: diff changeset	1435
a61af66fc99e Initial load duke parents: diff changeset	1436 void set_bci(uint row, int bci) {
a61af66fc99e Initial load duke parents: diff changeset	1437 assert((uint)row < row_limit(), "oob");
a61af66fc99e Initial load duke parents: diff changeset	1438 set_int_at(bci0_offset + row * ret_row_cell_count, bci);
a61af66fc99e Initial load duke parents: diff changeset	1439 }
a61af66fc99e Initial load duke parents: diff changeset	1440 void release_set_bci(uint row, int bci) {
a61af66fc99e Initial load duke parents: diff changeset	1441 assert((uint)row < row_limit(), "oob");
a61af66fc99e Initial load duke parents: diff changeset	1442 // 'release' when setting the bci acts as a valid flag for other
a61af66fc99e Initial load duke parents: diff changeset	1443 // threads wrt bci_count and bci_displacement.
a61af66fc99e Initial load duke parents: diff changeset	1444 release_set_int_at(bci0_offset + row * ret_row_cell_count, bci);
a61af66fc99e Initial load duke parents: diff changeset	1445 }
a61af66fc99e Initial load duke parents: diff changeset	1446 void set_bci_count(uint row, uint count) {
a61af66fc99e Initial load duke parents: diff changeset	1447 assert((uint)row < row_limit(), "oob");
a61af66fc99e Initial load duke parents: diff changeset	1448 set_uint_at(count0_offset + row * ret_row_cell_count, count);
a61af66fc99e Initial load duke parents: diff changeset	1449 }
a61af66fc99e Initial load duke parents: diff changeset	1450 void set_bci_displacement(uint row, int disp) {
a61af66fc99e Initial load duke parents: diff changeset	1451 set_int_at(displacement0_offset + row * ret_row_cell_count, disp);
a61af66fc99e Initial load duke parents: diff changeset	1452 }
a61af66fc99e Initial load duke parents: diff changeset	1453
a61af66fc99e Initial load duke parents: diff changeset	1454 public:
a61af66fc99e Initial load duke parents: diff changeset	1455 RetData(DataLayout* layout) : CounterData(layout) {
a61af66fc99e Initial load duke parents: diff changeset	1456 assert(layout->tag() == DataLayout::ret_data_tag, "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	1457 }
a61af66fc99e Initial load duke parents: diff changeset	1458
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1459 virtual bool is_RetData() const { return true; }
0 a61af66fc99e Initial load duke parents: diff changeset	1460
a61af66fc99e Initial load duke parents: diff changeset	1461 enum {
a61af66fc99e Initial load duke parents: diff changeset	1462 no_bci = -1 // value of bci when bci1/2 are not in use.
a61af66fc99e Initial load duke parents: diff changeset	1463 };
a61af66fc99e Initial load duke parents: diff changeset	1464
a61af66fc99e Initial load duke parents: diff changeset	1465 static int static_cell_count() {
a61af66fc99e Initial load duke parents: diff changeset	1466 return counter_cell_count + (uint) BciProfileWidth * ret_row_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	1467 }
a61af66fc99e Initial load duke parents: diff changeset	1468
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1469 virtual int cell_count() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1470 return static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	1471 }
a61af66fc99e Initial load duke parents: diff changeset	1472
a61af66fc99e Initial load duke parents: diff changeset	1473 static uint row_limit() {
a61af66fc99e Initial load duke parents: diff changeset	1474 return BciProfileWidth;
a61af66fc99e Initial load duke parents: diff changeset	1475 }
a61af66fc99e Initial load duke parents: diff changeset	1476 static int bci_cell_index(uint row) {
a61af66fc99e Initial load duke parents: diff changeset	1477 return bci0_offset + row * ret_row_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	1478 }
a61af66fc99e Initial load duke parents: diff changeset	1479 static int bci_count_cell_index(uint row) {
a61af66fc99e Initial load duke parents: diff changeset	1480 return count0_offset + row * ret_row_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	1481 }
a61af66fc99e Initial load duke parents: diff changeset	1482 static int bci_displacement_cell_index(uint row) {
a61af66fc99e Initial load duke parents: diff changeset	1483 return displacement0_offset + row * ret_row_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	1484 }
a61af66fc99e Initial load duke parents: diff changeset	1485
a61af66fc99e Initial load duke parents: diff changeset	1486 // Direct accessors
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1487 int bci(uint row) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1488 return int_at(bci_cell_index(row));
a61af66fc99e Initial load duke parents: diff changeset	1489 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1490 uint bci_count(uint row) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1491 return uint_at(bci_count_cell_index(row));
a61af66fc99e Initial load duke parents: diff changeset	1492 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1493 int bci_displacement(uint row) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1494 return int_at(bci_displacement_cell_index(row));
a61af66fc99e Initial load duke parents: diff changeset	1495 }
a61af66fc99e Initial load duke parents: diff changeset	1496
a61af66fc99e Initial load duke parents: diff changeset	1497 // Interpreter Runtime support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1498 address fixup_ret(int return_bci, MethodData* mdo);
0 a61af66fc99e Initial load duke parents: diff changeset	1499
a61af66fc99e Initial load duke parents: diff changeset	1500 // Code generation support
a61af66fc99e Initial load duke parents: diff changeset	1501 static ByteSize bci_offset(uint row) {
a61af66fc99e Initial load duke parents: diff changeset	1502 return cell_offset(bci_cell_index(row));
a61af66fc99e Initial load duke parents: diff changeset	1503 }
a61af66fc99e Initial load duke parents: diff changeset	1504 static ByteSize bci_count_offset(uint row) {
a61af66fc99e Initial load duke parents: diff changeset	1505 return cell_offset(bci_count_cell_index(row));
a61af66fc99e Initial load duke parents: diff changeset	1506 }
a61af66fc99e Initial load duke parents: diff changeset	1507 static ByteSize bci_displacement_offset(uint row) {
a61af66fc99e Initial load duke parents: diff changeset	1508 return cell_offset(bci_displacement_cell_index(row));
a61af66fc99e Initial load duke parents: diff changeset	1509 }
a61af66fc99e Initial load duke parents: diff changeset	1510
a61af66fc99e Initial load duke parents: diff changeset	1511 // Specific initialization.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1512 void post_initialize(BytecodeStream* stream, MethodData* mdo);
0 a61af66fc99e Initial load duke parents: diff changeset	1513
a61af66fc99e Initial load duke parents: diff changeset	1514 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1515 void print_data_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	1516 #endif
a61af66fc99e Initial load duke parents: diff changeset	1517 };
a61af66fc99e Initial load duke parents: diff changeset	1518
a61af66fc99e Initial load duke parents: diff changeset	1519 // BranchData
a61af66fc99e Initial load duke parents: diff changeset	1520 //
a61af66fc99e Initial load duke parents: diff changeset	1521 // A BranchData is used to access profiling data for a two-way branch.
a61af66fc99e Initial load duke parents: diff changeset	1522 // It consists of taken and not_taken counts as well as a data displacement
a61af66fc99e Initial load duke parents: diff changeset	1523 // for the taken case.
a61af66fc99e Initial load duke parents: diff changeset	1524 class BranchData : public JumpData {
a61af66fc99e Initial load duke parents: diff changeset	1525 protected:
a61af66fc99e Initial load duke parents: diff changeset	1526 enum {
a61af66fc99e Initial load duke parents: diff changeset	1527 not_taken_off_set = jump_cell_count,
a61af66fc99e Initial load duke parents: diff changeset	1528 branch_cell_count
a61af66fc99e Initial load duke parents: diff changeset	1529 };
a61af66fc99e Initial load duke parents: diff changeset	1530
a61af66fc99e Initial load duke parents: diff changeset	1531 void set_displacement(int displacement) {
a61af66fc99e Initial load duke parents: diff changeset	1532 set_int_at(displacement_off_set, displacement);
a61af66fc99e Initial load duke parents: diff changeset	1533 }
a61af66fc99e Initial load duke parents: diff changeset	1534
a61af66fc99e Initial load duke parents: diff changeset	1535 public:
a61af66fc99e Initial load duke parents: diff changeset	1536 BranchData(DataLayout* layout) : JumpData(layout) {
a61af66fc99e Initial load duke parents: diff changeset	1537 assert(layout->tag() == DataLayout::branch_data_tag, "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	1538 }
a61af66fc99e Initial load duke parents: diff changeset	1539
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1540 virtual bool is_BranchData() const { return true; }
0 a61af66fc99e Initial load duke parents: diff changeset	1541
a61af66fc99e Initial load duke parents: diff changeset	1542 static int static_cell_count() {
a61af66fc99e Initial load duke parents: diff changeset	1543 return branch_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	1544 }
a61af66fc99e Initial load duke parents: diff changeset	1545
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1546 virtual int cell_count() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1547 return static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	1548 }
a61af66fc99e Initial load duke parents: diff changeset	1549
a61af66fc99e Initial load duke parents: diff changeset	1550 // Direct accessor
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1551 uint not_taken() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1552 return uint_at(not_taken_off_set);
a61af66fc99e Initial load duke parents: diff changeset	1553 }
a61af66fc99e Initial load duke parents: diff changeset	1554
3905 c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3345 diff changeset	1555 void set_not_taken(uint cnt) {
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3345 diff changeset	1556 set_uint_at(not_taken_off_set, cnt);
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3345 diff changeset	1557 }
c26de9aef2ed 7071307: MethodHandle bimorphic inlining should consider the frequency never parents: 3345 diff changeset	1558
0 a61af66fc99e Initial load duke parents: diff changeset	1559 uint inc_not_taken() {
a61af66fc99e Initial load duke parents: diff changeset	1560 uint cnt = not_taken() + 1;
a61af66fc99e Initial load duke parents: diff changeset	1561 // Did we wrap? Will compiler screw us??
a61af66fc99e Initial load duke parents: diff changeset	1562 if (cnt == 0) cnt--;
a61af66fc99e Initial load duke parents: diff changeset	1563 set_uint_at(not_taken_off_set, cnt);
a61af66fc99e Initial load duke parents: diff changeset	1564 return cnt;
a61af66fc99e Initial load duke parents: diff changeset	1565 }
a61af66fc99e Initial load duke parents: diff changeset	1566
a61af66fc99e Initial load duke parents: diff changeset	1567 // Code generation support
a61af66fc99e Initial load duke parents: diff changeset	1568 static ByteSize not_taken_offset() {
a61af66fc99e Initial load duke parents: diff changeset	1569 return cell_offset(not_taken_off_set);
a61af66fc99e Initial load duke parents: diff changeset	1570 }
a61af66fc99e Initial load duke parents: diff changeset	1571 static ByteSize branch_data_size() {
a61af66fc99e Initial load duke parents: diff changeset	1572 return cell_offset(branch_cell_count);
a61af66fc99e Initial load duke parents: diff changeset	1573 }
a61af66fc99e Initial load duke parents: diff changeset	1574
a61af66fc99e Initial load duke parents: diff changeset	1575 // Specific initialization.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1576 void post_initialize(BytecodeStream* stream, MethodData* mdo);
0 a61af66fc99e Initial load duke parents: diff changeset	1577
a61af66fc99e Initial load duke parents: diff changeset	1578 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1579 void print_data_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	1580 #endif
a61af66fc99e Initial load duke parents: diff changeset	1581 };
a61af66fc99e Initial load duke parents: diff changeset	1582
a61af66fc99e Initial load duke parents: diff changeset	1583 // ArrayData
a61af66fc99e Initial load duke parents: diff changeset	1584 //
a61af66fc99e Initial load duke parents: diff changeset	1585 // A ArrayData is a base class for accessing profiling data which does
a61af66fc99e Initial load duke parents: diff changeset	1586 // not have a statically known size. It consists of an array length
a61af66fc99e Initial load duke parents: diff changeset	1587 // and an array start.
a61af66fc99e Initial load duke parents: diff changeset	1588 class ArrayData : public ProfileData {
a61af66fc99e Initial load duke parents: diff changeset	1589 protected:
a61af66fc99e Initial load duke parents: diff changeset	1590 friend class DataLayout;
a61af66fc99e Initial load duke parents: diff changeset	1591
a61af66fc99e Initial load duke parents: diff changeset	1592 enum {
a61af66fc99e Initial load duke parents: diff changeset	1593 array_len_off_set,
a61af66fc99e Initial load duke parents: diff changeset	1594 array_start_off_set
a61af66fc99e Initial load duke parents: diff changeset	1595 };
a61af66fc99e Initial load duke parents: diff changeset	1596
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1597 uint array_uint_at(int index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1598 int aindex = index + array_start_off_set;
a61af66fc99e Initial load duke parents: diff changeset	1599 return uint_at(aindex);
a61af66fc99e Initial load duke parents: diff changeset	1600 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1601 int array_int_at(int index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1602 int aindex = index + array_start_off_set;
a61af66fc99e Initial load duke parents: diff changeset	1603 return int_at(aindex);
a61af66fc99e Initial load duke parents: diff changeset	1604 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1605 oop array_oop_at(int index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1606 int aindex = index + array_start_off_set;
a61af66fc99e Initial load duke parents: diff changeset	1607 return oop_at(aindex);
a61af66fc99e Initial load duke parents: diff changeset	1608 }
a61af66fc99e Initial load duke parents: diff changeset	1609 void array_set_int_at(int index, int value) {
a61af66fc99e Initial load duke parents: diff changeset	1610 int aindex = index + array_start_off_set;
a61af66fc99e Initial load duke parents: diff changeset	1611 set_int_at(aindex, value);
a61af66fc99e Initial load duke parents: diff changeset	1612 }
a61af66fc99e Initial load duke parents: diff changeset	1613
a61af66fc99e Initial load duke parents: diff changeset	1614 // Code generation support for subclasses.
a61af66fc99e Initial load duke parents: diff changeset	1615 static ByteSize array_element_offset(int index) {
a61af66fc99e Initial load duke parents: diff changeset	1616 return cell_offset(array_start_off_set + index);
a61af66fc99e Initial load duke parents: diff changeset	1617 }
a61af66fc99e Initial load duke parents: diff changeset	1618
a61af66fc99e Initial load duke parents: diff changeset	1619 public:
a61af66fc99e Initial load duke parents: diff changeset	1620 ArrayData(DataLayout* layout) : ProfileData(layout) {}
a61af66fc99e Initial load duke parents: diff changeset	1621
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1622 virtual bool is_ArrayData() const { return true; }
0 a61af66fc99e Initial load duke parents: diff changeset	1623
a61af66fc99e Initial load duke parents: diff changeset	1624 static int static_cell_count() {
a61af66fc99e Initial load duke parents: diff changeset	1625 return -1;
a61af66fc99e Initial load duke parents: diff changeset	1626 }
a61af66fc99e Initial load duke parents: diff changeset	1627
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1628 int array_len() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1629 return int_at_unchecked(array_len_off_set);
a61af66fc99e Initial load duke parents: diff changeset	1630 }
a61af66fc99e Initial load duke parents: diff changeset	1631
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1632 virtual int cell_count() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1633 return array_len() + 1;
a61af66fc99e Initial load duke parents: diff changeset	1634 }
a61af66fc99e Initial load duke parents: diff changeset	1635
a61af66fc99e Initial load duke parents: diff changeset	1636 // Code generation support
a61af66fc99e Initial load duke parents: diff changeset	1637 static ByteSize array_len_offset() {
a61af66fc99e Initial load duke parents: diff changeset	1638 return cell_offset(array_len_off_set);
a61af66fc99e Initial load duke parents: diff changeset	1639 }
a61af66fc99e Initial load duke parents: diff changeset	1640 static ByteSize array_start_offset() {
a61af66fc99e Initial load duke parents: diff changeset	1641 return cell_offset(array_start_off_set);
a61af66fc99e Initial load duke parents: diff changeset	1642 }
a61af66fc99e Initial load duke parents: diff changeset	1643 };
a61af66fc99e Initial load duke parents: diff changeset	1644
a61af66fc99e Initial load duke parents: diff changeset	1645 // MultiBranchData
a61af66fc99e Initial load duke parents: diff changeset	1646 //
a61af66fc99e Initial load duke parents: diff changeset	1647 // A MultiBranchData is used to access profiling information for
a61af66fc99e Initial load duke parents: diff changeset	1648 // a multi-way branch (*switch bytecodes). It consists of a series
a61af66fc99e Initial load duke parents: diff changeset	1649 // of (count, displacement) pairs, which count the number of times each
a61af66fc99e Initial load duke parents: diff changeset	1650 // case was taken and specify the data displacment for each branch target.
a61af66fc99e Initial load duke parents: diff changeset	1651 class MultiBranchData : public ArrayData {
a61af66fc99e Initial load duke parents: diff changeset	1652 protected:
a61af66fc99e Initial load duke parents: diff changeset	1653 enum {
a61af66fc99e Initial load duke parents: diff changeset	1654 default_count_off_set,
a61af66fc99e Initial load duke parents: diff changeset	1655 default_disaplacement_off_set,
a61af66fc99e Initial load duke parents: diff changeset	1656 case_array_start
a61af66fc99e Initial load duke parents: diff changeset	1657 };
a61af66fc99e Initial load duke parents: diff changeset	1658 enum {
a61af66fc99e Initial load duke parents: diff changeset	1659 relative_count_off_set,
a61af66fc99e Initial load duke parents: diff changeset	1660 relative_displacement_off_set,
a61af66fc99e Initial load duke parents: diff changeset	1661 per_case_cell_count
a61af66fc99e Initial load duke parents: diff changeset	1662 };
a61af66fc99e Initial load duke parents: diff changeset	1663
a61af66fc99e Initial load duke parents: diff changeset	1664 void set_default_displacement(int displacement) {
a61af66fc99e Initial load duke parents: diff changeset	1665 array_set_int_at(default_disaplacement_off_set, displacement);
a61af66fc99e Initial load duke parents: diff changeset	1666 }
a61af66fc99e Initial load duke parents: diff changeset	1667 void set_displacement_at(int index, int displacement) {
a61af66fc99e Initial load duke parents: diff changeset	1668 array_set_int_at(case_array_start +
a61af66fc99e Initial load duke parents: diff changeset	1669 index * per_case_cell_count +
a61af66fc99e Initial load duke parents: diff changeset	1670 relative_displacement_off_set,
a61af66fc99e Initial load duke parents: diff changeset	1671 displacement);
a61af66fc99e Initial load duke parents: diff changeset	1672 }
a61af66fc99e Initial load duke parents: diff changeset	1673
a61af66fc99e Initial load duke parents: diff changeset	1674 public:
a61af66fc99e Initial load duke parents: diff changeset	1675 MultiBranchData(DataLayout* layout) : ArrayData(layout) {
a61af66fc99e Initial load duke parents: diff changeset	1676 assert(layout->tag() == DataLayout::multi_branch_data_tag, "wrong type");
a61af66fc99e Initial load duke parents: diff changeset	1677 }
a61af66fc99e Initial load duke parents: diff changeset	1678
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1679 virtual bool is_MultiBranchData() const { return true; }
0 a61af66fc99e Initial load duke parents: diff changeset	1680
a61af66fc99e Initial load duke parents: diff changeset	1681 static int compute_cell_count(BytecodeStream* stream);
a61af66fc99e Initial load duke parents: diff changeset	1682
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1683 int number_of_cases() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1684 int alen = array_len() - 2; // get rid of default case here.
a61af66fc99e Initial load duke parents: diff changeset	1685 assert(alen % per_case_cell_count == 0, "must be even");
a61af66fc99e Initial load duke parents: diff changeset	1686 return (alen / per_case_cell_count);
a61af66fc99e Initial load duke parents: diff changeset	1687 }
a61af66fc99e Initial load duke parents: diff changeset	1688
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1689 uint default_count() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1690 return array_uint_at(default_count_off_set);
a61af66fc99e Initial load duke parents: diff changeset	1691 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1692 int default_displacement() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1693 return array_int_at(default_disaplacement_off_set);
a61af66fc99e Initial load duke parents: diff changeset	1694 }
a61af66fc99e Initial load duke parents: diff changeset	1695
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1696 uint count_at(int index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1697 return array_uint_at(case_array_start +
a61af66fc99e Initial load duke parents: diff changeset	1698 index * per_case_cell_count +
a61af66fc99e Initial load duke parents: diff changeset	1699 relative_count_off_set);
a61af66fc99e Initial load duke parents: diff changeset	1700 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1701 int displacement_at(int index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1702 return array_int_at(case_array_start +
a61af66fc99e Initial load duke parents: diff changeset	1703 index * per_case_cell_count +
a61af66fc99e Initial load duke parents: diff changeset	1704 relative_displacement_off_set);
a61af66fc99e Initial load duke parents: diff changeset	1705 }
a61af66fc99e Initial load duke parents: diff changeset	1706
a61af66fc99e Initial load duke parents: diff changeset	1707 // Code generation support
a61af66fc99e Initial load duke parents: diff changeset	1708 static ByteSize default_count_offset() {
a61af66fc99e Initial load duke parents: diff changeset	1709 return array_element_offset(default_count_off_set);
a61af66fc99e Initial load duke parents: diff changeset	1710 }
a61af66fc99e Initial load duke parents: diff changeset	1711 static ByteSize default_displacement_offset() {
a61af66fc99e Initial load duke parents: diff changeset	1712 return array_element_offset(default_disaplacement_off_set);
a61af66fc99e Initial load duke parents: diff changeset	1713 }
a61af66fc99e Initial load duke parents: diff changeset	1714 static ByteSize case_count_offset(int index) {
a61af66fc99e Initial load duke parents: diff changeset	1715 return case_array_offset() +
a61af66fc99e Initial load duke parents: diff changeset	1716 (per_case_size() * index) +
a61af66fc99e Initial load duke parents: diff changeset	1717 relative_count_offset();
a61af66fc99e Initial load duke parents: diff changeset	1718 }
a61af66fc99e Initial load duke parents: diff changeset	1719 static ByteSize case_array_offset() {
a61af66fc99e Initial load duke parents: diff changeset	1720 return array_element_offset(case_array_start);
a61af66fc99e Initial load duke parents: diff changeset	1721 }
a61af66fc99e Initial load duke parents: diff changeset	1722 static ByteSize per_case_size() {
a61af66fc99e Initial load duke parents: diff changeset	1723 return in_ByteSize(per_case_cell_count) * cell_size;
a61af66fc99e Initial load duke parents: diff changeset	1724 }
a61af66fc99e Initial load duke parents: diff changeset	1725 static ByteSize relative_count_offset() {
a61af66fc99e Initial load duke parents: diff changeset	1726 return in_ByteSize(relative_count_off_set) * cell_size;
a61af66fc99e Initial load duke parents: diff changeset	1727 }
a61af66fc99e Initial load duke parents: diff changeset	1728 static ByteSize relative_displacement_offset() {
a61af66fc99e Initial load duke parents: diff changeset	1729 return in_ByteSize(relative_displacement_off_set) * cell_size;
a61af66fc99e Initial load duke parents: diff changeset	1730 }
a61af66fc99e Initial load duke parents: diff changeset	1731
a61af66fc99e Initial load duke parents: diff changeset	1732 // Specific initialization.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1733 void post_initialize(BytecodeStream* stream, MethodData* mdo);
0 a61af66fc99e Initial load duke parents: diff changeset	1734
a61af66fc99e Initial load duke parents: diff changeset	1735 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1736 void print_data_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	1737 #endif
a61af66fc99e Initial load duke parents: diff changeset	1738 };
a61af66fc99e Initial load duke parents: diff changeset	1739
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1740 class ArgInfoData : public ArrayData {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1741
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1742 public:
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1743 ArgInfoData(DataLayout* layout) : ArrayData(layout) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1744 assert(layout->tag() == DataLayout::arg_info_data_tag, "wrong type");
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1745 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1746
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1747 virtual bool is_ArgInfoData() const { return true; }
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1748
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1749
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1750 int number_of_args() const {
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1751 return array_len();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1752 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1753
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1754 uint arg_modified(int arg) const {
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1755 return array_uint_at(arg);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1756 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1757
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1758 void set_arg_modified(int arg, uint val) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1759 array_set_int_at(arg, val);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1760 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1761
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1762 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	1763 void print_data_on(outputStream* st) const;
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1764 #endif
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1765 };
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1766
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1767 // ParametersTypeData
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1768 //
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1769 // A ParametersTypeData is used to access profiling information about
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1770 // types of parameters to a method
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1771 class ParametersTypeData : public ArrayData {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1772
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1773 private:
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1774 TypeStackSlotEntries _parameters;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1775
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1776 static int stack_slot_local_offset(int i) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1777 assert_profiling_enabled();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1778 return array_start_off_set + TypeStackSlotEntries::stack_slot_local_offset(i);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1779 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1780
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1781 static int type_local_offset(int i) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1782 assert_profiling_enabled();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1783 return array_start_off_set + TypeStackSlotEntries::type_local_offset(i);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1784 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1785
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1786 static bool profiling_enabled();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1787 static void assert_profiling_enabled() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1788 assert(profiling_enabled(), "method parameters profiling should be on");
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1789 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1790
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1791 public:
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1792 ParametersTypeData(DataLayout* layout) : ArrayData(layout), _parameters(1, number_of_parameters()) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1793 assert(layout->tag() == DataLayout::parameters_type_data_tag, "wrong type");
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1794 // Some compilers (VC++) don't want this passed in member initialization list
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1795 _parameters.set_profile_data(this);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1796 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1797
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1798 static int compute_cell_count(Method* m);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1799
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1800 virtual bool is_ParametersTypeData() const { return true; }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1801
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1802 virtual void post_initialize(BytecodeStream* stream, MethodData* mdo);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1803
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1804 int number_of_parameters() const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1805 return array_len() / TypeStackSlotEntries::per_arg_count();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1806 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1807
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1808 const TypeStackSlotEntries* parameters() const { return &_parameters; }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1809
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1810 uint stack_slot(int i) const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1811 return _parameters.stack_slot(i);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1812 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1813
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1814 void set_type(int i, Klass* k) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1815 intptr_t current = _parameters.type(i);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1816 _parameters.set_type(i, TypeEntries::with_status((intptr_t)k, current));
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1817 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1818
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1819 virtual void clean_weak_klass_links(BoolObjectClosure* is_alive_closure) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1820 _parameters.clean_weak_klass_links(is_alive_closure);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1821 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1822
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1823 #ifndef PRODUCT
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1824 virtual void print_data_on(outputStream* st) const;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1825 #endif
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1826
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1827 static ByteSize stack_slot_offset(int i) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1828 return cell_offset(stack_slot_local_offset(i));
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1829 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1830
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1831 static ByteSize type_offset(int i) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1832 return cell_offset(type_local_offset(i));
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1833 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1834 };
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1835
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1836 // MethodData*
0 a61af66fc99e Initial load duke parents: diff changeset	1837 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1838 // A MethodData* holds information which has been collected about
0 a61af66fc99e Initial load duke parents: diff changeset	1839 // a method. Its layout looks like this:
a61af66fc99e Initial load duke parents: diff changeset	1840 //
a61af66fc99e Initial load duke parents: diff changeset	1841 // -----------------------------
a61af66fc99e Initial load duke parents: diff changeset	1842 // \| header \|
a61af66fc99e Initial load duke parents: diff changeset	1843 // \| klass \|
a61af66fc99e Initial load duke parents: diff changeset	1844 // -----------------------------
a61af66fc99e Initial load duke parents: diff changeset	1845 // \| method \|
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1846 // \| size of the MethodData* \|
0 a61af66fc99e Initial load duke parents: diff changeset	1847 // -----------------------------
a61af66fc99e Initial load duke parents: diff changeset	1848 // \| Data entries... \|
a61af66fc99e Initial load duke parents: diff changeset	1849 // \| (variable size) \|
a61af66fc99e Initial load duke parents: diff changeset	1850 // \| \|
a61af66fc99e Initial load duke parents: diff changeset	1851 // . .
a61af66fc99e Initial load duke parents: diff changeset	1852 // . .
a61af66fc99e Initial load duke parents: diff changeset	1853 // . .
a61af66fc99e Initial load duke parents: diff changeset	1854 // \| \|
a61af66fc99e Initial load duke parents: diff changeset	1855 // -----------------------------
a61af66fc99e Initial load duke parents: diff changeset	1856 //
a61af66fc99e Initial load duke parents: diff changeset	1857 // The data entry area is a heterogeneous array of DataLayouts. Each
a61af66fc99e Initial load duke parents: diff changeset	1858 // DataLayout in the array corresponds to a specific bytecode in the
a61af66fc99e Initial load duke parents: diff changeset	1859 // method. The entries in the array are sorted by the corresponding
a61af66fc99e Initial load duke parents: diff changeset	1860 // bytecode. Access to the data is via resource-allocated ProfileData,
a61af66fc99e Initial load duke parents: diff changeset	1861 // which point to the underlying blocks of DataLayout structures.
a61af66fc99e Initial load duke parents: diff changeset	1862 //
a61af66fc99e Initial load duke parents: diff changeset	1863 // During interpretation, if profiling in enabled, the interpreter
a61af66fc99e Initial load duke parents: diff changeset	1864 // maintains a method data pointer (mdp), which points at the entry
a61af66fc99e Initial load duke parents: diff changeset	1865 // in the array corresponding to the current bci. In the course of
a61af66fc99e Initial load duke parents: diff changeset	1866 // intepretation, when a bytecode is encountered that has profile data
a61af66fc99e Initial load duke parents: diff changeset	1867 // associated with it, the entry pointed to by mdp is updated, then the
a61af66fc99e Initial load duke parents: diff changeset	1868 // mdp is adjusted to point to the next appropriate DataLayout. If mdp
a61af66fc99e Initial load duke parents: diff changeset	1869 // is NULL to begin with, the interpreter assumes that the current method
a61af66fc99e Initial load duke parents: diff changeset	1870 // is not (yet) being profiled.
a61af66fc99e Initial load duke parents: diff changeset	1871 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1872 // In MethodData* parlance, "dp" is a "data pointer", the actual address
0 a61af66fc99e Initial load duke parents: diff changeset	1873 // of a DataLayout element. A "di" is a "data index", the offset in bytes
a61af66fc99e Initial load duke parents: diff changeset	1874 // from the base of the data entry array. A "displacement" is the byte offset
a61af66fc99e Initial load duke parents: diff changeset	1875 // in certain ProfileData objects that indicate the amount the mdp must be
a61af66fc99e Initial load duke parents: diff changeset	1876 // adjusted in the event of a change in control flow.
a61af66fc99e Initial load duke parents: diff changeset	1877 //
a61af66fc99e Initial load duke parents: diff changeset	1878
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1879 class MethodData : public Metadata {
0 a61af66fc99e Initial load duke parents: diff changeset	1880 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	1881 private:
a61af66fc99e Initial load duke parents: diff changeset	1882 friend class ProfileData;
a61af66fc99e Initial load duke parents: diff changeset	1883
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1884 // Back pointer to the Method*
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1885 Method* _method;
0 a61af66fc99e Initial load duke parents: diff changeset	1886
a61af66fc99e Initial load duke parents: diff changeset	1887 // Size of this oop in bytes
a61af66fc99e Initial load duke parents: diff changeset	1888 int _size;
a61af66fc99e Initial load duke parents: diff changeset	1889
a61af66fc99e Initial load duke parents: diff changeset	1890 // Cached hint for bci_to_dp and bci_to_data
a61af66fc99e Initial load duke parents: diff changeset	1891 int _hint_di;
a61af66fc99e Initial load duke parents: diff changeset	1892
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1893 MethodData(methodHandle method, int size, TRAPS);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1894 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1895 static MethodData* allocate(ClassLoaderData* loader_data, methodHandle method, TRAPS);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1896 MethodData() {}; // For ciMethodData
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1897
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1898 bool is_methodData() const volatile { return true; }
13181 389d40d7d99f fixed bug in MethodData and added assertion that precomputed size == initialized size Doug Simon <doug.simon@oracle.com> parents: 13108 diff changeset	1899 void initialize(bool for_reprofile = false);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1900
0 a61af66fc99e Initial load duke parents: diff changeset	1901 // Whole-method sticky bits and flags
a61af66fc99e Initial load duke parents: diff changeset	1902 enum {
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2333 diff changeset	1903 _trap_hist_limit = 17, // decoupled from Deoptimization::Reason_LIMIT
0 a61af66fc99e Initial load duke parents: diff changeset	1904 _trap_hist_mask = max_jubyte,
a61af66fc99e Initial load duke parents: diff changeset	1905 _extra_data_count = 4 // extra DataLayout headers, for trap history
a61af66fc99e Initial load duke parents: diff changeset	1906 }; // Public flag values
a61af66fc99e Initial load duke parents: diff changeset	1907 private:
a61af66fc99e Initial load duke parents: diff changeset	1908 uint _nof_decompiles; // count of all nmethod removals
a61af66fc99e Initial load duke parents: diff changeset	1909 uint _nof_overflow_recompiles; // recompile count, excluding recomp. bits
a61af66fc99e Initial load duke parents: diff changeset	1910 uint _nof_overflow_traps; // trap count, excluding _trap_hist
a61af66fc99e Initial load duke parents: diff changeset	1911 union {
a61af66fc99e Initial load duke parents: diff changeset	1912 intptr_t _align;
a61af66fc99e Initial load duke parents: diff changeset	1913 u1 _array[_trap_hist_limit];
a61af66fc99e Initial load duke parents: diff changeset	1914 } _trap_hist;
a61af66fc99e Initial load duke parents: diff changeset	1915
a61af66fc99e Initial load duke parents: diff changeset	1916 // Support for interprocedural escape analysis, from Thomas Kotzmann.
a61af66fc99e Initial load duke parents: diff changeset	1917 intx _eflags; // flags on escape information
a61af66fc99e Initial load duke parents: diff changeset	1918 intx _arg_local; // bit set of non-escaping arguments
a61af66fc99e Initial load duke parents: diff changeset	1919 intx _arg_stack; // bit set of stack-allocatable arguments
a61af66fc99e Initial load duke parents: diff changeset	1920 intx _arg_returned; // bit set of returned arguments
a61af66fc99e Initial load duke parents: diff changeset	1921
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1922 int _creation_mileage; // method mileage at MDO creation
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1923
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1924 // How many invocations has this MDO seen?
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1925 // These counters are used to determine the exact age of MDO.
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1926 // We need those because in tiered a method can be concurrently
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1927 // executed at different levels.
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1928 InvocationCounter _invocation_counter;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1929 // Same for backedges.
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1930 InvocationCounter _backedge_counter;
2252 72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	1931 // Counter values at the time profiling started.
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	1932 int _invocation_counter_start;
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	1933 int _backedge_counter_start;
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1934 // Number of loops and blocks is computed when compiling the first
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1935 // time with C1. It is used to determine if method is trivial.
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1936 short _num_loops;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1937 short _num_blocks;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1938 // Highest compile level this method has ever seen.
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1939 u1 _highest_comp_level;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1940 // Same for OSR level
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1941 u1 _highest_osr_comp_level;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1942 // Does this method contain anything worth profiling?
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1943 bool _would_profile;
0 a61af66fc99e Initial load duke parents: diff changeset	1944
a61af66fc99e Initial load duke parents: diff changeset	1945 // Size of _data array in bytes. (Excludes header and extra_data fields.)
a61af66fc99e Initial load duke parents: diff changeset	1946 int _data_size;
a61af66fc99e Initial load duke parents: diff changeset	1947
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1948 // data index for the area dedicated to parameters. -1 if no
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1949 // parameter profiling.
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1950 int _parameters_type_data_di;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1951
0 a61af66fc99e Initial load duke parents: diff changeset	1952 // Beginning of the data entries
a61af66fc99e Initial load duke parents: diff changeset	1953 intptr_t _data[1];
a61af66fc99e Initial load duke parents: diff changeset	1954
a61af66fc99e Initial load duke parents: diff changeset	1955 // Helper for size computation
a61af66fc99e Initial load duke parents: diff changeset	1956 static int compute_data_size(BytecodeStream* stream);
a61af66fc99e Initial load duke parents: diff changeset	1957 static int bytecode_cell_count(Bytecodes::Code code);
a61af66fc99e Initial load duke parents: diff changeset	1958 enum { no_profile_data = -1, variable_cell_count = -2 };
a61af66fc99e Initial load duke parents: diff changeset	1959
a61af66fc99e Initial load duke parents: diff changeset	1960 // Helper for initialization
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1961 DataLayout* data_layout_at(int data_index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1962 assert(data_index % sizeof(intptr_t) == 0, "unaligned");
a61af66fc99e Initial load duke parents: diff changeset	1963 return (DataLayout*) (((address)_data) + data_index);
a61af66fc99e Initial load duke parents: diff changeset	1964 }
a61af66fc99e Initial load duke parents: diff changeset	1965
a61af66fc99e Initial load duke parents: diff changeset	1966 // Initialize an individual data segment. Returns the size of
a61af66fc99e Initial load duke parents: diff changeset	1967 // the segment in bytes.
a61af66fc99e Initial load duke parents: diff changeset	1968 int initialize_data(BytecodeStream* stream, int data_index);
a61af66fc99e Initial load duke parents: diff changeset	1969
a61af66fc99e Initial load duke parents: diff changeset	1970 // Helper for data_at
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1971 DataLayout* limit_data_position() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1972 return (DataLayout*)((address)data_base() + _data_size);
a61af66fc99e Initial load duke parents: diff changeset	1973 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1974 bool out_of_bounds(int data_index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1975 return data_index >= data_size();
a61af66fc99e Initial load duke parents: diff changeset	1976 }
a61af66fc99e Initial load duke parents: diff changeset	1977
a61af66fc99e Initial load duke parents: diff changeset	1978 // Give each of the data entries a chance to perform specific
a61af66fc99e Initial load duke parents: diff changeset	1979 // data initialization.
a61af66fc99e Initial load duke parents: diff changeset	1980 void post_initialize(BytecodeStream* stream);
a61af66fc99e Initial load duke parents: diff changeset	1981
a61af66fc99e Initial load duke parents: diff changeset	1982 // hint accessors
a61af66fc99e Initial load duke parents: diff changeset	1983 int hint_di() const { return _hint_di; }
a61af66fc99e Initial load duke parents: diff changeset	1984 void set_hint_di(int di) {
a61af66fc99e Initial load duke parents: diff changeset	1985 assert(!out_of_bounds(di), "hint_di out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	1986 _hint_di = di;
a61af66fc99e Initial load duke parents: diff changeset	1987 }
a61af66fc99e Initial load duke parents: diff changeset	1988 ProfileData* data_before(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	1989 // avoid SEGV on this edge case
a61af66fc99e Initial load duke parents: diff changeset	1990 if (data_size() == 0)
a61af66fc99e Initial load duke parents: diff changeset	1991 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1992 int hint = hint_di();
a61af66fc99e Initial load duke parents: diff changeset	1993 if (data_layout_at(hint)->bci() <= bci)
a61af66fc99e Initial load duke parents: diff changeset	1994 return data_at(hint);
a61af66fc99e Initial load duke parents: diff changeset	1995 return first_data();
a61af66fc99e Initial load duke parents: diff changeset	1996 }
a61af66fc99e Initial load duke parents: diff changeset	1997
a61af66fc99e Initial load duke parents: diff changeset	1998 // What is the index of the first data entry?
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	1999 int first_di() const { return 0; }
0 a61af66fc99e Initial load duke parents: diff changeset	2000
a61af66fc99e Initial load duke parents: diff changeset	2001 // Find or create an extra ProfileData:
a61af66fc99e Initial load duke parents: diff changeset	2002 ProfileData* bci_to_extra_data(int bci, bool create_if_missing);
a61af66fc99e Initial load duke parents: diff changeset	2003
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	2004 // return the argument info cell
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	2005 ArgInfoData *arg_info();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	2006
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2007 enum {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2008 no_type_profile = 0,
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2009 type_profile_jsr292 = 1,
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2010 type_profile_all = 2
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2011 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2012
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2013 static bool profile_jsr292(methodHandle m, int bci);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2014 static int profile_arguments_flag();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2015 static bool profile_arguments_jsr292_only();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2016 static bool profile_all_arguments();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2017 static bool profile_arguments_for_invoke(methodHandle m, int bci);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	2018 static int profile_return_flag();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	2019 static bool profile_all_return();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	2020 static bool profile_return_for_invoke(methodHandle m, int bci);
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2021 static int profile_parameters_flag();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2022 static bool profile_parameters_jsr292_only();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2023 static bool profile_all_parameters();
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2024
0 a61af66fc99e Initial load duke parents: diff changeset	2025 public:
a61af66fc99e Initial load duke parents: diff changeset	2026 static int header_size() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2027 return sizeof(MethodData)/wordSize;
0 a61af66fc99e Initial load duke parents: diff changeset	2028 }
a61af66fc99e Initial load duke parents: diff changeset	2029
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2030 // Compute the size of a MethodData* before it is created.
0 a61af66fc99e Initial load duke parents: diff changeset	2031 static int compute_allocation_size_in_bytes(methodHandle method);
a61af66fc99e Initial load duke parents: diff changeset	2032 static int compute_allocation_size_in_words(methodHandle method);
a61af66fc99e Initial load duke parents: diff changeset	2033 static int compute_extra_data_count(int data_size, int empty_bc_count);
a61af66fc99e Initial load duke parents: diff changeset	2034
a61af66fc99e Initial load duke parents: diff changeset	2035 // Determine if a given bytecode can have profile information.
a61af66fc99e Initial load duke parents: diff changeset	2036 static bool bytecode_has_profile(Bytecodes::Code code) {
a61af66fc99e Initial load duke parents: diff changeset	2037 return bytecode_cell_count(code) != no_profile_data;
a61af66fc99e Initial load duke parents: diff changeset	2038 }
a61af66fc99e Initial load duke parents: diff changeset	2039
9080 b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8000 diff changeset	2040 // reset into original state
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8000 diff changeset	2041 void init();
0 a61af66fc99e Initial load duke parents: diff changeset	2042
a61af66fc99e Initial load duke parents: diff changeset	2043 // My size
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2044 int size_in_bytes() const { return _size; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2045 int size() const { return align_object_size(align_size_up(_size, BytesPerWord)/BytesPerWord); }
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	2046 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	2047 void collect_statistics(KlassSizeStats *sz) const;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	2048 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	2049
a61af66fc99e Initial load duke parents: diff changeset	2050 int creation_mileage() const { return _creation_mileage; }
a61af66fc99e Initial load duke parents: diff changeset	2051 void set_creation_mileage(int x) { _creation_mileage = x; }
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2052
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2053 int invocation_count() {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2054 if (invocation_counter()->carry()) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2055 return InvocationCounter::count_limit;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2056 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2057 return invocation_counter()->count();
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2058 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2059 int backedge_count() {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2060 if (backedge_counter()->carry()) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2061 return InvocationCounter::count_limit;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2062 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2063 return backedge_counter()->count();
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2064 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2065
2252 72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2066 int invocation_count_start() {
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2067 if (invocation_counter()->carry()) {
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2068 return 0;
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2069 }
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2070 return _invocation_counter_start;
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2071 }
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2072
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2073 int backedge_count_start() {
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2074 if (backedge_counter()->carry()) {
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2075 return 0;
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2076 }
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2077 return _backedge_counter_start;
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2078 }
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2079
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2080 int invocation_count_delta() { return invocation_count() - invocation_count_start(); }
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2081 int backedge_count_delta() { return backedge_count() - backedge_count_start(); }
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2082
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2083 void reset_start_counters() {
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2084 _invocation_counter_start = invocation_count();
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2085 _backedge_counter_start = backedge_count();
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2086 }
72d6c57d0658 7017434: Tiered needs to support reprofiling iveresov parents: 1972 diff changeset	2087
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2088 InvocationCounter* invocation_counter() { return &_invocation_counter; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2089 InvocationCounter* backedge_counter() { return &_backedge_counter; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2090
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2091 void set_would_profile(bool p) { _would_profile = p; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2092 bool would_profile() const { return _would_profile; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2093
10265 92ef81e2f571 8003557: NPG: Klass* const k should be const Klass* k. minqi parents: 9080 diff changeset	2094 int highest_comp_level() const { return _highest_comp_level; }
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2095 void set_highest_comp_level(int level) { _highest_comp_level = level; }
10265 92ef81e2f571 8003557: NPG: Klass* const k should be const Klass* k. minqi parents: 9080 diff changeset	2096 int highest_osr_comp_level() const { return _highest_osr_comp_level; }
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2097 void set_highest_osr_comp_level(int level) { _highest_osr_comp_level = level; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2098
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2099 int num_loops() const { return _num_loops; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2100 void set_num_loops(int n) { _num_loops = n; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2101 int num_blocks() const { return _num_blocks; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2102 void set_num_blocks(int n) { _num_blocks = n; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2103
0 a61af66fc99e Initial load duke parents: diff changeset	2104 bool is_mature() const; // consult mileage and ProfileMaturityPercentage
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2105 static int mileage_of(Method* m);
0 a61af66fc99e Initial load duke parents: diff changeset	2106
a61af66fc99e Initial load duke parents: diff changeset	2107 // Support for interprocedural escape analysis, from Thomas Kotzmann.
a61af66fc99e Initial load duke parents: diff changeset	2108 enum EscapeFlag {
a61af66fc99e Initial load duke parents: diff changeset	2109 estimated = 1 << 0,
78 e1e86702e43e 6680665: bytecode Escape Analyzer produces incorrect escape information for methods without oop arguments kvn parents: 45 diff changeset	2110 return_local = 1 << 1,
e1e86702e43e 6680665: bytecode Escape Analyzer produces incorrect escape information for methods without oop arguments kvn parents: 45 diff changeset	2111 return_allocated = 1 << 2,
e1e86702e43e 6680665: bytecode Escape Analyzer produces incorrect escape information for methods without oop arguments kvn parents: 45 diff changeset	2112 allocated_escapes = 1 << 3,
e1e86702e43e 6680665: bytecode Escape Analyzer produces incorrect escape information for methods without oop arguments kvn parents: 45 diff changeset	2113 unknown_modified = 1 << 4
0 a61af66fc99e Initial load duke parents: diff changeset	2114 };
a61af66fc99e Initial load duke parents: diff changeset	2115
a61af66fc99e Initial load duke parents: diff changeset	2116 intx eflags() { return _eflags; }
a61af66fc99e Initial load duke parents: diff changeset	2117 intx arg_local() { return _arg_local; }
a61af66fc99e Initial load duke parents: diff changeset	2118 intx arg_stack() { return _arg_stack; }
a61af66fc99e Initial load duke parents: diff changeset	2119 intx arg_returned() { return _arg_returned; }
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	2120 uint arg_modified(int a) { ArgInfoData *aid = arg_info();
9080 b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8000 diff changeset	2121 assert(aid != NULL, "arg_info must be not null");
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	2122 assert(a >= 0 && a < aid->number_of_args(), "valid argument number");
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	2123 return aid->arg_modified(a); }
0 a61af66fc99e Initial load duke parents: diff changeset	2124
a61af66fc99e Initial load duke parents: diff changeset	2125 void set_eflags(intx v) { _eflags = v; }
a61af66fc99e Initial load duke parents: diff changeset	2126 void set_arg_local(intx v) { _arg_local = v; }
a61af66fc99e Initial load duke parents: diff changeset	2127 void set_arg_stack(intx v) { _arg_stack = v; }
a61af66fc99e Initial load duke parents: diff changeset	2128 void set_arg_returned(intx v) { _arg_returned = v; }
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	2129 void set_arg_modified(int a, uint v) { ArgInfoData *aid = arg_info();
9080 b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8000 diff changeset	2130 assert(aid != NULL, "arg_info must be not null");
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	2131 assert(a >= 0 && a < aid->number_of_args(), "valid argument number");
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	2132 aid->set_arg_modified(a, v); }
0 a61af66fc99e Initial load duke parents: diff changeset	2133
a61af66fc99e Initial load duke parents: diff changeset	2134 void clear_escape_info() { _eflags = _arg_local = _arg_stack = _arg_returned = 0; }
a61af66fc99e Initial load duke parents: diff changeset	2135
a61af66fc99e Initial load duke parents: diff changeset	2136 // Location and size of data area
a61af66fc99e Initial load duke parents: diff changeset	2137 address data_base() const {
a61af66fc99e Initial load duke parents: diff changeset	2138 return (address) _data;
a61af66fc99e Initial load duke parents: diff changeset	2139 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2140 int data_size() const {
0 a61af66fc99e Initial load duke parents: diff changeset	2141 return _data_size;
a61af66fc99e Initial load duke parents: diff changeset	2142 }
a61af66fc99e Initial load duke parents: diff changeset	2143
a61af66fc99e Initial load duke parents: diff changeset	2144 // Accessors
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2145 Method* method() const { return _method; }
0 a61af66fc99e Initial load duke parents: diff changeset	2146
a61af66fc99e Initial load duke parents: diff changeset	2147 // Get the data at an arbitrary (sort of) data index.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2148 ProfileData* data_at(int data_index) const;
0 a61af66fc99e Initial load duke parents: diff changeset	2149
a61af66fc99e Initial load duke parents: diff changeset	2150 // Walk through the data in order.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2151 ProfileData* first_data() const { return data_at(first_di()); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2152 ProfileData* next_data(ProfileData* current) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2153 bool is_valid(ProfileData* current) const { return current != NULL; }
0 a61af66fc99e Initial load duke parents: diff changeset	2154
a61af66fc99e Initial load duke parents: diff changeset	2155 // Convert a dp (data pointer) to a di (data index).
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2156 int dp_to_di(address dp) const {
0 a61af66fc99e Initial load duke parents: diff changeset	2157 return dp - ((address)_data);
a61af66fc99e Initial load duke parents: diff changeset	2158 }
a61af66fc99e Initial load duke parents: diff changeset	2159
a61af66fc99e Initial load duke parents: diff changeset	2160 address di_to_dp(int di) {
a61af66fc99e Initial load duke parents: diff changeset	2161 return (address)data_layout_at(di);
a61af66fc99e Initial load duke parents: diff changeset	2162 }
a61af66fc99e Initial load duke parents: diff changeset	2163
a61af66fc99e Initial load duke parents: diff changeset	2164 // bci to di/dp conversion.
a61af66fc99e Initial load duke parents: diff changeset	2165 address bci_to_dp(int bci);
a61af66fc99e Initial load duke parents: diff changeset	2166 int bci_to_di(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	2167 return dp_to_di(bci_to_dp(bci));
a61af66fc99e Initial load duke parents: diff changeset	2168 }
a61af66fc99e Initial load duke parents: diff changeset	2169
a61af66fc99e Initial load duke parents: diff changeset	2170 // Get the data at an arbitrary bci, or NULL if there is none.
a61af66fc99e Initial load duke parents: diff changeset	2171 ProfileData* bci_to_data(int bci);
a61af66fc99e Initial load duke parents: diff changeset	2172
a61af66fc99e Initial load duke parents: diff changeset	2173 // Same, but try to create an extra_data record if one is needed:
a61af66fc99e Initial load duke parents: diff changeset	2174 ProfileData* allocate_bci_to_data(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	2175 ProfileData* data = bci_to_data(bci);
a61af66fc99e Initial load duke parents: diff changeset	2176 return (data != NULL) ? data : bci_to_extra_data(bci, true);
a61af66fc99e Initial load duke parents: diff changeset	2177 }
a61af66fc99e Initial load duke parents: diff changeset	2178
a61af66fc99e Initial load duke parents: diff changeset	2179 // Add a handful of extra data records, for trap tracking.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2180 DataLayout* extra_data_base() const { return limit_data_position(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2181 DataLayout* extra_data_limit() const { return (DataLayout*)((address)this + size_in_bytes()); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2182 int extra_data_size() const { return (address)extra_data_limit()
0 a61af66fc99e Initial load duke parents: diff changeset	2183 - (address)extra_data_base(); }
a61af66fc99e Initial load duke parents: diff changeset	2184 static DataLayout* next_extra(DataLayout* dp) { return (DataLayout*)((address)dp + in_bytes(DataLayout::cell_offset(0))); }
a61af66fc99e Initial load duke parents: diff changeset	2185
a61af66fc99e Initial load duke parents: diff changeset	2186 // Return (uint)-1 for overflow.
a61af66fc99e Initial load duke parents: diff changeset	2187 uint trap_count(int reason) const {
a61af66fc99e Initial load duke parents: diff changeset	2188 assert((uint)reason < _trap_hist_limit, "oob");
a61af66fc99e Initial load duke parents: diff changeset	2189 return (int)((_trap_hist._array[reason]+1) & _trap_hist_mask) - 1;
a61af66fc99e Initial load duke parents: diff changeset	2190 }
a61af66fc99e Initial load duke parents: diff changeset	2191 // For loops:
a61af66fc99e Initial load duke parents: diff changeset	2192 static uint trap_reason_limit() { return _trap_hist_limit; }
a61af66fc99e Initial load duke parents: diff changeset	2193 static uint trap_count_limit() { return _trap_hist_mask; }
a61af66fc99e Initial load duke parents: diff changeset	2194 uint inc_trap_count(int reason) {
a61af66fc99e Initial load duke parents: diff changeset	2195 // Count another trap, anywhere in this method.
a61af66fc99e Initial load duke parents: diff changeset	2196 assert(reason >= 0, "must be single trap");
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5111 diff changeset	2197 assert((uint)reason < _trap_hist_limit, "oob");
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5111 diff changeset	2198 uint cnt1 = 1 + _trap_hist._array[reason];
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5111 diff changeset	2199 if ((cnt1 & _trap_hist_mask) != 0) { // if no counter overflow...
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5111 diff changeset	2200 _trap_hist._array[reason] = cnt1;
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5111 diff changeset	2201 return cnt1;
0 a61af66fc99e Initial load duke parents: diff changeset	2202 } else {
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5111 diff changeset	2203 return _trap_hist_mask + (++_nof_overflow_traps);
0 a61af66fc99e Initial load duke parents: diff changeset	2204 }
a61af66fc99e Initial load duke parents: diff changeset	2205 }
a61af66fc99e Initial load duke parents: diff changeset	2206
a61af66fc99e Initial load duke parents: diff changeset	2207 uint overflow_trap_count() const {
a61af66fc99e Initial load duke parents: diff changeset	2208 return _nof_overflow_traps;
a61af66fc99e Initial load duke parents: diff changeset	2209 }
a61af66fc99e Initial load duke parents: diff changeset	2210 uint overflow_recompile_count() const {
a61af66fc99e Initial load duke parents: diff changeset	2211 return _nof_overflow_recompiles;
a61af66fc99e Initial load duke parents: diff changeset	2212 }
a61af66fc99e Initial load duke parents: diff changeset	2213 void inc_overflow_recompile_count() {
a61af66fc99e Initial load duke parents: diff changeset	2214 _nof_overflow_recompiles += 1;
a61af66fc99e Initial load duke parents: diff changeset	2215 }
a61af66fc99e Initial load duke parents: diff changeset	2216 uint decompile_count() const {
a61af66fc99e Initial load duke parents: diff changeset	2217 return _nof_decompiles;
a61af66fc99e Initial load duke parents: diff changeset	2218 }
a61af66fc99e Initial load duke parents: diff changeset	2219 void inc_decompile_count() {
a61af66fc99e Initial load duke parents: diff changeset	2220 _nof_decompiles += 1;
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 948 diff changeset	2221 if (decompile_count() > (uint)PerMethodRecompilationCutoff) {
7998 6a51fc70a15e 8006613: adding reason to made_not_compilable vlivanov parents: 6725 diff changeset	2222 method()->set_not_compilable(CompLevel_full_optimization, true, "decompile_count > PerMethodRecompilationCutoff");
1206 87684f1a88b5 6614597: Performance variability in jvm2008 xml.validation kvn parents: 948 diff changeset	2223 }
0 a61af66fc99e Initial load duke parents: diff changeset	2224 }
a61af66fc99e Initial load duke parents: diff changeset	2225
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2226 // Return pointer to area dedicated to parameters in MDO
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2227 ParametersTypeData* parameters_type_data() const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2228 return _parameters_type_data_di != -1 ? data_layout_at(_parameters_type_data_di)->data_in()->as_ParametersTypeData() : NULL;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2229 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2230
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2231 int parameters_type_data_di() const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2232 assert(_parameters_type_data_di != -1, "no args type data");
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2233 return _parameters_type_data_di;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2234 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2235
0 a61af66fc99e Initial load duke parents: diff changeset	2236 // Support for code generation
a61af66fc99e Initial load duke parents: diff changeset	2237 static ByteSize data_offset() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2238 return byte_offset_of(MethodData, _data[0]);
0 a61af66fc99e Initial load duke parents: diff changeset	2239 }
a61af66fc99e Initial load duke parents: diff changeset	2240
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5111 diff changeset	2241 static ByteSize trap_history_offset() {
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 5114 6725 diff changeset	2242 return byte_offset_of(MethodData, _trap_hist._array);
5114 dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5111 diff changeset	2243 }
dad1ac9dba7d finished first implementation of disabling runtime feedback selectively based on deoptimization history Christian Haeubl <christian.haeubl@oracle.com> parents: 5111 diff changeset	2244
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2245 static ByteSize invocation_counter_offset() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2246 return byte_offset_of(MethodData, _invocation_counter);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2247 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2248 static ByteSize backedge_counter_offset() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2249 return byte_offset_of(MethodData, _backedge_counter);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2250 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	2251
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2252 static ByteSize parameters_type_data_di_offset() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2253 return byte_offset_of(MethodData, _parameters_type_data_di);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2254 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2255
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2256 // Deallocation support - no pointer fields to deallocate
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2257 void deallocate_contents(ClassLoaderData* loader_data) {}
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2258
0 a61af66fc99e Initial load duke parents: diff changeset	2259 // GC support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2260 void set_size(int object_size_in_bytes) { _size = object_size_in_bytes; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2261
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2262 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2263 #ifndef PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2264 void print_on (outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2265 #endif
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2266 void print_value_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	2267
a61af66fc99e Initial load duke parents: diff changeset	2268 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	2269 // printing support for method data
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2270 void print_data_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	2271 #endif
a61af66fc99e Initial load duke parents: diff changeset	2272
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2273 const char* internal_name() const { return "{method data}"; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2274
0 a61af66fc99e Initial load duke parents: diff changeset	2275 // verification
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3905 diff changeset	2276 void verify_on(outputStream* st);
0 a61af66fc99e Initial load duke parents: diff changeset	2277 void verify_data_on(outputStream* st);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2278
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2279 static bool profile_parameters_for_method(methodHandle m);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12316 diff changeset	2280 static bool profile_arguments();
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	2281 static bool profile_return();
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	2282 static bool profile_parameters();
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	2283 static bool profile_return_jsr292_only();
0 a61af66fc99e Initial load duke parents: diff changeset	2284 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	2285
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	2286 #endif // SHARE_VM_OOPS_METHODDATAOOP_HPP

Mercurial > hg > truffle

annotate src/share/vm/oops/methodData.hpp @ 13212:eb03a7335eb0