truffle: src/share/vm/ci/ciMethodData.hpp annotate

annotate src/share/vm/ci/ciMethodData.hpp @ 17716:cdb71841f4bc

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

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	55fb97c4c58d
children	fdad2932c73f

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17467 55fb97c4c58d 8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013 mikael parents: 13080 diff changeset	2 * Copyright (c) 2001, 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: 196 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 196 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: 196 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	25 #ifndef SHARE_VM_CI_CIMETHODDATA_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	26 #define SHARE_VM_CI_CIMETHODDATA_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	28 #include "ci/ciClassList.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	29 #include "ci/ciKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	30 #include "ci/ciObject.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	31 #include "ci/ciUtilities.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	32 #include "oops/methodData.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	33 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	34
0 a61af66fc99e Initial load duke parents: diff changeset	35 class ciBitData;
a61af66fc99e Initial load duke parents: diff changeset	36 class ciCounterData;
a61af66fc99e Initial load duke parents: diff changeset	37 class ciJumpData;
a61af66fc99e Initial load duke parents: diff changeset	38 class ciReceiverTypeData;
a61af66fc99e Initial load duke parents: diff changeset	39 class ciRetData;
a61af66fc99e Initial load duke parents: diff changeset	40 class ciBranchData;
a61af66fc99e Initial load duke parents: diff changeset	41 class ciArrayData;
a61af66fc99e Initial load duke parents: diff changeset	42 class ciMultiBranchData;
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	43 class ciArgInfoData;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	44 class ciCallTypeData;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	45 class ciVirtualCallTypeData;
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	46 class ciParametersTypeData;
0 a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48 typedef ProfileData ciProfileData;
a61af66fc99e Initial load duke parents: diff changeset	49
a61af66fc99e Initial load duke parents: diff changeset	50 class ciBitData : public BitData {
a61af66fc99e Initial load duke parents: diff changeset	51 public:
a61af66fc99e Initial load duke parents: diff changeset	52 ciBitData(DataLayout* layout) : BitData(layout) {};
a61af66fc99e Initial load duke parents: diff changeset	53 };
a61af66fc99e Initial load duke parents: diff changeset	54
a61af66fc99e Initial load duke parents: diff changeset	55 class ciCounterData : public CounterData {
a61af66fc99e Initial load duke parents: diff changeset	56 public:
a61af66fc99e Initial load duke parents: diff changeset	57 ciCounterData(DataLayout* layout) : CounterData(layout) {};
a61af66fc99e Initial load duke parents: diff changeset	58 };
a61af66fc99e Initial load duke parents: diff changeset	59
a61af66fc99e Initial load duke parents: diff changeset	60 class ciJumpData : public JumpData {
a61af66fc99e Initial load duke parents: diff changeset	61 public:
a61af66fc99e Initial load duke parents: diff changeset	62 ciJumpData(DataLayout* layout) : JumpData(layout) {};
a61af66fc99e Initial load duke parents: diff changeset	63 };
a61af66fc99e Initial load duke parents: diff changeset	64
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	65 class ciTypeEntries {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	66 protected:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	67 static intptr_t translate_klass(intptr_t k) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	68 Klass* v = TypeEntries::valid_klass(k);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	69 if (v != NULL) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	70 ciKlass* klass = CURRENT_ENV->get_klass(v);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	71 return with_status(klass, k);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	72 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	73 return with_status(NULL, k);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	74 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	75
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	76 public:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	77 static ciKlass* valid_ciklass(intptr_t k) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	78 if (!TypeEntries::is_type_none(k) &&
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	79 !TypeEntries::is_type_unknown(k)) {
13080 6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12966 diff changeset	80 ciKlass* res = (ciKlass*)TypeEntries::klass_part(k);
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12966 diff changeset	81 assert(res != NULL, "invalid");
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12966 diff changeset	82 return res;
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	83 } else {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	84 return NULL;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	85 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	86 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	87
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	88 static intptr_t with_status(ciKlass* k, intptr_t in) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	89 return TypeEntries::with_status((intptr_t)k, in);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	90 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	91
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	92 #ifndef PRODUCT
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	93 static void print_ciklass(outputStream* st, intptr_t k);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	94 #endif
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	95 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	96
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	97 class ciTypeStackSlotEntries : public TypeStackSlotEntries, ciTypeEntries {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	98 public:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	99 void translate_type_data_from(const TypeStackSlotEntries* args);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	100
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	101 ciKlass* valid_type(int i) const {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	102 return valid_ciklass(type(i));
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	103 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	104
12966 b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	105 bool maybe_null(int i) const {
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	106 return was_null_seen(type(i));
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	107 }
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	108
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	109 #ifndef PRODUCT
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	110 void print_data_on(outputStream* st) const;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	111 #endif
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	112 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	113
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	114 class ciReturnTypeEntry : public ReturnTypeEntry, ciTypeEntries {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	115 public:
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	116 void translate_type_data_from(const ReturnTypeEntry* ret);
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	117
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	118 ciKlass* valid_type() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	119 return valid_ciklass(type());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	120 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	121
12966 b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	122 bool maybe_null() const {
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	123 return was_null_seen(type());
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	124 }
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	125
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	126 #ifndef PRODUCT
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	127 void print_data_on(outputStream* st) const;
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	128 #endif
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	129 };
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	130
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	131 class ciCallTypeData : public CallTypeData {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	132 public:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	133 ciCallTypeData(DataLayout* layout) : CallTypeData(layout) {}
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	134
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	135 ciTypeStackSlotEntries* args() const { return (ciTypeStackSlotEntries*)CallTypeData::args(); }
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	136 ciReturnTypeEntry* ret() const { return (ciReturnTypeEntry*)CallTypeData::ret(); }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	137
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	138 void translate_from(const ProfileData* data) {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	139 if (has_arguments()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	140 args()->translate_type_data_from(data->as_CallTypeData()->args());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	141 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	142 if (has_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	143 ret()->translate_type_data_from(data->as_CallTypeData()->ret());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	144 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	145 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	146
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	147 intptr_t argument_type(int i) const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	148 assert(has_arguments(), "no arg type profiling data");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	149 return args()->type(i);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	150 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	151
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	152 ciKlass* valid_argument_type(int i) const {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	153 assert(has_arguments(), "no arg type profiling data");
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	154 return args()->valid_type(i);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	155 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	156
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	157 intptr_t return_type() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	158 assert(has_return(), "no ret type profiling data");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	159 return ret()->type();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	160 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	161
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	162 ciKlass* valid_return_type() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	163 assert(has_return(), "no ret type profiling data");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	164 return ret()->valid_type();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	165 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	166
12966 b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	167 bool argument_maybe_null(int i) const {
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	168 return args()->maybe_null(i);
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	169 }
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	170
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	171 bool return_maybe_null() const {
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	172 return ret()->maybe_null();
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	173 }
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	174
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	175 #ifndef PRODUCT
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	176 void print_data_on(outputStream* st) const;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	177 #endif
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	178 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	179
0 a61af66fc99e Initial load duke parents: diff changeset	180 class ciReceiverTypeData : public ReceiverTypeData {
a61af66fc99e Initial load duke parents: diff changeset	181 public:
a61af66fc99e Initial load duke parents: diff changeset	182 ciReceiverTypeData(DataLayout* layout) : ReceiverTypeData(layout) {};
a61af66fc99e Initial load duke parents: diff changeset	183
a61af66fc99e Initial load duke parents: diff changeset	184 void set_receiver(uint row, ciKlass* recv) {
a61af66fc99e Initial load duke parents: diff changeset	185 assert((uint)row < row_limit(), "oob");
a61af66fc99e Initial load duke parents: diff changeset	186 set_intptr_at(receiver0_offset + row * receiver_type_row_cell_count,
a61af66fc99e Initial load duke parents: diff changeset	187 (intptr_t) recv);
a61af66fc99e Initial load duke parents: diff changeset	188 }
a61af66fc99e Initial load duke parents: diff changeset	189
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	190 ciKlass* receiver(uint row) const {
0 a61af66fc99e Initial load duke parents: diff changeset	191 assert((uint)row < row_limit(), "oob");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	192 ciKlass* recv = (ciKlass)intptr_at(receiver0_offset + row receiver_type_row_cell_count);
0 a61af66fc99e Initial load duke parents: diff changeset	193 assert(recv == NULL \|\| recv->is_klass(), "wrong type");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	194 return recv;
0 a61af66fc99e Initial load duke parents: diff changeset	195 }
a61af66fc99e Initial load duke parents: diff changeset	196
a61af66fc99e Initial load duke parents: diff changeset	197 // Copy & translate from oop based ReceiverTypeData
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	198 virtual void translate_from(const ProfileData* data) {
0 a61af66fc99e Initial load duke parents: diff changeset	199 translate_receiver_data_from(data);
a61af66fc99e Initial load duke parents: diff changeset	200 }
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	201 void translate_receiver_data_from(const ProfileData* data);
0 a61af66fc99e Initial load duke parents: diff changeset	202 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	203 void print_data_on(outputStream* st) const;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	204 void print_receiver_data_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	205 #endif
a61af66fc99e Initial load duke parents: diff changeset	206 };
a61af66fc99e Initial load duke parents: diff changeset	207
a61af66fc99e Initial load duke parents: diff changeset	208 class ciVirtualCallData : public VirtualCallData {
a61af66fc99e Initial load duke parents: diff changeset	209 // Fake multiple inheritance... It's a ciReceiverTypeData also.
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	210 ciReceiverTypeData* rtd_super() const { return (ciReceiverTypeData*) this; }
0 a61af66fc99e Initial load duke parents: diff changeset	211
a61af66fc99e Initial load duke parents: diff changeset	212 public:
a61af66fc99e Initial load duke parents: diff changeset	213 ciVirtualCallData(DataLayout* layout) : VirtualCallData(layout) {};
a61af66fc99e Initial load duke parents: diff changeset	214
a61af66fc99e Initial load duke parents: diff changeset	215 void set_receiver(uint row, ciKlass* recv) {
a61af66fc99e Initial load duke parents: diff changeset	216 rtd_super()->set_receiver(row, recv);
a61af66fc99e Initial load duke parents: diff changeset	217 }
a61af66fc99e Initial load duke parents: diff changeset	218
a61af66fc99e Initial load duke parents: diff changeset	219 ciKlass* receiver(uint row) {
a61af66fc99e Initial load duke parents: diff changeset	220 return rtd_super()->receiver(row);
a61af66fc99e Initial load duke parents: diff changeset	221 }
a61af66fc99e Initial load duke parents: diff changeset	222
a61af66fc99e Initial load duke parents: diff changeset	223 // Copy & translate from oop based VirtualCallData
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	224 virtual void translate_from(const ProfileData* data) {
0 a61af66fc99e Initial load duke parents: diff changeset	225 rtd_super()->translate_receiver_data_from(data);
a61af66fc99e Initial load duke parents: diff changeset	226 }
a61af66fc99e Initial load duke parents: diff changeset	227 #ifndef PRODUCT
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	228 void print_data_on(outputStream* st) const;
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	229 #endif
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	230 };
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	231
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	232 class ciVirtualCallTypeData : public VirtualCallTypeData {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	233 private:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	234 // Fake multiple inheritance... It's a ciReceiverTypeData also.
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	235 ciReceiverTypeData* rtd_super() const { return (ciReceiverTypeData*) this; }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	236 public:
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	237 ciVirtualCallTypeData(DataLayout* layout) : VirtualCallTypeData(layout) {}
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	238
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	239 void set_receiver(uint row, ciKlass* recv) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	240 rtd_super()->set_receiver(row, recv);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	241 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	242
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	243 ciKlass* receiver(uint row) const {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	244 return rtd_super()->receiver(row);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	245 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	246
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	247 ciTypeStackSlotEntries* args() const { return (ciTypeStackSlotEntries*)VirtualCallTypeData::args(); }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	248 ciReturnTypeEntry* ret() const { return (ciReturnTypeEntry*)VirtualCallTypeData::ret(); }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	249
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	250 // Copy & translate from oop based VirtualCallData
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	251 virtual void translate_from(const ProfileData* data) {
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	252 rtd_super()->translate_receiver_data_from(data);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	253 if (has_arguments()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	254 args()->translate_type_data_from(data->as_VirtualCallTypeData()->args());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	255 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	256 if (has_return()) {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	257 ret()->translate_type_data_from(data->as_VirtualCallTypeData()->ret());
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	258 }
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
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	261 intptr_t argument_type(int i) const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	262 assert(has_arguments(), "no arg type profiling data");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	263 return args()->type(i);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	264 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	265
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	266 ciKlass* valid_argument_type(int i) const {
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	267 assert(has_arguments(), "no arg type profiling data");
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	268 return args()->valid_type(i);
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	269 }
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	270
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	271 intptr_t return_type() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	272 assert(has_return(), "no ret type profiling data");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	273 return ret()->type();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	274 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	275
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	276 ciKlass* valid_return_type() const {
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	277 assert(has_return(), "no ret type profiling data");
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	278 return ret()->valid_type();
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	279 }
ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	280
12966 b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	281 bool argument_maybe_null(int i) const {
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	282 return args()->maybe_null(i);
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	283 }
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	284
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	285 bool return_maybe_null() const {
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	286 return ret()->maybe_null();
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	287 }
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	288
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	289 #ifndef PRODUCT
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	290 void print_data_on(outputStream* st) const;
0 a61af66fc99e Initial load duke parents: diff changeset	291 #endif
a61af66fc99e Initial load duke parents: diff changeset	292 };
a61af66fc99e Initial load duke parents: diff changeset	293
a61af66fc99e Initial load duke parents: diff changeset	294
a61af66fc99e Initial load duke parents: diff changeset	295 class ciRetData : public RetData {
a61af66fc99e Initial load duke parents: diff changeset	296 public:
a61af66fc99e Initial load duke parents: diff changeset	297 ciRetData(DataLayout* layout) : RetData(layout) {};
a61af66fc99e Initial load duke parents: diff changeset	298 };
a61af66fc99e Initial load duke parents: diff changeset	299
a61af66fc99e Initial load duke parents: diff changeset	300 class ciBranchData : public BranchData {
a61af66fc99e Initial load duke parents: diff changeset	301 public:
a61af66fc99e Initial load duke parents: diff changeset	302 ciBranchData(DataLayout* layout) : BranchData(layout) {};
a61af66fc99e Initial load duke parents: diff changeset	303 };
a61af66fc99e Initial load duke parents: diff changeset	304
a61af66fc99e Initial load duke parents: diff changeset	305 class ciArrayData : public ArrayData {
a61af66fc99e Initial load duke parents: diff changeset	306 public:
a61af66fc99e Initial load duke parents: diff changeset	307 ciArrayData(DataLayout* layout) : ArrayData(layout) {};
a61af66fc99e Initial load duke parents: diff changeset	308 };
a61af66fc99e Initial load duke parents: diff changeset	309
a61af66fc99e Initial load duke parents: diff changeset	310 class ciMultiBranchData : public MultiBranchData {
a61af66fc99e Initial load duke parents: diff changeset	311 public:
a61af66fc99e Initial load duke parents: diff changeset	312 ciMultiBranchData(DataLayout* layout) : MultiBranchData(layout) {};
a61af66fc99e Initial load duke parents: diff changeset	313 };
a61af66fc99e Initial load duke parents: diff changeset	314
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	315 class ciArgInfoData : public ArgInfoData {
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	316 public:
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	317 ciArgInfoData(DataLayout* layout) : ArgInfoData(layout) {};
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	318 };
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	319
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	320 class ciParametersTypeData : public ParametersTypeData {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	321 public:
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	322 ciParametersTypeData(DataLayout* layout) : ParametersTypeData(layout) {}
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	323
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	324 virtual void translate_from(const ProfileData* data) {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	325 parameters()->translate_type_data_from(data->as_ParametersTypeData()->parameters());
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	326 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	327
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	328 ciTypeStackSlotEntries* parameters() const { return (ciTypeStackSlotEntries*)ParametersTypeData::parameters(); }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	329
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	330 ciKlass* valid_parameter_type(int i) const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	331 return parameters()->valid_type(i);
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	332 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	333
12966 b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	334 bool parameter_maybe_null(int i) const {
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	335 return parameters()->maybe_null(i);
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	336 }
b2ee5dc63353 8024070: C2 needs some form of type speculation roland parents: 12962 diff changeset	337
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	338 #ifndef PRODUCT
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	339 void print_data_on(outputStream* st) const;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	340 #endif
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	341 };
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	342
0 a61af66fc99e Initial load duke parents: diff changeset	343 // ciMethodData
a61af66fc99e Initial load duke parents: diff changeset	344 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	345 // This class represents a MethodData* in the HotSpot virtual
0 a61af66fc99e Initial load duke parents: diff changeset	346 // machine.
a61af66fc99e Initial load duke parents: diff changeset	347
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	348 class ciMethodData : public ciMetadata {
0 a61af66fc99e Initial load duke parents: diff changeset	349 CI_PACKAGE_ACCESS
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	350 friend class ciReplay;
0 a61af66fc99e Initial load duke parents: diff changeset	351
a61af66fc99e Initial load duke parents: diff changeset	352 private:
a61af66fc99e Initial load duke parents: diff changeset	353 // Size in bytes
a61af66fc99e Initial load duke parents: diff changeset	354 int _data_size;
a61af66fc99e Initial load duke parents: diff changeset	355 int _extra_data_size;
a61af66fc99e Initial load duke parents: diff changeset	356
a61af66fc99e Initial load duke parents: diff changeset	357 // Data entries
a61af66fc99e Initial load duke parents: diff changeset	358 intptr_t* _data;
a61af66fc99e Initial load duke parents: diff changeset	359
a61af66fc99e Initial load duke parents: diff changeset	360 // Cached hint for data_before()
a61af66fc99e Initial load duke parents: diff changeset	361 int _hint_di;
a61af66fc99e Initial load duke parents: diff changeset	362
a61af66fc99e Initial load duke parents: diff changeset	363 // Is data attached? And is it mature?
a61af66fc99e Initial load duke parents: diff changeset	364 enum { empty_state, immature_state, mature_state };
a61af66fc99e Initial load duke parents: diff changeset	365 u_char _state;
a61af66fc99e Initial load duke parents: diff changeset	366
a61af66fc99e Initial load duke parents: diff changeset	367 // Set this true if empty extra_data slots are ever witnessed.
a61af66fc99e Initial load duke parents: diff changeset	368 u_char _saw_free_extra_data;
a61af66fc99e Initial load duke parents: diff changeset	369
a61af66fc99e Initial load duke parents: diff changeset	370 // Support for interprocedural escape analysis
a61af66fc99e Initial load duke parents: diff changeset	371 intx _eflags; // flags on escape information
a61af66fc99e Initial load duke parents: diff changeset	372 intx _arg_local; // bit set of non-escaping arguments
a61af66fc99e Initial load duke parents: diff changeset	373 intx _arg_stack; // bit set of stack-allocatable arguments
a61af66fc99e Initial load duke parents: diff changeset	374 intx _arg_returned; // bit set of returned arguments
a61af66fc99e Initial load duke parents: diff changeset	375
a61af66fc99e Initial load duke parents: diff changeset	376 // Maturity of the oop when the snapshot is taken.
a61af66fc99e Initial load duke parents: diff changeset	377 int _current_mileage;
a61af66fc99e Initial load duke parents: diff changeset	378
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	379 // These counters hold the age of MDO in tiered. In tiered we can have the same method
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	380 // running at different compilation levels concurrently. So, in order to precisely measure
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	381 // its maturity we need separate counters.
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	382 int _invocation_counter;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	383 int _backedge_counter;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	384
0 a61af66fc99e Initial load duke parents: diff changeset	385 // Coherent snapshot of original header.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	386 MethodData _orig;
0 a61af66fc99e Initial load duke parents: diff changeset	387
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	388 // Dedicated area dedicated to parameters. Null if no parameter
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	389 // profiling for this method.
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	390 DataLayout* _parameters;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	391
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	392 ciMethodData(MethodData* md);
0 a61af66fc99e Initial load duke parents: diff changeset	393 ciMethodData();
a61af66fc99e Initial load duke parents: diff changeset	394
a61af66fc99e Initial load duke parents: diff changeset	395 // Accessors
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	396 int data_size() const { return _data_size; }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	397 int extra_data_size() const { return _extra_data_size; }
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	398 intptr_t * data() const { return _data; }
0 a61af66fc99e Initial load duke parents: diff changeset	399
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	400 MethodData* get_MethodData() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	401 return (MethodData*)_metadata;
0 a61af66fc99e Initial load duke parents: diff changeset	402 }
a61af66fc99e Initial load duke parents: diff changeset	403
a61af66fc99e Initial load duke parents: diff changeset	404 const char* type_string() { return "ciMethodData"; }
a61af66fc99e Initial load duke parents: diff changeset	405
a61af66fc99e Initial load duke parents: diff changeset	406 void print_impl(outputStream* st);
a61af66fc99e Initial load duke parents: diff changeset	407
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	408 DataLayout* data_layout_at(int data_index) const {
0 a61af66fc99e Initial load duke parents: diff changeset	409 assert(data_index % sizeof(intptr_t) == 0, "unaligned");
a61af66fc99e Initial load duke parents: diff changeset	410 return (DataLayout*) (((address)_data) + data_index);
a61af66fc99e Initial load duke parents: diff changeset	411 }
a61af66fc99e Initial load duke parents: diff changeset	412
a61af66fc99e Initial load duke parents: diff changeset	413 bool out_of_bounds(int data_index) {
a61af66fc99e Initial load duke parents: diff changeset	414 return data_index >= data_size();
a61af66fc99e Initial load duke parents: diff changeset	415 }
a61af66fc99e Initial load duke parents: diff changeset	416
a61af66fc99e Initial load duke parents: diff changeset	417 // hint accessors
a61af66fc99e Initial load duke parents: diff changeset	418 int hint_di() const { return _hint_di; }
a61af66fc99e Initial load duke parents: diff changeset	419 void set_hint_di(int di) {
a61af66fc99e Initial load duke parents: diff changeset	420 assert(!out_of_bounds(di), "hint_di out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	421 _hint_di = di;
a61af66fc99e Initial load duke parents: diff changeset	422 }
a61af66fc99e Initial load duke parents: diff changeset	423 ciProfileData* data_before(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	424 // avoid SEGV on this edge case
a61af66fc99e Initial load duke parents: diff changeset	425 if (data_size() == 0)
a61af66fc99e Initial load duke parents: diff changeset	426 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	427 int hint = hint_di();
a61af66fc99e Initial load duke parents: diff changeset	428 if (data_layout_at(hint)->bci() <= bci)
a61af66fc99e Initial load duke parents: diff changeset	429 return data_at(hint);
a61af66fc99e Initial load duke parents: diff changeset	430 return first_data();
a61af66fc99e Initial load duke parents: diff changeset	431 }
a61af66fc99e Initial load duke parents: diff changeset	432
a61af66fc99e Initial load duke parents: diff changeset	433
a61af66fc99e Initial load duke parents: diff changeset	434 // What is the index of the first data entry?
a61af66fc99e Initial load duke parents: diff changeset	435 int first_di() { return 0; }
a61af66fc99e Initial load duke parents: diff changeset	436
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	437 ciArgInfoData *arg_info() const;
48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	438
0 a61af66fc99e Initial load duke parents: diff changeset	439 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	440 bool is_method_data() const { return true; }
3371 fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 1972 diff changeset	441
fabcf26ee72f 6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW twisti parents: 1972 diff changeset	442 bool is_empty() { return _state == empty_state; }
0 a61af66fc99e Initial load duke parents: diff changeset	443 bool is_mature() { return _state == mature_state; }
a61af66fc99e Initial load duke parents: diff changeset	444
a61af66fc99e Initial load duke parents: diff changeset	445 int creation_mileage() { return _orig.creation_mileage(); }
a61af66fc99e Initial load duke parents: diff changeset	446 int current_mileage() { return _current_mileage; }
a61af66fc99e Initial load duke parents: diff changeset	447
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	448 int invocation_count() { return _invocation_counter; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	449 int backedge_count() { return _backedge_counter; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	450 // Transfer information about the method to MethodData*.
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	451 // would_profile means we would like to profile this method,
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	452 // meaning it's not trivial.
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	453 void set_would_profile(bool p);
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	454 // Also set the numer of loops and blocks in the method.
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	455 // Again, this is used to determine if a method is trivial.
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	456 void set_compilation_stats(short loops, short blocks);
12875 d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	457 // If the compiler finds a profiled type that is known statically
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	458 // for sure, set it in the MethodData
d13d7aba8c12 8023657: New type profiling points: arguments to call roland parents: 12868 diff changeset	459 void set_argument_type(int bci, int i, ciKlass* k);
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	460 void set_parameter_type(int i, ciKlass* k);
12882 ce0cc25bc5e2 8026054: New type profiling points: type of return values at calls roland parents: 12875 diff changeset	461 void set_return_type(int bci, ciKlass* k);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	462
0 a61af66fc99e Initial load duke parents: diff changeset	463 void load_data();
a61af66fc99e Initial load duke parents: diff changeset	464
a61af66fc99e Initial load duke parents: diff changeset	465 // Convert a dp (data pointer) to a di (data index).
a61af66fc99e Initial load duke parents: diff changeset	466 int dp_to_di(address dp) {
a61af66fc99e Initial load duke parents: diff changeset	467 return dp - ((address)_data);
a61af66fc99e Initial load duke parents: diff changeset	468 }
a61af66fc99e Initial load duke parents: diff changeset	469
a61af66fc99e Initial load duke parents: diff changeset	470 // Get the data at an arbitrary (sort of) data index.
a61af66fc99e Initial load duke parents: diff changeset	471 ciProfileData* data_at(int data_index);
a61af66fc99e Initial load duke parents: diff changeset	472
a61af66fc99e Initial load duke parents: diff changeset	473 // Walk through the data in order.
a61af66fc99e Initial load duke parents: diff changeset	474 ciProfileData* first_data() { return data_at(first_di()); }
a61af66fc99e Initial load duke parents: diff changeset	475 ciProfileData* next_data(ciProfileData* current);
a61af66fc99e Initial load duke parents: diff changeset	476 bool is_valid(ciProfileData* current) { return current != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	477
a61af66fc99e Initial load duke parents: diff changeset	478 // Get the data at an arbitrary bci, or NULL if there is none.
a61af66fc99e Initial load duke parents: diff changeset	479 ciProfileData* bci_to_data(int bci);
a61af66fc99e Initial load duke parents: diff changeset	480 ciProfileData* bci_to_extra_data(int bci, bool create_if_missing);
a61af66fc99e Initial load duke parents: diff changeset	481
a61af66fc99e Initial load duke parents: diff changeset	482 uint overflow_trap_count() const {
a61af66fc99e Initial load duke parents: diff changeset	483 return _orig.overflow_trap_count();
a61af66fc99e Initial load duke parents: diff changeset	484 }
a61af66fc99e Initial load duke parents: diff changeset	485 uint overflow_recompile_count() const {
a61af66fc99e Initial load duke parents: diff changeset	486 return _orig.overflow_recompile_count();
a61af66fc99e Initial load duke parents: diff changeset	487 }
a61af66fc99e Initial load duke parents: diff changeset	488 uint decompile_count() const {
a61af66fc99e Initial load duke parents: diff changeset	489 return _orig.decompile_count();
a61af66fc99e Initial load duke parents: diff changeset	490 }
a61af66fc99e Initial load duke parents: diff changeset	491 uint trap_count(int reason) const {
a61af66fc99e Initial load duke parents: diff changeset	492 return _orig.trap_count(reason);
a61af66fc99e Initial load duke parents: diff changeset	493 }
a61af66fc99e Initial load duke parents: diff changeset	494 uint trap_reason_limit() const { return _orig.trap_reason_limit(); }
a61af66fc99e Initial load duke parents: diff changeset	495 uint trap_count_limit() const { return _orig.trap_count_limit(); }
a61af66fc99e Initial load duke parents: diff changeset	496
a61af66fc99e Initial load duke parents: diff changeset	497 // Helpful query functions that decode trap_state.
a61af66fc99e Initial load duke parents: diff changeset	498 int has_trap_at(ciProfileData* data, int reason);
a61af66fc99e Initial load duke parents: diff changeset	499 int has_trap_at(int bci, int reason) {
a61af66fc99e Initial load duke parents: diff changeset	500 return has_trap_at(bci_to_data(bci), reason);
a61af66fc99e Initial load duke parents: diff changeset	501 }
a61af66fc99e Initial load duke parents: diff changeset	502 int trap_recompiled_at(ciProfileData* data);
a61af66fc99e Initial load duke parents: diff changeset	503 int trap_recompiled_at(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	504 return trap_recompiled_at(bci_to_data(bci));
a61af66fc99e Initial load duke parents: diff changeset	505 }
a61af66fc99e Initial load duke parents: diff changeset	506
a61af66fc99e Initial load duke parents: diff changeset	507 void clear_escape_info();
a61af66fc99e Initial load duke parents: diff changeset	508 bool has_escape_info();
a61af66fc99e Initial load duke parents: diff changeset	509 void update_escape_info();
a61af66fc99e Initial load duke parents: diff changeset	510
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	511 void set_eflag(MethodData::EscapeFlag f);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	512 void clear_eflag(MethodData::EscapeFlag f);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3371 diff changeset	513 bool eflag_set(MethodData::EscapeFlag f) const;
0 a61af66fc99e Initial load duke parents: diff changeset	514
a61af66fc99e Initial load duke parents: diff changeset	515 void set_arg_local(int i);
a61af66fc99e Initial load duke parents: diff changeset	516 void set_arg_stack(int i);
a61af66fc99e Initial load duke parents: diff changeset	517 void set_arg_returned(int i);
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	518 void set_arg_modified(int arg, uint val);
0 a61af66fc99e Initial load duke parents: diff changeset	519
a61af66fc99e Initial load duke parents: diff changeset	520 bool is_arg_local(int i) const;
a61af66fc99e Initial load duke parents: diff changeset	521 bool is_arg_stack(int i) const;
a61af66fc99e Initial load duke parents: diff changeset	522 bool is_arg_returned(int i) const;
45 48a3fa21394b 6667615: (Escape Analysis) extend MDO to cache arguments escape state kvn parents: 0 diff changeset	523 uint arg_modified(int arg) const;
0 a61af66fc99e Initial load duke parents: diff changeset	524
12962 5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	525 ciParametersTypeData* parameters_type_data() const {
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	526 return _parameters != NULL ? new ciParametersTypeData(_parameters) : NULL;
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	527 }
5ccbab1c69f3 8026251: New type profiling points: parameters to methods roland parents: 12882 diff changeset	528
0 a61af66fc99e Initial load duke parents: diff changeset	529 // Code generation helper
a61af66fc99e Initial load duke parents: diff changeset	530 ByteSize offset_of_slot(ciProfileData* data, ByteSize slot_offset_in_data);
a61af66fc99e Initial load duke parents: diff changeset	531 int byte_offset_of_slot(ciProfileData* data, ByteSize slot_offset_in_data) { return in_bytes(offset_of_slot(data, slot_offset_in_data)); }
a61af66fc99e Initial load duke parents: diff changeset	532
a61af66fc99e Initial load duke parents: diff changeset	533 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	534 // printing support for method data
a61af66fc99e Initial load duke parents: diff changeset	535 void print();
a61af66fc99e Initial load duke parents: diff changeset	536 void print_data_on(outputStream* st);
a61af66fc99e Initial load duke parents: diff changeset	537 #endif
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6725 diff changeset	538 void dump_replay_data(outputStream* out);
0 a61af66fc99e Initial load duke parents: diff changeset	539 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	540
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	541 #endif // SHARE_VM_CI_CIMETHODDATA_HPP

Mercurial > hg > truffle

annotate src/share/vm/ci/ciMethodData.hpp @ 17716:cdb71841f4bc