LH před 3 roky
rodič
revize
69bc9918da

+ 609 - 4
SenaBitWiggler/src/main/java/de/nplusc/izc/senabitwiggler/XAPDisAsm.java

@@ -47,30 +47,185 @@ public class XAPDisAsm {
                 String value = "";
                 switch(opcodeReal)
                 {
-                    case 0x09:
+                    case 0x0e:
                         register="xh";
                         value = ParamManglerIndirectY(valueSigned);
                         break;
+
+
                     case 0x10:
+                        register="AH";
+                        value = ParamManglerImmediate(valueUnsigned);
+                        break;
                     case 0x11:
+                        register="AH";
+                        value = ParamManglerAddress(valueUnsigned);
+                        break;
                     case 0x12:
+                        register="AH";
+                        value = ParamManglerIndirectX(valueSigned);
+                        break;
                     case 0x13:
+                        register="AH";
+                        value = ParamManglerIndirectY(valueSigned);
+                        break;
+
+
                     case 0x14:
+                        register="AL";
+                        value = ParamManglerImmediate(valueUnsigned);
+                        break;
                     case 0x15:
+                        register="AL";
+                        value = ParamManglerAddress(valueUnsigned);
+                        break;
                     case 0x16:
+                        register="AL";
+                        value = ParamManglerIndirectX(valueSigned);
+                        break;
                     case 0x17:
+                        register="AL";
+                        value = ParamManglerIndirectY(valueSigned);
+                        break;
+
                     case 0x18:
+                        register="X";
+                        value = ParamManglerImmediate(valueUnsigned);
+                        break;
                     case 0x19:
+                        register="X";
+                        value = ParamManglerAddress(valueUnsigned);
+                        break;
                     case 0x1a:
+                        register="X";
+                        value = ParamManglerIndirectX(valueSigned);
+                        break;
                     case 0x1b:
+                        register="X";
+                        value = ParamManglerIndirectY(valueSigned);
+                        break;
+
                     case 0x1c:
+                        register="Y";
+                        value = ParamManglerImmediate(valueUnsigned);
+                        break;
                     case 0x1d:
+                        register="Y";
+                        value = ParamManglerAddress(valueUnsigned);
+                        break;
                     case 0x1e:
+                        register="Y";
+                        value = ParamManglerIndirectX(valueSigned);
+                        break;
                     case 0x1f:
+                        register="Y";
+                        value = ParamManglerIndirectY(valueSigned);
+                        break;
+                }
+                return addressToString(address)+":ld: "+register+" "+value;
+            };
+
+            OpCodeMangler st =  (modifier,opcode,address)->{
+                String badOpCode ="";
+                if(modifier!=0x00)
+                {
+                    badOpCode += (EntryPoint.bytesToHex(Shorts.toByteArray(modifier)));
+                };
+
+                byte[] opcodeValues = new byte[opcode.length];
+                byte opcodeReal = 0x00; // only checking lower byte though
+                for(int i=0;i<opcode.length;i++)
+                {
+                    byte[] opcodeWord = Shorts.toByteArray(opcode[i]);
+                    opcodeValues[i]=opcodeWord[0];
+                    opcodeReal=(opcodeWord[1]); //stompy stomp, only keeps the last
+                }
+
+                int valueUnsigned = XAPDisAsmGeneratedCode.unsignedCounts.get(EntryPoint.bytesToHex(opcodeValues));
+                int valueSigned =XAPDisAsmGeneratedCode.signedCounts.get(EntryPoint.bytesToHex(opcodeValues));
+                String register = "";
+
+                String value = "";
+                switch(opcodeReal)
+                {
+                    case 0x0a:
+                        register="xh";
+                        value = ParamManglerIndirectY(valueSigned);
+                        break;
+
+
+                    case 0x21:
+                        register="AH";
+                        value = ParamManglerAddress(valueUnsigned);
+                        break;
+                    case 0x22:
+                        register="AH";
+                        value = ParamManglerIndirectX(valueSigned);
+                        break;
+                    case 0x23:
+                        register="AH";
+                        value = ParamManglerIndirectY(valueSigned);
+                        break;
+
+
+                    case 0x25:
+                        register="AL";
+                        value = ParamManglerAddress(valueUnsigned);
+                        break;
+                    case 0x26:
+                        register="AL";
+                        value = ParamManglerIndirectX(valueSigned);
+                        break;
+                    case 0x27:
+                        register="AL";
+                        value = ParamManglerIndirectY(valueSigned);
+                        break;
+
+                    case 0x29:
+                        register="X";
+                        value = ParamManglerAddress(valueUnsigned);
+                        break;
+                    case 0x2a:
+                        register="X";
+                        value = ParamManglerIndirectX(valueSigned);
+                        break;
+                    case 0x2b:
+                        register="X";
+                        value = ParamManglerIndirectY(valueSigned);
+                        break;
+
+                    case 0x2d:
+                        register="Y";
+                        value = ParamManglerAddress(valueUnsigned);
+                        break;
+                    case 0x2e:
+                        register="Y";
+                        value = ParamManglerIndirectX(valueSigned);
+                        break;
+                    case 0x2f:
+                        register="Y";
+                        value = ParamManglerIndirectY(valueSigned);
+                        break;
                 }
-                return addressToString(address)+":ld: "+badOpCode;
+                return addressToString(address)+":ld: "+register+" "+value;
             };
 
