truffle: agent/src/share/classes/sun/jvm/hotspot/oops/ConstMethod.java annotate

annotate agent/src/share/classes/sun/jvm/hotspot/oops/ConstMethod.java @ 7402:fd74228fd5ca

8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. Summary: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. Reviewed-by: coleenp, minqi, jrose

author	jiangli
date	Tue, 11 Dec 2012 12:41:31 -0500
parents	b2dbd323c668
children	927a311d00f9

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 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: 0 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 0 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: 0 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
a61af66fc99e Initial load duke parents: diff changeset	25 package sun.jvm.hotspot.oops;
a61af66fc99e Initial load duke parents: diff changeset	26
a61af66fc99e Initial load duke parents: diff changeset	27 import java.io.*;
a61af66fc99e Initial load duke parents: diff changeset	28 import java.util.*;
a61af66fc99e Initial load duke parents: diff changeset	29 import sun.jvm.hotspot.code.*;
a61af66fc99e Initial load duke parents: diff changeset	30 import sun.jvm.hotspot.debugger.*;
a61af66fc99e Initial load duke parents: diff changeset	31 import sun.jvm.hotspot.interpreter.*;
a61af66fc99e Initial load duke parents: diff changeset	32 import sun.jvm.hotspot.memory.*;
a61af66fc99e Initial load duke parents: diff changeset	33 import sun.jvm.hotspot.runtime.*;
a61af66fc99e Initial load duke parents: diff changeset	34 import sun.jvm.hotspot.types.*;
a61af66fc99e Initial load duke parents: diff changeset	35 import sun.jvm.hotspot.utilities.*;
a61af66fc99e Initial load duke parents: diff changeset	36
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	37 public class ConstMethod extends VMObject {
0 a61af66fc99e Initial load duke parents: diff changeset	38 static {
a61af66fc99e Initial load duke parents: diff changeset	39 VM.registerVMInitializedObserver(new Observer() {
a61af66fc99e Initial load duke parents: diff changeset	40 public void update(Observable o, Object data) {
a61af66fc99e Initial load duke parents: diff changeset	41 initialize(VM.getVM().getTypeDataBase());
a61af66fc99e Initial load duke parents: diff changeset	42 }
a61af66fc99e Initial load duke parents: diff changeset	43 });
a61af66fc99e Initial load duke parents: diff changeset	44 }
a61af66fc99e Initial load duke parents: diff changeset	45
a61af66fc99e Initial load duke parents: diff changeset	46 // anon-enum constants for _flags.
a61af66fc99e Initial load duke parents: diff changeset	47 private static int HAS_LINENUMBER_TABLE;
a61af66fc99e Initial load duke parents: diff changeset	48 private static int HAS_CHECKED_EXCEPTIONS;
a61af66fc99e Initial load duke parents: diff changeset	49 private static int HAS_LOCALVARIABLE_TABLE;
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	50 private static int HAS_EXCEPTION_TABLE;
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	51 private static int HAS_GENERIC_SIGNATURE;
0 a61af66fc99e Initial load duke parents: diff changeset	52
a61af66fc99e Initial load duke parents: diff changeset	53 private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	54 Type type = db.lookupType("ConstMethod");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	55 constants = new MetadataField(type.getAddressField("_constants"), 0);
0 a61af66fc99e Initial load duke parents: diff changeset	56 constMethodSize = new CIntField(type.getCIntegerField("_constMethod_size"), 0);
a61af66fc99e Initial load duke parents: diff changeset	57 flags = new ByteField(type.getJByteField("_flags"), 0);
a61af66fc99e Initial load duke parents: diff changeset	58
a61af66fc99e Initial load duke parents: diff changeset	59 // enum constants for flags
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	60 HAS_LINENUMBER_TABLE = db.lookupIntConstant("ConstMethod::_has_linenumber_table").intValue();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	61 HAS_CHECKED_EXCEPTIONS = db.lookupIntConstant("ConstMethod::_has_checked_exceptions").intValue();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	62 HAS_LOCALVARIABLE_TABLE = db.lookupIntConstant("ConstMethod::_has_localvariable_table").intValue();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	63 HAS_EXCEPTION_TABLE = db.lookupIntConstant("ConstMethod::_has_exception_table").intValue();
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	64 HAS_GENERIC_SIGNATURE = db.lookupIntConstant("ConstMethod::_has_generic_signature").intValue();
0 a61af66fc99e Initial load duke parents: diff changeset	65
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	66 // Size of Java bytecodes allocated immediately after ConstMethod*.
0 a61af66fc99e Initial load duke parents: diff changeset	67 codeSize = new CIntField(type.getCIntegerField("_code_size"), 0);
a61af66fc99e Initial load duke parents: diff changeset	68 nameIndex = new CIntField(type.getCIntegerField("_name_index"), 0);
a61af66fc99e Initial load duke parents: diff changeset	69 signatureIndex = new CIntField(type.getCIntegerField("_signature_index"), 0);
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	70 idnum = new CIntField(type.getCIntegerField("_method_idnum"), 0);
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	71 maxStack = new CIntField(type.getCIntegerField("_max_stack"), 0);
7402 fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	72 maxLocals = new CIntField(type.getCIntegerField("_max_locals"), 0);
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	73 sizeOfParameters = new CIntField(type.getCIntegerField("_size_of_parameters"), 0);
0 a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75 // start of byte code
a61af66fc99e Initial load duke parents: diff changeset	76 bytecodeOffset = type.getSize();
a61af66fc99e Initial load duke parents: diff changeset	77
a61af66fc99e Initial load duke parents: diff changeset	78 type = db.lookupType("CheckedExceptionElement");
a61af66fc99e Initial load duke parents: diff changeset	79 checkedExceptionElementSize = type.getSize();
a61af66fc99e Initial load duke parents: diff changeset	80
a61af66fc99e Initial load duke parents: diff changeset	81 type = db.lookupType("LocalVariableTableElement");
a61af66fc99e Initial load duke parents: diff changeset	82 localVariableTableElementSize = type.getSize();
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	83
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	84 type = db.lookupType("ExceptionTableElement");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	85 exceptionTableElementSize = type.getSize();
0 a61af66fc99e Initial load duke parents: diff changeset	86 }
a61af66fc99e Initial load duke parents: diff changeset	87
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	88 public ConstMethod(Address addr) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	89 super(addr);
0 a61af66fc99e Initial load duke parents: diff changeset	90 }
a61af66fc99e Initial load duke parents: diff changeset	91
a61af66fc99e Initial load duke parents: diff changeset	92 // Fields
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	93 private static MetadataField constants;
0 a61af66fc99e Initial load duke parents: diff changeset	94 private static CIntField constMethodSize;
a61af66fc99e Initial load duke parents: diff changeset	95 private static ByteField flags;
a61af66fc99e Initial load duke parents: diff changeset	96 private static CIntField codeSize;
a61af66fc99e Initial load duke parents: diff changeset	97 private static CIntField nameIndex;
a61af66fc99e Initial load duke parents: diff changeset	98 private static CIntField signatureIndex;
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	99 private static CIntField idnum;
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	100 private static CIntField maxStack;
7402 fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	101 private static CIntField maxLocals;
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	102 private static CIntField sizeOfParameters;
0 a61af66fc99e Initial load duke parents: diff changeset	103
a61af66fc99e Initial load duke parents: diff changeset	104 // start of bytecode
a61af66fc99e Initial load duke parents: diff changeset	105 private static long bytecodeOffset;
a61af66fc99e Initial load duke parents: diff changeset	106
a61af66fc99e Initial load duke parents: diff changeset	107 private static long checkedExceptionElementSize;
a61af66fc99e Initial load duke parents: diff changeset	108 private static long localVariableTableElementSize;
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	109 private static long exceptionTableElementSize;
0 a61af66fc99e Initial load duke parents: diff changeset	110
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	111 public Method getMethod() {
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	112 InstanceKlass ik = (InstanceKlass)getConstants().getPoolHolder();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	113 MethodArray methods = ik.getMethods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	114 return methods.at((int)getIdNum());
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	115 }
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	116
0 a61af66fc99e Initial load duke parents: diff changeset	117 // Accessors for declared fields
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	118 public ConstantPool getConstants() {
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	119 return (ConstantPool) constants.getValue(this);
0 a61af66fc99e Initial load duke parents: diff changeset	120 }
a61af66fc99e Initial load duke parents: diff changeset	121
a61af66fc99e Initial load duke parents: diff changeset	122 public long getConstMethodSize() {
a61af66fc99e Initial load duke parents: diff changeset	123 return constMethodSize.getValue(this);
a61af66fc99e Initial load duke parents: diff changeset	124 }
a61af66fc99e Initial load duke parents: diff changeset	125
a61af66fc99e Initial load duke parents: diff changeset	126 public byte getFlags() {
a61af66fc99e Initial load duke parents: diff changeset	127 return flags.getValue(this);
a61af66fc99e Initial load duke parents: diff changeset	128 }
a61af66fc99e Initial load duke parents: diff changeset	129
a61af66fc99e Initial load duke parents: diff changeset	130 public long getCodeSize() {
a61af66fc99e Initial load duke parents: diff changeset	131 return codeSize.getValue(this);
a61af66fc99e Initial load duke parents: diff changeset	132 }
a61af66fc99e Initial load duke parents: diff changeset	133
a61af66fc99e Initial load duke parents: diff changeset	134 public long getNameIndex() {
a61af66fc99e Initial load duke parents: diff changeset	135 return nameIndex.getValue(this);
a61af66fc99e Initial load duke parents: diff changeset	136 }
a61af66fc99e Initial load duke parents: diff changeset	137
a61af66fc99e Initial load duke parents: diff changeset	138 public long getSignatureIndex() {
a61af66fc99e Initial load duke parents: diff changeset	139 return signatureIndex.getValue(this);
a61af66fc99e Initial load duke parents: diff changeset	140 }
a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 public long getGenericSignatureIndex() {
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	143 if (hasGenericSignature()) {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	144 return getAddress().getCIntegerAt(offsetOfGenericSignatureIndex(), 2, true);
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	145 } else {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	146 return 0;
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	147 }
0 a61af66fc99e Initial load duke parents: diff changeset	148 }
a61af66fc99e Initial load duke parents: diff changeset	149
6123 2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	150 public long getIdNum() {
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	151 return idnum.getValue(this);
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	152 }
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop. jiangli parents: 3838 diff changeset	153
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	154 public long getMaxStack() {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	155 return maxStack.getValue(this);
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	156 }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	157
7402 fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	158 public long getMaxLocals() {
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	159 return maxLocals.getValue(this);
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	160 }
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	161
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	162 public long getSizeOfParameters() {
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	163 return sizeOfParameters.getValue(this);
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	164 }
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	165
0 a61af66fc99e Initial load duke parents: diff changeset	166 public Symbol getName() {
a61af66fc99e Initial load duke parents: diff changeset	167 return getMethod().getName();
a61af66fc99e Initial load duke parents: diff changeset	168 }
a61af66fc99e Initial load duke parents: diff changeset	169
a61af66fc99e Initial load duke parents: diff changeset	170 public Symbol getSignature() {
a61af66fc99e Initial load duke parents: diff changeset	171 return getMethod().getSignature();
a61af66fc99e Initial load duke parents: diff changeset	172 }
a61af66fc99e Initial load duke parents: diff changeset	173
a61af66fc99e Initial load duke parents: diff changeset	174 public Symbol getGenericSignature() {
a61af66fc99e Initial load duke parents: diff changeset	175 return getMethod().getGenericSignature();
a61af66fc99e Initial load duke parents: diff changeset	176 }
a61af66fc99e Initial load duke parents: diff changeset	177
a61af66fc99e Initial load duke parents: diff changeset	178 // bytecode accessors
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180 /** Get a bytecode or breakpoint at the given bci */
a61af66fc99e Initial load duke parents: diff changeset	181 public int getBytecodeOrBPAt(int bci) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	182 return getAddress().getJByteAt(bytecodeOffset + bci) & 0xFF;
0 a61af66fc99e Initial load duke parents: diff changeset	183 }
a61af66fc99e Initial load duke parents: diff changeset	184
a61af66fc99e Initial load duke parents: diff changeset	185 public byte getBytecodeByteArg(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	186 return (byte) getBytecodeOrBPAt(bci);
a61af66fc99e Initial load duke parents: diff changeset	187 }
a61af66fc99e Initial load duke parents: diff changeset	188
a61af66fc99e Initial load duke parents: diff changeset	189 /** Fetches a 16-bit big-endian ("Java ordered") value from the
a61af66fc99e Initial load duke parents: diff changeset	190 bytecode stream */
a61af66fc99e Initial load duke parents: diff changeset	191 public short getBytecodeShortArg(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	192 int hi = getBytecodeOrBPAt(bci);
a61af66fc99e Initial load duke parents: diff changeset	193 int lo = getBytecodeOrBPAt(bci + 1);
a61af66fc99e Initial load duke parents: diff changeset	194 return (short) ((hi << 8) \| lo);
a61af66fc99e Initial load duke parents: diff changeset	195 }
a61af66fc99e Initial load duke parents: diff changeset	196
3838 6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	197 /** Fetches a 16-bit native ordered value from the
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	198 bytecode stream */
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	199 public short getNativeShortArg(int bci) {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	200 int hi = getBytecodeOrBPAt(bci);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	201 int lo = getBytecodeOrBPAt(bci + 1);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	202 if (VM.getVM().isBigEndian()) {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	203 return (short) ((hi << 8) \| lo);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	204 } else {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	205 return (short) ((lo << 8) \| hi);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	206 }
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	207 }
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	208
0 a61af66fc99e Initial load duke parents: diff changeset	209 /** Fetches a 32-bit big-endian ("Java ordered") value from the
a61af66fc99e Initial load duke parents: diff changeset	210 bytecode stream */
a61af66fc99e Initial load duke parents: diff changeset	211 public int getBytecodeIntArg(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	212 int b4 = getBytecodeOrBPAt(bci);
a61af66fc99e Initial load duke parents: diff changeset	213 int b3 = getBytecodeOrBPAt(bci + 1);
a61af66fc99e Initial load duke parents: diff changeset	214 int b2 = getBytecodeOrBPAt(bci + 2);
a61af66fc99e Initial load duke parents: diff changeset	215 int b1 = getBytecodeOrBPAt(bci + 3);
a61af66fc99e Initial load duke parents: diff changeset	216
a61af66fc99e Initial load duke parents: diff changeset	217 return (b4 << 24) \| (b3 << 16) \| (b2 << 8) \| b1;
a61af66fc99e Initial load duke parents: diff changeset	218 }
a61af66fc99e Initial load duke parents: diff changeset	219
3838 6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	220 /** Fetches a 32-bit native ordered value from the
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	221 bytecode stream */
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	222 public int getNativeIntArg(int bci) {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	223 int b4 = getBytecodeOrBPAt(bci);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	224 int b3 = getBytecodeOrBPAt(bci + 1);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	225 int b2 = getBytecodeOrBPAt(bci + 2);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	226 int b1 = getBytecodeOrBPAt(bci + 3);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	227
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	228 if (VM.getVM().isBigEndian()) {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	229 return (b4 << 24) \| (b3 << 16) \| (b2 << 8) \| b1;
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	230 } else {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	231 return (b1 << 24) \| (b2 << 16) \| (b3 << 8) \| b4;
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	232 }
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	233 }
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries never parents: 1552 diff changeset	234
0 a61af66fc99e Initial load duke parents: diff changeset	235 public byte[] getByteCode() {
a61af66fc99e Initial load duke parents: diff changeset	236 byte[] bc = new byte[ (int) getCodeSize() ];
a61af66fc99e Initial load duke parents: diff changeset	237 for( int i=0; i < bc.length; i++ )
a61af66fc99e Initial load duke parents: diff changeset	238 {
a61af66fc99e Initial load duke parents: diff changeset	239 long offs = bytecodeOffset + i;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	240 bc[i] = getAddress().getJByteAt( offs );
0 a61af66fc99e Initial load duke parents: diff changeset	241 }
a61af66fc99e Initial load duke parents: diff changeset	242 return bc;
a61af66fc99e Initial load duke parents: diff changeset	243 }
a61af66fc99e Initial load duke parents: diff changeset	244
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	245 public long getSize() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	246 return getConstMethodSize();
0 a61af66fc99e Initial load duke parents: diff changeset	247 }
a61af66fc99e Initial load duke parents: diff changeset	248
a61af66fc99e Initial load duke parents: diff changeset	249 public void printValueOn(PrintStream tty) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	250 tty.print("ConstMethod " + getName().asString() + getSignature().asString() + "@" + getAddress());
0 a61af66fc99e Initial load duke parents: diff changeset	251 }
a61af66fc99e Initial load duke parents: diff changeset	252
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	253 public void iterateFields(MetadataVisitor visitor) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	254 visitor.doMetadata(constants, true);
0 a61af66fc99e Initial load duke parents: diff changeset	255 visitor.doCInt(constMethodSize, true);
a61af66fc99e Initial load duke parents: diff changeset	256 visitor.doByte(flags, true);
a61af66fc99e Initial load duke parents: diff changeset	257 visitor.doCInt(codeSize, true);
a61af66fc99e Initial load duke parents: diff changeset	258 visitor.doCInt(nameIndex, true);
a61af66fc99e Initial load duke parents: diff changeset	259 visitor.doCInt(signatureIndex, true);
a61af66fc99e Initial load duke parents: diff changeset	260 visitor.doCInt(codeSize, true);
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	261 visitor.doCInt(maxStack, true);
7402 fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	262 visitor.doCInt(maxLocals, true);
fd74228fd5ca 8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing. jiangli parents: 7183 diff changeset	263 visitor.doCInt(sizeOfParameters, true);
0 a61af66fc99e Initial load duke parents: diff changeset	264 }
a61af66fc99e Initial load duke parents: diff changeset	265
a61af66fc99e Initial load duke parents: diff changeset	266 // Accessors
a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 public boolean hasLineNumberTable() {
a61af66fc99e Initial load duke parents: diff changeset	269 return (getFlags() & HAS_LINENUMBER_TABLE) != 0;
a61af66fc99e Initial load duke parents: diff changeset	270 }
a61af66fc99e Initial load duke parents: diff changeset	271
a61af66fc99e Initial load duke parents: diff changeset	272 public int getLineNumberFromBCI(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	273 if (!VM.getVM().isCore()) {
a61af66fc99e Initial load duke parents: diff changeset	274 if (bci == DebugInformationRecorder.SYNCHRONIZATION_ENTRY_BCI) bci = 0;
a61af66fc99e Initial load duke parents: diff changeset	275 }
a61af66fc99e Initial load duke parents: diff changeset	276
a61af66fc99e Initial load duke parents: diff changeset	277 if (isNative()) {
a61af66fc99e Initial load duke parents: diff changeset	278 return -1;
a61af66fc99e Initial load duke parents: diff changeset	279 }
a61af66fc99e Initial load duke parents: diff changeset	280
a61af66fc99e Initial load duke parents: diff changeset	281 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load duke parents: diff changeset	282 Assert.that(bci == 0 \|\| 0 <= bci && bci < getCodeSize(), "illegal bci");
a61af66fc99e Initial load duke parents: diff changeset	283 }
a61af66fc99e Initial load duke parents: diff changeset	284 int bestBCI = 0;
a61af66fc99e Initial load duke parents: diff changeset	285 int bestLine = -1;
a61af66fc99e Initial load duke parents: diff changeset	286 if (hasLineNumberTable()) {
a61af66fc99e Initial load duke parents: diff changeset	287 // The line numbers are a short array of 2-tuples [start_pc, line_number].
a61af66fc99e Initial load duke parents: diff changeset	288 // Not necessarily sorted and not necessarily one-to-one.
a61af66fc99e Initial load duke parents: diff changeset	289 CompressedLineNumberReadStream stream =
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	290 new CompressedLineNumberReadStream(getAddress(), (int) offsetOfCompressedLineNumberTable());
0 a61af66fc99e Initial load duke parents: diff changeset	291 while (stream.readPair()) {
a61af66fc99e Initial load duke parents: diff changeset	292 if (stream.bci() == bci) {
a61af66fc99e Initial load duke parents: diff changeset	293 // perfect match
a61af66fc99e Initial load duke parents: diff changeset	294 return stream.line();
a61af66fc99e Initial load duke parents: diff changeset	295 } else {
a61af66fc99e Initial load duke parents: diff changeset	296 // update best_bci/line
a61af66fc99e Initial load duke parents: diff changeset	297 if (stream.bci() < bci && stream.bci() >= bestBCI) {
a61af66fc99e Initial load duke parents: diff changeset	298 bestBCI = stream.bci();
a61af66fc99e Initial load duke parents: diff changeset	299 bestLine = stream.line();
a61af66fc99e Initial load duke parents: diff changeset	300 }
a61af66fc99e Initial load duke parents: diff changeset	301 }
a61af66fc99e Initial load duke parents: diff changeset	302 }
a61af66fc99e Initial load duke parents: diff changeset	303 }
a61af66fc99e Initial load duke parents: diff changeset	304 return bestLine;
a61af66fc99e Initial load duke parents: diff changeset	305 }
a61af66fc99e Initial load duke parents: diff changeset	306
a61af66fc99e Initial load duke parents: diff changeset	307 public LineNumberTableElement[] getLineNumberTable() {
a61af66fc99e Initial load duke parents: diff changeset	308 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load duke parents: diff changeset	309 Assert.that(hasLineNumberTable(),
a61af66fc99e Initial load duke parents: diff changeset	310 "should only be called if table is present");
a61af66fc99e Initial load duke parents: diff changeset	311 }
a61af66fc99e Initial load duke parents: diff changeset	312 int len = getLineNumberTableLength();
a61af66fc99e Initial load duke parents: diff changeset	313 CompressedLineNumberReadStream stream =
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	314 new CompressedLineNumberReadStream(getAddress(), (int) offsetOfCompressedLineNumberTable());
0 a61af66fc99e Initial load duke parents: diff changeset	315 LineNumberTableElement[] ret = new LineNumberTableElement[len];
a61af66fc99e Initial load duke parents: diff changeset	316
a61af66fc99e Initial load duke parents: diff changeset	317 for (int idx = 0; idx < len; idx++) {
a61af66fc99e Initial load duke parents: diff changeset	318 stream.readPair();
a61af66fc99e Initial load duke parents: diff changeset	319 ret[idx] = new LineNumberTableElement(stream.bci(), stream.line());
a61af66fc99e Initial load duke parents: diff changeset	320 }
a61af66fc99e Initial load duke parents: diff changeset	321 return ret;
a61af66fc99e Initial load duke parents: diff changeset	322 }
a61af66fc99e Initial load duke parents: diff changeset	323
a61af66fc99e Initial load duke parents: diff changeset	324 public boolean hasLocalVariableTable() {
a61af66fc99e Initial load duke parents: diff changeset	325 return (getFlags() & HAS_LOCALVARIABLE_TABLE) != 0;
a61af66fc99e Initial load duke parents: diff changeset	326 }
a61af66fc99e Initial load duke parents: diff changeset	327
a61af66fc99e Initial load duke parents: diff changeset	328 public Symbol getLocalVariableName(int bci, int slot) {
a61af66fc99e Initial load duke parents: diff changeset	329 return getMethod().getLocalVariableName(bci, slot);
a61af66fc99e Initial load duke parents: diff changeset	330 }
a61af66fc99e Initial load duke parents: diff changeset	331
a61af66fc99e Initial load duke parents: diff changeset	332 /** Should only be called if table is present */
a61af66fc99e Initial load duke parents: diff changeset	333 public LocalVariableTableElement[] getLocalVariableTable() {
a61af66fc99e Initial load duke parents: diff changeset	334 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load duke parents: diff changeset	335 Assert.that(hasLocalVariableTable(), "should only be called if table is present");
a61af66fc99e Initial load duke parents: diff changeset	336 }
a61af66fc99e Initial load duke parents: diff changeset	337 LocalVariableTableElement[] ret = new LocalVariableTableElement[getLocalVariableTableLength()];
a61af66fc99e Initial load duke parents: diff changeset	338 long offset = offsetOfLocalVariableTable();
a61af66fc99e Initial load duke parents: diff changeset	339 for (int i = 0; i < ret.length; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	340 ret[i] = new LocalVariableTableElement(getAddress(), offset);
0 a61af66fc99e Initial load duke parents: diff changeset	341 offset += localVariableTableElementSize;
a61af66fc99e Initial load duke parents: diff changeset	342 }
a61af66fc99e Initial load duke parents: diff changeset	343 return ret;
a61af66fc99e Initial load duke parents: diff changeset	344 }
a61af66fc99e Initial load duke parents: diff changeset	345
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	346 public boolean hasExceptionTable() {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	347 return (getFlags() & HAS_EXCEPTION_TABLE) != 0;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	348 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	349
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	350 public ExceptionTableElement[] getExceptionTable() {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	351 if (Assert.ASSERTS_ENABLED) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	352 Assert.that(hasExceptionTable(), "should only be called if table is present");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	353 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	354 ExceptionTableElement[] ret = new ExceptionTableElement[getExceptionTableLength()];
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	355 long offset = offsetOfExceptionTable();
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	356 for (int i = 0; i < ret.length; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	357 ret[i] = new ExceptionTableElement(getAddress(), offset);
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	358 offset += exceptionTableElementSize;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	359 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	360 return ret;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	361 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	362
0 a61af66fc99e Initial load duke parents: diff changeset	363 public boolean hasCheckedExceptions() {
a61af66fc99e Initial load duke parents: diff changeset	364 return (getFlags() & HAS_CHECKED_EXCEPTIONS) != 0;
a61af66fc99e Initial load duke parents: diff changeset	365 }
a61af66fc99e Initial load duke parents: diff changeset	366
a61af66fc99e Initial load duke parents: diff changeset	367 public CheckedExceptionElement[] getCheckedExceptions() {
a61af66fc99e Initial load duke parents: diff changeset	368 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load duke parents: diff changeset	369 Assert.that(hasCheckedExceptions(), "should only be called if table is present");
a61af66fc99e Initial load duke parents: diff changeset	370 }
a61af66fc99e Initial load duke parents: diff changeset	371 CheckedExceptionElement[] ret = new CheckedExceptionElement[getCheckedExceptionsLength()];
a61af66fc99e Initial load duke parents: diff changeset	372 long offset = offsetOfCheckedExceptions();
a61af66fc99e Initial load duke parents: diff changeset	373 for (int i = 0; i < ret.length; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	374 ret[i] = new CheckedExceptionElement(getAddress(), offset);
0 a61af66fc99e Initial load duke parents: diff changeset	375 offset += checkedExceptionElementSize;
a61af66fc99e Initial load duke parents: diff changeset	376 }
a61af66fc99e Initial load duke parents: diff changeset	377 return ret;
a61af66fc99e Initial load duke parents: diff changeset	378 }
a61af66fc99e Initial load duke parents: diff changeset	379
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	380 private boolean hasGenericSignature() {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	381 return (getFlags() & HAS_GENERIC_SIGNATURE) != 0;
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	382 }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	383
0 a61af66fc99e Initial load duke parents: diff changeset	384
a61af66fc99e Initial load duke parents: diff changeset	385 //---------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	386 // Internals only below this point
a61af66fc99e Initial load duke parents: diff changeset	387 //
a61af66fc99e Initial load duke parents: diff changeset	388
a61af66fc99e Initial load duke parents: diff changeset	389 private boolean isNative() {
a61af66fc99e Initial load duke parents: diff changeset	390 return getMethod().isNative();
a61af66fc99e Initial load duke parents: diff changeset	391 }
a61af66fc99e Initial load duke parents: diff changeset	392
a61af66fc99e Initial load duke parents: diff changeset	393 // Offset of end of code
a61af66fc99e Initial load duke parents: diff changeset	394 private long offsetOfCodeEnd() {
a61af66fc99e Initial load duke parents: diff changeset	395 return bytecodeOffset + getCodeSize();
a61af66fc99e Initial load duke parents: diff changeset	396 }
a61af66fc99e Initial load duke parents: diff changeset	397
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	398 // Offset of start of compressed line number table (see method.hpp)
0 a61af66fc99e Initial load duke parents: diff changeset	399 private long offsetOfCompressedLineNumberTable() {
a61af66fc99e Initial load duke parents: diff changeset	400 return offsetOfCodeEnd() + (isNative() ? 2 * VM.getVM().getAddressSize() : 0);
a61af66fc99e Initial load duke parents: diff changeset	401 }
a61af66fc99e Initial load duke parents: diff changeset	402
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	403 // Offset of last short in Method*
0 a61af66fc99e Initial load duke parents: diff changeset	404 private long offsetOfLastU2Element() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	405 return getSize() * VM.getVM().getObjectHeap().getOopSize() - 2;
0 a61af66fc99e Initial load duke parents: diff changeset	406 }
a61af66fc99e Initial load duke parents: diff changeset	407
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	408 // Offset of the generic signature index
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	409 private long offsetOfGenericSignatureIndex() {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	410 return offsetOfLastU2Element();
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	411 }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	412
0 a61af66fc99e Initial load duke parents: diff changeset	413 private long offsetOfCheckedExceptionsLength() {
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	414 return hasGenericSignature() ? offsetOfLastU2Element() - 2 :
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	415 offsetOfLastU2Element();
0 a61af66fc99e Initial load duke parents: diff changeset	416 }
a61af66fc99e Initial load duke parents: diff changeset	417
a61af66fc99e Initial load duke parents: diff changeset	418 private int getCheckedExceptionsLength() {
a61af66fc99e Initial load duke parents: diff changeset	419 if (hasCheckedExceptions()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	420 return (int) getAddress().getCIntegerAt(offsetOfCheckedExceptionsLength(), 2, true);
0 a61af66fc99e Initial load duke parents: diff changeset	421 } else {
a61af66fc99e Initial load duke parents: diff changeset	422 return 0;
a61af66fc99e Initial load duke parents: diff changeset	423 }
a61af66fc99e Initial load duke parents: diff changeset	424 }
a61af66fc99e Initial load duke parents: diff changeset	425
a61af66fc99e Initial load duke parents: diff changeset	426 // Offset of start of checked exceptions
a61af66fc99e Initial load duke parents: diff changeset	427 private long offsetOfCheckedExceptions() {
a61af66fc99e Initial load duke parents: diff changeset	428 long offset = offsetOfCheckedExceptionsLength();
a61af66fc99e Initial load duke parents: diff changeset	429 long length = getCheckedExceptionsLength();
a61af66fc99e Initial load duke parents: diff changeset	430 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load duke parents: diff changeset	431 Assert.that(length > 0, "should only be called if table is present");
a61af66fc99e Initial load duke parents: diff changeset	432 }
a61af66fc99e Initial load duke parents: diff changeset	433 offset -= length * checkedExceptionElementSize;
a61af66fc99e Initial load duke parents: diff changeset	434 return offset;
a61af66fc99e Initial load duke parents: diff changeset	435 }
a61af66fc99e Initial load duke parents: diff changeset	436
a61af66fc99e Initial load duke parents: diff changeset	437 private int getLineNumberTableLength() {
a61af66fc99e Initial load duke parents: diff changeset	438 int len = 0;
a61af66fc99e Initial load duke parents: diff changeset	439 if (hasLineNumberTable()) {
a61af66fc99e Initial load duke parents: diff changeset	440 CompressedLineNumberReadStream stream =
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	441 new CompressedLineNumberReadStream(getAddress(), (int) offsetOfCompressedLineNumberTable());
0 a61af66fc99e Initial load duke parents: diff changeset	442 while (stream.readPair()) {
a61af66fc99e Initial load duke parents: diff changeset	443 len += 1;
a61af66fc99e Initial load duke parents: diff changeset	444 }
a61af66fc99e Initial load duke parents: diff changeset	445 }
a61af66fc99e Initial load duke parents: diff changeset	446 return len;
a61af66fc99e Initial load duke parents: diff changeset	447 }
a61af66fc99e Initial load duke parents: diff changeset	448
a61af66fc99e Initial load duke parents: diff changeset	449 private int getLocalVariableTableLength() {
a61af66fc99e Initial load duke parents: diff changeset	450 if (hasLocalVariableTable()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	451 return (int) getAddress().getCIntegerAt(offsetOfLocalVariableTableLength(), 2, true);
0 a61af66fc99e Initial load duke parents: diff changeset	452 } else {
a61af66fc99e Initial load duke parents: diff changeset	453 return 0;
a61af66fc99e Initial load duke parents: diff changeset	454 }
a61af66fc99e Initial load duke parents: diff changeset	455 }
a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	457 // Offset of local variable table length
a61af66fc99e Initial load duke parents: diff changeset	458 private long offsetOfLocalVariableTableLength() {
a61af66fc99e Initial load duke parents: diff changeset	459 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load duke parents: diff changeset	460 Assert.that(hasLocalVariableTable(), "should only be called if table is present");
a61af66fc99e Initial load duke parents: diff changeset	461 }
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	462
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	463 if (hasExceptionTable()) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	464 return offsetOfExceptionTable() - 2;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	465 } else if (hasCheckedExceptions()) {
0 a61af66fc99e Initial load duke parents: diff changeset	466 return offsetOfCheckedExceptions() - 2;
a61af66fc99e Initial load duke parents: diff changeset	467 } else {
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	468 return hasGenericSignature() ? offsetOfLastU2Element() - 2 :
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	469 offsetOfLastU2Element();
0 a61af66fc99e Initial load duke parents: diff changeset	470 }
a61af66fc99e Initial load duke parents: diff changeset	471 }
a61af66fc99e Initial load duke parents: diff changeset	472
a61af66fc99e Initial load duke parents: diff changeset	473 private long offsetOfLocalVariableTable() {
a61af66fc99e Initial load duke parents: diff changeset	474 long offset = offsetOfLocalVariableTableLength();
a61af66fc99e Initial load duke parents: diff changeset	475 long length = getLocalVariableTableLength();
a61af66fc99e Initial load duke parents: diff changeset	476 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load duke parents: diff changeset	477 Assert.that(length > 0, "should only be called if table is present");
a61af66fc99e Initial load duke parents: diff changeset	478 }
a61af66fc99e Initial load duke parents: diff changeset	479 offset -= length * localVariableTableElementSize;
a61af66fc99e Initial load duke parents: diff changeset	480 return offset;
a61af66fc99e Initial load duke parents: diff changeset	481 }
a61af66fc99e Initial load duke parents: diff changeset	482
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	483 private int getExceptionTableLength() {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	484 if (hasExceptionTable()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6213 diff changeset	485 return (int) getAddress().getCIntegerAt(offsetOfExceptionTableLength(), 2, true);
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	486 } else {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	487 return 0;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	488 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	489 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	490
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	491 private long offsetOfExceptionTableLength() {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	492 if (Assert.ASSERTS_ENABLED) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	493 Assert.that(hasExceptionTable(), "should only be called if table is present");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	494 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	495 if (hasCheckedExceptions()) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	496 return offsetOfCheckedExceptions() - 2;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	497 } else {
7183 b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	498 return hasGenericSignature() ? offsetOfLastU2Element() - 2 :
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. jiangli parents: 6725 diff changeset	499 offsetOfLastU2Element();
6213 8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	500 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	501 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	502
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	503 private long offsetOfExceptionTable() {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	504 long offset = offsetOfExceptionTableLength();
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	505 long length = getExceptionTableLength();
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	506 if (Assert.ASSERTS_ENABLED) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	507 Assert.that(length > 0, "should only be called if table is present");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	508 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	509 offset -= length * exceptionTableElementSize;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	510 return offset;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	511 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table. jiangli parents: 6123 diff changeset	512
0 a61af66fc99e Initial load duke parents: diff changeset	513 }

Mercurial > hg > truffle

annotate agent/src/share/classes/sun/jvm/hotspot/oops/ConstMethod.java @ 7402:fd74228fd5ca