Return to op_mem.h CVS log

Up to [Qemu by Fabrice Bellard] / qemu / target-sparc

Annotation of qemu/target-sparc/op_mem.h, revision 1.1.1.2

1.1.1.2 ! root        1: #ifdef TARGET_ABI32
        !             2: #define ADDR(x) ((x) & 0xffffffff)
        !             3: #else
        !             4: #define ADDR(x) (x)
        !             5: #endif
        !             6: 
1.1       root        7: /***                             Integer load                              ***/
                      8: #define SPARC_LD_OP(name, qp)                                                 \
                      9: void OPPROTO glue(glue(op_, name), MEMSUFFIX)(void)                           \
                     10: {                                                                             \
1.1.1.2 ! root       11:     T1 = (target_ulong)glue(qp, MEMSUFFIX)(ADDR(T0));                         \
1.1       root       12: }
                     13: 
1.1.1.2 ! root       14: #define SPARC_LD_OP_S(name, qp)                                         \
        !            15:     void OPPROTO glue(glue(op_, name), MEMSUFFIX)(void)                 \
        !            16:     {                                                                   \
        !            17:         T1 = (target_long)glue(qp, MEMSUFFIX)(ADDR(T0));                      \
1.1       root       18:     }
                     19: 
                     20: #define SPARC_ST_OP(name, op)                                                 \
                     21: void OPPROTO glue(glue(op_, name), MEMSUFFIX)(void)                           \
                     22: {                                                                             \
1.1.1.2 ! root       23:     glue(op, MEMSUFFIX)(ADDR(T0), T1);                                      \
1.1       root       24: }
                     25: 
                     26: SPARC_LD_OP(ld, ldl);
                     27: SPARC_LD_OP(ldub, ldub);
                     28: SPARC_LD_OP(lduh, lduw);
                     29: SPARC_LD_OP_S(ldsb, ldsb);
                     30: SPARC_LD_OP_S(ldsh, ldsw);
                     31: 
                     32: /***                              Integer store                            ***/
                     33: SPARC_ST_OP(st, stl);
                     34: SPARC_ST_OP(stb, stb);
                     35: SPARC_ST_OP(sth, stw);
                     36: 
                     37: void OPPROTO glue(op_std, MEMSUFFIX)(void)
                     38: {
1.1.1.2 ! root       39:     uint64_t tmp = ((uint64_t)T1 << 32) | (uint64_t)(T2 & 0xffffffff);
        !            40: 
        !            41:     glue(stq, MEMSUFFIX)(ADDR(T0), tmp);
1.1       root       42: }
                     43: 
                     44: void OPPROTO glue(op_ldstub, MEMSUFFIX)(void)
                     45: {
1.1.1.2 ! root       46:     T1 = glue(ldub, MEMSUFFIX)(ADDR(T0));
        !            47:     glue(stb, MEMSUFFIX)(ADDR(T0), 0xff);     /* XXX: Should be Atomically */
1.1       root       48: }
                     49: 
                     50: void OPPROTO glue(op_swap, MEMSUFFIX)(void)
                     51: {
1.1.1.2 ! root       52:     target_ulong tmp = glue(ldl, MEMSUFFIX)(ADDR(T0));
        !            53:     glue(stl, MEMSUFFIX)(ADDR(T0), T1);       /* XXX: Should be Atomically */
1.1       root       54:     T1 = tmp;
                     55: }
                     56: 
                     57: void OPPROTO glue(op_ldd, MEMSUFFIX)(void)
                     58: {
1.1.1.2 ! root       59:     uint64_t tmp;
        !            60: 
        !            61:     tmp = glue(ldq, MEMSUFFIX)(ADDR(T0));
        !            62:     T1 = tmp >> 32;
        !            63:     T0 = tmp & 0xffffffff;
1.1       root       64: }
                     65: 
                     66: /***                         Floating-point store                          ***/
                     67: void OPPROTO glue(op_stf, MEMSUFFIX) (void)
                     68: {
1.1.1.2 ! root       69:     glue(stfl, MEMSUFFIX)(ADDR(T0), FT0);
1.1       root       70: }
                     71: 
                     72: void OPPROTO glue(op_stdf, MEMSUFFIX) (void)
                     73: {
1.1.1.2 ! root       74:     glue(stfq, MEMSUFFIX)(ADDR(T0), DT0);
1.1       root       75: }
                     76: 
                     77: /***                         Floating-point load                           ***/
                     78: void OPPROTO glue(op_ldf, MEMSUFFIX) (void)
                     79: {
1.1.1.2 ! root       80:     FT0 = glue(ldfl, MEMSUFFIX)(ADDR(T0));
1.1       root       81: }
                     82: 
                     83: void OPPROTO glue(op_lddf, MEMSUFFIX) (void)
                     84: {
1.1.1.2 ! root       85:     DT0 = glue(ldfq, MEMSUFFIX)(ADDR(T0));
1.1       root       86: }
                     87: 
1.1.1.2 ! root       88: #if defined(CONFIG_USER_ONLY)
        !            89: void OPPROTO glue(op_ldqf, MEMSUFFIX) (void)
        !            90: {
        !            91:     // XXX add 128 bit load
        !            92:     CPU_QuadU u;
        !            93: 
        !            94:     u.ll.upper = glue(ldq, MEMSUFFIX)(ADDR(T0));
        !            95:     u.ll.lower = glue(ldq, MEMSUFFIX)(ADDR(T0 + 8));
        !            96:     QT0 = u.q;
1.1       root       97: }
                     98: 
1.1.1.2 ! root       99: void OPPROTO glue(op_stqf, MEMSUFFIX) (void)
1.1       root      100: {
1.1.1.2 ! root      101:     // XXX add 128 bit store
        !           102:     CPU_QuadU u;
1.1       root      103: 
1.1.1.2 ! root      104:     u.q = QT0;
        !           105:     glue(stq, MEMSUFFIX)(ADDR(T0), u.ll.upper);
        !           106:     glue(stq, MEMSUFFIX)(ADDR(T0 + 8), u.ll.lower);
        !           107: }
        !           108: #endif
        !           109: 
        !           110: #ifdef TARGET_SPARC64
        !           111: void OPPROTO glue(op_lduw, MEMSUFFIX)(void)
        !           112: {
        !           113:     T1 = (uint64_t)(glue(ldl, MEMSUFFIX)(ADDR(T0)) & 0xffffffff);
1.1       root      114: }
                    115: 
                    116: void OPPROTO glue(op_ldsw, MEMSUFFIX)(void)
                    117: {
1.1.1.2 ! root      118:     T1 = (int64_t)(glue(ldl, MEMSUFFIX)(ADDR(T0)) & 0xffffffff);
1.1       root      119: }
                    120: 
                    121: SPARC_LD_OP(ldx, ldq);
                    122: SPARC_ST_OP(stx, stq);
                    123: #endif
                    124: #undef MEMSUFFIX

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.