Mercurial > hg > graal-jvmci-8

annotate agent/src/share/classes/sun/jvm/hotspot/oops/ConstMethod.java @ 7183:b2dbd323c668

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. Summary: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod. Reviewed-by: bdelsart, sspitsyn, coleenp
author jiangli
date Tue, 27 Nov 2012 17:03:56 -0500
parents da91efe96a93
children fd74228fd5ca
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
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);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
72
a61af66fc99e Initial load
duke
parents:
diff changeset
73 // start of byte code
a61af66fc99e Initial load
duke
parents:
diff changeset
74 bytecodeOffset = type.getSize();
a61af66fc99e Initial load
duke
parents:
diff changeset
75
a61af66fc99e Initial load
duke
parents:
diff changeset
76 type = db.lookupType("CheckedExceptionElement");
a61af66fc99e Initial load
duke
parents:
diff changeset
77 checkedExceptionElementSize = type.getSize();
a61af66fc99e Initial load
duke
parents:
diff changeset
78
a61af66fc99e Initial load
duke
parents:
diff changeset
79 type = db.lookupType("LocalVariableTableElement");
a61af66fc99e Initial load
duke
parents:
diff changeset
80 localVariableTableElementSize = type.getSize();
6213
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
81
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
82 type = db.lookupType("ExceptionTableElement");
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
83 exceptionTableElementSize = type.getSize();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
84 }
a61af66fc99e Initial load
duke
parents:
diff changeset
85
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
86 public ConstMethod(Address addr) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
87 super(addr);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
88 }
a61af66fc99e Initial load
duke
parents:
diff changeset
89
a61af66fc99e Initial load
duke
parents:
diff changeset
90 // Fields
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
91 private static MetadataField constants;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
92 private static CIntField constMethodSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
93 private static ByteField flags;
a61af66fc99e Initial load
duke
parents:
diff changeset
94 private static CIntField codeSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
95 private static CIntField nameIndex;
a61af66fc99e Initial load
duke
parents:
diff changeset
96 private static CIntField signatureIndex;
6123
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 3838
diff changeset
97 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
98 private static CIntField maxStack;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
99
a61af66fc99e Initial load
duke
parents:
diff changeset
100 // start of bytecode
a61af66fc99e Initial load
duke
parents:
diff changeset
101 private static long bytecodeOffset;
a61af66fc99e Initial load
duke
parents:
diff changeset
102
a61af66fc99e Initial load
duke
parents:
diff changeset
103 private static long checkedExceptionElementSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
104 private static long localVariableTableElementSize;
6213
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
105 private static long exceptionTableElementSize;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
106
6123
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 3838
diff changeset
107 public Method getMethod() {
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 3838
diff changeset
108 InstanceKlass ik = (InstanceKlass)getConstants().getPoolHolder();
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
109 MethodArray methods = ik.getMethods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
110 return methods.at((int)getIdNum());
6123
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 3838
diff changeset
111 }
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 3838
diff changeset
112
0
a61af66fc99e Initial load
duke
parents:
diff changeset
113 // Accessors for declared fields
6123
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 3838
diff changeset
114 public ConstantPool getConstants() {
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 3838
diff changeset
115 return (ConstantPool) constants.getValue(this);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
116 }
a61af66fc99e Initial load
duke
parents:
diff changeset
117
a61af66fc99e Initial load
duke
parents:
diff changeset
118 public long getConstMethodSize() {
a61af66fc99e Initial load
duke
parents:
diff changeset
119 return constMethodSize.getValue(this);
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 byte getFlags() {
a61af66fc99e Initial load
duke
parents:
diff changeset
123 return flags.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 long getCodeSize() {
a61af66fc99e Initial load
duke
parents:
diff changeset
127 return codeSize.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 getNameIndex() {
a61af66fc99e Initial load
duke
parents:
diff changeset
131 return nameIndex.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 getSignatureIndex() {
a61af66fc99e Initial load
duke
parents:
diff changeset
135 return signatureIndex.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 getGenericSignatureIndex() {
7183
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
139 if (hasGenericSignature()) {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
140 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
141 } else {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
142 return 0;
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
143 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
144 }
a61af66fc99e Initial load
duke
parents:
diff changeset
145
6123
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 3838
diff changeset
146 public long getIdNum() {
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 3838
diff changeset
147 return idnum.getValue(this);
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 3838
diff changeset
148 }
2fe087c3e814 7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents: 3838
diff changeset
149
7183
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
150 public long getMaxStack() {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
151 return maxStack.getValue(this);
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
152 }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
153
0
a61af66fc99e Initial load
duke
parents:
diff changeset
154 public Symbol getName() {
a61af66fc99e Initial load
duke
parents:
diff changeset
155 return getMethod().getName();
a61af66fc99e Initial load
duke
parents:
diff changeset
156 }
a61af66fc99e Initial load
duke
parents:
diff changeset
157
a61af66fc99e Initial load
duke
parents:
diff changeset
158 public Symbol getSignature() {
a61af66fc99e Initial load
duke
parents:
diff changeset
159 return getMethod().getSignature();
a61af66fc99e Initial load
duke
parents:
diff changeset
160 }
a61af66fc99e Initial load
duke
parents:
diff changeset
161
a61af66fc99e Initial load
duke
parents:
diff changeset
162 public Symbol getGenericSignature() {
a61af66fc99e Initial load
duke
parents:
diff changeset
163 return getMethod().getGenericSignature();
a61af66fc99e Initial load
duke
parents:
diff changeset
164 }
a61af66fc99e Initial load
duke
parents:
diff changeset
165
a61af66fc99e Initial load
duke
parents:
diff changeset
166 // bytecode accessors
a61af66fc99e Initial load
duke
parents:
diff changeset
167
a61af66fc99e Initial load
duke
parents:
diff changeset
168 /** Get a bytecode or breakpoint at the given bci */
a61af66fc99e Initial load
duke
parents:
diff changeset
169 public int getBytecodeOrBPAt(int bci) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
170 return getAddress().getJByteAt(bytecodeOffset + bci) & 0xFF;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
171 }
a61af66fc99e Initial load
duke
parents:
diff changeset
172
a61af66fc99e Initial load
duke
parents:
diff changeset
173 public byte getBytecodeByteArg(int bci) {
a61af66fc99e Initial load
duke
parents:
diff changeset
174 return (byte) getBytecodeOrBPAt(bci);
a61af66fc99e Initial load
duke
parents:
diff changeset
175 }
a61af66fc99e Initial load
duke
parents:
diff changeset
176
a61af66fc99e Initial load
duke
parents:
diff changeset
177 /** Fetches a 16-bit big-endian ("Java ordered") value from the
a61af66fc99e Initial load
duke
parents:
diff changeset
178 bytecode stream */
a61af66fc99e Initial load
duke
parents:
diff changeset
179 public short getBytecodeShortArg(int bci) {
a61af66fc99e Initial load
duke
parents:
diff changeset
180 int hi = getBytecodeOrBPAt(bci);
a61af66fc99e Initial load
duke
parents:
diff changeset
181 int lo = getBytecodeOrBPAt(bci + 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
182 return (short) ((hi << 8) | lo);
a61af66fc99e Initial load
duke
parents:
diff changeset
183 }
a61af66fc99e Initial load
duke
parents:
diff changeset
184
3838
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
185 /** 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
186 bytecode stream */
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
187 public short getNativeShortArg(int bci) {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
188 int hi = getBytecodeOrBPAt(bci);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
189 int lo = getBytecodeOrBPAt(bci + 1);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
190 if (VM.getVM().isBigEndian()) {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
191 return (short) ((hi << 8) | lo);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
192 } else {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
193 return (short) ((lo << 8) | hi);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
194 }
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
195 }
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
196
0
a61af66fc99e Initial load
duke
parents:
diff changeset
197 /** Fetches a 32-bit big-endian ("Java ordered") value from the
a61af66fc99e Initial load
duke
parents:
diff changeset
198 bytecode stream */
a61af66fc99e Initial load
duke
parents:
diff changeset
199 public int getBytecodeIntArg(int bci) {
a61af66fc99e Initial load
duke
parents:
diff changeset
200 int b4 = getBytecodeOrBPAt(bci);
a61af66fc99e Initial load
duke
parents:
diff changeset
201 int b3 = getBytecodeOrBPAt(bci + 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
202 int b2 = getBytecodeOrBPAt(bci + 2);
a61af66fc99e Initial load
duke
parents:
diff changeset
203 int b1 = getBytecodeOrBPAt(bci + 3);
a61af66fc99e Initial load
duke
parents:
diff changeset
204
a61af66fc99e Initial load
duke
parents:
diff changeset
205 return (b4 << 24) | (b3 << 16) | (b2 << 8) | b1;
a61af66fc99e Initial load
duke
parents:
diff changeset
206 }
a61af66fc99e Initial load
duke
parents:
diff changeset
207
3838
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
208 /** 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
209 bytecode stream */
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
210 public int getNativeIntArg(int bci) {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
211 int b4 = getBytecodeOrBPAt(bci);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
212 int b3 = getBytecodeOrBPAt(bci + 1);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
213 int b2 = getBytecodeOrBPAt(bci + 2);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
214 int b1 = getBytecodeOrBPAt(bci + 3);
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
215
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
216 if (VM.getVM().isBigEndian()) {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
217 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
218 } else {
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
219 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
220 }
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
221 }
6a991dcb52bb 7012081: JSR 292: SA-JDI can't read MH/MT/Indy ConstantPool entries
never
parents: 1552
diff changeset
222
0
a61af66fc99e Initial load
duke
parents:
diff changeset
223 public byte[] getByteCode() {
a61af66fc99e Initial load
duke
parents:
diff changeset
224 byte[] bc = new byte[ (int) getCodeSize() ];
a61af66fc99e Initial load
duke
parents:
diff changeset
225 for( int i=0; i < bc.length; i++ )
a61af66fc99e Initial load
duke
parents:
diff changeset
226 {
a61af66fc99e Initial load
duke
parents:
diff changeset
227 long offs = bytecodeOffset + i;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
228 bc[i] = getAddress().getJByteAt( offs );
0
a61af66fc99e Initial load
duke
parents:
diff changeset
229 }
a61af66fc99e Initial load
duke
parents:
diff changeset
230 return bc;
a61af66fc99e Initial load
duke
parents:
diff changeset
231 }
a61af66fc99e Initial load
duke
parents:
diff changeset
232
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
233 public long getSize() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
234 return getConstMethodSize();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
235 }
a61af66fc99e Initial load
duke
parents:
diff changeset
236
a61af66fc99e Initial load
duke
parents:
diff changeset
237 public void printValueOn(PrintStream tty) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
238 tty.print("ConstMethod " + getName().asString() + getSignature().asString() + "@" + getAddress());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
239 }
a61af66fc99e Initial load
duke
parents:
diff changeset
240
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
241 public void iterateFields(MetadataVisitor visitor) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
242 visitor.doMetadata(constants, true);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
243 visitor.doCInt(constMethodSize, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
244 visitor.doByte(flags, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
245 visitor.doCInt(codeSize, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
246 visitor.doCInt(nameIndex, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
247 visitor.doCInt(signatureIndex, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
248 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
249 visitor.doCInt(maxStack, true);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
250 }
a61af66fc99e Initial load
duke
parents:
diff changeset
251
a61af66fc99e Initial load
duke
parents:
diff changeset
252 // Accessors
a61af66fc99e Initial load
duke
parents:
diff changeset
253
a61af66fc99e Initial load
duke
parents:
diff changeset
254 public boolean hasLineNumberTable() {
a61af66fc99e Initial load
duke
parents:
diff changeset
255 return (getFlags() & HAS_LINENUMBER_TABLE) != 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
256 }
a61af66fc99e Initial load
duke
parents:
diff changeset
257
a61af66fc99e Initial load
duke
parents:
diff changeset
258 public int getLineNumberFromBCI(int bci) {
a61af66fc99e Initial load
duke
parents:
diff changeset
259 if (!VM.getVM().isCore()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
260 if (bci == DebugInformationRecorder.SYNCHRONIZATION_ENTRY_BCI) bci = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
261 }
a61af66fc99e Initial load
duke
parents:
diff changeset
262
a61af66fc99e Initial load
duke
parents:
diff changeset
263 if (isNative()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
264 return -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
265 }
a61af66fc99e Initial load
duke
parents:
diff changeset
266
a61af66fc99e Initial load
duke
parents:
diff changeset
267 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load
duke
parents:
diff changeset
268 Assert.that(bci == 0 || 0 <= bci && bci < getCodeSize(), "illegal bci");
a61af66fc99e Initial load
duke
parents:
diff changeset
269 }
a61af66fc99e Initial load
duke
parents:
diff changeset
270 int bestBCI = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
271 int bestLine = -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
272 if (hasLineNumberTable()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
273 // The line numbers are a short array of 2-tuples [start_pc, line_number].
a61af66fc99e Initial load
duke
parents:
diff changeset
274 // Not necessarily sorted and not necessarily one-to-one.
a61af66fc99e Initial load
duke
parents:
diff changeset
275 CompressedLineNumberReadStream stream =
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
276 new CompressedLineNumberReadStream(getAddress(), (int) offsetOfCompressedLineNumberTable());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
277 while (stream.readPair()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
278 if (stream.bci() == bci) {
a61af66fc99e Initial load
duke
parents:
diff changeset
279 // perfect match
a61af66fc99e Initial load
duke
parents:
diff changeset
280 return stream.line();
a61af66fc99e Initial load
duke
parents:
diff changeset
281 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
282 // update best_bci/line
a61af66fc99e Initial load
duke
parents:
diff changeset
283 if (stream.bci() < bci && stream.bci() >= bestBCI) {
a61af66fc99e Initial load
duke
parents:
diff changeset
284 bestBCI = stream.bci();
a61af66fc99e Initial load
duke
parents:
diff changeset
285 bestLine = stream.line();
a61af66fc99e Initial load
duke
parents:
diff changeset
286 }
a61af66fc99e Initial load
duke
parents:
diff changeset
287 }
a61af66fc99e Initial load
duke
parents:
diff changeset
288 }
a61af66fc99e Initial load
duke
parents:
diff changeset
289 }
a61af66fc99e Initial load
duke
parents:
diff changeset
290 return bestLine;
a61af66fc99e Initial load
duke
parents:
diff changeset
291 }
a61af66fc99e Initial load
duke
parents:
diff changeset
292
a61af66fc99e Initial load
duke
parents:
diff changeset
293 public LineNumberTableElement[] getLineNumberTable() {
a61af66fc99e Initial load
duke
parents:
diff changeset
294 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load
duke
parents:
diff changeset
295 Assert.that(hasLineNumberTable(),
a61af66fc99e Initial load
duke
parents:
diff changeset
296 "should only be called if table is present");
a61af66fc99e Initial load
duke
parents:
diff changeset
297 }
a61af66fc99e Initial load
duke
parents:
diff changeset
298 int len = getLineNumberTableLength();
a61af66fc99e Initial load
duke
parents:
diff changeset
299 CompressedLineNumberReadStream stream =
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
300 new CompressedLineNumberReadStream(getAddress(), (int) offsetOfCompressedLineNumberTable());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
301 LineNumberTableElement[] ret = new LineNumberTableElement[len];
a61af66fc99e Initial load
duke
parents:
diff changeset
302
a61af66fc99e Initial load
duke
parents:
diff changeset
303 for (int idx = 0; idx < len; idx++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
304 stream.readPair();
a61af66fc99e Initial load
duke
parents:
diff changeset
305 ret[idx] = new LineNumberTableElement(stream.bci(), stream.line());
a61af66fc99e Initial load
duke
parents:
diff changeset
306 }
a61af66fc99e Initial load
duke
parents:
diff changeset
307 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
308 }
a61af66fc99e Initial load
duke
parents:
diff changeset
309
a61af66fc99e Initial load
duke
parents:
diff changeset
310 public boolean hasLocalVariableTable() {
a61af66fc99e Initial load
duke
parents:
diff changeset
311 return (getFlags() & HAS_LOCALVARIABLE_TABLE) != 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
312 }
a61af66fc99e Initial load
duke
parents:
diff changeset
313
a61af66fc99e Initial load
duke
parents:
diff changeset
314 public Symbol getLocalVariableName(int bci, int slot) {
a61af66fc99e Initial load
duke
parents:
diff changeset
315 return getMethod().getLocalVariableName(bci, slot);
a61af66fc99e Initial load
duke
parents:
diff changeset
316 }
a61af66fc99e Initial load
duke
parents:
diff changeset
317
a61af66fc99e Initial load
duke
parents:
diff changeset
318 /** Should only be called if table is present */
a61af66fc99e Initial load
duke
parents:
diff changeset
319 public LocalVariableTableElement[] getLocalVariableTable() {
a61af66fc99e Initial load
duke
parents:
diff changeset
320 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load
duke
parents:
diff changeset
321 Assert.that(hasLocalVariableTable(), "should only be called if table is present");
a61af66fc99e Initial load
duke
parents:
diff changeset
322 }
a61af66fc99e Initial load
duke
parents:
diff changeset
323 LocalVariableTableElement[] ret = new LocalVariableTableElement[getLocalVariableTableLength()];
a61af66fc99e Initial load
duke
parents:
diff changeset
324 long offset = offsetOfLocalVariableTable();
a61af66fc99e Initial load
duke
parents:
diff changeset
325 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
326 ret[i] = new LocalVariableTableElement(getAddress(), offset);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
327 offset += localVariableTableElementSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
328 }
a61af66fc99e Initial load
duke
parents:
diff changeset
329 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
330 }
a61af66fc99e Initial load
duke
parents:
diff changeset
331
6213
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
332 public boolean hasExceptionTable() {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
333 return (getFlags() & HAS_EXCEPTION_TABLE) != 0;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
334 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
335
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
336 public ExceptionTableElement[] getExceptionTable() {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
337 if (Assert.ASSERTS_ENABLED) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
338 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
339 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
340 ExceptionTableElement[] ret = new ExceptionTableElement[getExceptionTableLength()];
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
341 long offset = offsetOfExceptionTable();
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
342 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
343 ret[i] = new ExceptionTableElement(getAddress(), offset);
6213
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
344 offset += exceptionTableElementSize;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
345 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
346 return ret;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
347 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
348
0
a61af66fc99e Initial load
duke
parents:
diff changeset
349 public boolean hasCheckedExceptions() {
a61af66fc99e Initial load
duke
parents:
diff changeset
350 return (getFlags() & HAS_CHECKED_EXCEPTIONS) != 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
351 }
a61af66fc99e Initial load
duke
parents:
diff changeset
352
a61af66fc99e Initial load
duke
parents:
diff changeset
353 public CheckedExceptionElement[] getCheckedExceptions() {
a61af66fc99e Initial load
duke
parents:
diff changeset
354 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load
duke
parents:
diff changeset
355 Assert.that(hasCheckedExceptions(), "should only be called if table is present");
a61af66fc99e Initial load
duke
parents:
diff changeset
356 }
a61af66fc99e Initial load
duke
parents:
diff changeset
357 CheckedExceptionElement[] ret = new CheckedExceptionElement[getCheckedExceptionsLength()];
a61af66fc99e Initial load
duke
parents:
diff changeset
358 long offset = offsetOfCheckedExceptions();
a61af66fc99e Initial load
duke
parents:
diff changeset
359 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
360 ret[i] = new CheckedExceptionElement(getAddress(), offset);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
361 offset += checkedExceptionElementSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
362 }
a61af66fc99e Initial load
duke
parents:
diff changeset
363 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
364 }
a61af66fc99e Initial load
duke
parents:
diff changeset
365
7183
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
366 private boolean hasGenericSignature() {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
367 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
368 }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
369
0
a61af66fc99e Initial load
duke
parents:
diff changeset
370
a61af66fc99e Initial load
duke
parents:
diff changeset
371 //---------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
372 // Internals only below this point
a61af66fc99e Initial load
duke
parents:
diff changeset
373 //
a61af66fc99e Initial load
duke
parents:
diff changeset
374
a61af66fc99e Initial load
duke
parents:
diff changeset
375 private boolean isNative() {
a61af66fc99e Initial load
duke
parents:
diff changeset
376 return getMethod().isNative();
a61af66fc99e Initial load
duke
parents:
diff changeset
377 }
a61af66fc99e Initial load
duke
parents:
diff changeset
378
a61af66fc99e Initial load
duke
parents:
diff changeset
379 // Offset of end of code
a61af66fc99e Initial load
duke
parents:
diff changeset
380 private long offsetOfCodeEnd() {
a61af66fc99e Initial load
duke
parents:
diff changeset
381 return bytecodeOffset + getCodeSize();
a61af66fc99e Initial load
duke
parents:
diff changeset
382 }
a61af66fc99e Initial load
duke
parents:
diff changeset
383
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
384 // Offset of start of compressed line number table (see method.hpp)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
385 private long offsetOfCompressedLineNumberTable() {
a61af66fc99e Initial load
duke
parents:
diff changeset
386 return offsetOfCodeEnd() + (isNative() ? 2 * VM.getVM().getAddressSize() : 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
387 }
a61af66fc99e Initial load
duke
parents:
diff changeset
388
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
389 // Offset of last short in Method*
0
a61af66fc99e Initial load
duke
parents:
diff changeset
390 private long offsetOfLastU2Element() {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
391 return getSize() * VM.getVM().getObjectHeap().getOopSize() - 2;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
392 }
a61af66fc99e Initial load
duke
parents:
diff changeset
393
7183
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
394 // 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
395 private long offsetOfGenericSignatureIndex() {
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
396 return offsetOfLastU2Element();
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
397 }
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
398
0
a61af66fc99e Initial load
duke
parents:
diff changeset
399 private long offsetOfCheckedExceptionsLength() {
7183
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
400 return hasGenericSignature() ? offsetOfLastU2Element() - 2 :
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
401 offsetOfLastU2Element();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
402 }
a61af66fc99e Initial load
duke
parents:
diff changeset
403
a61af66fc99e Initial load
duke
parents:
diff changeset
404 private int getCheckedExceptionsLength() {
a61af66fc99e Initial load
duke
parents:
diff changeset
405 if (hasCheckedExceptions()) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
406 return (int) getAddress().getCIntegerAt(offsetOfCheckedExceptionsLength(), 2, true);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
407 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
408 return 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
409 }
a61af66fc99e Initial load
duke
parents:
diff changeset
410 }
a61af66fc99e Initial load
duke
parents:
diff changeset
411
a61af66fc99e Initial load
duke
parents:
diff changeset
412 // Offset of start of checked exceptions
a61af66fc99e Initial load
duke
parents:
diff changeset
413 private long offsetOfCheckedExceptions() {
a61af66fc99e Initial load
duke
parents:
diff changeset
414 long offset = offsetOfCheckedExceptionsLength();
a61af66fc99e Initial load
duke
parents:
diff changeset
415 long length = getCheckedExceptionsLength();
a61af66fc99e Initial load
duke
parents:
diff changeset
416 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load
duke
parents:
diff changeset
417 Assert.that(length > 0, "should only be called if table is present");
a61af66fc99e Initial load
duke
parents:
diff changeset
418 }
a61af66fc99e Initial load
duke
parents:
diff changeset
419 offset -= length * checkedExceptionElementSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
420 return offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
421 }
a61af66fc99e Initial load
duke
parents:
diff changeset
422
a61af66fc99e Initial load
duke
parents:
diff changeset
423 private int getLineNumberTableLength() {
a61af66fc99e Initial load
duke
parents:
diff changeset
424 int len = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
425 if (hasLineNumberTable()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
426 CompressedLineNumberReadStream stream =
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
427 new CompressedLineNumberReadStream(getAddress(), (int) offsetOfCompressedLineNumberTable());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
428 while (stream.readPair()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
429 len += 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
430 }
a61af66fc99e Initial load
duke
parents:
diff changeset
431 }
a61af66fc99e Initial load
duke
parents:
diff changeset
432 return len;
a61af66fc99e Initial load
duke
parents:
diff changeset
433 }
a61af66fc99e Initial load
duke
parents:
diff changeset
434
a61af66fc99e Initial load
duke
parents:
diff changeset
435 private int getLocalVariableTableLength() {
a61af66fc99e Initial load
duke
parents:
diff changeset
436 if (hasLocalVariableTable()) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
437 return (int) getAddress().getCIntegerAt(offsetOfLocalVariableTableLength(), 2, true);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
438 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
439 return 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
440 }
a61af66fc99e Initial load
duke
parents:
diff changeset
441 }
a61af66fc99e Initial load
duke
parents:
diff changeset
442
a61af66fc99e Initial load
duke
parents:
diff changeset
443 // Offset of local variable table length
a61af66fc99e Initial load
duke
parents:
diff changeset
444 private long offsetOfLocalVariableTableLength() {
a61af66fc99e Initial load
duke
parents:
diff changeset
445 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load
duke
parents:
diff changeset
446 Assert.that(hasLocalVariableTable(), "should only be called if table is present");
a61af66fc99e Initial load
duke
parents:
diff changeset
447 }
6213
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
448
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
449 if (hasExceptionTable()) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
450 return offsetOfExceptionTable() - 2;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
451 } else if (hasCheckedExceptions()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
452 return offsetOfCheckedExceptions() - 2;
a61af66fc99e Initial load
duke
parents:
diff changeset
453 } else {
7183
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
454 return hasGenericSignature() ? offsetOfLastU2Element() - 2 :
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
455 offsetOfLastU2Element();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
456 }
a61af66fc99e Initial load
duke
parents:
diff changeset
457 }
a61af66fc99e Initial load
duke
parents:
diff changeset
458
a61af66fc99e Initial load
duke
parents:
diff changeset
459 private long offsetOfLocalVariableTable() {
a61af66fc99e Initial load
duke
parents:
diff changeset
460 long offset = offsetOfLocalVariableTableLength();
a61af66fc99e Initial load
duke
parents:
diff changeset
461 long length = getLocalVariableTableLength();
a61af66fc99e Initial load
duke
parents:
diff changeset
462 if (Assert.ASSERTS_ENABLED) {
a61af66fc99e Initial load
duke
parents:
diff changeset
463 Assert.that(length > 0, "should only be called if table is present");
a61af66fc99e Initial load
duke
parents:
diff changeset
464 }
a61af66fc99e Initial load
duke
parents:
diff changeset
465 offset -= length * localVariableTableElementSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
466 return offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
467 }
a61af66fc99e Initial load
duke
parents:
diff changeset
468
6213
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
469 private int getExceptionTableLength() {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
470 if (hasExceptionTable()) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6213
diff changeset
471 return (int) getAddress().getCIntegerAt(offsetOfExceptionTableLength(), 2, true);
6213
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
472 } else {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
473 return 0;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
474 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
475 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
476
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
477 private long offsetOfExceptionTableLength() {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
478 if (Assert.ASSERTS_ENABLED) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
479 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
480 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
481 if (hasCheckedExceptions()) {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
482 return offsetOfCheckedExceptions() - 2;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
483 } else {
7183
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
484 return hasGenericSignature() ? offsetOfLastU2Element() - 2 :
b2dbd323c668 8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents: 6725
diff changeset
485 offsetOfLastU2Element();
6213
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
486 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
487 }
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 private long offsetOfExceptionTable() {
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
490 long offset = offsetOfExceptionTableLength();
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
491 long length = getExceptionTableLength();
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(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
494 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
495 offset -= length * exceptionTableElementSize;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
496 return offset;
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
497 }
8150fa46d2ed 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 6123
diff changeset
498
0
a61af66fc99e Initial load
duke
parents:
diff changeset
499 }