809 // Repack the double/long as two jints.
810 // The convention the interpreter uses is that the second local
811 // holds the first raw word of the native double representation.
812 // This is actually reasonable, since locals and stack arrays
813 // grow downwards in all implementations.
814 // (If, on some machine, the interpreter's Java locals or stack
815 // were to grow upwards, the embedded doubles would be word-swapped.)
816 array->append(new_loc_value( C->regalloc(), OptoReg::add(regnum,1), Location::normal ));
817 array->append(new_loc_value( C->regalloc(), regnum , Location::normal ));
818 }
819 #endif //_LP64
820 else if( (t->base() == Type::FloatBot || t->base() == Type::FloatCon) &&
821 OptoReg::is_reg(regnum) ) {
822 array->append(new_loc_value( C->regalloc(), regnum, Matcher::float_in_double()
823 ? Location::float_in_dbl : Location::normal ));
824 } else if( t->base() == Type::Int && OptoReg::is_reg(regnum) ) {
825 array->append(new_loc_value( C->regalloc(), regnum, Matcher::int_in_long
826 ? Location::int_in_long : Location::normal ));
827 } else if( t->base() == Type::NarrowOop ) {
828 array->append(new_loc_value( C->regalloc(), regnum, Location::narrowoop ));
829 } else {
830 array->append(new_loc_value( C->regalloc(), regnum, C->regalloc()->is_oop(local) ? Location::oop : Location::normal ));
831 }
832 return;
833 }
834
835 // No register. It must be constant data.
836 switch (t->base()) {
837 case Type::Half: // Second half of a double
838 ShouldNotReachHere(); // Caller should skip 2nd halves
839 break;
840 case Type::AnyPtr:
841 array->append(new ConstantOopWriteValue(NULL));
842 break;
843 case Type::AryPtr:
844 case Type::InstPtr: // fall through
845 array->append(new ConstantOopWriteValue(t->isa_oopptr()->const_oop()->constant_encoding()));
846 break;
847 case Type::NarrowOop:
848 if (t == TypeNarrowOop::NULL_PTR) {
|
809 // Repack the double/long as two jints.
810 // The convention the interpreter uses is that the second local
811 // holds the first raw word of the native double representation.
812 // This is actually reasonable, since locals and stack arrays
813 // grow downwards in all implementations.
814 // (If, on some machine, the interpreter's Java locals or stack
815 // were to grow upwards, the embedded doubles would be word-swapped.)
816 array->append(new_loc_value( C->regalloc(), OptoReg::add(regnum,1), Location::normal ));
817 array->append(new_loc_value( C->regalloc(), regnum , Location::normal ));
818 }
819 #endif //_LP64
820 else if( (t->base() == Type::FloatBot || t->base() == Type::FloatCon) &&
821 OptoReg::is_reg(regnum) ) {
822 array->append(new_loc_value( C->regalloc(), regnum, Matcher::float_in_double()
823 ? Location::float_in_dbl : Location::normal ));
824 } else if( t->base() == Type::Int && OptoReg::is_reg(regnum) ) {
825 array->append(new_loc_value( C->regalloc(), regnum, Matcher::int_in_long
826 ? Location::int_in_long : Location::normal ));
827 } else if( t->base() == Type::NarrowOop ) {
828 array->append(new_loc_value( C->regalloc(), regnum, Location::narrowoop ));
829 } else if ( t->base() == Type::VectorS || t->base() == Type::VectorD ||
830 t->base() == Type::VectorX || t->base() == Type::VectorY ||
831 t->base() == Type::VectorZ) {
832 array->append(new_loc_value( C->regalloc(), regnum, Location::vector ));
833 } else {
834 array->append(new_loc_value( C->regalloc(), regnum, C->regalloc()->is_oop(local) ? Location::oop : Location::normal ));
835 }
836 return;
837 }
838
839 // No register. It must be constant data.
840 switch (t->base()) {
841 case Type::Half: // Second half of a double
842 ShouldNotReachHere(); // Caller should skip 2nd halves
843 break;
844 case Type::AnyPtr:
845 array->append(new ConstantOopWriteValue(NULL));
846 break;
847 case Type::AryPtr:
848 case Type::InstPtr: // fall through
849 array->append(new ConstantOopWriteValue(t->isa_oopptr()->const_oop()->constant_encoding()));
850 break;
851 case Type::NarrowOop:
852 if (t == TypeNarrowOop::NULL_PTR) {
|