854 src_pos.load_item_force (FrameMap::R15_opr);
855 dst.load_item_force (FrameMap::R17_oop_opr);
856 dst_pos.load_item_force (FrameMap::R18_opr);
857 length.load_item_force (FrameMap::R19_opr);
858 LIR_Opr tmp = FrameMap::R20_opr;
859
860 int flags;
861 ciArrayKlass* expected_type;
862 arraycopy_helper(x, &flags, &expected_type);
863
864 __ arraycopy(src.result(), src_pos.result(), dst.result(), dst_pos.result(),
865 length.result(), tmp,
866 expected_type, flags, info);
867 set_no_result(x);
868 }
869
870
871 // _i2l, _i2f, _i2d, _l2i, _l2f, _l2d, _f2i, _f2l, _f2d, _d2i, _d2l, _d2f
872 // _i2b, _i2c, _i2s
873 void LIRGenerator::do_Convert(Convert* x) {
874 switch (x->op()) {
875
876 // int -> float: force spill
877 case Bytecodes::_l2f: {
878 if (!VM_Version::has_fcfids()) { // fcfids is >= Power7 only
879 // fcfid+frsp needs fixup code to avoid rounding incompatibility.
880 address entry = CAST_FROM_FN_PTR(address, SharedRuntime::l2f);
881 LIR_Opr result = call_runtime(x->value(), entry, x->type(), NULL);
882 set_result(x, result);
883 break;
884 } // else fallthru
885 }
886 case Bytecodes::_l2d: {
887 LIRItem value(x->value(), this);
888 LIR_Opr reg = rlock_result(x);
889 value.load_item();
890 LIR_Opr tmp = force_to_spill(value.result(), T_DOUBLE);
891 __ convert(x->op(), tmp, reg);
892 break;
893 }
894 case Bytecodes::_i2f:
895 case Bytecodes::_i2d: {
896 LIRItem value(x->value(), this);
897 LIR_Opr reg = rlock_result(x);
898 value.load_item();
899 // Convert i2l first.
900 LIR_Opr tmp1 = new_register(T_LONG);
901 __ convert(Bytecodes::_i2l, value.result(), tmp1);
902 LIR_Opr tmp2 = force_to_spill(tmp1, T_DOUBLE);
903 __ convert(x->op(), tmp2, reg);
904 break;
905 }
906
907 // float -> int: result will be stored
908 case Bytecodes::_f2l:
909 case Bytecodes::_d2l: {
910 LIRItem value(x->value(), this);
911 LIR_Opr reg = rlock_result(x);
912 value.set_destroys_register(); // USE_KILL
913 value.load_item();
914 set_vreg_flag(reg, must_start_in_memory);
915 __ convert(x->op(), value.result(), reg);
916 break;
917 }
918 case Bytecodes::_f2i:
919 case Bytecodes::_d2i: {
920 LIRItem value(x->value(), this);
921 LIR_Opr reg = rlock_result(x);
922 value.set_destroys_register(); // USE_KILL
923 value.load_item();
924 // Convert l2i afterwards.
925 LIR_Opr tmp1 = new_register(T_LONG);
926 set_vreg_flag(tmp1, must_start_in_memory);
927 __ convert(x->op(), value.result(), tmp1);
928 __ convert(Bytecodes::_l2i, tmp1, reg);
929 break;
930 }
931
932 // Within same category: just register conversions.
933 case Bytecodes::_i2b:
934 case Bytecodes::_i2c:
935 case Bytecodes::_i2s:
936 case Bytecodes::_i2l:
937 case Bytecodes::_l2i:
938 case Bytecodes::_f2d:
939 case Bytecodes::_d2f: {
940 LIRItem value(x->value(), this);
941 LIR_Opr reg = rlock_result(x);
942 value.load_item();
943 __ convert(x->op(), value.result(), reg);
944 break;
945 }
946
947 default: ShouldNotReachHere();
948 }
949 }
950
951
952 void LIRGenerator::do_NewInstance(NewInstance* x) {
953 // This instruction can be deoptimized in the slow path.
954 const LIR_Opr reg = result_register_for(x->type());
955 #ifndef PRODUCT
956 if (PrintNotLoaded && !x->klass()->is_loaded()) {
957 tty->print_cr(" ###class not loaded at new bci %d", x->printable_bci());
958 }
959 #endif
960 CodeEmitInfo* info = state_for(x, x->state());
961 LIR_Opr klass_reg = FrameMap::R4_metadata_opr; // Used by slow path (NewInstanceStub).
962 LIR_Opr tmp1 = FrameMap::R5_oop_opr;
963 LIR_Opr tmp2 = FrameMap::R6_oop_opr;
964 LIR_Opr tmp3 = FrameMap::R7_oop_opr;
965 LIR_Opr tmp4 = FrameMap::R8_oop_opr;
966 new_instance(reg, x->klass(), x->is_unresolved(), tmp1, tmp2, tmp3, tmp4, klass_reg, info);
967
968 // Must prevent reordering of stores for object initialization
|
854 src_pos.load_item_force (FrameMap::R15_opr);
855 dst.load_item_force (FrameMap::R17_oop_opr);
856 dst_pos.load_item_force (FrameMap::R18_opr);
857 length.load_item_force (FrameMap::R19_opr);
858 LIR_Opr tmp = FrameMap::R20_opr;
859
860 int flags;
861 ciArrayKlass* expected_type;
862 arraycopy_helper(x, &flags, &expected_type);
863
864 __ arraycopy(src.result(), src_pos.result(), dst.result(), dst_pos.result(),
865 length.result(), tmp,
866 expected_type, flags, info);
867 set_no_result(x);
868 }
869
870
871 // _i2l, _i2f, _i2d, _l2i, _l2f, _l2d, _f2i, _f2l, _f2d, _d2i, _d2l, _d2f
872 // _i2b, _i2c, _i2s
873 void LIRGenerator::do_Convert(Convert* x) {
874 if (!VM_Version::has_mtfprd()) {
875 switch (x->op()) {
876
877 // int -> float: force spill
878 case Bytecodes::_l2f: {
879 if (!VM_Version::has_fcfids()) { // fcfids is >= Power7 only
880 // fcfid+frsp needs fixup code to avoid rounding incompatibility.
881 address entry = CAST_FROM_FN_PTR(address, SharedRuntime::l2f);
882 LIR_Opr result = call_runtime(x->value(), entry, x->type(), NULL);
883 set_result(x, result);
884 return;
885 } // else fallthru
886 }
887 case Bytecodes::_l2d: {
888 LIRItem value(x->value(), this);
889 LIR_Opr reg = rlock_result(x);
890 value.load_item();
891 LIR_Opr tmp = force_to_spill(value.result(), T_DOUBLE);
892 __ convert(x->op(), tmp, reg);
893 return;
894 }
895 case Bytecodes::_i2f:
896 case Bytecodes::_i2d: {
897 LIRItem value(x->value(), this);
898 LIR_Opr reg = rlock_result(x);
899 value.load_item();
900 // Convert i2l first.
901 LIR_Opr tmp1 = new_register(T_LONG);
902 __ convert(Bytecodes::_i2l, value.result(), tmp1);
903 LIR_Opr tmp2 = force_to_spill(tmp1, T_DOUBLE);
904 __ convert(x->op(), tmp2, reg);
905 return;
906 }
907
908 // float -> int: result will be stored
909 case Bytecodes::_f2l:
910 case Bytecodes::_d2l: {
911 LIRItem value(x->value(), this);
912 LIR_Opr reg = rlock_result(x);
913 value.set_destroys_register(); // USE_KILL
914 value.load_item();
915 set_vreg_flag(reg, must_start_in_memory);
916 __ convert(x->op(), value.result(), reg);
917 return;
918 }
919 case Bytecodes::_f2i:
920 case Bytecodes::_d2i: {
921 LIRItem value(x->value(), this);
922 LIR_Opr reg = rlock_result(x);
923 value.set_destroys_register(); // USE_KILL
924 value.load_item();
925 // Convert l2i afterwards.
926 LIR_Opr tmp1 = new_register(T_LONG);
927 set_vreg_flag(tmp1, must_start_in_memory);
928 __ convert(x->op(), value.result(), tmp1);
929 __ convert(Bytecodes::_l2i, tmp1, reg);
930 return;
931 }
932
933 // Within same category: just register conversions.
934 case Bytecodes::_i2b:
935 case Bytecodes::_i2c:
936 case Bytecodes::_i2s:
937 case Bytecodes::_i2l:
938 case Bytecodes::_l2i:
939 case Bytecodes::_f2d:
940 case Bytecodes::_d2f:
941 break;
942
943 default: ShouldNotReachHere();
944 }
945 }
946
947 // Register conversion.
948 LIRItem value(x->value(), this);
949 LIR_Opr reg = rlock_result(x);
950 value.load_item();
951 switch (x->op()) {
952 case Bytecodes::_f2l:
953 case Bytecodes::_d2l:
954 case Bytecodes::_f2i:
955 case Bytecodes::_d2i: value.set_destroys_register(); break; // USE_KILL
956 default: break;
957 }
958 __ convert(x->op(), value.result(), reg);
959 }
960
961
962 void LIRGenerator::do_NewInstance(NewInstance* x) {
963 // This instruction can be deoptimized in the slow path.
964 const LIR_Opr reg = result_register_for(x->type());
965 #ifndef PRODUCT
966 if (PrintNotLoaded && !x->klass()->is_loaded()) {
967 tty->print_cr(" ###class not loaded at new bci %d", x->printable_bci());
968 }
969 #endif
970 CodeEmitInfo* info = state_for(x, x->state());
971 LIR_Opr klass_reg = FrameMap::R4_metadata_opr; // Used by slow path (NewInstanceStub).
972 LIR_Opr tmp1 = FrameMap::R5_oop_opr;
973 LIR_Opr tmp2 = FrameMap::R6_oop_opr;
974 LIR_Opr tmp3 = FrameMap::R7_oop_opr;
975 LIR_Opr tmp4 = FrameMap::R8_oop_opr;
976 new_instance(reg, x->klass(), x->is_unresolved(), tmp1, tmp2, tmp3, tmp4, klass_reg, info);
977
978 // Must prevent reordering of stores for object initialization
|