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

annotate src/share/vm/ci/ciMethodData.hpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	2c6ef90f030a
children	7848fc12602b

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

Mercurial > hg > truffle

annotate src/share/vm/ci/ciMethodData.hpp @ 20543:e7d0505c8a30