Mercurial > hg > truffle
annotate src/share/vm/oops/methodOop.hpp @ 3011:f00918f35c7f
inlining and runtime interface related changes:
added codeSize() and compilerStorage() to RiMethod
HotSpotMethodResolved uses reflective methods instead of vmIds and survives compilations
HotSpotResolvedType.isInitialized not represented as field (can change)
inlining stores graphs into method objects and reuses them
| author | Lukas Stadler <lukas.stadler@jku.at> |
|---|---|
| date | Thu, 16 Jun 2011 20:36:17 +0200 |
| parents | 38fea01eb669 |
| children | be4ca325525a |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2142 | 2 * Copyright (c) 1997, 2011, 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:
1507
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
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:
1507
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OOPS_METHODOOP_HPP |
| 26 #define SHARE_VM_OOPS_METHODOOP_HPP | |
| 27 | |
| 28 #include "classfile/vmSymbols.hpp" | |
| 29 #include "code/compressedStream.hpp" | |
| 30 #include "compiler/oopMap.hpp" | |
| 31 #include "interpreter/invocationCounter.hpp" | |
| 32 #include "oops/constMethodOop.hpp" | |
| 33 #include "oops/constantPoolOop.hpp" | |
| 34 #include "oops/instanceKlass.hpp" | |
| 35 #include "oops/oop.hpp" | |
| 36 #include "oops/typeArrayOop.hpp" | |
| 37 #include "utilities/accessFlags.hpp" | |
| 38 #include "utilities/growableArray.hpp" | |
| 39 | |
| 0 | 40 // A methodOop represents a Java method. |
| 41 // | |
| 42 // Memory layout (each line represents a word). Note that most applications load thousands of methods, | |
| 43 // so keeping the size of this structure small has a big impact on footprint. | |
| 44 // | |
| 45 // We put all oops and method_size first for better gc cache locality. | |
| 46 // | |
| 47 // The actual bytecodes are inlined after the end of the methodOopDesc struct. | |
| 48 // | |
| 49 // There are bits in the access_flags telling whether inlined tables are present. | |
| 50 // Note that accessing the line number and local variable tables is not performance critical at all. | |
| 51 // Accessing the checked exceptions table is used by reflection, so we put that last to make access | |
| 52 // to it fast. | |
| 53 // | |
| 54 // The line number table is compressed and inlined following the byte codes. It is found as the first | |
| 55 // byte following the byte codes. The checked exceptions table and the local variable table are inlined | |
| 56 // after the line number table, and indexed from the end of the method. We do not compress the checked | |
| 57 // exceptions table since the average length is less than 2, and do not bother to compress the local | |
| 58 // variable table either since it is mostly absent. | |
| 59 // | |
| 60 // Note that native_function and signature_handler has to be at fixed offsets (required by the interpreter) | |
| 61 // | |
| 62 // |------------------------------------------------------| | |
| 63 // | header | | |
| 64 // | klass | | |
| 65 // |------------------------------------------------------| | |
| 66 // | constMethodOop (oop) | | |
| 67 // | constants (oop) | | |
| 68 // |------------------------------------------------------| | |
| 69 // | methodData (oop) | | |
| 70 // | interp_invocation_count | | |
| 71 // |------------------------------------------------------| | |
| 72 // | access_flags | | |
| 73 // | vtable_index | | |
| 74 // |------------------------------------------------------| | |
| 75 // | result_index (C++ interpreter only) | | |
| 76 // |------------------------------------------------------| | |
| 77 // | method_size | max_stack | | |
| 78 // | max_locals | size_of_parameters | | |
| 79 // |------------------------------------------------------| | |
| 1783 | 80 // | intrinsic_id, (unused) | throwout_count | |
| 0 | 81 // |------------------------------------------------------| |
| 1783 | 82 // | num_breakpoints | (unused) | |
| 0 | 83 // |------------------------------------------------------| |
| 84 // | invocation_counter | | |
| 85 // | backedge_counter | | |
| 86 // |------------------------------------------------------| | |
|
2348
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
87 // | prev_time (tiered only, 64 bit wide) | |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
88 // | | |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
89 // |------------------------------------------------------| |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
90 // | rate (tiered) | |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
91 // |------------------------------------------------------| |
| 0 | 92 // | code (pointer) | |
| 93 // | i2i (pointer) | | |
| 94 // | adapter (pointer) | | |
| 95 // | from_compiled_entry (pointer) | | |
| 96 // | from_interpreted_entry (pointer) | | |
| 97 // |------------------------------------------------------| | |
| 98 // | native_function (present only if native) | | |
| 99 // | signature_handler (present only if native) | | |
| 100 // |------------------------------------------------------| | |
| 101 | |
| 102 | |
| 103 class CheckedExceptionElement; | |
| 104 class LocalVariableTableElement; | |
| 105 class AdapterHandlerEntry; | |
| 106 class methodDataOopDesc; | |
| 107 | |
| 108 class methodOopDesc : public oopDesc { | |
| 109 friend class methodKlass; | |
| 110 friend class VMStructs; | |
| 111 private: | |
| 112 constMethodOop _constMethod; // Method read-only data. | |
| 113 constantPoolOop _constants; // Constant pool | |
| 114 methodDataOop _method_data; | |
| 1783 | 115 int _interpreter_invocation_count; // Count of times invoked (reused as prev_event_count in tiered) |
| 0 | 116 AccessFlags _access_flags; // Access flags |
| 117 int _vtable_index; // vtable index of this method (see VtableIndexFlag) | |
| 118 // note: can have vtables with >2**16 elements (because of inheritance) | |
| 119 #ifdef CC_INTERP | |
| 120 int _result_index; // C++ interpreter needs for converting results to/from stack | |
| 121 #endif | |
| 122 u2 _method_size; // size of this object | |
| 123 u2 _max_stack; // Maximum number of entries on the expression stack | |
| 124 u2 _max_locals; // Number of local variables used by this method | |
| 125 u2 _size_of_parameters; // size of the parameter block (receiver + arguments) in words | |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
126 u1 _intrinsic_id; // vmSymbols::intrinsic_id (0 == _none) |
| 0 | 127 u2 _interpreter_throwout_count; // Count of times method was exited via exception while interpreting |
| 128 u2 _number_of_breakpoints; // fullspeed debugging support | |
| 129 InvocationCounter _invocation_counter; // Incremented before each activation of the method - used to trigger frequency-based optimizations | |
| 130 InvocationCounter _backedge_counter; // Incremented before each backedge taken - used to trigger frequencey-based optimizations | |
| 1783 | 131 |
|
3011
f00918f35c7f
inlining and runtime interface related changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
2416
diff
changeset
|
132 // com/oracle/max/graal/runtime/HotSpotMethodResolved mirroring this method |
|
f00918f35c7f
inlining and runtime interface related changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
2416
diff
changeset
|
133 oop _graal_mirror; |
|
2348
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
134 #ifdef TIERED |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
135 jlong _prev_time; // Previous time the rate was acquired |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
136 float _rate; // Events (invocation and backedge counter increments) per millisecond |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
137 #endif |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
138 |
| 0 | 139 #ifndef PRODUCT |
| 140 int _compiled_invocation_count; // Number of nmethod invocations so far (for perf. debugging) | |
| 141 #endif | |
| 142 // Entry point for calling both from and to the interpreter. | |
| 143 address _i2i_entry; // All-args-on-stack calling convention | |
| 144 // Adapter blob (i2c/c2i) for this methodOop. Set once when method is linked. | |
| 145 AdapterHandlerEntry* _adapter; | |
| 146 // Entry point for calling from compiled code, to compiled code if it exists | |
| 147 // or else the interpreter. | |
| 148 volatile address _from_compiled_entry; // Cache of: _code ? _code->entry_point() : _adapter->c2i_entry() | |
| 149 // The entry point for calling both from and to compiled code is | |
| 150 // "_code->entry_point()". Because of tiered compilation and de-opt, this | |
| 151 // field can come and go. It can transition from NULL to not-null at any | |
| 152 // time (whenever a compile completes). It can transition from not-null to | |
| 153 // NULL only at safepoints (because of a de-opt). | |
| 154 nmethod* volatile _code; // Points to the corresponding piece of native code | |
| 155 volatile address _from_interpreted_entry; // Cache of _code ? _adapter->i2c_entry() : _i2i_entry | |
| 156 | |
| 157 public: | |
|
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
196
diff
changeset
|
158 |
| 0 | 159 // accessors for instance variables |
| 160 constMethodOop constMethod() const { return _constMethod; } | |
| 161 void set_constMethod(constMethodOop xconst) { oop_store_without_check((oop*)&_constMethod, (oop)xconst); } | |
| 162 | |
| 163 | |
| 164 static address make_adapters(methodHandle mh, TRAPS); | |
| 165 volatile address from_compiled_entry() const { return (address)OrderAccess::load_ptr_acquire(&_from_compiled_entry); } | |
| 166 volatile address from_interpreted_entry() const{ return (address)OrderAccess::load_ptr_acquire(&_from_interpreted_entry); } | |
| 167 | |
| 168 // access flag | |
| 169 AccessFlags access_flags() const { return _access_flags; } | |
| 170 void set_access_flags(AccessFlags flags) { _access_flags = flags; } | |
| 171 | |
| 172 // name | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
173 Symbol* name() const { return _constants->symbol_at(name_index()); } |
| 0 | 174 int name_index() const { return constMethod()->name_index(); } |
| 175 void set_name_index(int index) { constMethod()->set_name_index(index); } | |
| 176 | |
| 177 // signature | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
178 Symbol* signature() const { return _constants->symbol_at(signature_index()); } |
| 0 | 179 int signature_index() const { return constMethod()->signature_index(); } |
| 180 void set_signature_index(int index) { constMethod()->set_signature_index(index); } | |
| 181 | |
| 182 // generics support | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
183 Symbol* generic_signature() const { int idx = generic_signature_index(); return ((idx != 0) ? _constants->symbol_at(idx) : (Symbol*)NULL); } |
| 0 | 184 int generic_signature_index() const { return constMethod()->generic_signature_index(); } |
| 185 void set_generic_signature_index(int index) { constMethod()->set_generic_signature_index(index); } | |
| 186 | |
| 187 // annotations support | |
| 188 typeArrayOop annotations() const { return instanceKlass::cast(method_holder())->get_method_annotations_of(method_idnum()); } | |
| 189 typeArrayOop parameter_annotations() const { return instanceKlass::cast(method_holder())->get_method_parameter_annotations_of(method_idnum()); } | |
| 190 typeArrayOop annotation_default() const { return instanceKlass::cast(method_holder())->get_method_default_annotations_of(method_idnum()); } | |
| 191 | |
| 192 #ifdef CC_INTERP | |
| 193 void set_result_index(BasicType type); | |
| 194 int result_index() { return _result_index; } | |
| 195 #endif | |
| 196 | |
| 197 // Helper routine: get klass name + "." + method name + signature as | |
| 198 // C string, for the purpose of providing more useful NoSuchMethodErrors | |
| 199 // and fatal error handling. The string is allocated in resource | |
| 200 // area if a buffer is not provided by the caller. | |
| 201 char* name_and_sig_as_C_string(); | |
| 202 char* name_and_sig_as_C_string(char* buf, int size); | |
| 203 | |
| 204 // Static routine in the situations we don't have a methodOop | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
205 static char* name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
206 static char* name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature, char* buf, int size); |
| 0 | 207 |
| 2142 | 208 Bytecodes::Code java_code_at(int bci) const { |
| 209 return Bytecodes::java_code_at(this, bcp_from(bci)); | |
| 210 } | |
| 211 Bytecodes::Code code_at(int bci) const { | |
| 212 return Bytecodes::code_at(this, bcp_from(bci)); | |
| 213 } | |
| 214 | |
| 0 | 215 // JVMTI breakpoints |
| 2142 | 216 Bytecodes::Code orig_bytecode_at(int bci) const; |
| 0 | 217 void set_orig_bytecode_at(int bci, Bytecodes::Code code); |
| 218 void set_breakpoint(int bci); | |
| 219 void clear_breakpoint(int bci); | |
| 220 void clear_all_breakpoints(); | |
| 221 // Tracking number of breakpoints, for fullspeed debugging. | |
| 222 // Only mutated by VM thread. | |
| 223 u2 number_of_breakpoints() const { return _number_of_breakpoints; } | |
| 224 void incr_number_of_breakpoints() { ++_number_of_breakpoints; } | |
| 225 void decr_number_of_breakpoints() { --_number_of_breakpoints; } | |
| 226 // Initialization only | |
| 227 void clear_number_of_breakpoints() { _number_of_breakpoints = 0; } | |
| 228 | |
| 229 // index into instanceKlass methods() array | |
| 230 u2 method_idnum() const { return constMethod()->method_idnum(); } | |
| 231 void set_method_idnum(u2 idnum) { constMethod()->set_method_idnum(idnum); } | |
| 232 | |
| 233 // code size | |
| 234 int code_size() const { return constMethod()->code_size(); } | |
| 235 | |
| 236 // method size | |
| 237 int method_size() const { return _method_size; } | |
| 238 void set_method_size(int size) { | |
| 239 assert(0 <= size && size < (1 << 16), "invalid method size"); | |
| 240 _method_size = size; | |
| 241 } | |
| 242 | |
| 243 // constant pool for klassOop holding this method | |
| 244 constantPoolOop constants() const { return _constants; } | |
| 245 void set_constants(constantPoolOop c) { oop_store_without_check((oop*)&_constants, c); } | |
| 246 | |
| 247 // max stack | |
| 248 int max_stack() const { return _max_stack; } | |
| 249 void set_max_stack(int size) { _max_stack = size; } | |
| 250 | |
| 251 // max locals | |
| 252 int max_locals() const { return _max_locals; } | |
| 253 void set_max_locals(int size) { _max_locals = size; } | |
| 1783 | 254 |
| 255 int highest_comp_level() const; | |
| 256 void set_highest_comp_level(int level); | |
| 257 int highest_osr_comp_level() const; | |
| 258 void set_highest_osr_comp_level(int level); | |
| 0 | 259 |
| 260 // Count of times method was exited via exception while interpreting | |
| 261 void interpreter_throwout_increment() { | |
| 262 if (_interpreter_throwout_count < 65534) { | |
| 263 _interpreter_throwout_count++; | |
| 264 } | |
| 265 } | |
| 266 | |
| 267 int interpreter_throwout_count() const { return _interpreter_throwout_count; } | |
| 268 void set_interpreter_throwout_count(int count) { _interpreter_throwout_count = count; } | |
| 269 | |
| 270 // size of parameters | |
| 271 int size_of_parameters() const { return _size_of_parameters; } | |
| 272 | |
| 273 bool has_stackmap_table() const { | |
| 274 return constMethod()->has_stackmap_table(); | |
| 275 } | |
| 276 | |
| 277 typeArrayOop stackmap_data() const { | |
| 278 return constMethod()->stackmap_data(); | |
| 279 } | |
| 280 | |
|
1877
a4c7fe54bf3f
6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents:
1793
diff
changeset
|
281 void set_stackmap_data(typeArrayOop sd) { |
|
a4c7fe54bf3f
6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents:
1793
diff
changeset
|
282 constMethod()->set_stackmap_data(sd); |
|
a4c7fe54bf3f
6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents:
1793
diff
changeset
|
283 } |
|
a4c7fe54bf3f
6991315: RedefineClasses fails with java.lang.VerifyError
kamg
parents:
1793
diff
changeset
|
284 |
| 0 | 285 // exception handler table |
| 286 typeArrayOop exception_table() const | |
| 287 { return constMethod()->exception_table(); } | |
| 288 void set_exception_table(typeArrayOop e) | |
| 289 { constMethod()->set_exception_table(e); } | |
| 290 bool has_exception_handler() const | |
| 291 { return constMethod()->has_exception_handler(); } | |
| 292 | |
| 293 // Finds the first entry point bci of an exception handler for an | |
| 294 // exception of klass ex_klass thrown at throw_bci. A value of NULL | |
| 295 // for ex_klass indicates that the exception klass is not known; in | |
| 296 // this case it matches any constraint class. Returns -1 if the | |
| 297 // exception cannot be handled in this method. The handler | |
| 298 // constraint classes are loaded if necessary. Note that this may | |
| 299 // throw an exception if loading of the constraint classes causes | |
| 300 // an IllegalAccessError (bugid 4307310) or an OutOfMemoryError. | |
| 301 // If an exception is thrown, returns the bci of the | |
| 302 // exception handler which caused the exception to be thrown, which | |
| 303 // is needed for proper retries. See, for example, | |
| 304 // InterpreterRuntime::exception_handler_for_exception. | |
| 305 int fast_exception_handler_bci_for(KlassHandle ex_klass, int throw_bci, TRAPS); | |
| 306 | |
| 307 // method data access | |
| 308 methodDataOop method_data() const { | |
| 309 return _method_data; | |
| 310 } | |
| 311 void set_method_data(methodDataOop data) { | |
| 312 oop_store_without_check((oop*)&_method_data, (oop)data); | |
| 313 } | |
| 314 | |
| 315 // invocation counter | |
| 1783 | 316 InvocationCounter* invocation_counter() { return &_invocation_counter; } |
| 317 InvocationCounter* backedge_counter() { return &_backedge_counter; } | |
| 318 | |
|
2348
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
319 #ifdef TIERED |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
320 // We are reusing interpreter_invocation_count as a holder for the previous event count! |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
321 // We can do that since interpreter_invocation_count is not used in tiered. |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
322 int prev_event_count() const { return _interpreter_invocation_count; } |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
323 void set_prev_event_count(int count) { _interpreter_invocation_count = count; } |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
324 jlong prev_time() const { return _prev_time; } |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
325 void set_prev_time(jlong time) { _prev_time = time; } |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
326 float rate() const { return _rate; } |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
327 void set_rate(float rate) { _rate = rate; } |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
328 #endif |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2243
diff
changeset
|
329 |
| 1783 | 330 int invocation_count(); |
| 331 int backedge_count(); | |
| 332 | |
|
3011
f00918f35c7f
inlining and runtime interface related changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
2416
diff
changeset
|
333 // graal mirror |
|
f00918f35c7f
inlining and runtime interface related changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
2416
diff
changeset
|
334 oop graal_mirror() const { return _graal_mirror; } |
|
f00918f35c7f
inlining and runtime interface related changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
2416
diff
changeset
|
335 void set_graal_mirror(oop m) { oop_store((oop*) &_graal_mirror, m); } |
|
f00918f35c7f
inlining and runtime interface related changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
2416
diff
changeset
|
336 |
| 1783 | 337 bool was_executed_more_than(int n); |
| 338 bool was_never_executed() { return !was_executed_more_than(0); } | |
| 0 | 339 |
| 340 static void build_interpreter_method_data(methodHandle method, TRAPS); | |
| 341 | |
| 1783 | 342 int interpreter_invocation_count() { |
| 343 if (TieredCompilation) return invocation_count(); | |
| 344 else return _interpreter_invocation_count; | |
| 345 } | |
| 0 | 346 void set_interpreter_invocation_count(int count) { _interpreter_invocation_count = count; } |
| 1783 | 347 int increment_interpreter_invocation_count() { |
| 348 if (TieredCompilation) ShouldNotReachHere(); | |
| 349 return ++_interpreter_invocation_count; | |
| 350 } | |
| 0 | 351 |
| 352 #ifndef PRODUCT | |
| 1783 | 353 int compiled_invocation_count() const { return _compiled_invocation_count; } |
| 0 | 354 void set_compiled_invocation_count(int count) { _compiled_invocation_count = count; } |
| 355 #endif // not PRODUCT | |
| 356 | |
| 605 | 357 // Clear (non-shared space) pointers which could not be relevant |
| 0 | 358 // if this (shared) method were mapped into another JVM. |
| 359 void remove_unshareable_info(); | |
| 360 | |
| 361 // nmethod/verified compiler entry | |
| 362 address verified_code_entry(); | |
| 363 bool check_code() const; // Not inline to avoid circular ref | |
| 364 nmethod* volatile code() const { assert( check_code(), "" ); return (nmethod *)OrderAccess::load_ptr_acquire(&_code); } | |
| 365 void clear_code(); // Clear out any compiled code | |
| 1202 | 366 static void set_code(methodHandle mh, nmethod* code); |
| 0 | 367 void set_adapter_entry(AdapterHandlerEntry* adapter) { _adapter = adapter; } |
| 368 address get_i2c_entry(); | |
| 369 address get_c2i_entry(); | |
| 370 address get_c2i_unverified_entry(); | |
| 371 AdapterHandlerEntry* adapter() { return _adapter; } | |
| 372 // setup entry points | |
| 373 void link_method(methodHandle method, TRAPS); | |
| 374 // clear entry points. Used by sharing code | |
| 375 void unlink_method(); | |
| 376 | |
| 377 // vtable index | |
| 378 enum VtableIndexFlag { | |
| 379 // Valid vtable indexes are non-negative (>= 0). | |
| 380 // These few negative values are used as sentinels. | |
| 710 | 381 highest_unused_vtable_index_value = -5, |
| 0 | 382 invalid_vtable_index = -4, // distinct from any valid vtable index |
| 383 garbage_vtable_index = -3, // not yet linked; no vtable layout yet | |
| 384 nonvirtual_vtable_index = -2 // there is no need for vtable dispatch | |
| 385 // 6330203 Note: Do not use -1, which was overloaded with many meanings. | |
| 386 }; | |
| 387 DEBUG_ONLY(bool valid_vtable_index() const { return _vtable_index >= nonvirtual_vtable_index; }) | |
| 388 int vtable_index() const { assert(valid_vtable_index(), ""); | |
| 389 return _vtable_index; } | |
| 390 void set_vtable_index(int index) { _vtable_index = index; } | |
| 391 | |
| 392 // interpreter entry | |
| 393 address interpreter_entry() const { return _i2i_entry; } | |
| 394 // Only used when first initialize so we can set _i2i_entry and _from_interpreted_entry | |
| 395 void set_interpreter_entry(address entry) { _i2i_entry = entry; _from_interpreted_entry = entry; } | |
| 396 int interpreter_kind(void) { | |
| 397 return constMethod()->interpreter_kind(); | |
| 398 } | |
| 399 void set_interpreter_kind(); | |
| 400 void set_interpreter_kind(int kind) { | |
| 401 constMethod()->set_interpreter_kind(kind); | |
| 402 } | |
| 403 | |
| 404 // native function (used for native methods only) | |
| 405 enum { | |
| 406 native_bind_event_is_interesting = true | |
| 407 }; | |
| 408 address native_function() const { return *(native_function_addr()); } | |
| 409 // Must specify a real function (not NULL). | |
| 410 // Use clear_native_function() to unregister. | |
| 411 void set_native_function(address function, bool post_event_flag); | |
| 412 bool has_native_function() const; | |
| 413 void clear_native_function(); | |
| 414 | |
| 415 // signature handler (used for native methods only) | |
| 416 address signature_handler() const { return *(signature_handler_addr()); } | |
| 417 void set_signature_handler(address handler); | |
| 418 | |
| 419 // Interpreter oopmap support | |
| 420 void mask_for(int bci, InterpreterOopMap* mask); | |
| 421 | |
| 422 #ifndef PRODUCT | |
| 423 // operations on invocation counter | |
| 1783 | 424 void print_invocation_count(); |
| 0 | 425 #endif |
| 426 | |
| 427 // byte codes | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
977
diff
changeset
|
428 void set_code(address code) { return constMethod()->set_code(code); } |
| 0 | 429 address code_base() const { return constMethod()->code_base(); } |
| 430 bool contains(address bcp) const { return constMethod()->contains(bcp); } | |
| 431 | |
| 432 // prints byte codes | |
| 433 void print_codes() const { print_codes_on(tty); } | |
| 434 void print_codes_on(outputStream* st) const PRODUCT_RETURN; | |
| 435 void print_codes_on(int from, int to, outputStream* st) const PRODUCT_RETURN; | |
| 436 | |
| 437 // checked exceptions | |
| 438 int checked_exceptions_length() const | |
| 439 { return constMethod()->checked_exceptions_length(); } | |
| 440 CheckedExceptionElement* checked_exceptions_start() const | |
| 441 { return constMethod()->checked_exceptions_start(); } | |
| 442 | |
| 443 // localvariable table | |
| 444 bool has_localvariable_table() const | |
| 445 { return constMethod()->has_localvariable_table(); } | |
| 446 int localvariable_table_length() const | |
| 447 { return constMethod()->localvariable_table_length(); } | |
| 448 LocalVariableTableElement* localvariable_table_start() const | |
| 449 { return constMethod()->localvariable_table_start(); } | |
| 450 | |
| 451 bool has_linenumber_table() const | |
| 452 { return constMethod()->has_linenumber_table(); } | |
| 453 u_char* compressed_linenumber_table() const | |
| 454 { return constMethod()->compressed_linenumber_table(); } | |
| 455 | |
| 456 // method holder (the klassOop holding this method) | |
| 457 klassOop method_holder() const { return _constants->pool_holder(); } | |
| 458 | |
| 459 void compute_size_of_parameters(Thread *thread); // word size of parameters (receiver if any + arguments) | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
460 Symbol* klass_name() const; // returns the name of the method holder |
| 0 | 461 BasicType result_type() const; // type of the method result |
| 462 int result_type_index() const; // type index of the method result | |
| 463 bool is_returning_oop() const { BasicType r = result_type(); return (r == T_OBJECT || r == T_ARRAY); } | |
| 464 bool is_returning_fp() const { BasicType r = result_type(); return (r == T_FLOAT || r == T_DOUBLE); } | |
| 465 | |
| 466 // Checked exceptions thrown by this method (resolved to mirrors) | |
| 467 objArrayHandle resolved_checked_exceptions(TRAPS) { return resolved_checked_exceptions_impl(this, THREAD); } | |
| 468 | |
| 469 // Access flags | |
| 470 bool is_public() const { return access_flags().is_public(); } | |
| 471 bool is_private() const { return access_flags().is_private(); } | |
| 472 bool is_protected() const { return access_flags().is_protected(); } | |
| 473 bool is_package_private() const { return !is_public() && !is_private() && !is_protected(); } | |
| 474 bool is_static() const { return access_flags().is_static(); } | |
| 475 bool is_final() const { return access_flags().is_final(); } | |
| 476 bool is_synchronized() const { return access_flags().is_synchronized();} | |
| 477 bool is_native() const { return access_flags().is_native(); } | |
| 478 bool is_abstract() const { return access_flags().is_abstract(); } | |
| 479 bool is_strict() const { return access_flags().is_strict(); } | |
| 480 bool is_synthetic() const { return access_flags().is_synthetic(); } | |
| 481 | |
| 482 // returns true if contains only return operation | |
| 483 bool is_empty_method() const; | |
| 484 | |
| 485 // returns true if this is a vanilla constructor | |
| 486 bool is_vanilla_constructor() const; | |
| 487 | |
| 488 // checks method and its method holder | |
| 489 bool is_final_method() const; | |
| 490 bool is_strict_method() const; | |
| 491 | |
| 492 // true if method needs no dynamic dispatch (final and/or no vtable entry) | |
| 493 bool can_be_statically_bound() const; | |
| 494 | |
| 495 // returns true if the method has any backward branches. | |
| 496 bool has_loops() { | |
| 497 return access_flags().loops_flag_init() ? access_flags().has_loops() : compute_has_loops_flag(); | |
| 498 }; | |
| 499 | |
| 500 bool compute_has_loops_flag(); | |
| 501 | |
| 502 bool has_jsrs() { | |
| 503 return access_flags().has_jsrs(); | |
| 504 }; | |
| 505 void set_has_jsrs() { | |
| 506 _access_flags.set_has_jsrs(); | |
| 507 } | |
| 508 | |
| 509 // returns true if the method has any monitors. | |
| 510 bool has_monitors() const { return is_synchronized() || access_flags().has_monitor_bytecodes(); } | |
| 511 bool has_monitor_bytecodes() const { return access_flags().has_monitor_bytecodes(); } | |
| 512 | |
| 513 void set_has_monitor_bytecodes() { _access_flags.set_has_monitor_bytecodes(); } | |
| 514 | |
| 515 // monitor matching. This returns a conservative estimate of whether the monitorenter/monitorexit bytecodes | |
| 516 // propererly nest in the method. It might return false, even though they actually nest properly, since the info. | |
| 517 // has not been computed yet. | |
| 518 bool guaranteed_monitor_matching() const { return access_flags().is_monitor_matching(); } | |
| 519 void set_guaranteed_monitor_matching() { _access_flags.set_monitor_matching(); } | |
| 520 | |
| 521 // returns true if the method is an accessor function (setter/getter). | |
| 522 bool is_accessor() const; | |
| 523 | |
| 524 // returns true if the method is an initializer (<init> or <clinit>). | |
| 525 bool is_initializer() const; | |
| 526 | |
|
2334
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2243
diff
changeset
|
527 // returns true if the method is static OR if the classfile version < 51 |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2243
diff
changeset
|
528 bool has_valid_initializer_flags() const; |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2243
diff
changeset
|
529 |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2243
diff
changeset
|
530 // returns true if the method name is <clinit> and the method has |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2243
diff
changeset
|
531 // valid static initializer flags. |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2243
diff
changeset
|
532 bool is_static_initializer() const; |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2243
diff
changeset
|
533 |
| 0 | 534 // compiled code support |
| 535 // NOTE: code() is inherently racy as deopt can be clearing code | |
| 536 // simultaneously. Use with caution. | |
| 537 bool has_compiled_code() const { return code() != NULL; } | |
| 538 | |
| 539 // sizing | |
| 540 static int object_size(bool is_native); | |
| 541 static int header_size() { return sizeof(methodOopDesc)/HeapWordSize; } | |
| 542 int object_size() const { return method_size(); } | |
| 543 | |
| 544 bool object_is_parsable() const { return method_size() > 0; } | |
| 545 | |
| 546 // interpreter support | |
| 547 static ByteSize const_offset() { return byte_offset_of(methodOopDesc, _constMethod ); } | |
| 548 static ByteSize constants_offset() { return byte_offset_of(methodOopDesc, _constants ); } | |
| 549 static ByteSize access_flags_offset() { return byte_offset_of(methodOopDesc, _access_flags ); } | |
| 550 #ifdef CC_INTERP | |
| 551 static ByteSize result_index_offset() { return byte_offset_of(methodOopDesc, _result_index ); } | |
| 552 #endif /* CC_INTERP */ | |
| 553 static ByteSize size_of_locals_offset() { return byte_offset_of(methodOopDesc, _max_locals ); } | |
| 554 static ByteSize size_of_parameters_offset() { return byte_offset_of(methodOopDesc, _size_of_parameters); } | |
| 555 static ByteSize from_compiled_offset() { return byte_offset_of(methodOopDesc, _from_compiled_entry); } | |
| 556 static ByteSize code_offset() { return byte_offset_of(methodOopDesc, _code); } | |
| 557 static ByteSize invocation_counter_offset() { return byte_offset_of(methodOopDesc, _invocation_counter); } | |
| 558 static ByteSize backedge_counter_offset() { return byte_offset_of(methodOopDesc, _backedge_counter); } | |
| 559 static ByteSize method_data_offset() { | |
| 560 return byte_offset_of(methodOopDesc, _method_data); | |
| 561 } | |
| 562 static ByteSize interpreter_invocation_counter_offset() { return byte_offset_of(methodOopDesc, _interpreter_invocation_count); } | |
| 563 #ifndef PRODUCT | |
| 564 static ByteSize compiled_invocation_counter_offset() { return byte_offset_of(methodOopDesc, _compiled_invocation_count); } | |
| 565 #endif // not PRODUCT | |
| 566 static ByteSize native_function_offset() { return in_ByteSize(sizeof(methodOopDesc)); } | |
| 567 static ByteSize from_interpreted_offset() { return byte_offset_of(methodOopDesc, _from_interpreted_entry ); } | |
| 568 static ByteSize interpreter_entry_offset() { return byte_offset_of(methodOopDesc, _i2i_entry ); } | |
| 569 static ByteSize signature_handler_offset() { return in_ByteSize(sizeof(methodOopDesc) + wordSize); } | |
| 570 static ByteSize max_stack_offset() { return byte_offset_of(methodOopDesc, _max_stack ); } | |
| 571 | |
| 572 // for code generation | |
| 573 static int method_data_offset_in_bytes() { return offset_of(methodOopDesc, _method_data); } | |
| 574 static int interpreter_invocation_counter_offset_in_bytes() | |
| 575 { return offset_of(methodOopDesc, _interpreter_invocation_count); } | |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1783
diff
changeset
|
576 static int intrinsic_id_offset_in_bytes() { return offset_of(methodOopDesc, _intrinsic_id); } |
|
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1783
diff
changeset
|
577 static int intrinsic_id_size_in_bytes() { return sizeof(u1); } |
| 0 | 578 |
| 579 // Static methods that are used to implement member methods where an exposed this pointer | |
| 580 // is needed due to possible GCs | |
| 581 static objArrayHandle resolved_checked_exceptions_impl(methodOop this_oop, TRAPS); | |
| 582 | |
| 583 // Returns the byte code index from the byte code pointer | |
| 584 int bci_from(address bcp) const; | |
| 585 address bcp_from(int bci) const; | |
| 586 int validate_bci_from_bcx(intptr_t bcx) const; | |
| 587 | |
| 588 // Returns the line number for a bci if debugging information for the method is prowided, | |
| 589 // -1 is returned otherwise. | |
| 590 int line_number_from_bci(int bci) const; | |
| 591 | |
| 592 // Reflection support | |
| 593 bool is_overridden_in(klassOop k) const; | |
| 594 | |
| 710 | 595 // JSR 292 support |
| 596 bool is_method_handle_invoke() const { return access_flags().is_method_handle_invoke(); } | |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1208
diff
changeset
|
597 static bool is_method_handle_invoke_name(vmSymbols::SID name_sid); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
598 static bool is_method_handle_invoke_name(Symbol* name) { |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1208
diff
changeset
|
599 return is_method_handle_invoke_name(vmSymbols::find_sid(name)); |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1208
diff
changeset
|
600 } |
|
1152
cd37471eaecc
6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents:
1138
diff
changeset
|
601 // Tests if this method is an internal adapter frame from the |
|
cd37471eaecc
6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents:
1138
diff
changeset
|
602 // MethodHandleCompiler. |
|
cd37471eaecc
6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents:
1138
diff
changeset
|
603 bool is_method_handle_adapter() const; |
| 710 | 604 static methodHandle make_invoke_method(KlassHandle holder, |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
605 Symbol* name, //invokeExact or invokeGeneric |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
606 Symbol* signature, //anything at all |
| 710 | 607 Handle method_type, |
| 608 TRAPS); | |
| 609 // these operate only on invoke methods: | |
| 610 oop method_handle_type() const; | |
| 611 static jint* method_type_offsets_chain(); // series of pointer-offsets, terminated by -1 | |
| 612 // presize interpreter frames for extra interpreter stack entries, if needed | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
613 // method handles want to be able to push a few extra values (e.g., a bound receiver), and |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
614 // invokedynamic sometimes needs to push a bootstrap method, call site, and arglist, |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
615 // all without checking for a stack overflow |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2355
diff
changeset
|
616 static int extra_stack_entries() { return EnableInvokeDynamic ? (int) MethodHandlePushLimit + 3 : 0; } |
| 710 | 617 static int extra_stack_words(); // = extra_stack_entries() * Interpreter::stackElementSize() |
|
1152
cd37471eaecc
6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents:
1138
diff
changeset
|
618 |
| 0 | 619 // RedefineClasses() support: |
| 620 bool is_old() const { return access_flags().is_old(); } | |
| 621 void set_is_old() { _access_flags.set_is_old(); } | |
| 622 bool is_obsolete() const { return access_flags().is_obsolete(); } | |
| 623 void set_is_obsolete() { _access_flags.set_is_obsolete(); } | |
|
48
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
624 // see the definition in methodOop.cpp for the gory details |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
625 bool should_not_be_cached() const; |
| 0 | 626 |
| 627 // JVMTI Native method prefixing support: | |
| 628 bool is_prefixed_native() const { return access_flags().is_prefixed_native(); } | |
| 629 void set_is_prefixed_native() { _access_flags.set_is_prefixed_native(); } | |
| 630 | |
| 631 // Rewriting support | |
| 632 static methodHandle clone_with_new_data(methodHandle m, u_char* new_code, int new_code_length, | |
| 633 u_char* new_compressed_linenumber_table, int new_compressed_linenumber_size, TRAPS); | |
| 634 | |
| 635 // Get this method's jmethodID -- allocate if it doesn't exist | |
| 636 jmethodID jmethod_id() { methodHandle this_h(this); | |
|
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
856
diff
changeset
|
637 return instanceKlass::get_jmethod_id(method_holder(), this_h); } |
| 0 | 638 |
| 639 // Lookup the jmethodID for this method. Return NULL if not found. | |
| 640 // NOTE that this function can be called from a signal handler | |
| 641 // (see AsyncGetCallTrace support for Forte Analyzer) and this | |
| 642 // needs to be async-safe. No allocation should be done and | |
| 643 // so handles are not used to avoid deadlock. | |
| 644 jmethodID find_jmethod_id_or_null() { return instanceKlass::cast(method_holder())->jmethod_id_or_null(this); } | |
| 645 | |
| 646 // JNI static invoke cached itable index accessors | |
| 647 int cached_itable_index() { return instanceKlass::cast(method_holder())->cached_itable_index(method_idnum()); } | |
| 648 void set_cached_itable_index(int index) { instanceKlass::cast(method_holder())->set_cached_itable_index(method_idnum(), index); } | |
| 649 | |
| 650 // Support for inlining of intrinsic methods | |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
651 vmIntrinsics::ID intrinsic_id() const { return (vmIntrinsics::ID) _intrinsic_id; } |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
652 void set_intrinsic_id(vmIntrinsics::ID id) { _intrinsic_id = (u1) id; } |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
653 |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
654 // Helper routines for intrinsic_id() and vmIntrinsics::method(). |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
655 void init_intrinsic_id(); // updates from _none if a match |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
656 static vmSymbols::SID klass_id_for_intrinsics(klassOop holder); |
| 0 | 657 |
| 658 // On-stack replacement support | |
| 1783 | 659 bool has_osr_nmethod(int level, bool match_level) { |
| 660 return instanceKlass::cast(method_holder())->lookup_osr_nmethod(this, InvocationEntryBci, level, match_level) != NULL; | |
| 661 } | |
| 662 | |
| 663 nmethod* lookup_osr_nmethod_for(int bci, int level, bool match_level) { | |
| 664 return instanceKlass::cast(method_holder())->lookup_osr_nmethod(this, bci, level, match_level); | |
| 665 } | |
| 0 | 666 |
| 667 // Inline cache support | |
| 668 void cleanup_inline_caches(); | |
| 669 | |
| 670 // Find if klass for method is loaded | |
| 671 bool is_klass_loaded_by_klass_index(int klass_index) const; | |
| 672 bool is_klass_loaded(int refinfo_index, bool must_be_resolved = false) const; | |
| 673 | |
| 674 // Indicates whether compilation failed earlier for this method, or | |
| 675 // whether it is not compilable for another reason like having a | |
| 676 // breakpoint set in it. | |
| 1783 | 677 bool is_not_compilable(int comp_level = CompLevel_any) const; |
| 678 void set_not_compilable(int comp_level = CompLevel_all, bool report = true); | |
| 679 void set_not_compilable_quietly(int comp_level = CompLevel_all) { | |
|
1208
cef333a48af6
6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents:
1202
diff
changeset
|
680 set_not_compilable(comp_level, false); |
|
cef333a48af6
6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents:
1202
diff
changeset
|
681 } |
| 1783 | 682 bool is_not_osr_compilable(int comp_level = CompLevel_any) const { |
| 683 return is_not_compilable(comp_level) || access_flags().is_not_osr_compilable(); | |
| 684 } | |
| 685 void set_not_osr_compilable() { _access_flags.set_not_osr_compilable(); } | |
| 686 bool is_not_c1_compilable() const { return access_flags().is_not_c1_compilable(); } | |
| 687 void set_not_c1_compilable() { _access_flags.set_not_c1_compilable(); } | |
| 688 bool is_not_c2_compilable() const { return access_flags().is_not_c2_compilable(); } | |
| 689 void set_not_c2_compilable() { _access_flags.set_not_c2_compilable(); } | |
| 0 | 690 |
| 691 // Background compilation support | |
| 1783 | 692 bool queued_for_compilation() const { return access_flags().queued_for_compilation(); } |
| 693 void set_queued_for_compilation() { _access_flags.set_queued_for_compilation(); } | |
| 694 void clear_queued_for_compilation() { _access_flags.clear_queued_for_compilation(); } | |
| 0 | 695 |
| 696 // Resolve all classes in signature, return 'true' if successful | |
| 697 static bool load_signature_classes(methodHandle m, TRAPS); | |
| 698 | |
| 699 // Return if true if not all classes references in signature, including return type, has been loaded | |
| 700 static bool has_unloaded_classes_in_signature(methodHandle m, TRAPS); | |
| 701 | |
| 702 // Printing | |
| 703 void print_short_name(outputStream* st) /*PRODUCT_RETURN*/; // prints as klassname::methodname; Exposed so field engineers can debug VM | |
| 704 void print_name(outputStream* st) PRODUCT_RETURN; // prints as "virtual void foo(int)" | |
| 705 | |
| 706 // Helper routine used for method sorting | |
| 707 static void sort_methods(objArrayOop methods, | |
| 708 objArrayOop methods_annotations, | |
| 709 objArrayOop methods_parameter_annotations, | |
| 710 objArrayOop methods_default_annotations, | |
| 711 bool idempotent = false); | |
| 712 | |
| 713 // size of parameters | |
| 714 void set_size_of_parameters(int size) { _size_of_parameters = size; } | |
| 715 private: | |
| 716 | |
| 717 // Inlined elements | |
| 718 address* native_function_addr() const { assert(is_native(), "must be native"); return (address*) (this+1); } | |
| 719 address* signature_handler_addr() const { return native_function_addr() + 1; } | |
| 720 | |
| 721 // Garbage collection support | |
| 722 oop* adr_constMethod() const { return (oop*)&_constMethod; } | |
| 723 oop* adr_constants() const { return (oop*)&_constants; } | |
|
3011
f00918f35c7f
inlining and runtime interface related changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
2416
diff
changeset
|
724 oop* adr_graal_mirror() const { return (oop*)&_graal_mirror; } |
| 0 | 725 oop* adr_method_data() const { return (oop*)&_method_data; } |
| 726 }; | |
| 727 | |
| 728 | |
| 729 // Utility class for compressing line number tables | |
| 730 | |
| 731 class CompressedLineNumberWriteStream: public CompressedWriteStream { | |
| 732 private: | |
| 733 int _bci; | |
| 734 int _line; | |
| 735 public: | |
| 736 // Constructor | |
| 737 CompressedLineNumberWriteStream(int initial_size) : CompressedWriteStream(initial_size), _bci(0), _line(0) {} | |
| 738 CompressedLineNumberWriteStream(u_char* buffer, int initial_size) : CompressedWriteStream(buffer, initial_size), _bci(0), _line(0) {} | |
| 739 | |
| 740 // Write (bci, line number) pair to stream | |
| 741 void write_pair_regular(int bci_delta, int line_delta); | |
| 742 | |
| 743 inline void write_pair_inline(int bci, int line) { | |
| 744 int bci_delta = bci - _bci; | |
| 745 int line_delta = line - _line; | |
| 746 _bci = bci; | |
| 747 _line = line; | |
| 748 // Skip (0,0) deltas - they do not add information and conflict with terminator. | |
| 749 if (bci_delta == 0 && line_delta == 0) return; | |
| 750 // Check if bci is 5-bit and line number 3-bit unsigned. | |
| 751 if (((bci_delta & ~0x1F) == 0) && ((line_delta & ~0x7) == 0)) { | |
| 752 // Compress into single byte. | |
| 753 jubyte value = ((jubyte) bci_delta << 3) | (jubyte) line_delta; | |
| 754 // Check that value doesn't match escape character. | |
| 755 if (value != 0xFF) { | |
| 756 write_byte(value); | |
| 757 return; | |
| 758 } | |
| 759 } | |
| 760 write_pair_regular(bci_delta, line_delta); | |
| 761 } | |
| 762 | |
| 763 // Windows AMD64 + Apr 2005 PSDK with /O2 generates bad code for write_pair. | |
| 764 // Disabling optimization doesn't work for methods in header files | |
| 765 // so we force it to call through the non-optimized version in the .cpp. | |
| 766 // It's gross, but it's the only way we can ensure that all callers are | |
|
2233
15d6977f04b0
7017824: Add support for creating 64-bit Visual Studio projects
sla
parents:
2177
diff
changeset
|
767 // fixed. _MSC_VER is defined by the windows compiler |
|
15d6977f04b0
7017824: Add support for creating 64-bit Visual Studio projects
sla
parents:
2177
diff
changeset
|
768 #if defined(_M_AMD64) && _MSC_VER >= 1400 |
| 0 | 769 void write_pair(int bci, int line); |
| 770 #else | |
| 771 void write_pair(int bci, int line) { write_pair_inline(bci, line); } | |
| 772 #endif | |
| 773 | |
| 774 // Write end-of-stream marker | |
| 775 void write_terminator() { write_byte(0); } | |
| 776 }; | |
| 777 | |
| 778 | |
| 779 // Utility class for decompressing line number tables | |
| 780 | |
| 781 class CompressedLineNumberReadStream: public CompressedReadStream { | |
| 782 private: | |
| 783 int _bci; | |
| 784 int _line; | |
| 785 public: | |
| 786 // Constructor | |
| 787 CompressedLineNumberReadStream(u_char* buffer); | |
| 788 // Read (bci, line number) pair from stream. Returns false at end-of-stream. | |
| 789 bool read_pair(); | |
| 790 // Accessing bci and line number (after calling read_pair) | |
| 791 int bci() const { return _bci; } | |
| 792 int line() const { return _line; } | |
| 793 }; | |
| 794 | |
| 795 | |
| 796 /// Fast Breakpoints. | |
| 797 | |
| 798 // If this structure gets more complicated (because bpts get numerous), | |
| 799 // move it into its own header. | |
| 800 | |
| 801 // There is presently no provision for concurrent access | |
| 802 // to breakpoint lists, which is only OK for JVMTI because | |
| 803 // breakpoints are written only at safepoints, and are read | |
| 804 // concurrently only outside of safepoints. | |
| 805 | |
| 806 class BreakpointInfo : public CHeapObj { | |
| 807 friend class VMStructs; | |
| 808 private: | |
| 809 Bytecodes::Code _orig_bytecode; | |
| 810 int _bci; | |
| 811 u2 _name_index; // of method | |
| 812 u2 _signature_index; // of method | |
| 813 BreakpointInfo* _next; // simple storage allocation | |
| 814 | |
| 815 public: | |
| 816 BreakpointInfo(methodOop m, int bci); | |
| 817 | |
| 818 // accessors | |
| 819 Bytecodes::Code orig_bytecode() { return _orig_bytecode; } | |
| 820 void set_orig_bytecode(Bytecodes::Code code) { _orig_bytecode = code; } | |
| 821 int bci() { return _bci; } | |
| 822 | |
| 823 BreakpointInfo* next() const { return _next; } | |
| 824 void set_next(BreakpointInfo* n) { _next = n; } | |
| 825 | |
| 826 // helps for searchers | |
| 2142 | 827 bool match(const methodOopDesc* m, int bci) { |
| 0 | 828 return bci == _bci && match(m); |
| 829 } | |
| 830 | |
| 2142 | 831 bool match(const methodOopDesc* m) { |
| 0 | 832 return _name_index == m->name_index() && |
| 833 _signature_index == m->signature_index(); | |
| 834 } | |
| 835 | |
| 836 void set(methodOop method); | |
| 837 void clear(methodOop method); | |
| 838 }; | |
| 1972 | 839 |
| 840 #endif // SHARE_VM_OOPS_METHODOOP_HPP |