|
1 /* |
|
2 * Copyright 1999-2005 Sun Microsystems, Inc. All Rights Reserved. |
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
4 * |
|
5 * This code is free software; you can redistribute it and/or modify it |
|
6 * under the terms of the GNU General Public License version 2 only, as |
|
7 * published by the Free Software Foundation. |
|
8 * |
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 * version 2 for more details (a copy is included in the LICENSE file that |
|
13 * accompanied this code). |
|
14 * |
|
15 * You should have received a copy of the GNU General Public License version |
|
16 * 2 along with this work; if not, write to the Free Software Foundation, |
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 * |
|
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or |
|
21 * have any questions. |
|
22 * |
|
23 */ |
|
24 |
|
25 #include "incls/_precompiled.incl" |
|
26 #include "incls/_ciStreams.cpp.incl" |
|
27 |
|
28 // ciExceptionHandlerStream |
|
29 // |
|
30 // Walk over some selected set of a methods exception handlers. |
|
31 |
|
32 // ------------------------------------------------------------------ |
|
33 // ciExceptionHandlerStream::count |
|
34 // |
|
35 // How many exception handlers are there in this stream? |
|
36 // |
|
37 // Implementation note: Compiler2 needs this functionality, so I had |
|
38 int ciExceptionHandlerStream::count() { |
|
39 int save_pos = _pos; |
|
40 int save_end = _end; |
|
41 |
|
42 int count = 0; |
|
43 |
|
44 _pos = -1; |
|
45 _end = _method->_handler_count; |
|
46 |
|
47 |
|
48 next(); |
|
49 while (!is_done()) { |
|
50 count++; |
|
51 next(); |
|
52 } |
|
53 |
|
54 _pos = save_pos; |
|
55 _end = save_end; |
|
56 |
|
57 return count; |
|
58 } |
|
59 |
|
60 int ciExceptionHandlerStream::count_remaining() { |
|
61 int save_pos = _pos; |
|
62 int save_end = _end; |
|
63 |
|
64 int count = 0; |
|
65 |
|
66 while (!is_done()) { |
|
67 count++; |
|
68 next(); |
|
69 } |
|
70 |
|
71 _pos = save_pos; |
|
72 _end = save_end; |
|
73 |
|
74 return count; |
|
75 } |
|
76 |
|
77 // ciBytecodeStream |
|
78 // |
|
79 // The class is used to iterate over the bytecodes of a method. |
|
80 // It hides the details of constant pool structure/access by |
|
81 // providing accessors for constant pool items. |
|
82 |
|
83 // ------------------------------------------------------------------ |
|
84 // ciBytecodeStream::wide |
|
85 // |
|
86 // Special handling for the wide bytcode |
|
87 Bytecodes::Code ciBytecodeStream::wide() |
|
88 { |
|
89 // Get following bytecode; do not return wide |
|
90 Bytecodes::Code bc = (Bytecodes::Code)_pc[1]; |
|
91 _pc += 2; // Skip both bytecodes |
|
92 _pc += 2; // Skip index always |
|
93 if( bc == Bytecodes::_iinc ) |
|
94 _pc += 2; // Skip optional constant |
|
95 _was_wide = _pc; // Flag last wide bytecode found |
|
96 return bc; |
|
97 } |
|
98 |
|
99 // ------------------------------------------------------------------ |
|
100 // ciBytecodeStream::table |
|
101 // |
|
102 // Special handling for switch ops |
|
103 Bytecodes::Code ciBytecodeStream::table( Bytecodes::Code bc ) { |
|
104 switch( bc ) { // Check for special bytecode handling |
|
105 |
|
106 case Bytecodes::_lookupswitch: |
|
107 _pc++; // Skip wide bytecode |
|
108 _pc += (_start-_pc)&3; // Word align |
|
109 _table_base = (jint*)_pc; // Capture for later usage |
|
110 // table_base[0] is default far_dest |
|
111 // Table has 2 lead elements (default, length), then pairs of u4 values. |
|
112 // So load table length, and compute address at end of table |
|
113 _pc = (address)&_table_base[2+ 2*Bytes::get_Java_u4((address)&_table_base[1])]; |
|
114 break; |
|
115 |
|
116 case Bytecodes::_tableswitch: { |
|
117 _pc++; // Skip wide bytecode |
|
118 _pc += (_start-_pc)&3; // Word align |
|
119 _table_base = (jint*)_pc; // Capture for later usage |
|
120 // table_base[0] is default far_dest |
|
121 int lo = Bytes::get_Java_u4((address)&_table_base[1]);// Low bound |
|
122 int hi = Bytes::get_Java_u4((address)&_table_base[2]);// High bound |
|
123 int len = hi - lo + 1; // Dense table size |
|
124 _pc = (address)&_table_base[3+len]; // Skip past table |
|
125 break; |
|
126 } |
|
127 |
|
128 default: |
|
129 fatal("unhandled bytecode"); |
|
130 } |
|
131 return bc; |
|
132 } |
|
133 |
|
134 // ------------------------------------------------------------------ |
|
135 // ciBytecodeStream::reset_to_bci |
|
136 void ciBytecodeStream::reset_to_bci( int bci ) { |
|
137 _bc_start=_was_wide=0; |
|
138 _pc = _start+bci; |
|
139 } |
|
140 |
|
141 // ------------------------------------------------------------------ |
|
142 // ciBytecodeStream::force_bci |
|
143 void ciBytecodeStream::force_bci(int bci) { |
|
144 if (bci < 0) { |
|
145 reset_to_bci(0); |
|
146 _bc_start = _start + bci; |
|
147 _bc = EOBC(); |
|
148 } else { |
|
149 reset_to_bci(bci); |
|
150 next(); |
|
151 } |
|
152 } |
|
153 |
|
154 |
|
155 // ------------------------------------------------------------------ |
|
156 // Constant pool access |
|
157 // ------------------------------------------------------------------ |
|
158 |
|
159 // ------------------------------------------------------------------ |
|
160 // ciBytecodeStream::get_klass_index |
|
161 // |
|
162 // If this bytecodes references a klass, return the index of the |
|
163 // referenced klass. |
|
164 int ciBytecodeStream::get_klass_index() const { |
|
165 switch(cur_bc()) { |
|
166 case Bytecodes::_ldc: |
|
167 return get_index(); |
|
168 case Bytecodes::_ldc_w: |
|
169 case Bytecodes::_ldc2_w: |
|
170 case Bytecodes::_checkcast: |
|
171 case Bytecodes::_instanceof: |
|
172 case Bytecodes::_anewarray: |
|
173 case Bytecodes::_multianewarray: |
|
174 case Bytecodes::_new: |
|
175 case Bytecodes::_newarray: |
|
176 return get_index_big(); |
|
177 default: |
|
178 ShouldNotReachHere(); |
|
179 return 0; |
|
180 } |
|
181 } |
|
182 |
|
183 // ------------------------------------------------------------------ |
|
184 // ciBytecodeStream::get_klass |
|
185 // |
|
186 // If this bytecode is a new, newarray, multianewarray, instanceof, |
|
187 // or checkcast, get the referenced klass. |
|
188 ciKlass* ciBytecodeStream::get_klass(bool& will_link) { |
|
189 return CURRENT_ENV->get_klass_by_index(_holder, get_klass_index(), |
|
190 will_link); |
|
191 } |
|
192 |
|
193 // ------------------------------------------------------------------ |
|
194 // ciBytecodeStream::get_constant_index |
|
195 // |
|
196 // If this bytecode is one of the ldc variants, get the index of the |
|
197 // referenced constant. |
|
198 int ciBytecodeStream::get_constant_index() const { |
|
199 switch(cur_bc()) { |
|
200 case Bytecodes::_ldc: |
|
201 return get_index(); |
|
202 case Bytecodes::_ldc_w: |
|
203 case Bytecodes::_ldc2_w: |
|
204 return get_index_big(); |
|
205 default: |
|
206 ShouldNotReachHere(); |
|
207 return 0; |
|
208 } |
|
209 } |
|
210 // ------------------------------------------------------------------ |
|
211 // ciBytecodeStream::get_constant |
|
212 // |
|
213 // If this bytecode is one of the ldc variants, get the referenced |
|
214 // constant. |
|
215 ciConstant ciBytecodeStream::get_constant() { |
|
216 return CURRENT_ENV->get_constant_by_index(_holder, get_constant_index()); |
|
217 } |
|
218 |
|
219 // ------------------------------------------------------------------ |
|
220 bool ciBytecodeStream::is_unresolved_string() const { |
|
221 return CURRENT_ENV->is_unresolved_string(_holder, get_constant_index()); |
|
222 } |
|
223 |
|
224 // ------------------------------------------------------------------ |
|
225 bool ciBytecodeStream::is_unresolved_klass() const { |
|
226 return CURRENT_ENV->is_unresolved_klass(_holder, get_klass_index()); |
|
227 } |
|
228 |
|
229 // ------------------------------------------------------------------ |
|
230 // ciBytecodeStream::get_field_index |
|
231 // |
|
232 // If this is a field access bytecode, get the constant pool |
|
233 // index of the referenced field. |
|
234 int ciBytecodeStream::get_field_index() { |
|
235 assert(cur_bc() == Bytecodes::_getfield || |
|
236 cur_bc() == Bytecodes::_putfield || |
|
237 cur_bc() == Bytecodes::_getstatic || |
|
238 cur_bc() == Bytecodes::_putstatic, "wrong bc"); |
|
239 return get_index_big(); |
|
240 } |
|
241 |
|
242 |
|
243 // ------------------------------------------------------------------ |
|
244 // ciBytecodeStream::get_field |
|
245 // |
|
246 // If this bytecode is one of get_field, get_static, put_field, |
|
247 // or put_static, get the referenced field. |
|
248 ciField* ciBytecodeStream::get_field(bool& will_link) { |
|
249 ciField* f = CURRENT_ENV->get_field_by_index(_holder, get_field_index()); |
|
250 will_link = f->will_link(_holder, _bc); |
|
251 return f; |
|
252 } |
|
253 |
|
254 |
|
255 // ------------------------------------------------------------------ |
|
256 // ciBytecodeStream::get_declared_field_holder |
|
257 // |
|
258 // Get the declared holder of the currently referenced field. |
|
259 // |
|
260 // Usage note: the holder() of a ciField class returns the canonical |
|
261 // holder of the field, rather than the holder declared in the |
|
262 // bytecodes. |
|
263 // |
|
264 // There is no "will_link" result passed back. The user is responsible |
|
265 // for checking linkability when retrieving the associated field. |
|
266 ciInstanceKlass* ciBytecodeStream::get_declared_field_holder() { |
|
267 int holder_index = get_field_holder_index(); |
|
268 bool ignore; |
|
269 return CURRENT_ENV->get_klass_by_index(_holder, holder_index, ignore) |
|
270 ->as_instance_klass(); |
|
271 } |
|
272 |
|
273 // ------------------------------------------------------------------ |
|
274 // ciBytecodeStream::get_field_holder_index |
|
275 // |
|
276 // Get the constant pool index of the declared holder of the field |
|
277 // referenced by the current bytecode. Used for generating |
|
278 // deoptimization information. |
|
279 int ciBytecodeStream::get_field_holder_index() { |
|
280 VM_ENTRY_MARK; |
|
281 constantPoolOop cpool = _holder->get_instanceKlass()->constants(); |
|
282 return cpool->klass_ref_index_at(get_field_index()); |
|
283 } |
|
284 |
|
285 // ------------------------------------------------------------------ |
|
286 // ciBytecodeStream::get_field_signature_index |
|
287 // |
|
288 // Get the constant pool index of the signature of the field |
|
289 // referenced by the current bytecode. Used for generating |
|
290 // deoptimization information. |
|
291 int ciBytecodeStream::get_field_signature_index() { |
|
292 VM_ENTRY_MARK; |
|
293 constantPoolOop cpool = _holder->get_instanceKlass()->constants(); |
|
294 int nt_index = cpool->name_and_type_ref_index_at(get_field_index()); |
|
295 return cpool->signature_ref_index_at(nt_index); |
|
296 } |
|
297 |
|
298 // ------------------------------------------------------------------ |
|
299 // ciBytecodeStream::get_method_index |
|
300 // |
|
301 // If this is a method invocation bytecode, get the constant pool |
|
302 // index of the invoked method. |
|
303 int ciBytecodeStream::get_method_index() { |
|
304 switch (cur_bc()) { |
|
305 case Bytecodes::_invokeinterface: |
|
306 return Bytes::get_Java_u2(_pc-4); |
|
307 case Bytecodes::_invokevirtual: |
|
308 case Bytecodes::_invokespecial: |
|
309 case Bytecodes::_invokestatic: |
|
310 return get_index_big(); |
|
311 default: |
|
312 ShouldNotReachHere(); |
|
313 return 0; |
|
314 } |
|
315 } |
|
316 |
|
317 // ------------------------------------------------------------------ |
|
318 // ciBytecodeStream::get_method |
|
319 // |
|
320 // If this is a method invocation bytecode, get the invoked method. |
|
321 ciMethod* ciBytecodeStream::get_method(bool& will_link) { |
|
322 ciMethod* m = CURRENT_ENV->get_method_by_index(_holder, get_method_index(),cur_bc()); |
|
323 will_link = m->is_loaded(); |
|
324 return m; |
|
325 } |
|
326 |
|
327 // ------------------------------------------------------------------ |
|
328 // ciBytecodeStream::get_declared_method_holder |
|
329 // |
|
330 // Get the declared holder of the currently referenced method. |
|
331 // |
|
332 // Usage note: the holder() of a ciMethod class returns the canonical |
|
333 // holder of the method, rather than the holder declared in the |
|
334 // bytecodes. |
|
335 // |
|
336 // There is no "will_link" result passed back. The user is responsible |
|
337 // for checking linkability when retrieving the associated method. |
|
338 ciKlass* ciBytecodeStream::get_declared_method_holder() { |
|
339 bool ignore; |
|
340 return CURRENT_ENV->get_klass_by_index(_holder, get_method_holder_index(), ignore); |
|
341 } |
|
342 |
|
343 // ------------------------------------------------------------------ |
|
344 // ciBytecodeStream::get_method_holder_index |
|
345 // |
|
346 // Get the constant pool index of the declared holder of the method |
|
347 // referenced by the current bytecode. Used for generating |
|
348 // deoptimization information. |
|
349 int ciBytecodeStream::get_method_holder_index() { |
|
350 VM_ENTRY_MARK; |
|
351 constantPoolOop cpool = _holder->get_instanceKlass()->constants(); |
|
352 return cpool->klass_ref_index_at(get_method_index()); |
|
353 } |
|
354 |
|
355 // ------------------------------------------------------------------ |
|
356 // ciBytecodeStream::get_method_signature_index |
|
357 // |
|
358 // Get the constant pool index of the signature of the method |
|
359 // referenced by the current bytecode. Used for generating |
|
360 // deoptimization information. |
|
361 int ciBytecodeStream::get_method_signature_index() { |
|
362 VM_ENTRY_MARK; |
|
363 constantPoolOop cpool = _holder->get_instanceKlass()->constants(); |
|
364 int method_index = get_method_index(); |
|
365 int name_and_type_index = cpool->name_and_type_ref_index_at(method_index); |
|
366 return cpool->signature_ref_index_at(name_and_type_index); |
|
367 } |