src/share/vm/interpreter/bytecodeInterpreter.cpp

Print this page
rev 4869 : 8019518: PPC64 (part 103): cppInterpreter: implement support for compressed Oops


1636           ARRAY_INTRO(-2);                                                            \
1637           extra;                                                                      \
1638           SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), \
1639                            -2);                                                       \
1640           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);                                      \
1641       }
1642 
1643       /* 64-bit loads */
1644 #define ARRAY_LOADTO64(T,T2, stackRes, extra)                                              \
1645       {                                                                                    \
1646           ARRAY_INTRO(-2);                                                                 \
1647           SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), -1); \
1648           extra;                                                                           \
1649           UPDATE_PC_AND_CONTINUE(1);                                            \
1650       }
1651 
1652       CASE(_iaload):
1653           ARRAY_LOADTO32(T_INT, jint,   "%d",   STACK_INT, 0);
1654       CASE(_faload):
1655           ARRAY_LOADTO32(T_FLOAT, jfloat, "%f",   STACK_FLOAT, 0);
1656       CASE(_aaload):
1657           ARRAY_LOADTO32(T_OBJECT, oop,   INTPTR_FORMAT, STACK_OBJECT, 0);



1658       CASE(_baload):
1659           ARRAY_LOADTO32(T_BYTE, jbyte,  "%d",   STACK_INT, 0);
1660       CASE(_caload):
1661           ARRAY_LOADTO32(T_CHAR,  jchar, "%d",   STACK_INT, 0);
1662       CASE(_saload):
1663           ARRAY_LOADTO32(T_SHORT, jshort, "%d",   STACK_INT, 0);
1664       CASE(_laload):
1665           ARRAY_LOADTO64(T_LONG, jlong, STACK_LONG, 0);
1666       CASE(_daload):
1667           ARRAY_LOADTO64(T_DOUBLE, jdouble, STACK_DOUBLE, 0);
1668 
1669       /* 32-bit stores. These handle conversion to < 32-bit types */
1670 #define ARRAY_STOREFROM32(T, T2, format, stackSrc, extra)                            \
1671       {                                                                              \
1672           ARRAY_INTRO(-3);                                                           \
1673           extra;                                                                     \
1674           *(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)) = stackSrc( -1); \
1675           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -3);                                     \
1676       }
1677 




1636           ARRAY_INTRO(-2);                                                            \
1637           extra;                                                                      \
1638           SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), \
1639                            -2);                                                       \
1640           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);                                      \
1641       }
1642 
1643       /* 64-bit loads */
1644 #define ARRAY_LOADTO64(T,T2, stackRes, extra)                                              \
1645       {                                                                                    \
1646           ARRAY_INTRO(-2);                                                                 \
1647           SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), -1); \
1648           extra;                                                                           \
1649           UPDATE_PC_AND_CONTINUE(1);                                            \
1650       }
1651 
1652       CASE(_iaload):
1653           ARRAY_LOADTO32(T_INT, jint,   "%d",   STACK_INT, 0);
1654       CASE(_faload):
1655           ARRAY_LOADTO32(T_FLOAT, jfloat, "%f",   STACK_FLOAT, 0);
1656       CASE(_aaload): {
1657           ARRAY_INTRO(-2);
1658           SET_STACK_OBJECT(((objArrayOop) arrObj)->obj_at(index), -2);
1659           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
1660       }
1661       CASE(_baload):
1662           ARRAY_LOADTO32(T_BYTE, jbyte,  "%d",   STACK_INT, 0);
1663       CASE(_caload):
1664           ARRAY_LOADTO32(T_CHAR,  jchar, "%d",   STACK_INT, 0);
1665       CASE(_saload):
1666           ARRAY_LOADTO32(T_SHORT, jshort, "%d",   STACK_INT, 0);
1667       CASE(_laload):
1668           ARRAY_LOADTO64(T_LONG, jlong, STACK_LONG, 0);
1669       CASE(_daload):
1670           ARRAY_LOADTO64(T_DOUBLE, jdouble, STACK_DOUBLE, 0);
1671 
1672       /* 32-bit stores. These handle conversion to < 32-bit types */
1673 #define ARRAY_STOREFROM32(T, T2, format, stackSrc, extra)                            \
1674       {                                                                              \
1675           ARRAY_INTRO(-3);                                                           \
1676           extra;                                                                     \
1677           *(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)) = stackSrc( -1); \
1678           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -3);                                     \
1679       }
1680