Mercurial > hg > graal-jvmci-8

comparison src/share/vm/oops/constantPoolOop.hpp @ 726:be93aad57795

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6655646: dynamic languages need dynamically linked call sites Summary: invokedynamic instruction (JSR 292 RI) Reviewed-by: twisti, never
author jrose
date Tue, 21 Apr 2009 23:21:04 -0700
parents 0fbdb4381b99
children 389049f3f393
comparison
equal deleted inserted replaced
725:928912ce8438 726:be93aad57795
51 void set_tags(typeArrayOop tags) { oop_store_without_check((oop*)&_tags, tags); } 51 void set_tags(typeArrayOop tags) { oop_store_without_check((oop*)&_tags, tags); }
52 void tag_at_put(int which, jbyte t) { tags()->byte_at_put(which, t); } 52 void tag_at_put(int which, jbyte t) { tags()->byte_at_put(which, t); }
53 void release_tag_at_put(int which, jbyte t) { tags()->release_byte_at_put(which, t); } 53 void release_tag_at_put(int which, jbyte t) { tags()->release_byte_at_put(which, t); }
54 54
55 enum FlagBit { 55 enum FlagBit {
56 FB_has_invokedynamic = 1,
56 FB_has_pseudo_string = 2 57 FB_has_pseudo_string = 2
57 }; 58 };
58 59
59 int flags() const { return _flags; } 60 int flags() const { return _flags; }
60 void set_flags(int f) { _flags = f; } 61 void set_flags(int f) { _flags = f; }
94 95
95 public: 96 public:
96 typeArrayOop tags() const { return _tags; } 97 typeArrayOop tags() const { return _tags; }
97 98
98 bool has_pseudo_string() const { return flag_at(FB_has_pseudo_string); } 99 bool has_pseudo_string() const { return flag_at(FB_has_pseudo_string); }
100 bool has_invokedynamic() const { return flag_at(FB_has_invokedynamic); }
99 void set_pseudo_string() { set_flag_at(FB_has_pseudo_string); } 101 void set_pseudo_string() { set_flag_at(FB_has_pseudo_string); }
102 void set_invokedynamic() { set_flag_at(FB_has_invokedynamic); }
100 103
101 // Klass holding pool 104 // Klass holding pool
102 klassOop pool_holder() const { return _pool_holder; } 105 klassOop pool_holder() const { return _pool_holder; }
103 void set_pool_holder(klassOop k) { oop_store_without_check((oop*)&_pool_holder, (oop) k); } 106 void set_pool_holder(klassOop k) { oop_store_without_check((oop*)&_pool_holder, (oop) k); }
104 oop* pool_holder_addr() { return (oop*)&_pool_holder; } 107 oop* pool_holder_addr() { return (oop*)&_pool_holder; }
336 jint name_and_type_at(int which) { 339 jint name_and_type_at(int which) {
337 assert(tag_at(which).is_name_and_type(), "Corrupted constant pool"); 340 assert(tag_at(which).is_name_and_type(), "Corrupted constant pool");
338 return *int_at_addr(which); 341 return *int_at_addr(which);
339 } 342 }
340 343
341 // The following methods (klass_ref_at, klass_ref_at_noresolve, name_ref_at, 344 // The following methods (name/signature/klass_ref_at, klass_ref_at_noresolve,
342 // signature_ref_at, klass_ref_index_at, name_and_type_ref_index_at, 345 // name_and_type_ref_index_at) all expect constant pool indices
343 // name_ref_index_at, signature_ref_index_at) all expect constant pool indices
344 // from the bytecodes to be passed in, which are actually potentially byte-swapped 346 // from the bytecodes to be passed in, which are actually potentially byte-swapped
345 // contstant pool cache indices. See field_or_method_at. 347 // or rewritten constant pool cache indices. They all call map_instruction_operand_to_index.
348 int map_instruction_operand_to_index(int operand);
349
350 // There are also "uncached" versions which do not map the operand index; see below.
346 351
347 // Lookup for entries consisting of (klass_index, name_and_type index) 352 // Lookup for entries consisting of (klass_index, name_and_type index)
348 klassOop klass_ref_at(int which, TRAPS); 353 klassOop klass_ref_at(int which, TRAPS);
349 symbolOop klass_ref_at_noresolve(int which); 354 symbolOop klass_ref_at_noresolve(int which);
350 symbolOop name_ref_at(int which); 355 symbolOop name_ref_at(int which) { return impl_name_ref_at(which, false); }
351 symbolOop signature_ref_at(int which); // the type descriptor 356 symbolOop signature_ref_at(int which) { return impl_signature_ref_at(which, false); }
352 357
353 int klass_ref_index_at(int which); 358 int klass_ref_index_at(int which) { return impl_klass_ref_index_at(which, false); }
354 int name_and_type_ref_index_at(int which); 359 int name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, false); }
355 360
356 // Lookup for entries consisting of (name_index, signature_index) 361 // Lookup for entries consisting of (name_index, signature_index)
357 int name_ref_index_at(int which); 362 int name_ref_index_at(int which_nt); // == low-order jshort of name_and_type_at(which_nt)
358 int signature_ref_index_at(int which); 363 int signature_ref_index_at(int which_nt); // == high-order jshort of name_and_type_at(which_nt)
364 symbolOop nt_name_ref_at(int which_nt) { return symbol_at(name_ref_index_at(which_nt)); }
365 symbolOop nt_signature_ref_at(int which_nt) { return symbol_at(signature_ref_index_at(which_nt)); }
359 366
360 BasicType basic_type_for_signature_at(int which); 367 BasicType basic_type_for_signature_at(int which);
361 368
362 // Resolve string constants (to prevent allocation during compilation) 369 // Resolve string constants (to prevent allocation during compilation)
363 void resolve_string_constants(TRAPS) { 370 void resolve_string_constants(TRAPS) {
395 static klassOop klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int which, TRAPS); 402 static klassOop klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int which, TRAPS);
396 403
397 // Routines currently used for annotations (only called by jvm.cpp) but which might be used in the 404 // Routines currently used for annotations (only called by jvm.cpp) but which might be used in the
398 // future by other Java code. These take constant pool indices rather than possibly-byte-swapped 405 // future by other Java code. These take constant pool indices rather than possibly-byte-swapped
399 // constant pool cache indices as do the peer methods above. 406 // constant pool cache indices as do the peer methods above.
400 symbolOop uncached_name_ref_at(int which); 407 symbolOop uncached_name_ref_at(int which) { return impl_name_ref_at(which, true); }
401 symbolOop uncached_signature_ref_at(int which); 408 symbolOop uncached_signature_ref_at(int which) { return impl_signature_ref_at(which, true); }
402 int uncached_klass_ref_index_at(int which); 409 int uncached_klass_ref_index_at(int which) { return impl_klass_ref_index_at(which, true); }
403 int uncached_name_and_type_ref_index_at(int which); 410 int uncached_name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, true); }
404 411
405 // Sharing 412 // Sharing
406 int pre_resolve_shared_klasses(TRAPS); 413 int pre_resolve_shared_klasses(TRAPS);
407 void shared_symbols_iterate(OopClosure* closure0); 414 void shared_symbols_iterate(OopClosure* closure0);
408 void shared_tags_iterate(OopClosure* closure0); 415 void shared_tags_iterate(OopClosure* closure0);
411 // Debugging 418 // Debugging
412 const char* printable_name_at(int which) PRODUCT_RETURN0; 419 const char* printable_name_at(int which) PRODUCT_RETURN0;
413 420
414 private: 421 private:
415 422
423 symbolOop impl_name_ref_at(int which, bool uncached);
424 symbolOop impl_signature_ref_at(int which, bool uncached);
425 int impl_klass_ref_index_at(int which, bool uncached);
426 int impl_name_and_type_ref_index_at(int which, bool uncached);
427
416 // Takes either a constant pool cache index in possibly byte-swapped 428 // Takes either a constant pool cache index in possibly byte-swapped
417 // byte order (which comes from the bytecodes after rewriting) or, 429 // byte order (which comes from the bytecodes after rewriting) or,
418 // if "uncached" is true, a vanilla constant pool index 430 // if "uncached" is true, a vanilla constant pool index
419 jint field_or_method_at(int which, bool uncached) { 431 jint field_or_method_at(int which, bool uncached) {
420 int i = -1; 432 int i = which;
421 if (uncached || cache() == NULL) { 433 if (!uncached && cache() != NULL) {
422 i = which;
423 } else {
424 // change byte-ordering and go via cache 434 // change byte-ordering and go via cache
425 i = cache()->entry_at(Bytes::swap_u2(which))->constant_pool_index(); 435 i = map_instruction_operand_to_index(which);
426 } 436 }
427 assert(tag_at(i).is_field_or_method(), "Corrupted constant pool"); 437 assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
428 return *int_at_addr(i); 438 return *int_at_addr(i);
429 } 439 }
430 440