+            OpCodeMangler add = GetBasicMangler("add",(short)0x30);
+            OpCodeMangler sub = GetBasicMangler("sub",(short)0x50);
+            OpCodeMangler or = GetBasicMangler("or",(short)0xb0);
+            OpCodeMangler and = GetBasicMangler("and",(short)0xc0);
+            OpCodeMangler xor = GetBasicMangler("xor",(short)0xd0);
+            OpCodeMangler cmp = GetBasicMangler("cmp",(short)0x80);
+            OpCodeMangler bra = GetBraMangler("bra",(short)0xe0,true);
+            OpCodeMangler blt = GetBraMangler("blt",(short)0xe4,false);
+            OpCodeMangler bne = GetBraMangler("bne",(short)0xf0,false);
+            OpCodeMangler beq = GetBraMangler("beq",(short)0xf4,false);
+            OpCodeMangler bcc = GetBraMangler("bcc",(short)0xf8,false);
+            OpCodeMangler bcs = GetBraMangler("bcs",(short)0xfc,false);
+            OpCodeMangler tst = GetBraMangler("tst",(short)0x98,false);
+            OpCodeMangler bsr = GetBraMangler("bsr",(short)0x9c,false);
+
+
 
 
 
@@ -90,15 +245,465 @@ public class XAPDisAsm {
 
                 return addressToString(address)+": Modifier, this should not be visible at all in the disassembly!!!!!, should not happen";
             };
-            manglers[0xa]=invalid;
+            manglers[0xa]=st;
             manglers[0xb]=invalid;
             manglers[0xc]=invalid;
             manglers[0xd]=invalid;
-            manglers[0xe]=invalid;
+            manglers[0xe]=ld;  //VERIFY
             manglers[0xf]=invalid;
 
