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