ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/uae_cpu/readcpu.cpp
(Generate patch)

Comparing BasiliskII/src/uae_cpu/readcpu.cpp (file contents):
Revision 1.4 by gbeauche, 2001-08-19T16:21:01Z vs.
Revision 1.5 by gbeauche, 2002-09-01T15:17:13Z

# Line 139 | Line 139 | struct mnemolookup lookuptab[] = {
139      { i_CPUSHA, "CPUSHA" },
140      { i_MOVE16, "MOVE16" },
141  
142 +        { i_EMULOP_RETURN, "EMULOP_RETURN" },
143 +        { i_EMULOP, "EMULOP" },
144 +        
145      { i_MMUOP, "MMUOP" },
146      { i_ILLG, "" },
147   };
# Line 195 | Line 198 | static void build_insn (int insn)
198      int variants;
199      struct instr_def id;
200      const char *opcstr;
201 <    int i;
201 >    int i, n;
202  
203      int flaglive = 0, flagdead = 0;
204 +        int cflow = 0;
205  
206      id = defs68k[insn];
207  
208 +        // Control flow information
209 +        cflow = id.cflow;
210 +        
211 +        // Mask of flags set/used
212 +        unsigned char flags_set(0), flags_used(0);
213 +        
214 +        for (i = 0, n = 4; i < 5; i++, n--) {
215 +                switch (id.flaginfo[i].flagset) {
216 +                        case fa_unset: case fa_isjmp: break;
217 +                        default: flags_set |= (1 << n);
218 +                }
219 +                
220 +                switch (id.flaginfo[i].flaguse) {
221 +                        case fu_unused: case fu_isjmp: break;
222 +                        default: flags_used |= (1 << n);
223 +                }
224 +        }
225 +        
226      for (i = 0; i < 5; i++) {
227          switch (id.flaginfo[i].flagset){
228           case fa_unset: break;
207 –         case fa_isjmp: break;
229           case fa_zero: flagdead |= 1 << i; break;
230           case fa_one: flagdead |= 1 << i; break;
231           case fa_dontcare: flagdead |= 1 << i; break;
# Line 217 | Line 238 | static void build_insn (int insn)
238      for (i = 0; i < 5; i++) {
239          switch (id.flaginfo[i].flaguse) {
240           case fu_unused: break;
220 –         case fu_isjmp: flaglive |= 1 << i; break;
221 –         case fu_maybecc: flaglive |= 1 << i; break;
241           case fu_unknown: flaglive = -1; goto out2;
242           case fu_used: flaglive |= 1 << i; break;
243          }
# Line 273 | Line 292 | static void build_insn (int insn)
292              continue;
293          if (bitcnt[bitI] && (bitval[bitI] == 0x00 || bitval[bitI] == 0xff))
294              continue;
295 +        if (bitcnt[bitE] && (bitval[bitE] == 0x00))
296 +                continue;
297  
298          /* bitI and bitC get copied to biti and bitc */
299          if (bitcnt[bitI]) {
# Line 396 | Line 417 | static void build_insn (int insn)
417                      srcpos = bitpos[bitK];
418                  }
419                  break;
420 +                 case 'E': srcmode = immi; srcreg = bitval[bitE];
421 +                if (CPU_EMU_SIZE < 5) { // gb-- what is CPU_EMU_SIZE used for ??
422 +                        /* 1..255 */
423 +                        srcgather = 1;
424 +                        srctype = 6;
425 +                        srcpos = bitpos[bitE];
426 +                }
427 +                break;
428                   case 'p': srcmode = immi; srcreg = bitval[bitp];
429                  if (CPU_EMU_SIZE < 5) {
430                          /* 0..3 */
# Line 719 | Line 748 | static void build_insn (int insn)
748              table68k[opc].flaginfo[i].flaguse = id.flaginfo[i].flaguse;
749          }
750   #endif
751 +        
752 + #if 1
753 +        /* gb-- flagdead and flaglive would not have correct information */
754 +        table68k[opc].flagdead = flags_set;
755 +        table68k[opc].flaglive = flags_used;
756 + #else
757          table68k[opc].flagdead = flagdead;
758          table68k[opc].flaglive = flaglive;
759 + #endif
760 +        table68k[opc].cflow = cflow;
761          nomatch:
762          /* FOO! */;
763      }
# Line 739 | Line 776 | void read_table68k (void)
776      for (i = 0; i < n_defs68k; i++) {
777          build_insn (i);
778      }
779 +        
780 +        /* Extra fixes in table68k for control flow information and flag usage */
781 +        for (i = 0; i < 65536; i++) {
782 +                instrmnem mnemo = (instrmnem)(table68k[i].mnemo);
783 +                
784 + #define IS_CONST_JUMP(opc) \
785 +                (       ((table68k[opc].mnemo == i_Bcc) && (table68k[opc].cc < 2)) \
786 +                ||      (table68k[opc].mnemo == i_BSR) \
787 +                )
788 +
789 + #if 0
790 +                // gb-- Don't follow false and true branches as we may not be
791 +                // able to determine the whole block length in bytes in order
792 +                // to compute the block checksum
793 +                
794 +                // We can follow unconditional jumps if neither Lazy Flusher
795 +                // nor Dynamic Code Patches feature is enabled
796 +                
797 +                // UPDATE: this is no longer permitted since we can decide
798 +                // at runtime whether the JIT compiler is used or not
799 +                if (IS_CONST_JUMP(i))
800 +                        table68k[i].cflow = fl_normal;
801 + #endif
802 +                
803 +                // Fix flags used information for Scc, Bcc, TRAPcc, DBcc instructions
804 +                int flags_used = table68k[i].flaglive;
805 +                if      (       (mnemo == i_Scc)
806 +                        ||      (mnemo == i_Bcc)
807 +                        ||      (mnemo == i_DBcc)
808 +                        ||      (mnemo == i_TRAPcc)
809 +                        )       {
810 +                        switch (table68k[i].cc) {
811 +                        // CC mask:     XNZVC
812 +                        //                       8421
813 +                        case 0: flags_used = 0x00; break;       /*  T */
814 +                        case 1: flags_used = 0x00; break;       /*  F */
815 +                        case 2: flags_used = 0x05; break;       /* HI */
816 +                        case 3: flags_used = 0x05; break;       /* LS */
817 +                        case 4: flags_used = 0x01; break;       /* CC */
818 +                        case 5: flags_used = 0x01; break;       /* CS */
819 +                        case 6: flags_used = 0x04; break;       /* NE */
820 +                        case 7: flags_used = 0x04; break;       /* EQ */
821 +                        case 8: flags_used = 0x02; break;       /* VC */
822 +                        case 9: flags_used = 0x02; break;       /* VS */
823 +                        case 10:flags_used = 0x08; break;       /* PL */
824 +                        case 11:flags_used = 0x08; break;       /* MI */
825 +                        case 12:flags_used = 0x0A; break;       /* GE */
826 +                        case 13:flags_used = 0x0A; break;       /* LT */
827 +                        case 14:flags_used = 0x0E; break;       /* GT */
828 +                        case 15:flags_used = 0x0E; break;       /* LE */
829 +                        }
830 +                }
831 +                
832 +                /* Unconditional jumps don't evaluate condition codes, so they
833 +                   don't actually use any flags themselves */
834 +                if (IS_CONST_JUMP(i))
835 +                        flags_used = 0;
836 +                
837 +                table68k[i].flaglive = flags_used;
838 +        }
839   }
840  
841   static int mismatch;
# Line 766 | Line 863 | static void handle_merges (long int opco
863              smsk = 7; sbitdst = 8; break;
864           case 5:
865              smsk = 63; sbitdst = 64; break;
866 +         case 6:
867 +                smsk = 255; sbitdst = 256; break;
868           case 7:
869                  smsk = 3; sbitdst = 4; break;
870           default:

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines