Mercurial > hg > truffle
annotate src/share/vm/classfile/genericSignatures.cpp @ 12161:e1fbb86b47e4
8016277: Crash in nmethod::is_compiled_by_c1() on x86
Summary: Method pointer for zombie methods may be invalid
Reviewed-by: kvn, coleenp
author | roland |
---|---|
date | Mon, 26 Aug 2013 16:12:20 +0200 |
parents | ef57c43512d6 |
children |
rev | line source |
---|---|
6934 | 1 /* |
2 * Copyright (c) 2012, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
20 * or visit www.oracle.com if you need additional information or have any | |
21 * questions. | |
22 * | |
23 */ | |
24 | |
25 #include "precompiled.hpp" | |
26 | |
27 #include "classfile/genericSignatures.hpp" | |
28 #include "classfile/symbolTable.hpp" | |
29 #include "classfile/systemDictionary.hpp" | |
30 #include "memory/resourceArea.hpp" | |
31 | |
32 namespace generic { | |
33 | |
34 // Helper class for parsing the generic signature Symbol in klass and methods | |
35 class DescriptorStream : public ResourceObj { | |
36 private: | |
37 Symbol* _symbol; | |
38 int _offset; | |
39 int _mark; | |
40 const char* _parse_error; | |
41 | |
42 void set_parse_error(const char* error) { | |
43 assert(error != NULL, "Can't set NULL error string"); | |
44 _parse_error = error; | |
45 } | |
46 | |
47 public: | |
48 DescriptorStream(Symbol* sym) | |
49 : _symbol(sym), _offset(0), _mark(-1), _parse_error(NULL) {} | |
50 | |
51 const char* parse_error() const { | |
52 return _parse_error; | |
53 } | |
54 | |
55 bool at_end() { return _offset >= _symbol->utf8_length(); } | |
56 | |
57 char peek() { | |
58 if (at_end()) { | |
59 set_parse_error("Peeking past end of signature"); | |
60 return '\0'; | |
61 } else { | |
62 return _symbol->byte_at(_offset); | |
63 } | |
64 } | |
65 | |
66 char read() { | |
67 if (at_end()) { | |
68 set_parse_error("Reading past end of signature"); | |
69 return '\0'; | |
70 } else { | |
71 return _symbol->byte_at(_offset++); | |
72 } | |
73 } | |
74 | |
75 void read(char expected) { | |
76 char c = read(); | |
77 assert_char(c, expected, 0); | |
78 } | |
79 | |
80 void assert_char(char c, char expected, int pos = -1) { | |
81 if (c != expected) { | |
82 const char* fmt = "Parse error at %d: expected %c but got %c"; | |
83 size_t len = strlen(fmt) + 5; | |
84 char* buffer = NEW_RESOURCE_ARRAY(char, len); | |
85 jio_snprintf(buffer, len, fmt, _offset + pos, expected, c); | |
86 set_parse_error(buffer); | |
87 } | |
88 } | |
89 | |
90 void push(char c) { | |
91 assert(c == _symbol->byte_at(_offset - 1), "Pushing back wrong value"); | |
92 --_offset; | |
93 } | |
94 | |
95 void expect_end() { | |
96 if (!at_end()) { | |
97 set_parse_error("Unexpected data trailing signature"); | |
98 } | |
99 } | |
100 | |
101 bool has_mark() { return _mark != -1; } | |
102 | |
103 void set_mark() { | |
104 _mark = _offset; | |
105 } | |
106 | |
107 Identifier* identifier_from_mark() { | |
108 assert(has_mark(), "Mark should be set"); | |
109 if (!has_mark()) { | |
110 set_parse_error("Expected mark to be set"); | |
111 return NULL; | |
112 } else { | |
113 Identifier* id = new Identifier(_symbol, _mark, _offset - 1); | |
114 _mark = -1; | |
115 return id; | |
116 } | |
117 } | |
118 }; | |
119 | |
120 | |
121 #define CHECK_FOR_PARSE_ERROR() \ | |
122 if (STREAM->parse_error() != NULL) { \ | |
123 if (VerifyGenericSignatures) { \ | |
124 fatal(STREAM->parse_error()); \ | |
125 } \ | |
126 return NULL; \ | |
10973
ef57c43512d6
8014431: cleanup warnings indicated by the -Wunused-value compiler option on linux
ccheung
parents:
10128
diff
changeset
|
127 } (void)0 |
6934 | 128 |
129 #define READ() STREAM->read(); CHECK_FOR_PARSE_ERROR() | |
130 #define PEEK() STREAM->peek(); CHECK_FOR_PARSE_ERROR() | |
131 #define PUSH(c) STREAM->push(c) | |
132 #define EXPECT(c) STREAM->read(c); CHECK_FOR_PARSE_ERROR() | |
133 #define EXPECTED(c, ch) STREAM->assert_char(c, ch); CHECK_FOR_PARSE_ERROR() | |
134 #define EXPECT_END() STREAM->expect_end(); CHECK_FOR_PARSE_ERROR() | |
135 | |
10973
ef57c43512d6
8014431: cleanup warnings indicated by the -Wunused-value compiler option on linux
ccheung
parents:
10128
diff
changeset
|
136 #define CHECK_STREAM STREAM); CHECK_FOR_PARSE_ERROR(); ((void)0 |
6934 | 137 |
138 #ifndef PRODUCT | |
139 void Identifier::print_on(outputStream* str) const { | |
140 for (int i = _begin; i < _end; ++i) { | |
141 str->print("%c", (char)_sym->byte_at(i)); | |
142 } | |
143 } | |
144 #endif // ndef PRODUCT | |
145 | |
146 bool Identifier::equals(Identifier* other) { | |
147 if (_sym == other->_sym && _begin == other->_begin && _end == other->_end) { | |
148 return true; | |
149 } else if (_end - _begin != other->_end - other->_begin) { | |
150 return false; | |
151 } else { | |
152 size_t len = _end - _begin; | |
153 char* addr = ((char*)_sym->bytes()) + _begin; | |
154 char* oaddr = ((char*)other->_sym->bytes()) + other->_begin; | |
155 return strncmp(addr, oaddr, len) == 0; | |
156 } | |
157 } | |
158 | |
159 bool Identifier::equals(Symbol* sym) { | |
160 Identifier id(sym, 0, sym->utf8_length()); | |
161 return equals(&id); | |
162 } | |
163 | |
164 /** | |
165 * A formal type parameter may be found in the the enclosing class, but it could | |
166 * also come from an enclosing method or outer class, in the case of inner-outer | |
167 * classes or anonymous classes. For example: | |
168 * | |
169 * class Outer<T,V> { | |
170 * class Inner<W> { | |
171 * void m(T t, V v, W w); | |
172 * } | |
173 * } | |
174 * | |
175 * In this case, the type variables in m()'s signature are not all found in the | |
176 * immediate enclosing class (Inner). class Inner has only type parameter W, | |
177 * but it's outer_class field will reference Outer's descriptor which contains | |
178 * T & V (no outer_method in this case). | |
179 * | |
180 * If you have an anonymous class, it has both an enclosing method *and* an | |
181 * enclosing class where type parameters can be declared: | |
182 * | |
183 * class MOuter<T> { | |
184 * <V> void bar(V v) { | |
185 * Runnable r = new Runnable() { | |
186 * public void run() {} | |
187 * public void foo(T t, V v) { ... } | |
188 * }; | |
189 * } | |
190 * } | |
191 * | |
192 * In this case, foo will be a member of some class, Runnable$1, which has no | |
193 * formal parameters itself, but has an outer_method (bar()) which provides | |
194 * type parameter V, and an outer class MOuter with type parameter T. | |
195 * | |
196 * It is also possible that the outer class is itself an inner class to some | |
197 * other class (or an anonymous class with an enclosing method), so we need to | |
198 * follow the outer_class/outer_method chain to it's end when looking for a | |
199 * type parameter. | |
200 */ | |
201 TypeParameter* Descriptor::find_type_parameter(Identifier* id, int* depth) { | |
202 | |
203 int current_depth = 0; | |
204 | |
205 MethodDescriptor* outer_method = as_method_signature(); | |
206 ClassDescriptor* outer_class = as_class_signature(); | |
207 | |
208 if (outer_class == NULL) { // 'this' is a method signature; use the holder | |
209 outer_class = outer_method->outer_class(); | |
210 } | |
211 | |
212 while (outer_method != NULL || outer_class != NULL) { | |
213 if (outer_method != NULL) { | |
214 for (int i = 0; i < outer_method->type_parameters().length(); ++i) { | |
215 TypeParameter* p = outer_method->type_parameters().at(i); | |
216 if (p->identifier()->equals(id)) { | |
217 *depth = -1; // indicates this this is a method parameter | |
218 return p; | |
219 } | |
220 } | |
221 } | |
222 if (outer_class != NULL) { | |
223 for (int i = 0; i < outer_class->type_parameters().length(); ++i) { | |
224 TypeParameter* p = outer_class->type_parameters().at(i); | |
225 if (p->identifier()->equals(id)) { | |
226 *depth = current_depth; | |
227 return p; | |
228 } | |
229 } | |
230 outer_method = outer_class->outer_method(); | |
231 outer_class = outer_class->outer_class(); | |
232 ++current_depth; | |
233 } | |
234 } | |
235 | |
236 if (VerifyGenericSignatures) { | |
237 fatal("Could not resolve identifier"); | |
238 } | |
239 | |
240 return NULL; | |
241 } | |
242 | |
243 ClassDescriptor* ClassDescriptor::parse_generic_signature(Klass* klass, TRAPS) { | |
244 return parse_generic_signature(klass, NULL, CHECK_NULL); | |
245 } | |
246 | |
247 ClassDescriptor* ClassDescriptor::parse_generic_signature( | |
248 Klass* klass, Symbol* original_name, TRAPS) { | |
249 | |
250 InstanceKlass* ik = InstanceKlass::cast(klass); | |
251 Symbol* sym = ik->generic_signature(); | |
252 | |
253 ClassDescriptor* spec; | |
254 | |
255 if (sym == NULL || (spec = ClassDescriptor::parse_generic_signature(sym)) == NULL) { | |
256 spec = ClassDescriptor::placeholder(ik); | |
257 } | |
258 | |
259 u2 outer_index = get_outer_class_index(ik, CHECK_NULL); | |
260 if (outer_index != 0) { | |
261 if (original_name == NULL) { | |
262 original_name = ik->name(); | |
263 } | |
264 Handle class_loader = Handle(THREAD, ik->class_loader()); | |
265 Handle protection_domain = Handle(THREAD, ik->protection_domain()); | |
266 | |
267 Symbol* outer_name = ik->constants()->klass_name_at(outer_index); | |
268 Klass* outer = SystemDictionary::find( | |
269 outer_name, class_loader, protection_domain, CHECK_NULL); | |
270 if (outer == NULL && !THREAD->is_Compiler_thread()) { | |
10128
41ed397cc0cd
8006267: InterfaceMethod_ref should allow invokestatic and invokespecial
bharadwaj
parents:
6934
diff
changeset
|
271 if (outer_name == ik->super()->name()) { |
41ed397cc0cd
8006267: InterfaceMethod_ref should allow invokestatic and invokespecial
bharadwaj
parents:
6934
diff
changeset
|
272 outer = SystemDictionary::resolve_super_or_fail(original_name, outer_name, |
41ed397cc0cd
8006267: InterfaceMethod_ref should allow invokestatic and invokespecial
bharadwaj
parents:
6934
diff
changeset
|
273 class_loader, protection_domain, |
41ed397cc0cd
8006267: InterfaceMethod_ref should allow invokestatic and invokespecial
bharadwaj
parents:
6934
diff
changeset
|
274 false, CHECK_NULL); |
41ed397cc0cd
8006267: InterfaceMethod_ref should allow invokestatic and invokespecial
bharadwaj
parents:
6934
diff
changeset
|
275 } |
41ed397cc0cd
8006267: InterfaceMethod_ref should allow invokestatic and invokespecial
bharadwaj
parents:
6934
diff
changeset
|
276 else { |
41ed397cc0cd
8006267: InterfaceMethod_ref should allow invokestatic and invokespecial
bharadwaj
parents:
6934
diff
changeset
|
277 outer = SystemDictionary::resolve_or_fail(outer_name, class_loader, |
41ed397cc0cd
8006267: InterfaceMethod_ref should allow invokestatic and invokespecial
bharadwaj
parents:
6934
diff
changeset
|
278 protection_domain, false, CHECK_NULL); |
41ed397cc0cd
8006267: InterfaceMethod_ref should allow invokestatic and invokespecial
bharadwaj
parents:
6934
diff
changeset
|
279 } |
6934 | 280 } |
281 | |
282 InstanceKlass* outer_ik; | |
283 ClassDescriptor* outer_spec = NULL; | |
284 if (outer == NULL) { | |
285 outer_spec = ClassDescriptor::placeholder(ik); | |
286 assert(false, "Outer class not loaded and not loadable from here"); | |
287 } else { | |
288 outer_ik = InstanceKlass::cast(outer); | |
289 outer_spec = parse_generic_signature(outer, original_name, CHECK_NULL); | |
290 } | |
291 spec->set_outer_class(outer_spec); | |
292 | |
293 u2 encl_method_idx = ik->enclosing_method_method_index(); | |
294 if (encl_method_idx != 0 && outer_ik != NULL) { | |
295 ConstantPool* cp = ik->constants(); | |
296 u2 name_index = cp->name_ref_index_at(encl_method_idx); | |
297 u2 sig_index = cp->signature_ref_index_at(encl_method_idx); | |
298 Symbol* name = cp->symbol_at(name_index); | |
299 Symbol* sig = cp->symbol_at(sig_index); | |
300 Method* m = outer_ik->find_method(name, sig); | |
301 if (m != NULL) { | |
302 Symbol* gsig = m->generic_signature(); | |
303 if (gsig != NULL) { | |
304 MethodDescriptor* gms = MethodDescriptor::parse_generic_signature(gsig, outer_spec); | |
305 spec->set_outer_method(gms); | |
306 } | |
307 } else if (VerifyGenericSignatures) { | |
308 ResourceMark rm; | |
309 stringStream ss; | |
310 ss.print("Could not find method %s %s in class %s", | |
311 name->as_C_string(), sig->as_C_string(), outer_name->as_C_string()); | |
312 fatal(ss.as_string()); | |
313 } | |
314 } | |
315 } | |
316 | |
317 spec->bind_variables_to_parameters(); | |
318 return spec; | |
319 } | |
320 | |
321 ClassDescriptor* ClassDescriptor::placeholder(InstanceKlass* klass) { | |
322 GrowableArray<TypeParameter*> formals; | |
323 GrowableArray<ClassType*> interfaces; | |
324 ClassType* super_type = NULL; | |
325 | |
326 Klass* super_klass = klass->super(); | |
327 if (super_klass != NULL) { | |
328 InstanceKlass* super = InstanceKlass::cast(super_klass); | |
329 super_type = ClassType::from_symbol(super->name()); | |
330 } | |
331 | |
332 for (int i = 0; i < klass->local_interfaces()->length(); ++i) { | |
333 InstanceKlass* iface = InstanceKlass::cast(klass->local_interfaces()->at(i)); | |
334 interfaces.append(ClassType::from_symbol(iface->name())); | |
335 } | |
336 return new ClassDescriptor(formals, super_type, interfaces); | |
337 } | |
338 | |
339 ClassDescriptor* ClassDescriptor::parse_generic_signature(Symbol* sym) { | |
340 | |
341 DescriptorStream ds(sym); | |
342 DescriptorStream* STREAM = &ds; | |
343 | |
344 GrowableArray<TypeParameter*> parameters(8); | |
345 char c = READ(); | |
346 if (c == '<') { | |
347 c = READ(); | |
348 while (c != '>') { | |
349 PUSH(c); | |
350 TypeParameter* ftp = TypeParameter::parse_generic_signature(CHECK_STREAM); | |
351 parameters.append(ftp); | |
352 c = READ(); | |
353 } | |
354 } else { | |
355 PUSH(c); | |
356 } | |
357 | |
358 EXPECT('L'); | |
359 ClassType* super = ClassType::parse_generic_signature(CHECK_STREAM); | |
360 | |
361 GrowableArray<ClassType*> signatures(2); | |
362 while (!STREAM->at_end()) { | |
363 EXPECT('L'); | |
364 ClassType* iface = ClassType::parse_generic_signature(CHECK_STREAM); | |
365 signatures.append(iface); | |
366 } | |
367 | |
368 EXPECT_END(); | |
369 | |
370 return new ClassDescriptor(parameters, super, signatures); | |
371 } | |
372 | |
373 #ifndef PRODUCT | |
374 void ClassDescriptor::print_on(outputStream* str) const { | |
375 str->indent().print_cr("ClassDescriptor {"); | |
376 { | |
377 streamIndentor si(str); | |
378 if (_type_parameters.length() > 0) { | |
379 str->indent().print_cr("Formals {"); | |
380 { | |
381 streamIndentor si(str); | |
382 for (int i = 0; i < _type_parameters.length(); ++i) { | |
383 _type_parameters.at(i)->print_on(str); | |
384 } | |
385 } | |
386 str->indent().print_cr("}"); | |
387 } | |
388 if (_super != NULL) { | |
389 str->indent().print_cr("Superclass: "); | |
390 { | |
391 streamIndentor si(str); | |
392 _super->print_on(str); | |
393 } | |
394 } | |
395 if (_interfaces.length() > 0) { | |
396 str->indent().print_cr("SuperInterfaces: {"); | |
397 { | |
398 streamIndentor si(str); | |
399 for (int i = 0; i < _interfaces.length(); ++i) { | |
400 _interfaces.at(i)->print_on(str); | |
401 } | |
402 } | |
403 str->indent().print_cr("}"); | |
404 } | |
405 if (_outer_method != NULL) { | |
406 str->indent().print_cr("Outer Method: {"); | |
407 { | |
408 streamIndentor si(str); | |
409 _outer_method->print_on(str); | |
410 } | |
411 str->indent().print_cr("}"); | |
412 } | |
413 if (_outer_class != NULL) { | |
414 str->indent().print_cr("Outer Class: {"); | |
415 { | |
416 streamIndentor si(str); | |
417 _outer_class->print_on(str); | |
418 } | |
419 str->indent().print_cr("}"); | |
420 } | |
421 } | |
422 str->indent().print_cr("}"); | |
423 } | |
424 #endif // ndef PRODUCT | |
425 | |
426 ClassType* ClassDescriptor::interface_desc(Symbol* sym) { | |
427 for (int i = 0; i < _interfaces.length(); ++i) { | |
428 if (_interfaces.at(i)->identifier()->equals(sym)) { | |
429 return _interfaces.at(i); | |
430 } | |
431 } | |
432 if (VerifyGenericSignatures) { | |
433 fatal("Did not find expected interface"); | |
434 } | |
435 return NULL; | |
436 } | |
437 | |
438 void ClassDescriptor::bind_variables_to_parameters() { | |
439 if (_outer_class != NULL) { | |
440 _outer_class->bind_variables_to_parameters(); | |
441 } | |
442 if (_outer_method != NULL) { | |
443 _outer_method->bind_variables_to_parameters(); | |
444 } | |
445 for (int i = 0; i < _type_parameters.length(); ++i) { | |
446 _type_parameters.at(i)->bind_variables_to_parameters(this, i); | |
447 } | |
448 if (_super != NULL) { | |
449 _super->bind_variables_to_parameters(this); | |
450 } | |
451 for (int i = 0; i < _interfaces.length(); ++i) { | |
452 _interfaces.at(i)->bind_variables_to_parameters(this); | |
453 } | |
454 } | |
455 | |
456 ClassDescriptor* ClassDescriptor::canonicalize(Context* ctx) { | |
457 | |
458 GrowableArray<TypeParameter*> type_params(_type_parameters.length()); | |
459 for (int i = 0; i < _type_parameters.length(); ++i) { | |
460 type_params.append(_type_parameters.at(i)->canonicalize(ctx, 0)); | |
461 } | |
462 | |
463 ClassDescriptor* outer = _outer_class == NULL ? NULL : | |
464 _outer_class->canonicalize(ctx); | |
465 | |
466 ClassType* super = _super == NULL ? NULL : _super->canonicalize(ctx, 0); | |
467 | |
468 GrowableArray<ClassType*> interfaces(_interfaces.length()); | |
469 for (int i = 0; i < _interfaces.length(); ++i) { | |
470 interfaces.append(_interfaces.at(i)->canonicalize(ctx, 0)); | |
471 } | |
472 | |
473 MethodDescriptor* md = _outer_method == NULL ? NULL : | |
474 _outer_method->canonicalize(ctx); | |
475 | |
476 return new ClassDescriptor(type_params, super, interfaces, outer, md); | |
477 } | |
478 | |
479 u2 ClassDescriptor::get_outer_class_index(InstanceKlass* klass, TRAPS) { | |
480 int inner_index = InstanceKlass::inner_class_inner_class_info_offset; | |
481 int outer_index = InstanceKlass::inner_class_outer_class_info_offset; | |
482 int name_offset = InstanceKlass::inner_class_inner_name_offset; | |
483 int next_offset = InstanceKlass::inner_class_next_offset; | |
484 | |
485 if (klass->inner_classes() == NULL || klass->inner_classes()->length() == 0) { | |
486 // No inner class info => no declaring class | |
487 return 0; | |
488 } | |
489 | |
490 Array<u2>* i_icls = klass->inner_classes(); | |
491 ConstantPool* i_cp = klass->constants(); | |
492 int i_length = i_icls->length(); | |
493 | |
494 // Find inner_klass attribute | |
495 for (int i = 0; i + next_offset < i_length; i += next_offset) { | |
496 u2 ioff = i_icls->at(i + inner_index); | |
497 u2 ooff = i_icls->at(i + outer_index); | |
498 u2 noff = i_icls->at(i + name_offset); | |
499 if (ioff != 0) { | |
500 // Check to see if the name matches the class we're looking for | |
501 // before attempting to find the class. | |
502 if (i_cp->klass_name_at_matches(klass, ioff) && ooff != 0) { | |
503 return ooff; | |
504 } | |
505 } | |
506 } | |
507 | |
508 // It may be anonymous; try for that. | |
509 u2 encl_method_class_idx = klass->enclosing_method_class_index(); | |
510 if (encl_method_class_idx != 0) { | |
511 return encl_method_class_idx; | |
512 } | |
513 | |
514 return 0; | |
515 } | |
516 | |
517 MethodDescriptor* MethodDescriptor::parse_generic_signature(Method* m, ClassDescriptor* outer) { | |
518 Symbol* generic_sig = m->generic_signature(); | |
519 MethodDescriptor* md = NULL; | |
520 if (generic_sig == NULL || (md = parse_generic_signature(generic_sig, outer)) == NULL) { | |
521 md = parse_generic_signature(m->signature(), outer); | |
522 } | |
523 assert(md != NULL, "Could not parse method signature"); | |
524 md->bind_variables_to_parameters(); | |
525 return md; | |
526 } | |
527 | |
528 MethodDescriptor* MethodDescriptor::parse_generic_signature(Symbol* sym, ClassDescriptor* outer) { | |
529 | |
530 DescriptorStream ds(sym); | |
531 DescriptorStream* STREAM = &ds; | |
532 | |
533 GrowableArray<TypeParameter*> params(8); | |
534 char c = READ(); | |
535 if (c == '<') { | |
536 c = READ(); | |
537 while (c != '>') { | |
538 PUSH(c); | |
539 TypeParameter* ftp = TypeParameter::parse_generic_signature(CHECK_STREAM); | |
540 params.append(ftp); | |
541 c = READ(); | |
542 } | |
543 } else { | |
544 PUSH(c); | |
545 } | |
546 | |
547 EXPECT('('); | |
548 | |
549 GrowableArray<Type*> parameters(8); | |
550 c = READ(); | |
551 while (c != ')') { | |
552 PUSH(c); | |
553 Type* arg = Type::parse_generic_signature(CHECK_STREAM); | |
554 parameters.append(arg); | |
555 c = READ(); | |
556 } | |
557 | |
558 Type* rt = Type::parse_generic_signature(CHECK_STREAM); | |
559 | |
560 GrowableArray<Type*> throws; | |
561 while (!STREAM->at_end()) { | |
562 EXPECT('^'); | |
563 Type* spec = Type::parse_generic_signature(CHECK_STREAM); | |
564 throws.append(spec); | |
565 } | |
566 | |
567 return new MethodDescriptor(params, outer, parameters, rt, throws); | |
568 } | |
569 | |
570 void MethodDescriptor::bind_variables_to_parameters() { | |
571 for (int i = 0; i < _type_parameters.length(); ++i) { | |
572 _type_parameters.at(i)->bind_variables_to_parameters(this, i); | |
573 } | |
574 for (int i = 0; i < _parameters.length(); ++i) { | |
575 _parameters.at(i)->bind_variables_to_parameters(this); | |
576 } | |
577 _return_type->bind_variables_to_parameters(this); | |
578 for (int i = 0; i < _throws.length(); ++i) { | |
579 _throws.at(i)->bind_variables_to_parameters(this); | |
580 } | |
581 } | |
582 | |
583 bool MethodDescriptor::covariant_match(MethodDescriptor* other, Context* ctx) { | |
584 | |
585 if (_parameters.length() == other->_parameters.length()) { | |
586 for (int i = 0; i < _parameters.length(); ++i) { | |
587 if (!_parameters.at(i)->covariant_match(other->_parameters.at(i), ctx)) { | |
588 return false; | |
589 } | |
590 } | |
591 | |
592 if (_return_type->as_primitive() != NULL) { | |
593 return _return_type->covariant_match(other->_return_type, ctx); | |
594 } else { | |
595 // return type is a reference | |
596 return other->_return_type->as_class() != NULL || | |
597 other->_return_type->as_variable() != NULL || | |
598 other->_return_type->as_array() != NULL; | |
599 } | |
600 } else { | |
601 return false; | |
602 } | |
603 } | |
604 | |
605 MethodDescriptor* MethodDescriptor::canonicalize(Context* ctx) { | |
606 | |
607 GrowableArray<TypeParameter*> type_params(_type_parameters.length()); | |
608 for (int i = 0; i < _type_parameters.length(); ++i) { | |
609 type_params.append(_type_parameters.at(i)->canonicalize(ctx, 0)); | |
610 } | |
611 | |
612 ClassDescriptor* outer = _outer_class == NULL ? NULL : | |
613 _outer_class->canonicalize(ctx); | |
614 | |
615 GrowableArray<Type*> params(_parameters.length()); | |
616 for (int i = 0; i < _parameters.length(); ++i) { | |
617 params.append(_parameters.at(i)->canonicalize(ctx, 0)); | |
618 } | |
619 | |
620 Type* rt = _return_type->canonicalize(ctx, 0); | |
621 | |
622 GrowableArray<Type*> throws(_throws.length()); | |
623 for (int i = 0; i < _throws.length(); ++i) { | |
624 throws.append(_throws.at(i)->canonicalize(ctx, 0)); | |
625 } | |
626 | |
627 return new MethodDescriptor(type_params, outer, params, rt, throws); | |
628 } | |
629 | |
630 #ifndef PRODUCT | |
631 TempNewSymbol MethodDescriptor::reify_signature(Context* ctx, TRAPS) { | |
632 stringStream ss(256); | |
633 | |
634 ss.print("("); | |
635 for (int i = 0; i < _parameters.length(); ++i) { | |
636 _parameters.at(i)->reify_signature(&ss, ctx); | |
637 } | |
638 ss.print(")"); | |
639 _return_type->reify_signature(&ss, ctx); | |
640 return SymbolTable::new_symbol(ss.base(), (int)ss.size(), THREAD); | |
641 } | |
642 | |
643 void MethodDescriptor::print_on(outputStream* str) const { | |
644 str->indent().print_cr("MethodDescriptor {"); | |
645 { | |
646 streamIndentor si(str); | |
647 if (_type_parameters.length() > 0) { | |
648 str->indent().print_cr("Formals: {"); | |
649 { | |
650 streamIndentor si(str); | |
651 for (int i = 0; i < _type_parameters.length(); ++i) { | |
652 _type_parameters.at(i)->print_on(str); | |
653 } | |
654 } | |
655 str->indent().print_cr("}"); | |
656 } | |
657 str->indent().print_cr("Parameters: {"); | |
658 { | |
659 streamIndentor si(str); | |
660 for (int i = 0; i < _parameters.length(); ++i) { | |
661 _parameters.at(i)->print_on(str); | |
662 } | |
663 } | |
664 str->indent().print_cr("}"); | |
665 str->indent().print_cr("Return Type: "); | |
666 { | |
667 streamIndentor si(str); | |
668 _return_type->print_on(str); | |
669 } | |
670 | |
671 if (_throws.length() > 0) { | |
672 str->indent().print_cr("Throws: {"); | |
673 { | |
674 streamIndentor si(str); | |
675 for (int i = 0; i < _throws.length(); ++i) { | |
676 _throws.at(i)->print_on(str); | |
677 } | |
678 } | |
679 str->indent().print_cr("}"); | |
680 } | |
681 } | |
682 str->indent().print_cr("}"); | |
683 } | |
684 #endif // ndef PRODUCT | |
685 | |
686 TypeParameter* TypeParameter::parse_generic_signature(DescriptorStream* STREAM) { | |
687 STREAM->set_mark(); | |
688 char c = READ(); | |
689 while (c != ':') { | |
690 c = READ(); | |
691 } | |
692 | |
693 Identifier* id = STREAM->identifier_from_mark(); | |
694 | |
695 ClassType* class_bound = NULL; | |
696 GrowableArray<ClassType*> interface_bounds(8); | |
697 | |
698 c = READ(); | |
699 if (c != '>') { | |
700 if (c != ':') { | |
701 EXPECTED(c, 'L'); | |
702 class_bound = ClassType::parse_generic_signature(CHECK_STREAM); | |
703 c = READ(); | |
704 } | |
705 | |
706 while (c == ':') { | |
707 EXPECT('L'); | |
708 ClassType* fts = ClassType::parse_generic_signature(CHECK_STREAM); | |
709 interface_bounds.append(fts); | |
710 c = READ(); | |
711 } | |
712 } | |
713 PUSH(c); | |
714 | |
715 return new TypeParameter(id, class_bound, interface_bounds); | |
716 } | |
717 | |
718 void TypeParameter::bind_variables_to_parameters(Descriptor* sig, int position) { | |
719 if (_class_bound != NULL) { | |
720 _class_bound->bind_variables_to_parameters(sig); | |
721 } | |
722 for (int i = 0; i < _interface_bounds.length(); ++i) { | |
723 _interface_bounds.at(i)->bind_variables_to_parameters(sig); | |
724 } | |
725 _position = position; | |
726 } | |
727 | |
728 Type* TypeParameter::resolve( | |
729 Context* ctx, int inner_depth, int ctx_depth) { | |
730 | |
731 if (inner_depth == -1) { | |
732 // This indicates that the parameter is a method type parameter, which | |
733 // isn't resolveable using the class hierarchy context | |
734 return bound(); | |
735 } | |
736 | |
737 ClassType* provider = ctx->at_depth(ctx_depth); | |
738 if (provider != NULL) { | |
739 for (int i = 0; i < inner_depth && provider != NULL; ++i) { | |
740 provider = provider->outer_class(); | |
741 } | |
742 if (provider != NULL) { | |
743 TypeArgument* arg = provider->type_argument_at(_position); | |
744 if (arg != NULL) { | |
745 Type* value = arg->lower_bound(); | |
746 return value->canonicalize(ctx, ctx_depth + 1); | |
747 } | |
748 } | |
749 } | |
750 | |
751 return bound(); | |
752 } | |
753 | |
754 TypeParameter* TypeParameter::canonicalize(Context* ctx, int ctx_depth) { | |
755 ClassType* bound = _class_bound == NULL ? NULL : | |
756 _class_bound->canonicalize(ctx, ctx_depth); | |
757 | |
758 GrowableArray<ClassType*> ifaces(_interface_bounds.length()); | |
759 for (int i = 0; i < _interface_bounds.length(); ++i) { | |
760 ifaces.append(_interface_bounds.at(i)->canonicalize(ctx, ctx_depth)); | |
761 } | |
762 | |
763 TypeParameter* ret = new TypeParameter(_identifier, bound, ifaces); | |
764 ret->_position = _position; | |
765 return ret; | |
766 } | |
767 | |
768 ClassType* TypeParameter::bound() { | |
769 if (_class_bound != NULL) { | |
770 return _class_bound; | |
771 } | |
772 | |
773 if (_interface_bounds.length() == 1) { | |
774 return _interface_bounds.at(0); | |
775 } | |
776 | |
777 return ClassType::java_lang_Object(); // TODO: investigate this case | |
778 } | |
779 | |
780 #ifndef PRODUCT | |
781 void TypeParameter::print_on(outputStream* str) const { | |
782 str->indent().print_cr("Formal: {"); | |
783 { | |
784 streamIndentor si(str); | |
785 | |
786 str->indent().print("Identifier: "); | |
787 _identifier->print_on(str); | |
788 str->print_cr(""); | |
789 if (_class_bound != NULL) { | |
790 str->indent().print_cr("Class Bound: "); | |
791 streamIndentor si(str); | |
792 _class_bound->print_on(str); | |
793 } | |
794 if (_interface_bounds.length() > 0) { | |
795 str->indent().print_cr("Interface Bounds: {"); | |
796 { | |
797 streamIndentor si(str); | |
798 for (int i = 0; i < _interface_bounds.length(); ++i) { | |
799 _interface_bounds.at(i)->print_on(str); | |
800 } | |
801 } | |
802 str->indent().print_cr("}"); | |
803 } | |
804 str->indent().print_cr("Ordinal Position: %d", _position); | |
805 } | |
806 str->indent().print_cr("}"); | |
807 } | |
808 #endif // ndef PRODUCT | |
809 | |
810 Type* Type::parse_generic_signature(DescriptorStream* STREAM) { | |
811 char c = READ(); | |
812 switch (c) { | |
813 case 'L': | |
814 return ClassType::parse_generic_signature(CHECK_STREAM); | |
815 case 'T': | |
816 return TypeVariable::parse_generic_signature(CHECK_STREAM); | |
817 case '[': | |
818 return ArrayType::parse_generic_signature(CHECK_STREAM); | |
819 default: | |
820 return new PrimitiveType(c); | |
821 } | |
822 } | |
823 | |
824 Identifier* ClassType::parse_generic_signature_simple(GrowableArray<TypeArgument*>* args, | |
825 bool* has_inner, DescriptorStream* STREAM) { | |
826 STREAM->set_mark(); | |
827 | |
828 char c = READ(); | |
829 while (c != ';' && c != '.' && c != '<') { c = READ(); } | |
830 Identifier* id = STREAM->identifier_from_mark(); | |
831 | |
832 if (c == '<') { | |
833 c = READ(); | |
834 while (c != '>') { | |
835 PUSH(c); | |
836 TypeArgument* arg = TypeArgument::parse_generic_signature(CHECK_STREAM); | |
837 args->append(arg); | |
838 c = READ(); | |
839 } | |
840 c = READ(); | |
841 } | |
842 | |
843 *has_inner = (c == '.'); | |
844 if (!(*has_inner)) { | |
845 EXPECTED(c, ';'); | |
846 } | |
847 | |
848 return id; | |
849 } | |
850 | |
851 ClassType* ClassType::parse_generic_signature(DescriptorStream* STREAM) { | |
852 return parse_generic_signature(NULL, CHECK_STREAM); | |
853 } | |
854 | |
855 ClassType* ClassType::parse_generic_signature(ClassType* outer, DescriptorStream* STREAM) { | |
856 GrowableArray<TypeArgument*> args; | |
857 ClassType* gct = NULL; | |
858 bool has_inner = false; | |
859 | |
860 Identifier* id = parse_generic_signature_simple(&args, &has_inner, STREAM); | |
861 if (id != NULL) { | |
862 gct = new ClassType(id, args, outer); | |
863 | |
864 if (has_inner) { | |
865 gct = parse_generic_signature(gct, CHECK_STREAM); | |
866 } | |
867 } | |
868 return gct; | |
869 } | |
870 | |
871 ClassType* ClassType::from_symbol(Symbol* sym) { | |
872 assert(sym != NULL, "Must not be null"); | |
873 GrowableArray<TypeArgument*> args; | |
874 Identifier* id = new Identifier(sym, 0, sym->utf8_length()); | |
875 return new ClassType(id, args, NULL); | |
876 } | |
877 | |
878 ClassType* ClassType::java_lang_Object() { | |
879 return from_symbol(vmSymbols::java_lang_Object()); | |
880 } | |
881 | |
882 void ClassType::bind_variables_to_parameters(Descriptor* sig) { | |
883 for (int i = 0; i < _type_arguments.length(); ++i) { | |
884 _type_arguments.at(i)->bind_variables_to_parameters(sig); | |
885 } | |
886 if (_outer_class != NULL) { | |
887 _outer_class->bind_variables_to_parameters(sig); | |
888 } | |
889 } | |
890 | |
891 TypeArgument* ClassType::type_argument_at(int i) { | |
892 if (i >= 0 && i < _type_arguments.length()) { | |
893 return _type_arguments.at(i); | |
894 } else { | |
895 return NULL; | |
896 } | |
897 } | |
898 | |
899 #ifndef PRODUCT | |
900 void ClassType::reify_signature(stringStream* ss, Context* ctx) { | |
901 ss->print("L"); | |
902 _identifier->print_on(ss); | |
903 ss->print(";"); | |
904 } | |
905 | |
906 void ClassType::print_on(outputStream* str) const { | |
907 str->indent().print_cr("Class {"); | |
908 { | |
909 streamIndentor si(str); | |
910 str->indent().print("Name: "); | |
911 _identifier->print_on(str); | |
912 str->print_cr(""); | |
913 if (_type_arguments.length() != 0) { | |
914 str->indent().print_cr("Type Arguments: {"); | |
915 { | |
916 streamIndentor si(str); | |
917 for (int j = 0; j < _type_arguments.length(); ++j) { | |
918 _type_arguments.at(j)->print_on(str); | |
919 } | |
920 } | |
921 str->indent().print_cr("}"); | |
922 } | |
923 if (_outer_class != NULL) { | |
924 str->indent().print_cr("Outer Class: "); | |
925 streamIndentor sir(str); | |
926 _outer_class->print_on(str); | |
927 } | |
928 } | |
929 str->indent().print_cr("}"); | |
930 } | |
931 #endif // ndef PRODUCT | |
932 | |
933 bool ClassType::covariant_match(Type* other, Context* ctx) { | |
934 | |
935 if (other == this) { | |
936 return true; | |
937 } | |
938 | |
939 TypeVariable* variable = other->as_variable(); | |
940 if (variable != NULL) { | |
941 other = variable->resolve(ctx, 0); | |
942 } | |
943 | |
944 ClassType* outer = outer_class(); | |
945 ClassType* other_class = other->as_class(); | |
946 | |
947 if (other_class == NULL || | |
948 (outer == NULL) != (other_class->outer_class() == NULL)) { | |
949 return false; | |
950 } | |
951 | |
952 if (!_identifier->equals(other_class->_identifier)) { | |
953 return false; | |
954 } | |
955 | |
956 if (outer != NULL && !outer->covariant_match(other_class->outer_class(), ctx)) { | |
957 return false; | |
958 } | |
959 | |
960 return true; | |
961 } | |
962 | |
963 ClassType* ClassType::canonicalize(Context* ctx, int ctx_depth) { | |
964 | |
965 GrowableArray<TypeArgument*> args(_type_arguments.length()); | |
966 for (int i = 0; i < _type_arguments.length(); ++i) { | |
967 args.append(_type_arguments.at(i)->canonicalize(ctx, ctx_depth)); | |
968 } | |
969 | |
970 ClassType* outer = _outer_class == NULL ? NULL : | |
971 _outer_class->canonicalize(ctx, ctx_depth); | |
972 | |
973 return new ClassType(_identifier, args, outer); | |
974 } | |
975 | |
976 TypeVariable* TypeVariable::parse_generic_signature(DescriptorStream* STREAM) { | |
977 STREAM->set_mark(); | |
978 char c = READ(); | |
979 while (c != ';') { | |
980 c = READ(); | |
981 } | |
982 Identifier* id = STREAM->identifier_from_mark(); | |
983 | |
984 return new TypeVariable(id); | |
985 } | |
986 | |
987 void TypeVariable::bind_variables_to_parameters(Descriptor* sig) { | |
988 _parameter = sig->find_type_parameter(_id, &_inner_depth); | |
989 if (VerifyGenericSignatures && _parameter == NULL) { | |
990 fatal("Could not find formal parameter"); | |
991 } | |
992 } | |
993 | |
994 Type* TypeVariable::resolve(Context* ctx, int ctx_depth) { | |
995 if (parameter() != NULL) { | |
996 return parameter()->resolve(ctx, inner_depth(), ctx_depth); | |
997 } else { | |
998 if (VerifyGenericSignatures) { | |
999 fatal("Type variable matches no parameter"); | |
1000 } | |
1001 return NULL; | |
1002 } | |
1003 } | |
1004 | |
1005 bool TypeVariable::covariant_match(Type* other, Context* ctx) { | |
1006 | |
1007 if (other == this) { | |
1008 return true; | |
1009 } | |
1010 | |
1011 Context my_context(NULL); // empty, results in erasure | |
1012 Type* my_type = resolve(&my_context, 0); | |
1013 if (my_type == NULL) { | |
1014 return false; | |
1015 } | |
1016 | |
1017 return my_type->covariant_match(other, ctx); | |
1018 } | |
1019 | |
1020 Type* TypeVariable::canonicalize(Context* ctx, int ctx_depth) { | |
1021 return resolve(ctx, ctx_depth); | |
1022 } | |
1023 | |
1024 #ifndef PRODUCT | |
1025 void TypeVariable::reify_signature(stringStream* ss, Context* ctx) { | |
1026 Type* type = resolve(ctx, 0); | |
1027 if (type != NULL) { | |
1028 type->reify_signature(ss, ctx); | |
1029 } | |
1030 } | |
1031 | |
1032 void TypeVariable::print_on(outputStream* str) const { | |
1033 str->indent().print_cr("Type Variable {"); | |
1034 { | |
1035 streamIndentor si(str); | |
1036 str->indent().print("Name: "); | |
1037 _id->print_on(str); | |
1038 str->print_cr(""); | |
1039 str->indent().print_cr("Inner depth: %d", _inner_depth); | |
1040 } | |
1041 str->indent().print_cr("}"); | |
1042 } | |
1043 #endif // ndef PRODUCT | |
1044 | |
1045 ArrayType* ArrayType::parse_generic_signature(DescriptorStream* STREAM) { | |
1046 Type* base = Type::parse_generic_signature(CHECK_STREAM); | |
1047 return new ArrayType(base); | |
1048 } | |
1049 | |
1050 void ArrayType::bind_variables_to_parameters(Descriptor* sig) { | |
1051 assert(_base != NULL, "Invalid base"); | |
1052 _base->bind_variables_to_parameters(sig); | |
1053 } | |
1054 | |
1055 bool ArrayType::covariant_match(Type* other, Context* ctx) { | |
1056 assert(_base != NULL, "Invalid base"); | |
1057 | |
1058 if (other == this) { | |
1059 return true; | |
1060 } | |
1061 | |
1062 ArrayType* other_array = other->as_array(); | |
1063 return (other_array != NULL && _base->covariant_match(other_array->_base, ctx)); | |
1064 } | |
1065 | |
1066 ArrayType* ArrayType::canonicalize(Context* ctx, int ctx_depth) { | |
1067 assert(_base != NULL, "Invalid base"); | |
1068 return new ArrayType(_base->canonicalize(ctx, ctx_depth)); | |
1069 } | |
1070 | |
1071 #ifndef PRODUCT | |
1072 void ArrayType::reify_signature(stringStream* ss, Context* ctx) { | |
1073 assert(_base != NULL, "Invalid base"); | |
1074 ss->print("["); | |
1075 _base->reify_signature(ss, ctx); | |
1076 } | |
1077 | |
1078 void ArrayType::print_on(outputStream* str) const { | |
1079 str->indent().print_cr("Array {"); | |
1080 { | |
1081 streamIndentor si(str); | |
1082 _base->print_on(str); | |
1083 } | |
1084 str->indent().print_cr("}"); | |
1085 } | |
1086 #endif // ndef PRODUCT | |
1087 | |
1088 bool PrimitiveType::covariant_match(Type* other, Context* ctx) { | |
1089 | |
1090 PrimitiveType* other_prim = other->as_primitive(); | |
1091 return (other_prim != NULL && _type == other_prim->_type); | |
1092 } | |
1093 | |
1094 PrimitiveType* PrimitiveType::canonicalize(Context* ctx, int ctxd) { | |
1095 return this; | |
1096 } | |
1097 | |
1098 #ifndef PRODUCT | |
1099 void PrimitiveType::reify_signature(stringStream* ss, Context* ctx) { | |
1100 ss->print("%c", _type); | |
1101 } | |
1102 | |
1103 void PrimitiveType::print_on(outputStream* str) const { | |
1104 str->indent().print_cr("Primitive: '%c'", _type); | |
1105 } | |
1106 #endif // ndef PRODUCT | |
1107 | |
1108 void PrimitiveType::bind_variables_to_parameters(Descriptor* sig) { | |
1109 } | |
1110 | |
1111 TypeArgument* TypeArgument::parse_generic_signature(DescriptorStream* STREAM) { | |
1112 char c = READ(); | |
1113 Type* type = NULL; | |
1114 | |
1115 switch (c) { | |
1116 case '*': | |
1117 return new TypeArgument(ClassType::java_lang_Object(), NULL); | |
1118 break; | |
1119 default: | |
1120 PUSH(c); | |
1121 // fall-through | |
1122 case '+': | |
1123 case '-': | |
1124 type = Type::parse_generic_signature(CHECK_STREAM); | |
1125 if (c == '+') { | |
1126 return new TypeArgument(type, NULL); | |
1127 } else if (c == '-') { | |
1128 return new TypeArgument(ClassType::java_lang_Object(), type); | |
1129 } else { | |
1130 return new TypeArgument(type, type); | |
1131 } | |
1132 } | |
1133 } | |
1134 | |
1135 void TypeArgument::bind_variables_to_parameters(Descriptor* sig) { | |
1136 assert(_lower_bound != NULL, "Invalid lower bound"); | |
1137 _lower_bound->bind_variables_to_parameters(sig); | |
1138 if (_upper_bound != NULL && _upper_bound != _lower_bound) { | |
1139 _upper_bound->bind_variables_to_parameters(sig); | |
1140 } | |
1141 } | |
1142 | |
1143 bool TypeArgument::covariant_match(TypeArgument* other, Context* ctx) { | |
1144 assert(_lower_bound != NULL, "Invalid lower bound"); | |
1145 | |
1146 if (other == this) { | |
1147 return true; | |
1148 } | |
1149 | |
1150 if (!_lower_bound->covariant_match(other->lower_bound(), ctx)) { | |
1151 return false; | |
1152 } | |
1153 return true; | |
1154 } | |
1155 | |
1156 TypeArgument* TypeArgument::canonicalize(Context* ctx, int ctx_depth) { | |
1157 assert(_lower_bound != NULL, "Invalid lower bound"); | |
1158 Type* lower = _lower_bound->canonicalize(ctx, ctx_depth); | |
1159 Type* upper = NULL; | |
1160 | |
1161 if (_upper_bound == _lower_bound) { | |
1162 upper = lower; | |
1163 } else if (_upper_bound != NULL) { | |
1164 upper = _upper_bound->canonicalize(ctx, ctx_depth); | |
1165 } | |
1166 | |
1167 return new TypeArgument(lower, upper); | |
1168 } | |
1169 | |
1170 #ifndef PRODUCT | |
1171 void TypeArgument::print_on(outputStream* str) const { | |
1172 str->indent().print_cr("TypeArgument {"); | |
1173 { | |
1174 streamIndentor si(str); | |
1175 if (_lower_bound != NULL) { | |
1176 str->indent().print("Lower bound: "); | |
1177 _lower_bound->print_on(str); | |
1178 } | |
1179 if (_upper_bound != NULL) { | |
1180 str->indent().print("Upper bound: "); | |
1181 _upper_bound->print_on(str); | |
1182 } | |
1183 } | |
1184 str->indent().print_cr("}"); | |
1185 } | |
1186 #endif // ndef PRODUCT | |
1187 | |
1188 void Context::Mark::destroy() { | |
1189 if (is_active()) { | |
1190 _context->reset_to_mark(_marked_size); | |
1191 } | |
1192 deactivate(); | |
1193 } | |
1194 | |
1195 void Context::apply_type_arguments( | |
1196 InstanceKlass* current, InstanceKlass* super, TRAPS) { | |
1197 assert(_cache != NULL, "Cannot use an empty context"); | |
1198 ClassType* spec = NULL; | |
1199 if (current != NULL) { | |
1200 ClassDescriptor* descriptor = _cache->descriptor_for(current, CHECK); | |
1201 if (super == current->super()) { | |
1202 spec = descriptor->super(); | |
1203 } else { | |
1204 spec = descriptor->interface_desc(super->name()); | |
1205 } | |
1206 if (spec != NULL) { | |
1207 _type_arguments.push(spec); | |
1208 } | |
1209 } | |
1210 } | |
1211 | |
1212 void Context::reset_to_mark(int size) { | |
1213 _type_arguments.trunc_to(size); | |
1214 } | |
1215 | |
1216 ClassType* Context::at_depth(int i) const { | |
1217 if (i < _type_arguments.length()) { | |
1218 return _type_arguments.at(_type_arguments.length() - 1 - i); | |
1219 } | |
1220 return NULL; | |
1221 } | |
1222 | |
1223 #ifndef PRODUCT | |
1224 void Context::print_on(outputStream* str) const { | |
1225 str->indent().print_cr("Context {"); | |
1226 for (int i = 0; i < _type_arguments.length(); ++i) { | |
1227 streamIndentor si(str); | |
1228 str->indent().print("leval %d: ", i); | |
1229 ClassType* ct = at_depth(i); | |
1230 if (ct == NULL) { | |
1231 str->print_cr("<empty>"); | |
1232 continue; | |
1233 } else { | |
1234 str->print_cr("{"); | |
1235 } | |
1236 | |
1237 for (int j = 0; j < ct->type_arguments_length(); ++j) { | |
1238 streamIndentor si(str); | |
1239 TypeArgument* ta = ct->type_argument_at(j); | |
1240 Type* bound = ta->lower_bound(); | |
1241 bound->print_on(str); | |
1242 } | |
1243 str->indent().print_cr("}"); | |
1244 } | |
1245 str->indent().print_cr("}"); | |
1246 } | |
1247 #endif // ndef PRODUCT | |
1248 | |
1249 ClassDescriptor* DescriptorCache::descriptor_for(InstanceKlass* ik, TRAPS) { | |
1250 | |
1251 ClassDescriptor** existing = _class_descriptors.get(ik); | |
1252 if (existing == NULL) { | |
1253 ClassDescriptor* cd = ClassDescriptor::parse_generic_signature(ik, CHECK_NULL); | |
1254 _class_descriptors.put(ik, cd); | |
1255 return cd; | |
1256 } else { | |
1257 return *existing; | |
1258 } | |
1259 } | |
1260 | |
1261 MethodDescriptor* DescriptorCache::descriptor_for( | |
1262 Method* mh, ClassDescriptor* cd, TRAPS) { | |
1263 assert(mh != NULL && cd != NULL, "Should not be NULL"); | |
1264 MethodDescriptor** existing = _method_descriptors.get(mh); | |
1265 if (existing == NULL) { | |
1266 MethodDescriptor* md = MethodDescriptor::parse_generic_signature(mh, cd); | |
1267 _method_descriptors.put(mh, md); | |
1268 return md; | |
1269 } else { | |
1270 return *existing; | |
1271 } | |
1272 } | |
1273 MethodDescriptor* DescriptorCache::descriptor_for(Method* mh, TRAPS) { | |
1274 ClassDescriptor* cd = descriptor_for( | |
1275 InstanceKlass::cast(mh->method_holder()), CHECK_NULL); | |
1276 return descriptor_for(mh, cd, THREAD); | |
1277 } | |
1278 | |
1279 } // namespace generic |