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

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

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

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

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
9765 2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	381 #ifdef GRAAL
2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	382 void VirtualCallData::clean_weak_klass_links(BoolObjectClosure* is_alive_cl) {
2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	383 ReceiverTypeData::clean_weak_klass_links(is_alive_cl);
2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	384 for (uint row = 0; row < method_row_limit(); row++) {
2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	385 Method* p = method(row);
2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	386 if (p != NULL && !p->method_holder()->is_loader_alive(is_alive_cl)) {
2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	387 clear_method_row(row);
2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	388 }
2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	389 }
2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	390 }
2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	391 #endif // GRAAL
2461285a2f90 Bugfix. Christian Haeubl <haeubl@ssw.jku.at> parents: 9762 diff changeset	392
0 a61af66fc99e Initial load duke parents: diff changeset	393 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	394 void ReceiverTypeData::print_receiver_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	395 uint row;
a61af66fc99e Initial load duke parents: diff changeset	396 int entries = 0;
a61af66fc99e Initial load duke parents: diff changeset	397 for (row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	398 if (receiver(row) != NULL) entries++;
a61af66fc99e Initial load duke parents: diff changeset	399 }
13108 d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	400 #ifdef GRAAL
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	401 st->print_cr("count(%u) nonprofiled_count(%u) entries(%u)", count(), nonprofiled_count(), entries);
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	402 #else
0 a61af66fc99e Initial load duke parents: diff changeset	403 st->print_cr("count(%u) entries(%u)", count(), entries);
13108 d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	404 #endif
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	405 int total = count();
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	406 for (row = 0; row < row_limit(); row++) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	407 if (receiver(row) != NULL) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	408 total += receiver_count(row);
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	409 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	410 }
0 a61af66fc99e Initial load duke parents: diff changeset	411 for (row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	412 if (receiver(row) != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	413 tab(st);
a61af66fc99e Initial load duke parents: diff changeset	414 receiver(row)->print_value_on(st);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	415 st->print_cr("(%u %4.2f)", receiver_count(row), (float) receiver_count(row) / (float) total);
0 a61af66fc99e Initial load duke parents: diff changeset	416 }
a61af66fc99e Initial load duke parents: diff changeset	417 }
a61af66fc99e Initial load duke parents: diff changeset	418 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	419 void ReceiverTypeData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	420 print_shared(st, "ReceiverTypeData");
a61af66fc99e Initial load duke parents: diff changeset	421 print_receiver_data_on(st);
a61af66fc99e Initial load duke parents: diff changeset	422 }
13108 d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	423
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	424 #ifdef GRAAL
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	425 void VirtualCallData::print_method_data_on(outputStream* st) const {
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	426 uint row;
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	427 int entries = 0;
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	428 for (row = 0; row < method_row_limit(); row++) {
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	429 if (method(row) != NULL) entries++;
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	430 }
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	431 tab(st);
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	432 st->print_cr("method_entries(%u)", entries);
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	433 int total = count();
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	434 for (row = 0; row < method_row_limit(); row++) {
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	435 if (method(row) != NULL) {
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	436 total += method_count(row);
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	437 }
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	438 }
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	439 for (row = 0; row < method_row_limit(); row++) {
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	440 if (method(row) != NULL) {
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	441 tab(st);
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	442 method(row)->print_value_on(st);
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	443 st->print_cr("(%u %4.2f)", method_count(row), (float) method_count(row) / (float) total);
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	444 }
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	445 }
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	446 }
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	447 #endif
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	448
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	449 void VirtualCallData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	450 print_shared(st, "VirtualCallData");
a61af66fc99e Initial load duke parents: diff changeset	451 print_receiver_data_on(st);
13108 d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	452 #ifdef GRAAL
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	453 print_method_data_on(st);
d84fa69a9874 added support for printing method profiles for virtual calls Doug Simon <doug.simon@oracle.com> parents: 13087 diff changeset	454 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	455 }
a61af66fc99e Initial load duke parents: diff changeset	456 #endif // !PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	457
a61af66fc99e Initial load duke parents: diff changeset	458 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	459 // RetData
a61af66fc99e Initial load duke parents: diff changeset	460 //
a61af66fc99e Initial load duke parents: diff changeset	461 // A RetData is used to access profiling information for a ret bytecode.
a61af66fc99e Initial load duke parents: diff changeset	462 // It is composed of a count of the number of times that the ret has
a61af66fc99e Initial load duke parents: diff changeset	463 // been executed, followed by a series of triples of the form
a61af66fc99e Initial load duke parents: diff changeset	464 // (bci, count, di) which count the number of times that some bci was the
a61af66fc99e Initial load duke parents: diff changeset	465 // target of the ret and cache a corresponding displacement.
a61af66fc99e Initial load duke parents: diff changeset	466
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	467 void RetData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
0 a61af66fc99e Initial load duke parents: diff changeset	468 for (uint row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	469 set_bci_displacement(row, -1);
a61af66fc99e Initial load duke parents: diff changeset	470 set_bci(row, no_bci);
a61af66fc99e Initial load duke parents: diff changeset	471 }
a61af66fc99e Initial load duke parents: diff changeset	472 // release so other threads see a consistent state. bci is used as
a61af66fc99e Initial load duke parents: diff changeset	473 // a valid flag for bci_displacement.
a61af66fc99e Initial load duke parents: diff changeset	474 OrderAccess::release();
a61af66fc99e Initial load duke parents: diff changeset	475 }
a61af66fc99e Initial load duke parents: diff changeset	476
a61af66fc99e Initial load duke parents: diff changeset	477 // This routine needs to atomically update the RetData structure, so the
a61af66fc99e Initial load duke parents: diff changeset	478 // caller needs to hold the RetData_lock before it gets here. Since taking
a61af66fc99e Initial load duke parents: diff changeset	479 // the lock can block (and allow GC) and since RetData is a ProfileData is a
a61af66fc99e Initial load duke parents: diff changeset	480 // wrapper around a derived oop, taking the lock in _this_ method will
a61af66fc99e Initial load duke parents: diff changeset	481 // basically cause the 'this' pointer's _data field to contain junk after the
a61af66fc99e Initial load duke parents: diff changeset	482 // lock. We require the caller to take the lock before making the ProfileData
a61af66fc99e Initial load duke parents: diff changeset	483 // 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	484 address RetData::fixup_ret(int return_bci, MethodData* h_mdo) {
0 a61af66fc99e Initial load duke parents: diff changeset	485 // First find the mdp which corresponds to the return bci.
a61af66fc99e Initial load duke parents: diff changeset	486 address mdp = h_mdo->bci_to_dp(return_bci);
a61af66fc99e Initial load duke parents: diff changeset	487
a61af66fc99e Initial load duke parents: diff changeset	488 // Now check to see if any of the cache slots are open.
a61af66fc99e Initial load duke parents: diff changeset	489 for (uint row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	490 if (bci(row) == no_bci) {
a61af66fc99e Initial load duke parents: diff changeset	491 set_bci_displacement(row, mdp - dp());
a61af66fc99e Initial load duke parents: diff changeset	492 set_bci_count(row, DataLayout::counter_increment);
a61af66fc99e Initial load duke parents: diff changeset	493 // Barrier to ensure displacement is written before the bci; allows
a61af66fc99e Initial load duke parents: diff changeset	494 // the interpreter to read displacement without fear of race condition.
a61af66fc99e Initial load duke parents: diff changeset	495 release_set_bci(row, return_bci);
a61af66fc99e Initial load duke parents: diff changeset	496 break;
a61af66fc99e Initial load duke parents: diff changeset	497 }
a61af66fc99e Initial load duke parents: diff changeset	498 }
a61af66fc99e Initial load duke parents: diff changeset	499 return mdp;
a61af66fc99e Initial load duke parents: diff changeset	500 }
a61af66fc99e Initial load duke parents: diff changeset	501
a61af66fc99e Initial load duke parents: diff changeset	502
a61af66fc99e Initial load duke parents: diff changeset	503 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	504 void RetData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	505 print_shared(st, "RetData");
a61af66fc99e Initial load duke parents: diff changeset	506 uint row;
a61af66fc99e Initial load duke parents: diff changeset	507 int entries = 0;
a61af66fc99e Initial load duke parents: diff changeset	508 for (row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	509 if (bci(row) != no_bci) entries++;
a61af66fc99e Initial load duke parents: diff changeset	510 }
a61af66fc99e Initial load duke parents: diff changeset	511 st->print_cr("count(%u) entries(%u)", count(), entries);
a61af66fc99e Initial load duke parents: diff changeset	512 for (row = 0; row < row_limit(); row++) {
a61af66fc99e Initial load duke parents: diff changeset	513 if (bci(row) != no_bci) {
a61af66fc99e Initial load duke parents: diff changeset	514 tab(st);
a61af66fc99e Initial load duke parents: diff changeset	515 st->print_cr("bci(%d: count(%u) displacement(%d))",
a61af66fc99e Initial load duke parents: diff changeset	516 bci(row), bci_count(row), bci_displacement(row));
a61af66fc99e Initial load duke parents: diff changeset	517 }
a61af66fc99e Initial load duke parents: diff changeset	518 }
a61af66fc99e Initial load duke parents: diff changeset	519 }
a61af66fc99e Initial load duke parents: diff changeset	520 #endif // !PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	521
a61af66fc99e Initial load duke parents: diff changeset	522 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	523 // BranchData
a61af66fc99e Initial load duke parents: diff changeset	524 //
a61af66fc99e Initial load duke parents: diff changeset	525 // A BranchData is used to access profiling data for a two-way branch.
a61af66fc99e Initial load duke parents: diff changeset	526 // It consists of taken and not_taken counts as well as a data displacement
a61af66fc99e Initial load duke parents: diff changeset	527 // for the taken case.
a61af66fc99e Initial load duke parents: diff changeset	528
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	529 void BranchData::post_initialize(BytecodeStream* stream, 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 = stream->dest();
a61af66fc99e Initial load duke parents: diff changeset	532 int my_di = mdo->dp_to_di(dp());
a61af66fc99e Initial load duke parents: diff changeset	533 int target_di = mdo->bci_to_di(target);
a61af66fc99e Initial load duke parents: diff changeset	534 int offset = target_di - my_di;
a61af66fc99e Initial load duke parents: diff changeset	535 set_displacement(offset);
a61af66fc99e Initial load duke parents: diff changeset	536 }
a61af66fc99e Initial load duke parents: diff changeset	537
a61af66fc99e Initial load duke parents: diff changeset	538 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	539 void BranchData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	540 print_shared(st, "BranchData");
a61af66fc99e Initial load duke parents: diff changeset	541 st->print_cr("taken(%u) displacement(%d)",
a61af66fc99e Initial load duke parents: diff changeset	542 taken(), displacement());
a61af66fc99e Initial load duke parents: diff changeset	543 tab(st);
a61af66fc99e Initial load duke parents: diff changeset	544 st->print_cr("not taken(%u)", not_taken());
a61af66fc99e Initial load duke parents: diff changeset	545 }
a61af66fc99e Initial load duke parents: diff changeset	546 #endif
a61af66fc99e Initial load duke parents: diff changeset	547
a61af66fc99e Initial load duke parents: diff changeset	548 // ==================================================================
a61af66fc99e Initial load duke parents: diff changeset	549 // MultiBranchData
a61af66fc99e Initial load duke parents: diff changeset	550 //
a61af66fc99e Initial load duke parents: diff changeset	551 // A MultiBranchData is used to access profiling information for
a61af66fc99e Initial load duke parents: diff changeset	552 // a multi-way branch (*switch bytecodes). It consists of a series
a61af66fc99e Initial load duke parents: diff changeset	553 // of (count, displacement) pairs, which count the number of times each
a61af66fc99e Initial load duke parents: diff changeset	554 // case was taken and specify the data displacment for each branch target.
a61af66fc99e Initial load duke parents: diff changeset	555
a61af66fc99e Initial load duke parents: diff changeset	556 int MultiBranchData::compute_cell_count(BytecodeStream* stream) {
a61af66fc99e Initial load duke parents: diff changeset	557 int cell_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	558 if (stream->code() == Bytecodes::_tableswitch) {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	559 Bytecode_tableswitch sw(stream->method()(), stream->bcp());
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	560 cell_count = 1 + per_case_cell_count * (1 + sw.length()); // 1 for default
0 a61af66fc99e Initial load duke parents: diff changeset	561 } else {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	562 Bytecode_lookupswitch sw(stream->method()(), stream->bcp());
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	563 cell_count = 1 + per_case_cell_count * (sw.number_of_pairs() + 1); // 1 for default
0 a61af66fc99e Initial load duke parents: diff changeset	564 }
a61af66fc99e Initial load duke parents: diff changeset	565 return cell_count;
a61af66fc99e Initial load duke parents: diff changeset	566 }
a61af66fc99e Initial load duke parents: diff changeset	567
a61af66fc99e Initial load duke parents: diff changeset	568 void MultiBranchData::post_initialize(BytecodeStream* stream,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	569 MethodData* mdo) {
0 a61af66fc99e Initial load duke parents: diff changeset	570 assert(stream->bci() == bci(), "wrong pos");
a61af66fc99e Initial load duke parents: diff changeset	571 int target;
a61af66fc99e Initial load duke parents: diff changeset	572 int my_di;
a61af66fc99e Initial load duke parents: diff changeset	573 int target_di;
a61af66fc99e Initial load duke parents: diff changeset	574 int offset;
a61af66fc99e Initial load duke parents: diff changeset	575 if (stream->code() == Bytecodes::_tableswitch) {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	576 Bytecode_tableswitch sw(stream->method()(), stream->bcp());
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	577 int len = sw.length();
0 a61af66fc99e Initial load duke parents: diff changeset	578 assert(array_len() == per_case_cell_count * (len + 1), "wrong len");
a61af66fc99e Initial load duke parents: diff changeset	579 for (int count = 0; count < len; count++) {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	580 target = sw.dest_offset_at(count) + bci();
0 a61af66fc99e Initial load duke parents: diff changeset	581 my_di = mdo->dp_to_di(dp());
a61af66fc99e Initial load duke parents: diff changeset	582 target_di = mdo->bci_to_di(target);
a61af66fc99e Initial load duke parents: diff changeset	583 offset = target_di - my_di;
a61af66fc99e Initial load duke parents: diff changeset	584 set_displacement_at(count, offset);
a61af66fc99e Initial load duke parents: diff changeset	585 }
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	586 target = sw.default_offset() + bci();
0 a61af66fc99e Initial load duke parents: diff changeset	587 my_di = mdo->dp_to_di(dp());
a61af66fc99e Initial load duke parents: diff changeset	588 target_di = mdo->bci_to_di(target);
a61af66fc99e Initial load duke parents: diff changeset	589 offset = target_di - my_di;
a61af66fc99e Initial load duke parents: diff changeset	590 set_default_displacement(offset);
a61af66fc99e Initial load duke parents: diff changeset	591
a61af66fc99e Initial load duke parents: diff changeset	592 } else {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	593 Bytecode_lookupswitch sw(stream->method()(), stream->bcp());
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	594 int npairs = sw.number_of_pairs();
0 a61af66fc99e Initial load duke parents: diff changeset	595 assert(array_len() == per_case_cell_count * (npairs + 1), "wrong len");
a61af66fc99e Initial load duke parents: diff changeset	596 for (int count = 0; count < npairs; count++) {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	597 LookupswitchPair pair = sw.pair_at(count);
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	598 target = pair.offset() + bci();
0 a61af66fc99e Initial load duke parents: diff changeset	599 my_di = mdo->dp_to_di(dp());
a61af66fc99e Initial load duke parents: diff changeset	600 target_di = mdo->bci_to_di(target);
a61af66fc99e Initial load duke parents: diff changeset	601 offset = target_di - my_di;
a61af66fc99e Initial load duke parents: diff changeset	602 set_displacement_at(count, offset);
a61af66fc99e Initial load duke parents: diff changeset	603 }
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	604 target = sw.default_offset() + bci();
0 a61af66fc99e Initial load duke parents: diff changeset	605 my_di = mdo->dp_to_di(dp());
a61af66fc99e Initial load duke parents: diff changeset	606 target_di = mdo->bci_to_di(target);
a61af66fc99e Initial load duke parents: diff changeset	607 offset = target_di - my_di;
a61af66fc99e Initial load duke parents: diff changeset	608 set_default_displacement(offset);
a61af66fc99e Initial load duke parents: diff changeset	609 }
a61af66fc99e Initial load duke parents: diff changeset	610 }
a61af66fc99e Initial load duke parents: diff changeset	611
a61af66fc99e Initial load duke parents: diff changeset	612 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	613 void MultiBranchData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	614 print_shared(st, "MultiBranchData");
a61af66fc99e Initial load duke parents: diff changeset	615 st->print_cr("default_count(%u) displacement(%d)",
a61af66fc99e Initial load duke parents: diff changeset	616 default_count(), default_displacement());
a61af66fc99e Initial load duke parents: diff changeset	617 int cases = number_of_cases();
a61af66fc99e Initial load duke parents: diff changeset	618 for (int i = 0; i < cases; i++) {
a61af66fc99e Initial load duke parents: diff changeset	619 tab(st);
a61af66fc99e Initial load duke parents: diff changeset	620 st->print_cr("count(%u) displacement(%d)",
a61af66fc99e Initial load duke parents: diff changeset	621 count_at(i), displacement_at(i));
a61af66fc99e Initial load duke parents: diff changeset	622 }
a61af66fc99e Initial load duke parents: diff changeset	623 }
a61af66fc99e Initial load duke parents: diff changeset	624 #endif
a61af66fc99e Initial load duke parents: diff changeset	625
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	626 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	627 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	628 print_shared(st, "ArgInfoData");
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	629 int nargs = number_of_args();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	630 for (int i = 0; i < nargs; i++) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	631 st->print(" 0x%x", arg_modified(i));
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	632 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	633 st->cr();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	634 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	635
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	636 #endif
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	637
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	638 int ParametersTypeData::compute_cell_count(Method* m) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	639 if (!MethodData::profile_parameters_for_method(m)) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	640 return 0;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	641 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	642 int max = TypeProfileParmsLimit == -1 ? INT_MAX : TypeProfileParmsLimit;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	643 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	644 if (obj_args > 0) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	645 return obj_args + 1; // 1 cell for array len
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	646 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	647 return 0;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	648 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	649
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	650 void ParametersTypeData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	651 _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	652 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	653
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	654 bool ParametersTypeData::profiling_enabled() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	655 return MethodData::profile_parameters();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	656 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	657
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	658 #ifndef PRODUCT
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	659 void ParametersTypeData::print_data_on(outputStream* st) const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	660 st->print("parameter types");
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	661 _parameters.print_data_on(st);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	662 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	663 #endif
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	664
0 a61af66fc99e Initial load duke parents: diff changeset	665 // ==================================================================
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	666 // MethodData*
0 a61af66fc99e Initial load duke parents: diff changeset	667 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	668 // A MethodData* holds information which has been collected about
0 a61af66fc99e Initial load duke parents: diff changeset	669 // a method.
a61af66fc99e Initial load duke parents: diff changeset	670
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	671 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	672 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	673
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10107 diff changeset	674 return new (loader_data, size, false, MetaspaceObj::MethodDataType, THREAD)
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10107 diff changeset	675 MethodData(method(), size, CHECK_NULL);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	676 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	677
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	678 int MethodData::bytecode_cell_count(Bytecodes::Code code) {
8883 b9a918201d47 Merge with hsx25 Gilles Duboscq <duboscq@ssw.jku.at> parents: 8616 8860 diff changeset	679 #if defined(COMPILER1) && !(defined(COMPILER2) \|\| defined(GRAAL))
8860 46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	680 return no_profile_data;
46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	681 #else
0 a61af66fc99e Initial load duke parents: diff changeset	682 switch (code) {
a61af66fc99e Initial load duke parents: diff changeset	683 case Bytecodes::_checkcast:
a61af66fc99e Initial load duke parents: diff changeset	684 case Bytecodes::_instanceof:
a61af66fc99e Initial load duke parents: diff changeset	685 case Bytecodes::_aastore:
a61af66fc99e Initial load duke parents: diff changeset	686 if (TypeProfileCasts) {
a61af66fc99e Initial load duke parents: diff changeset	687 return ReceiverTypeData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	688 } else {
a61af66fc99e Initial load duke parents: diff changeset	689 return BitData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	690 }
a61af66fc99e Initial load duke parents: diff changeset	691 case Bytecodes::_invokespecial:
a61af66fc99e Initial load duke parents: diff changeset	692 case Bytecodes::_invokestatic:
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	693 if (MethodData::profile_arguments() \|\| MethodData::profile_return()) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	694 return variable_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	695 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	696 return CounterData::static_cell_count();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	697 }
0 a61af66fc99e Initial load duke parents: diff changeset	698 case Bytecodes::_goto:
a61af66fc99e Initial load duke parents: diff changeset	699 case Bytecodes::_goto_w:
a61af66fc99e Initial load duke parents: diff changeset	700 case Bytecodes::_jsr:
a61af66fc99e Initial load duke parents: diff changeset	701 case Bytecodes::_jsr_w:
a61af66fc99e Initial load duke parents: diff changeset	702 return JumpData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	703 case Bytecodes::_invokevirtual:
a61af66fc99e Initial load duke parents: diff changeset	704 case Bytecodes::_invokeinterface:
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	705 if (MethodData::profile_arguments() \|\| MethodData::profile_return()) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	706 return variable_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	707 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	708 return VirtualCallData::static_cell_count();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	709 }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	710 case Bytecodes::_invokedynamic:
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	711 if (MethodData::profile_arguments() \|\| MethodData::profile_return()) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	712 return variable_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	713 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	714 return CounterData::static_cell_count();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	715 }
0 a61af66fc99e Initial load duke parents: diff changeset	716 case Bytecodes::_ret:
a61af66fc99e Initial load duke parents: diff changeset	717 return RetData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	718 case Bytecodes::_ifeq:
a61af66fc99e Initial load duke parents: diff changeset	719 case Bytecodes::_ifne:
a61af66fc99e Initial load duke parents: diff changeset	720 case Bytecodes::_iflt:
a61af66fc99e Initial load duke parents: diff changeset	721 case Bytecodes::_ifge:
a61af66fc99e Initial load duke parents: diff changeset	722 case Bytecodes::_ifgt:
a61af66fc99e Initial load duke parents: diff changeset	723 case Bytecodes::_ifle:
a61af66fc99e Initial load duke parents: diff changeset	724 case Bytecodes::_if_icmpeq:
a61af66fc99e Initial load duke parents: diff changeset	725 case Bytecodes::_if_icmpne:
a61af66fc99e Initial load duke parents: diff changeset	726 case Bytecodes::_if_icmplt:
a61af66fc99e Initial load duke parents: diff changeset	727 case Bytecodes::_if_icmpge:
a61af66fc99e Initial load duke parents: diff changeset	728 case Bytecodes::_if_icmpgt:
a61af66fc99e Initial load duke parents: diff changeset	729 case Bytecodes::_if_icmple:
a61af66fc99e Initial load duke parents: diff changeset	730 case Bytecodes::_if_acmpeq:
a61af66fc99e Initial load duke parents: diff changeset	731 case Bytecodes::_if_acmpne:
a61af66fc99e Initial load duke parents: diff changeset	732 case Bytecodes::_ifnull:
a61af66fc99e Initial load duke parents: diff changeset	733 case Bytecodes::_ifnonnull:
a61af66fc99e Initial load duke parents: diff changeset	734 return BranchData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	735 case Bytecodes::_lookupswitch:
a61af66fc99e Initial load duke parents: diff changeset	736 case Bytecodes::_tableswitch:
a61af66fc99e Initial load duke parents: diff changeset	737 return variable_cell_count;
a61af66fc99e Initial load duke parents: diff changeset	738 }
a61af66fc99e Initial load duke parents: diff changeset	739 return no_profile_data;
8860 46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	740 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	741 }
a61af66fc99e Initial load duke parents: diff changeset	742
a61af66fc99e Initial load duke parents: diff changeset	743 // Compute the size of the profiling information corresponding to
a61af66fc99e Initial load duke parents: diff changeset	744 // the current bytecode.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	745 int MethodData::compute_data_size(BytecodeStream* stream) {
0 a61af66fc99e Initial load duke parents: diff changeset	746 int cell_count = bytecode_cell_count(stream->code());
a61af66fc99e Initial load duke parents: diff changeset	747 if (cell_count == no_profile_data) {
a61af66fc99e Initial load duke parents: diff changeset	748 return 0;
a61af66fc99e Initial load duke parents: diff changeset	749 }
a61af66fc99e Initial load duke parents: diff changeset	750 if (cell_count == variable_cell_count) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	751 switch (stream->code()) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	752 case Bytecodes::_lookupswitch:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	753 case Bytecodes::_tableswitch:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	754 cell_count = MultiBranchData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	755 break;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	756 case Bytecodes::_invokespecial:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	757 case Bytecodes::_invokestatic:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	758 case Bytecodes::_invokedynamic:
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	759 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	760 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	761 profile_return_for_invoke(stream->method(), stream->bci())) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	762 cell_count = CallTypeData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	763 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	764 cell_count = CounterData::static_cell_count();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	765 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	766 break;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	767 case Bytecodes::_invokevirtual:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	768 case Bytecodes::_invokeinterface: {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	769 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	770 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	771 profile_return_for_invoke(stream->method(), stream->bci())) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	772 cell_count = VirtualCallTypeData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	773 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	774 cell_count = VirtualCallData::static_cell_count();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	775 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	776 break;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	777 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	778 default:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	779 fatal("unexpected bytecode for var length profile data");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	780 }
0 a61af66fc99e Initial load duke parents: diff changeset	781 }
a61af66fc99e Initial load duke parents: diff changeset	782 // Note: cell_count might be zero, meaning that there is just
a61af66fc99e Initial load duke parents: diff changeset	783 // a DataLayout header, with no extra cells.
a61af66fc99e Initial load duke parents: diff changeset	784 assert(cell_count >= 0, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	785 return DataLayout::compute_size_in_bytes(cell_count);
a61af66fc99e Initial load duke parents: diff changeset	786 }
a61af66fc99e Initial load duke parents: diff changeset	787
8616 d343737786fe changed profiling of exceptions so that the ExceptionSeen flag also works without GRAALVM Christian Haeubl <haeubl@ssw.jku.at> parents: 8615 diff changeset	788 #ifdef GRAAL
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 5150 6725 diff changeset	789 int MethodData::compute_extra_data_count(int data_size, int empty_bc_count) {
4568 8e1d9c27989a better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately Christian Haeubl <christian.haeubl@oracle.com> parents: 4439 diff changeset	790 if (!ProfileTraps) return 0;
8e1d9c27989a better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately Christian Haeubl <christian.haeubl@oracle.com> parents: 4439 diff changeset	791
8e1d9c27989a better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately Christian Haeubl <christian.haeubl@oracle.com> parents: 4439 diff changeset	792 // Assume that up to 30% of the possibly trapping BCIs with no MDP will need to allocate one.
8e1d9c27989a better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately Christian Haeubl <christian.haeubl@oracle.com> parents: 4439 diff changeset	793 return MIN2(empty_bc_count, MAX2(4, (empty_bc_count * 30) / 100));
8e1d9c27989a better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately Christian Haeubl <christian.haeubl@oracle.com> parents: 4439 diff changeset	794 }
8e1d9c27989a better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately Christian Haeubl <christian.haeubl@oracle.com> parents: 4439 diff changeset	795 #else
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	796 int MethodData::compute_extra_data_count(int data_size, int empty_bc_count) {
0 a61af66fc99e Initial load duke parents: diff changeset	797 if (ProfileTraps) {
a61af66fc99e Initial load duke parents: diff changeset	798 // Assume that up to 3% of BCIs with no MDP will need to allocate one.
a61af66fc99e Initial load duke parents: diff changeset	799 int extra_data_count = (uint)(empty_bc_count * 3) / 128 + 1;
a61af66fc99e Initial load duke parents: diff changeset	800 // If the method is large, let the extra BCIs grow numerous (to ~1%).
a61af66fc99e Initial load duke parents: diff changeset	801 int one_percent_of_data
a61af66fc99e Initial load duke parents: diff changeset	802 = (uint)data_size / (DataLayout::header_size_in_bytes()*128);
a61af66fc99e Initial load duke parents: diff changeset	803 if (extra_data_count < one_percent_of_data)
a61af66fc99e Initial load duke parents: diff changeset	804 extra_data_count = one_percent_of_data;
a61af66fc99e Initial load duke parents: diff changeset	805 if (extra_data_count > empty_bc_count)
a61af66fc99e Initial load duke parents: diff changeset	806 extra_data_count = empty_bc_count; // no need for more
a61af66fc99e Initial load duke parents: diff changeset	807 return extra_data_count;
a61af66fc99e Initial load duke parents: diff changeset	808 } else {
a61af66fc99e Initial load duke parents: diff changeset	809 return 0;
a61af66fc99e Initial load duke parents: diff changeset	810 }
a61af66fc99e Initial load duke parents: diff changeset	811 }
4568 8e1d9c27989a better allocation of methodData's extraData so that exceptions and deoptimizations can be recorded more accurately Christian Haeubl <christian.haeubl@oracle.com> parents: 4439 diff changeset	812 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	813
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	814 // Compute the size of the MethodData* necessary to store
0 a61af66fc99e Initial load duke parents: diff changeset	815 // 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	816 int MethodData::compute_allocation_size_in_bytes(methodHandle method) {
0 a61af66fc99e Initial load duke parents: diff changeset	817 int data_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	818 BytecodeStream stream(method);
a61af66fc99e Initial load duke parents: diff changeset	819 Bytecodes::Code c;
a61af66fc99e Initial load duke parents: diff changeset	820 int empty_bc_count = 0; // number of bytecodes lacking data
a61af66fc99e Initial load duke parents: diff changeset	821 while ((c = stream.next()) >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	822 int size_in_bytes = compute_data_size(&stream);
a61af66fc99e Initial load duke parents: diff changeset	823 data_size += size_in_bytes;
13181 389d40d7d99f fixed bug in MethodData and added assertion that precomputed size == initialized size Doug Simon <doug.simon@oracle.com> parents: 13108 diff changeset	824 if (size_in_bytes == 0 GRAAL_ONLY(&& Bytecodes::can_trap(c))) empty_bc_count += 1;
0 a61af66fc99e Initial load duke parents: diff changeset	825 }
a61af66fc99e Initial load duke parents: diff changeset	826 int object_size = in_bytes(data_offset()) + data_size;
a61af66fc99e Initial load duke parents: diff changeset	827
a61af66fc99e Initial load duke parents: diff changeset	828 // Add some extra DataLayout cells (at least one) to track stray traps.
a61af66fc99e Initial load duke parents: diff changeset	829 int extra_data_count = compute_extra_data_count(data_size, empty_bc_count);
a61af66fc99e Initial load duke parents: diff changeset	830 object_size += extra_data_count * DataLayout::compute_size_in_bytes(0);
a61af66fc99e Initial load duke parents: diff changeset	831
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	832 // 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	833 int arg_size = method->size_of_parameters();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	834 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	835
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	836 // 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	837 // parameters
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	838 int args_cell = ParametersTypeData::compute_cell_count(method());
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	839 if (args_cell > 0) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	840 object_size += DataLayout::compute_size_in_bytes(args_cell);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	841 }
0 a61af66fc99e Initial load duke parents: diff changeset	842 return object_size;
a61af66fc99e Initial load duke parents: diff changeset	843 }
a61af66fc99e Initial load duke parents: diff changeset	844
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	845 // Compute the size of the MethodData* necessary to store
0 a61af66fc99e Initial load duke parents: diff changeset	846 // 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	847 int MethodData::compute_allocation_size_in_words(methodHandle method) {
0 a61af66fc99e Initial load duke parents: diff changeset	848 int byte_size = compute_allocation_size_in_bytes(method);
a61af66fc99e Initial load duke parents: diff changeset	849 int word_size = align_size_up(byte_size, BytesPerWord) / BytesPerWord;
a61af66fc99e Initial load duke parents: diff changeset	850 return align_object_size(word_size);
a61af66fc99e Initial load duke parents: diff changeset	851 }
a61af66fc99e Initial load duke parents: diff changeset	852
a61af66fc99e Initial load duke parents: diff changeset	853 // Initialize an individual data segment. Returns the size of
a61af66fc99e Initial load duke parents: diff changeset	854 // the segment in bytes.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	855 int MethodData::initialize_data(BytecodeStream* stream,
0 a61af66fc99e Initial load duke parents: diff changeset	856 int data_index) {
8883 b9a918201d47 Merge with hsx25 Gilles Duboscq <duboscq@ssw.jku.at> parents: 8616 8860 diff changeset	857 #if defined(COMPILER1) && !(defined(COMPILER2) \|\| defined(GRAAL))
8860 46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	858 return 0;
46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	859 #else
0 a61af66fc99e Initial load duke parents: diff changeset	860 int cell_count = -1;
a61af66fc99e Initial load duke parents: diff changeset	861 int tag = DataLayout::no_tag;
a61af66fc99e Initial load duke parents: diff changeset	862 DataLayout* data_layout = data_layout_at(data_index);
a61af66fc99e Initial load duke parents: diff changeset	863 Bytecodes::Code c = stream->code();
a61af66fc99e Initial load duke parents: diff changeset	864 switch (c) {
a61af66fc99e Initial load duke parents: diff changeset	865 case Bytecodes::_checkcast:
a61af66fc99e Initial load duke parents: diff changeset	866 case Bytecodes::_instanceof:
a61af66fc99e Initial load duke parents: diff changeset	867 case Bytecodes::_aastore:
a61af66fc99e Initial load duke parents: diff changeset	868 if (TypeProfileCasts) {
a61af66fc99e Initial load duke parents: diff changeset	869 cell_count = ReceiverTypeData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	870 tag = DataLayout::receiver_type_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	871 } else {
a61af66fc99e Initial load duke parents: diff changeset	872 cell_count = BitData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	873 tag = DataLayout::bit_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	874 }
a61af66fc99e Initial load duke parents: diff changeset	875 break;
a61af66fc99e Initial load duke parents: diff changeset	876 case Bytecodes::_invokespecial:
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	877 case Bytecodes::_invokestatic: {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	878 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	879 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	880 profile_return_for_invoke(stream->method(), stream->bci())) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	881 cell_count = CallTypeData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	882 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	883 cell_count = counter_data_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	884 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	885 if (cell_count > counter_data_cell_count) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	886 tag = DataLayout::call_type_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	887 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	888 tag = DataLayout::counter_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	889 }
0 a61af66fc99e Initial load duke parents: diff changeset	890 break;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	891 }
0 a61af66fc99e Initial load duke parents: diff changeset	892 case Bytecodes::_goto:
a61af66fc99e Initial load duke parents: diff changeset	893 case Bytecodes::_goto_w:
a61af66fc99e Initial load duke parents: diff changeset	894 case Bytecodes::_jsr:
a61af66fc99e Initial load duke parents: diff changeset	895 case Bytecodes::_jsr_w:
a61af66fc99e Initial load duke parents: diff changeset	896 cell_count = JumpData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	897 tag = DataLayout::jump_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	898 break;
a61af66fc99e Initial load duke parents: diff changeset	899 case Bytecodes::_invokevirtual:
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	900 case Bytecodes::_invokeinterface: {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	901 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	902 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	903 profile_return_for_invoke(stream->method(), stream->bci())) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	904 cell_count = VirtualCallTypeData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	905 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	906 cell_count = virtual_call_data_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	907 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	908 if (cell_count > virtual_call_data_cell_count) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	909 tag = DataLayout::virtual_call_type_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	910 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	911 tag = DataLayout::virtual_call_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	912 }
0 a61af66fc99e Initial load duke parents: diff changeset	913 break;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	914 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	915 case Bytecodes::_invokedynamic: {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	916 // %%% 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	917 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	918 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	919 profile_return_for_invoke(stream->method(), stream->bci())) {
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	920 cell_count = CallTypeData::compute_cell_count(stream);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	921 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	922 cell_count = counter_data_cell_count;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	923 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	924 if (cell_count > counter_data_cell_count) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	925 tag = DataLayout::call_type_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	926 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	927 tag = DataLayout::counter_data_tag;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	928 }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 196 diff changeset	929 break;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	930 }
0 a61af66fc99e Initial load duke parents: diff changeset	931 case Bytecodes::_ret:
a61af66fc99e Initial load duke parents: diff changeset	932 cell_count = RetData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	933 tag = DataLayout::ret_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	934 break;
a61af66fc99e Initial load duke parents: diff changeset	935 case Bytecodes::_ifeq:
a61af66fc99e Initial load duke parents: diff changeset	936 case Bytecodes::_ifne:
a61af66fc99e Initial load duke parents: diff changeset	937 case Bytecodes::_iflt:
a61af66fc99e Initial load duke parents: diff changeset	938 case Bytecodes::_ifge:
a61af66fc99e Initial load duke parents: diff changeset	939 case Bytecodes::_ifgt:
a61af66fc99e Initial load duke parents: diff changeset	940 case Bytecodes::_ifle:
a61af66fc99e Initial load duke parents: diff changeset	941 case Bytecodes::_if_icmpeq:
a61af66fc99e Initial load duke parents: diff changeset	942 case Bytecodes::_if_icmpne:
a61af66fc99e Initial load duke parents: diff changeset	943 case Bytecodes::_if_icmplt:
a61af66fc99e Initial load duke parents: diff changeset	944 case Bytecodes::_if_icmpge:
a61af66fc99e Initial load duke parents: diff changeset	945 case Bytecodes::_if_icmpgt:
a61af66fc99e Initial load duke parents: diff changeset	946 case Bytecodes::_if_icmple:
a61af66fc99e Initial load duke parents: diff changeset	947 case Bytecodes::_if_acmpeq:
a61af66fc99e Initial load duke parents: diff changeset	948 case Bytecodes::_if_acmpne:
a61af66fc99e Initial load duke parents: diff changeset	949 case Bytecodes::_ifnull:
a61af66fc99e Initial load duke parents: diff changeset	950 case Bytecodes::_ifnonnull:
a61af66fc99e Initial load duke parents: diff changeset	951 cell_count = BranchData::static_cell_count();
a61af66fc99e Initial load duke parents: diff changeset	952 tag = DataLayout::branch_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	953 break;
a61af66fc99e Initial load duke parents: diff changeset	954 case Bytecodes::_lookupswitch:
a61af66fc99e Initial load duke parents: diff changeset	955 case Bytecodes::_tableswitch:
a61af66fc99e Initial load duke parents: diff changeset	956 cell_count = MultiBranchData::compute_cell_count(stream);
a61af66fc99e Initial load duke parents: diff changeset	957 tag = DataLayout::multi_branch_data_tag;
a61af66fc99e Initial load duke parents: diff changeset	958 break;
a61af66fc99e Initial load duke parents: diff changeset	959 }
a61af66fc99e Initial load duke parents: diff changeset	960 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	961 ((MethodData::profile_arguments() \|\| MethodData::profile_return()) &&
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	962 (tag == DataLayout::call_type_data_tag \|\|
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	963 tag == DataLayout::counter_data_tag \|\|
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	964 tag == DataLayout::virtual_call_type_data_tag \|\|
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	965 tag == DataLayout::virtual_call_data_tag)) \|\|
0 a61af66fc99e Initial load duke parents: diff changeset	966 cell_count == bytecode_cell_count(c), "cell counts must agree");
a61af66fc99e Initial load duke parents: diff changeset	967 if (cell_count >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	968 assert(tag != DataLayout::no_tag, "bad tag");
a61af66fc99e Initial load duke parents: diff changeset	969 assert(bytecode_has_profile(c), "agree w/ BHP");
a61af66fc99e Initial load duke parents: diff changeset	970 data_layout->initialize(tag, stream->bci(), cell_count);
a61af66fc99e Initial load duke parents: diff changeset	971 return DataLayout::compute_size_in_bytes(cell_count);
a61af66fc99e Initial load duke parents: diff changeset	972 } else {
a61af66fc99e Initial load duke parents: diff changeset	973 assert(!bytecode_has_profile(c), "agree w/ !BHP");
a61af66fc99e Initial load duke parents: diff changeset	974 return 0;
a61af66fc99e Initial load duke parents: diff changeset	975 }
8860 46f6f063b272 7153771: array bound check elimination for c1 roland parents: 8712 diff changeset	976 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	977 }
a61af66fc99e Initial load duke parents: diff changeset	978
a61af66fc99e Initial load duke parents: diff changeset	979 // 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	980 ProfileData* MethodData::data_at(int data_index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	981 if (out_of_bounds(data_index)) {
a61af66fc99e Initial load duke parents: diff changeset	982 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	983 }
a61af66fc99e Initial load duke parents: diff changeset	984 DataLayout* data_layout = data_layout_at(data_index);
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	985 return data_layout->data_in();
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	986 }
0 a61af66fc99e Initial load duke parents: diff changeset	987
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	988 ProfileData* DataLayout::data_in() {
8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	989 switch (tag()) {
0 a61af66fc99e Initial load duke parents: diff changeset	990 case DataLayout::no_tag:
a61af66fc99e Initial load duke parents: diff changeset	991 default:
a61af66fc99e Initial load duke parents: diff changeset	992 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	993 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	994 case DataLayout::bit_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	995 return new BitData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	996 case DataLayout::counter_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	997 return new CounterData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	998 case DataLayout::jump_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	999 return new JumpData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1000 case DataLayout::receiver_type_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	1001 return new ReceiverTypeData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1002 case DataLayout::virtual_call_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	1003 return new VirtualCallData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1004 case DataLayout::ret_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	1005 return new RetData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1006 case DataLayout::branch_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	1007 return new BranchData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1008 case DataLayout::multi_branch_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	1009 return new MultiBranchData(this);
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1010 case DataLayout::arg_info_data_tag:
941 8b46c4d82093 4957990: Perm heap bloat in JVM ysr parents: 844 diff changeset	1011 return new ArgInfoData(this);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1012 case DataLayout::call_type_data_tag:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1013 return new CallTypeData(this);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1014 case DataLayout::virtual_call_type_data_tag:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1015 return new VirtualCallTypeData(this);
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1016 case DataLayout::parameters_type_data_tag:
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1017 return new ParametersTypeData(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1018 };
a61af66fc99e Initial load duke parents: diff changeset	1019 }
a61af66fc99e Initial load duke parents: diff changeset	1020
a61af66fc99e Initial load duke parents: diff changeset	1021 // Iteration over data.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1022 ProfileData* MethodData::next_data(ProfileData* current) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1023 int current_index = dp_to_di(current->dp());
a61af66fc99e Initial load duke parents: diff changeset	1024 int next_index = current_index + current->size_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	1025 ProfileData* next = data_at(next_index);
a61af66fc99e Initial load duke parents: diff changeset	1026 return next;
a61af66fc99e Initial load duke parents: diff changeset	1027 }
a61af66fc99e Initial load duke parents: diff changeset	1028
a61af66fc99e Initial load duke parents: diff changeset	1029 // Give each of the data entries a chance to perform specific
a61af66fc99e Initial load duke parents: diff changeset	1030 // data initialization.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1031 void MethodData::post_initialize(BytecodeStream* stream) {
0 a61af66fc99e Initial load duke parents: diff changeset	1032 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1033 ProfileData* data;
a61af66fc99e Initial load duke parents: diff changeset	1034 for (data = first_data(); is_valid(data); data = next_data(data)) {
a61af66fc99e Initial load duke parents: diff changeset	1035 stream->set_start(data->bci());
a61af66fc99e Initial load duke parents: diff changeset	1036 stream->next();
a61af66fc99e Initial load duke parents: diff changeset	1037 data->post_initialize(stream, this);
a61af66fc99e Initial load duke parents: diff changeset	1038 }
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1039 if (_parameters_type_data_di != -1) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1040 parameters_type_data()->post_initialize(NULL, this);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1041 }
0 a61af66fc99e Initial load duke parents: diff changeset	1042 }
a61af66fc99e Initial load duke parents: diff changeset	1043
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1044 // Initialize the MethodData* corresponding to a given method.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1045 MethodData::MethodData(methodHandle method, int size, TRAPS) {
8611 6c4db417385a added API to reset the profiling information for a method Christian Haeubl <haeubl@ssw.jku.at> parents: 8125 diff changeset	1046 // Set the method back-pointer.
6c4db417385a added API to reset the profiling information for a method Christian Haeubl <haeubl@ssw.jku.at> parents: 8125 diff changeset	1047 _method = method();
6c4db417385a added API to reset the profiling information for a method Christian Haeubl <haeubl@ssw.jku.at> parents: 8125 diff changeset	1048 initialize();
6c4db417385a added API to reset the profiling information for a method Christian Haeubl <haeubl@ssw.jku.at> parents: 8125 diff changeset	1049 }
6c4db417385a added API to reset the profiling information for a method Christian Haeubl <haeubl@ssw.jku.at> parents: 8125 diff changeset	1050
13181 389d40d7d99f fixed bug in MethodData and added assertion that precomputed size == initialized size Doug Simon <doug.simon@oracle.com> parents: 13108 diff changeset	1051 void MethodData::initialize(bool for_reprofile) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1052 No_Safepoint_Verifier no_safepoint; // init function atomic wrt GC
0 a61af66fc99e Initial load duke parents: diff changeset	1053 ResourceMark rm;
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1054
9080 b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1055 init();
0 a61af66fc99e Initial load duke parents: diff changeset	1056 set_creation_mileage(mileage_of(method()));
a61af66fc99e Initial load duke parents: diff changeset	1057
a61af66fc99e Initial load duke parents: diff changeset	1058 // Go through the bytecodes and allocate and initialize the
a61af66fc99e Initial load duke parents: diff changeset	1059 // corresponding data cells.
a61af66fc99e Initial load duke parents: diff changeset	1060 int data_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	1061 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	1062 _data[0] = 0; // apparently not set below.
8611 6c4db417385a added API to reset the profiling information for a method Christian Haeubl <haeubl@ssw.jku.at> parents: 8125 diff changeset	1063 BytecodeStream stream(method());
0 a61af66fc99e Initial load duke parents: diff changeset	1064 Bytecodes::Code c;
a61af66fc99e Initial load duke parents: diff changeset	1065 while ((c = stream.next()) >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	1066 int size_in_bytes = initialize_data(&stream, data_size);
a61af66fc99e Initial load duke parents: diff changeset	1067 data_size += size_in_bytes;
13181 389d40d7d99f fixed bug in MethodData and added assertion that precomputed size == initialized size Doug Simon <doug.simon@oracle.com> parents: 13108 diff changeset	1068 if (size_in_bytes == 0 GRAAL_ONLY(&& Bytecodes::can_trap(c))) empty_bc_count += 1;
0 a61af66fc99e Initial load duke parents: diff changeset	1069 }
a61af66fc99e Initial load duke parents: diff changeset	1070 _data_size = data_size;
a61af66fc99e Initial load duke parents: diff changeset	1071 int object_size = in_bytes(data_offset()) + data_size;
a61af66fc99e Initial load duke parents: diff changeset	1072
a61af66fc99e Initial load duke parents: diff changeset	1073 // Add some extra DataLayout cells (at least one) to track stray traps.
a61af66fc99e Initial load duke parents: diff changeset	1074 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	1075 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	1076
13181 389d40d7d99f fixed bug in MethodData and added assertion that precomputed size == initialized size Doug Simon <doug.simon@oracle.com> parents: 13108 diff changeset	1077 #ifdef GRAAL
389d40d7d99f fixed bug in MethodData and added assertion that precomputed size == initialized size Doug Simon <doug.simon@oracle.com> parents: 13108 diff changeset	1078 if (for_reprofile) {
389d40d7d99f fixed bug in MethodData and added assertion that precomputed size == initialized size Doug Simon <doug.simon@oracle.com> parents: 13108 diff changeset	1079 // Clear out extra data
389d40d7d99f fixed bug in MethodData and added assertion that precomputed size == initialized size Doug Simon <doug.simon@oracle.com> parents: 13108 diff changeset	1080 Copy::zero_to_bytes((HeapWord*) extra_data_base(), extra_size);
389d40d7d99f fixed bug in MethodData and added assertion that precomputed size == initialized size Doug Simon <doug.simon@oracle.com> parents: 13108 diff changeset	1081 }
389d40d7d99f fixed bug in MethodData and added assertion that precomputed size == initialized size Doug Simon <doug.simon@oracle.com> parents: 13108 diff changeset	1082 #endif
8611 6c4db417385a added API to reset the profiling information for a method Christian Haeubl <haeubl@ssw.jku.at> parents: 8125 diff changeset	1083
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1084 // 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	1085 // 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	1086 // the code for traps cells works.
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1087 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	1088
8615 91c79e13b9cf minor C1/C2 fix Christian Haeubl <haeubl@ssw.jku.at> parents: 8611 diff changeset	1089 int arg_size = method()->size_of_parameters();
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1090 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	1091
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1092 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	1093 object_size += extra_size + arg_data_size;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1094
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1095 int args_cell = ParametersTypeData::compute_cell_count(method());
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1096 // 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	1097 // 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	1098 // 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	1099 // 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	1100 // this area (or -1 if no parameter is profiled)
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1101 if (args_cell > 0) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1102 object_size += DataLayout::compute_size_in_bytes(args_cell);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1103 _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	1104 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	1105 dp->initialize(DataLayout::parameters_type_data_tag, 0, args_cell);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1106 } else {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1107 _parameters_type_data_di = -1;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1108 }
0 a61af66fc99e Initial load duke parents: diff changeset	1109
a61af66fc99e Initial load duke parents: diff changeset	1110 // Set an initial hint. Don't use set_hint_di() because
a61af66fc99e Initial load duke parents: diff changeset	1111 // first_di() may be out of bounds if data_size is 0.
a61af66fc99e Initial load duke parents: diff changeset	1112 // In that situation, _hint_di is never used, but at
a61af66fc99e Initial load duke parents: diff changeset	1113 // least well-defined.
a61af66fc99e Initial load duke parents: diff changeset	1114 _hint_di = first_di();
a61af66fc99e Initial load duke parents: diff changeset	1115
a61af66fc99e Initial load duke parents: diff changeset	1116 post_initialize(&stream);
a61af66fc99e Initial load duke parents: diff changeset	1117
13181 389d40d7d99f fixed bug in MethodData and added assertion that precomputed size == initialized size Doug Simon <doug.simon@oracle.com> parents: 13108 diff changeset	1118 assert(object_size == compute_allocation_size_in_bytes(methodHandle(_method)), "MethodData: computed size != initialized size");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1119 set_size(object_size);
9080 b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1120 }
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 7956 diff changeset	1121
9080 b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1122 void MethodData::init() {
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1123 _invocation_counter.init();
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1124 _backedge_counter.init();
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1125 _invocation_counter_start = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1126 _backedge_counter_start = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1127 _num_loops = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1128 _num_blocks = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1129 _highest_comp_level = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1130 _highest_osr_comp_level = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1131 _would_profile = true;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1132
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1133 // Initialize flags and trap history.
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1134 _nof_decompiles = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1135 _nof_overflow_recompiles = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1136 _nof_overflow_traps = 0;
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1137 clear_escape_info();
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1138 assert(sizeof(_trap_hist) % sizeof(HeapWord) == 0, "align");
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1139 Copy::zero_to_words((HeapWord*) &_trap_hist,
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8860 diff changeset	1140 sizeof(_trap_hist) / sizeof(HeapWord));
0 a61af66fc99e Initial load duke parents: diff changeset	1141 }
a61af66fc99e Initial load duke parents: diff changeset	1142
a61af66fc99e Initial load duke parents: diff changeset	1143 // 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	1144 int MethodData::mileage_of(Method* method) {
0 a61af66fc99e Initial load duke parents: diff changeset	1145 int mileage = 0;
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1146 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1147 mileage = MAX2(method->invocation_count(), method->backedge_count());
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1148 } else {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1149 int iic = method->interpreter_invocation_count();
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1150 if (mileage < iic) mileage = iic;
10105 aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1151 MethodCounters* mcs = method->method_counters();
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1152 if (mcs != NULL) {
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1153 InvocationCounter* ic = mcs->invocation_counter();
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1154 InvocationCounter* bc = mcs->backedge_counter();
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1155 int icval = ic->count();
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1156 if (ic->carry()) icval += CompileThreshold;
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1157 if (mileage < icval) mileage = icval;
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1158 int bcval = bc->count();
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1159 if (bc->carry()) bcval += CompileThreshold;
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1160 if (mileage < bcval) mileage = bcval;
aeaca88565e6 8010862: The Method counter fields used for profiling can be allocated lazily. jiangli parents: 8860 diff changeset	1161 }
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1162 }
0 a61af66fc99e Initial load duke parents: diff changeset	1163 return mileage;
a61af66fc99e Initial load duke parents: diff changeset	1164 }
a61af66fc99e Initial load duke parents: diff changeset	1165
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1166 bool MethodData::is_mature() const {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	1167 return CompilationPolicy::policy()->is_mature(_method);
0 a61af66fc99e Initial load duke parents: diff changeset	1168 }
a61af66fc99e Initial load duke parents: diff changeset	1169
a61af66fc99e Initial load duke parents: diff changeset	1170 // 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	1171 address MethodData::bci_to_dp(int bci) {
0 a61af66fc99e Initial load duke parents: diff changeset	1172 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1173 ProfileData* data = data_before(bci);
a61af66fc99e Initial load duke parents: diff changeset	1174 ProfileData* prev = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1175 for ( ; is_valid(data); data = next_data(data)) {
a61af66fc99e Initial load duke parents: diff changeset	1176 if (data->bci() >= bci) {
a61af66fc99e Initial load duke parents: diff changeset	1177 if (data->bci() == bci) set_hint_di(dp_to_di(data->dp()));
a61af66fc99e Initial load duke parents: diff changeset	1178 else if (prev != NULL) set_hint_di(dp_to_di(prev->dp()));
a61af66fc99e Initial load duke parents: diff changeset	1179 return data->dp();
a61af66fc99e Initial load duke parents: diff changeset	1180 }
a61af66fc99e Initial load duke parents: diff changeset	1181 prev = data;
a61af66fc99e Initial load duke parents: diff changeset	1182 }
a61af66fc99e Initial load duke parents: diff changeset	1183 return (address)limit_data_position();
a61af66fc99e Initial load duke parents: diff changeset	1184 }
a61af66fc99e Initial load duke parents: diff changeset	1185
a61af66fc99e Initial load duke parents: diff changeset	1186 // 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	1187 ProfileData* MethodData::bci_to_data(int bci) {
0 a61af66fc99e Initial load duke parents: diff changeset	1188 ProfileData* data = data_before(bci);
a61af66fc99e Initial load duke parents: diff changeset	1189 for ( ; is_valid(data); data = next_data(data)) {
a61af66fc99e Initial load duke parents: diff changeset	1190 if (data->bci() == bci) {
a61af66fc99e Initial load duke parents: diff changeset	1191 set_hint_di(dp_to_di(data->dp()));
a61af66fc99e Initial load duke parents: diff changeset	1192 return data;
a61af66fc99e Initial load duke parents: diff changeset	1193 } else if (data->bci() > bci) {
a61af66fc99e Initial load duke parents: diff changeset	1194 break;
a61af66fc99e Initial load duke parents: diff changeset	1195 }
a61af66fc99e Initial load duke parents: diff changeset	1196 }
a61af66fc99e Initial load duke parents: diff changeset	1197 return bci_to_extra_data(bci, false);
a61af66fc99e Initial load duke parents: diff changeset	1198 }
a61af66fc99e Initial load duke parents: diff changeset	1199
a61af66fc99e Initial load duke parents: diff changeset	1200 // 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	1201 ProfileData* MethodData::bci_to_extra_data(int bci, bool create_if_missing) {
0 a61af66fc99e Initial load duke parents: diff changeset	1202 DataLayout* dp = extra_data_base();
a61af66fc99e Initial load duke parents: diff changeset	1203 DataLayout* end = extra_data_limit();
a61af66fc99e Initial load duke parents: diff changeset	1204 DataLayout* avail = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1205 for (; dp < end; dp = next_extra(dp)) {
a61af66fc99e Initial load duke parents: diff changeset	1206 // No need for "OrderAccess::load_acquire" ops,
a61af66fc99e Initial load duke parents: diff changeset	1207 // since the data structure is monotonic.
a61af66fc99e Initial load duke parents: diff changeset	1208 if (dp->tag() == DataLayout::no_tag) break;
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1209 if (dp->tag() == DataLayout::arg_info_data_tag) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1210 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	1211 break;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1212 }
0 a61af66fc99e Initial load duke parents: diff changeset	1213 if (dp->bci() == bci) {
a61af66fc99e Initial load duke parents: diff changeset	1214 assert(dp->tag() == DataLayout::bit_data_tag, "sane");
a61af66fc99e Initial load duke parents: diff changeset	1215 return new BitData(dp);
a61af66fc99e Initial load duke parents: diff changeset	1216 }
a61af66fc99e Initial load duke parents: diff changeset	1217 }
a61af66fc99e Initial load duke parents: diff changeset	1218 if (create_if_missing && dp < end) {
a61af66fc99e Initial load duke parents: diff changeset	1219 // Allocate this one. There is no mutual exclusion,
a61af66fc99e Initial load duke parents: diff changeset	1220 // so two threads could allocate different BCIs to the
a61af66fc99e Initial load duke parents: diff changeset	1221 // same data layout. This means these extra data
a61af66fc99e Initial load duke parents: diff changeset	1222 // records, like most other MDO contents, must not be
a61af66fc99e Initial load duke parents: diff changeset	1223 // trusted too much.
a61af66fc99e Initial load duke parents: diff changeset	1224 DataLayout temp;
a61af66fc99e Initial load duke parents: diff changeset	1225 temp.initialize(DataLayout::bit_data_tag, bci, 0);
a61af66fc99e Initial load duke parents: diff changeset	1226 dp->release_set_header(temp.header());
a61af66fc99e Initial load duke parents: diff changeset	1227 assert(dp->tag() == DataLayout::bit_data_tag, "sane");
a61af66fc99e Initial load duke parents: diff changeset	1228 //NO: assert(dp->bci() == bci, "no concurrent allocation");
a61af66fc99e Initial load duke parents: diff changeset	1229 return new BitData(dp);
a61af66fc99e Initial load duke parents: diff changeset	1230 }
a61af66fc99e Initial load duke parents: diff changeset	1231 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1232 }
a61af66fc99e Initial load duke parents: diff changeset	1233
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1234 ArgInfoData *MethodData::arg_info() {
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1235 DataLayout* dp = extra_data_base();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1236 DataLayout* end = extra_data_limit();
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1237 for (; dp < end; dp = next_extra(dp)) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1238 if (dp->tag() == DataLayout::arg_info_data_tag)
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1239 return new ArgInfoData(dp);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1240 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1241 return NULL;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1242 }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1243
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1244 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1245
0 a61af66fc99e Initial load duke parents: diff changeset	1246 #ifndef PRODUCT
6725 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::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1249 assert(is_methodData(), "should be method data");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1250 st->print("method data for ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1251 method()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1252 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1253 print_data_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1254 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1255
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1256 #endif //PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1257
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1258 void MethodData::print_value_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1259 assert(is_methodData(), "should be method data");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1260 st->print("method data for ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1261 method()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1262 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1263
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1264 #ifndef PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1265 void MethodData::print_data_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1266 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1267 ProfileData* data = first_data();
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1268 if (_parameters_type_data_di != -1) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1269 parameters_type_data()->print_data_on(st);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1270 }
0 a61af66fc99e Initial load duke parents: diff changeset	1271 for ( ; is_valid(data); data = next_data(data)) {
a61af66fc99e Initial load duke parents: diff changeset	1272 st->print("%d", dp_to_di(data->dp()));
a61af66fc99e Initial load duke parents: diff changeset	1273 st->fill_to(6);
a61af66fc99e Initial load duke parents: diff changeset	1274 data->print_data_on(st);
a61af66fc99e Initial load duke parents: diff changeset	1275 }
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1276 st->print_cr("--- Extra data:");
0 a61af66fc99e Initial load duke parents: diff changeset	1277 DataLayout* dp = extra_data_base();
a61af66fc99e Initial load duke parents: diff changeset	1278 DataLayout* end = extra_data_limit();
a61af66fc99e Initial load duke parents: diff changeset	1279 for (; dp < end; dp = next_extra(dp)) {
a61af66fc99e Initial load duke parents: diff changeset	1280 // No need for "OrderAccess::load_acquire" ops,
a61af66fc99e Initial load duke parents: diff changeset	1281 // since the data structure is monotonic.
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1282 if (dp->tag() == DataLayout::no_tag) continue;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1283 if (dp->tag() == DataLayout::bit_data_tag) {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1284 data = new BitData(dp);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1285 } else {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1286 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	1287 data = new ArgInfoData(dp);
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	1288 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	1289 }
0 a61af66fc99e Initial load duke parents: diff changeset	1290 st->print("%d", dp_to_di(data->dp()));
a61af66fc99e Initial load duke parents: diff changeset	1291 st->fill_to(6);
a61af66fc99e Initial load duke parents: diff changeset	1292 data->print_data_on(st);
a61af66fc99e Initial load duke parents: diff changeset	1293 }
a61af66fc99e Initial load duke parents: diff changeset	1294 }
a61af66fc99e Initial load duke parents: diff changeset	1295 #endif
a61af66fc99e Initial load duke parents: diff changeset	1296
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1297 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1298 // Size Statistics
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1299 void MethodData::collect_statistics(KlassSizeStats *sz) const {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1300 int n = sz->count(this);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1301 sz->_method_data_bytes += n;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1302 sz->_method_all_bytes += n;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1303 sz->_rw_bytes += n;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1304 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6725 diff changeset	1305 #endif // INCLUDE_SERVICES
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1306
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1307 // Verification
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1308
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1309 void MethodData::verify_on(outputStream* st) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1310 guarantee(is_methodData(), "object must be method data");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1311 // guarantee(m->is_perm(), "should be in permspace");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1312 this->verify_data_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1313 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1314
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 2264 diff changeset	1315 void MethodData::verify_data_on(outputStream* st) {
0 a61af66fc99e Initial load duke parents: diff changeset	1316 NEEDS_CLEANUP;
a61af66fc99e Initial load duke parents: diff changeset	1317 // not yet implemented.
a61af66fc99e Initial load duke parents: diff changeset	1318 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1319
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1320 bool MethodData::profile_jsr292(methodHandle m, int bci) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1321 if (m->is_compiled_lambda_form()) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1322 return true;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1323 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1324
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1325 Bytecode_invoke inv(m , bci);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1326 return inv.is_invokedynamic() \|\| inv.is_invokehandle();
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1327 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1328
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1329 int MethodData::profile_arguments_flag() {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1330 return TypeProfileLevel % 10;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1331 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1332
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1333 bool MethodData::profile_arguments() {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1334 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	1335 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1336
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1337 bool MethodData::profile_arguments_jsr292_only() {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1338 return profile_arguments_flag() == type_profile_jsr292;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1339 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1340
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1341 bool MethodData::profile_all_arguments() {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1342 return profile_arguments_flag() == type_profile_all;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1343 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1344
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1345 bool MethodData::profile_arguments_for_invoke(methodHandle m, int bci) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1346 if (!profile_arguments()) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1347 return false;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1348 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1349
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1350 if (profile_all_arguments()) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1351 return true;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1352 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1353
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1354 assert(profile_arguments_jsr292_only(), "inconsistent");
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1355 return profile_jsr292(m, bci);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1356 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 10376 diff changeset	1357
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1358 int MethodData::profile_return_flag() {
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1359 return (TypeProfileLevel % 100) / 10;
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1360 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1361
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1362 bool MethodData::profile_return() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1363 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	1364 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1365
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1366 bool MethodData::profile_return_jsr292_only() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1367 return profile_return_flag() == type_profile_jsr292;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1368 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1369
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1370 bool MethodData::profile_all_return() {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1371 return profile_return_flag() == type_profile_all;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1372 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1373
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1374 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	1375 if (!profile_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1376 return false;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1377 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1378
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1379 if (profile_all_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1380 return true;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1381 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1382
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1383 assert(profile_return_jsr292_only(), "inconsistent");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1384 return profile_jsr292(m, bci);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	1385 }
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1386
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1387 int MethodData::profile_parameters_flag() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1388 return TypeProfileLevel / 100;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1389 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1390
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1391 bool MethodData::profile_parameters() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1392 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	1393 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1394
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1395 bool MethodData::profile_parameters_jsr292_only() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1396 return profile_parameters_flag() == type_profile_jsr292;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1397 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1398
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1399 bool MethodData::profile_all_parameters() {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1400 return profile_parameters_flag() == type_profile_all;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1401 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1402
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1403 bool MethodData::profile_parameters_for_method(methodHandle m) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1404 if (!profile_parameters()) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1405 return false;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1406 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1407
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1408 if (profile_all_parameters()) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1409 return true;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1410 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1411
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1412 assert(profile_parameters_jsr292_only(), "inconsistent");
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1413 return m->is_compiled_lambda_form();
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	1414 }

Mercurial > hg > truffle

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