Mercurial > hg > graal-compiler
annotate src/share/vm/ci/ciMethodData.hpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | da91efe96a93 |
| children | c775af091fe9 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 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 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_CI_CIMETHODDATA_HPP |
| 26 #define SHARE_VM_CI_CIMETHODDATA_HPP | |
| 27 | |
| 28 #include "ci/ciClassList.hpp" | |
| 29 #include "ci/ciKlass.hpp" | |
| 30 #include "ci/ciObject.hpp" | |
| 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 | 33 #include "oops/oop.inline.hpp" |
| 34 | |
| 0 | 35 class ciBitData; |
| 36 class ciCounterData; | |
| 37 class ciJumpData; | |
| 38 class ciReceiverTypeData; | |
| 39 class ciRetData; | |
| 40 class ciBranchData; | |
| 41 class ciArrayData; | |
| 42 class ciMultiBranchData; | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
43 class ciArgInfoData; |
| 0 | 44 |
| 45 typedef ProfileData ciProfileData; | |
| 46 | |
| 47 class ciBitData : public BitData { | |
| 48 public: | |
| 49 ciBitData(DataLayout* layout) : BitData(layout) {}; | |
| 50 }; | |
| 51 | |
| 52 class ciCounterData : public CounterData { | |
| 53 public: | |
| 54 ciCounterData(DataLayout* layout) : CounterData(layout) {}; | |
| 55 }; | |
| 56 | |
| 57 class ciJumpData : public JumpData { | |
| 58 public: | |
| 59 ciJumpData(DataLayout* layout) : JumpData(layout) {}; | |
| 60 }; | |
| 61 | |
| 62 class ciReceiverTypeData : public ReceiverTypeData { | |
| 63 public: | |
| 64 ciReceiverTypeData(DataLayout* layout) : ReceiverTypeData(layout) {}; | |
| 65 | |
| 66 void set_receiver(uint row, ciKlass* recv) { | |
| 67 assert((uint)row < row_limit(), "oob"); | |
| 68 set_intptr_at(receiver0_offset + row * receiver_type_row_cell_count, | |
| 69 (intptr_t) recv); | |
| 70 } | |
| 71 | |
| 72 ciKlass* receiver(uint row) { | |
| 73 assert((uint)row < row_limit(), "oob"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
74 ciKlass* recv = (ciKlass*)intptr_at(receiver0_offset + row * receiver_type_row_cell_count); |
| 0 | 75 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
|
76 return recv; |
| 0 | 77 } |
| 78 | |
| 79 // Copy & translate from oop based ReceiverTypeData | |
| 80 virtual void translate_from(ProfileData* data) { | |
| 81 translate_receiver_data_from(data); | |
| 82 } | |
| 83 void translate_receiver_data_from(ProfileData* data); | |
| 84 #ifndef PRODUCT | |
| 85 void print_data_on(outputStream* st); | |
| 86 void print_receiver_data_on(outputStream* st); | |
| 87 #endif | |
| 88 }; | |
| 89 | |
| 90 class ciVirtualCallData : public VirtualCallData { | |
| 91 // Fake multiple inheritance... It's a ciReceiverTypeData also. | |
| 92 ciReceiverTypeData* rtd_super() { return (ciReceiverTypeData*) this; } | |
| 93 | |
| 94 public: | |
| 95 ciVirtualCallData(DataLayout* layout) : VirtualCallData(layout) {}; | |
| 96 | |
| 97 void set_receiver(uint row, ciKlass* recv) { | |
| 98 rtd_super()->set_receiver(row, recv); | |
| 99 } | |
| 100 | |
| 101 ciKlass* receiver(uint row) { | |
| 102 return rtd_super()->receiver(row); | |
| 103 } | |
| 104 | |
| 105 // Copy & translate from oop based VirtualCallData | |
| 106 virtual void translate_from(ProfileData* data) { | |
| 107 rtd_super()->translate_receiver_data_from(data); | |
| 108 } | |
| 109 #ifndef PRODUCT | |
| 110 void print_data_on(outputStream* st); | |
| 111 #endif | |
| 112 }; | |
| 113 | |
| 114 | |
| 115 class ciRetData : public RetData { | |
| 116 public: | |
| 117 ciRetData(DataLayout* layout) : RetData(layout) {}; | |
| 118 }; | |
| 119 | |
| 120 class ciBranchData : public BranchData { | |
| 121 public: | |
| 122 ciBranchData(DataLayout* layout) : BranchData(layout) {}; | |
| 123 }; | |
| 124 | |
| 125 class ciArrayData : public ArrayData { | |
| 126 public: | |
| 127 ciArrayData(DataLayout* layout) : ArrayData(layout) {}; | |
| 128 }; | |
| 129 | |
| 130 class ciMultiBranchData : public MultiBranchData { | |
| 131 public: | |
| 132 ciMultiBranchData(DataLayout* layout) : MultiBranchData(layout) {}; | |
| 133 }; | |
| 134 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
135 class ciArgInfoData : public ArgInfoData { |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
136 public: |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
137 ciArgInfoData(DataLayout* layout) : ArgInfoData(layout) {}; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
138 }; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
139 |
| 0 | 140 // ciMethodData |
| 141 // | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
142 // This class represents a MethodData* in the HotSpot virtual |
| 0 | 143 // machine. |
| 144 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
145 class ciMethodData : public ciMetadata { |
| 0 | 146 CI_PACKAGE_ACCESS |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
147 friend class ciReplay; |
| 0 | 148 |
| 149 private: | |
| 150 // Size in bytes | |
| 151 int _data_size; | |
| 152 int _extra_data_size; | |
| 153 | |
| 154 // Data entries | |
| 155 intptr_t* _data; | |
| 156 | |
| 157 // Cached hint for data_before() | |
| 158 int _hint_di; | |
| 159 | |
| 160 // Is data attached? And is it mature? | |
| 161 enum { empty_state, immature_state, mature_state }; | |
| 162 u_char _state; | |
| 163 | |
| 164 // Set this true if empty extra_data slots are ever witnessed. | |
| 165 u_char _saw_free_extra_data; | |
| 166 | |
| 167 // Support for interprocedural escape analysis | |
| 168 intx _eflags; // flags on escape information | |
| 169 intx _arg_local; // bit set of non-escaping arguments | |
| 170 intx _arg_stack; // bit set of stack-allocatable arguments | |
| 171 intx _arg_returned; // bit set of returned arguments | |
| 172 | |
| 173 // Maturity of the oop when the snapshot is taken. | |
| 174 int _current_mileage; | |
| 175 | |
| 1783 | 176 // These counters hold the age of MDO in tiered. In tiered we can have the same method |
| 177 // running at different compilation levels concurrently. So, in order to precisely measure | |
| 178 // its maturity we need separate counters. | |
| 179 int _invocation_counter; | |
| 180 int _backedge_counter; | |
| 181 | |
| 0 | 182 // Coherent snapshot of original header. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
183 MethodData _orig; |
| 0 | 184 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
185 ciMethodData(MethodData* md); |
| 0 | 186 ciMethodData(); |
| 187 | |
| 188 // Accessors | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
189 int data_size() const { return _data_size; } |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
190 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
|
191 intptr_t * data() const { return _data; } |
| 0 | 192 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
193 MethodData* get_MethodData() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
194 return (MethodData*)_metadata; |
| 0 | 195 } |
| 196 | |
| 197 const char* type_string() { return "ciMethodData"; } | |
| 198 | |
| 199 void print_impl(outputStream* st); | |
| 200 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
201 DataLayout* data_layout_at(int data_index) const { |
| 0 | 202 assert(data_index % sizeof(intptr_t) == 0, "unaligned"); |
| 203 return (DataLayout*) (((address)_data) + data_index); | |
| 204 } | |
| 205 | |
| 206 bool out_of_bounds(int data_index) { | |
| 207 return data_index >= data_size(); | |
| 208 } | |
| 209 | |
| 210 // hint accessors | |
| 211 int hint_di() const { return _hint_di; } | |
| 212 void set_hint_di(int di) { | |
| 213 assert(!out_of_bounds(di), "hint_di out of bounds"); | |
| 214 _hint_di = di; | |
| 215 } | |
| 216 ciProfileData* data_before(int bci) { | |
| 217 // avoid SEGV on this edge case | |
| 218 if (data_size() == 0) | |
| 219 return NULL; | |
| 220 int hint = hint_di(); | |
| 221 if (data_layout_at(hint)->bci() <= bci) | |
| 222 return data_at(hint); | |
| 223 return first_data(); | |
| 224 } | |
| 225 | |
| 226 | |
| 227 // What is the index of the first data entry? | |
| 228 int first_di() { return 0; } | |
| 229 | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
230 ciArgInfoData *arg_info() const; |
|
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
231 |
| 0 | 232 public: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
233 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
|
234 |
|
fabcf26ee72f
6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW
twisti
parents:
1972
diff
changeset
|
235 void set_mature() { _state = mature_state; } |
|
fabcf26ee72f
6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW
twisti
parents:
1972
diff
changeset
|
236 |
|
fabcf26ee72f
6998541: JSR 292 implement missing return-type conversion for OP_RETYPE_RAW
twisti
parents:
1972
diff
changeset
|
237 bool is_empty() { return _state == empty_state; } |
| 0 | 238 bool is_mature() { return _state == mature_state; } |
| 239 | |
| 240 int creation_mileage() { return _orig.creation_mileage(); } | |
| 241 int current_mileage() { return _current_mileage; } | |
| 242 | |
| 1783 | 243 int invocation_count() { return _invocation_counter; } |
| 244 int backedge_count() { return _backedge_counter; } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
245 // Transfer information about the method to MethodData*. |
| 1783 | 246 // would_profile means we would like to profile this method, |
| 247 // meaning it's not trivial. | |
| 248 void set_would_profile(bool p); | |
| 249 // Also set the numer of loops and blocks in the method. | |
| 250 // Again, this is used to determine if a method is trivial. | |
| 251 void set_compilation_stats(short loops, short blocks); | |
| 252 | |
| 0 | 253 void load_data(); |
| 254 | |
| 255 // Convert a dp (data pointer) to a di (data index). | |
| 256 int dp_to_di(address dp) { | |
| 257 return dp - ((address)_data); | |
| 258 } | |
| 259 | |
| 260 // Get the data at an arbitrary (sort of) data index. | |
| 261 ciProfileData* data_at(int data_index); | |
| 262 | |
| 263 // Walk through the data in order. | |
| 264 ciProfileData* first_data() { return data_at(first_di()); } | |
| 265 ciProfileData* next_data(ciProfileData* current); | |
| 266 bool is_valid(ciProfileData* current) { return current != NULL; } | |
| 267 | |
| 268 // Get the data at an arbitrary bci, or NULL if there is none. | |
| 269 ciProfileData* bci_to_data(int bci); | |
| 270 ciProfileData* bci_to_extra_data(int bci, bool create_if_missing); | |
| 271 | |
| 272 uint overflow_trap_count() const { | |
| 273 return _orig.overflow_trap_count(); | |
| 274 } | |
| 275 uint overflow_recompile_count() const { | |
| 276 return _orig.overflow_recompile_count(); | |
| 277 } | |
| 278 uint decompile_count() const { | |
| 279 return _orig.decompile_count(); | |
| 280 } | |
| 281 uint trap_count(int reason) const { | |
| 282 return _orig.trap_count(reason); | |
| 283 } | |
| 284 uint trap_reason_limit() const { return _orig.trap_reason_limit(); } | |
| 285 uint trap_count_limit() const { return _orig.trap_count_limit(); } | |
| 286 | |
| 287 // Helpful query functions that decode trap_state. | |
| 288 int has_trap_at(ciProfileData* data, int reason); | |
| 289 int has_trap_at(int bci, int reason) { | |
| 290 return has_trap_at(bci_to_data(bci), reason); | |
| 291 } | |
| 292 int trap_recompiled_at(ciProfileData* data); | |
| 293 int trap_recompiled_at(int bci) { | |
| 294 return trap_recompiled_at(bci_to_data(bci)); | |
| 295 } | |
| 296 | |
| 297 void clear_escape_info(); | |
| 298 bool has_escape_info(); | |
| 299 void update_escape_info(); | |
| 300 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
301 void set_eflag(MethodData::EscapeFlag f); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
302 void clear_eflag(MethodData::EscapeFlag f); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3371
diff
changeset
|
303 bool eflag_set(MethodData::EscapeFlag f) const; |
| 0 | 304 |
| 305 void set_arg_local(int i); | |
| 306 void set_arg_stack(int i); | |
| 307 void set_arg_returned(int i); | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
308 void set_arg_modified(int arg, uint val); |
| 0 | 309 |
| 310 bool is_arg_local(int i) const; | |
| 311 bool is_arg_stack(int i) const; | |
| 312 bool is_arg_returned(int i) const; | |
|
45
48a3fa21394b
6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents:
0
diff
changeset
|
313 uint arg_modified(int arg) const; |
| 0 | 314 |
| 315 // Code generation helper | |
| 316 ByteSize offset_of_slot(ciProfileData* data, ByteSize slot_offset_in_data); | |
| 317 int byte_offset_of_slot(ciProfileData* data, ByteSize slot_offset_in_data) { return in_bytes(offset_of_slot(data, slot_offset_in_data)); } | |
| 318 | |
| 319 #ifndef PRODUCT | |
| 320 // printing support for method data | |
| 321 void print(); | |
| 322 void print_data_on(outputStream* st); | |
| 323 #endif | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6725
diff
changeset
|
324 void dump_replay_data(outputStream* out); |
| 0 | 325 }; |
| 1972 | 326 |
| 327 #endif // SHARE_VM_CI_CIMETHODDATA_HPP |