Return to compiler.h CVS log

Up to [UNIX Amiga Emulator] / uae / src / include

Annotation of uae/src/include/compiler.h, revision 1.1.1.2

1.1       root        1:  /* 
                      2:   * UAE - The Un*x Amiga Emulator
                      3:   * 
                      4:   * m68k -> i386 compiler
                      5:   *
                      6:   * (c) 1995 Bernd Schmidt
                      7:   */
                      8: 
                      9: typedef CPTR (*code_execfunc)(void);
                     10: 
                     11: struct code_page {
                     12:     struct code_page *next;
                     13:     ULONG allocmask;
                     14: };
                     15: 
                     16: struct hash_block {
                     17:     struct hash_block *lru_next, *lru_prev;
                     18:     struct hash_entry *he_first;
                     19: 
                     20:     struct code_page *cpage;
                     21:     int alloclen;
                     22:     ULONG page_allocmask;
                     23:     char *compile_start;
                     24:     
                     25:     int nrefs;
                     26: 
                     27:     int translated:1;
                     28:     int untranslatable:1;
                     29:     int allocfailed:1;
                     30: };
                     31: 
                     32: struct hash_entry {
1.1.1.2 ! root       33:     code_execfunc execute; /* For the sake of the stubs in X86.S */
1.1       root       34:     struct hash_entry *next,*prev;
                     35:     struct hash_entry *next_same_block, *lru_next, *lru_prev;
                     36:     struct hash_block *block;
                     37:     
                     38:     CPTR addr;
                     39:     ULONG matchword;
                     40:     int ncalls:8;
                     41:     int locked:1;
                     42:     int cacheflush:1;
                     43: };
                     44: 
                     45: extern int nr_bbs_start;
                     46: extern UBYTE nr_bbs_to_run;
                     47: extern code_execfunc exec_me;
                     48: 
                     49: #ifdef USE_COMPILER
                     50: static __inline__ void run_compiled_code(void)
                     51: {
1.1.1.2 ! root       52:     if (regs.spcflags == SPCFLAG_EXEC && may_run_compiled) {
1.1       root       53:        while (regs.spcflags == SPCFLAG_EXEC) {
                     54:            CPTR newpc;
                     55:            regs.spcflags = 0;
                     56:            /*          newpc = (*exec_me)();*/
                     57:            __asm__ __volatile__ ("pushl %%ebp; call *%1; popl %%ebp" : "=a" (newpc) : "r" (exec_me) :
                     58:                                  "%eax", "%edx", "%ecx", "%ebx",
                     59:                                  "%edi", "%esi", "memory", "cc");
                     60:            if (nr_bbs_to_run == 0) {
                     61:                struct hash_entry *h = (struct hash_entry *)newpc;
                     62:                regs.spcflags = SPCFLAG_EXEC;
                     63:                exec_me = h->execute;
                     64:                regs.pc = h->addr;
                     65:                regs.pc_p = regs.pc_oldp = get_real_address(h->addr);
                     66:                nr_bbs_to_run = nr_bbs_start;
                     67:            } else
                     68:                m68k_setpc_fast(newpc);
                     69:            do_cycles();
                     70:        }
                     71:     } else 
                     72:        regs.spcflags &= ~SPCFLAG_EXEC;
                     73: }
                     74: 
                     75: extern void compiler_init(void);
                     76: extern void possible_loadseg(void);
                     77: 
1.1.1.2 ! root       78: extern void m68k_do_rts(void);
        !            79: extern void m68k_do_bsr(LONG);
        !            80: extern void m68k_do_jsr(CPTR);
        !            81: extern void compiler_flush_jsr_stack(void);
        !            82: 
1.1       root       83: #else
                     84: 
1.1.1.2 ! root       85: #define run_compiled_code() do { } while (0)
        !            86: #define compiler_init() do { } while (0)
        !            87: #define possible_loadseg() do { } while (0)
        !            88: #define compiler_flush_jsr_stack() do { } while (0)
        !            89: 
        !            90: static __inline__ void m68k_do_rts(void)
1.1       root       91: {
1.1.1.2 ! root       92:     m68k_setpc(get_long(m68k_areg(regs, 7)));
        !            93:     m68k_areg(regs, 7) += 4;
1.1       root       94: }
                     95: 
1.1.1.2 ! root       96: static __inline__ void m68k_do_bsr(LONG offset)
1.1       root       97: {
1.1.1.2 ! root       98: #if defined(USE_POINTER)
        !            99:     char *oldpcp = (char *)regs.pc_p;    
        !           100: #endif
        !           101:     ULONG oldpc = m68k_getpc();
        !           102:     m68k_areg(regs, 7) -= 4;
        !           103:     put_long(m68k_areg(regs, 7), oldpc);
        !           104:     
        !           105: #if defined(USE_POINTER)
        !           106:     regs.pc_p = (UBYTE *)(oldpcp + (LONG)offset);
        !           107: #else
        !           108:     regs.pc = oldpc + (LONG)offset;
        !           109: #endif
1.1       root      110: }
                    111: 
1.1.1.2 ! root      112: static __inline__ void m68k_do_jsr(CPTR dest)
1.1       root      113: {
1.1.1.2 ! root      114:     ULONG oldpc = m68k_getpc();
        !           115:     m68k_areg(regs, 7) -= 4;
        !           116:     put_long(m68k_areg(regs, 7), oldpc);
        !           117:     m68k_setpc(dest);
1.1       root      118: }
                    119: 
                    120: #endif

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