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

annotate src/share/vm/oops/methodData.cpp @ 14649:f6301b007a16

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	da862781b584
children	fdad2932c73f 62c54fcc0a35

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: 941 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 941 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: 941 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 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	26 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	27 #include "interpreter/bytecode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	28 #include "interpreter/bytecodeStream.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	29 #include "interpreter/linkResolver.hpp"
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	30 #include "memory/heapInspection.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	31 #include "oops/methodData.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	32 #include "prims/jvmtiRedefineClasses.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	33 #include "runtime/compilationPolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	34 #include "runtime/deoptimization.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	35 #include "runtime/handles.inline.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	36
a61af66fc99e Initial load duke parents: diff changeset	37 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	38 // DataLayout
a61af66fc99e Initial load duke parents: diff changeset	39 //
a61af66fc99e Initial load duke parents: diff changeset	40 // Overlay for generic profiling data.
a61af66fc99e Initial load duke parents: diff changeset	41
a61af66fc99e Initial load duke parents: diff changeset	42 // Some types of data layouts need a length field.
a61af66fc99e Initial load duke parents: diff changeset	43 bool DataLayout::needs_array_len(u1 tag) {
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	44 return (tag == multi_branch_data_tag) \|\| (tag == arg_info_data_tag) \|\| (tag == parameters_type_data_tag);
0 a61af66fc99e Initial load duke parents: diff changeset	45 }
a61af66fc99e Initial load duke parents: diff changeset	46
a61af66fc99e Initial load duke parents: diff changeset	47 // Perform generic initialization of the data. More specific
a61af66fc99e Initial load duke parents: diff changeset	48 // initialization occurs in overrides of ProfileData::post_initialize.
a61af66fc99e Initial load duke parents: diff changeset	49 void DataLayout::initialize(u1 tag, u2 bci, int cell_count) {
a61af66fc99e Initial load duke parents: diff changeset	50 _header._bits = (intptr_t)0;
a61af66fc99e Initial load duke parents: diff changeset	51 _header._struct._tag = tag;
a61af66fc99e Initial load duke parents: diff changeset	52 _header._struct._bci = bci;
a61af66fc99e Initial load duke parents: diff changeset	53 for (int i = 0; i < cell_count; i++) {
a61af66fc99e Initial load duke parents: diff changeset	54 set_cell_at(i, (intptr_t)0);
a61af66fc99e Initial load duke parents: diff changeset	55 }
a61af66fc99e Initial load duke parents: diff changeset	56 if (needs_array_len(tag)) {
a61af66fc99e Initial load duke parents: diff changeset	57 set_cell_at(ArrayData::array_len_off_set, cell_count - 1); // -1 for header.
a61af66fc99e Initial load duke parents: diff changeset	58 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	59 if (tag == call_type_data_tag) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	60 CallTypeData::initialize(this, cell_count);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	61 } else if (tag == virtual_call_type_data_tag) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	62 VirtualCallTypeData::initialize(this, cell_count);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	63 }
0 a61af66fc99e Initial load duke parents: diff changeset	64 }
a61af66fc99e Initial load duke parents: diff changeset	65
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	66 void DataLayout::clean_weak_klass_links(BoolObjectClosure* cl) {
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	67 ResourceMark m;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	68 data_in()->clean_weak_klass_links(cl);
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	69 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	70
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	71
0 a61af66fc99e Initial load duke parents: diff changeset	72 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	73 // ProfileData
a61af66fc99e Initial load duke parents: diff changeset	74 //
a61af66fc99e Initial load duke parents: diff changeset	75 // A ProfileData object is created to refer to a section of profiling
a61af66fc99e Initial load duke parents: diff changeset	76 // data in a structured way.
a61af66fc99e Initial load duke parents: diff changeset	77
a61af66fc99e Initial load duke parents: diff changeset	78 // Constructor for invalid ProfileData.
a61af66fc99e Initial load duke parents: diff changeset	79 ProfileData::ProfileData() {
a61af66fc99e Initial load duke parents: diff changeset	80 _data = NULL;
a61af66fc99e Initial load duke parents: diff changeset	81 }
a61af66fc99e Initial load duke parents: diff changeset	82
a61af66fc99e Initial load duke parents: diff changeset	83 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	84 void ProfileData::print_shared(outputStream* st, const char* name) const {
0 a61af66fc99e Initial load duke parents: diff changeset	85 st->print("bci: %d", bci());
a61af66fc99e Initial load duke parents: diff changeset	86 st->fill_to(tab_width_one);
a61af66fc99e Initial load duke parents: diff changeset	87 st->print("%s", name);
a61af66fc99e Initial load duke parents: diff changeset	88 tab(st);
a61af66fc99e Initial load duke parents: diff changeset	89 int trap = trap_state();
a61af66fc99e Initial load duke parents: diff changeset	90 if (trap != 0) {
a61af66fc99e Initial load duke parents: diff changeset	91 char buf[100];
a61af66fc99e Initial load duke parents: diff changeset	92 st->print("trap(%s) ", Deoptimization::format_trap_state(buf, sizeof(buf), trap));
a61af66fc99e Initial load duke parents: diff changeset	93 }
a61af66fc99e Initial load duke parents: diff changeset	94 int flags = data()->flags();
a61af66fc99e Initial load duke parents: diff changeset	95 if (flags != 0)
a61af66fc99e Initial load duke parents: diff changeset	96 st->print("flags(%d) ", flags);
a61af66fc99e Initial load duke parents: diff changeset	97 }
a61af66fc99e Initial load duke parents: diff changeset	98
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	99 void ProfileData::tab(outputStream* st, bool first) const {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	100 st->fill_to(first ? tab_width_one : tab_width_two);
0 a61af66fc99e Initial load duke parents: diff changeset	101 }
a61af66fc99e Initial load duke parents: diff changeset	102 #endif // !PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	103
a61af66fc99e Initial load duke parents: diff changeset	104 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	105 // BitData
a61af66fc99e Initial load duke parents: diff changeset	106 //
a61af66fc99e Initial load duke parents: diff changeset	107 // A BitData corresponds to a one-bit flag. This is used to indicate
a61af66fc99e Initial load duke parents: diff changeset	108 // whether a checkcast bytecode has seen a null value.
a61af66fc99e Initial load duke parents: diff changeset	109
a61af66fc99e Initial load duke parents: diff changeset	110
a61af66fc99e Initial load duke parents: diff changeset	111 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	112 void BitData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	113 print_shared(st, "BitData");
a61af66fc99e Initial load duke parents: diff changeset	114 }
a61af66fc99e Initial load duke parents: diff changeset	115 #endif // !PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	116
a61af66fc99e Initial load duke parents: diff changeset	117 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	118 // CounterData
a61af66fc99e Initial load duke parents: diff changeset	119 //
a61af66fc99e Initial load duke parents: diff changeset	120 // A CounterData corresponds to a simple counter.
a61af66fc99e Initial load duke parents: diff changeset	121
a61af66fc99e Initial load duke parents: diff changeset	122 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	123 void CounterData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	124 print_shared(st, "CounterData");
a61af66fc99e Initial load duke parents: diff changeset	125 st->print_cr("count(%u)", count());
a61af66fc99e Initial load duke parents: diff changeset	126 }
a61af66fc99e Initial load duke parents: diff changeset	127 #endif // !PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	128
a61af66fc99e Initial load duke parents: diff changeset	129 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	130 // JumpData
a61af66fc99e Initial load duke parents: diff changeset	131 //
a61af66fc99e Initial load duke parents: diff changeset	132 // A JumpData is used to access profiling information for a direct
a61af66fc99e Initial load duke parents: diff changeset	133 // branch. It is a counter, used for counting the number of branches,
a61af66fc99e Initial load duke parents: diff changeset	134 // plus a data displacement, used for realigning the data pointer to
a61af66fc99e Initial load duke parents: diff changeset	135 // the corresponding target bci.
a61af66fc99e Initial load duke parents: diff changeset	136
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	137 void JumpData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
0 a61af66fc99e Initial load duke parents: diff changeset	138 assert(stream->bci() == bci(), "wrong pos");
a61af66fc99e Initial load duke parents: diff changeset	139 int target;
a61af66fc99e Initial load duke parents: diff changeset	140 Bytecodes::Code c = stream->code();
a61af66fc99e Initial load duke parents: diff changeset	141 if (c == Bytecodes::_goto_w \|\| c == Bytecodes::_jsr_w) {
a61af66fc99e Initial load duke parents: diff changeset	142 target = stream->dest_w();
a61af66fc99e Initial load duke parents: diff changeset	143 } else {
a61af66fc99e Initial load duke parents: diff changeset	144 target = stream->dest();
a61af66fc99e Initial load duke parents: diff changeset	145 }
a61af66fc99e Initial load duke parents: diff changeset	146 int my_di = mdo->dp_to_di(dp());
a61af66fc99e Initial load duke parents: diff changeset	147 int target_di = mdo->bci_to_di(target);
a61af66fc99e Initial load duke parents: diff changeset	148 int offset = target_di - my_di;
a61af66fc99e Initial load duke parents: diff changeset	149 set_displacement(offset);
a61af66fc99e Initial load duke parents: diff changeset	150 }
a61af66fc99e Initial load duke parents: diff changeset	151
a61af66fc99e Initial load duke parents: diff changeset	152 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	153 void JumpData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	154 print_shared(st, "JumpData");
a61af66fc99e Initial load duke parents: diff changeset	155 st->print_cr("taken(%u) displacement(%d)", taken(), displacement());
a61af66fc99e Initial load duke parents: diff changeset	156 }
a61af66fc99e Initial load duke parents: diff changeset	157 #endif // !PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	158
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	159 int TypeStackSlotEntries::compute_cell_count(Symbol* signature, bool include_receiver, int max) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	160 // Parameter profiling include the receiver
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	161 int args_count = include_receiver ? 1 : 0;
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	162 ResourceMark rm;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	163 SignatureStream ss(signature);
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	164 args_count += ss.reference_parameter_count();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	165 args_count = MIN2(args_count, max);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	166 return args_count * per_arg_cell_count;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	167 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	168
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	169 int TypeEntriesAtCall::compute_cell_count(BytecodeStream* stream) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	170 assert(Bytecodes::is_invoke(stream->code()), "should be invoke");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	171 assert(TypeStackSlotEntries::per_arg_count() > ReturnTypeEntry::static_cell_count(), "code to test for arguments/results broken");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	172 Bytecode_invoke inv(stream->method(), stream->bci());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	173 int args_cell = 0;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	174 if (arguments_profiling_enabled()) {
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	175 args_cell = TypeStackSlotEntries::compute_cell_count(inv.signature(), false, TypeProfileArgsLimit);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	176 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	177 int ret_cell = 0;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	178 if (return_profiling_enabled() && (inv.result_type() == T_OBJECT \|\| inv.result_type() == T_ARRAY)) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	179 ret_cell = ReturnTypeEntry::static_cell_count();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	180 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	181 int header_cell = 0;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	182 if (args_cell + ret_cell > 0) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	183 header_cell = header_cell_count();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	184 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	185
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	186 return header_cell + args_cell + ret_cell;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	187 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	188
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	189 class ArgumentOffsetComputer : public SignatureInfo {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	190 private:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	191 int _max;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	192 GrowableArray<int> _offsets;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	193
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	194 void set(int size, BasicType type) { _size += size; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	195 void do_object(int begin, int end) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	196 if (_offsets.length() < _max) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	197 _offsets.push(_size);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	198 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	199 SignatureInfo::do_object(begin, end);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	200 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	201 void do_array (int begin, int end) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	202 if (_offsets.length() < _max) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	203 _offsets.push(_size);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	204 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	205 SignatureInfo::do_array(begin, end);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	206 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	207
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	208 public:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	209 ArgumentOffsetComputer(Symbol* signature, int max)
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	210 : SignatureInfo(signature), _max(max), _offsets(Thread::current(), max) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	211 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	212
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	213 int total() { lazy_iterate_parameters(); return _size; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	214
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	215 int off_at(int i) const { return _offsets.at(i); }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	216 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	217
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	218 void TypeStackSlotEntries::post_initialize(Symbol* signature, bool has_receiver, bool include_receiver) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	219 ResourceMark rm;
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	220 int start = 0;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	221 // Parameter profiling include the receiver
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	222 if (include_receiver && has_receiver) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	223 set_stack_slot(0, 0);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	224 set_type(0, type_none());
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	225 start += 1;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	226 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	227 ArgumentOffsetComputer aos(signature, _number_of_entries-start);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	228 aos.total();
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	229 for (int i = start; i < _number_of_entries; i++) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	230 set_stack_slot(i, aos.off_at(i-start) + (has_receiver ? 1 : 0));
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	231 set_type(i, type_none());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	232 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	233 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	234
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	235 void CallTypeData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	236 assert(Bytecodes::is_invoke(stream->code()), "should be invoke");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	237 Bytecode_invoke inv(stream->method(), stream->bci());
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	238
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	239 SignatureStream ss(inv.signature());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	240 if (has_arguments()) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	241 #ifdef ASSERT
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	242 ResourceMark rm;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	243 int count = MIN2(ss.reference_parameter_count(), (int)TypeProfileArgsLimit);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	244 assert(count > 0, "room for args type but none found?");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	245 check_number_of_arguments(count);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	246 #endif
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	247 _args.post_initialize(inv.signature(), inv.has_receiver(), false);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	248 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	249
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	250 if (has_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	251 assert(inv.result_type() == T_OBJECT \|\| inv.result_type() == T_ARRAY, "room for a ret type but doesn't return obj?");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	252 _ret.post_initialize();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	253 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	254 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	255
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	256 void VirtualCallTypeData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	257 assert(Bytecodes::is_invoke(stream->code()), "should be invoke");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	258 Bytecode_invoke inv(stream->method(), stream->bci());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	259
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	260 if (has_arguments()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	261 #ifdef ASSERT
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	262 ResourceMark rm;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	263 SignatureStream ss(inv.signature());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	264 int count = MIN2(ss.reference_parameter_count(), (int)TypeProfileArgsLimit);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	265 assert(count > 0, "room for args type but none found?");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	266 check_number_of_arguments(count);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	267 #endif
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	268 _args.post_initialize(inv.signature(), inv.has_receiver(), false);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	269 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	270
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	271 if (has_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	272 assert(inv.result_type() == T_OBJECT \|\| inv.result_type() == T_ARRAY, "room for a ret type but doesn't return obj?");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	273 _ret.post_initialize();
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	274 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	275 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	276
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	277 bool TypeEntries::is_loader_alive(BoolObjectClosure* is_alive_cl, intptr_t p) {
13080 6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12962 diff changeset	278 Klass* k = (Klass*)klass_part(p);
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12962 diff changeset	279 return k != NULL && k->is_loader_alive(is_alive_cl);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	280 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	281
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	282 void TypeStackSlotEntries::clean_weak_klass_links(BoolObjectClosure* is_alive_cl) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	283 for (int i = 0; i < _number_of_entries; i++) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	284 intptr_t p = type(i);
13080 6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12962 diff changeset	285 if (!is_loader_alive(is_alive_cl, p)) {
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12962 diff changeset	286 set_type(i, with_status((Klass*)NULL, p));
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	287 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	288 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	289 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	290
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	291 void ReturnTypeEntry::clean_weak_klass_links(BoolObjectClosure* is_alive_cl) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	292 intptr_t p = type();
13080 6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12962 diff changeset	293 if (!is_loader_alive(is_alive_cl, p)) {
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12962 diff changeset	294 set_type(with_status((Klass*)NULL, p));
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	295 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	296 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	297
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	298 bool TypeEntriesAtCall::return_profiling_enabled() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	299 return MethodData::profile_return();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	300 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	301
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	302 bool TypeEntriesAtCall::arguments_profiling_enabled() {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	303 return MethodData::profile_arguments();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	304 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	305
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	306 #ifndef PRODUCT
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	307 void TypeEntries::print_klass(outputStream* st, intptr_t k) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	308 if (is_type_none(k)) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	309 st->print("none");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	310 } else if (is_type_unknown(k)) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	311 st->print("unknown");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	312 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	313 valid_klass(k)->print_value_on(st);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	314 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	315 if (was_null_seen(k)) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	316 st->print(" (null seen)");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	317 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	318 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	319
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	320 void TypeStackSlotEntries::print_data_on(outputStream* st) const {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	321 for (int i = 0; i < _number_of_entries; i++) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	322 _pd->tab(st);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	323 st->print("%d: stack(%u) ", i, stack_slot(i));
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	324 print_klass(st, type(i));
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	325 st->cr();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	326 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	327 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	328
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	329 void ReturnTypeEntry::print_data_on(outputStream* st) const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	330 _pd->tab(st);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	331 print_klass(st, type());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	332 st->cr();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	333 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	334
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	335 void CallTypeData::print_data_on(outputStream* st) const {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	336 CounterData::print_data_on(st);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	337 if (has_arguments()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	338 tab(st, true);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	339 st->print("argument types");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	340 _args.print_data_on(st);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	341 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	342 if (has_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	343 tab(st, true);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	344 st->print("return type");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	345 _ret.print_data_on(st);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	346 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	347 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	348
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	349 void VirtualCallTypeData::print_data_on(outputStream* st) const {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	350 VirtualCallData::print_data_on(st);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	351 if (has_arguments()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	352 tab(st, true);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	353 st->print("argument types");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	354 _args.print_data_on(st);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	355 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	356 if (has_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	357 tab(st, true);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	358 st->print("return type");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	359 _ret.print_data_on(st);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	360 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	361 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	362 #endif
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	363
0 a61af66fc99e Initial load duke parents: diff changeset	364 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	365 // ReceiverTypeData
a61af66fc99e Initial load duke parents: diff changeset	366 //
a61af66fc99e Initial load duke parents: diff changeset	367 // A ReceiverTypeData is used to access profiling information about a
a61af66fc99e Initial load duke parents: diff changeset	368 // 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: 2264 diff changeset	369 // that the check is reached, and a series of (Klass*, count) pairs
0 a61af66fc99e Initial load duke parents: diff changeset	370 // which are used to store a type profile for the receiver of the check.
a61af66fc99e Initial load duke parents: diff changeset	371
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	372 void ReceiverTypeData::clean_weak_klass_links(BoolObjectClosure* is_alive_cl) {
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	373 for (uint row = 0; row < row_limit(); row++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	374 Klass* p = receiver(row);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	375 if (p != NULL && !p->is_loader_alive(is_alive_cl)) {
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	376 clear_row(row);
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	377 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	378 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	379 }
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	380
0 a61af66fc99e Initial load duke parents: diff changeset	381 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	382 void ReceiverTypeData::print_receiver_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	383 uint row;
a61af66fc99e Initial load duke parents: diff changeset	384 int entries = 0;
a61af66fc99e Initial load duke parents: diff changeset	385 for (row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	386 if (receiver(row) != NULL) entries++;
a61af66fc99e Initial load duke parents: diff changeset	387 }
a61af66fc99e Initial load duke parents: diff changeset	388 st->print_cr("count(%u) entries(%u)", count(), entries);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	389 int total = count();
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	390 for (row = 0; row < row_limit(); row++) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	391 if (receiver(row) != NULL) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	392 total += receiver_count(row);
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	393 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	394 }
0 a61af66fc99e Initial load duke parents: diff changeset	395 for (row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	396 if (receiver(row) != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	397 tab(st);
a61af66fc99e Initial load duke parents: diff changeset	398 receiver(row)->print_value_on(st);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	399 st->print_cr("(%u %4.2f)", receiver_count(row), (float) receiver_count(row) / (float) total);
0 a61af66fc99e Initial load duke parents: diff changeset	400 }
a61af66fc99e Initial load duke parents: diff changeset	401 }
a61af66fc99e Initial load duke parents: diff changeset	402 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	403 void ReceiverTypeData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	404 print_shared(st, "ReceiverTypeData");
a61af66fc99e Initial load duke parents: diff changeset	405 print_receiver_data_on(st);
a61af66fc99e Initial load duke parents: diff changeset	406 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	407 void VirtualCallData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	408 print_shared(st, "VirtualCallData");
a61af66fc99e Initial load duke parents: diff changeset	409 print_receiver_data_on(st);
a61af66fc99e Initial load duke parents: diff changeset	410 }
a61af66fc99e Initial load duke parents: diff changeset	411 #endif // !PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	412
a61af66fc99e Initial load duke parents: diff changeset	413 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	414 // RetData
a61af66fc99e Initial load duke parents: diff changeset	415 //
a61af66fc99e Initial load duke parents: diff changeset	416 // A RetData is used to access profiling information for a ret bytecode.
a61af66fc99e Initial load duke parents: diff changeset	417 // It is composed of a count of the number of times that the ret has
a61af66fc99e Initial load duke parents: diff changeset	418 // been executed, followed by a series of triples of the form
a61af66fc99e Initial load duke parents: diff changeset	419 // (bci, count, di) which count the number of times that some bci was the
a61af66fc99e Initial load duke parents: diff changeset	420 // target of the ret and cache a corresponding displacement.
a61af66fc99e Initial load duke parents: diff changeset	421
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	422 void RetData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
0 a61af66fc99e Initial load duke parents: diff changeset	423 for (uint row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	424 set_bci_displacement(row, -1);
a61af66fc99e Initial load duke parents: diff changeset	425 set_bci(row, no_bci);
a61af66fc99e Initial load duke parents: diff changeset	426 }
a61af66fc99e Initial load duke parents: diff changeset	427 // release so other threads see a consistent state. bci is used as
a61af66fc99e Initial load duke parents: diff changeset	428 // a valid flag for bci_displacement.
a61af66fc99e Initial load duke parents: diff changeset	429 OrderAccess::release();
a61af66fc99e Initial load duke parents: diff changeset	430 }
a61af66fc99e Initial load duke parents: diff changeset	431
a61af66fc99e Initial load duke parents: diff changeset	432 // This routine needs to atomically update the RetData structure, so the
a61af66fc99e Initial load duke parents: diff changeset	433 // caller needs to hold the RetData_lock before it gets here. Since taking
a61af66fc99e Initial load duke parents: diff changeset	434 // the lock can block (and allow GC) and since RetData is a ProfileData is a
a61af66fc99e Initial load duke parents: diff changeset	435 // wrapper around a derived oop, taking the lock in _this_ method will
a61af66fc99e Initial load duke parents: diff changeset	436 // basically cause the 'this' pointer's _data field to contain junk after the
a61af66fc99e Initial load duke parents: diff changeset	437 // lock. We require the caller to take the lock before making the ProfileData
a61af66fc99e Initial load duke parents: diff changeset	438 // structure. Currently the only caller is InterpreterRuntime::update_mdp_for_ret
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	439 address RetData::fixup_ret(int return_bci, MethodData* h_mdo) {
0 a61af66fc99e Initial load duke parents: diff changeset	440 // First find the mdp which corresponds to the return bci.
a61af66fc99e Initial load duke parents: diff changeset	441 address mdp = h_mdo->bci_to_dp(return_bci);
a61af66fc99e Initial load duke parents: diff changeset	442
a61af66fc99e Initial load duke parents: diff changeset	443 // Now check to see if any of the cache slots are open.
a61af66fc99e Initial load duke parents: diff changeset	444 for (uint row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	445 if (bci(row) == no_bci) {
a61af66fc99e Initial load duke parents: diff changeset	446 set_bci_displacement(row, mdp - dp());
a61af66fc99e Initial load duke parents: diff changeset	447 set_bci_count(row, DataLayout::counter_increment);
a61af66fc99e Initial load duke parents: diff changeset	448 // Barrier to ensure displacement is written before the bci; allows
a61af66fc99e Initial load duke parents: diff changeset	449 // the interpreter to read displacement without fear of race condition.
a61af66fc99e Initial load duke parents: diff changeset	450 release_set_bci(row, return_bci);
a61af66fc99e Initial load duke parents: diff changeset	451 break;
a61af66fc99e Initial load duke parents: diff changeset	452 }
a61af66fc99e Initial load duke parents: diff changeset	453 }
a61af66fc99e Initial load duke parents: diff changeset	454 return mdp;
a61af66fc99e Initial load duke parents: diff changeset	455 }
a61af66fc99e Initial load duke parents: diff changeset	456
14420 abe03600372a 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling goetz parents: 10376 diff changeset	457 #ifdef CC_INTERP
abe03600372a 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling goetz parents: 10376 diff changeset	458 DataLayout* RetData::advance(MethodData *md, int bci) {
abe03600372a 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling goetz parents: 10376 diff changeset	459 return (DataLayout*) md->bci_to_dp(bci);
abe03600372a 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling goetz parents: 10376 diff changeset	460 }
abe03600372a 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling goetz parents: 10376 diff changeset	461 #endif // CC_INTERP
0 a61af66fc99e Initial load duke parents: diff changeset	462
a61af66fc99e Initial load duke parents: diff changeset	463 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	464 void RetData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	465 print_shared(st, "RetData");
a61af66fc99e Initial load duke parents: diff changeset	466 uint row;
a61af66fc99e Initial load duke parents: diff changeset	467 int entries = 0;
a61af66fc99e Initial load duke parents: diff changeset	468 for (row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	469 if (bci(row) != no_bci) entries++;
a61af66fc99e Initial load duke parents: diff changeset	470 }
a61af66fc99e Initial load duke parents: diff changeset	471 st->print_cr("count(%u) entries(%u)", count(), entries);
a61af66fc99e Initial load duke parents: diff changeset	472 for (row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	473 if (bci(row) != no_bci) {
a61af66fc99e Initial load duke parents: diff changeset	474 tab(st);
a61af66fc99e Initial load duke parents: diff changeset	475 st->print_cr("bci(%d: count(%u) displacement(%d))",
a61af66fc99e Initial load duke parents: diff changeset	476 bci(row), bci_count(row), bci_displacement(row));
a61af66fc99e Initial load duke parents: diff changeset	477 }
a61af66fc99e Initial load duke parents: diff changeset	478 }
a61af66fc99e Initial load duke parents: diff changeset	479 }
a61af66fc99e Initial load duke parents: diff changeset	480 #endif // !PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	481
a61af66fc99e Initial load duke parents: diff changeset	482 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	483 // BranchData
a61af66fc99e Initial load duke parents: diff changeset	484 //
a61af66fc99e Initial load duke parents: diff changeset	485 // A BranchData is used to access profiling data for a two-way branch.
a61af66fc99e Initial load duke parents: diff changeset	486 // It consists of taken and not_taken counts as well as a data displacement
a61af66fc99e Initial load duke parents: diff changeset	487 // for the taken case.
a61af66fc99e Initial load duke parents: diff changeset	488
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	489 void BranchData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
0 a61af66fc99e Initial load duke parents: diff changeset	490 assert(stream->bci() == bci(), "wrong pos");
a61af66fc99e Initial load duke parents: diff changeset	491 int target = stream->dest();
a61af66fc99e Initial load duke parents: diff changeset	492 int my_di = mdo->dp_to_di(dp());
a61af66fc99e Initial load duke parents: diff changeset	493 int target_di = mdo->bci_to_di(target);
a61af66fc99e Initial load duke parents: diff changeset	494 int offset = target_di - my_di;
a61af66fc99e Initial load duke parents: diff changeset	495 set_displacement(offset);
a61af66fc99e Initial load duke parents: diff changeset	496 }
a61af66fc99e Initial load duke parents: diff changeset	497
a61af66fc99e Initial load duke parents: diff changeset	498 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	499 void BranchData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	500 print_shared(st, "BranchData");
a61af66fc99e Initial load duke parents: diff changeset	501 st->print_cr("taken(%u) displacement(%d)",
a61af66fc99e Initial load duke parents: diff changeset	502 taken(), displacement());
a61af66fc99e Initial load duke parents: diff changeset	503 tab(st);
a61af66fc99e Initial load duke parents: diff changeset	504 st->print_cr("not taken(%u)", not_taken());
a61af66fc99e Initial load duke parents: diff changeset	505 }
a61af66fc99e Initial load duke parents: diff changeset	506 #endif
a61af66fc99e Initial load duke parents: diff changeset	507
a61af66fc99e Initial load duke parents: diff changeset	508 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	509 // MultiBranchData
a61af66fc99e Initial load duke parents: diff changeset	510 //
a61af66fc99e Initial load duke parents: diff changeset	511 // A MultiBranchData is used to access profiling information for
a61af66fc99e Initial load duke parents: diff changeset	512 // a multi-way branch (*switch bytecodes). It consists of a series
a61af66fc99e Initial load duke parents: diff changeset	513 // of (count, displacement) pairs, which count the number of times each
a61af66fc99e Initial load duke parents: diff changeset	514 // case was taken and specify the data displacment for each branch target.
a61af66fc99e Initial load duke parents: diff changeset	515
a61af66fc99e Initial load duke parents: diff changeset	516 int MultiBranchData::compute_cell_count(BytecodeStream* stream) {
a61af66fc99e Initial load duke parents: diff changeset	517 int cell_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	518 if (stream->code() == Bytecodes::_tableswitch) {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	519 Bytecode_tableswitch sw(stream->method()(), stream->bcp());
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	520 cell_count = 1 + per_case_cell_count * (1 + sw.length()); // 1 for default
0 a61af66fc99e Initial load duke parents: diff changeset	521 } else {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	522 Bytecode_lookupswitch sw(stream->method()(), stream->bcp());
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	523 cell_count = 1 + per_case_cell_count * (sw.number_of_pairs() + 1); // 1 for default
0 a61af66fc99e Initial load duke parents: diff changeset	524 }
a61af66fc99e Initial load duke parents: diff changeset	525 return cell_count;
a61af66fc99e Initial load duke parents: diff changeset	526 }
a61af66fc99e Initial load duke parents: diff changeset	527
a61af66fc99e Initial load duke parents: diff changeset	528 void MultiBranchData::post_initialize(BytecodeStream* stream,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	529 MethodData* mdo) {
0 a61af66fc99e Initial load duke parents: diff changeset	530 assert(stream->bci() == bci(), "wrong pos");
a61af66fc99e Initial load duke parents: diff changeset	531 int target;
a61af66fc99e Initial load duke parents: diff changeset	532 int my_di;
a61af66fc99e Initial load duke parents: diff changeset	533 int target_di;
a61af66fc99e Initial load duke parents: diff changeset	534 int offset;
a61af66fc99e Initial load duke parents: diff changeset	535 if (stream->code() == Bytecodes::_tableswitch) {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	536 Bytecode_tableswitch sw(stream->method()(), stream->bcp());
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	537 int len = sw.length();
0 a61af66fc99e Initial load duke parents: diff changeset	538 assert(array_len() == per_case_cell_count * (len + 1), "wrong len");
a61af66fc99e Initial load duke parents: diff changeset	539 for (int count = 0; count < len; count++) {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	540 target = sw.dest_offset_at(count) + bci();
0 a61af66fc99e Initial load duke parents: diff changeset	541 my_di = mdo->dp_to_di(dp());
a61af66fc99e Initial load duke parents: diff changeset	542 target_di = mdo->bci_to_di(target);
a61af66fc99e Initial load duke parents: diff changeset	543 offset = target_di - my_di;
a61af66fc99e Initial load duke parents: diff changeset	544 set_displacement_at(count, offset);
a61af66fc99e Initial load duke parents: diff changeset	545 }
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	546 target = sw.default_offset() + bci();
0 a61af66fc99e Initial load duke parents: diff changeset	547 my_di = mdo->dp_to_di(dp());
a61af66fc99e Initial load duke parents: diff changeset	548 target_di = mdo->bci_to_di(target);
a61af66fc99e Initial load duke parents: diff changeset	549 offset = target_di - my_di;
a61af66fc99e Initial load duke parents: diff changeset	550 set_default_displacement(offset);
a61af66fc99e Initial load duke parents: diff changeset	551
a61af66fc99e Initial load duke parents: diff changeset	552 } else {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	553 Bytecode_lookupswitch sw(stream->method()(), stream->bcp());
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	554 int npairs = sw.number_of_pairs();
0 a61af66fc99e Initial load duke parents: diff changeset	555 assert(array_len() == per_case_cell_count * (npairs + 1), "wrong len");
a61af66fc99e Initial load duke parents: diff changeset	556 for (int count = 0; count < npairs; count++) {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	557 LookupswitchPair pair = sw.pair_at(count);
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	558 target = pair.offset() + bci();
0 a61af66fc99e Initial load duke parents: diff changeset	559 my_di = mdo->dp_to_di(dp());
a61af66fc99e Initial load duke parents: diff changeset	560 target_di = mdo->bci_to_di(target);
a61af66fc99e Initial load duke parents: diff changeset	561 offset = target_di - my_di;
a61af66fc99e Initial load duke parents: diff changeset	562 set_displacement_at(count, offset);
a61af66fc99e Initial load duke parents: diff changeset	563 }
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	564 target = sw.default_offset() + bci();
0 a61af66fc99e Initial load duke parents: diff changeset	565 my_di = mdo->dp_to_di(dp());
a61af66fc99e Initial load duke parents: diff changeset	566 target_di = mdo->bci_to_di(target);
a61af66fc99e Initial load duke parents: diff changeset	567 offset = target_di - my_di;
a61af66fc99e Initial load duke parents: diff changeset	568 set_default_displacement(offset);
a61af66fc99e Initial load duke parents: diff changeset	569 }
a61af66fc99e Initial load duke parents: diff changeset	570 }
a61af66fc99e Initial load duke parents: diff changeset	571
a61af66fc99e Initial load duke parents: diff changeset	572 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	573 void MultiBranchData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	574 print_shared(st, "MultiBranchData");
a61af66fc99e Initial load duke parents: diff changeset	575 st->print_cr("default_count(%u) displacement(%d)",
a61af66fc99e Initial load duke parents: diff changeset	576 default_count(), default_displacement());
a61af66fc99e Initial load duke parents: diff changeset	577 int cases = number_of_cases();
a61af66fc99e Initial load duke parents: diff changeset	578 for (int i = 0; i < cases; i++) {
a61af66fc99e Initial load duke parents: diff changeset	579 tab(st);
a61af66fc99e Initial load duke parents: diff changeset	580 st->print_cr("count(%u) displacement(%d)",
a61af66fc99e Initial load duke parents: diff changeset	581 count_at(i), displacement_at(i));
a61af66fc99e Initial load duke parents: diff changeset	582 }
a61af66fc99e Initial load duke parents: diff changeset	583 }
a61af66fc99e Initial load duke parents: diff changeset	584 #endif
a61af66fc99e Initial load duke parents: diff changeset	585
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	586 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	587 void ArgInfoData::print_data_on(outputStream* st) const {
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	588 print_shared(st, "ArgInfoData");
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	589 int nargs = number_of_args();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	590 for (int i = 0; i < nargs; i++) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	591 st->print(" 0x%x", arg_modified(i));
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	592 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	593 st->cr();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	594 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	595
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	596 #endif
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	597
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	598 int ParametersTypeData::compute_cell_count(Method* m) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	599 if (!MethodData::profile_parameters_for_method(m)) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	600 return 0;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	601 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	602 int max = TypeProfileParmsLimit == -1 ? INT_MAX : TypeProfileParmsLimit;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	603 int obj_args = TypeStackSlotEntries::compute_cell_count(m->signature(), !m->is_static(), max);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	604 if (obj_args > 0) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	605 return obj_args + 1; // 1 cell for array len
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	606 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	607 return 0;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	608 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	609
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	610 void ParametersTypeData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	611 _parameters.post_initialize(mdo->method()->signature(), !mdo->method()->is_static(), true);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	612 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	613
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	614 bool ParametersTypeData::profiling_enabled() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	615 return MethodData::profile_parameters();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	616 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	617
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	618 #ifndef PRODUCT
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	619 void ParametersTypeData::print_data_on(outputStream* st) const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	620 st->print("parameter types");
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	621 _parameters.print_data_on(st);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	622 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	623 #endif
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	624
0 a61af66fc99e Initial load duke parents: diff changeset	625 // ==================================================================
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	626 // MethodData*
0 a61af66fc99e Initial load duke parents: diff changeset	627 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	628 // A MethodData* holds information which has been collected about
0 a61af66fc99e Initial load duke parents: diff changeset	629 // a method.
a61af66fc99e Initial load duke parents: diff changeset	630
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	631 MethodData* MethodData::allocate(ClassLoaderData* loader_data, methodHandle method, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	632 int size = MethodData::compute_allocation_size_in_words(method);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	633
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10107 diff changeset	634 return new (loader_data, size, false, MetaspaceObj::MethodDataType, THREAD)
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10107 diff changeset	635 MethodData(method(), size, CHECK_NULL);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	636 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	637
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	638 int MethodData::bytecode_cell_count(Bytecodes::Code code) {
8860 46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	639 #if defined(COMPILER1) && !defined(COMPILER2)
46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	640 return no_profile_data;
46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	641 #else
0 a61af66fc99e Initial load duke parents: diff changeset	642 switch (code) {
a61af66fc99e Initial load duke parents: diff changeset	643 case Bytecodes::_checkcast:
a61af66fc99e Initial load duke parents: diff changeset	644 case Bytecodes::_instanceof:
a61af66fc99e Initial load duke parents: diff changeset	645 case Bytecodes::_aastore:
a61af66fc99e Initial load duke parents: diff changeset	646 if (TypeProfileCasts) {
a61af66fc99e Initial load duke parents: diff changeset	647 return ReceiverTypeData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	648 } else {
a61af66fc99e Initial load duke parents: diff changeset	649 return BitData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	650 }
a61af66fc99e Initial load duke parents: diff changeset	651 case Bytecodes::_invokespecial:
a61af66fc99e Initial load duke parents: diff changeset	652 case Bytecodes::_invokestatic:
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	653 if (MethodData::profile_arguments() \|\| MethodData::profile_return()) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	654 return variable_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	655 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	656 return CounterData::static_cell_count();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	657 }
0 a61af66fc99e Initial load duke parents: diff changeset	658 case Bytecodes::_goto:
a61af66fc99e Initial load duke parents: diff changeset	659 case Bytecodes::_goto_w:
a61af66fc99e Initial load duke parents: diff changeset	660 case Bytecodes::_jsr:
a61af66fc99e Initial load duke parents: diff changeset	661 case Bytecodes::_jsr_w:
a61af66fc99e Initial load duke parents: diff changeset	662 return JumpData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	663 case Bytecodes::_invokevirtual:
a61af66fc99e Initial load duke parents: diff changeset	664 case Bytecodes::_invokeinterface:
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	665 if (MethodData::profile_arguments() \|\| MethodData::profile_return()) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	666 return variable_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	667 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	668 return VirtualCallData::static_cell_count();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	669 }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	670 case Bytecodes::_invokedynamic:
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	671 if (MethodData::profile_arguments() \|\| MethodData::profile_return()) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	672 return variable_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	673 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	674 return CounterData::static_cell_count();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	675 }
0 a61af66fc99e Initial load duke parents: diff changeset	676 case Bytecodes::_ret:
a61af66fc99e Initial load duke parents: diff changeset	677 return RetData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	678 case Bytecodes::_ifeq:
a61af66fc99e Initial load duke parents: diff changeset	679 case Bytecodes::_ifne:
a61af66fc99e Initial load duke parents: diff changeset	680 case Bytecodes::_iflt:
a61af66fc99e Initial load duke parents: diff changeset	681 case Bytecodes::_ifge:
a61af66fc99e Initial load duke parents: diff changeset	682 case Bytecodes::_ifgt:
a61af66fc99e Initial load duke parents: diff changeset	683 case Bytecodes::_ifle:
a61af66fc99e Initial load duke parents: diff changeset	684 case Bytecodes::_if_icmpeq:
a61af66fc99e Initial load duke parents: diff changeset	685 case Bytecodes::_if_icmpne:
a61af66fc99e Initial load duke parents: diff changeset	686 case Bytecodes::_if_icmplt:
a61af66fc99e Initial load duke parents: diff changeset	687 case Bytecodes::_if_icmpge:
a61af66fc99e Initial load duke parents: diff changeset	688 case Bytecodes::_if_icmpgt:
a61af66fc99e Initial load duke parents: diff changeset	689 case Bytecodes::_if_icmple:
a61af66fc99e Initial load duke parents: diff changeset	690 case Bytecodes::_if_acmpeq:
a61af66fc99e Initial load duke parents: diff changeset	691 case Bytecodes::_if_acmpne:
a61af66fc99e Initial load duke parents: diff changeset	692 case Bytecodes::_ifnull:
a61af66fc99e Initial load duke parents: diff changeset	693 case Bytecodes::_ifnonnull:
a61af66fc99e Initial load duke parents: diff changeset	694 return BranchData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	695 case Bytecodes::_lookupswitch:
a61af66fc99e Initial load duke parents: diff changeset	696 case Bytecodes::_tableswitch:
a61af66fc99e Initial load duke parents: diff changeset	697 return variable_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	698 }
a61af66fc99e Initial load duke parents: diff changeset	699 return no_profile_data;
8860 46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	700 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	701 }
a61af66fc99e Initial load duke parents: diff changeset	702
a61af66fc99e Initial load duke parents: diff changeset	703 // Compute the size of the profiling information corresponding to
a61af66fc99e Initial load duke parents: diff changeset	704 // the current bytecode.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	705 int MethodData::compute_data_size(BytecodeStream* stream) {
0 a61af66fc99e Initial load duke parents: diff changeset	706 int cell_count = bytecode_cell_count(stream->code());
a61af66fc99e Initial load duke parents: diff changeset	707 if (cell_count == no_profile_data) {
a61af66fc99e Initial load duke parents: diff changeset	708 return 0;
a61af66fc99e Initial load duke parents: diff changeset	709 }
a61af66fc99e Initial load duke parents: diff changeset	710 if (cell_count == variable_cell_count) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	711 switch (stream->code()) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	712 case Bytecodes::_lookupswitch:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	713 case Bytecodes::_tableswitch:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	714 cell_count = MultiBranchData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	715 break;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	716 case Bytecodes::_invokespecial:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	717 case Bytecodes::_invokestatic:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	718 case Bytecodes::_invokedynamic:
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	719 assert(MethodData::profile_arguments() \|\| MethodData::profile_return(), "should be collecting args profile");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	720 if (profile_arguments_for_invoke(stream->method(), stream->bci()) \|\|
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	721 profile_return_for_invoke(stream->method(), stream->bci())) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	722 cell_count = CallTypeData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	723 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	724 cell_count = CounterData::static_cell_count();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	725 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	726 break;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	727 case Bytecodes::_invokevirtual:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	728 case Bytecodes::_invokeinterface: {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	729 assert(MethodData::profile_arguments() \|\| MethodData::profile_return(), "should be collecting args profile");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	730 if (profile_arguments_for_invoke(stream->method(), stream->bci()) \|\|
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	731 profile_return_for_invoke(stream->method(), stream->bci())) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	732 cell_count = VirtualCallTypeData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	733 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	734 cell_count = VirtualCallData::static_cell_count();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	735 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	736 break;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	737 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	738 default:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	739 fatal("unexpected bytecode for var length profile data");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	740 }
0 a61af66fc99e Initial load duke parents: diff changeset	741 }
a61af66fc99e Initial load duke parents: diff changeset	742 // Note: cell_count might be zero, meaning that there is just
a61af66fc99e Initial load duke parents: diff changeset	743 // a DataLayout header, with no extra cells.
a61af66fc99e Initial load duke parents: diff changeset	744 assert(cell_count >= 0, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	745 return DataLayout::compute_size_in_bytes(cell_count);
a61af66fc99e Initial load duke parents: diff changeset	746 }
a61af66fc99e Initial load duke parents: diff changeset	747
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	748 int MethodData::compute_extra_data_count(int data_size, int empty_bc_count) {
0 a61af66fc99e Initial load duke parents: diff changeset	749 if (ProfileTraps) {
a61af66fc99e Initial load duke parents: diff changeset	750 // Assume that up to 3% of BCIs with no MDP will need to allocate one.
a61af66fc99e Initial load duke parents: diff changeset	751 int extra_data_count = (uint)(empty_bc_count * 3) / 128 + 1;
a61af66fc99e Initial load duke parents: diff changeset	752 // If the method is large, let the extra BCIs grow numerous (to ~1%).
a61af66fc99e Initial load duke parents: diff changeset	753 int one_percent_of_data
a61af66fc99e Initial load duke parents: diff changeset	754 = (uint)data_size / (DataLayout::header_size_in_bytes()*128);
a61af66fc99e Initial load duke parents: diff changeset	755 if (extra_data_count < one_percent_of_data)
a61af66fc99e Initial load duke parents: diff changeset	756 extra_data_count = one_percent_of_data;
a61af66fc99e Initial load duke parents: diff changeset	757 if (extra_data_count > empty_bc_count)
a61af66fc99e Initial load duke parents: diff changeset	758 extra_data_count = empty_bc_count; // no need for more
a61af66fc99e Initial load duke parents: diff changeset	759 return extra_data_count;
a61af66fc99e Initial load duke parents: diff changeset	760 } else {
a61af66fc99e Initial load duke parents: diff changeset	761 return 0;
a61af66fc99e Initial load duke parents: diff changeset	762 }
a61af66fc99e Initial load duke parents: diff changeset	763 }
a61af66fc99e Initial load duke parents: diff changeset	764
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	765 // Compute the size of the MethodData* necessary to store
0 a61af66fc99e Initial load duke parents: diff changeset	766 // profiling information about a given method. Size is in bytes.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	767 int MethodData::compute_allocation_size_in_bytes(methodHandle method) {
0 a61af66fc99e Initial load duke parents: diff changeset	768 int data_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	769 BytecodeStream stream(method);
a61af66fc99e Initial load duke parents: diff changeset	770 Bytecodes::Code c;
a61af66fc99e Initial load duke parents: diff changeset	771 int empty_bc_count = 0; // number of bytecodes lacking data
a61af66fc99e Initial load duke parents: diff changeset	772 while ((c = stream.next()) >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	773 int size_in_bytes = compute_data_size(&stream);
a61af66fc99e Initial load duke parents: diff changeset	774 data_size += size_in_bytes;
a61af66fc99e Initial load duke parents: diff changeset	775 if (size_in_bytes == 0) empty_bc_count += 1;
a61af66fc99e Initial load duke parents: diff changeset	776 }
a61af66fc99e Initial load duke parents: diff changeset	777 int object_size = in_bytes(data_offset()) + data_size;
a61af66fc99e Initial load duke parents: diff changeset	778
a61af66fc99e Initial load duke parents: diff changeset	779 // Add some extra DataLayout cells (at least one) to track stray traps.
a61af66fc99e Initial load duke parents: diff changeset	780 int extra_data_count = compute_extra_data_count(data_size, empty_bc_count);
a61af66fc99e Initial load duke parents: diff changeset	781 object_size += extra_data_count * DataLayout::compute_size_in_bytes(0);
a61af66fc99e Initial load duke parents: diff changeset	782
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	783 // Add a cell to record information about modified arguments.
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	784 int arg_size = method->size_of_parameters();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	785 object_size += DataLayout::compute_size_in_bytes(arg_size+1);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	786
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	787 // Reserve room for an area of the MDO dedicated to profiling of
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	788 // parameters
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	789 int args_cell = ParametersTypeData::compute_cell_count(method());
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	790 if (args_cell > 0) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	791 object_size += DataLayout::compute_size_in_bytes(args_cell);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	792 }
0 a61af66fc99e Initial load duke parents: diff changeset	793 return object_size;
a61af66fc99e Initial load duke parents: diff changeset	794 }
a61af66fc99e Initial load duke parents: diff changeset	795
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	796 // Compute the size of the MethodData* necessary to store
0 a61af66fc99e Initial load duke parents: diff changeset	797 // profiling information about a given method. Size is in words
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	798 int MethodData::compute_allocation_size_in_words(methodHandle method) {
0 a61af66fc99e Initial load duke parents: diff changeset	799 int byte_size = compute_allocation_size_in_bytes(method);
a61af66fc99e Initial load duke parents: diff changeset	800 int word_size = align_size_up(byte_size, BytesPerWord) / BytesPerWord;
a61af66fc99e Initial load duke parents: diff changeset	801 return align_object_size(word_size);
a61af66fc99e Initial load duke parents: diff changeset	802 }
a61af66fc99e Initial load duke parents: diff changeset	803
a61af66fc99e Initial load duke parents: diff changeset	804 // Initialize an individual data segment. Returns the size of
a61af66fc99e Initial load duke parents: diff changeset	805 // the segment in bytes.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	806 int MethodData::initialize_data(BytecodeStream* stream,
0 a61af66fc99e Initial load duke parents: diff changeset	807 int data_index) {
8860 46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	808 #if defined(COMPILER1) && !defined(COMPILER2)
46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	809 return 0;
46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	810 #else
0 a61af66fc99e Initial load duke parents: diff changeset	811 int cell_count = -1;
a61af66fc99e Initial load duke parents: diff changeset	812 int tag = DataLayout::no_tag;
a61af66fc99e Initial load duke parents: diff changeset	813 DataLayout* data_layout = data_layout_at(data_index);
a61af66fc99e Initial load duke parents: diff changeset	814 Bytecodes::Code c = stream->code();
a61af66fc99e Initial load duke parents: diff changeset	815 switch (c) {
a61af66fc99e Initial load duke parents: diff changeset	816 case Bytecodes::_checkcast:
a61af66fc99e Initial load duke parents: diff changeset	817 case Bytecodes::_instanceof:
a61af66fc99e Initial load duke parents: diff changeset	818 case Bytecodes::_aastore:
a61af66fc99e Initial load duke parents: diff changeset	819 if (TypeProfileCasts) {
a61af66fc99e Initial load duke parents: diff changeset	820 cell_count = ReceiverTypeData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	821 tag = DataLayout::receiver_type_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	822 } else {
a61af66fc99e Initial load duke parents: diff changeset	823 cell_count = BitData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	824 tag = DataLayout::bit_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	825 }
a61af66fc99e Initial load duke parents: diff changeset	826 break;
a61af66fc99e Initial load duke parents: diff changeset	827 case Bytecodes::_invokespecial:
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	828 case Bytecodes::_invokestatic: {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	829 int counter_data_cell_count = CounterData::static_cell_count();
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	830 if (profile_arguments_for_invoke(stream->method(), stream->bci()) \|\|
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	831 profile_return_for_invoke(stream->method(), stream->bci())) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	832 cell_count = CallTypeData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	833 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	834 cell_count = counter_data_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	835 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	836 if (cell_count > counter_data_cell_count) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	837 tag = DataLayout::call_type_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	838 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	839 tag = DataLayout::counter_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	840 }
0 a61af66fc99e Initial load duke parents: diff changeset	841 break;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	842 }
0 a61af66fc99e Initial load duke parents: diff changeset	843 case Bytecodes::_goto:
a61af66fc99e Initial load duke parents: diff changeset	844 case Bytecodes::_goto_w:
a61af66fc99e Initial load duke parents: diff changeset	845 case Bytecodes::_jsr:
a61af66fc99e Initial load duke parents: diff changeset	846 case Bytecodes::_jsr_w:
a61af66fc99e Initial load duke parents: diff changeset	847 cell_count = JumpData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	848 tag = DataLayout::jump_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	849 break;
a61af66fc99e Initial load duke parents: diff changeset	850 case Bytecodes::_invokevirtual:
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	851 case Bytecodes::_invokeinterface: {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	852 int virtual_call_data_cell_count = VirtualCallData::static_cell_count();
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	853 if (profile_arguments_for_invoke(stream->method(), stream->bci()) \|\|
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	854 profile_return_for_invoke(stream->method(), stream->bci())) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	855 cell_count = VirtualCallTypeData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	856 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	857 cell_count = virtual_call_data_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	858 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	859 if (cell_count > virtual_call_data_cell_count) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	860 tag = DataLayout::virtual_call_type_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	861 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	862 tag = DataLayout::virtual_call_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	863 }
0 a61af66fc99e Initial load duke parents: diff changeset	864 break;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	865 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	866 case Bytecodes::_invokedynamic: {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	867 // %%% should make a type profile for any invokedynamic that takes a ref argument
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	868 int counter_data_cell_count = CounterData::static_cell_count();
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	869 if (profile_arguments_for_invoke(stream->method(), stream->bci()) \|\|
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	870 profile_return_for_invoke(stream->method(), stream->bci())) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	871 cell_count = CallTypeData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	872 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	873 cell_count = counter_data_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	874 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	875 if (cell_count > counter_data_cell_count) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	876 tag = DataLayout::call_type_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	877 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	878 tag = DataLayout::counter_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	879 }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	880 break;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	881 }
0 a61af66fc99e Initial load duke parents: diff changeset	882 case Bytecodes::_ret:
a61af66fc99e Initial load duke parents: diff changeset	883 cell_count = RetData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	884 tag = DataLayout::ret_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	885 break;
a61af66fc99e Initial load duke parents: diff changeset	886 case Bytecodes::_ifeq:
a61af66fc99e Initial load duke parents: diff changeset	887 case Bytecodes::_ifne:
a61af66fc99e Initial load duke parents: diff changeset	888 case Bytecodes::_iflt:
a61af66fc99e Initial load duke parents: diff changeset	889 case Bytecodes::_ifge:
a61af66fc99e Initial load duke parents: diff changeset	890 case Bytecodes::_ifgt:
a61af66fc99e Initial load duke parents: diff changeset	891 case Bytecodes::_ifle:
a61af66fc99e Initial load duke parents: diff changeset	892 case Bytecodes::_if_icmpeq:
a61af66fc99e Initial load duke parents: diff changeset	893 case Bytecodes::_if_icmpne:
a61af66fc99e Initial load duke parents: diff changeset	894 case Bytecodes::_if_icmplt:
a61af66fc99e Initial load duke parents: diff changeset	895 case Bytecodes::_if_icmpge:
a61af66fc99e Initial load duke parents: diff changeset	896 case Bytecodes::_if_icmpgt:
a61af66fc99e Initial load duke parents: diff changeset	897 case Bytecodes::_if_icmple:
a61af66fc99e Initial load duke parents: diff changeset	898 case Bytecodes::_if_acmpeq:
a61af66fc99e Initial load duke parents: diff changeset	899 case Bytecodes::_if_acmpne:
a61af66fc99e Initial load duke parents: diff changeset	900 case Bytecodes::_ifnull:
a61af66fc99e Initial load duke parents: diff changeset	901 case Bytecodes::_ifnonnull:
a61af66fc99e Initial load duke parents: diff changeset	902 cell_count = BranchData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	903 tag = DataLayout::branch_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	904 break;
a61af66fc99e Initial load duke parents: diff changeset	905 case Bytecodes::_lookupswitch:
a61af66fc99e Initial load duke parents: diff changeset	906 case Bytecodes::_tableswitch:
a61af66fc99e Initial load duke parents: diff changeset	907 cell_count = MultiBranchData::compute_cell_count(stream);
a61af66fc99e Initial load duke parents: diff changeset	908 tag = DataLayout::multi_branch_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	909 break;
a61af66fc99e Initial load duke parents: diff changeset	910 }
a61af66fc99e Initial load duke parents: diff changeset	911 assert(tag == DataLayout::multi_branch_data_tag \|\|
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	912 ((MethodData::profile_arguments() \|\| MethodData::profile_return()) &&
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	913 (tag == DataLayout::call_type_data_tag \|\|
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	914 tag == DataLayout::counter_data_tag \|\|
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	915 tag == DataLayout::virtual_call_type_data_tag \|\|
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	916 tag == DataLayout::virtual_call_data_tag)) \|\|
0 a61af66fc99e Initial load duke parents: diff changeset	917 cell_count == bytecode_cell_count(c), "cell counts must agree");
a61af66fc99e Initial load duke parents: diff changeset	918 if (cell_count >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	919 assert(tag != DataLayout::no_tag, "bad tag");
a61af66fc99e Initial load duke parents: diff changeset	920 assert(bytecode_has_profile(c), "agree w/ BHP");
a61af66fc99e Initial load duke parents: diff changeset	921 data_layout->initialize(tag, stream->bci(), cell_count);
a61af66fc99e Initial load duke parents: diff changeset	922 return DataLayout::compute_size_in_bytes(cell_count);
a61af66fc99e Initial load duke parents: diff changeset	923 } else {
a61af66fc99e Initial load duke parents: diff changeset	924 assert(!bytecode_has_profile(c), "agree w/ !BHP");
a61af66fc99e Initial load duke parents: diff changeset	925 return 0;
a61af66fc99e Initial load duke parents: diff changeset	926 }
8860 46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	927 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	928 }
a61af66fc99e Initial load duke parents: diff changeset	929
a61af66fc99e Initial load duke parents: diff changeset	930 // Get the data at an arbitrary (sort of) data index.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	931 ProfileData* MethodData::data_at(int data_index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	932 if (out_of_bounds(data_index)) {
a61af66fc99e Initial load duke parents: diff changeset	933 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	934 }
a61af66fc99e Initial load duke parents: diff changeset	935 DataLayout* data_layout = data_layout_at(data_index);
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	936 return data_layout->data_in();
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	937 }
0 a61af66fc99e Initial load duke parents: diff changeset	938
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	939 ProfileData* DataLayout::data_in() {
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	940 switch (tag()) {
0 a61af66fc99e Initial load duke parents: diff changeset	941 case DataLayout::no_tag:
a61af66fc99e Initial load duke parents: diff changeset	942 default:
a61af66fc99e Initial load duke parents: diff changeset	943 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	944 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	945 case DataLayout::bit_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	946 return new BitData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	947 case DataLayout::counter_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	948 return new CounterData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	949 case DataLayout::jump_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	950 return new JumpData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	951 case DataLayout::receiver_type_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	952 return new ReceiverTypeData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	953 case DataLayout::virtual_call_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	954 return new VirtualCallData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	955 case DataLayout::ret_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	956 return new RetData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	957 case DataLayout::branch_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	958 return new BranchData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	959 case DataLayout::multi_branch_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	960 return new MultiBranchData(this);
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	961 case DataLayout::arg_info_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	962 return new ArgInfoData(this);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	963 case DataLayout::call_type_data_tag:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	964 return new CallTypeData(this);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	965 case DataLayout::virtual_call_type_data_tag:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	966 return new VirtualCallTypeData(this);
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	967 case DataLayout::parameters_type_data_tag:
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	968 return new ParametersTypeData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	969 };
a61af66fc99e Initial load duke parents: diff changeset	970 }
a61af66fc99e Initial load duke parents: diff changeset	971
a61af66fc99e Initial load duke parents: diff changeset	972 // Iteration over data.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	973 ProfileData* MethodData::next_data(ProfileData* current) const {
0 a61af66fc99e Initial load duke parents: diff changeset	974 int current_index = dp_to_di(current->dp());
a61af66fc99e Initial load duke parents: diff changeset	975 int next_index = current_index + current->size_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	976 ProfileData* next = data_at(next_index);
a61af66fc99e Initial load duke parents: diff changeset	977 return next;
a61af66fc99e Initial load duke parents: diff changeset	978 }
a61af66fc99e Initial load duke parents: diff changeset	979
a61af66fc99e Initial load duke parents: diff changeset	980 // Give each of the data entries a chance to perform specific
a61af66fc99e Initial load duke parents: diff changeset	981 // data initialization.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	982 void MethodData::post_initialize(BytecodeStream* stream) {
0 a61af66fc99e Initial load duke parents: diff changeset	983 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	984 ProfileData* data;
a61af66fc99e Initial load duke parents: diff changeset	985 for (data = first_data(); is_valid(data); data = next_data(data)) {
a61af66fc99e Initial load duke parents: diff changeset	986 stream->set_start(data->bci());
a61af66fc99e Initial load duke parents: diff changeset	987 stream->next();
a61af66fc99e Initial load duke parents: diff changeset	988 data->post_initialize(stream, this);
a61af66fc99e Initial load duke parents: diff changeset	989 }
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	990 if (_parameters_type_data_di != -1) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	991 parameters_type_data()->post_initialize(NULL, this);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	992 }
0 a61af66fc99e Initial load duke parents: diff changeset	993 }
a61af66fc99e Initial load duke parents: diff changeset	994
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	995 // Initialize the MethodData* corresponding to a given method.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	996 MethodData::MethodData(methodHandle method, int size, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	997 No_Safepoint_Verifier no_safepoint; // init function atomic wrt GC
0 a61af66fc99e Initial load duke parents: diff changeset	998 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	999 // Set the method back-pointer.
a61af66fc99e Initial load duke parents: diff changeset	1000 _method = method();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1001
9080 b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1002 init();
0 a61af66fc99e Initial load duke parents: diff changeset	1003 set_creation_mileage(mileage_of(method()));
a61af66fc99e Initial load duke parents: diff changeset	1004
a61af66fc99e Initial load duke parents: diff changeset	1005 // Go through the bytecodes and allocate and initialize the
a61af66fc99e Initial load duke parents: diff changeset	1006 // corresponding data cells.
a61af66fc99e Initial load duke parents: diff changeset	1007 int data_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	1008 int empty_bc_count = 0; // number of bytecodes lacking data
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 7956 diff changeset	1009 _data[0] = 0; // apparently not set below.
0 a61af66fc99e Initial load duke parents: diff changeset	1010 BytecodeStream stream(method);
a61af66fc99e Initial load duke parents: diff changeset	1011 Bytecodes::Code c;
a61af66fc99e Initial load duke parents: diff changeset	1012 while ((c = stream.next()) >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	1013 int size_in_bytes = initialize_data(&stream, data_size);
a61af66fc99e Initial load duke parents: diff changeset	1014 data_size += size_in_bytes;
a61af66fc99e Initial load duke parents: diff changeset	1015 if (size_in_bytes == 0) empty_bc_count += 1;
a61af66fc99e Initial load duke parents: diff changeset	1016 }
a61af66fc99e Initial load duke parents: diff changeset	1017 _data_size = data_size;
a61af66fc99e Initial load duke parents: diff changeset	1018 int object_size = in_bytes(data_offset()) + data_size;
a61af66fc99e Initial load duke parents: diff changeset	1019
a61af66fc99e Initial load duke parents: diff changeset	1020 // Add some extra DataLayout cells (at least one) to track stray traps.
a61af66fc99e Initial load duke parents: diff changeset	1021 int extra_data_count = compute_extra_data_count(data_size, empty_bc_count);
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1022 int extra_size = extra_data_count * DataLayout::compute_size_in_bytes(0);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1023
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1024 // Add a cell to record information about modified arguments.
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1025 // Set up _args_modified array after traps cells so that
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1026 // the code for traps cells works.
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1027 DataLayout *dp = data_layout_at(data_size + extra_size);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1028
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1029 int arg_size = method->size_of_parameters();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1030 dp->initialize(DataLayout::arg_info_data_tag, 0, arg_size+1);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1031
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1032 int arg_data_size = DataLayout::compute_size_in_bytes(arg_size+1);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1033 object_size += extra_size + arg_data_size;
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 int args_cell = ParametersTypeData::compute_cell_count(method());
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1036 // If we are profiling parameters, we reserver an area near the end
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1037 // of the MDO after the slots for bytecodes (because there's no bci
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1038 // for method entry so they don't fit with the framework for the
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1039 // profiling of bytecodes). We store the offset within the MDO of
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1040 // this area (or -1 if no parameter is profiled)
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1041 if (args_cell > 0) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1042 object_size += DataLayout::compute_size_in_bytes(args_cell);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1043 _parameters_type_data_di = data_size + extra_size + arg_data_size;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1044 DataLayout *dp = data_layout_at(data_size + extra_size + arg_data_size);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1045 dp->initialize(DataLayout::parameters_type_data_tag, 0, args_cell);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1046 } else {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1047 _parameters_type_data_di = -1;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1048 }
0 a61af66fc99e Initial load duke parents: diff changeset	1049
a61af66fc99e Initial load duke parents: diff changeset	1050 // Set an initial hint. Don't use set_hint_di() because
a61af66fc99e Initial load duke parents: diff changeset	1051 // first_di() may be out of bounds if data_size is 0.
a61af66fc99e Initial load duke parents: diff changeset	1052 // In that situation, _hint_di is never used, but at
a61af66fc99e Initial load duke parents: diff changeset	1053 // least well-defined.
a61af66fc99e Initial load duke parents: diff changeset	1054 _hint_di = first_di();
a61af66fc99e Initial load duke parents: diff changeset	1055
a61af66fc99e Initial load duke parents: diff changeset	1056 post_initialize(&stream);
a61af66fc99e Initial load duke parents: diff changeset	1057
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1058 set_size(object_size);
9080 b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1059 }
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 7956 diff changeset	1060
9080 b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1061 void MethodData::init() {
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1062 _invocation_counter.init();
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1063 _backedge_counter.init();
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1064 _invocation_counter_start = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1065 _backedge_counter_start = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1066 _num_loops = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1067 _num_blocks = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1068 _highest_comp_level = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1069 _highest_osr_comp_level = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1070 _would_profile = true;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1071
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1072 // Initialize flags and trap history.
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1073 _nof_decompiles = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1074 _nof_overflow_recompiles = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1075 _nof_overflow_traps = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1076 clear_escape_info();
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1077 assert(sizeof(_trap_hist) % sizeof(HeapWord) == 0, "align");
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1078 Copy::zero_to_words((HeapWord*) &_trap_hist,
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1079 sizeof(_trap_hist) / sizeof(HeapWord));
0 a61af66fc99e Initial load duke parents: diff changeset	1080 }
a61af66fc99e Initial load duke parents: diff changeset	1081
a61af66fc99e Initial load duke parents: diff changeset	1082 // Get a measure of how much mileage the method has on it.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1083 int MethodData::mileage_of(Method* method) {
0 a61af66fc99e Initial load duke parents: diff changeset	1084 int mileage = 0;
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1085 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1086 mileage = MAX2(method->invocation_count(), method->backedge_count());
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1087 } else {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1088 int iic = method->interpreter_invocation_count();
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1089 if (mileage < iic) mileage = iic;
10105 aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1090 MethodCounters* mcs = method->method_counters();
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1091 if (mcs != NULL) {
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1092 InvocationCounter* ic = mcs->invocation_counter();
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1093 InvocationCounter* bc = mcs->backedge_counter();
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1094 int icval = ic->count();
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1095 if (ic->carry()) icval += CompileThreshold;
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1096 if (mileage < icval) mileage = icval;
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1097 int bcval = bc->count();
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1098 if (bc->carry()) bcval += CompileThreshold;
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1099 if (mileage < bcval) mileage = bcval;
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1100 }
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1101 }
0 a61af66fc99e Initial load duke parents: diff changeset	1102 return mileage;
a61af66fc99e Initial load duke parents: diff changeset	1103 }
a61af66fc99e Initial load duke parents: diff changeset	1104
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1105 bool MethodData::is_mature() const {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1106 return CompilationPolicy::policy()->is_mature(_method);
0 a61af66fc99e Initial load duke parents: diff changeset	1107 }
a61af66fc99e Initial load duke parents: diff changeset	1108
a61af66fc99e Initial load duke parents: diff changeset	1109 // Translate a bci to its corresponding data index (di).
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1110 address MethodData::bci_to_dp(int bci) {
0 a61af66fc99e Initial load duke parents: diff changeset	1111 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1112 ProfileData* data = data_before(bci);
a61af66fc99e Initial load duke parents: diff changeset	1113 ProfileData* prev = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1114 for ( ; is_valid(data); data = next_data(data)) {
a61af66fc99e Initial load duke parents: diff changeset	1115 if (data->bci() >= bci) {
a61af66fc99e Initial load duke parents: diff changeset	1116 if (data->bci() == bci) set_hint_di(dp_to_di(data->dp()));
a61af66fc99e Initial load duke parents: diff changeset	1117 else if (prev != NULL) set_hint_di(dp_to_di(prev->dp()));
a61af66fc99e Initial load duke parents: diff changeset	1118 return data->dp();
a61af66fc99e Initial load duke parents: diff changeset	1119 }
a61af66fc99e Initial load duke parents: diff changeset	1120 prev = data;
a61af66fc99e Initial load duke parents: diff changeset	1121 }
a61af66fc99e Initial load duke parents: diff changeset	1122 return (address)limit_data_position();
a61af66fc99e Initial load duke parents: diff changeset	1123 }
a61af66fc99e Initial load duke parents: diff changeset	1124
a61af66fc99e Initial load duke parents: diff changeset	1125 // Translate a bci to its corresponding data, or NULL.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1126 ProfileData* MethodData::bci_to_data(int bci) {
0 a61af66fc99e Initial load duke parents: diff changeset	1127 ProfileData* data = data_before(bci);
a61af66fc99e Initial load duke parents: diff changeset	1128 for ( ; is_valid(data); data = next_data(data)) {
a61af66fc99e Initial load duke parents: diff changeset	1129 if (data->bci() == bci) {
a61af66fc99e Initial load duke parents: diff changeset	1130 set_hint_di(dp_to_di(data->dp()));
a61af66fc99e Initial load duke parents: diff changeset	1131 return data;
a61af66fc99e Initial load duke parents: diff changeset	1132 } else if (data->bci() > bci) {
a61af66fc99e Initial load duke parents: diff changeset	1133 break;
a61af66fc99e Initial load duke parents: diff changeset	1134 }
a61af66fc99e Initial load duke parents: diff changeset	1135 }
a61af66fc99e Initial load duke parents: diff changeset	1136 return bci_to_extra_data(bci, false);
a61af66fc99e Initial load duke parents: diff changeset	1137 }
a61af66fc99e Initial load duke parents: diff changeset	1138
a61af66fc99e Initial load duke parents: diff changeset	1139 // Translate a bci to its corresponding extra data, or NULL.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1140 ProfileData* MethodData::bci_to_extra_data(int bci, bool create_if_missing) {
0 a61af66fc99e Initial load duke parents: diff changeset	1141 DataLayout* dp = extra_data_base();
a61af66fc99e Initial load duke parents: diff changeset	1142 DataLayout* end = extra_data_limit();
a61af66fc99e Initial load duke parents: diff changeset	1143 DataLayout* avail = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1144 for (; dp < end; dp = next_extra(dp)) {
a61af66fc99e Initial load duke parents: diff changeset	1145 // No need for "OrderAccess::load_acquire" ops,
a61af66fc99e Initial load duke parents: diff changeset	1146 // since the data structure is monotonic.
a61af66fc99e Initial load duke parents: diff changeset	1147 if (dp->tag() == DataLayout::no_tag) break;
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1148 if (dp->tag() == DataLayout::arg_info_data_tag) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1149 dp = end; // ArgInfoData is at the end of extra data section.
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1150 break;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1151 }
0 a61af66fc99e Initial load duke parents: diff changeset	1152 if (dp->bci() == bci) {
a61af66fc99e Initial load duke parents: diff changeset	1153 assert(dp->tag() == DataLayout::bit_data_tag, "sane");
a61af66fc99e Initial load duke parents: diff changeset	1154 return new BitData(dp);
a61af66fc99e Initial load duke parents: diff changeset	1155 }
a61af66fc99e Initial load duke parents: diff changeset	1156 }
a61af66fc99e Initial load duke parents: diff changeset	1157 if (create_if_missing && dp < end) {
a61af66fc99e Initial load duke parents: diff changeset	1158 // Allocate this one. There is no mutual exclusion,
a61af66fc99e Initial load duke parents: diff changeset	1159 // so two threads could allocate different BCIs to the
a61af66fc99e Initial load duke parents: diff changeset	1160 // same data layout. This means these extra data
a61af66fc99e Initial load duke parents: diff changeset	1161 // records, like most other MDO contents, must not be
a61af66fc99e Initial load duke parents: diff changeset	1162 // trusted too much.
a61af66fc99e Initial load duke parents: diff changeset	1163 DataLayout temp;
a61af66fc99e Initial load duke parents: diff changeset	1164 temp.initialize(DataLayout::bit_data_tag, bci, 0);
a61af66fc99e Initial load duke parents: diff changeset	1165 dp->release_set_header(temp.header());
a61af66fc99e Initial load duke parents: diff changeset	1166 assert(dp->tag() == DataLayout::bit_data_tag, "sane");
a61af66fc99e Initial load duke parents: diff changeset	1167 //NO: assert(dp->bci() == bci, "no concurrent allocation");
a61af66fc99e Initial load duke parents: diff changeset	1168 return new BitData(dp);
a61af66fc99e Initial load duke parents: diff changeset	1169 }
a61af66fc99e Initial load duke parents: diff changeset	1170 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1171 }
a61af66fc99e Initial load duke parents: diff changeset	1172
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1173 ArgInfoData *MethodData::arg_info() {
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1174 DataLayout* dp = extra_data_base();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1175 DataLayout* end = extra_data_limit();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1176 for (; dp < end; dp = next_extra(dp)) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1177 if (dp->tag() == DataLayout::arg_info_data_tag)
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1178 return new ArgInfoData(dp);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1179 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1180 return NULL;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1181 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1182
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1183 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1184
0 a61af66fc99e Initial load duke parents: diff changeset	1185 #ifndef PRODUCT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1186
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1187 void MethodData::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1188 assert(is_methodData(), "should be method data");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1189 st->print("method data for ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1190 method()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1191 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1192 print_data_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1193 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1194
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1195 #endif //PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1196
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1197 void MethodData::print_value_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1198 assert(is_methodData(), "should be method data");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1199 st->print("method data for ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1200 method()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1201 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1202
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1203 #ifndef PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1204 void MethodData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1205 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1206 ProfileData* data = first_data();
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1207 if (_parameters_type_data_di != -1) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1208 parameters_type_data()->print_data_on(st);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1209 }
0 a61af66fc99e Initial load duke parents: diff changeset	1210 for ( ; is_valid(data); data = next_data(data)) {
a61af66fc99e Initial load duke parents: diff changeset	1211 st->print("%d", dp_to_di(data->dp()));
a61af66fc99e Initial load duke parents: diff changeset	1212 st->fill_to(6);
a61af66fc99e Initial load duke parents: diff changeset	1213 data->print_data_on(st);
a61af66fc99e Initial load duke parents: diff changeset	1214 }
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1215 st->print_cr("--- Extra data:");
0 a61af66fc99e Initial load duke parents: diff changeset	1216 DataLayout* dp = extra_data_base();
a61af66fc99e Initial load duke parents: diff changeset	1217 DataLayout* end = extra_data_limit();
a61af66fc99e Initial load duke parents: diff changeset	1218 for (; dp < end; dp = next_extra(dp)) {
a61af66fc99e Initial load duke parents: diff changeset	1219 // No need for "OrderAccess::load_acquire" ops,
a61af66fc99e Initial load duke parents: diff changeset	1220 // since the data structure is monotonic.
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1221 if (dp->tag() == DataLayout::no_tag) continue;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1222 if (dp->tag() == DataLayout::bit_data_tag) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1223 data = new BitData(dp);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1224 } else {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1225 assert(dp->tag() == DataLayout::arg_info_data_tag, "must be BitData or ArgInfo");
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1226 data = new ArgInfoData(dp);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1227 dp = end; // ArgInfoData is at the end of extra data section.
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1228 }
0 a61af66fc99e Initial load duke parents: diff changeset	1229 st->print("%d", dp_to_di(data->dp()));
a61af66fc99e Initial load duke parents: diff changeset	1230 st->fill_to(6);
a61af66fc99e Initial load duke parents: diff changeset	1231 data->print_data_on(st);
a61af66fc99e Initial load duke parents: diff changeset	1232 }
a61af66fc99e Initial load duke parents: diff changeset	1233 }
a61af66fc99e Initial load duke parents: diff changeset	1234 #endif
a61af66fc99e Initial load duke parents: diff changeset	1235
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1236 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1237 // Size Statistics
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1238 void MethodData::collect_statistics(KlassSizeStats *sz) const {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1239 int n = sz->count(this);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1240 sz->_method_data_bytes += n;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1241 sz->_method_all_bytes += n;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1242 sz->_rw_bytes += n;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1243 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1244 #endif // INCLUDE_SERVICES
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1245
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1246 // Verification
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1247
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1248 void MethodData::verify_on(outputStream* st) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1249 guarantee(is_methodData(), "object must be method data");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1250 // guarantee(m->is_perm(), "should be in permspace");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1251 this->verify_data_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1252 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1253
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1254 void MethodData::verify_data_on(outputStream* st) {
0 a61af66fc99e Initial load duke parents: diff changeset	1255 NEEDS_CLEANUP;
a61af66fc99e Initial load duke parents: diff changeset	1256 // not yet implemented.
a61af66fc99e Initial load duke parents: diff changeset	1257 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1258
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1259 bool MethodData::profile_jsr292(methodHandle m, int bci) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1260 if (m->is_compiled_lambda_form()) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1261 return true;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1262 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1263
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1264 Bytecode_invoke inv(m , bci);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1265 return inv.is_invokedynamic() \|\| inv.is_invokehandle();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1266 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1267
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1268 int MethodData::profile_arguments_flag() {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1269 return TypeProfileLevel % 10;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1270 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1271
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1272 bool MethodData::profile_arguments() {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1273 return profile_arguments_flag() > no_type_profile && profile_arguments_flag() <= type_profile_all;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1274 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1275
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1276 bool MethodData::profile_arguments_jsr292_only() {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1277 return profile_arguments_flag() == type_profile_jsr292;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1278 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1279
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1280 bool MethodData::profile_all_arguments() {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1281 return profile_arguments_flag() == type_profile_all;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1282 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1283
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1284 bool MethodData::profile_arguments_for_invoke(methodHandle m, int bci) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1285 if (!profile_arguments()) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1286 return false;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1287 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1288
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1289 if (profile_all_arguments()) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1290 return true;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1291 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1292
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1293 assert(profile_arguments_jsr292_only(), "inconsistent");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1294 return profile_jsr292(m, bci);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1295 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1296
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1297 int MethodData::profile_return_flag() {
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1298 return (TypeProfileLevel % 100) / 10;
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1299 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1300
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1301 bool MethodData::profile_return() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1302 return profile_return_flag() > no_type_profile && profile_return_flag() <= type_profile_all;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1303 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1304
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1305 bool MethodData::profile_return_jsr292_only() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1306 return profile_return_flag() == type_profile_jsr292;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1307 }
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 bool MethodData::profile_all_return() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1310 return profile_return_flag() == type_profile_all;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1311 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1312
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1313 bool MethodData::profile_return_for_invoke(methodHandle m, int bci) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1314 if (!profile_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1315 return false;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1316 }
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 if (profile_all_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1319 return true;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1320 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1321
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1322 assert(profile_return_jsr292_only(), "inconsistent");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1323 return profile_jsr292(m, bci);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1324 }
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1325
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1326 int MethodData::profile_parameters_flag() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1327 return TypeProfileLevel / 100;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1328 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1329
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1330 bool MethodData::profile_parameters() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1331 return profile_parameters_flag() > no_type_profile && profile_parameters_flag() <= type_profile_all;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1332 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1333
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1334 bool MethodData::profile_parameters_jsr292_only() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1335 return profile_parameters_flag() == type_profile_jsr292;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1336 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1337
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1338 bool MethodData::profile_all_parameters() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1339 return profile_parameters_flag() == type_profile_all;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1340 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1341
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1342 bool MethodData::profile_parameters_for_method(methodHandle m) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1343 if (!profile_parameters()) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1344 return false;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1345 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1346
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1347 if (profile_all_parameters()) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1348 return true;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1349 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1350
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1351 assert(profile_parameters_jsr292_only(), "inconsistent");
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1352 return m->is_compiled_lambda_form();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1353 }

Mercurial > hg > truffle

annotate src/share/vm/oops/methodData.cpp @ 14649:f6301b007a16