461 // (The fast-path is just a degenerate variant of the slow-path).
462 // Perform the dreaded state transition and pass control into the slow-path.
463 JRT_BLOCK;
464 Handle h_obj(THREAD, obj);
465 ObjectSynchronizer::notifyall(h_obj, CHECK);
466 JRT_BLOCK_END;
467 JRT_END
468
469 const TypeFunc *OptoRuntime::new_instance_Type() {
470 // create input type (domain)
471 const Type **fields = TypeTuple::fields(1);
472 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
473 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
474
475 // create result type (range)
476 fields = TypeTuple::fields(1);
477 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
478
479 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
480
481 return TypeFunc::make(domain, range);
482 }
483
484
485 const TypeFunc *OptoRuntime::athrow_Type() {
486 // create input type (domain)
487 const Type **fields = TypeTuple::fields(1);
488 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
489 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
490
491 // create result type (range)
492 fields = TypeTuple::fields(0);
493
494 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
495
496 return TypeFunc::make(domain, range);
497 }
498
499
500 const TypeFunc *OptoRuntime::new_array_Type() {
501 // create input type (domain)
502 const Type **fields = TypeTuple::fields(2);
503 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // element klass
504 fields[TypeFunc::Parms+1] = TypeInt::INT; // array size
505 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
506
507 // create result type (range)
508 fields = TypeTuple::fields(1);
509 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
510
511 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
512
513 return TypeFunc::make(domain, range);
514 }
515
516 const TypeFunc *OptoRuntime::multianewarray_Type(int ndim) {
517 // create input type (domain)
518 const int nargs = ndim + 1;
519 const Type **fields = TypeTuple::fields(nargs);
520 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // element klass
521 for( int i = 1; i < nargs; i++ )
522 fields[TypeFunc::Parms + i] = TypeInt::INT; // array size
523 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+nargs, fields);
524
525 // create result type (range)
526 fields = TypeTuple::fields(1);
527 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
528 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
529
530 return TypeFunc::make(domain, range);
531 }
532
533 const TypeFunc *OptoRuntime::multianewarray2_Type() {
534 return multianewarray_Type(2);
535 }
536
537 const TypeFunc *OptoRuntime::multianewarray3_Type() {
538 return multianewarray_Type(3);
539 }
540
541 const TypeFunc *OptoRuntime::multianewarray4_Type() {
542 return multianewarray_Type(4);
543 }
544
545 const TypeFunc *OptoRuntime::multianewarray5_Type() {
546 return multianewarray_Type(5);
547 }
548
549 const TypeFunc *OptoRuntime::multianewarrayN_Type() {
550 // create input type (domain)
551 const Type **fields = TypeTuple::fields(2);
552 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // element klass
553 fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // array of dim sizes
554 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
555
556 // create result type (range)
557 fields = TypeTuple::fields(1);
558 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
559 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
560
561 return TypeFunc::make(domain, range);
562 }
563
564 const TypeFunc *OptoRuntime::g1_wb_pre_Type() {
565 const Type **fields = TypeTuple::fields(2);
566 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // original field value
567 fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // thread
568 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
569
570 // create result type (range)
571 fields = TypeTuple::fields(0);
572 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
573
574 return TypeFunc::make(domain, range);
575 }
576
577 const TypeFunc *OptoRuntime::g1_wb_post_Type() {
578
579 const Type **fields = TypeTuple::fields(2);
580 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Card addr
581 fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // thread
582 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
583
584 // create result type (range)
585 fields = TypeTuple::fields(0);
586 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
587
588 return TypeFunc::make(domain, range);
589 }
590
591 const TypeFunc *OptoRuntime::uncommon_trap_Type() {
592 // create input type (domain)
593 const Type **fields = TypeTuple::fields(1);
594 fields[TypeFunc::Parms+0] = TypeInt::INT; // trap_reason (deopt reason and action)
595 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
596
597 // create result type (range)
598 fields = TypeTuple::fields(0);
599 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
600
601 return TypeFunc::make(domain, range);
602 }
603
604 //-----------------------------------------------------------------------------
605 // Monitor Handling
606 const TypeFunc *OptoRuntime::complete_monitor_enter_Type() {
607 // create input type (domain)
608 const Type **fields = TypeTuple::fields(2);
609 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
610 fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // Address of stack location for lock
611 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
612
613 // create result type (range)
614 fields = TypeTuple::fields(0);
615
616 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
617
618 return TypeFunc::make(domain,range);
619 }
620
621
622 //-----------------------------------------------------------------------------
623 const TypeFunc *OptoRuntime::complete_monitor_exit_Type() {
624 // create input type (domain)
625 const Type **fields = TypeTuple::fields(3);
626 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
627 fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // Address of stack location for lock - BasicLock
628 fields[TypeFunc::Parms+2] = TypeRawPtr::BOTTOM; // Thread pointer (Self)
629 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+3, fields);
630
631 // create result type (range)
632 fields = TypeTuple::fields(0);
633
634 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
635
636 return TypeFunc::make(domain, range);
637 }
638
639 const TypeFunc *OptoRuntime::monitor_notify_Type() {
640 // create input type (domain)
641 const Type **fields = TypeTuple::fields(1);
642 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
643 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
644
645 // create result type (range)
646 fields = TypeTuple::fields(0);
647 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
648 return TypeFunc::make(domain, range);
649 }
650
651 const TypeFunc* OptoRuntime::flush_windows_Type() {
652 // create input type (domain)
653 const Type** fields = TypeTuple::fields(1);
654 fields[TypeFunc::Parms+0] = NULL; // void
655 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms, fields);
656
657 // create result type
658 fields = TypeTuple::fields(1);
659 fields[TypeFunc::Parms+0] = NULL; // void
660 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
661
662 return TypeFunc::make(domain, range);
663 }
664
665 const TypeFunc* OptoRuntime::l2f_Type() {
666 // create input type (domain)
667 const Type **fields = TypeTuple::fields(2);
668 fields[TypeFunc::Parms+0] = TypeLong::LONG;
669 fields[TypeFunc::Parms+1] = Type::HALF;
670 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
671
672 // create result type (range)
673 fields = TypeTuple::fields(1);
674 fields[TypeFunc::Parms+0] = Type::FLOAT;
675 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
676
677 return TypeFunc::make(domain, range);
678 }
679
680 const TypeFunc* OptoRuntime::modf_Type() {
681 const Type **fields = TypeTuple::fields(2);
682 fields[TypeFunc::Parms+0] = Type::FLOAT;
683 fields[TypeFunc::Parms+1] = Type::FLOAT;
684 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
685
686 // create result type (range)
687 fields = TypeTuple::fields(1);
688 fields[TypeFunc::Parms+0] = Type::FLOAT;
689
690 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
691
692 return TypeFunc::make(domain, range);
693 }
694
695 const TypeFunc *OptoRuntime::Math_D_D_Type() {
696 // create input type (domain)
697 const Type **fields = TypeTuple::fields(2);
698 // Symbol* name of class to be loaded
699 fields[TypeFunc::Parms+0] = Type::DOUBLE;
700 fields[TypeFunc::Parms+1] = Type::HALF;
701 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
702
703 // create result type (range)
704 fields = TypeTuple::fields(2);
705 fields[TypeFunc::Parms+0] = Type::DOUBLE;
706 fields[TypeFunc::Parms+1] = Type::HALF;
707 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
708
709 return TypeFunc::make(domain, range);
710 }
711
712 const TypeFunc* OptoRuntime::Math_DD_D_Type() {
713 const Type **fields = TypeTuple::fields(4);
714 fields[TypeFunc::Parms+0] = Type::DOUBLE;
715 fields[TypeFunc::Parms+1] = Type::HALF;
716 fields[TypeFunc::Parms+2] = Type::DOUBLE;
717 fields[TypeFunc::Parms+3] = Type::HALF;
718 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+4, fields);
719
720 // create result type (range)
721 fields = TypeTuple::fields(2);
722 fields[TypeFunc::Parms+0] = Type::DOUBLE;
723 fields[TypeFunc::Parms+1] = Type::HALF;
724 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
725
726 return TypeFunc::make(domain, range);
727 }
728
729 //-------------- currentTimeMillis, currentTimeNanos, etc
730
731 const TypeFunc* OptoRuntime::void_long_Type() {
732 // create input type (domain)
733 const Type **fields = TypeTuple::fields(0);
734 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+0, fields);
735
736 // create result type (range)
737 fields = TypeTuple::fields(2);
738 fields[TypeFunc::Parms+0] = TypeLong::LONG;
739 fields[TypeFunc::Parms+1] = Type::HALF;
740 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
741
742 return TypeFunc::make(domain, range);
743 }
744
745 // arraycopy stub variations:
746 enum ArrayCopyType {
747 ac_fast, // void(ptr, ptr, size_t)
748 ac_checkcast, // int(ptr, ptr, size_t, size_t, ptr)
749 ac_slow, // void(ptr, int, ptr, int, int)
750 ac_generic // int(ptr, int, ptr, int, int)
751 };
752
753 static const TypeFunc* make_arraycopy_Type(ArrayCopyType act) {
754 // create input type (domain)
755 int num_args = (act == ac_fast ? 3 : 5);
756 int num_size_args = (act == ac_fast ? 1 : act == ac_checkcast ? 2 : 0);
757 int argcnt = num_args;
758 LP64_ONLY(argcnt += num_size_args); // halfwords for lengths
759 const Type** fields = TypeTuple::fields(argcnt);
760 int argp = TypeFunc::Parms;
761 fields[argp++] = TypePtr::NOTNULL; // src
762 if (num_size_args == 0) {
768 fields[argp++] = TypeInt::INT; // length
769 }
770 while (num_size_args-- > 0) {
771 fields[argp++] = TypeX_X; // size in whatevers (size_t)
772 LP64_ONLY(fields[argp++] = Type::HALF); // other half of long length
773 }
774 if (act == ac_checkcast) {
775 fields[argp++] = TypePtr::NOTNULL; // super_klass
776 }
777 assert(argp == TypeFunc::Parms+argcnt, "correct decoding of act");
778 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
779
780 // create result type if needed
781 int retcnt = (act == ac_checkcast || act == ac_generic ? 1 : 0);
782 fields = TypeTuple::fields(1);
783 if (retcnt == 0)
784 fields[TypeFunc::Parms+0] = NULL; // void
785 else
786 fields[TypeFunc::Parms+0] = TypeInt::INT; // status result, if needed
787 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+retcnt, fields);
788 return TypeFunc::make(domain, range);
789 }
790
791 const TypeFunc* OptoRuntime::fast_arraycopy_Type() {
792 // This signature is simple: Two base pointers and a size_t.
793 return make_arraycopy_Type(ac_fast);
794 }
795
796 const TypeFunc* OptoRuntime::checkcast_arraycopy_Type() {
797 // An extension of fast_arraycopy_Type which adds type checking.
798 return make_arraycopy_Type(ac_checkcast);
799 }
800
801 const TypeFunc* OptoRuntime::slow_arraycopy_Type() {
802 // This signature is exactly the same as System.arraycopy.
803 // There are no intptr_t (int/long) arguments.
804 return make_arraycopy_Type(ac_slow);
805 }
806
807 const TypeFunc* OptoRuntime::generic_arraycopy_Type() {
808 // This signature is like System.arraycopy, except that it returns status.
809 return make_arraycopy_Type(ac_generic);
810 }
811
812
813 const TypeFunc* OptoRuntime::array_fill_Type() {
814 const Type** fields;
815 int argp = TypeFunc::Parms;
816 // create input type (domain): pointer, int, size_t
817 fields = TypeTuple::fields(3 LP64_ONLY( + 1));
818 fields[argp++] = TypePtr::NOTNULL;
819 fields[argp++] = TypeInt::INT;
820 fields[argp++] = TypeX_X; // size in whatevers (size_t)
821 LP64_ONLY(fields[argp++] = Type::HALF); // other half of long length
822 const TypeTuple *domain = TypeTuple::make(argp, fields);
823
824 // create result type
825 fields = TypeTuple::fields(1);
826 fields[TypeFunc::Parms+0] = NULL; // void
827 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
828
829 return TypeFunc::make(domain, range);
830 }
831
832 // for aescrypt encrypt/decrypt operations, just three pointers returning void (length is constant)
833 const TypeFunc* OptoRuntime::aescrypt_block_Type() {
834 // create input type (domain)
835 int num_args = 3;
836 if (Matcher::pass_original_key_for_aes()) {
837 num_args = 4;
838 }
839 int argcnt = num_args;
840 const Type** fields = TypeTuple::fields(argcnt);
841 int argp = TypeFunc::Parms;
842 fields[argp++] = TypePtr::NOTNULL; // src
843 fields[argp++] = TypePtr::NOTNULL; // dest
844 fields[argp++] = TypePtr::NOTNULL; // k array
845 if (Matcher::pass_original_key_for_aes()) {
846 fields[argp++] = TypePtr::NOTNULL; // original k array
847 }
848 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
849 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
850
851 // no result type needed
852 fields = TypeTuple::fields(1);
853 fields[TypeFunc::Parms+0] = NULL; // void
854 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
855 return TypeFunc::make(domain, range);
856 }
857
858 /**
859 * int updateBytesCRC32(int crc, byte* b, int len)
860 */
861 const TypeFunc* OptoRuntime::updateBytesCRC32_Type() {
862 // create input type (domain)
863 int num_args = 3;
864 int argcnt = num_args;
865 const Type** fields = TypeTuple::fields(argcnt);
866 int argp = TypeFunc::Parms;
867 fields[argp++] = TypeInt::INT; // crc
868 fields[argp++] = TypePtr::NOTNULL; // src
869 fields[argp++] = TypeInt::INT; // len
870 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
871 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
872
873 // result type needed
874 fields = TypeTuple::fields(1);
875 fields[TypeFunc::Parms+0] = TypeInt::INT; // crc result
876 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
877 return TypeFunc::make(domain, range);
878 }
879
880 /**
881 * int updateBytesCRC32C(int crc, byte* buf, int len, int* table)
882 */
883 const TypeFunc* OptoRuntime::updateBytesCRC32C_Type() {
884 // create input type (domain)
885 int num_args = 4;
886 int argcnt = num_args;
887 const Type** fields = TypeTuple::fields(argcnt);
888 int argp = TypeFunc::Parms;
889 fields[argp++] = TypeInt::INT; // crc
890 fields[argp++] = TypePtr::NOTNULL; // buf
891 fields[argp++] = TypeInt::INT; // len
892 fields[argp++] = TypePtr::NOTNULL; // table
893 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
894 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
895
896 // result type needed
897 fields = TypeTuple::fields(1);
898 fields[TypeFunc::Parms+0] = TypeInt::INT; // crc result
899 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
900 return TypeFunc::make(domain, range);
901 }
902
903 /**
904 * int updateBytesAdler32(int adler, bytes* b, int off, int len)
905 */
906 const TypeFunc* OptoRuntime::updateBytesAdler32_Type() {
907 // create input type (domain)
908 int num_args = 3;
909 int argcnt = num_args;
910 const Type** fields = TypeTuple::fields(argcnt);
911 int argp = TypeFunc::Parms;
912 fields[argp++] = TypeInt::INT; // crc
913 fields[argp++] = TypePtr::NOTNULL; // src + offset
914 fields[argp++] = TypeInt::INT; // len
915 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
916 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
917
918 // result type needed
919 fields = TypeTuple::fields(1);
920 fields[TypeFunc::Parms+0] = TypeInt::INT; // crc result
921 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
922 return TypeFunc::make(domain, range);
923 }
924
925 // for cipherBlockChaining calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
926 const TypeFunc* OptoRuntime::cipherBlockChaining_aescrypt_Type() {
927 // create input type (domain)
928 int num_args = 5;
929 if (Matcher::pass_original_key_for_aes()) {
930 num_args = 6;
931 }
932 int argcnt = num_args;
933 const Type** fields = TypeTuple::fields(argcnt);
934 int argp = TypeFunc::Parms;
935 fields[argp++] = TypePtr::NOTNULL; // src
936 fields[argp++] = TypePtr::NOTNULL; // dest
937 fields[argp++] = TypePtr::NOTNULL; // k array
938 fields[argp++] = TypePtr::NOTNULL; // r array
939 fields[argp++] = TypeInt::INT; // src len
940 if (Matcher::pass_original_key_for_aes()) {
941 fields[argp++] = TypePtr::NOTNULL; // original k array
942 }
943 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
944 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
945
946 // returning cipher len (int)
947 fields = TypeTuple::fields(1);
948 fields[TypeFunc::Parms+0] = TypeInt::INT;
949 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
950 return TypeFunc::make(domain, range);
951 }
952
953 //for counterMode calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
954 const TypeFunc* OptoRuntime::counterMode_aescrypt_Type() {
955 // create input type (domain)
956 int num_args = 7;
957 if (Matcher::pass_original_key_for_aes()) {
958 num_args = 8;
959 }
960 int argcnt = num_args;
961 const Type** fields = TypeTuple::fields(argcnt);
962 int argp = TypeFunc::Parms;
963 fields[argp++] = TypePtr::NOTNULL; // src
964 fields[argp++] = TypePtr::NOTNULL; // dest
965 fields[argp++] = TypePtr::NOTNULL; // k array
966 fields[argp++] = TypePtr::NOTNULL; // counter array
967 fields[argp++] = TypeInt::INT; // src len
968 fields[argp++] = TypePtr::NOTNULL; // saved_encCounter
969 fields[argp++] = TypePtr::NOTNULL; // saved used addr
970 if (Matcher::pass_original_key_for_aes()) {
971 fields[argp++] = TypePtr::NOTNULL; // original k array
972 }
973 assert(argp == TypeFunc::Parms + argcnt, "correct decoding");
974 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms + argcnt, fields);
975 // returning cipher len (int)
976 fields = TypeTuple::fields(1);
977 fields[TypeFunc::Parms + 0] = TypeInt::INT;
978 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms + 1, fields);
979 return TypeFunc::make(domain, range);
980 }
981
982 /*
983 * void implCompress(byte[] buf, int ofs)
984 */
985 const TypeFunc* OptoRuntime::sha_implCompress_Type() {
986 // create input type (domain)
987 int num_args = 2;
988 int argcnt = num_args;
989 const Type** fields = TypeTuple::fields(argcnt);
990 int argp = TypeFunc::Parms;
991 fields[argp++] = TypePtr::NOTNULL; // buf
992 fields[argp++] = TypePtr::NOTNULL; // state
993 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
994 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
995
996 // no result type needed
997 fields = TypeTuple::fields(1);
998 fields[TypeFunc::Parms+0] = NULL; // void
999 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1000 return TypeFunc::make(domain, range);
1001 }
1002
1003 /*
1004 * int implCompressMultiBlock(byte[] b, int ofs, int limit)
1005 */
1006 const TypeFunc* OptoRuntime::digestBase_implCompressMB_Type() {
1007 // create input type (domain)
1008 int num_args = 4;
1009 int argcnt = num_args;
1010 const Type** fields = TypeTuple::fields(argcnt);
1011 int argp = TypeFunc::Parms;
1012 fields[argp++] = TypePtr::NOTNULL; // buf
1013 fields[argp++] = TypePtr::NOTNULL; // state
1014 fields[argp++] = TypeInt::INT; // ofs
1015 fields[argp++] = TypeInt::INT; // limit
1016 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1017 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1018
1019 // returning ofs (int)
1020 fields = TypeTuple::fields(1);
1021 fields[TypeFunc::Parms+0] = TypeInt::INT; // ofs
1022 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
1023 return TypeFunc::make(domain, range);
1024 }
1025
1026 const TypeFunc* OptoRuntime::multiplyToLen_Type() {
1027 // create input type (domain)
1028 int num_args = 6;
1029 int argcnt = num_args;
1030 const Type** fields = TypeTuple::fields(argcnt);
1031 int argp = TypeFunc::Parms;
1032 fields[argp++] = TypePtr::NOTNULL; // x
1033 fields[argp++] = TypeInt::INT; // xlen
1034 fields[argp++] = TypePtr::NOTNULL; // y
1035 fields[argp++] = TypeInt::INT; // ylen
1036 fields[argp++] = TypePtr::NOTNULL; // z
1037 fields[argp++] = TypeInt::INT; // zlen
1038 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1039 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1040
1041 // no result type needed
1042 fields = TypeTuple::fields(1);
1043 fields[TypeFunc::Parms+0] = NULL;
1044 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1045 return TypeFunc::make(domain, range);
1046 }
1047
1048 const TypeFunc* OptoRuntime::squareToLen_Type() {
1049 // create input type (domain)
1050 int num_args = 4;
1051 int argcnt = num_args;
1052 const Type** fields = TypeTuple::fields(argcnt);
1053 int argp = TypeFunc::Parms;
1054 fields[argp++] = TypePtr::NOTNULL; // x
1055 fields[argp++] = TypeInt::INT; // len
1056 fields[argp++] = TypePtr::NOTNULL; // z
1057 fields[argp++] = TypeInt::INT; // zlen
1058 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1059 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1060
1061 // no result type needed
1062 fields = TypeTuple::fields(1);
1063 fields[TypeFunc::Parms+0] = NULL;
1064 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1065 return TypeFunc::make(domain, range);
1066 }
1067
1068 // for mulAdd calls, 2 pointers and 3 ints, returning int
1069 const TypeFunc* OptoRuntime::mulAdd_Type() {
1070 // create input type (domain)
1071 int num_args = 5;
1072 int argcnt = num_args;
1073 const Type** fields = TypeTuple::fields(argcnt);
1074 int argp = TypeFunc::Parms;
1075 fields[argp++] = TypePtr::NOTNULL; // out
1076 fields[argp++] = TypePtr::NOTNULL; // in
1077 fields[argp++] = TypeInt::INT; // offset
1078 fields[argp++] = TypeInt::INT; // len
1079 fields[argp++] = TypeInt::INT; // k
1080 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1081 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1082
1083 // returning carry (int)
1084 fields = TypeTuple::fields(1);
1085 fields[TypeFunc::Parms+0] = TypeInt::INT;
1086 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
1087 return TypeFunc::make(domain, range);
1088 }
1089
1090 const TypeFunc* OptoRuntime::montgomeryMultiply_Type() {
1091 // create input type (domain)
1092 int num_args = 7;
1093 int argcnt = num_args;
1094 const Type** fields = TypeTuple::fields(argcnt);
1095 int argp = TypeFunc::Parms;
1096 fields[argp++] = TypePtr::NOTNULL; // a
1097 fields[argp++] = TypePtr::NOTNULL; // b
1098 fields[argp++] = TypePtr::NOTNULL; // n
1099 fields[argp++] = TypeInt::INT; // len
1100 fields[argp++] = TypeLong::LONG; // inv
1101 fields[argp++] = Type::HALF;
1102 fields[argp++] = TypePtr::NOTNULL; // result
1103 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1104 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1105
1106 // result type needed
1107 fields = TypeTuple::fields(1);
1108 fields[TypeFunc::Parms+0] = TypePtr::NOTNULL;
1109
1110 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1111 return TypeFunc::make(domain, range);
1112 }
1113
1114 const TypeFunc* OptoRuntime::montgomerySquare_Type() {
1115 // create input type (domain)
1116 int num_args = 6;
1117 int argcnt = num_args;
1118 const Type** fields = TypeTuple::fields(argcnt);
1119 int argp = TypeFunc::Parms;
1120 fields[argp++] = TypePtr::NOTNULL; // a
1121 fields[argp++] = TypePtr::NOTNULL; // n
1122 fields[argp++] = TypeInt::INT; // len
1123 fields[argp++] = TypeLong::LONG; // inv
1124 fields[argp++] = Type::HALF;
1125 fields[argp++] = TypePtr::NOTNULL; // result
1126 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1127 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1128
1129 // result type needed
1130 fields = TypeTuple::fields(1);
1131 fields[TypeFunc::Parms+0] = TypePtr::NOTNULL;
1132
1133 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1134 return TypeFunc::make(domain, range);
1135 }
1136
1137 const TypeFunc* OptoRuntime::vectorizedMismatch_Type() {
1138 // create input type (domain)
1139 int num_args = 4;
1140 int argcnt = num_args;
1141 const Type** fields = TypeTuple::fields(argcnt);
1142 int argp = TypeFunc::Parms;
1143 fields[argp++] = TypePtr::NOTNULL; // obja
1144 fields[argp++] = TypePtr::NOTNULL; // objb
1145 fields[argp++] = TypeInt::INT; // length, number of elements
1146 fields[argp++] = TypeInt::INT; // log2scale, element size
1147 assert(argp == TypeFunc::Parms + argcnt, "correct decoding");
1148 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms + argcnt, fields);
1149
1150 //return mismatch index (int)
1151 fields = TypeTuple::fields(1);
1152 fields[TypeFunc::Parms + 0] = TypeInt::INT;
1153 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms + 1, fields);
1154 return TypeFunc::make(domain, range);
1155 }
1156
1157 // GHASH block processing
1158 const TypeFunc* OptoRuntime::ghash_processBlocks_Type() {
1159 int argcnt = 4;
1160
1161 const Type** fields = TypeTuple::fields(argcnt);
1162 int argp = TypeFunc::Parms;
1163 fields[argp++] = TypePtr::NOTNULL; // state
1164 fields[argp++] = TypePtr::NOTNULL; // subkeyH
1165 fields[argp++] = TypePtr::NOTNULL; // data
1166 fields[argp++] = TypeInt::INT; // blocks
1167 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1168 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1169
1170 // result type needed
1171 fields = TypeTuple::fields(1);
1172 fields[TypeFunc::Parms+0] = NULL; // void
1173 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1174 return TypeFunc::make(domain, range);
1175 }
1176
1177 //------------- Interpreter state access for on stack replacement
1178 const TypeFunc* OptoRuntime::osr_end_Type() {
1179 // create input type (domain)
1180 const Type **fields = TypeTuple::fields(1);
1181 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // OSR temp buf
1182 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
1183
1184 // create result type
1185 fields = TypeTuple::fields(1);
1186 // fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // locked oop
1187 fields[TypeFunc::Parms+0] = NULL; // void
1188 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
1189 return TypeFunc::make(domain, range);
1190 }
1191
1192 //-------------- methodData update helpers
1193
1194 const TypeFunc* OptoRuntime::profile_receiver_type_Type() {
1195 // create input type (domain)
1196 const Type **fields = TypeTuple::fields(2);
1197 fields[TypeFunc::Parms+0] = TypeAryPtr::NOTNULL; // methodData pointer
1198 fields[TypeFunc::Parms+1] = TypeInstPtr::BOTTOM; // receiver oop
1199 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
1200
1201 // create result type
1202 fields = TypeTuple::fields(1);
1203 fields[TypeFunc::Parms+0] = NULL; // void
1204 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
1205 return TypeFunc::make(domain,range);
1206 }
1207
1208 JRT_LEAF(void, OptoRuntime::profile_receiver_type_C(DataLayout* data, oopDesc* receiver))
1209 if (receiver == NULL) return;
1210 Klass* receiver_klass = receiver->klass();
1211
1212 intptr_t* mdp = ((intptr_t*)(data)) + DataLayout::header_size_in_cells();
1213 int empty_row = -1; // free row, if any is encountered
1214
1215 // ReceiverTypeData* vc = new ReceiverTypeData(mdp);
1216 for (uint row = 0; row < ReceiverTypeData::row_limit(); row++) {
1217 // if (vc->receiver(row) == receiver_klass)
1218 int receiver_off = ReceiverTypeData::receiver_cell_index(row);
1219 intptr_t row_recv = *(mdp + receiver_off);
1220 if (row_recv == (intptr_t) receiver_klass) {
1221 // vc->set_receiver_count(row, vc->receiver_count(row) + DataLayout::counter_increment);
1222 int count_off = ReceiverTypeData::receiver_count_cell_index(row);
1223 *(mdp + count_off) += DataLayout::counter_increment;
1224 return;
1225 } else if (row_recv == 0) {
1449 }
1450 #endif
1451
1452 thread->set_vm_result(exception);
1453 // Frame not compiled (handles deoptimization blob)
1454 return SharedRuntime::raw_exception_handler_for_return_address(thread, ret_pc);
1455 }
1456
1457
1458 const TypeFunc *OptoRuntime::rethrow_Type() {
1459 // create input type (domain)
1460 const Type **fields = TypeTuple::fields(1);
1461 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Exception oop
1462 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1,fields);
1463
1464 // create result type (range)
1465 fields = TypeTuple::fields(1);
1466 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Exception oop
1467 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
1468
1469 return TypeFunc::make(domain, range);
1470 }
1471
1472
1473 void OptoRuntime::deoptimize_caller_frame(JavaThread *thread, bool doit) {
1474 // Deoptimize the caller before continuing, as the compiled
1475 // exception handler table may not be valid.
1476 if (!StressCompiledExceptionHandlers && doit) {
1477 deoptimize_caller_frame(thread);
1478 }
1479 }
1480
1481 void OptoRuntime::deoptimize_caller_frame(JavaThread *thread) {
1482 // Called from within the owner thread, so no need for safepoint
1483 RegisterMap reg_map(thread);
1484 frame stub_frame = thread->last_frame();
1485 assert(stub_frame.is_runtime_frame() || exception_blob()->contains(stub_frame.pc()), "sanity check");
1486 frame caller_frame = stub_frame.sender(®_map);
1487
1488 // Deoptimize the caller frame.
1489 Deoptimization::deoptimize_frame(thread, caller_frame.id());
1496 frame stub_frame = thread->last_frame();
1497 assert(stub_frame.is_runtime_frame() || exception_blob()->contains(stub_frame.pc()), "sanity check");
1498 frame caller_frame = stub_frame.sender(®_map);
1499 return caller_frame.is_deoptimized_frame();
1500 }
1501
1502
1503 const TypeFunc *OptoRuntime::register_finalizer_Type() {
1504 // create input type (domain)
1505 const Type **fields = TypeTuple::fields(1);
1506 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // oop; Receiver
1507 // // The JavaThread* is passed to each routine as the last argument
1508 // fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // JavaThread *; Executing thread
1509 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1,fields);
1510
1511 // create result type (range)
1512 fields = TypeTuple::fields(0);
1513
1514 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
1515
1516 return TypeFunc::make(domain,range);
1517 }
1518
1519
1520 //-----------------------------------------------------------------------------
1521 // Dtrace support. entry and exit probes have the same signature
1522 const TypeFunc *OptoRuntime::dtrace_method_entry_exit_Type() {
1523 // create input type (domain)
1524 const Type **fields = TypeTuple::fields(2);
1525 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage
1526 fields[TypeFunc::Parms+1] = TypeMetadataPtr::BOTTOM; // Method*; Method we are entering
1527 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
1528
1529 // create result type (range)
1530 fields = TypeTuple::fields(0);
1531
1532 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
1533
1534 return TypeFunc::make(domain,range);
1535 }
1536
1537 const TypeFunc *OptoRuntime::dtrace_object_alloc_Type() {
1538 // create input type (domain)
1539 const Type **fields = TypeTuple::fields(2);
1540 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage
1541 fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // oop; newly allocated object
1542
1543 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
1544
1545 // create result type (range)
1546 fields = TypeTuple::fields(0);
1547
1548 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
1549
1550 return TypeFunc::make(domain,range);
1551 }
1552
1553
1554 JRT_ENTRY_NO_ASYNC(void, OptoRuntime::register_finalizer(oopDesc* obj, JavaThread* thread))
1555 assert(obj->is_oop(), "must be a valid oop");
1556 assert(obj->klass()->has_finalizer(), "shouldn't be here otherwise");
1557 InstanceKlass::register_finalizer(instanceOop(obj), CHECK);
1558 JRT_END
1559
1560 //-----------------------------------------------------------------------------
1561
1562 NamedCounter * volatile OptoRuntime::_named_counters = NULL;
1563
1564 //
1565 // dump the collected NamedCounters.
1566 //
1567 void OptoRuntime::print_named_counters() {
1568 int total_lock_count = 0;
1569 int eliminated_lock_count = 0;
1570
|
461 // (The fast-path is just a degenerate variant of the slow-path).
462 // Perform the dreaded state transition and pass control into the slow-path.
463 JRT_BLOCK;
464 Handle h_obj(THREAD, obj);
465 ObjectSynchronizer::notifyall(h_obj, CHECK);
466 JRT_BLOCK_END;
467 JRT_END
468
469 const TypeFunc *OptoRuntime::new_instance_Type() {
470 // create input type (domain)
471 const Type **fields = TypeTuple::fields(1);
472 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
473 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
474
475 // create result type (range)
476 fields = TypeTuple::fields(1);
477 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
478
479 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
480
481 return TypeFunc::make(domain, domain, range);
482 }
483
484
485 const TypeFunc *OptoRuntime::athrow_Type() {
486 // create input type (domain)
487 const Type **fields = TypeTuple::fields(1);
488 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
489 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
490
491 // create result type (range)
492 fields = TypeTuple::fields(0);
493
494 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
495
496 return TypeFunc::make(domain, domain, range);
497 }
498
499
500 const TypeFunc *OptoRuntime::new_array_Type() {
501 // create input type (domain)
502 const Type **fields = TypeTuple::fields(2);
503 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // element klass
504 fields[TypeFunc::Parms+1] = TypeInt::INT; // array size
505 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
506
507 // create result type (range)
508 fields = TypeTuple::fields(1);
509 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
510
511 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
512
513 return TypeFunc::make(domain, domain, range);
514 }
515
516 const TypeFunc *OptoRuntime::multianewarray_Type(int ndim) {
517 // create input type (domain)
518 const int nargs = ndim + 1;
519 const Type **fields = TypeTuple::fields(nargs);
520 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // element klass
521 for( int i = 1; i < nargs; i++ )
522 fields[TypeFunc::Parms + i] = TypeInt::INT; // array size
523 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+nargs, fields);
524
525 // create result type (range)
526 fields = TypeTuple::fields(1);
527 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
528 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
529
530 return TypeFunc::make(domain, domain, range);
531 }
532
533 const TypeFunc *OptoRuntime::multianewarray2_Type() {
534 return multianewarray_Type(2);
535 }
536
537 const TypeFunc *OptoRuntime::multianewarray3_Type() {
538 return multianewarray_Type(3);
539 }
540
541 const TypeFunc *OptoRuntime::multianewarray4_Type() {
542 return multianewarray_Type(4);
543 }
544
545 const TypeFunc *OptoRuntime::multianewarray5_Type() {
546 return multianewarray_Type(5);
547 }
548
549 const TypeFunc *OptoRuntime::multianewarrayN_Type() {
550 // create input type (domain)
551 const Type **fields = TypeTuple::fields(2);
552 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // element klass
553 fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // array of dim sizes
554 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
555
556 // create result type (range)
557 fields = TypeTuple::fields(1);
558 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
559 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
560
561 return TypeFunc::make(domain, domain, range);
562 }
563
564 const TypeFunc *OptoRuntime::g1_wb_pre_Type() {
565 const Type **fields = TypeTuple::fields(2);
566 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // original field value
567 fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // thread
568 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
569
570 // create result type (range)
571 fields = TypeTuple::fields(0);
572 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
573
574 return TypeFunc::make(domain, domain, range);
575 }
576
577 const TypeFunc *OptoRuntime::g1_wb_post_Type() {
578
579 const Type **fields = TypeTuple::fields(2);
580 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Card addr
581 fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // thread
582 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
583
584 // create result type (range)
585 fields = TypeTuple::fields(0);
586 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
587
588 return TypeFunc::make(domain, domain, range);
589 }
590
591 const TypeFunc *OptoRuntime::uncommon_trap_Type() {
592 // create input type (domain)
593 const Type **fields = TypeTuple::fields(1);
594 fields[TypeFunc::Parms+0] = TypeInt::INT; // trap_reason (deopt reason and action)
595 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
596
597 // create result type (range)
598 fields = TypeTuple::fields(0);
599 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
600
601 return TypeFunc::make(domain, domain, range);
602 }
603
604 //-----------------------------------------------------------------------------
605 // Monitor Handling
606 const TypeFunc *OptoRuntime::complete_monitor_enter_Type() {
607 // create input type (domain)
608 const Type **fields = TypeTuple::fields(2);
609 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
610 fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // Address of stack location for lock
611 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
612
613 // create result type (range)
614 fields = TypeTuple::fields(0);
615
616 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
617
618 return TypeFunc::make(domain, domain, range);
619 }
620
621
622 //-----------------------------------------------------------------------------
623 const TypeFunc *OptoRuntime::complete_monitor_exit_Type() {
624 // create input type (domain)
625 const Type **fields = TypeTuple::fields(3);
626 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
627 fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // Address of stack location for lock - BasicLock
628 fields[TypeFunc::Parms+2] = TypeRawPtr::BOTTOM; // Thread pointer (Self)
629 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+3, fields);
630
631 // create result type (range)
632 fields = TypeTuple::fields(0);
633
634 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
635
636 return TypeFunc::make(domain, domain, range);
637 }
638
639 const TypeFunc *OptoRuntime::monitor_notify_Type() {
640 // create input type (domain)
641 const Type **fields = TypeTuple::fields(1);
642 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
643 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
644
645 // create result type (range)
646 fields = TypeTuple::fields(0);
647 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
648 return TypeFunc::make(domain, domain, range);
649 }
650
651 const TypeFunc* OptoRuntime::flush_windows_Type() {
652 // create input type (domain)
653 const Type** fields = TypeTuple::fields(1);
654 fields[TypeFunc::Parms+0] = NULL; // void
655 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms, fields);
656
657 // create result type
658 fields = TypeTuple::fields(1);
659 fields[TypeFunc::Parms+0] = NULL; // void
660 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
661
662 return TypeFunc::make(domain, domain, range);
663 }
664
665 const TypeFunc* OptoRuntime::l2f_Type() {
666 // create input type (domain)
667 const Type **fields = TypeTuple::fields(2);
668 fields[TypeFunc::Parms+0] = TypeLong::LONG;
669 fields[TypeFunc::Parms+1] = Type::HALF;
670 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
671
672 // create result type (range)
673 fields = TypeTuple::fields(1);
674 fields[TypeFunc::Parms+0] = Type::FLOAT;
675 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
676
677 return TypeFunc::make(domain, domain, range);
678 }
679
680 const TypeFunc* OptoRuntime::modf_Type() {
681 const Type **fields = TypeTuple::fields(2);
682 fields[TypeFunc::Parms+0] = Type::FLOAT;
683 fields[TypeFunc::Parms+1] = Type::FLOAT;
684 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
685
686 // create result type (range)
687 fields = TypeTuple::fields(1);
688 fields[TypeFunc::Parms+0] = Type::FLOAT;
689
690 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
691
692 return TypeFunc::make(domain, domain, range);
693 }
694
695 const TypeFunc *OptoRuntime::Math_D_D_Type() {
696 // create input type (domain)
697 const Type **fields = TypeTuple::fields(2);
698 // Symbol* name of class to be loaded
699 fields[TypeFunc::Parms+0] = Type::DOUBLE;
700 fields[TypeFunc::Parms+1] = Type::HALF;
701 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
702
703 // create result type (range)
704 fields = TypeTuple::fields(2);
705 fields[TypeFunc::Parms+0] = Type::DOUBLE;
706 fields[TypeFunc::Parms+1] = Type::HALF;
707 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
708
709 return TypeFunc::make(domain, domain, range);
710 }
711
712 const TypeFunc* OptoRuntime::Math_DD_D_Type() {
713 const Type **fields = TypeTuple::fields(4);
714 fields[TypeFunc::Parms+0] = Type::DOUBLE;
715 fields[TypeFunc::Parms+1] = Type::HALF;
716 fields[TypeFunc::Parms+2] = Type::DOUBLE;
717 fields[TypeFunc::Parms+3] = Type::HALF;
718 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+4, fields);
719
720 // create result type (range)
721 fields = TypeTuple::fields(2);
722 fields[TypeFunc::Parms+0] = Type::DOUBLE;
723 fields[TypeFunc::Parms+1] = Type::HALF;
724 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
725
726 return TypeFunc::make(domain, domain, range);
727 }
728
729 //-------------- currentTimeMillis, currentTimeNanos, etc
730
731 const TypeFunc* OptoRuntime::void_long_Type() {
732 // create input type (domain)
733 const Type **fields = TypeTuple::fields(0);
734 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+0, fields);
735
736 // create result type (range)
737 fields = TypeTuple::fields(2);
738 fields[TypeFunc::Parms+0] = TypeLong::LONG;
739 fields[TypeFunc::Parms+1] = Type::HALF;
740 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
741
742 return TypeFunc::make(domain, domain, range);
743 }
744
745 // arraycopy stub variations:
746 enum ArrayCopyType {
747 ac_fast, // void(ptr, ptr, size_t)
748 ac_checkcast, // int(ptr, ptr, size_t, size_t, ptr)
749 ac_slow, // void(ptr, int, ptr, int, int)
750 ac_generic // int(ptr, int, ptr, int, int)
751 };
752
753 static const TypeFunc* make_arraycopy_Type(ArrayCopyType act) {
754 // create input type (domain)
755 int num_args = (act == ac_fast ? 3 : 5);
756 int num_size_args = (act == ac_fast ? 1 : act == ac_checkcast ? 2 : 0);
757 int argcnt = num_args;
758 LP64_ONLY(argcnt += num_size_args); // halfwords for lengths
759 const Type** fields = TypeTuple::fields(argcnt);
760 int argp = TypeFunc::Parms;
761 fields[argp++] = TypePtr::NOTNULL; // src
762 if (num_size_args == 0) {
768 fields[argp++] = TypeInt::INT; // length
769 }
770 while (num_size_args-- > 0) {
771 fields[argp++] = TypeX_X; // size in whatevers (size_t)
772 LP64_ONLY(fields[argp++] = Type::HALF); // other half of long length
773 }
774 if (act == ac_checkcast) {
775 fields[argp++] = TypePtr::NOTNULL; // super_klass
776 }
777 assert(argp == TypeFunc::Parms+argcnt, "correct decoding of act");
778 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
779
780 // create result type if needed
781 int retcnt = (act == ac_checkcast || act == ac_generic ? 1 : 0);
782 fields = TypeTuple::fields(1);
783 if (retcnt == 0)
784 fields[TypeFunc::Parms+0] = NULL; // void
785 else
786 fields[TypeFunc::Parms+0] = TypeInt::INT; // status result, if needed
787 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+retcnt, fields);
788 return TypeFunc::make(domain, domain, range);
789 }
790
791 const TypeFunc* OptoRuntime::fast_arraycopy_Type() {
792 // This signature is simple: Two base pointers and a size_t.
793 return make_arraycopy_Type(ac_fast);
794 }
795
796 const TypeFunc* OptoRuntime::checkcast_arraycopy_Type() {
797 // An extension of fast_arraycopy_Type which adds type checking.
798 return make_arraycopy_Type(ac_checkcast);
799 }
800
801 const TypeFunc* OptoRuntime::slow_arraycopy_Type() {
802 // This signature is exactly the same as System.arraycopy.
803 // There are no intptr_t (int/long) arguments.
804 return make_arraycopy_Type(ac_slow);
805 }
806
807 const TypeFunc* OptoRuntime::generic_arraycopy_Type() {
808 // This signature is like System.arraycopy, except that it returns status.
809 return make_arraycopy_Type(ac_generic);
810 }
811
812
813 const TypeFunc* OptoRuntime::array_fill_Type() {
814 const Type** fields;
815 int argp = TypeFunc::Parms;
816 // create input type (domain): pointer, int, size_t
817 fields = TypeTuple::fields(3 LP64_ONLY( + 1));
818 fields[argp++] = TypePtr::NOTNULL;
819 fields[argp++] = TypeInt::INT;
820 fields[argp++] = TypeX_X; // size in whatevers (size_t)
821 LP64_ONLY(fields[argp++] = Type::HALF); // other half of long length
822 const TypeTuple *domain = TypeTuple::make(argp, fields);
823
824 // create result type
825 fields = TypeTuple::fields(1);
826 fields[TypeFunc::Parms+0] = NULL; // void
827 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
828
829 return TypeFunc::make(domain, domain, range);
830 }
831
832 // for aescrypt encrypt/decrypt operations, just three pointers returning void (length is constant)
833 const TypeFunc* OptoRuntime::aescrypt_block_Type() {
834 // create input type (domain)
835 int num_args = 3;
836 if (Matcher::pass_original_key_for_aes()) {
837 num_args = 4;
838 }
839 int argcnt = num_args;
840 const Type** fields = TypeTuple::fields(argcnt);
841 int argp = TypeFunc::Parms;
842 fields[argp++] = TypePtr::NOTNULL; // src
843 fields[argp++] = TypePtr::NOTNULL; // dest
844 fields[argp++] = TypePtr::NOTNULL; // k array
845 if (Matcher::pass_original_key_for_aes()) {
846 fields[argp++] = TypePtr::NOTNULL; // original k array
847 }
848 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
849 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
850
851 // no result type needed
852 fields = TypeTuple::fields(1);
853 fields[TypeFunc::Parms+0] = NULL; // void
854 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
855 return TypeFunc::make(domain, domain, range);
856 }
857
858 /**
859 * int updateBytesCRC32(int crc, byte* b, int len)
860 */
861 const TypeFunc* OptoRuntime::updateBytesCRC32_Type() {
862 // create input type (domain)
863 int num_args = 3;
864 int argcnt = num_args;
865 const Type** fields = TypeTuple::fields(argcnt);
866 int argp = TypeFunc::Parms;
867 fields[argp++] = TypeInt::INT; // crc
868 fields[argp++] = TypePtr::NOTNULL; // src
869 fields[argp++] = TypeInt::INT; // len
870 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
871 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
872
873 // result type needed
874 fields = TypeTuple::fields(1);
875 fields[TypeFunc::Parms+0] = TypeInt::INT; // crc result
876 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
877 return TypeFunc::make(domain, domain, range);
878 }
879
880 /**
881 * int updateBytesCRC32C(int crc, byte* buf, int len, int* table)
882 */
883 const TypeFunc* OptoRuntime::updateBytesCRC32C_Type() {
884 // create input type (domain)
885 int num_args = 4;
886 int argcnt = num_args;
887 const Type** fields = TypeTuple::fields(argcnt);
888 int argp = TypeFunc::Parms;
889 fields[argp++] = TypeInt::INT; // crc
890 fields[argp++] = TypePtr::NOTNULL; // buf
891 fields[argp++] = TypeInt::INT; // len
892 fields[argp++] = TypePtr::NOTNULL; // table
893 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
894 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
895
896 // result type needed
897 fields = TypeTuple::fields(1);
898 fields[TypeFunc::Parms+0] = TypeInt::INT; // crc result
899 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
900 return TypeFunc::make(domain, domain, range);
901 }
902
903 /**
904 * int updateBytesAdler32(int adler, bytes* b, int off, int len)
905 */
906 const TypeFunc* OptoRuntime::updateBytesAdler32_Type() {
907 // create input type (domain)
908 int num_args = 3;
909 int argcnt = num_args;
910 const Type** fields = TypeTuple::fields(argcnt);
911 int argp = TypeFunc::Parms;
912 fields[argp++] = TypeInt::INT; // crc
913 fields[argp++] = TypePtr::NOTNULL; // src + offset
914 fields[argp++] = TypeInt::INT; // len
915 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
916 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
917
918 // result type needed
919 fields = TypeTuple::fields(1);
920 fields[TypeFunc::Parms+0] = TypeInt::INT; // crc result
921 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
922 return TypeFunc::make(domain, domain, range);
923 }
924
925 // for cipherBlockChaining calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
926 const TypeFunc* OptoRuntime::cipherBlockChaining_aescrypt_Type() {
927 // create input type (domain)
928 int num_args = 5;
929 if (Matcher::pass_original_key_for_aes()) {
930 num_args = 6;
931 }
932 int argcnt = num_args;
933 const Type** fields = TypeTuple::fields(argcnt);
934 int argp = TypeFunc::Parms;
935 fields[argp++] = TypePtr::NOTNULL; // src
936 fields[argp++] = TypePtr::NOTNULL; // dest
937 fields[argp++] = TypePtr::NOTNULL; // k array
938 fields[argp++] = TypePtr::NOTNULL; // r array
939 fields[argp++] = TypeInt::INT; // src len
940 if (Matcher::pass_original_key_for_aes()) {
941 fields[argp++] = TypePtr::NOTNULL; // original k array
942 }
943 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
944 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
945
946 // returning cipher len (int)
947 fields = TypeTuple::fields(1);
948 fields[TypeFunc::Parms+0] = TypeInt::INT;
949 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
950 return TypeFunc::make(domain, domain, range);
951 }
952
953 //for counterMode calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
954 const TypeFunc* OptoRuntime::counterMode_aescrypt_Type() {
955 // create input type (domain)
956 int num_args = 7;
957 if (Matcher::pass_original_key_for_aes()) {
958 num_args = 8;
959 }
960 int argcnt = num_args;
961 const Type** fields = TypeTuple::fields(argcnt);
962 int argp = TypeFunc::Parms;
963 fields[argp++] = TypePtr::NOTNULL; // src
964 fields[argp++] = TypePtr::NOTNULL; // dest
965 fields[argp++] = TypePtr::NOTNULL; // k array
966 fields[argp++] = TypePtr::NOTNULL; // counter array
967 fields[argp++] = TypeInt::INT; // src len
968 fields[argp++] = TypePtr::NOTNULL; // saved_encCounter
969 fields[argp++] = TypePtr::NOTNULL; // saved used addr
970 if (Matcher::pass_original_key_for_aes()) {
971 fields[argp++] = TypePtr::NOTNULL; // original k array
972 }
973 assert(argp == TypeFunc::Parms + argcnt, "correct decoding");
974 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms + argcnt, fields);
975 // returning cipher len (int)
976 fields = TypeTuple::fields(1);
977 fields[TypeFunc::Parms + 0] = TypeInt::INT;
978 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms + 1, fields);
979 return TypeFunc::make(domain, domain, range);
980 }
981
982 /*
983 * void implCompress(byte[] buf, int ofs)
984 */
985 const TypeFunc* OptoRuntime::sha_implCompress_Type() {
986 // create input type (domain)
987 int num_args = 2;
988 int argcnt = num_args;
989 const Type** fields = TypeTuple::fields(argcnt);
990 int argp = TypeFunc::Parms;
991 fields[argp++] = TypePtr::NOTNULL; // buf
992 fields[argp++] = TypePtr::NOTNULL; // state
993 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
994 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
995
996 // no result type needed
997 fields = TypeTuple::fields(1);
998 fields[TypeFunc::Parms+0] = NULL; // void
999 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1000 return TypeFunc::make(domain, domain, range);
1001 }
1002
1003 /*
1004 * int implCompressMultiBlock(byte[] b, int ofs, int limit)
1005 */
1006 const TypeFunc* OptoRuntime::digestBase_implCompressMB_Type() {
1007 // create input type (domain)
1008 int num_args = 4;
1009 int argcnt = num_args;
1010 const Type** fields = TypeTuple::fields(argcnt);
1011 int argp = TypeFunc::Parms;
1012 fields[argp++] = TypePtr::NOTNULL; // buf
1013 fields[argp++] = TypePtr::NOTNULL; // state
1014 fields[argp++] = TypeInt::INT; // ofs
1015 fields[argp++] = TypeInt::INT; // limit
1016 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1017 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1018
1019 // returning ofs (int)
1020 fields = TypeTuple::fields(1);
1021 fields[TypeFunc::Parms+0] = TypeInt::INT; // ofs
1022 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
1023 return TypeFunc::make(domain, domain, range);
1024 }
1025
1026 const TypeFunc* OptoRuntime::multiplyToLen_Type() {
1027 // create input type (domain)
1028 int num_args = 6;
1029 int argcnt = num_args;
1030 const Type** fields = TypeTuple::fields(argcnt);
1031 int argp = TypeFunc::Parms;
1032 fields[argp++] = TypePtr::NOTNULL; // x
1033 fields[argp++] = TypeInt::INT; // xlen
1034 fields[argp++] = TypePtr::NOTNULL; // y
1035 fields[argp++] = TypeInt::INT; // ylen
1036 fields[argp++] = TypePtr::NOTNULL; // z
1037 fields[argp++] = TypeInt::INT; // zlen
1038 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1039 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1040
1041 // no result type needed
1042 fields = TypeTuple::fields(1);
1043 fields[TypeFunc::Parms+0] = NULL;
1044 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1045 return TypeFunc::make(domain, domain, range);
1046 }
1047
1048 const TypeFunc* OptoRuntime::squareToLen_Type() {
1049 // create input type (domain)
1050 int num_args = 4;
1051 int argcnt = num_args;
1052 const Type** fields = TypeTuple::fields(argcnt);
1053 int argp = TypeFunc::Parms;
1054 fields[argp++] = TypePtr::NOTNULL; // x
1055 fields[argp++] = TypeInt::INT; // len
1056 fields[argp++] = TypePtr::NOTNULL; // z
1057 fields[argp++] = TypeInt::INT; // zlen
1058 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1059 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1060
1061 // no result type needed
1062 fields = TypeTuple::fields(1);
1063 fields[TypeFunc::Parms+0] = NULL;
1064 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1065 return TypeFunc::make(domain, domain, range);
1066 }
1067
1068 // for mulAdd calls, 2 pointers and 3 ints, returning int
1069 const TypeFunc* OptoRuntime::mulAdd_Type() {
1070 // create input type (domain)
1071 int num_args = 5;
1072 int argcnt = num_args;
1073 const Type** fields = TypeTuple::fields(argcnt);
1074 int argp = TypeFunc::Parms;
1075 fields[argp++] = TypePtr::NOTNULL; // out
1076 fields[argp++] = TypePtr::NOTNULL; // in
1077 fields[argp++] = TypeInt::INT; // offset
1078 fields[argp++] = TypeInt::INT; // len
1079 fields[argp++] = TypeInt::INT; // k
1080 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1081 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1082
1083 // returning carry (int)
1084 fields = TypeTuple::fields(1);
1085 fields[TypeFunc::Parms+0] = TypeInt::INT;
1086 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
1087 return TypeFunc::make(domain, domain, range);
1088 }
1089
1090 const TypeFunc* OptoRuntime::montgomeryMultiply_Type() {
1091 // create input type (domain)
1092 int num_args = 7;
1093 int argcnt = num_args;
1094 const Type** fields = TypeTuple::fields(argcnt);
1095 int argp = TypeFunc::Parms;
1096 fields[argp++] = TypePtr::NOTNULL; // a
1097 fields[argp++] = TypePtr::NOTNULL; // b
1098 fields[argp++] = TypePtr::NOTNULL; // n
1099 fields[argp++] = TypeInt::INT; // len
1100 fields[argp++] = TypeLong::LONG; // inv
1101 fields[argp++] = Type::HALF;
1102 fields[argp++] = TypePtr::NOTNULL; // result
1103 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1104 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1105
1106 // result type needed
1107 fields = TypeTuple::fields(1);
1108 fields[TypeFunc::Parms+0] = TypePtr::NOTNULL;
1109
1110 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1111 return TypeFunc::make(domain, domain, range);
1112 }
1113
1114 const TypeFunc* OptoRuntime::montgomerySquare_Type() {
1115 // create input type (domain)
1116 int num_args = 6;
1117 int argcnt = num_args;
1118 const Type** fields = TypeTuple::fields(argcnt);
1119 int argp = TypeFunc::Parms;
1120 fields[argp++] = TypePtr::NOTNULL; // a
1121 fields[argp++] = TypePtr::NOTNULL; // n
1122 fields[argp++] = TypeInt::INT; // len
1123 fields[argp++] = TypeLong::LONG; // inv
1124 fields[argp++] = Type::HALF;
1125 fields[argp++] = TypePtr::NOTNULL; // result
1126 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1127 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1128
1129 // result type needed
1130 fields = TypeTuple::fields(1);
1131 fields[TypeFunc::Parms+0] = TypePtr::NOTNULL;
1132
1133 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1134 return TypeFunc::make(domain, domain, range);
1135 }
1136
1137 const TypeFunc* OptoRuntime::vectorizedMismatch_Type() {
1138 // create input type (domain)
1139 int num_args = 4;
1140 int argcnt = num_args;
1141 const Type** fields = TypeTuple::fields(argcnt);
1142 int argp = TypeFunc::Parms;
1143 fields[argp++] = TypePtr::NOTNULL; // obja
1144 fields[argp++] = TypePtr::NOTNULL; // objb
1145 fields[argp++] = TypeInt::INT; // length, number of elements
1146 fields[argp++] = TypeInt::INT; // log2scale, element size
1147 assert(argp == TypeFunc::Parms + argcnt, "correct decoding");
1148 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms + argcnt, fields);
1149
1150 //return mismatch index (int)
1151 fields = TypeTuple::fields(1);
1152 fields[TypeFunc::Parms + 0] = TypeInt::INT;
1153 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms + 1, fields);
1154 return TypeFunc::make(domain, domain, range);
1155 }
1156
1157 // GHASH block processing
1158 const TypeFunc* OptoRuntime::ghash_processBlocks_Type() {
1159 int argcnt = 4;
1160
1161 const Type** fields = TypeTuple::fields(argcnt);
1162 int argp = TypeFunc::Parms;
1163 fields[argp++] = TypePtr::NOTNULL; // state
1164 fields[argp++] = TypePtr::NOTNULL; // subkeyH
1165 fields[argp++] = TypePtr::NOTNULL; // data
1166 fields[argp++] = TypeInt::INT; // blocks
1167 assert(argp == TypeFunc::Parms+argcnt, "correct decoding");
1168 const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields);
1169
1170 // result type needed
1171 fields = TypeTuple::fields(1);
1172 fields[TypeFunc::Parms+0] = NULL; // void
1173 const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
1174 return TypeFunc::make(domain, domain, range);
1175 }
1176
1177 //------------- Interpreter state access for on stack replacement
1178 const TypeFunc* OptoRuntime::osr_end_Type() {
1179 // create input type (domain)
1180 const Type **fields = TypeTuple::fields(1);
1181 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // OSR temp buf
1182 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
1183
1184 // create result type
1185 fields = TypeTuple::fields(1);
1186 // fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // locked oop
1187 fields[TypeFunc::Parms+0] = NULL; // void
1188 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
1189 return TypeFunc::make(domain, domain, range);
1190 }
1191
1192 //-------------- methodData update helpers
1193
1194 const TypeFunc* OptoRuntime::profile_receiver_type_Type() {
1195 // create input type (domain)
1196 const Type **fields = TypeTuple::fields(2);
1197 fields[TypeFunc::Parms+0] = TypeAryPtr::NOTNULL; // methodData pointer
1198 fields[TypeFunc::Parms+1] = TypeInstPtr::BOTTOM; // receiver oop
1199 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
1200
1201 // create result type
1202 fields = TypeTuple::fields(1);
1203 fields[TypeFunc::Parms+0] = NULL; // void
1204 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
1205 return TypeFunc::make(domain, domain, range);
1206 }
1207
1208 JRT_LEAF(void, OptoRuntime::profile_receiver_type_C(DataLayout* data, oopDesc* receiver))
1209 if (receiver == NULL) return;
1210 Klass* receiver_klass = receiver->klass();
1211
1212 intptr_t* mdp = ((intptr_t*)(data)) + DataLayout::header_size_in_cells();
1213 int empty_row = -1; // free row, if any is encountered
1214
1215 // ReceiverTypeData* vc = new ReceiverTypeData(mdp);
1216 for (uint row = 0; row < ReceiverTypeData::row_limit(); row++) {
1217 // if (vc->receiver(row) == receiver_klass)
1218 int receiver_off = ReceiverTypeData::receiver_cell_index(row);
1219 intptr_t row_recv = *(mdp + receiver_off);
1220 if (row_recv == (intptr_t) receiver_klass) {
1221 // vc->set_receiver_count(row, vc->receiver_count(row) + DataLayout::counter_increment);
1222 int count_off = ReceiverTypeData::receiver_count_cell_index(row);
1223 *(mdp + count_off) += DataLayout::counter_increment;
1224 return;
1225 } else if (row_recv == 0) {
1449 }
1450 #endif
1451
1452 thread->set_vm_result(exception);
1453 // Frame not compiled (handles deoptimization blob)
1454 return SharedRuntime::raw_exception_handler_for_return_address(thread, ret_pc);
1455 }
1456
1457
1458 const TypeFunc *OptoRuntime::rethrow_Type() {
1459 // create input type (domain)
1460 const Type **fields = TypeTuple::fields(1);
1461 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Exception oop
1462 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1,fields);
1463
1464 // create result type (range)
1465 fields = TypeTuple::fields(1);
1466 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Exception oop
1467 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
1468
1469 return TypeFunc::make(domain, domain, range);
1470 }
1471
1472
1473 void OptoRuntime::deoptimize_caller_frame(JavaThread *thread, bool doit) {
1474 // Deoptimize the caller before continuing, as the compiled
1475 // exception handler table may not be valid.
1476 if (!StressCompiledExceptionHandlers && doit) {
1477 deoptimize_caller_frame(thread);
1478 }
1479 }
1480
1481 void OptoRuntime::deoptimize_caller_frame(JavaThread *thread) {
1482 // Called from within the owner thread, so no need for safepoint
1483 RegisterMap reg_map(thread);
1484 frame stub_frame = thread->last_frame();
1485 assert(stub_frame.is_runtime_frame() || exception_blob()->contains(stub_frame.pc()), "sanity check");
1486 frame caller_frame = stub_frame.sender(®_map);
1487
1488 // Deoptimize the caller frame.
1489 Deoptimization::deoptimize_frame(thread, caller_frame.id());
1496 frame stub_frame = thread->last_frame();
1497 assert(stub_frame.is_runtime_frame() || exception_blob()->contains(stub_frame.pc()), "sanity check");
1498 frame caller_frame = stub_frame.sender(®_map);
1499 return caller_frame.is_deoptimized_frame();
1500 }
1501
1502
1503 const TypeFunc *OptoRuntime::register_finalizer_Type() {
1504 // create input type (domain)
1505 const Type **fields = TypeTuple::fields(1);
1506 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // oop; Receiver
1507 // // The JavaThread* is passed to each routine as the last argument
1508 // fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // JavaThread *; Executing thread
1509 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1,fields);
1510
1511 // create result type (range)
1512 fields = TypeTuple::fields(0);
1513
1514 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
1515
1516 return TypeFunc::make(domain, domain, range);
1517 }
1518
1519
1520 //-----------------------------------------------------------------------------
1521 // Dtrace support. entry and exit probes have the same signature
1522 const TypeFunc *OptoRuntime::dtrace_method_entry_exit_Type() {
1523 // create input type (domain)
1524 const Type **fields = TypeTuple::fields(2);
1525 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage
1526 fields[TypeFunc::Parms+1] = TypeMetadataPtr::BOTTOM; // Method*; Method we are entering
1527 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
1528
1529 // create result type (range)
1530 fields = TypeTuple::fields(0);
1531
1532 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
1533
1534 return TypeFunc::make(domain, domain, range);
1535 }
1536
1537 const TypeFunc *OptoRuntime::dtrace_object_alloc_Type() {
1538 // create input type (domain)
1539 const Type **fields = TypeTuple::fields(2);
1540 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage
1541 fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // oop; newly allocated object
1542
1543 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
1544
1545 // create result type (range)
1546 fields = TypeTuple::fields(0);
1547
1548 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
1549
1550 return TypeFunc::make(domain, domain, range);
1551 }
1552
1553
1554 JRT_ENTRY_NO_ASYNC(void, OptoRuntime::register_finalizer(oopDesc* obj, JavaThread* thread))
1555 assert(obj->is_oop(), "must be a valid oop");
1556 assert(obj->klass()->has_finalizer(), "shouldn't be here otherwise");
1557 InstanceKlass::register_finalizer(instanceOop(obj), CHECK);
1558 JRT_END
1559
1560 //-----------------------------------------------------------------------------
1561
1562 NamedCounter * volatile OptoRuntime::_named_counters = NULL;
1563
1564 //
1565 // dump the collected NamedCounters.
1566 //
1567 void OptoRuntime::print_named_counters() {
1568 int total_lock_count = 0;
1569 int eliminated_lock_count = 0;
1570
|