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 #include "code/codeCache.hpp"
27 #include "code/compiledIC.hpp"
28 #include "code/nmethod.hpp"
29 #include "code/relocInfo.hpp"
30 #include "memory/resourceArea.hpp"
31 #include "runtime/stubCodeGenerator.hpp"
32 #include "utilities/copy.hpp"
33
34 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
35
36 const RelocationHolder RelocationHolder::none; // its type is relocInfo::none
37
38
39 // Implementation of relocInfo
40
41 #ifdef ASSERT
42 relocInfo::relocInfo(relocType t, int off, int f) {
43 assert(t != data_prefix_tag, "cannot build a prefix this way");
44 assert((t & type_mask) == t, "wrong type");
45 assert((f & format_mask) == f, "wrong format");
46 assert(off >= 0 && off < offset_limit(), "offset out off bounds");
47 assert((off & (offset_unit-1)) == 0, "misaligned offset");
48 (*this) = relocInfo(t, RAW_BITS, off, f);
49 }
50 #endif
51
52 void relocInfo::initialize(CodeSection* dest, Relocation* reloc) {
407 }
408 return (*this);
409 }
410
411
412 void Relocation::guarantee_size() {
413 guarantee(false, "Make _relocbuf bigger!");
414 }
415
416 // some relocations can compute their own values
417 address Relocation::value() {
418 ShouldNotReachHere();
419 return NULL;
420 }
421
422
423 void Relocation::set_value(address x) {
424 ShouldNotReachHere();
425 }
426
427
428 RelocationHolder Relocation::spec_simple(relocInfo::relocType rtype) {
429 if (rtype == relocInfo::none) return RelocationHolder::none;
430 relocInfo ri = relocInfo(rtype, 0);
431 RelocIterator itr;
432 itr.set_current(ri);
433 itr.reloc();
434 return itr._rh;
435 }
436
437 int32_t Relocation::runtime_address_to_index(address runtime_address) {
438 assert(!is_reloc_index((intptr_t)runtime_address), "must not look like an index");
439
440 if (runtime_address == NULL) return 0;
441
442 StubCodeDesc* p = StubCodeDesc::desc_for(runtime_address);
443 if (p != NULL && p->begin() == runtime_address) {
444 assert(is_reloc_index(p->index()), "there must not be too many stubs");
445 return (int32_t)p->index();
446 } else {
563 }
564
565
566 void virtual_call_Relocation::unpack_data() {
567 jint x0 = unpack_1_int();
568 address point = addr();
569 _cached_value = x0==0? NULL: address_from_scaled_offset(x0, point);
570 }
571
572
573 void static_stub_Relocation::pack_data_to(CodeSection* dest) {
574 short* p = (short*) dest->locs_end();
575 CodeSection* insts = dest->outer()->insts();
576 normalize_address(_static_call, insts);
577 p = pack_1_int_to(p, scaled_offset(_static_call, insts->start()));
578 dest->set_locs_end((relocInfo*) p);
579 }
580
581 void static_stub_Relocation::unpack_data() {
582 address base = binding()->section_start(CodeBuffer::SECT_INSTS);
583 _static_call = address_from_scaled_offset(unpack_1_int(), base);
584 }
585
586 void trampoline_stub_Relocation::pack_data_to(CodeSection* dest ) {
587 short* p = (short*) dest->locs_end();
588 CodeSection* insts = dest->outer()->insts();
589 normalize_address(_owner, insts);
590 p = pack_1_int_to(p, scaled_offset(_owner, insts->start()));
591 dest->set_locs_end((relocInfo*) p);
592 }
593
594 void trampoline_stub_Relocation::unpack_data() {
595 address base = binding()->section_start(CodeBuffer::SECT_INSTS);
596 _owner = address_from_scaled_offset(unpack_1_int(), base);
597 }
598
599 void external_word_Relocation::pack_data_to(CodeSection* dest) {
600 short* p = (short*) dest->locs_end();
601 int32_t index = runtime_address_to_index(_target);
602 #ifndef _LP64
603 p = pack_1_int_to(p, index);
777 CompiledIC* icache = CompiledIC_at(this);
778 icache->set_to_clean();
779 }
780
781
782 void opt_virtual_call_Relocation::clear_inline_cache() {
783 // No stubs for ICs
784 // Clean IC
785 ResourceMark rm;
786 CompiledIC* icache = CompiledIC_at(this);
787 icache->set_to_clean();
788 }
789
790
791 address opt_virtual_call_Relocation::static_stub() {
792 // search for the static stub who points back to this static call
793 address static_call_addr = addr();
794 RelocIterator iter(code());
795 while (iter.next()) {
796 if (iter.type() == relocInfo::static_stub_type) {
797 if (iter.static_stub_reloc()->static_call() == static_call_addr) {
798 return iter.addr();
799 }
800 }
801 }
802 return NULL;
803 }
804
805
806 void static_call_Relocation::clear_inline_cache() {
807 // Safe call site info
808 CompiledStaticCall* handler = compiledStaticCall_at(this);
809 handler->set_to_clean();
810 }
811
812
813 address static_call_Relocation::static_stub() {
814 // search for the static stub who points back to this static call
815 address static_call_addr = addr();
816 RelocIterator iter(code());
817 while (iter.next()) {
818 if (iter.type() == relocInfo::static_stub_type) {
819 if (iter.static_stub_reloc()->static_call() == static_call_addr) {
820 return iter.addr();
821 }
822 }
823 }
824 return NULL;
825 }
826
827 // Finds the trampoline address for a call. If no trampoline stub is
828 // found NULL is returned which can be handled by the caller.
829 address trampoline_stub_Relocation::get_trampoline_for(address call, nmethod* code) {
830 // There are no relocations available when the code gets relocated
831 // because of CodeBuffer expansion.
832 if (code->relocation_size() == 0)
833 return NULL;
834
835 RelocIterator iter(code, call);
836 while (iter.next()) {
837 if (iter.type() == relocInfo::trampoline_stub_type) {
838 if (iter.trampoline_stub_reloc()->owner() == call) {
839 return iter.addr();
|
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 #include "code/codeCache.hpp"
27 #include "code/compiledIC.hpp"
28 #include "code/nmethod.hpp"
29 #include "code/relocInfo.hpp"
30 #include "memory/resourceArea.hpp"
31 #include "runtime/stubCodeGenerator.hpp"
32 #include "utilities/copy.hpp"
33 #include "oops/oop.inline.hpp"
34
35 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
36
37 const RelocationHolder RelocationHolder::none; // its type is relocInfo::none
38
39
40 // Implementation of relocInfo
41
42 #ifdef ASSERT
43 relocInfo::relocInfo(relocType t, int off, int f) {
44 assert(t != data_prefix_tag, "cannot build a prefix this way");
45 assert((t & type_mask) == t, "wrong type");
46 assert((f & format_mask) == f, "wrong format");
47 assert(off >= 0 && off < offset_limit(), "offset out off bounds");
48 assert((off & (offset_unit-1)) == 0, "misaligned offset");
49 (*this) = relocInfo(t, RAW_BITS, off, f);
50 }
51 #endif
52
53 void relocInfo::initialize(CodeSection* dest, Relocation* reloc) {
408 }
409 return (*this);
410 }
411
412
413 void Relocation::guarantee_size() {
414 guarantee(false, "Make _relocbuf bigger!");
415 }
416
417 // some relocations can compute their own values
418 address Relocation::value() {
419 ShouldNotReachHere();
420 return NULL;
421 }
422
423
424 void Relocation::set_value(address x) {
425 ShouldNotReachHere();
426 }
427
428 void Relocation::const_set_data_value(address x) {
429 #ifdef _LP64
430 if (format() == relocInfo::narrow_oop_in_const) {
431 *(narrowOop*)addr() = oopDesc::encode_heap_oop((oop) x);
432 } else {
433 #endif
434 *(address*)addr() = x;
435 #ifdef _LP64
436 }
437 #endif
438 }
439
440 void Relocation::const_verify_data_value(address x) {
441 #ifdef _LP64
442 if (format() == relocInfo::narrow_oop_in_const) {
443 assert(*(narrowOop*)addr() == oopDesc::encode_heap_oop((oop) x), "must agree");
444 } else {
445 #endif
446 assert(*(address*)addr() == x, "must agree");
447 #ifdef _LP64
448 }
449 #endif
450 }
451
452
453 RelocationHolder Relocation::spec_simple(relocInfo::relocType rtype) {
454 if (rtype == relocInfo::none) return RelocationHolder::none;
455 relocInfo ri = relocInfo(rtype, 0);
456 RelocIterator itr;
457 itr.set_current(ri);
458 itr.reloc();
459 return itr._rh;
460 }
461
462 int32_t Relocation::runtime_address_to_index(address runtime_address) {
463 assert(!is_reloc_index((intptr_t)runtime_address), "must not look like an index");
464
465 if (runtime_address == NULL) return 0;
466
467 StubCodeDesc* p = StubCodeDesc::desc_for(runtime_address);
468 if (p != NULL && p->begin() == runtime_address) {
469 assert(is_reloc_index(p->index()), "there must not be too many stubs");
470 return (int32_t)p->index();
471 } else {
588 }
589
590
591 void virtual_call_Relocation::unpack_data() {
592 jint x0 = unpack_1_int();
593 address point = addr();
594 _cached_value = x0==0? NULL: address_from_scaled_offset(x0, point);
595 }
596
597
598 void static_stub_Relocation::pack_data_to(CodeSection* dest) {
599 short* p = (short*) dest->locs_end();
600 CodeSection* insts = dest->outer()->insts();
601 normalize_address(_static_call, insts);
602 p = pack_1_int_to(p, scaled_offset(_static_call, insts->start()));
603 dest->set_locs_end((relocInfo*) p);
604 }
605
606 void static_stub_Relocation::unpack_data() {
607 address base = binding()->section_start(CodeBuffer::SECT_INSTS);
608 jint offset = unpack_1_int();
609 _static_call = address_from_scaled_offset(offset, base);
610 }
611
612 void trampoline_stub_Relocation::pack_data_to(CodeSection* dest ) {
613 short* p = (short*) dest->locs_end();
614 CodeSection* insts = dest->outer()->insts();
615 normalize_address(_owner, insts);
616 p = pack_1_int_to(p, scaled_offset(_owner, insts->start()));
617 dest->set_locs_end((relocInfo*) p);
618 }
619
620 void trampoline_stub_Relocation::unpack_data() {
621 address base = binding()->section_start(CodeBuffer::SECT_INSTS);
622 _owner = address_from_scaled_offset(unpack_1_int(), base);
623 }
624
625 void external_word_Relocation::pack_data_to(CodeSection* dest) {
626 short* p = (short*) dest->locs_end();
627 int32_t index = runtime_address_to_index(_target);
628 #ifndef _LP64
629 p = pack_1_int_to(p, index);
803 CompiledIC* icache = CompiledIC_at(this);
804 icache->set_to_clean();
805 }
806
807
808 void opt_virtual_call_Relocation::clear_inline_cache() {
809 // No stubs for ICs
810 // Clean IC
811 ResourceMark rm;
812 CompiledIC* icache = CompiledIC_at(this);
813 icache->set_to_clean();
814 }
815
816
817 address opt_virtual_call_Relocation::static_stub() {
818 // search for the static stub who points back to this static call
819 address static_call_addr = addr();
820 RelocIterator iter(code());
821 while (iter.next()) {
822 if (iter.type() == relocInfo::static_stub_type) {
823 static_stub_Relocation* stub_reloc = iter.static_stub_reloc();
824 if (stub_reloc->static_call() == static_call_addr) {
825 return iter.addr();
826 }
827 }
828 }
829 return NULL;
830 }
831
832
833 void static_call_Relocation::clear_inline_cache() {
834 // Safe call site info
835 CompiledStaticCall* handler = compiledStaticCall_at(this);
836 handler->set_to_clean();
837 }
838
839
840 address static_call_Relocation::static_stub() {
841 // search for the static stub who points back to this static call
842 address static_call_addr = addr();
843 RelocIterator iter(code());
844 while (iter.next()) {
845 if (iter.type() == relocInfo::static_stub_type) {
846 static_stub_Relocation* stub_reloc = iter.static_stub_reloc();
847 if (stub_reloc->static_call() == static_call_addr) {
848 return iter.addr();
849 }
850 }
851 }
852 return NULL;
853 }
854
855 // Finds the trampoline address for a call. If no trampoline stub is
856 // found NULL is returned which can be handled by the caller.
857 address trampoline_stub_Relocation::get_trampoline_for(address call, nmethod* code) {
858 // There are no relocations available when the code gets relocated
859 // because of CodeBuffer expansion.
860 if (code->relocation_size() == 0)
861 return NULL;
862
863 RelocIterator iter(code, call);
864 while (iter.next()) {
865 if (iter.type() == relocInfo::trampoline_stub_type) {
866 if (iter.trampoline_stub_reloc()->owner() == call) {
867 return iter.addr();
|