src/share/vm/interpreter/bytecodeInterpreter.cpp

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


1583           ARRAY_INTRO(-2);                                                            \
1584           extra;                                                                      \
1585           SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), \
1586                            -2);                                                       \
1587           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);                                      \
1588       }
1589 
1590       /* 64-bit loads */
1591 #define ARRAY_LOADTO64(T,T2, stackRes, extra)                                              \
1592       {                                                                                    \
1593           ARRAY_INTRO(-2);                                                                 \
1594           SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), -1); \
1595           extra;                                                                           \
1596           UPDATE_PC_AND_CONTINUE(1);                                            \
1597       }
1598 
1599       CASE(_iaload):
1600           ARRAY_LOADTO32(T_INT, jint,   "%d",   STACK_INT, 0);
1601       CASE(_faload):
1602           ARRAY_LOADTO32(T_FLOAT, jfloat, "%f",   STACK_FLOAT, 0);
1603       CASE(_aaload):








1604           ARRAY_LOADTO32(T_OBJECT, oop,   INTPTR_FORMAT, STACK_OBJECT, 0);


1605       CASE(_baload):
1606           ARRAY_LOADTO32(T_BYTE, jbyte,  "%d",   STACK_INT, 0);
1607       CASE(_caload):
1608           ARRAY_LOADTO32(T_CHAR,  jchar, "%d",   STACK_INT, 0);
1609       CASE(_saload):
1610           ARRAY_LOADTO32(T_SHORT, jshort, "%d",   STACK_INT, 0);
1611       CASE(_laload):
1612           ARRAY_LOADTO64(T_LONG, jlong, STACK_LONG, 0);
1613       CASE(_daload):
1614           ARRAY_LOADTO64(T_DOUBLE, jdouble, STACK_DOUBLE, 0);
1615 
1616       /* 32-bit stores. These handle conversion to < 32-bit types */
1617 #define ARRAY_STOREFROM32(T, T2, format, stackSrc, extra)                            \
1618       {                                                                              \
1619           ARRAY_INTRO(-3);                                                           \
1620           extra;                                                                     \
1621           *(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)) = stackSrc( -1); \
1622           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -3);                                     \
1623       }
1624 




1583           ARRAY_INTRO(-2);                                                            \
1584           extra;                                                                      \
1585           SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), \
1586                            -2);                                                       \
1587           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);                                      \
1588       }
1589 
1590       /* 64-bit loads */
1591 #define ARRAY_LOADTO64(T,T2, stackRes, extra)                                              \
1592       {                                                                                    \
1593           ARRAY_INTRO(-2);                                                                 \
1594           SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), -1); \
1595           extra;                                                                           \
1596           UPDATE_PC_AND_CONTINUE(1);                                            \
1597       }
1598 
1599       CASE(_iaload):
1600           ARRAY_LOADTO32(T_INT, jint,   "%d",   STACK_INT, 0);
1601       CASE(_faload):
1602           ARRAY_LOADTO32(T_FLOAT, jfloat, "%f",   STACK_FLOAT, 0);
1603       CASE(_aaload): {
1604         // Decode compressed oop.
1605         if (UseCompressedOops) {
1606           ARRAY_INTRO(-2);
1607           address oopAdr = ((address) arrObj->base(T_OBJECT)) + index * sizeof(narrowOop);
1608           oop decodedOop =  oopDesc::decode_heap_oop(*(narrowOop*)(oopAdr));
1609           SET_STACK_OBJECT(decodedOop, -2);
1610           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
1611         } else {
1612           ARRAY_LOADTO32(T_OBJECT, oop, INTPTR_FORMAT, STACK_OBJECT, 0);
1613         }
1614       }
1615       CASE(_baload):
1616           ARRAY_LOADTO32(T_BYTE, jbyte,  "%d",   STACK_INT, 0);
1617       CASE(_caload):
1618           ARRAY_LOADTO32(T_CHAR,  jchar, "%d",   STACK_INT, 0);
1619       CASE(_saload):
1620           ARRAY_LOADTO32(T_SHORT, jshort, "%d",   STACK_INT, 0);
1621       CASE(_laload):
1622           ARRAY_LOADTO64(T_LONG, jlong, STACK_LONG, 0);
1623       CASE(_daload):
1624           ARRAY_LOADTO64(T_DOUBLE, jdouble, STACK_DOUBLE, 0);
1625 
1626       /* 32-bit stores. These handle conversion to < 32-bit types */
1627 #define ARRAY_STOREFROM32(T, T2, format, stackSrc, extra)                            \
1628       {                                                                              \
1629           ARRAY_INTRO(-3);                                                           \
1630           extra;                                                                     \
1631           *(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)) = stackSrc( -1); \
1632           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -3);                                     \
1633       }
1634