+
+            manglers[0x10]=ld;
+            manglers[0x11]=ld;
+            manglers[0x12]=ld;
+            manglers[0x13]=ld;
+            manglers[0x14]=ld;
+            manglers[0x15]=ld;
+            manglers[0x16]=ld;
+            manglers[0x17]=ld;
+            manglers[0x18]=ld;
+            manglers[0x19]=ld;
+            manglers[0x1a]=ld;
+            manglers[0x1b]=ld;
+            manglers[0x1c]=ld;
+            manglers[0x1d]=ld;
+            manglers[0x1e]=ld;
+            manglers[0x1f]=ld;
+
+            manglers[0x20]=invalid; //BGT
+            manglers[0x21]=st;
+            manglers[0x22]=st;
+            manglers[0x23]=st;
+            manglers[0x24]=invalid;
+            manglers[0x25]=st;
+            manglers[0x26]=st;
+            manglers[0x27]=st;
+            manglers[0x28]=invalid;
+            manglers[0x29]=st;
+            manglers[0x2a]=st;
+            manglers[0x2b]=st;
+            manglers[0x2c]=invalid; //BCZ
+            manglers[0x2d]=st;
+            manglers[0x2e]=st;
+            manglers[0x2f]=st;
+
+
+            manglers[0x30]=add;
+            manglers[0x31]=add;
+            manglers[0x32]=add;
+            manglers[0x33]=add;
+            manglers[0x34]=add;
+            manglers[0x35]=add;
+            manglers[0x36]=add;
+            manglers[0x37]=add;
+            manglers[0x38]=add;
+            manglers[0x39]=add;
+            manglers[0x3a]=add;
+            manglers[0x3b]=add;
+            manglers[0x3c]=add;
+            manglers[0x3d]=add;
+            manglers[0x3e]=add;
+            manglers[0x3f]=add;
+
+            manglers[0x40]=invalid;
+            manglers[0x41]=invalid;
+            manglers[0x42]=invalid;
+            manglers[0x43]=invalid;
+            manglers[0x44]=invalid;
+            manglers[0x45]=invalid;
+            manglers[0x46]=invalid;
+            manglers[0x47]=invalid;
+            manglers[0x48]=invalid;
+            manglers[0x49]=invalid;
+            manglers[0x4a]=invalid;
+            manglers[0x4b]=invalid;
+            manglers[0x4c]=invalid;
+            manglers[0x4d]=invalid;
+            manglers[0x4e]=invalid;
+            manglers[0x4f]=invalid;
+
+
+
+            manglers[0x50]=sub;
+            manglers[0x51]=sub;
+            manglers[0x52]=sub;
+            manglers[0x53]=sub;
+            manglers[0x54]=sub;
+            manglers[0x55]=sub;
+            manglers[0x56]=sub;
+            manglers[0x57]=sub;
+            manglers[0x58]=sub;
+            manglers[0x59]=sub;
+            manglers[0x5a]=sub;
+            manglers[0x5b]=sub;
+            manglers[0x5c]=sub;
+            manglers[0x5d]=sub;
+            manglers[0x5e]=sub;
+            manglers[0x5f]=sub;
+
+            manglers[0x60]=invalid;
+            manglers[0x61]=invalid;
+            manglers[0x62]=invalid;
+            manglers[0x63]=invalid;
+            manglers[0x64]=invalid;
+            manglers[0x65]=invalid;
+            manglers[0x66]=invalid;
+            manglers[0x67]=invalid;
+            manglers[0x68]=invalid;
+            manglers[0x69]=invalid;
+            manglers[0x6a]=invalid;
+            manglers[0x6b]=invalid;
+            manglers[0x6c]=invalid;
+            manglers[0x6d]=invalid;
+            manglers[0x6e]=invalid;
+            manglers[0x6f]=invalid;
+
+            manglers[0x70]=invalid;
+            manglers[0x71]=invalid;
+            manglers[0x72]=invalid;
+            manglers[0x73]=invalid;
+            manglers[0x74]=invalid;
+            manglers[0x75]=invalid;
+            manglers[0x76]=invalid;
+            manglers[0x77]=invalid;
+            manglers[0x78]=invalid;
+            manglers[0x79]=invalid;
+            manglers[0x7a]=invalid;
+            manglers[0x7b]=invalid;
+            manglers[0x7c]=invalid;
+            manglers[0x7d]=invalid;
+            manglers[0x7e]=invalid;
+            manglers[0x7f]=invalid;
+
+            manglers[0x80]=cmp;
+            manglers[0x81]=cmp;
+            manglers[0x82]=cmp;
+            manglers[0x83]=cmp;
+            manglers[0x84]=cmp;
+            manglers[0x85]=cmp;
+            manglers[0x86]=cmp;
+            manglers[0x87]=cmp;
+            manglers[0x88]=cmp;
+            manglers[0x89]=cmp;
+            manglers[0x8a]=cmp;
+            manglers[0x8b]=cmp;
+            manglers[0x8c]=cmp;
+            manglers[0x8d]=cmp;
+            manglers[0x8e]=cmp;
+            manglers[0x8f]=cmp;
+
+            manglers[0x90]=invalid; //XXX
+            manglers[0x91]=invalid;
+            manglers[0x92]=invalid;
+            manglers[0x93]=invalid;
+            manglers[0x94]=invalid;
+            manglers[0x95]=invalid;
+            manglers[0x96]=invalid;
+            manglers[0x97]=invalid;
+            manglers[0x98]=invalid;
+            manglers[0x99]=tst;
+            manglers[0x9a]=tst;
+            manglers[0x9b]=tst;
+            manglers[0x9c]=invalid;
+            manglers[0x9d]=bsr;
+            manglers[0x9e]=bsr;
+            manglers[0x9f]=bsr;
+            //0xax
+
+
+
+
+
+
+
+
+            manglers[0xb0]=or;
+            manglers[0xb1]=or;
+            manglers[0xb2]=or;
+            manglers[0xb3]=or;
+            manglers[0xb4]=or;
+            manglers[0xb5]=or;
+            manglers[0xb6]=or;
+            manglers[0xb7]=or;
+            manglers[0xb8]=or;
+            manglers[0xb9]=or;
+            manglers[0xba]=or;
+            manglers[0xbb]=or;
+            manglers[0xbc]=or;
+            manglers[0xbd]=or;
+            manglers[0xbe]=or;
+            manglers[0xbf]=or;
+
+
+            manglers[0xc0]=and;
+            manglers[0xc1]=and;
+            manglers[0xc2]=and;
+            manglers[0xc3]=and;
+            manglers[0xc4]=and;
+            manglers[0xc5]=and;
+            manglers[0xc6]=and;
+            manglers[0xc7]=and;
+            manglers[0xc8]=and;
+            manglers[0xc9]=and;
+            manglers[0xca]=and;
+            manglers[0xcb]=and;
+            manglers[0xcc]=and;
+            manglers[0xcd]=and;
+            manglers[0xce]=and;
+            manglers[0xcf]=and;
+
+            manglers[0xd0]=xor;
+            manglers[0xd1]=xor;
+            manglers[0xd2]=xor;
+            manglers[0xd3]=xor;
+            manglers[0xd4]=xor;
+            manglers[0xd5]=xor;
+            manglers[0xd6]=xor;
+            manglers[0xd7]=xor;
+            manglers[0xd8]=xor;
+            manglers[0xd9]=xor;
+            manglers[0xda]=xor;
+            manglers[0xdb]=xor;
+            manglers[0xdc]=xor;
+            manglers[0xdd]=xor;
+            manglers[0xde]=xor;
+            manglers[0xdf]=xor;
+
+            manglers[0xe0]=invalid;
+            manglers[0xe1]=bra;
+            manglers[0xe2]=bra;
+            manglers[0xe3]=bra;
+            manglers[0xe4]=invalid;
+            manglers[0xe5]=blt;
+            manglers[0xe6]=blt;
+            manglers[0xe7]=blt;
+            manglers[0xe8]=invalid;
+            manglers[0xe9]=invalid;
+            manglers[0xea]=invalid;
+            manglers[0xeb]=invalid;
+            manglers[0xec]=invalid;
+            manglers[0xed]=invalid;
+            manglers[0xee]=invalid;
+            manglers[0xef]=invalid;
+
+            manglers[0xf0]=invalid;
+            manglers[0xf1]=bne;
+            manglers[0xf2]=bne;
+            manglers[0xf3]=bne;
+            manglers[0xf4]=invalid;
+            manglers[0xf5]=beq;
+            manglers[0xf6]=beq;
+            manglers[0xf7]=beq;
+            manglers[0xf8]=invalid;
+            manglers[0xf9]=bcc;
+            manglers[0xfa]=bcc;
+            manglers[0xfb]=bcc;
+            manglers[0xfc]=invalid;
+            manglers[0xfd]=bcs;
+            manglers[0xfe]=bcs;
+            manglers[0xff]=bcs;
         }
 
