truffle: src/share/vm/oops/method.hpp annotate

annotate src/share/vm/oops/method.hpp @ 9126:bc26f978b0ce

HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly don't use the (wrong) cached value, but ask the runtime on each request. Fixes regression on xml.* benchmarks @ specjvm2008. The problem was: After the constructor of Object was deoptimized due to an assumption violation, it was recompiled again after some time. However, on recompilation, the value of hasFinalizeSubclass for the class was not updated and it was compiled again with a, now wrong, assumption, which then triggers deoptimization again. This was repeated until it hit the recompilation limit (defined by PerMethodRecompilationCutoff), and therefore only executed by the interpreter from now on, causing the performance regression.

author	Bernhard Urban <bernhard.urban@jku.at>
date	Mon, 15 Apr 2013 19:54:58 +0200
parents	89e4d67fdd2a
children	836a62f43af9

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7470 diff changeset	2 * Copyright (c) 1997, 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: 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 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: 1877 diff changeset	25 #ifndef SHARE_VM_OOPS_METHODOOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	26 #define SHARE_VM_OOPS_METHODOOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	28 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	29 #include "code/compressedStream.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	30 #include "compiler/oopMap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	31 #include "interpreter/invocationCounter.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	32 #include "oops/annotations.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	33 #include "oops/constantPool.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	34 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	35 #include "oops/oop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	36 #include "oops/typeArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	37 #include "utilities/accessFlags.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	38 #include "utilities/growableArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	39
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	40 // A Method* represents a Java method.
0 a61af66fc99e Initial load duke parents: diff changeset	41 //
a61af66fc99e Initial load duke parents: diff changeset	42 // Memory layout (each line represents a word). Note that most applications load thousands of methods,
a61af66fc99e Initial load duke parents: diff changeset	43 // so keeping the size of this structure small has a big impact on footprint.
a61af66fc99e Initial load duke parents: diff changeset	44 //
a61af66fc99e Initial load duke parents: diff changeset	45 // We put all oops and method_size first for better gc cache locality.
a61af66fc99e Initial load duke parents: diff changeset	46 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	47 // The actual bytecodes are inlined after the end of the Method struct.
0 a61af66fc99e Initial load duke parents: diff changeset	48 //
a61af66fc99e Initial load duke parents: diff changeset	49 // There are bits in the access_flags telling whether inlined tables are present.
a61af66fc99e Initial load duke parents: diff changeset	50 // Note that accessing the line number and local variable tables is not performance critical at all.
a61af66fc99e Initial load duke parents: diff changeset	51 // Accessing the checked exceptions table is used by reflection, so we put that last to make access
a61af66fc99e Initial load duke parents: diff changeset	52 // to it fast.
a61af66fc99e Initial load duke parents: diff changeset	53 //
a61af66fc99e Initial load duke parents: diff changeset	54 // The line number table is compressed and inlined following the byte codes. It is found as the first
a61af66fc99e Initial load duke parents: diff changeset	55 // byte following the byte codes. The checked exceptions table and the local variable table are inlined
a61af66fc99e Initial load duke parents: diff changeset	56 // after the line number table, and indexed from the end of the method. We do not compress the checked
a61af66fc99e Initial load duke parents: diff changeset	57 // exceptions table since the average length is less than 2, and do not bother to compress the local
a61af66fc99e Initial load duke parents: diff changeset	58 // variable table either since it is mostly absent.
a61af66fc99e Initial load duke parents: diff changeset	59 //
a61af66fc99e Initial load duke parents: diff changeset	60 // Note that native_function and signature_handler has to be at fixed offsets (required by the interpreter)
a61af66fc99e Initial load duke parents: diff changeset	61 //
a61af66fc99e Initial load duke parents: diff changeset	62 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	63 // \| header \|
a61af66fc99e Initial load duke parents: diff changeset	64 // \| klass \|
a61af66fc99e Initial load duke parents: diff changeset	65 // \|------------------------------------------------------\|
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	66 // \| ConstMethod* (oop) \|
0 a61af66fc99e Initial load duke parents: diff changeset	67 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	68 // \| methodData (oop) \|
a61af66fc99e Initial load duke parents: diff changeset	69 // \| interp_invocation_count \|
a61af66fc99e Initial load duke parents: diff changeset	70 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	71 // \| access_flags \|
a61af66fc99e Initial load duke parents: diff changeset	72 // \| vtable_index \|
a61af66fc99e Initial load duke parents: diff changeset	73 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	74 // \| result_index (C++ interpreter only) \|
a61af66fc99e Initial load duke parents: diff changeset	75 // \|------------------------------------------------------\|
7402 fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7184 diff changeset	76 // \| method_size \| intrinsic_id\| flags \|
0 a61af66fc99e Initial load duke parents: diff changeset	77 // \|------------------------------------------------------\|
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6940 diff changeset	78 // \| throwout_count \| num_breakpoints \|
0 a61af66fc99e Initial load duke parents: diff changeset	79 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	80 // \| invocation_counter \|
a61af66fc99e Initial load duke parents: diff changeset	81 // \| backedge_counter \|
a61af66fc99e Initial load duke parents: diff changeset	82 // \|------------------------------------------------------\|
2348 5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	83 // \| prev_time (tiered only, 64 bit wide) \|
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	84 // \| \|
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	85 // \|------------------------------------------------------\|
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	86 // \| rate (tiered) \|
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	87 // \|------------------------------------------------------\|
0 a61af66fc99e Initial load duke parents: diff changeset	88 // \| code (pointer) \|
a61af66fc99e Initial load duke parents: diff changeset	89 // \| i2i (pointer) \|
a61af66fc99e Initial load duke parents: diff changeset	90 // \| adapter (pointer) \|
a61af66fc99e Initial load duke parents: diff changeset	91 // \| from_compiled_entry (pointer) \|
a61af66fc99e Initial load duke parents: diff changeset	92 // \| from_interpreted_entry (pointer) \|
a61af66fc99e Initial load duke parents: diff changeset	93 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	94 // \| native_function (present only if native) \|
a61af66fc99e Initial load duke parents: diff changeset	95 // \| signature_handler (present only if native) \|
a61af66fc99e Initial load duke parents: diff changeset	96 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	97
a61af66fc99e Initial load duke parents: diff changeset	98
a61af66fc99e Initial load duke parents: diff changeset	99 class CheckedExceptionElement;
a61af66fc99e Initial load duke parents: diff changeset	100 class LocalVariableTableElement;
a61af66fc99e Initial load duke parents: diff changeset	101 class AdapterHandlerEntry;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	102 class MethodData;
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6800 diff changeset	103 class ConstMethod;
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8025 diff changeset	104 class InlineTableSizes;
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7470 diff changeset	105 class KlassSizeStats;
0 a61af66fc99e Initial load duke parents: diff changeset	106
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	107 class Method : public Metadata {
0 a61af66fc99e Initial load duke parents: diff changeset	108 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	109 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	110 ConstMethod* _constMethod; // Method read-only data.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	111 MethodData* _method_data;
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	112 int _interpreter_invocation_count; // Count of times invoked (reused as prev_event_count in tiered)
0 a61af66fc99e Initial load duke parents: diff changeset	113 AccessFlags _access_flags; // Access flags
a61af66fc99e Initial load duke parents: diff changeset	114 int _vtable_index; // vtable index of this method (see VtableIndexFlag)
a61af66fc99e Initial load duke parents: diff changeset	115 // note: can have vtables with >2**16 elements (because of inheritance)
a61af66fc99e Initial load duke parents: diff changeset	116 #ifdef CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	117 int _result_index; // C++ interpreter needs for converting results to/from stack
a61af66fc99e Initial load duke parents: diff changeset	118 #endif
a61af66fc99e Initial load duke parents: diff changeset	119 u2 _method_size; // size of this object
856 75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics jrose parents: 726 diff changeset	120 u1 _intrinsic_id; // vmSymbols::intrinsic_id (0 == _none)
8866 16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	121 u1 _jfr_towrite : 1, // Flags
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	122 _caller_sensitive : 1,
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	123 _force_inline : 1,
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	124 _hidden : 1,
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	125 _dont_inline : 1,
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	126 : 3;
0 a61af66fc99e Initial load duke parents: diff changeset	127 u2 _interpreter_throwout_count; // Count of times method was exited via exception while interpreting
a61af66fc99e Initial load duke parents: diff changeset	128 u2 _number_of_breakpoints; // fullspeed debugging support
a61af66fc99e Initial load duke parents: diff changeset	129 InvocationCounter _invocation_counter; // Incremented before each activation of the method - used to trigger frequency-based optimizations
a61af66fc99e Initial load duke parents: diff changeset	130 InvocationCounter _backedge_counter; // Incremented before each backedge taken - used to trigger frequencey-based optimizations
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	131
5176 af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	132 #ifdef GRAAL
af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	133 jlong _graal_invocation_time;
af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	134 int _graal_priority;
af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	135 #endif
2348 5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	136 #ifdef TIERED
7968 44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7470 diff changeset	137 float _rate; // Events (invocation and backedge counter increments) per millisecond
2348 5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	138 jlong _prev_time; // Previous time the rate was acquired
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	139 #endif
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	140
0 a61af66fc99e Initial load duke parents: diff changeset	141 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	142 int _compiled_invocation_count; // Number of nmethod invocations so far (for perf. debugging)
a61af66fc99e Initial load duke parents: diff changeset	143 #endif
a61af66fc99e Initial load duke parents: diff changeset	144 // Entry point for calling both from and to the interpreter.
a61af66fc99e Initial load duke parents: diff changeset	145 address _i2i_entry; // All-args-on-stack calling convention
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	146 // Adapter blob (i2c/c2i) for this Method*. Set once when method is linked.
0 a61af66fc99e Initial load duke parents: diff changeset	147 AdapterHandlerEntry* _adapter;
a61af66fc99e Initial load duke parents: diff changeset	148 // Entry point for calling from compiled code, to compiled code if it exists
a61af66fc99e Initial load duke parents: diff changeset	149 // or else the interpreter.
a61af66fc99e Initial load duke parents: diff changeset	150 volatile address _from_compiled_entry; // Cache of: _code ? _code->entry_point() : _adapter->c2i_entry()
a61af66fc99e Initial load duke parents: diff changeset	151 // The entry point for calling both from and to compiled code is
a61af66fc99e Initial load duke parents: diff changeset	152 // "_code->entry_point()". Because of tiered compilation and de-opt, this
a61af66fc99e Initial load duke parents: diff changeset	153 // field can come and go. It can transition from NULL to not-null at any
a61af66fc99e Initial load duke parents: diff changeset	154 // time (whenever a compile completes). It can transition from not-null to
a61af66fc99e Initial load duke parents: diff changeset	155 // NULL only at safepoints (because of a de-opt).
a61af66fc99e Initial load duke parents: diff changeset	156 nmethod* volatile _code; // Points to the corresponding piece of native code
a61af66fc99e Initial load duke parents: diff changeset	157 volatile address _from_interpreted_entry; // Cache of _code ? _adapter->i2c_entry() : _i2i_entry
a61af66fc99e Initial load duke parents: diff changeset	158
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	159 // Constructor
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	160 Method(ConstMethod* xconst, AccessFlags access_flags, int size);
0 a61af66fc99e Initial load duke parents: diff changeset	161 public:
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6800 diff changeset	162
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	163 static Method* allocate(ClassLoaderData* loader_data,
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6800 diff changeset	164 int byte_code_size,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6800 diff changeset	165 AccessFlags access_flags,
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8025 diff changeset	166 InlineTableSizes* sizes,
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6800 diff changeset	167 ConstMethod::MethodType method_type,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6800 diff changeset	168 TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	169
7176 59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6940 diff changeset	170 // CDS and vtbl checking can create an empty Method to get vtbl pointer.
59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6940 diff changeset	171 Method(){}
6733 fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	172
fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	173 // The Method vtable is restored by this call when the Method is in the
fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	174 // shared archive. See patch_klass_vtables() in metaspaceShared.cpp for
fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	175 // all the gory details. SA, dtrace and pstack helpers distinguish metadata
fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	176 // by their vtable.
fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	177 void restore_vtable() { guarantee(is_method(), "vtable restored by this call"); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	178 bool is_method() const volatile { return true; }
518 0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 196 diff changeset	179
0 a61af66fc99e Initial load duke parents: diff changeset	180 // accessors for instance variables
6733 fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	181
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	182 ConstMethod* constMethod() const { return _constMethod; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	183 void set_constMethod(ConstMethod* xconst) { _constMethod = xconst; }
0 a61af66fc99e Initial load duke parents: diff changeset	184
a61af66fc99e Initial load duke parents: diff changeset	185
a61af66fc99e Initial load duke parents: diff changeset	186 static address make_adapters(methodHandle mh, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	187 volatile address from_compiled_entry() const { return (address)OrderAccess::load_ptr_acquire(&_from_compiled_entry); }
a61af66fc99e Initial load duke parents: diff changeset	188 volatile address from_interpreted_entry() const{ return (address)OrderAccess::load_ptr_acquire(&_from_interpreted_entry); }
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 // access flag
a61af66fc99e Initial load duke parents: diff changeset	191 AccessFlags access_flags() const { return _access_flags; }
a61af66fc99e Initial load duke parents: diff changeset	192 void set_access_flags(AccessFlags flags) { _access_flags = flags; }
a61af66fc99e Initial load duke parents: diff changeset	193
a61af66fc99e Initial load duke parents: diff changeset	194 // name
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 4873 diff changeset	195 Symbol* name() const { return constants()->symbol_at(name_index()); }
0 a61af66fc99e Initial load duke parents: diff changeset	196 int name_index() const { return constMethod()->name_index(); }
a61af66fc99e Initial load duke parents: diff changeset	197 void set_name_index(int index) { constMethod()->set_name_index(index); }
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 // signature
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 4873 diff changeset	200 Symbol* signature() const { return constants()->symbol_at(signature_index()); }
0 a61af66fc99e Initial load duke parents: diff changeset	201 int signature_index() const { return constMethod()->signature_index(); }
a61af66fc99e Initial load duke parents: diff changeset	202 void set_signature_index(int index) { constMethod()->set_signature_index(index); }
a61af66fc99e Initial load duke parents: diff changeset	203
a61af66fc99e Initial load duke parents: diff changeset	204 // generics support
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 4873 diff changeset	205 Symbol* generic_signature() const { int idx = generic_signature_index(); return ((idx != 0) ? constants()->symbol_at(idx) : (Symbol*)NULL); }
0 a61af66fc99e Initial load duke parents: diff changeset	206 int generic_signature_index() const { return constMethod()->generic_signature_index(); }
a61af66fc99e Initial load duke parents: diff changeset	207 void set_generic_signature_index(int index) { constMethod()->set_generic_signature_index(index); }
a61af66fc99e Initial load duke parents: diff changeset	208
a61af66fc99e Initial load duke parents: diff changeset	209 // annotations support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	210 AnnotationArray* annotations() const {
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8025 diff changeset	211 return constMethod()->method_annotations();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	212 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	213 AnnotationArray* parameter_annotations() const {
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8025 diff changeset	214 return constMethod()->parameter_annotations();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	215 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	216 AnnotationArray* annotation_default() const {
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8025 diff changeset	217 return constMethod()->default_annotations();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	218 }
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8025 diff changeset	219 AnnotationArray* type_annotations() const {
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8025 diff changeset	220 return constMethod()->type_annotations();
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8025 diff changeset	221 }
0 a61af66fc99e Initial load duke parents: diff changeset	222
a61af66fc99e Initial load duke parents: diff changeset	223 #ifdef CC_INTERP
a61af66fc99e Initial load duke parents: diff changeset	224 void set_result_index(BasicType type);
a61af66fc99e Initial load duke parents: diff changeset	225 int result_index() { return _result_index; }
a61af66fc99e Initial load duke parents: diff changeset	226 #endif
a61af66fc99e Initial load duke parents: diff changeset	227
a61af66fc99e Initial load duke parents: diff changeset	228 // Helper routine: get klass name + "." + method name + signature as
a61af66fc99e Initial load duke parents: diff changeset	229 // C string, for the purpose of providing more useful NoSuchMethodErrors
a61af66fc99e Initial load duke parents: diff changeset	230 // and fatal error handling. The string is allocated in resource
a61af66fc99e Initial load duke parents: diff changeset	231 // area if a buffer is not provided by the caller.
6145 e2fe93124108 7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely twisti parents: 4873 diff changeset	232 char* name_and_sig_as_C_string() const;
e2fe93124108 7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely twisti parents: 4873 diff changeset	233 char* name_and_sig_as_C_string(char* buf, int size) const;
0 a61af66fc99e Initial load duke parents: diff changeset	234
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	235 // Static routine in the situations we don't have a Method*
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	236 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	237 static char* name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature, char* buf, int size);
0 a61af66fc99e Initial load duke parents: diff changeset	238
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	239 Bytecodes::Code java_code_at(int bci) const {
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	240 return Bytecodes::java_code_at(this, bcp_from(bci));
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	241 }
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	242 Bytecodes::Code code_at(int bci) const {
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	243 return Bytecodes::code_at(this, bcp_from(bci));
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	244 }
8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	245
0 a61af66fc99e Initial load duke parents: diff changeset	246 // JVMTI breakpoints
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 1972 diff changeset	247 Bytecodes::Code orig_bytecode_at(int bci) const;
0 a61af66fc99e Initial load duke parents: diff changeset	248 void set_orig_bytecode_at(int bci, Bytecodes::Code code);
a61af66fc99e Initial load duke parents: diff changeset	249 void set_breakpoint(int bci);
a61af66fc99e Initial load duke parents: diff changeset	250 void clear_breakpoint(int bci);
a61af66fc99e Initial load duke parents: diff changeset	251 void clear_all_breakpoints();
a61af66fc99e Initial load duke parents: diff changeset	252 // Tracking number of breakpoints, for fullspeed debugging.
a61af66fc99e Initial load duke parents: diff changeset	253 // Only mutated by VM thread.
a61af66fc99e Initial load duke parents: diff changeset	254 u2 number_of_breakpoints() const { return _number_of_breakpoints; }
a61af66fc99e Initial load duke parents: diff changeset	255 void incr_number_of_breakpoints() { ++_number_of_breakpoints; }
a61af66fc99e Initial load duke parents: diff changeset	256 void decr_number_of_breakpoints() { --_number_of_breakpoints; }
a61af66fc99e Initial load duke parents: diff changeset	257 // Initialization only
a61af66fc99e Initial load duke parents: diff changeset	258 void clear_number_of_breakpoints() { _number_of_breakpoints = 0; }
a61af66fc99e Initial load duke parents: diff changeset	259
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	260 // index into InstanceKlass methods() array
4800 94ec88ca68e2 7115199: Add event tracing hooks and Java Flight Recorder infrastructure phh parents: 3461 diff changeset	261 // note: also used by jfr
0 a61af66fc99e Initial load duke parents: diff changeset	262 u2 method_idnum() const { return constMethod()->method_idnum(); }
a61af66fc99e Initial load duke parents: diff changeset	263 void set_method_idnum(u2 idnum) { constMethod()->set_method_idnum(idnum); }
a61af66fc99e Initial load duke parents: diff changeset	264
a61af66fc99e Initial load duke parents: diff changeset	265 // code size
a61af66fc99e Initial load duke parents: diff changeset	266 int code_size() const { return constMethod()->code_size(); }
a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 // method size
a61af66fc99e Initial load duke parents: diff changeset	269 int method_size() const { return _method_size; }
a61af66fc99e Initial load duke parents: diff changeset	270 void set_method_size(int size) {
a61af66fc99e Initial load duke parents: diff changeset	271 assert(0 <= size && size < (1 << 16), "invalid method size");
a61af66fc99e Initial load duke parents: diff changeset	272 _method_size = size;
a61af66fc99e Initial load duke parents: diff changeset	273 }
a61af66fc99e Initial load duke parents: diff changeset	274
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	275 // constant pool for Klass* holding this method
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	276 ConstantPool* constants() const { return constMethod()->constants(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	277 void set_constants(ConstantPool* c) { constMethod()->set_constants(c); }
0 a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279 // max stack
6271 93c71eb28866 7188911: nightly failures after JSR 292 lazy method handle update (round 2) twisti parents: 6266 diff changeset	280 // return original max stack size for method verification
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6940 diff changeset	281 int verifier_max_stack() const { return constMethod()->max_stack(); }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6940 diff changeset	282 int max_stack() const { return constMethod()->max_stack() + extra_stack_entries(); }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6940 diff changeset	283 void set_max_stack(int size) { constMethod()->set_max_stack(size); }
0 a61af66fc99e Initial load duke parents: diff changeset	284
a61af66fc99e Initial load duke parents: diff changeset	285 // max locals
7402 fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7184 diff changeset	286 int max_locals() const { return constMethod()->max_locals(); }
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7184 diff changeset	287 void set_max_locals(int size) { constMethod()->set_max_locals(size); }
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	288
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	289 int highest_comp_level() const;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	290 void set_highest_comp_level(int level);
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	291 int highest_osr_comp_level() const;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	292 void set_highest_osr_comp_level(int level);
0 a61af66fc99e Initial load duke parents: diff changeset	293
a61af66fc99e Initial load duke parents: diff changeset	294 // Count of times method was exited via exception while interpreting
a61af66fc99e Initial load duke parents: diff changeset	295 void interpreter_throwout_increment() {
a61af66fc99e Initial load duke parents: diff changeset	296 if (_interpreter_throwout_count < 65534) {
a61af66fc99e Initial load duke parents: diff changeset	297 _interpreter_throwout_count++;
a61af66fc99e Initial load duke parents: diff changeset	298 }
a61af66fc99e Initial load duke parents: diff changeset	299 }
a61af66fc99e Initial load duke parents: diff changeset	300
a61af66fc99e Initial load duke parents: diff changeset	301 int interpreter_throwout_count() const { return _interpreter_throwout_count; }
a61af66fc99e Initial load duke parents: diff changeset	302 void set_interpreter_throwout_count(int count) { _interpreter_throwout_count = count; }
a61af66fc99e Initial load duke parents: diff changeset	303
a61af66fc99e Initial load duke parents: diff changeset	304 // size of parameters
7402 fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7184 diff changeset	305 int size_of_parameters() const { return constMethod()->size_of_parameters(); }
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7184 diff changeset	306 void set_size_of_parameters(int size) { constMethod()->set_size_of_parameters(size); }
0 a61af66fc99e Initial load duke parents: diff changeset	307
a61af66fc99e Initial load duke parents: diff changeset	308 bool has_stackmap_table() const {
a61af66fc99e Initial load duke parents: diff changeset	309 return constMethod()->has_stackmap_table();
a61af66fc99e Initial load duke parents: diff changeset	310 }
a61af66fc99e Initial load duke parents: diff changeset	311
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	312 Array<u1>* stackmap_data() const {
0 a61af66fc99e Initial load duke parents: diff changeset	313 return constMethod()->stackmap_data();
a61af66fc99e Initial load duke parents: diff changeset	314 }
a61af66fc99e Initial load duke parents: diff changeset	315
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	316 void set_stackmap_data(Array<u1>* sd) {
1877 a4c7fe54bf3f 6991315: RedefineClasses fails with java.lang.VerifyError kamg parents: 1793 diff changeset	317 constMethod()->set_stackmap_data(sd);
a4c7fe54bf3f 6991315: RedefineClasses fails with java.lang.VerifyError kamg parents: 1793 diff changeset	318 }
a4c7fe54bf3f 6991315: RedefineClasses fails with java.lang.VerifyError kamg parents: 1793 diff changeset	319
0 a61af66fc99e Initial load duke parents: diff changeset	320 // exception handler table
a61af66fc99e Initial load duke parents: diff changeset	321 bool has_exception_handler() const
a61af66fc99e Initial load duke parents: diff changeset	322 { return constMethod()->has_exception_handler(); }
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	323 int exception_table_length() const
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	324 { return constMethod()->exception_table_length(); }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	325 ExceptionTableElement* exception_table_start() const
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	326 { return constMethod()->exception_table_start(); }
0 a61af66fc99e Initial load duke parents: diff changeset	327
a61af66fc99e Initial load duke parents: diff changeset	328 // Finds the first entry point bci of an exception handler for an
a61af66fc99e Initial load duke parents: diff changeset	329 // exception of klass ex_klass thrown at throw_bci. A value of NULL
a61af66fc99e Initial load duke parents: diff changeset	330 // for ex_klass indicates that the exception klass is not known; in
a61af66fc99e Initial load duke parents: diff changeset	331 // this case it matches any constraint class. Returns -1 if the
a61af66fc99e Initial load duke parents: diff changeset	332 // exception cannot be handled in this method. The handler
a61af66fc99e Initial load duke parents: diff changeset	333 // constraint classes are loaded if necessary. Note that this may
a61af66fc99e Initial load duke parents: diff changeset	334 // throw an exception if loading of the constraint classes causes
a61af66fc99e Initial load duke parents: diff changeset	335 // an IllegalAccessError (bugid 4307310) or an OutOfMemoryError.
a61af66fc99e Initial load duke parents: diff changeset	336 // If an exception is thrown, returns the bci of the
a61af66fc99e Initial load duke parents: diff changeset	337 // exception handler which caused the exception to be thrown, which
a61af66fc99e Initial load duke parents: diff changeset	338 // is needed for proper retries. See, for example,
a61af66fc99e Initial load duke parents: diff changeset	339 // InterpreterRuntime::exception_handler_for_exception.
7469 0c8717a92b2d 8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread)+0x3e9. jiangli* parents: 7402 diff changeset	340 static int fast_exception_handler_bci_for(methodHandle mh, KlassHandle ex_klass, int throw_bci, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	341
a61af66fc99e Initial load duke parents: diff changeset	342 // method data access
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	343 MethodData* method_data() const {
0 a61af66fc99e Initial load duke parents: diff changeset	344 return _method_data;
a61af66fc99e Initial load duke parents: diff changeset	345 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	346 void set_method_data(MethodData* data) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	347 _method_data = data;
0 a61af66fc99e Initial load duke parents: diff changeset	348 }
a61af66fc99e Initial load duke parents: diff changeset	349
a61af66fc99e Initial load duke parents: diff changeset	350 // invocation counter
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	351 InvocationCounter* invocation_counter() { return &_invocation_counter; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	352 InvocationCounter* backedge_counter() { return &_backedge_counter; }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	353
2348 5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	354 #ifdef TIERED
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	355 // 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	356 // We can do that since interpreter_invocation_count is not used in tiered.
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	357 int prev_event_count() const { return _interpreter_invocation_count; }
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	358 void set_prev_event_count(int count) { _interpreter_invocation_count = count; }
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	359 jlong prev_time() const { return _prev_time; }
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	360 void set_prev_time(jlong time) { _prev_time = time; }
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	361 float rate() const { return _rate; }
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	362 void set_rate(float rate) { _rate = rate; }
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	363 #endif
5d8f5a6dced7 7020403: Add AdvancedCompilationPolicy for tiered iveresov parents: 2243 diff changeset	364
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	365 int invocation_count();
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	366 int backedge_count();
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	367
5176 af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	368 #ifdef GRAAL
af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	369 void set_graal_invocation_time(jlong time) { _graal_invocation_time = time; }
af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	370 jlong graal_invocation_time() { return _graal_invocation_time; }
af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	371
af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	372 void set_graal_priority(int prio) { _graal_priority = prio; }
af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	373 int graal_priority() { return _graal_priority; }
8611 6c4db417385a added API to reset the profiling information for a method Christian Haeubl <haeubl@ssw.jku.at> parents: 8151 diff changeset	374
6c4db417385a added API to reset the profiling information for a method Christian Haeubl <haeubl@ssw.jku.at> parents: 8151 diff changeset	375 void reset_counters();
5176 af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	376 #endif // GRAAL
af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	377
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	378 bool was_executed_more_than(int n);
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	379 bool was_never_executed() { return !was_executed_more_than(0); }
0 a61af66fc99e Initial load duke parents: diff changeset	380
a61af66fc99e Initial load duke parents: diff changeset	381 static void build_interpreter_method_data(methodHandle method, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	382
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	383 int interpreter_invocation_count() {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	384 if (TieredCompilation) return invocation_count();
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	385 else return _interpreter_invocation_count;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	386 }
0 a61af66fc99e Initial load duke parents: diff changeset	387 void set_interpreter_invocation_count(int count) { _interpreter_invocation_count = count; }
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	388 int increment_interpreter_invocation_count() {
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	389 if (TieredCompilation) ShouldNotReachHere();
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	390 return ++_interpreter_invocation_count;
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	391 }
8611 6c4db417385a added API to reset the profiling information for a method Christian Haeubl <haeubl@ssw.jku.at> parents: 8151 diff changeset	392
0 a61af66fc99e Initial load duke parents: diff changeset	393 #ifndef PRODUCT
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	394 int compiled_invocation_count() const { return _compiled_invocation_count; }
0 a61af66fc99e Initial load duke parents: diff changeset	395 void set_compiled_invocation_count(int count) { _compiled_invocation_count = count; }
a61af66fc99e Initial load duke parents: diff changeset	396 #endif // not PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	397
605 98cb887364d3 6810672: Comment typos twisti parents: 518 diff changeset	398 // Clear (non-shared space) pointers which could not be relevant
0 a61af66fc99e Initial load duke parents: diff changeset	399 // if this (shared) method were mapped into another JVM.
a61af66fc99e Initial load duke parents: diff changeset	400 void remove_unshareable_info();
a61af66fc99e Initial load duke parents: diff changeset	401
a61af66fc99e Initial load duke parents: diff changeset	402 // nmethod/verified compiler entry
a61af66fc99e Initial load duke parents: diff changeset	403 address verified_code_entry();
a61af66fc99e Initial load duke parents: diff changeset	404 bool check_code() const; // Not inline to avoid circular ref
a61af66fc99e Initial load duke parents: diff changeset	405 nmethod* volatile code() const { assert( check_code(), "" ); return (nmethod *)OrderAccess::load_ptr_acquire(&_code); }
a61af66fc99e Initial load duke parents: diff changeset	406 void clear_code(); // Clear out any compiled code
1202 5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1152 diff changeset	407 static void set_code(methodHandle mh, nmethod* code);
0 a61af66fc99e Initial load duke parents: diff changeset	408 void set_adapter_entry(AdapterHandlerEntry* adapter) { _adapter = adapter; }
a61af66fc99e Initial load duke parents: diff changeset	409 address get_i2c_entry();
a61af66fc99e Initial load duke parents: diff changeset	410 address get_c2i_entry();
a61af66fc99e Initial load duke parents: diff changeset	411 address get_c2i_unverified_entry();
a61af66fc99e Initial load duke parents: diff changeset	412 AdapterHandlerEntry* adapter() { return _adapter; }
a61af66fc99e Initial load duke parents: diff changeset	413 // setup entry points
a61af66fc99e Initial load duke parents: diff changeset	414 void link_method(methodHandle method, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	415 // clear entry points. Used by sharing code
a61af66fc99e Initial load duke parents: diff changeset	416 void unlink_method();
a61af66fc99e Initial load duke parents: diff changeset	417
a61af66fc99e Initial load duke parents: diff changeset	418 // vtable index
a61af66fc99e Initial load duke parents: diff changeset	419 enum VtableIndexFlag {
a61af66fc99e Initial load duke parents: diff changeset	420 // Valid vtable indexes are non-negative (>= 0).
a61af66fc99e Initial load duke parents: diff changeset	421 // These few negative values are used as sentinels.
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 628 diff changeset	422 highest_unused_vtable_index_value = -5,
0 a61af66fc99e Initial load duke parents: diff changeset	423 invalid_vtable_index = -4, // distinct from any valid vtable index
a61af66fc99e Initial load duke parents: diff changeset	424 garbage_vtable_index = -3, // not yet linked; no vtable layout yet
a61af66fc99e Initial load duke parents: diff changeset	425 nonvirtual_vtable_index = -2 // there is no need for vtable dispatch
a61af66fc99e Initial load duke parents: diff changeset	426 // 6330203 Note: Do not use -1, which was overloaded with many meanings.
a61af66fc99e Initial load duke parents: diff changeset	427 };
a61af66fc99e Initial load duke parents: diff changeset	428 DEBUG_ONLY(bool valid_vtable_index() const { return _vtable_index >= nonvirtual_vtable_index; })
a61af66fc99e Initial load duke parents: diff changeset	429 int vtable_index() const { assert(valid_vtable_index(), "");
a61af66fc99e Initial load duke parents: diff changeset	430 return _vtable_index; }
a61af66fc99e Initial load duke parents: diff changeset	431 void set_vtable_index(int index) { _vtable_index = index; }
a61af66fc99e Initial load duke parents: diff changeset	432
a61af66fc99e Initial load duke parents: diff changeset	433 // interpreter entry
a61af66fc99e Initial load duke parents: diff changeset	434 address interpreter_entry() const { return _i2i_entry; }
a61af66fc99e Initial load duke parents: diff changeset	435 // Only used when first initialize so we can set _i2i_entry and _from_interpreted_entry
a61af66fc99e Initial load duke parents: diff changeset	436 void set_interpreter_entry(address entry) { _i2i_entry = entry; _from_interpreted_entry = entry; }
a61af66fc99e Initial load duke parents: diff changeset	437
a61af66fc99e Initial load duke parents: diff changeset	438 // native function (used for native methods only)
a61af66fc99e Initial load duke parents: diff changeset	439 enum {
a61af66fc99e Initial load duke parents: diff changeset	440 native_bind_event_is_interesting = true
a61af66fc99e Initial load duke parents: diff changeset	441 };
a61af66fc99e Initial load duke parents: diff changeset	442 address native_function() const { return *(native_function_addr()); }
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 4800 diff changeset	443 address critical_native_function();
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 4800 diff changeset	444
0 a61af66fc99e Initial load duke parents: diff changeset	445 // Must specify a real function (not NULL).
a61af66fc99e Initial load duke parents: diff changeset	446 // Use clear_native_function() to unregister.
a61af66fc99e Initial load duke parents: diff changeset	447 void set_native_function(address function, bool post_event_flag);
a61af66fc99e Initial load duke parents: diff changeset	448 bool has_native_function() const;
a61af66fc99e Initial load duke parents: diff changeset	449 void clear_native_function();
a61af66fc99e Initial load duke parents: diff changeset	450
a61af66fc99e Initial load duke parents: diff changeset	451 // signature handler (used for native methods only)
a61af66fc99e Initial load duke parents: diff changeset	452 address signature_handler() const { return *(signature_handler_addr()); }
a61af66fc99e Initial load duke parents: diff changeset	453 void set_signature_handler(address handler);
a61af66fc99e Initial load duke parents: diff changeset	454
a61af66fc99e Initial load duke parents: diff changeset	455 // Interpreter oopmap support
a61af66fc99e Initial load duke parents: diff changeset	456 void mask_for(int bci, InterpreterOopMap* mask);
a61af66fc99e Initial load duke parents: diff changeset	457
a61af66fc99e Initial load duke parents: diff changeset	458 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	459 // operations on invocation counter
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	460 void print_invocation_count();
0 a61af66fc99e Initial load duke parents: diff changeset	461 #endif
a61af66fc99e Initial load duke parents: diff changeset	462
a61af66fc99e Initial load duke parents: diff changeset	463 // byte codes
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 977 diff changeset	464 void set_code(address code) { return constMethod()->set_code(code); }
0 a61af66fc99e Initial load duke parents: diff changeset	465 address code_base() const { return constMethod()->code_base(); }
a61af66fc99e Initial load duke parents: diff changeset	466 bool contains(address bcp) const { return constMethod()->contains(bcp); }
a61af66fc99e Initial load duke parents: diff changeset	467
a61af66fc99e Initial load duke parents: diff changeset	468 // prints byte codes
a61af66fc99e Initial load duke parents: diff changeset	469 void print_codes() const { print_codes_on(tty); }
a61af66fc99e Initial load duke parents: diff changeset	470 void print_codes_on(outputStream* st) const PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	471 void print_codes_on(int from, int to, outputStream* st) const PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	472
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7458 diff changeset	473 // method parameters
8068 56c364daccc3 8007153: Ensure that MethodParameters API works properly with RedefineClasses emc parents: 8031 diff changeset	474 bool has_method_parameters() const
56c364daccc3 8007153: Ensure that MethodParameters API works properly with RedefineClasses emc parents: 8031 diff changeset	475 { return constMethod()->has_method_parameters(); }
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7458 diff changeset	476 int method_parameters_length() const
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7458 diff changeset	477 { return constMethod()->method_parameters_length(); }
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7458 diff changeset	478 MethodParametersElement* method_parameters_start() const
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7458 diff changeset	479 { return constMethod()->method_parameters_start(); }
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7458 diff changeset	480
0 a61af66fc99e Initial load duke parents: diff changeset	481 // checked exceptions
a61af66fc99e Initial load duke parents: diff changeset	482 int checked_exceptions_length() const
a61af66fc99e Initial load duke parents: diff changeset	483 { return constMethod()->checked_exceptions_length(); }
a61af66fc99e Initial load duke parents: diff changeset	484 CheckedExceptionElement* checked_exceptions_start() const
a61af66fc99e Initial load duke parents: diff changeset	485 { return constMethod()->checked_exceptions_start(); }
a61af66fc99e Initial load duke parents: diff changeset	486
a61af66fc99e Initial load duke parents: diff changeset	487 // localvariable table
a61af66fc99e Initial load duke parents: diff changeset	488 bool has_localvariable_table() const
a61af66fc99e Initial load duke parents: diff changeset	489 { return constMethod()->has_localvariable_table(); }
a61af66fc99e Initial load duke parents: diff changeset	490 int localvariable_table_length() const
a61af66fc99e Initial load duke parents: diff changeset	491 { return constMethod()->localvariable_table_length(); }
a61af66fc99e Initial load duke parents: diff changeset	492 LocalVariableTableElement* localvariable_table_start() const
a61af66fc99e Initial load duke parents: diff changeset	493 { return constMethod()->localvariable_table_start(); }
a61af66fc99e Initial load duke parents: diff changeset	494
a61af66fc99e Initial load duke parents: diff changeset	495 bool has_linenumber_table() const
a61af66fc99e Initial load duke parents: diff changeset	496 { return constMethod()->has_linenumber_table(); }
a61af66fc99e Initial load duke parents: diff changeset	497 u_char* compressed_linenumber_table() const
a61af66fc99e Initial load duke parents: diff changeset	498 { return constMethod()->compressed_linenumber_table(); }
a61af66fc99e Initial load duke parents: diff changeset	499
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	500 // method holder (the Klass* holding this method)
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	501 InstanceKlass* method_holder() const { return constants()->pool_holder(); }
0 a61af66fc99e Initial load duke parents: diff changeset	502
a61af66fc99e Initial load duke parents: diff changeset	503 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	504 Symbol* klass_name() const; // returns the name of the method holder
0 a61af66fc99e Initial load duke parents: diff changeset	505 BasicType result_type() const; // type of the method result
a61af66fc99e Initial load duke parents: diff changeset	506 int result_type_index() const; // type index of the method result
a61af66fc99e Initial load duke parents: diff changeset	507 bool is_returning_oop() const { BasicType r = result_type(); return (r == T_OBJECT \|\| r == T_ARRAY); }
a61af66fc99e Initial load duke parents: diff changeset	508 bool is_returning_fp() const { BasicType r = result_type(); return (r == T_FLOAT \|\| r == T_DOUBLE); }
a61af66fc99e Initial load duke parents: diff changeset	509
a61af66fc99e Initial load duke parents: diff changeset	510 // Checked exceptions thrown by this method (resolved to mirrors)
a61af66fc99e Initial load duke parents: diff changeset	511 objArrayHandle resolved_checked_exceptions(TRAPS) { return resolved_checked_exceptions_impl(this, THREAD); }
a61af66fc99e Initial load duke parents: diff changeset	512
a61af66fc99e Initial load duke parents: diff changeset	513 // Access flags
a61af66fc99e Initial load duke parents: diff changeset	514 bool is_public() const { return access_flags().is_public(); }
a61af66fc99e Initial load duke parents: diff changeset	515 bool is_private() const { return access_flags().is_private(); }
a61af66fc99e Initial load duke parents: diff changeset	516 bool is_protected() const { return access_flags().is_protected(); }
a61af66fc99e Initial load duke parents: diff changeset	517 bool is_package_private() const { return !is_public() && !is_private() && !is_protected(); }
a61af66fc99e Initial load duke parents: diff changeset	518 bool is_static() const { return access_flags().is_static(); }
a61af66fc99e Initial load duke parents: diff changeset	519 bool is_final() const { return access_flags().is_final(); }
a61af66fc99e Initial load duke parents: diff changeset	520 bool is_synchronized() const { return access_flags().is_synchronized();}
a61af66fc99e Initial load duke parents: diff changeset	521 bool is_native() const { return access_flags().is_native(); }
a61af66fc99e Initial load duke parents: diff changeset	522 bool is_abstract() const { return access_flags().is_abstract(); }
a61af66fc99e Initial load duke parents: diff changeset	523 bool is_strict() const { return access_flags().is_strict(); }
a61af66fc99e Initial load duke parents: diff changeset	524 bool is_synthetic() const { return access_flags().is_synthetic(); }
a61af66fc99e Initial load duke parents: diff changeset	525
a61af66fc99e Initial load duke parents: diff changeset	526 // returns true if contains only return operation
a61af66fc99e Initial load duke parents: diff changeset	527 bool is_empty_method() const;
a61af66fc99e Initial load duke parents: diff changeset	528
a61af66fc99e Initial load duke parents: diff changeset	529 // returns true if this is a vanilla constructor
a61af66fc99e Initial load duke parents: diff changeset	530 bool is_vanilla_constructor() const;
a61af66fc99e Initial load duke parents: diff changeset	531
a61af66fc99e Initial load duke parents: diff changeset	532 // checks method and its method holder
a61af66fc99e Initial load duke parents: diff changeset	533 bool is_final_method() const;
a61af66fc99e Initial load duke parents: diff changeset	534 bool is_strict_method() const;
a61af66fc99e Initial load duke parents: diff changeset	535
a61af66fc99e Initial load duke parents: diff changeset	536 // true if method needs no dynamic dispatch (final and/or no vtable entry)
a61af66fc99e Initial load duke parents: diff changeset	537 bool can_be_statically_bound() const;
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539 // returns true if the method has any backward branches.
a61af66fc99e Initial load duke parents: diff changeset	540 bool has_loops() {
a61af66fc99e Initial load duke parents: diff changeset	541 return access_flags().loops_flag_init() ? access_flags().has_loops() : compute_has_loops_flag();
a61af66fc99e Initial load duke parents: diff changeset	542 };
a61af66fc99e Initial load duke parents: diff changeset	543
a61af66fc99e Initial load duke parents: diff changeset	544 bool compute_has_loops_flag();
a61af66fc99e Initial load duke parents: diff changeset	545
a61af66fc99e Initial load duke parents: diff changeset	546 bool has_jsrs() {
a61af66fc99e Initial load duke parents: diff changeset	547 return access_flags().has_jsrs();
a61af66fc99e Initial load duke parents: diff changeset	548 };
a61af66fc99e Initial load duke parents: diff changeset	549 void set_has_jsrs() {
a61af66fc99e Initial load duke parents: diff changeset	550 _access_flags.set_has_jsrs();
a61af66fc99e Initial load duke parents: diff changeset	551 }
a61af66fc99e Initial load duke parents: diff changeset	552
a61af66fc99e Initial load duke parents: diff changeset	553 // returns true if the method has any monitors.
a61af66fc99e Initial load duke parents: diff changeset	554 bool has_monitors() const { return is_synchronized() \|\| access_flags().has_monitor_bytecodes(); }
a61af66fc99e Initial load duke parents: diff changeset	555 bool has_monitor_bytecodes() const { return access_flags().has_monitor_bytecodes(); }
a61af66fc99e Initial load duke parents: diff changeset	556
a61af66fc99e Initial load duke parents: diff changeset	557 void set_has_monitor_bytecodes() { _access_flags.set_has_monitor_bytecodes(); }
a61af66fc99e Initial load duke parents: diff changeset	558
a61af66fc99e Initial load duke parents: diff changeset	559 // monitor matching. This returns a conservative estimate of whether the monitorenter/monitorexit bytecodes
a61af66fc99e Initial load duke parents: diff changeset	560 // propererly nest in the method. It might return false, even though they actually nest properly, since the info.
a61af66fc99e Initial load duke parents: diff changeset	561 // has not been computed yet.
a61af66fc99e Initial load duke parents: diff changeset	562 bool guaranteed_monitor_matching() const { return access_flags().is_monitor_matching(); }
a61af66fc99e Initial load duke parents: diff changeset	563 void set_guaranteed_monitor_matching() { _access_flags.set_monitor_matching(); }
a61af66fc99e Initial load duke parents: diff changeset	564
a61af66fc99e Initial load duke parents: diff changeset	565 // returns true if the method is an accessor function (setter/getter).
a61af66fc99e Initial load duke parents: diff changeset	566 bool is_accessor() const;
a61af66fc99e Initial load duke parents: diff changeset	567
a61af66fc99e Initial load duke parents: diff changeset	568 // returns true if the method is an initializer (<init> or <clinit>).
a61af66fc99e Initial load duke parents: diff changeset	569 bool is_initializer() const;
a61af66fc99e Initial load duke parents: diff changeset	570
2334 dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process kamg parents: 2243 diff changeset	571 // 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	572 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	573
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process kamg parents: 2243 diff changeset	574 // 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	575 // 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	576 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	577
0 a61af66fc99e Initial load duke parents: diff changeset	578 // compiled code support
a61af66fc99e Initial load duke parents: diff changeset	579 // NOTE: code() is inherently racy as deopt can be clearing code
a61af66fc99e Initial load duke parents: diff changeset	580 // simultaneously. Use with caution.
a61af66fc99e Initial load duke parents: diff changeset	581 bool has_compiled_code() const { return code() != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	582
a61af66fc99e Initial load duke parents: diff changeset	583 // sizing
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	584 static int header_size() { return sizeof(Method)/HeapWordSize; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	585 static int size(bool is_native);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	586 int size() const { return method_size(); }
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7470 diff changeset	587 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7470 diff changeset	588 void collect_statistics(KlassSizeStats *sz) const;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7470 diff changeset	589 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	590
a61af66fc99e Initial load duke parents: diff changeset	591 // interpreter support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	592 static ByteSize const_offset() { return byte_offset_of(Method, _constMethod ); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	593 static ByteSize access_flags_offset() { return byte_offset_of(Method, _access_flags ); }
0 a61af66fc99e Initial load duke parents: diff changeset	594 #ifdef CC_INTERP
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	595 static ByteSize result_index_offset() { return byte_offset_of(Method, _result_index ); }
0 a61af66fc99e Initial load duke parents: diff changeset	596 #endif /* CC_INTERP */
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	597 static ByteSize from_compiled_offset() { return byte_offset_of(Method, _from_compiled_entry); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	598 static ByteSize code_offset() { return byte_offset_of(Method, _code); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	599 static ByteSize invocation_counter_offset() { return byte_offset_of(Method, _invocation_counter); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	600 static ByteSize backedge_counter_offset() { return byte_offset_of(Method, _backedge_counter); }
0 a61af66fc99e Initial load duke parents: diff changeset	601 static ByteSize method_data_offset() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	602 return byte_offset_of(Method, _method_data);
0 a61af66fc99e Initial load duke parents: diff changeset	603 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	604 static ByteSize interpreter_invocation_counter_offset() { return byte_offset_of(Method, _interpreter_invocation_count); }
5176 af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	605 #ifdef GRAAL
6948 e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6275 6940 diff changeset	606 static ByteSize graal_invocation_time_offset() { return byte_offset_of(Method, _graal_invocation_time); }
e522a00b91aa Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works Doug Simon <doug.simon@oracle.com> parents: 6275 6940 diff changeset	607 static ByteSize graal_priority_offset() { return byte_offset_of(Method, _graal_priority); }
5176 af59b4dfc9e4 compilation queue changes: Lukas Stadler <lukas.stadler@jku.at> parents: 5062 diff changeset	608 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	609 #ifndef PRODUCT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	610 static ByteSize compiled_invocation_counter_offset() { return byte_offset_of(Method, _compiled_invocation_count); }
0 a61af66fc99e Initial load duke parents: diff changeset	611 #endif // not PRODUCT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	612 static ByteSize native_function_offset() { return in_ByteSize(sizeof(Method)); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	613 static ByteSize from_interpreted_offset() { return byte_offset_of(Method, _from_interpreted_entry ); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	614 static ByteSize interpreter_entry_offset() { return byte_offset_of(Method, _i2i_entry ); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	615 static ByteSize signature_handler_offset() { return in_ByteSize(sizeof(Method) + wordSize); }
0 a61af66fc99e Initial load duke parents: diff changeset	616
a61af66fc99e Initial load duke parents: diff changeset	617 // for code generation
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	618 static int method_data_offset_in_bytes() { return offset_of(Method, _method_data); }
0 a61af66fc99e Initial load duke parents: diff changeset	619 static int interpreter_invocation_counter_offset_in_bytes()
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	620 { return offset_of(Method, _interpreter_invocation_count); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	621 static int intrinsic_id_offset_in_bytes() { return offset_of(Method, _intrinsic_id); }
1793 d257356e35f0 6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions jrose parents: 1783 diff changeset	622 static int intrinsic_id_size_in_bytes() { return sizeof(u1); }
0 a61af66fc99e Initial load duke parents: diff changeset	623
a61af66fc99e Initial load duke parents: diff changeset	624 // Static methods that are used to implement member methods where an exposed this pointer
a61af66fc99e Initial load duke parents: diff changeset	625 // is needed due to possible GCs
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	626 static objArrayHandle resolved_checked_exceptions_impl(Method* this_oop, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	627
a61af66fc99e Initial load duke parents: diff changeset	628 // Returns the byte code index from the byte code pointer
a61af66fc99e Initial load duke parents: diff changeset	629 int bci_from(address bcp) const;
a61af66fc99e Initial load duke parents: diff changeset	630 address bcp_from(int bci) const;
a61af66fc99e Initial load duke parents: diff changeset	631 int validate_bci_from_bcx(intptr_t bcx) const;
a61af66fc99e Initial load duke parents: diff changeset	632
a61af66fc99e Initial load duke parents: diff changeset	633 // Returns the line number for a bci if debugging information for the method is prowided,
a61af66fc99e Initial load duke parents: diff changeset	634 // -1 is returned otherwise.
a61af66fc99e Initial load duke parents: diff changeset	635 int line_number_from_bci(int bci) const;
a61af66fc99e Initial load duke parents: diff changeset	636
a61af66fc99e Initial load duke parents: diff changeset	637 // Reflection support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	638 bool is_overridden_in(Klass* k) const;
0 a61af66fc99e Initial load duke parents: diff changeset	639
8866 16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	640 // Stack walking support
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	641 bool is_ignored_by_security_stack_walk() const;
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	642
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 628 diff changeset	643 // JSR 292 support
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6227 diff changeset	644 bool is_method_handle_intrinsic() const; // MethodHandles::is_signature_polymorphic_intrinsic(intrinsic_id)
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6227 diff changeset	645 bool is_compiled_lambda_form() const; // intrinsic_id() == vmIntrinsics::_compiledLambdaForm
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6227 diff changeset	646 bool has_member_arg() const; // intrinsic_id() == vmIntrinsics::_linkToSpecial, etc.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6227 diff changeset	647 static methodHandle make_method_handle_intrinsic(vmIntrinsics::ID iid, // _invokeBasic, _linkToVirtual
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6227 diff changeset	648 Symbol* signature, //anything at all
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6227 diff changeset	649 TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	650 static Klass* check_non_bcp_klass(Klass* klass);
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 628 diff changeset	651 // these operate only on invoke methods:
e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 628 diff changeset	652 // 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	653 // 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	654 // 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	655 // all without checking for a stack overflow
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6227 diff changeset	656 static int extra_stack_entries() { return EnableInvokeDynamic ? 2 : 0; }
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 628 diff changeset	657 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	658
0 a61af66fc99e Initial load duke parents: diff changeset	659 // RedefineClasses() support:
a61af66fc99e Initial load duke parents: diff changeset	660 bool is_old() const { return access_flags().is_old(); }
a61af66fc99e Initial load duke parents: diff changeset	661 void set_is_old() { _access_flags.set_is_old(); }
a61af66fc99e Initial load duke parents: diff changeset	662 bool is_obsolete() const { return access_flags().is_obsolete(); }
a61af66fc99e Initial load duke parents: diff changeset	663 void set_is_obsolete() { _access_flags.set_is_obsolete(); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	664 bool on_stack() const { return access_flags().on_stack(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	665 void set_on_stack(const bool value);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	666
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	667 // see the definition in Method*.cpp for the gory details
48 d8b3ef7ee3e5 6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure dcubed parents: 0 diff changeset	668 bool should_not_be_cached() const;
0 a61af66fc99e Initial load duke parents: diff changeset	669
a61af66fc99e Initial load duke parents: diff changeset	670 // JVMTI Native method prefixing support:
a61af66fc99e Initial load duke parents: diff changeset	671 bool is_prefixed_native() const { return access_flags().is_prefixed_native(); }
a61af66fc99e Initial load duke parents: diff changeset	672 void set_is_prefixed_native() { _access_flags.set_is_prefixed_native(); }
a61af66fc99e Initial load duke parents: diff changeset	673
a61af66fc99e Initial load duke parents: diff changeset	674 // Rewriting support
a61af66fc99e Initial load duke parents: diff changeset	675 static methodHandle clone_with_new_data(methodHandle m, u_char* new_code, int new_code_length,
a61af66fc99e Initial load duke parents: diff changeset	676 u_char* new_compressed_linenumber_table, int new_compressed_linenumber_size, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	677
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	678 // jmethodID handling
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	679 // Because the useful life-span of a jmethodID cannot be determined,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	680 // once created they are never reclaimed. The methods to which they refer,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	681 // however, can be GC'ed away if the class is unloaded or if the method is
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	682 // made obsolete or deleted -- in these cases, the jmethodID
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	683 // refers to NULL (as is the case for any weak reference).
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	684 static jmethodID make_jmethod_id(ClassLoaderData* loader_data, Method* mh);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	685 static void destroy_jmethod_id(ClassLoaderData* loader_data, jmethodID mid);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	686
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	687 // Use resolve_jmethod_id() in situations where the caller is expected
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	688 // to provide a valid jmethodID; the only sanity checks are in asserts;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	689 // result guaranteed not to be NULL.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	690 inline static Method* resolve_jmethod_id(jmethodID mid) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	691 assert(mid != NULL, "JNI method id should not be null");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	692 return ((Method*)mid);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	693 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	694
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	695 // Use checked_resolve_jmethod_id() in situations where the caller
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	696 // should provide a valid jmethodID, but might not. NULL is returned
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	697 // when the jmethodID does not refer to a valid method.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	698 static Method* checked_resolve_jmethod_id(jmethodID mid);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	699
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	700 static void change_method_associated_with_jmethod_id(jmethodID old_jmid_ptr, Method* new_method);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	701 static bool is_method_id(jmethodID mid);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	702
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	703 // Clear methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	704 static void clear_jmethod_ids(ClassLoaderData* loader_data);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	705 static void print_jmethod_ids(ClassLoaderData* loader_data, outputStream* out) PRODUCT_RETURN;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	706
0 a61af66fc99e Initial load duke parents: diff changeset	707 // Get this method's jmethodID -- allocate if it doesn't exist
a61af66fc99e Initial load duke parents: diff changeset	708 jmethodID jmethod_id() { methodHandle this_h(this);
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	709 return InstanceKlass::get_jmethod_id(method_holder(), this_h); }
0 a61af66fc99e Initial load duke parents: diff changeset	710
a61af66fc99e Initial load duke parents: diff changeset	711 // Lookup the jmethodID for this method. Return NULL if not found.
a61af66fc99e Initial load duke parents: diff changeset	712 // NOTE that this function can be called from a signal handler
a61af66fc99e Initial load duke parents: diff changeset	713 // (see AsyncGetCallTrace support for Forte Analyzer) and this
a61af66fc99e Initial load duke parents: diff changeset	714 // needs to be async-safe. No allocation should be done and
a61af66fc99e Initial load duke parents: diff changeset	715 // so handles are not used to avoid deadlock.
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	716 jmethodID find_jmethod_id_or_null() { return method_holder()->jmethod_id_or_null(this); }
0 a61af66fc99e Initial load duke parents: diff changeset	717
a61af66fc99e Initial load duke parents: diff changeset	718 // JNI static invoke cached itable index accessors
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	719 int cached_itable_index() { return method_holder()->cached_itable_index(method_idnum()); }
18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	720 void set_cached_itable_index(int index) { method_holder()->set_cached_itable_index(method_idnum(), index); }
0 a61af66fc99e Initial load duke parents: diff changeset	721
a61af66fc99e Initial load duke parents: diff changeset	722 // Support for inlining of intrinsic methods
856 75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics jrose parents: 726 diff changeset	723 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	724 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	725
75596850f863 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics jrose parents: 726 diff changeset	726 // 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	727 void init_intrinsic_id(); // updates from _none if a match
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	728 static vmSymbols::SID klass_id_for_intrinsics(Klass* holder);
0 a61af66fc99e Initial load duke parents: diff changeset	729
8866 16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	730 bool jfr_towrite() { return _jfr_towrite; }
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	731 void set_jfr_towrite(bool x) { _jfr_towrite = x; }
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	732 bool caller_sensitive() { return _caller_sensitive; }
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	733 void set_caller_sensitive(bool x) { _caller_sensitive = x; }
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	734 bool force_inline() { return _force_inline; }
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	735 void set_force_inline(bool x) { _force_inline = x; }
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	736 bool dont_inline() { return _dont_inline; }
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	737 void set_dont_inline(bool x) { _dont_inline = x; }
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	738 bool is_hidden() { return _hidden; }
16885e702c88 7198429: need checked categorization of caller-sensitive methods in the JDK twisti parents: 8068 diff changeset	739 void set_hidden(bool x) { _hidden = x; }
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6800 diff changeset	740 ConstMethod::MethodType method_type() const {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6800 diff changeset	741 return _constMethod->method_type();
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6800 diff changeset	742 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6800 diff changeset	743 bool is_overpass() const { return method_type() == ConstMethod::OVERPASS; }
6222 6d8f36bcef55 6711908: JVM needs direct access to some annotations jrose parents: 6146 diff changeset	744
0 a61af66fc99e Initial load duke parents: diff changeset	745 // On-stack replacement support
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	746 bool has_osr_nmethod(int level, bool match_level) {
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	747 return method_holder()->lookup_osr_nmethod(this, InvocationEntryBci, level, match_level) != NULL;
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	748 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	749
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	750 nmethod* lookup_osr_nmethod_for(int bci, int level, bool match_level) {
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	751 return method_holder()->lookup_osr_nmethod(this, bci, level, match_level);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	752 }
0 a61af66fc99e Initial load duke parents: diff changeset	753
a61af66fc99e Initial load duke parents: diff changeset	754 // Inline cache support
a61af66fc99e Initial load duke parents: diff changeset	755 void cleanup_inline_caches();
a61af66fc99e Initial load duke parents: diff changeset	756
a61af66fc99e Initial load duke parents: diff changeset	757 // Find if klass for method is loaded
a61af66fc99e Initial load duke parents: diff changeset	758 bool is_klass_loaded_by_klass_index(int klass_index) const;
a61af66fc99e Initial load duke parents: diff changeset	759 bool is_klass_loaded(int refinfo_index, bool must_be_resolved = false) const;
a61af66fc99e Initial load duke parents: diff changeset	760
a61af66fc99e Initial load duke parents: diff changeset	761 // Indicates whether compilation failed earlier for this method, or
a61af66fc99e Initial load duke parents: diff changeset	762 // whether it is not compilable for another reason like having a
a61af66fc99e Initial load duke parents: diff changeset	763 // breakpoint set in it.
6800 9191895df19d 7200001: failed C1 OSR compile doesn't get recompiled with C2 twisti parents: 6733 diff changeset	764 bool is_not_compilable(int comp_level = CompLevel_any) const;
7998 6a51fc70a15e 8006613: adding reason to made_not_compilable vlivanov parents: 7470 diff changeset	765 void set_not_compilable(int comp_level = CompLevel_all, bool report = true, const char* reason = NULL);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	766 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	767 set_not_compilable(comp_level, false);
cef333a48af6 6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly kvn parents: 1202 diff changeset	768 }
6800 9191895df19d 7200001: failed C1 OSR compile doesn't get recompiled with C2 twisti parents: 6733 diff changeset	769 bool is_not_osr_compilable(int comp_level = CompLevel_any) const;
7998 6a51fc70a15e 8006613: adding reason to made_not_compilable vlivanov parents: 7470 diff changeset	770 void set_not_osr_compilable(int comp_level = CompLevel_all, bool report = true, const char* reason = NULL);
6800 9191895df19d 7200001: failed C1 OSR compile doesn't get recompiled with C2 twisti parents: 6733 diff changeset	771 void set_not_osr_compilable_quietly(int comp_level = CompLevel_all) {
9191895df19d 7200001: failed C1 OSR compile doesn't get recompiled with C2 twisti parents: 6733 diff changeset	772 set_not_osr_compilable(comp_level, false);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	773 }
6800 9191895df19d 7200001: failed C1 OSR compile doesn't get recompiled with C2 twisti parents: 6733 diff changeset	774
9191895df19d 7200001: failed C1 OSR compile doesn't get recompiled with C2 twisti parents: 6733 diff changeset	775 private:
7998 6a51fc70a15e 8006613: adding reason to made_not_compilable vlivanov parents: 7470 diff changeset	776 void print_made_not_compilable(int comp_level, bool is_osr, bool report, const char* reason);
6800 9191895df19d 7200001: failed C1 OSR compile doesn't get recompiled with C2 twisti parents: 6733 diff changeset	777
9191895df19d 7200001: failed C1 OSR compile doesn't get recompiled with C2 twisti parents: 6733 diff changeset	778 public:
9080 b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	779 bool is_not_c1_compilable() const { return access_flags().is_not_c1_compilable(); }
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	780 void set_not_c1_compilable() { _access_flags.set_not_c1_compilable(); }
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	781 void clear_not_c1_compilable() { _access_flags.clear_not_c1_compilable(); }
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	782 bool is_not_c2_compilable() const { return access_flags().is_not_c2_compilable(); }
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	783 void set_not_c2_compilable() { _access_flags.set_not_c2_compilable(); }
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	784 void clear_not_c2_compilable() { _access_flags.clear_not_c2_compilable(); }
6800 9191895df19d 7200001: failed C1 OSR compile doesn't get recompiled with C2 twisti parents: 6733 diff changeset	785
9080 b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	786 bool is_not_c1_osr_compilable() const { return is_not_c1_compilable(); } // don't waste an accessFlags bit
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	787 void set_not_c1_osr_compilable() { set_not_c1_compilable(); } // don't waste an accessFlags bit
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	788 void clear_not_c1_osr_compilable() { clear_not_c1_compilable(); } // don't waste an accessFlags bit
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	789 bool is_not_c2_osr_compilable() const { return access_flags().is_not_c2_osr_compilable(); }
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	790 void set_not_c2_osr_compilable() { _access_flags.set_not_c2_osr_compilable(); }
b84fd7d73702 8007288: Additional WB API for compiler's testing iignatyev parents: 8866 diff changeset	791 void clear_not_c2_osr_compilable() { _access_flags.clear_not_c2_osr_compilable(); }
0 a61af66fc99e Initial load duke parents: diff changeset	792
a61af66fc99e Initial load duke parents: diff changeset	793 // Background compilation support
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	794 bool queued_for_compilation() const { return access_flags().queued_for_compilation(); }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	795 void set_queued_for_compilation() { _access_flags.set_queued_for_compilation(); }
d5d065957597 6953144: Tiered compilation iveresov parents: 1552 diff changeset	796 void clear_queued_for_compilation() { _access_flags.clear_queued_for_compilation(); }
0 a61af66fc99e Initial load duke parents: diff changeset	797
a61af66fc99e Initial load duke parents: diff changeset	798 // Resolve all classes in signature, return 'true' if successful
a61af66fc99e Initial load duke parents: diff changeset	799 static bool load_signature_classes(methodHandle m, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	800
a61af66fc99e Initial load duke parents: diff changeset	801 // Return if true if not all classes references in signature, including return type, has been loaded
a61af66fc99e Initial load duke parents: diff changeset	802 static bool has_unloaded_classes_in_signature(methodHandle m, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	803
a61af66fc99e Initial load duke parents: diff changeset	804 // Printing
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 7969 diff changeset	805 void print_short_name(outputStream* st = tty); // prints as klassname::methodname; Exposed so field engineers can debug VM
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 7969 diff changeset	806 #if INCLUDE_JVMTI
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 7969 diff changeset	807 void print_name(outputStream* st = tty); // prints as "virtual void foo(int)"; exposed for TraceRedefineClasses
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 7969 diff changeset	808 #else
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6227 diff changeset	809 void print_name(outputStream* st = tty) PRODUCT_RETURN; // prints as "virtual void foo(int)"
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 7969 diff changeset	810 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	811
a61af66fc99e Initial load duke parents: diff changeset	812 // Helper routine used for method sorting
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8025 diff changeset	813 static void sort_methods(Array<Method> methods, bool idempotent = false);
0 a61af66fc99e Initial load duke parents: diff changeset	814
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	815 // Deallocation function for redefine classes or if an error occurs
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	816 void deallocate_contents(ClassLoaderData* loader_data);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	817
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	818 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	819 #ifndef PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	820 void print_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	821 #endif
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	822 void print_value_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	823
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	824 const char* internal_name() const { return "{method}"; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	825
7176 59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6940 diff changeset	826 // Check for valid method pointer
59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6940 diff changeset	827 bool is_valid_method() const;
59c790074993 8003635: NPG: AsynchGetCallTrace broken by Method* virtual call coleenp parents: 6940 diff changeset	828
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	829 // Verify
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	830 void verify() { verify_on(tty); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	831 void verify_on(outputStream* st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	832
0 a61af66fc99e Initial load duke parents: diff changeset	833 private:
a61af66fc99e Initial load duke parents: diff changeset	834
a61af66fc99e Initial load duke parents: diff changeset	835 // Inlined elements
a61af66fc99e Initial load duke parents: diff changeset	836 address* native_function_addr() const { assert(is_native(), "must be native"); return (address*) (this+1); }
a61af66fc99e Initial load duke parents: diff changeset	837 address* signature_handler_addr() const { return native_function_addr() + 1; }
a61af66fc99e Initial load duke parents: diff changeset	838 };
a61af66fc99e Initial load duke parents: diff changeset	839
a61af66fc99e Initial load duke parents: diff changeset	840
a61af66fc99e Initial load duke parents: diff changeset	841 // Utility class for compressing line number tables
a61af66fc99e Initial load duke parents: diff changeset	842
a61af66fc99e Initial load duke parents: diff changeset	843 class CompressedLineNumberWriteStream: public CompressedWriteStream {
a61af66fc99e Initial load duke parents: diff changeset	844 private:
a61af66fc99e Initial load duke parents: diff changeset	845 int _bci;
a61af66fc99e Initial load duke parents: diff changeset	846 int _line;
a61af66fc99e Initial load duke parents: diff changeset	847 public:
a61af66fc99e Initial load duke parents: diff changeset	848 // Constructor
a61af66fc99e Initial load duke parents: diff changeset	849 CompressedLineNumberWriteStream(int initial_size) : CompressedWriteStream(initial_size), _bci(0), _line(0) {}
a61af66fc99e Initial load duke parents: diff changeset	850 CompressedLineNumberWriteStream(u_char* buffer, int initial_size) : CompressedWriteStream(buffer, initial_size), _bci(0), _line(0) {}
a61af66fc99e Initial load duke parents: diff changeset	851
a61af66fc99e Initial load duke parents: diff changeset	852 // Write (bci, line number) pair to stream
a61af66fc99e Initial load duke parents: diff changeset	853 void write_pair_regular(int bci_delta, int line_delta);
a61af66fc99e Initial load duke parents: diff changeset	854
a61af66fc99e Initial load duke parents: diff changeset	855 inline void write_pair_inline(int bci, int line) {
a61af66fc99e Initial load duke parents: diff changeset	856 int bci_delta = bci - _bci;
a61af66fc99e Initial load duke parents: diff changeset	857 int line_delta = line - _line;
a61af66fc99e Initial load duke parents: diff changeset	858 _bci = bci;
a61af66fc99e Initial load duke parents: diff changeset	859 _line = line;
a61af66fc99e Initial load duke parents: diff changeset	860 // Skip (0,0) deltas - they do not add information and conflict with terminator.
a61af66fc99e Initial load duke parents: diff changeset	861 if (bci_delta == 0 && line_delta == 0) return;
a61af66fc99e Initial load duke parents: diff changeset	862 // Check if bci is 5-bit and line number 3-bit unsigned.
a61af66fc99e Initial load duke parents: diff changeset	863 if (((bci_delta & ~0x1F) == 0) && ((line_delta & ~0x7) == 0)) {
a61af66fc99e Initial load duke parents: diff changeset	864 // Compress into single byte.
a61af66fc99e Initial load duke parents: diff changeset	865 jubyte value = ((jubyte) bci_delta << 3) \| (jubyte) line_delta;
a61af66fc99e Initial load duke parents: diff changeset	866 // Check that value doesn't match escape character.
a61af66fc99e Initial load duke parents: diff changeset	867 if (value != 0xFF) {
a61af66fc99e Initial load duke parents: diff changeset	868 write_byte(value);
a61af66fc99e Initial load duke parents: diff changeset	869 return;
a61af66fc99e Initial load duke parents: diff changeset	870 }
a61af66fc99e Initial load duke parents: diff changeset	871 }
a61af66fc99e Initial load duke parents: diff changeset	872 write_pair_regular(bci_delta, line_delta);
a61af66fc99e Initial load duke parents: diff changeset	873 }
a61af66fc99e Initial load duke parents: diff changeset	874
a61af66fc99e Initial load duke parents: diff changeset	875 // Windows AMD64 + Apr 2005 PSDK with /O2 generates bad code for write_pair.
a61af66fc99e Initial load duke parents: diff changeset	876 // Disabling optimization doesn't work for methods in header files
a61af66fc99e Initial load duke parents: diff changeset	877 // so we force it to call through the non-optimized version in the .cpp.
a61af66fc99e Initial load duke parents: diff changeset	878 // 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	879 // 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	880 #if defined(_M_AMD64) && _MSC_VER >= 1400
0 a61af66fc99e Initial load duke parents: diff changeset	881 void write_pair(int bci, int line);
a61af66fc99e Initial load duke parents: diff changeset	882 #else
a61af66fc99e Initial load duke parents: diff changeset	883 void write_pair(int bci, int line) { write_pair_inline(bci, line); }
a61af66fc99e Initial load duke parents: diff changeset	884 #endif
a61af66fc99e Initial load duke parents: diff changeset	885
a61af66fc99e Initial load duke parents: diff changeset	886 // Write end-of-stream marker
a61af66fc99e Initial load duke parents: diff changeset	887 void write_terminator() { write_byte(0); }
a61af66fc99e Initial load duke parents: diff changeset	888 };
a61af66fc99e Initial load duke parents: diff changeset	889
a61af66fc99e Initial load duke parents: diff changeset	890
a61af66fc99e Initial load duke parents: diff changeset	891 // Utility class for decompressing line number tables
a61af66fc99e Initial load duke parents: diff changeset	892
a61af66fc99e Initial load duke parents: diff changeset	893 class CompressedLineNumberReadStream: public CompressedReadStream {
a61af66fc99e Initial load duke parents: diff changeset	894 private:
a61af66fc99e Initial load duke parents: diff changeset	895 int _bci;
a61af66fc99e Initial load duke parents: diff changeset	896 int _line;
a61af66fc99e Initial load duke parents: diff changeset	897 public:
a61af66fc99e Initial load duke parents: diff changeset	898 // Constructor
a61af66fc99e Initial load duke parents: diff changeset	899 CompressedLineNumberReadStream(u_char* buffer);
a61af66fc99e Initial load duke parents: diff changeset	900 // Read (bci, line number) pair from stream. Returns false at end-of-stream.
a61af66fc99e Initial load duke parents: diff changeset	901 bool read_pair();
a61af66fc99e Initial load duke parents: diff changeset	902 // Accessing bci and line number (after calling read_pair)
a61af66fc99e Initial load duke parents: diff changeset	903 int bci() const { return _bci; }
a61af66fc99e Initial load duke parents: diff changeset	904 int line() const { return _line; }
a61af66fc99e Initial load duke parents: diff changeset	905 };
a61af66fc99e Initial load duke parents: diff changeset	906
a61af66fc99e Initial load duke parents: diff changeset	907
a61af66fc99e Initial load duke parents: diff changeset	908 /// Fast Breakpoints.
a61af66fc99e Initial load duke parents: diff changeset	909
a61af66fc99e Initial load duke parents: diff changeset	910 // If this structure gets more complicated (because bpts get numerous),
a61af66fc99e Initial load duke parents: diff changeset	911 // move it into its own header.
a61af66fc99e Initial load duke parents: diff changeset	912
a61af66fc99e Initial load duke parents: diff changeset	913 // There is presently no provision for concurrent access
a61af66fc99e Initial load duke parents: diff changeset	914 // to breakpoint lists, which is only OK for JVMTI because
a61af66fc99e Initial load duke parents: diff changeset	915 // breakpoints are written only at safepoints, and are read
a61af66fc99e Initial load duke parents: diff changeset	916 // concurrently only outside of safepoints.
a61af66fc99e Initial load duke parents: diff changeset	917
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6146 diff changeset	918 class BreakpointInfo : public CHeapObj<mtClass> {
0 a61af66fc99e Initial load duke parents: diff changeset	919 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	920 private:
a61af66fc99e Initial load duke parents: diff changeset	921 Bytecodes::Code _orig_bytecode;
a61af66fc99e Initial load duke parents: diff changeset	922 int _bci;
a61af66fc99e Initial load duke parents: diff changeset	923 u2 _name_index; // of method
a61af66fc99e Initial load duke parents: diff changeset	924 u2 _signature_index; // of method
a61af66fc99e Initial load duke parents: diff changeset	925 BreakpointInfo* _next; // simple storage allocation
a61af66fc99e Initial load duke parents: diff changeset	926
a61af66fc99e Initial load duke parents: diff changeset	927 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	928 BreakpointInfo(Method* m, int bci);
0 a61af66fc99e Initial load duke parents: diff changeset	929
a61af66fc99e Initial load duke parents: diff changeset	930 // accessors
a61af66fc99e Initial load duke parents: diff changeset	931 Bytecodes::Code orig_bytecode() { return _orig_bytecode; }
a61af66fc99e Initial load duke parents: diff changeset	932 void set_orig_bytecode(Bytecodes::Code code) { _orig_bytecode = code; }
a61af66fc99e Initial load duke parents: diff changeset	933 int bci() { return _bci; }
a61af66fc99e Initial load duke parents: diff changeset	934
a61af66fc99e Initial load duke parents: diff changeset	935 BreakpointInfo* next() const { return _next; }
a61af66fc99e Initial load duke parents: diff changeset	936 void set_next(BreakpointInfo* n) { _next = n; }
a61af66fc99e Initial load duke parents: diff changeset	937
a61af66fc99e Initial load duke parents: diff changeset	938 // helps for searchers
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	939 bool match(const Method* m, int bci) {
0 a61af66fc99e Initial load duke parents: diff changeset	940 return bci == _bci && match(m);
a61af66fc99e Initial load duke parents: diff changeset	941 }
a61af66fc99e Initial load duke parents: diff changeset	942
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	943 bool match(const Method* m) {
0 a61af66fc99e Initial load duke parents: diff changeset	944 return _name_index == m->name_index() &&
a61af66fc99e Initial load duke parents: diff changeset	945 _signature_index == m->signature_index();
a61af66fc99e Initial load duke parents: diff changeset	946 }
a61af66fc99e Initial load duke parents: diff changeset	947
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	948 void set(Method* method);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	949 void clear(Method* method);
0 a61af66fc99e Initial load duke parents: diff changeset	950 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	951
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	952 // Utility class for access exception handlers
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	953 class ExceptionTable : public StackObj {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	954 private:
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	955 ExceptionTableElement* _table;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	956 u2 _length;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	957
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	958 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	959 ExceptionTable(Method* m) {
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	960 if (m->has_exception_handler()) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	961 _table = m->exception_table_start();
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	962 _length = m->exception_table_length();
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	963 } else {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	964 _table = NULL;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	965 _length = 0;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	966 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	967 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	968
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	969 int length() const {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	970 return _length;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	971 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	972
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	973 u2 start_pc(int idx) const {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	974 assert(idx < _length, "out of bounds");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	975 return _table[idx].start_pc;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	976 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	977
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	978 void set_start_pc(int idx, u2 value) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	979 assert(idx < _length, "out of bounds");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	980 _table[idx].start_pc = value;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	981 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	982
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	983 u2 end_pc(int idx) const {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	984 assert(idx < _length, "out of bounds");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	985 return _table[idx].end_pc;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	986 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	987
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	988 void set_end_pc(int idx, u2 value) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	989 assert(idx < _length, "out of bounds");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	990 _table[idx].end_pc = value;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	991 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	992
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	993 u2 handler_pc(int idx) const {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	994 assert(idx < _length, "out of bounds");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	995 return _table[idx].handler_pc;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	996 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	997
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	998 void set_handler_pc(int idx, u2 value) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	999 assert(idx < _length, "out of bounds");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1000 _table[idx].handler_pc = value;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1001 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1002
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1003 u2 catch_type_index(int idx) const {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1004 assert(idx < _length, "out of bounds");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1005 return _table[idx].catch_type_index;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1006 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1007
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1008 void set_catch_type_index(int idx, u2 value) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1009 assert(idx < _length, "out of bounds");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1010 _table[idx].catch_type_index = value;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1011 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1012 };
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6146 diff changeset	1013
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1877 diff changeset	1014 #endif // SHARE_VM_OOPS_METHODOOP_HPP

Mercurial > hg > truffle

annotate src/share/vm/oops/method.hpp @ 9126:bc26f978b0ce