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.1 by cebix, 1999-10-03T14:16:26Z vs.
Revision 1.9 by gbeauche, 2005-06-06T19:22:56Z

# Line 130 | Line 130 | struct mnemolookup lookuptab[] = {
130      { i_FBcc, "FBcc" },
131      { i_FSAVE, "FSAVE" },
132      { i_FRESTORE, "FRESTORE" },
133 +
134 +    { i_CINVL, "CINVL" },
135 +    { i_CINVP, "CINVP" },
136 +    { i_CINVA, "CINVA" },
137 +    { i_CPUSHL, "CPUSHL" },
138 +    { i_CPUSHP, "CPUSHP" },
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 186 | 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;
198 –         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 208 | 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;
211 –         case fu_isjmp: flaglive |= 1 << i; break;
212 –         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 227 | Line 255 | static void build_insn (int insn)
255          int pos = 0;
256          int mnp = 0;
257          int bitno = 0;
258 <        char mnemonic[10];
258 >        char mnemonic[64];
259  
260          wordsizes sz = sz_long;
261          int srcgather = 0, dstgather = 0;
# Line 264 | 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 302 | Line 332 | static void build_insn (int insn)
332                      }
333                  }
334                  mnp++;
335 +                if ((unsigned)mnp >= sizeof(mnemonic) - 1) {
336 +                        mnemonic[sizeof(mnemonic) - 1] = 0;
337 +                        fprintf(stderr, "Instruction %s overflow\n", mnemonic);
338 +                        abort();
339 +                }
340              }
341              pos++;
342          }
# Line 339 | Line 374 | static void build_insn (int insn)
374               case 'P': srcmode = Aipi; pos++; break;
375              }
376              break;
377 +        case 'L':
378 +                srcmode = absl;
379 +                break;
380           case '#':
381              switch (opcstr[pos++]) {
382               case 'z': srcmode = imm; break;
# Line 384 | Line 422 | static void build_insn (int insn)
422                      srcpos = bitpos[bitK];
423                  }
424                  break;
425 +                 case 'E': srcmode = immi; srcreg = bitval[bitE];
426 +                if (CPU_EMU_SIZE < 5) { // gb-- what is CPU_EMU_SIZE used for ??
427 +                        /* 1..255 */
428 +                        srcgather = 1;
429 +                        srctype = 6;
430 +                        srcpos = bitpos[bitE];
431 +                }
432 +                break;
433 +                 case 'p': srcmode = immi; srcreg = bitval[bitp];
434 +                if (CPU_EMU_SIZE < 5) {
435 +                        /* 0..3 */
436 +                        srcgather = 1;
437 +                        srctype = 7;
438 +                        srcpos = bitpos[bitp];
439 +                }
440 +                break;
441               default: abort();
442              }
443              break;
# Line 508 | Line 562 | static void build_insn (int insn)
562               case 'R': destreg = bitval[bitR]; dstgather = 1; dstpos = bitpos[bitR]; break;
563               default: abort();
564              }
565 +                if (dstpos < 0 || dstpos >= 32)
566 +                        abort();
567              break;
568           case 'A':
569              destmode = Areg;
570              switch (opcstr[pos++]) {
571               case 'r': destreg = bitval[bitr]; dstgather = 1; dstpos = bitpos[bitr]; break;
572               case 'R': destreg = bitval[bitR]; dstgather = 1; dstpos = bitpos[bitR]; break;
573 +                case 'x': destreg = 0; dstgather = 0; dstpos = 0; break;
574               default: abort();
575              }
576 +                if (dstpos < 0 || dstpos >= 32)
577 +                        abort();
578              switch (opcstr[pos]) {
579               case 'p': destmode = Apdi; pos++; break;
580               case 'P': destmode = Aipi; pos++; break;
581              }
582              break;
583 +        case 'L':
584 +                destmode = absl;
585 +                break;
586           case '#':
587              switch (opcstr[pos++]) {
588               case 'z': destmode = imm; break;
# Line 691 | Line 753 | static void build_insn (int insn)
753              table68k[opc].flaginfo[i].flaguse = id.flaginfo[i].flaguse;
754          }
755   #endif
756 +        
757 +        // Fix flags used information for Scc, Bcc, TRAPcc, DBcc instructions
758 +        if      (       table68k[opc].mnemo == i_Scc
759 +                ||      table68k[opc].mnemo == i_Bcc
760 +                ||      table68k[opc].mnemo == i_DBcc
761 +                ||      table68k[opc].mnemo == i_TRAPcc
762 +                )       {
763 +                switch (table68k[opc].cc) {
764 +                // CC mask:     XNZVC
765 +                //                       8421
766 +                case 0: flags_used = 0x00; break;       /*  T */
767 +                case 1: flags_used = 0x00; break;       /*  F */
768 +                case 2: flags_used = 0x05; break;       /* HI */
769 +                case 3: flags_used = 0x05; break;       /* LS */
770 +                case 4: flags_used = 0x01; break;       /* CC */
771 +                case 5: flags_used = 0x01; break;       /* CS */
772 +                case 6: flags_used = 0x04; break;       /* NE */
773 +                case 7: flags_used = 0x04; break;       /* EQ */
774 +                case 8: flags_used = 0x02; break;       /* VC */
775 +                case 9: flags_used = 0x02; break;       /* VS */
776 +                case 10:flags_used = 0x08; break;       /* PL */
777 +                case 11:flags_used = 0x08; break;       /* MI */
778 +                case 12:flags_used = 0x0A; break;       /* GE */
779 +                case 13:flags_used = 0x0A; break;       /* LT */
780 +                case 14:flags_used = 0x0E; break;       /* GT */
781 +                case 15:flags_used = 0x0E; break;       /* LE */
782 +                }
783 +        }
784 +                
785 + #if 1
786 +        /* gb-- flagdead and flaglive would not have correct information */
787 +        table68k[opc].flagdead = flags_set;
788 +        table68k[opc].flaglive = flags_used;
789 + #else
790          table68k[opc].flagdead = flagdead;
791          table68k[opc].flaglive = flaglive;
792 + #endif
793 +        table68k[opc].cflow = cflow;
794          nomatch:
795          /* FOO! */;
796      }
# Line 738 | Line 836 | static void handle_merges (long int opco
836              smsk = 7; sbitdst = 8; break;
837           case 5:
838              smsk = 63; sbitdst = 64; break;
839 +         case 6:
840 +                smsk = 255; sbitdst = 256; break;
841 +         case 7:
842 +                smsk = 3; sbitdst = 4; break;
843           default:
844              smsk = 0; sbitdst = 0;
845              abort();

Diff Legend

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