+    static OpCodeMangler GetModifiedMangler(String opcodeLabel, String OpcodeLabelModified, short opcodeBase, boolean bra_specialcase)
+    {
+        return (modifier,opcode,address)->{
+            boolean modified = modifier==0x09;
+
+            byte[] opcodeValues = new byte[opcode.length];
+            short opcodeReal = 0x00; // only checking lower byte though
+            for(int i=0;i<opcode.length;i++)
+            {
+                byte[] opcodeWord = Shorts.toByteArray(opcode[i]);
+                opcodeValues[i]=opcodeWord[0];
+                opcodeReal=(short)((opcode[i]-opcodeBase)&0xFF); //stompy stomp, only keeps the last
+            }
+
+            int valueUnsigned = XAPDisAsmGeneratedCode.unsignedCounts.get(EntryPoint.bytesToHex(opcodeValues));
+            int valueSigned =XAPDisAsmGeneratedCode.signedCounts.get(EntryPoint.bytesToHex(opcodeValues));
+            String register = "";
+
+            String value = "";
+            switch(opcodeReal)
+            {
+                case 0x01:
+                    register="AH";
+                    value = ParamManglerAddress(valueSigned);
+                    break;
+                case 0x02:
+                    register="AH";
+                    value = ParamManglerIndirectX(valueSigned);
+                    break;
+                case 0x03:
+                    register="AH";
+                    value = ParamManglerIndirectY(valueSigned);
+                    break;
+            }
+            String potentialTargetAddress=addressToString(address+opcode.length-1+valueSigned);
+
+            if(bra_specialcase&&opcodeReal==0x02&&address==0)
+            {
+                return addressToString(address)+":rts";
+            }
+
+
+            return addressToString(address)+":"+opcodeLabel+":"+value+"; Target="+potentialTargetAddress;
+        };
+    }
+
+
+
+
+
+    static OpCodeMangler GetBraMangler(String opcodeLabel, short opcodeBase, boolean bra_specialcase)
+    {
+        return (modifier,opcode,address)->{
+            String badOpCode ="";
+            if(modifier!=0x00)
+            {
+                badOpCode += (EntryPoint.bytesToHex(Shorts.toByteArray(modifier)));
+            };
+
+            byte[] opcodeValues = new byte[opcode.length];
+            short opcodeReal = 0x00; // only checking lower byte though
+            for(int i=0;i<opcode.length;i++)
+            {
+                byte[] opcodeWord = Shorts.toByteArray(opcode[i]);
+                opcodeValues[i]=opcodeWord[0];
+                opcodeReal=(short)((opcode[i]-opcodeBase)&0xFF); //stompy stomp, only keeps the last
+            }
+
+            int valueUnsigned = XAPDisAsmGeneratedCode.unsignedCounts.get(EntryPoint.bytesToHex(opcodeValues));
+            int valueSigned =XAPDisAsmGeneratedCode.signedCounts.get(EntryPoint.bytesToHex(opcodeValues));
+            String register = "";
+
+            String value = "";
+            switch(opcodeReal)
+            {
+                case 0x01:
+                    register="AH";
+                    value = ParamManglerAddress(valueSigned);
+                    break;
+                case 0x02:
+                    register="AH";
+                    value = ParamManglerIndirectX(valueSigned);
+                    break;
+                case 0x03:
+                    register="AH";
+                    value = ParamManglerIndirectY(valueSigned);
+                    break;
+            }
+            String potentialTargetAddress=addressToString(address+opcode.length-1+valueSigned);
+
+            if(bra_specialcase&&opcodeReal==0x02&&address==0)
+            {
+                return addressToString(address)+":rts";
+            }
+
+
+            return addressToString(address)+":"+opcodeLabel+":"+value+"; Target="+potentialTargetAddress;
+        };
+    }
+
+
+
+    static OpCodeMangler GetBasicMangler(String opcodeLabel, short opcodeBase)
+    {
+        return (modifier,opcode,address)->{
+            String badOpCode ="";
+            if(modifier!=0x00)
+            {
+                badOpCode += (EntryPoint.bytesToHex(Shorts.toByteArray(modifier)));
+            };
+
+            byte[] opcodeValues = new byte[opcode.length];
+            short opcodeReal = 0x00; // only checking lower byte though
+            for(int i=0;i<opcode.length;i++)
+            {
+                byte[] opcodeWord = Shorts.toByteArray(opcode[i]);
+                opcodeValues[i]=opcodeWord[0];
+                opcodeReal=(short)(opcodeWord[1]&(short)0x00FF); //stompy stomp, only keeps the last
+            }
+            short opcodeDispatch = (short)(opcodeReal-opcodeBase);
+
+            int valueUnsigned = XAPDisAsmGeneratedCode.unsignedCounts.get(EntryPoint.bytesToHex(opcodeValues));
+            int valueSigned =XAPDisAsmGeneratedCode.signedCounts.get(EntryPoint.bytesToHex(opcodeValues));
+            String register = "";
+
+            String value = "";
+            switch(opcodeDispatch)
+            {
+                case 0x0:
+                    register="AH";
+                    value = ParamManglerImmediate(valueUnsigned);
+                    break;
+                case 0x1:
+                    register="AH";
+                    value = ParamManglerAddress(valueUnsigned);
+                    break;
+                case 0x2:
+                    register="AH";
+                    value = ParamManglerIndirectX(valueSigned);
+                    break;
+                case 0x3:
+                    register="AH";
+                    value = ParamManglerIndirectY(valueSigned);
+                    break;
+
+
+                case 0x4:
+                    register="AL";
+                    value = ParamManglerImmediate(valueUnsigned);
+                    break;
+                case 0x5:
+                    register="AL";
+                    value = ParamManglerAddress(valueUnsigned);
+                    break;
+                case 0x6:
+                    register="AL";
+                    value = ParamManglerIndirectX(valueSigned);
+                    break;
+                case 0x7:
+                    register="AL";
+                    value = ParamManglerIndirectY(valueSigned);
+                    break;
+
+                case 0x8:
+                    register="X";
+                    value = ParamManglerImmediate(valueUnsigned);
+                    break;
+                case 0x9:
+                    register="X";
+                    value = ParamManglerAddress(valueUnsigned);
+                    break;
+                case 0xa:
+                    register="X";
+                    value = ParamManglerIndirectX(valueSigned);
+                    break;
+                case 0xb:
+                    register="X";
+                    value = ParamManglerIndirectY(valueSigned);
+                    break;
+
+                case 0xc:
+                    register="Y";
+                    value = ParamManglerImmediate(valueUnsigned);
+                    break;
+                case 0xd:
+                    register="Y";
+                    value = ParamManglerAddress(valueUnsigned);
+                    break;
+                case 0xe:
+                    register="Y";
+                    value = ParamManglerIndirectX(valueSigned);
+                    break;
+                case 0xf:
+                    register="Y";
+                    value = ParamManglerIndirectY(valueSigned);
+                    break;
+            }
+            return addressToString(address)+":"+opcodeLabel+": "+register+" "+value;
+        };
+    }
 
 
     private static String addressToString(int address)