Mercurial > hg > truffle
annotate src/share/vm/oops/constMethodOop.hpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
| author | tonyp |
|---|---|
| date | Fri, 16 Dec 2011 02:14:27 -0500 |
| parents | f95d63e2154a |
| children | 2fe087c3e814 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 2003, 2010, 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:
1138
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1138
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:
1138
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OOPS_CONSTMETHODOOP_HPP |
| 26 #define SHARE_VM_OOPS_CONSTMETHODOOP_HPP | |
| 27 | |
| 28 #include "oops/oop.hpp" | |
| 29 #include "oops/typeArrayOop.hpp" | |
| 30 | |
| 0 | 31 // An constMethodOop represents portions of a Java method which |
| 32 // do not vary. | |
| 33 // | |
| 34 // Memory layout (each line represents a word). Note that most | |
| 35 // applications load thousands of methods, so keeping the size of this | |
| 36 // structure small has a big impact on footprint. | |
| 37 // | |
| 38 // |------------------------------------------------------| | |
| 39 // | header | | |
| 40 // | klass | | |
| 41 // |------------------------------------------------------| | |
| 42 // | fingerprint 1 | | |
| 43 // | fingerprint 2 | | |
| 44 // | method (oop) | | |
| 45 // | stackmap_data (oop) | | |
| 46 // | exception_table (oop) | | |
| 47 // | constMethod_size | | |
| 48 // | interp_kind | flags | code_size | | |
| 49 // | name index | signature index | | |
| 50 // | method_idnum | generic_signature_index | | |
| 51 // |------------------------------------------------------| | |
| 52 // | | | |
| 53 // | byte codes | | |
| 54 // | | | |
| 55 // |------------------------------------------------------| | |
| 56 // | compressed linenumber table | | |
| 57 // | (see class CompressedLineNumberReadStream) | | |
| 58 // | (note that length is unknown until decompressed) | | |
| 59 // | (access flags bit tells whether table is present) | | |
| 60 // | (indexed from start of constMethodOop) | | |
| 61 // | (elements not necessarily sorted!) | | |
| 62 // |------------------------------------------------------| | |
| 63 // | localvariable table elements + length (length last) | | |
| 64 // | (length is u2, elements are 6-tuples of u2) | | |
| 65 // | (see class LocalVariableTableElement) | | |
| 66 // | (access flags bit tells whether table is present) | | |
| 67 // | (indexed from end of contMethodOop) | | |
| 68 // |------------------------------------------------------| | |
| 69 // | checked exceptions elements + length (length last) | | |
| 70 // | (length is u2, elements are u2) | | |
| 71 // | (see class CheckedExceptionElement) | | |
| 72 // | (access flags bit tells whether table is present) | | |
| 73 // | (indexed from end of constMethodOop) | | |
| 74 // |------------------------------------------------------| | |
| 75 | |
| 76 | |
| 77 // Utitily class decribing elements in checked exceptions table inlined in methodOop. | |
| 78 class CheckedExceptionElement VALUE_OBJ_CLASS_SPEC { | |
| 79 public: | |
| 80 u2 class_cp_index; | |
| 81 }; | |
| 82 | |
| 83 | |
| 84 // Utitily class decribing elements in local variable table inlined in methodOop. | |
| 85 class LocalVariableTableElement VALUE_OBJ_CLASS_SPEC { | |
| 86 public: | |
| 87 u2 start_bci; | |
| 88 u2 length; | |
| 89 u2 name_cp_index; | |
| 90 u2 descriptor_cp_index; | |
| 91 u2 signature_cp_index; | |
| 92 u2 slot; | |
| 93 }; | |
| 94 | |
| 95 | |
| 96 class constMethodOopDesc : public oopDesc { | |
| 97 friend class constMethodKlass; | |
| 98 friend class VMStructs; | |
| 99 private: | |
| 100 enum { | |
| 101 _has_linenumber_table = 1, | |
| 102 _has_checked_exceptions = 2, | |
| 103 _has_localvariable_table = 4 | |
| 104 }; | |
| 105 | |
| 106 // Bit vector of signature | |
| 107 // Callers interpret 0=not initialized yet and | |
| 108 // -1=too many args to fix, must parse the slow way. | |
| 109 // The real initial value is special to account for nonatomicity of 64 bit | |
| 110 // loads and stores. This value may updated and read without a lock by | |
| 111 // multiple threads, so is volatile. | |
| 112 volatile uint64_t _fingerprint; | |
|
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
0
diff
changeset
|
113 volatile bool _is_conc_safe; // if true, safe for concurrent GC processing |
| 0 | 114 |
| 115 public: | |
| 116 oop* oop_block_beg() const { return adr_method(); } | |
| 117 oop* oop_block_end() const { return adr_exception_table() + 1; } | |
| 118 | |
| 119 private: | |
| 120 // | |
| 121 // The oop block. See comment in klass.hpp before making changes. | |
| 122 // | |
| 123 | |
| 124 // Backpointer to non-const methodOop (needed for some JVMTI operations) | |
| 125 methodOop _method; | |
| 126 | |
| 127 // Raw stackmap data for the method | |
| 128 typeArrayOop _stackmap_data; | |
| 129 | |
| 130 // The exception handler table. 4-tuples of ints [start_pc, end_pc, | |
| 131 // handler_pc, catch_type index] For methods with no exceptions the | |
| 132 // table is pointing to Universe::the_empty_int_array | |
| 133 typeArrayOop _exception_table; | |
| 134 | |
| 135 // | |
| 136 // End of the oop block. | |
| 137 // | |
| 138 | |
| 139 int _constMethod_size; | |
| 140 jbyte _interpreter_kind; | |
| 141 jbyte _flags; | |
| 142 | |
| 143 // Size of Java bytecodes allocated immediately after methodOop. | |
| 144 u2 _code_size; | |
| 145 u2 _name_index; // Method name (index in constant pool) | |
| 146 u2 _signature_index; // Method signature (index in constant pool) | |
| 147 u2 _method_idnum; // unique identification number for the method within the class | |
| 148 // initially corresponds to the index into the methods array. | |
| 149 // but this may change with redefinition | |
| 150 u2 _generic_signature_index; // Generic signature (index in constant pool, 0 if absent) | |
| 151 | |
| 152 public: | |
| 153 // Inlined tables | |
| 154 void set_inlined_tables_length(int checked_exceptions_len, | |
| 155 int compressed_line_number_size, | |
| 156 int localvariable_table_len); | |
| 157 | |
| 158 bool has_linenumber_table() const | |
| 159 { return (_flags & _has_linenumber_table) != 0; } | |
| 160 | |
| 161 bool has_checked_exceptions() const | |
| 162 { return (_flags & _has_checked_exceptions) != 0; } | |
| 163 | |
| 164 bool has_localvariable_table() const | |
| 165 { return (_flags & _has_localvariable_table) != 0; } | |
| 166 | |
| 167 void set_interpreter_kind(int kind) { _interpreter_kind = kind; } | |
| 168 int interpreter_kind(void) const { return _interpreter_kind; } | |
| 169 | |
| 170 // backpointer to non-const methodOop | |
| 171 methodOop method() const { return _method; } | |
| 172 void set_method(methodOop m) { oop_store_without_check((oop*)&_method, (oop) m); } | |
| 173 | |
| 174 | |
| 175 // stackmap table data | |
| 176 typeArrayOop stackmap_data() const { return _stackmap_data; } | |
| 177 void set_stackmap_data(typeArrayOop sd) { | |
| 178 oop_store_without_check((oop*)&_stackmap_data, (oop)sd); | |
| 179 } | |
| 180 bool has_stackmap_table() const { return _stackmap_data != NULL; } | |
| 181 | |
| 182 // exception handler table | |
| 183 typeArrayOop exception_table() const { return _exception_table; } | |
| 184 void set_exception_table(typeArrayOop e) { oop_store_without_check((oop*) &_exception_table, (oop) e); } | |
| 185 bool has_exception_handler() const { return exception_table() != NULL && exception_table()->length() > 0; } | |
| 186 | |
| 187 void init_fingerprint() { | |
| 188 const uint64_t initval = CONST64(0x8000000000000000); | |
| 189 _fingerprint = initval; | |
| 190 } | |
| 191 | |
| 192 uint64_t fingerprint() const { | |
| 193 // Since reads aren't atomic for 64 bits, if any of the high or low order | |
| 194 // word is the initial value, return 0. See init_fingerprint for initval. | |
| 195 uint high_fp = (uint)(_fingerprint >> 32); | |
| 196 if ((int) _fingerprint == 0 || high_fp == 0x80000000) { | |
| 197 return 0L; | |
| 198 } else { | |
| 199 return _fingerprint; | |
| 200 } | |
| 201 } | |
| 202 | |
| 203 uint64_t set_fingerprint(uint64_t new_fingerprint) { | |
| 204 #ifdef ASSERT | |
| 205 // Assert only valid if complete/valid 64 bit _fingerprint value is read. | |
| 206 uint64_t oldfp = fingerprint(); | |
| 207 #endif // ASSERT | |
| 208 _fingerprint = new_fingerprint; | |
| 209 assert(oldfp == 0L || new_fingerprint == oldfp, | |
| 210 "fingerprint cannot change"); | |
| 211 assert(((new_fingerprint >> 32) != 0x80000000) && (int)new_fingerprint !=0, | |
| 212 "fingerprint should call init to set initial value"); | |
| 213 return new_fingerprint; | |
| 214 } | |
| 215 | |
| 216 // name | |
| 217 int name_index() const { return _name_index; } | |
| 218 void set_name_index(int index) { _name_index = index; } | |
| 219 | |
| 220 // signature | |
| 221 int signature_index() const { return _signature_index; } | |
| 222 void set_signature_index(int index) { _signature_index = index; } | |
| 223 | |
| 224 // generics support | |
| 225 int generic_signature_index() const { return _generic_signature_index; } | |
| 226 void set_generic_signature_index(int index) { _generic_signature_index = index; } | |
| 227 | |
| 228 // Sizing | |
| 229 static int header_size() { | |
| 230 return sizeof(constMethodOopDesc)/HeapWordSize; | |
| 231 } | |
| 232 | |
| 233 // Object size needed | |
| 234 static int object_size(int code_size, int compressed_line_number_size, | |
| 235 int local_variable_table_length, | |
| 236 int checked_exceptions_length); | |
| 237 | |
| 238 int object_size() const { return _constMethod_size; } | |
| 239 void set_constMethod_size(int size) { _constMethod_size = size; } | |
| 240 // Is object parsable by gc | |
| 241 bool object_is_parsable() { return object_size() > 0; } | |
| 242 | |
| 243 // code size | |
| 244 int code_size() const { return _code_size; } | |
| 245 void set_code_size(int size) { | |
| 246 assert(max_method_code_size < (1 << 16), | |
| 247 "u2 is too small to hold method code size in general"); | |
| 248 assert(0 <= size && size <= max_method_code_size, "invalid code size"); | |
| 249 _code_size = size; | |
| 250 } | |
| 251 | |
| 252 // linenumber table - note that length is unknown until decompression, | |
| 253 // see class CompressedLineNumberReadStream. | |
| 254 u_char* compressed_linenumber_table() const; // not preserved by gc | |
| 255 u2* checked_exceptions_length_addr() const; | |
| 256 u2* localvariable_table_length_addr() const; | |
| 257 | |
| 258 // checked exceptions | |
| 259 int checked_exceptions_length() const; | |
| 260 CheckedExceptionElement* checked_exceptions_start() const; | |
| 261 | |
| 262 // localvariable table | |
| 263 int localvariable_table_length() const; | |
| 264 LocalVariableTableElement* localvariable_table_start() const; | |
| 265 | |
| 266 // byte codes | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
579
diff
changeset
|
267 void set_code(address code) { |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
579
diff
changeset
|
268 if (code_size() > 0) { |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
579
diff
changeset
|
269 memcpy(code_base(), code, code_size()); |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
579
diff
changeset
|
270 } |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
579
diff
changeset
|
271 } |
| 0 | 272 address code_base() const { return (address) (this+1); } |
| 273 address code_end() const { return code_base() + code_size(); } | |
| 274 bool contains(address bcp) const { return code_base() <= bcp | |
| 275 && bcp < code_end(); } | |
| 276 // Offset to bytecodes | |
| 277 static ByteSize codes_offset() | |
| 278 { return in_ByteSize(sizeof(constMethodOopDesc)); } | |
| 279 | |
| 280 // interpreter support | |
| 281 static ByteSize exception_table_offset() | |
| 282 { return byte_offset_of(constMethodOopDesc, _exception_table); } | |
| 283 | |
| 284 // Garbage collection support | |
| 285 oop* adr_method() const { return (oop*)&_method; } | |
| 286 oop* adr_stackmap_data() const { return (oop*)&_stackmap_data; } | |
| 287 oop* adr_exception_table() const { return (oop*)&_exception_table; } | |
|
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
0
diff
changeset
|
288 bool is_conc_safe() { return _is_conc_safe; } |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
0
diff
changeset
|
289 void set_is_conc_safe(bool v) { _is_conc_safe = v; } |
| 0 | 290 |
| 291 // Unique id for the method | |
| 292 static const u2 MAX_IDNUM; | |
| 293 static const u2 UNSET_IDNUM; | |
| 294 u2 method_idnum() const { return _method_idnum; } | |
| 295 void set_method_idnum(u2 idnum) { _method_idnum = idnum; } | |
| 296 | |
| 297 private: | |
| 298 // Since the size of the compressed line number table is unknown, the | |
| 299 // offsets of the other variable sized sections are computed backwards | |
| 300 // from the end of the constMethodOop. | |
| 301 | |
| 302 // First byte after constMethodOop | |
| 303 address constMethod_end() const | |
| 304 { return (address)((oop*)this + _constMethod_size); } | |
| 305 | |
| 306 // Last short in constMethodOop | |
| 307 u2* last_u2_element() const | |
| 308 { return (u2*)constMethod_end() - 1; } | |
| 309 }; | |
| 1972 | 310 |
| 311 #endif // SHARE_VM_OOPS_CONSTMETHODOOP_HPP |