Return to op-hacks.h CVS log

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

Annotation of qemu/target-m68k/op-hacks.h, revision 1.1

1.1     ! root        1: /* Various hacks to make code written for a dynamic code generator work
        !             2:    with regular QEMU.  */
        !             3: 
        !             4: static int free_qreg;
        !             5: 
        !             6: #define QMODE_I32 1
        !             7: #define QMODE_F32 1
        !             8: #define QMODE_F64 2
        !             9: 
        !            10: static inline int gen_new_qreg(int mode)
        !            11: {
        !            12:     int qreg;
        !            13: 
        !            14:     qreg = free_qreg;
        !            15:     free_qreg += mode;
        !            16:     if (free_qreg > MAX_QREGS) {
        !            17:         fprintf(stderr, "qreg overflow\n");
        !            18:         abort();
        !            19:     }
        !            20:     return qreg + TARGET_NUM_QREGS;
        !            21: }
        !            22: 
        !            23: static inline int gen_im32(uint32_t i)
        !            24: {
        !            25:     int qreg = gen_new_qreg(QMODE_I32);
        !            26:     gen_op_mov32_im(qreg, i);
        !            27:     return qreg;
        !            28: }
        !            29: 
        !            30: static inline void gen_op_ldf32(int dest, int addr)
        !            31: {
        !            32:     gen_op_ld32(dest, addr);
        !            33: }
        !            34: 
        !            35: static inline void gen_op_stf32(int addr, int dest)
        !            36: {
        !            37:     gen_op_st32(addr, dest);
        !            38: }
        !            39: 
        !            40: static inline void gen_op_pack_32_f32(int dest, int src)
        !            41: {
        !            42:     gen_op_mov32(dest, src);
        !            43: }
        !            44: 
        !            45: static inline void gen_op_pack_f32_32(int dest, int src)
        !            46: {
        !            47:     gen_op_mov32(dest, src);
        !            48: }
        !            49: 
        !            50: static inline void gen_op_flags_set(void)
        !            51: {
        !            52:     /* Dummy op.  */
        !            53: }
        !            54: 
        !            55: static inline void gen_op_shl_im_cc(int val, int shift)
        !            56: {
        !            57:     gen_op_shl_cc(val, gen_im32(shift));
        !            58: }
        !            59: 
        !            60: static inline void gen_op_shr_im_cc(int val, int shift)
        !            61: {
        !            62:     gen_op_shr_cc(val, gen_im32(shift));
        !            63: }
        !            64: 
        !            65: static inline void gen_op_sar_im_cc(int val, int shift)
        !            66: {
        !            67:     gen_op_sar_cc(val, gen_im32(shift));
        !            68: }
        !            69: 
        !            70: #ifdef USE_DIRECT_JUMP
        !            71: #define TBPARAM(x)
        !            72: #else
        !            73: #define TBPARAM(x) (long)(x)
        !            74: #endif
        !            75: 
        !            76: static inline void gen_op_goto_tb(int dummy, int n, long tb)
        !            77: {
        !            78:     if (n == 0) {
        !            79:         gen_op_goto_tb0(TBPARAM(tb));
        !            80:     } else {
        !            81:         gen_op_goto_tb1(TBPARAM(tb));
        !            82:     }
        !            83: }

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