graal-compiler: src/share/vm/oops/constMethod.hpp annotate

annotate src/share/vm/oops/constMethod.hpp @ 7588:f9eb431c3efe

8006005: Fix constant pool index validation and alignment trap for method parameter reflection Summary: This patch addresses an alignment trap due to the storage format of method parameters data in constMethod. It also adds code to validate constant pool indexes for method parameters data. Reviewed-by: jrose, dholmes Contributed-by: eric.mccorkle@oracle.com

author	coleenp
date	Mon, 14 Jan 2013 11:01:39 -0500
parents	ade95d680b42
children	16fb9f942703

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 1972 diff changeset	2 * Copyright (c) 2003, 2012, 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: 1138 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1138 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1138 diff changeset	21 * questions.
0 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: 1552 diff changeset	25 #ifndef SHARE_VM_OOPS_CONSTMETHODOOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #define SHARE_VM_OOPS_CONSTMETHODOOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "oops/oop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	30 // An ConstMethod* represents portions of a Java method which
0 a61af66fc99e Initial load duke parents: diff changeset	31 // do not vary.
a61af66fc99e Initial load duke parents: diff changeset	32 //
a61af66fc99e Initial load duke parents: diff changeset	33 // Memory layout (each line represents a word). Note that most
a61af66fc99e Initial load duke parents: diff changeset	34 // applications load thousands of methods, so keeping the size of this
a61af66fc99e Initial load duke parents: diff changeset	35 // structure small has a big impact on footprint.
a61af66fc99e Initial load duke parents: diff changeset	36 //
a61af66fc99e Initial load duke parents: diff changeset	37 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	38 // \| header \|
a61af66fc99e Initial load duke parents: diff changeset	39 // \| klass \|
a61af66fc99e Initial load duke parents: diff changeset	40 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	41 // \| fingerprint 1 \|
a61af66fc99e Initial load duke parents: diff changeset	42 // \| fingerprint 2 \|
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 1972 diff changeset	43 // \| constants (oop) \|
0 a61af66fc99e Initial load duke parents: diff changeset	44 // \| stackmap_data (oop) \|
a61af66fc99e Initial load duke parents: diff changeset	45 // \| constMethod_size \|
a61af66fc99e Initial load duke parents: diff changeset	46 // \| interp_kind \| flags \| code_size \|
a61af66fc99e Initial load duke parents: diff changeset	47 // \| name index \| signature index \|
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	48 // \| method_idnum \| max_stack \|
7402 fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	49 // \| max_locals \| size_of_parameters \|
0 a61af66fc99e Initial load duke parents: diff changeset	50 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	51 // \| \|
a61af66fc99e Initial load duke parents: diff changeset	52 // \| byte codes \|
a61af66fc99e Initial load duke parents: diff changeset	53 // \| \|
a61af66fc99e Initial load duke parents: diff changeset	54 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	55 // \| compressed linenumber table \|
a61af66fc99e Initial load duke parents: diff changeset	56 // \| (see class CompressedLineNumberReadStream) \|
a61af66fc99e Initial load duke parents: diff changeset	57 // \| (note that length is unknown until decompressed) \|
a61af66fc99e Initial load duke parents: diff changeset	58 // \| (access flags bit tells whether table is present) \|
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	59 // \| (indexed from start of ConstMethod*) \|
0 a61af66fc99e Initial load duke parents: diff changeset	60 // \| (elements not necessarily sorted!) \|
a61af66fc99e Initial load duke parents: diff changeset	61 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	62 // \| localvariable table elements + length (length last) \|
a61af66fc99e Initial load duke parents: diff changeset	63 // \| (length is u2, elements are 6-tuples of u2) \|
a61af66fc99e Initial load duke parents: diff changeset	64 // \| (see class LocalVariableTableElement) \|
a61af66fc99e Initial load duke parents: diff changeset	65 // \| (access flags bit tells whether table is present) \|
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	66 // \| (indexed from end of ConstMethod*) \|
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	67 // \|------------------------------------------------------\|
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	68 // \| exception table + length (length last) \|
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	69 // \| (length is u2, elements are 4-tuples of u2) \|
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	70 // \| (see class ExceptionTableElement) \|
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	71 // \| (access flags bit tells whether table is present) \|
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	72 // \| (indexed from end of ConstMethod*) \|
0 a61af66fc99e Initial load duke parents: diff changeset	73 // \|------------------------------------------------------\|
a61af66fc99e Initial load duke parents: diff changeset	74 // \| checked exceptions elements + length (length last) \|
a61af66fc99e Initial load duke parents: diff changeset	75 // \| (length is u2, elements are u2) \|
a61af66fc99e Initial load duke parents: diff changeset	76 // \| (see class CheckedExceptionElement) \|
a61af66fc99e Initial load duke parents: diff changeset	77 // \| (access flags bit tells whether table is present) \|
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	78 // \| (indexed from end of ConstMethod*) \|
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	79 // \|------------------------------------------------------\|
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	80 // \| method parameters elements + length (length last) \|
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	81 // \| (length is u2, elements are u2, u4 structures) \|
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	82 // \| (see class MethodParametersElement) \|
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	83 // \| (access flags bit tells whether table is present) \|
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	84 // \| (indexed from end of ConstMethod*) \|
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	85 // \|------------------------------------------------------\|
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	86 // \| generic signature index (u2) \|
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	87 // \| (indexed from start of constMethodOop) \|
0 a61af66fc99e Initial load duke parents: diff changeset	88 // \|------------------------------------------------------\|
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	89 //
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	90 // IMPORTANT: If anything gets added here, there need to be changes to
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	91 // ensure that ServicabilityAgent doesn't get broken as a result!
0 a61af66fc99e Initial load duke parents: diff changeset	92
a61af66fc99e Initial load duke parents: diff changeset	93
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	94 // Utitily class decribing elements in checked exceptions table inlined in Method*.
0 a61af66fc99e Initial load duke parents: diff changeset	95 class CheckedExceptionElement VALUE_OBJ_CLASS_SPEC {
a61af66fc99e Initial load duke parents: diff changeset	96 public:
a61af66fc99e Initial load duke parents: diff changeset	97 u2 class_cp_index;
a61af66fc99e Initial load duke parents: diff changeset	98 };
a61af66fc99e Initial load duke parents: diff changeset	99
a61af66fc99e Initial load duke parents: diff changeset	100
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	101 // Utitily class decribing elements in local variable table inlined in Method*.
0 a61af66fc99e Initial load duke parents: diff changeset	102 class LocalVariableTableElement VALUE_OBJ_CLASS_SPEC {
a61af66fc99e Initial load duke parents: diff changeset	103 public:
a61af66fc99e Initial load duke parents: diff changeset	104 u2 start_bci;
a61af66fc99e Initial load duke parents: diff changeset	105 u2 length;
a61af66fc99e Initial load duke parents: diff changeset	106 u2 name_cp_index;
a61af66fc99e Initial load duke parents: diff changeset	107 u2 descriptor_cp_index;
a61af66fc99e Initial load duke parents: diff changeset	108 u2 signature_cp_index;
a61af66fc99e Initial load duke parents: diff changeset	109 u2 slot;
a61af66fc99e Initial load duke parents: diff changeset	110 };
a61af66fc99e Initial load duke parents: diff changeset	111
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	112 // Utitily class describing elements in exception table
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	113 class ExceptionTableElement VALUE_OBJ_CLASS_SPEC {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	114 public:
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	115 u2 start_pc;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	116 u2 end_pc;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	117 u2 handler_pc;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	118 u2 catch_type_index;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	119 };
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	120
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	121 // Utility class describing elements in method parameters
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	122 class MethodParametersElement VALUE_OBJ_CLASS_SPEC {
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	123 public:
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	124 u2 name_cp_index;
7588 f9eb431c3efe 8006005: Fix constant pool index validation and alignment trap for method parameter reflection coleenp parents: 7462 diff changeset	125 // This has to happen, otherwise it will cause SIGBUS from a
f9eb431c3efe 8006005: Fix constant pool index validation and alignment trap for method parameter reflection coleenp parents: 7462 diff changeset	126 // misaligned u4 on some architectures (ie SPARC)
f9eb431c3efe 8006005: Fix constant pool index validation and alignment trap for method parameter reflection coleenp parents: 7462 diff changeset	127 // because MethodParametersElements are only aligned mod 2
f9eb431c3efe 8006005: Fix constant pool index validation and alignment trap for method parameter reflection coleenp parents: 7462 diff changeset	128 // within the ConstMethod container u2 flags_hi;
f9eb431c3efe 8006005: Fix constant pool index validation and alignment trap for method parameter reflection coleenp parents: 7462 diff changeset	129 u2 flags_hi;
f9eb431c3efe 8006005: Fix constant pool index validation and alignment trap for method parameter reflection coleenp parents: 7462 diff changeset	130 u2 flags_lo;
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	131 };
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	132
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	133
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	134 class ConstMethod : public MetaspaceObj {
0 a61af66fc99e Initial load duke parents: diff changeset	135 friend class VMStructs;
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	136
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	137 public:
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	138 typedef enum { NORMAL, OVERPASS } MethodType;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	139
0 a61af66fc99e Initial load duke parents: diff changeset	140 private:
a61af66fc99e Initial load duke parents: diff changeset	141 enum {
a61af66fc99e Initial load duke parents: diff changeset	142 _has_linenumber_table = 1,
a61af66fc99e Initial load duke parents: diff changeset	143 _has_checked_exceptions = 2,
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	144 _has_localvariable_table = 4,
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	145 _has_exception_table = 8,
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	146 _has_generic_signature = 16,
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	147 _has_method_parameters = 32,
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	148 _is_overpass = 64
0 a61af66fc99e Initial load duke parents: diff changeset	149 };
a61af66fc99e Initial load duke parents: diff changeset	150
a61af66fc99e Initial load duke parents: diff changeset	151 // Bit vector of signature
a61af66fc99e Initial load duke parents: diff changeset	152 // Callers interpret 0=not initialized yet and
a61af66fc99e Initial load duke parents: diff changeset	153 // -1=too many args to fix, must parse the slow way.
a61af66fc99e Initial load duke parents: diff changeset	154 // The real initial value is special to account for nonatomicity of 64 bit
a61af66fc99e Initial load duke parents: diff changeset	155 // loads and stores. This value may updated and read without a lock by
a61af66fc99e Initial load duke parents: diff changeset	156 // multiple threads, so is volatile.
a61af66fc99e Initial load duke parents: diff changeset	157 volatile uint64_t _fingerprint;
a61af66fc99e Initial load duke parents: diff changeset	158
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	159 ConstantPool* _constants; // Constant pool
0 a61af66fc99e Initial load duke parents: diff changeset	160
a61af66fc99e Initial load duke parents: diff changeset	161 // Raw stackmap data for the method
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	162 Array<u1>* _stackmap_data;
0 a61af66fc99e Initial load duke parents: diff changeset	163
a61af66fc99e Initial load duke parents: diff changeset	164 int _constMethod_size;
a61af66fc99e Initial load duke parents: diff changeset	165 jbyte _interpreter_kind;
a61af66fc99e Initial load duke parents: diff changeset	166 jbyte _flags;
a61af66fc99e Initial load duke parents: diff changeset	167
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	168 // Size of Java bytecodes allocated immediately after Method*.
0 a61af66fc99e Initial load duke parents: diff changeset	169 u2 _code_size;
a61af66fc99e Initial load duke parents: diff changeset	170 u2 _name_index; // Method name (index in constant pool)
a61af66fc99e Initial load duke parents: diff changeset	171 u2 _signature_index; // Method signature (index in constant pool)
a61af66fc99e Initial load duke parents: diff changeset	172 u2 _method_idnum; // unique identification number for the method within the class
a61af66fc99e Initial load duke parents: diff changeset	173 // initially corresponds to the index into the methods array.
a61af66fc99e Initial load duke parents: diff changeset	174 // but this may change with redefinition
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	175 u2 _max_stack; // Maximum number of entries on the expression stack
7402 fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	176 u2 _max_locals; // Number of local variables used by this method
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	177 u2 _size_of_parameters; // size of the parameter block (receiver + arguments) in words
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	178
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	179 // Constructor
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	180 ConstMethod(int byte_code_size,
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	181 int compressed_line_number_size,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	182 int localvariable_table_length,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	183 int exception_table_length,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	184 int checked_exceptions_length,
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	185 int method_parameters_length,
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	186 u2 generic_signature_index,
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	187 MethodType is_overpass,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	188 int size);
0 a61af66fc99e Initial load duke parents: diff changeset	189 public:
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	190
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	191 static ConstMethod* allocate(ClassLoaderData* loader_data,
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	192 int byte_code_size,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	193 int compressed_line_number_size,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	194 int localvariable_table_length,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	195 int exception_table_length,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	196 int checked_exceptions_length,
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	197 int method_parameters_length,
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	198 u2 generic_signature_index,
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	199 MethodType mt,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	200 TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	201
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	202 bool is_constMethod() const { return true; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	203
0 a61af66fc99e Initial load duke parents: diff changeset	204 // Inlined tables
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	205 void set_inlined_tables_length(u2 generic_signature_index,
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	206 int checked_exceptions_len,
0 a61af66fc99e Initial load duke parents: diff changeset	207 int compressed_line_number_size,
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	208 int localvariable_table_len,
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	209 int exception_table_len,
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	210 int method_parameters_length);
0 a61af66fc99e Initial load duke parents: diff changeset	211
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	212 bool has_generic_signature() const
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	213 { return (_flags & _has_generic_signature) != 0; }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	214
0 a61af66fc99e Initial load duke parents: diff changeset	215 bool has_linenumber_table() const
a61af66fc99e Initial load duke parents: diff changeset	216 { return (_flags & _has_linenumber_table) != 0; }
a61af66fc99e Initial load duke parents: diff changeset	217
a61af66fc99e Initial load duke parents: diff changeset	218 bool has_checked_exceptions() const
a61af66fc99e Initial load duke parents: diff changeset	219 { return (_flags & _has_checked_exceptions) != 0; }
a61af66fc99e Initial load duke parents: diff changeset	220
a61af66fc99e Initial load duke parents: diff changeset	221 bool has_localvariable_table() const
a61af66fc99e Initial load duke parents: diff changeset	222 { return (_flags & _has_localvariable_table) != 0; }
a61af66fc99e Initial load duke parents: diff changeset	223
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	224 bool has_exception_handler() const
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	225 { return (_flags & _has_exception_table) != 0; }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	226
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	227 bool has_method_parameters() const
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	228 { return (_flags & _has_method_parameters) != 0; }
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	229
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	230 MethodType method_type() const {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	231 return ((_flags & _is_overpass) == 0) ? NORMAL : OVERPASS;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	232 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	233
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	234 void set_method_type(MethodType mt) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	235 if (mt == NORMAL) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	236 _flags &= ~(_is_overpass);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	237 } else {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	238 _flags \|= _is_overpass;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	239 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	240 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	241
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	242
0 a61af66fc99e Initial load duke parents: diff changeset	243 void set_interpreter_kind(int kind) { _interpreter_kind = kind; }
a61af66fc99e Initial load duke parents: diff changeset	244 int interpreter_kind(void) const { return _interpreter_kind; }
a61af66fc99e Initial load duke parents: diff changeset	245
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 1972 diff changeset	246 // constant pool
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	247 ConstantPool* constants() const { return _constants; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	248 void set_constants(ConstantPool* c) { _constants = c; }
0 a61af66fc99e Initial load duke parents: diff changeset	249
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	250 Method* method() const;
0 a61af66fc99e Initial load duke parents: diff changeset	251
a61af66fc99e Initial load duke parents: diff changeset	252 // stackmap table data
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	253 Array<u1>* stackmap_data() const { return _stackmap_data; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	254 void set_stackmap_data(Array<u1>* sd) { _stackmap_data = sd; }
0 a61af66fc99e Initial load duke parents: diff changeset	255 bool has_stackmap_table() const { return _stackmap_data != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	256
a61af66fc99e Initial load duke parents: diff changeset	257 void init_fingerprint() {
a61af66fc99e Initial load duke parents: diff changeset	258 const uint64_t initval = CONST64(0x8000000000000000);
a61af66fc99e Initial load duke parents: diff changeset	259 _fingerprint = initval;
a61af66fc99e Initial load duke parents: diff changeset	260 }
a61af66fc99e Initial load duke parents: diff changeset	261
a61af66fc99e Initial load duke parents: diff changeset	262 uint64_t fingerprint() const {
a61af66fc99e Initial load duke parents: diff changeset	263 // Since reads aren't atomic for 64 bits, if any of the high or low order
a61af66fc99e Initial load duke parents: diff changeset	264 // word is the initial value, return 0. See init_fingerprint for initval.
a61af66fc99e Initial load duke parents: diff changeset	265 uint high_fp = (uint)(_fingerprint >> 32);
a61af66fc99e Initial load duke parents: diff changeset	266 if ((int) _fingerprint == 0 \|\| high_fp == 0x80000000) {
a61af66fc99e Initial load duke parents: diff changeset	267 return 0L;
a61af66fc99e Initial load duke parents: diff changeset	268 } else {
a61af66fc99e Initial load duke parents: diff changeset	269 return _fingerprint;
a61af66fc99e Initial load duke parents: diff changeset	270 }
a61af66fc99e Initial load duke parents: diff changeset	271 }
a61af66fc99e Initial load duke parents: diff changeset	272
a61af66fc99e Initial load duke parents: diff changeset	273 uint64_t set_fingerprint(uint64_t new_fingerprint) {
a61af66fc99e Initial load duke parents: diff changeset	274 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	275 // Assert only valid if complete/valid 64 bit _fingerprint value is read.
a61af66fc99e Initial load duke parents: diff changeset	276 uint64_t oldfp = fingerprint();
a61af66fc99e Initial load duke parents: diff changeset	277 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	278 _fingerprint = new_fingerprint;
a61af66fc99e Initial load duke parents: diff changeset	279 assert(oldfp == 0L \|\| new_fingerprint == oldfp,
a61af66fc99e Initial load duke parents: diff changeset	280 "fingerprint cannot change");
a61af66fc99e Initial load duke parents: diff changeset	281 assert(((new_fingerprint >> 32) != 0x80000000) && (int)new_fingerprint !=0,
a61af66fc99e Initial load duke parents: diff changeset	282 "fingerprint should call init to set initial value");
a61af66fc99e Initial load duke parents: diff changeset	283 return new_fingerprint;
a61af66fc99e Initial load duke parents: diff changeset	284 }
a61af66fc99e Initial load duke parents: diff changeset	285
a61af66fc99e Initial load duke parents: diff changeset	286 // name
a61af66fc99e Initial load duke parents: diff changeset	287 int name_index() const { return _name_index; }
a61af66fc99e Initial load duke parents: diff changeset	288 void set_name_index(int index) { _name_index = index; }
a61af66fc99e Initial load duke parents: diff changeset	289
a61af66fc99e Initial load duke parents: diff changeset	290 // signature
a61af66fc99e Initial load duke parents: diff changeset	291 int signature_index() const { return _signature_index; }
a61af66fc99e Initial load duke parents: diff changeset	292 void set_signature_index(int index) { _signature_index = index; }
a61af66fc99e Initial load duke parents: diff changeset	293
a61af66fc99e Initial load duke parents: diff changeset	294 // generics support
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	295 int generic_signature_index() const {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	296 if (has_generic_signature()) {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	297 return *generic_signature_index_addr();
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	298 } else {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	299 return 0;
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	300 }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	301 }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	302 void set_generic_signature_index(u2 index) {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	303 assert(has_generic_signature(), "");
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	304 u2* addr = generic_signature_index_addr();
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	305 *addr = index;
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	306 }
0 a61af66fc99e Initial load duke parents: diff changeset	307
a61af66fc99e Initial load duke parents: diff changeset	308 // Sizing
a61af66fc99e Initial load duke parents: diff changeset	309 static int header_size() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	310 return sizeof(ConstMethod)/HeapWordSize;
0 a61af66fc99e Initial load duke parents: diff changeset	311 }
a61af66fc99e Initial load duke parents: diff changeset	312
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	313 // Size needed
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	314 static int size(int code_size, int compressed_line_number_size,
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	315 int local_variable_table_length,
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	316 int exception_table_length,
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	317 int checked_exceptions_length,
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	318 int method_parameters_length,
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	319 u2 generic_signature_index);
0 a61af66fc99e Initial load duke parents: diff changeset	320
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	321 int size() const { return _constMethod_size;}
0 a61af66fc99e Initial load duke parents: diff changeset	322 void set_constMethod_size(int size) { _constMethod_size = size; }
a61af66fc99e Initial load duke parents: diff changeset	323
a61af66fc99e Initial load duke parents: diff changeset	324 // code size
a61af66fc99e Initial load duke parents: diff changeset	325 int code_size() const { return _code_size; }
a61af66fc99e Initial load duke parents: diff changeset	326 void set_code_size(int size) {
a61af66fc99e Initial load duke parents: diff changeset	327 assert(max_method_code_size < (1 << 16),
a61af66fc99e Initial load duke parents: diff changeset	328 "u2 is too small to hold method code size in general");
a61af66fc99e Initial load duke parents: diff changeset	329 assert(0 <= size && size <= max_method_code_size, "invalid code size");
a61af66fc99e Initial load duke parents: diff changeset	330 _code_size = size;
a61af66fc99e Initial load duke parents: diff changeset	331 }
a61af66fc99e Initial load duke parents: diff changeset	332
a61af66fc99e Initial load duke parents: diff changeset	333 // linenumber table - note that length is unknown until decompression,
a61af66fc99e Initial load duke parents: diff changeset	334 // see class CompressedLineNumberReadStream.
a61af66fc99e Initial load duke parents: diff changeset	335 u_char* compressed_linenumber_table() const; // not preserved by gc
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	336 u2* generic_signature_index_addr() const;
0 a61af66fc99e Initial load duke parents: diff changeset	337 u2* checked_exceptions_length_addr() const;
a61af66fc99e Initial load duke parents: diff changeset	338 u2* localvariable_table_length_addr() const;
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	339 u2* exception_table_length_addr() const;
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	340 u2* method_parameters_length_addr() const;
0 a61af66fc99e Initial load duke parents: diff changeset	341
a61af66fc99e Initial load duke parents: diff changeset	342 // checked exceptions
a61af66fc99e Initial load duke parents: diff changeset	343 int checked_exceptions_length() const;
a61af66fc99e Initial load duke parents: diff changeset	344 CheckedExceptionElement* checked_exceptions_start() const;
a61af66fc99e Initial load duke parents: diff changeset	345
a61af66fc99e Initial load duke parents: diff changeset	346 // localvariable table
a61af66fc99e Initial load duke parents: diff changeset	347 int localvariable_table_length() const;
a61af66fc99e Initial load duke parents: diff changeset	348 LocalVariableTableElement* localvariable_table_start() const;
a61af66fc99e Initial load duke parents: diff changeset	349
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	350 // exception table
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	351 int exception_table_length() const;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	352 ExceptionTableElement* exception_table_start() const;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	353
7462 ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	354 // method parameters table
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	355 int method_parameters_length() const;
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	356 MethodParametersElement* method_parameters_start() const;
ade95d680b42 8004728: Add hotspot support for parameter reflection coleenp parents: 7402 diff changeset	357
0 a61af66fc99e Initial load duke parents: diff changeset	358 // byte codes
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 579 diff changeset	359 void set_code(address code) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 579 diff changeset	360 if (code_size() > 0) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 579 diff changeset	361 memcpy(code_base(), code, code_size());
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 579 diff changeset	362 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 579 diff changeset	363 }
0 a61af66fc99e Initial load duke parents: diff changeset	364 address code_base() const { return (address) (this+1); }
a61af66fc99e Initial load duke parents: diff changeset	365 address code_end() const { return code_base() + code_size(); }
a61af66fc99e Initial load duke parents: diff changeset	366 bool contains(address bcp) const { return code_base() <= bcp
a61af66fc99e Initial load duke parents: diff changeset	367 && bcp < code_end(); }
a61af66fc99e Initial load duke parents: diff changeset	368 // Offset to bytecodes
a61af66fc99e Initial load duke parents: diff changeset	369 static ByteSize codes_offset()
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	370 { return in_ByteSize(sizeof(ConstMethod)); }
0 a61af66fc99e Initial load duke parents: diff changeset	371
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	372 static ByteSize constants_offset()
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	373 { return byte_offset_of(ConstMethod, _constants); }
0 a61af66fc99e Initial load duke parents: diff changeset	374
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	375 static ByteSize max_stack_offset()
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	376 { return byte_offset_of(ConstMethod, _max_stack); }
7402 fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	377 static ByteSize size_of_locals_offset()
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	378 { return byte_offset_of(ConstMethod, _max_locals); }
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	379 static ByteSize size_of_parameters_offset()
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	380 { return byte_offset_of(ConstMethod, _size_of_parameters); }
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	381
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	382
0 a61af66fc99e Initial load duke parents: diff changeset	383 // Unique id for the method
a61af66fc99e Initial load duke parents: diff changeset	384 static const u2 MAX_IDNUM;
a61af66fc99e Initial load duke parents: diff changeset	385 static const u2 UNSET_IDNUM;
a61af66fc99e Initial load duke parents: diff changeset	386 u2 method_idnum() const { return _method_idnum; }
a61af66fc99e Initial load duke parents: diff changeset	387 void set_method_idnum(u2 idnum) { _method_idnum = idnum; }
a61af66fc99e Initial load duke parents: diff changeset	388
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	389 // max stack
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	390 int max_stack() const { return _max_stack; }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	391 void set_max_stack(int size) { _max_stack = size; }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6934 diff changeset	392
7402 fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	393 // max locals
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	394 int max_locals() const { return _max_locals; }
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	395 void set_max_locals(int size) { _max_locals = size; }
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	396
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	397 // size of parameters
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	398 int size_of_parameters() const { return _size_of_parameters; }
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	399 void set_size_of_parameters(int size) { _size_of_parameters = size; }
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	400
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	401 // Deallocation for RedefineClasses
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	402 void deallocate_contents(ClassLoaderData* loader_data);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	403 bool is_klass() const { return false; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	404 DEBUG_ONLY(bool on_stack() { return false; })
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	405
0 a61af66fc99e Initial load duke parents: diff changeset	406 private:
a61af66fc99e Initial load duke parents: diff changeset	407 // Since the size of the compressed line number table is unknown, the
a61af66fc99e Initial load duke parents: diff changeset	408 // offsets of the other variable sized sections are computed backwards
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	409 // from the end of the ConstMethod*.
0 a61af66fc99e Initial load duke parents: diff changeset	410
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	411 // First byte after ConstMethod*
0 a61af66fc99e Initial load duke parents: diff changeset	412 address constMethod_end() const
a61af66fc99e Initial load duke parents: diff changeset	413 { return (address)((oop*)this + _constMethod_size); }
a61af66fc99e Initial load duke parents: diff changeset	414
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	415 // Last short in ConstMethod*
0 a61af66fc99e Initial load duke parents: diff changeset	416 u2* last_u2_element() const
a61af66fc99e Initial load duke parents: diff changeset	417 { return (u2*)constMethod_end() - 1; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	418
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	419 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	420 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	421 void print_on (outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	422 void print_value_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	423
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	424 const char* internal_name() const { return "{constMethod}"; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	425
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	426 // Verify
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	427 void verify_on(outputStream* st);
0 a61af66fc99e Initial load duke parents: diff changeset	428 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	429
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	430 #endif // SHARE_VM_OOPS_CONSTMETHODOOP_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/oops/constMethod.hpp @ 7588:f9eb431c3efe