src/emu/cpu/apexc/apexc.c
| r7205 | r7206 | |
| 356 | 356 | |
| 357 | 357 | int running; /* 1 flag: */ |
| 358 | 358 | /* running: flag implied by the existence of the stop instruction */ |
| 359 | UINT32 pc; /* address of next instruction for the disassembler */ |
| 359 | 360 | |
| 360 | 361 | running_device *device; |
| 361 | 362 | const address_space *program; |
| r7205 | r7206 | |
| 540 | 541 | function = (cpustate->cr >> 7) & 0x1F; |
| 541 | 542 | c6 = (cpustate->cr >> 1) & 0x3F; |
| 542 | 543 | vector = cpustate->cr & 1; |
| 544 | cpustate->pc = y<<2; |
| 543 | 545 | |
| 544 | 546 | function &= 0x1E; /* this is a mere guess - the LSBit is reserved for future additions */ |
| 545 | 547 | |
| r7205 | r7206 | |
| 595 | 597 | { |
| 596 | 598 | /* load ml with X */ |
| 597 | 599 | delay1 = load_ml(cpustate, x, vector); |
| 600 | cpustate->pc = x<<2; |
| 598 | 601 | /* burn pre-fetch delay if needed */ |
| 599 | 602 | if (delay1) |
| 600 | 603 | { |
| r7205 | r7206 | |
| 827 | 830 | |
| 828 | 831 | do |
| 829 | 832 | { |
| 830 | | debugger_instruction_hook(device, effective_address(cpustate, cpustate->ml)); |
| 833 | debugger_instruction_hook(device, cpustate->pc); |
| 831 | 834 | |
| 832 | 835 | if (cpustate->running) |
| 833 | 836 | execute(cpustate); |
| r7205 | r7206 | |
| 870 | 873 | case CPUINFO_INT_REGISTER + APEXC_A: cpustate->a = info->i; break; |
| 871 | 874 | case CPUINFO_INT_REGISTER + APEXC_R: cpustate->r = info->i; break; |
| 872 | 875 | case CPUINFO_INT_REGISTER + APEXC_ML: cpustate->ml = info->i & 0x3ff; break; |
| 876 | case CPUINFO_INT_REGISTER + APEXC_PC: cpustate->pc = info->i; break; |
| 873 | 877 | case CPUINFO_INT_REGISTER + APEXC_WS: cpustate->working_store = info->i & 0xf; break; |
| 874 | 878 | case CPUINFO_INT_REGISTER + APEXC_STATE: cpustate->running = info->i ? TRUE : FALSE; break; |
| 875 | 879 | } |
| r7205 | r7206 | |
| 904 | 908 | |
| 905 | 909 | case CPUINFO_INT_SP: info->i = 0; /* no SP */ break; |
| 906 | 910 | case CPUINFO_INT_PC: |
| 907 | | /* no PC - return memory location register instead, this should be |
| 908 | | equivalent unless executed in the midst of an instruction */ |
| 909 | | info->i = effective_address(cpustate, cpustate->ml); |
| 910 | | break; |
| 911 | | case CPUINFO_INT_PREVIOUSPC: info->i = 0; /* no PC */ break; |
| 911 | case CPUINFO_INT_PREVIOUSPC: info->i = cpustate->pc; /* psuedo-PC */ break; |
| 912 | 912 | |
| 913 | 913 | /*case CPUINFO_INT_INPUT_STATE + ...:*/ /* no interrupts */ |
| 914 | 914 | |
| r7205 | r7206 | |
| 916 | 916 | case CPUINFO_INT_REGISTER + APEXC_A: info->i = cpustate->a; break; |
| 917 | 917 | case CPUINFO_INT_REGISTER + APEXC_R: info->i = cpustate->r; break; |
| 918 | 918 | case CPUINFO_INT_REGISTER + APEXC_ML: info->i = cpustate->ml; break; |
| 919 | case CPUINFO_INT_REGISTER + APEXC_PC: info->i = cpustate->pc; break; |
| 919 | 920 | case CPUINFO_INT_REGISTER + APEXC_WS: info->i = cpustate->working_store; break; |
| 920 | 921 | case CPUINFO_INT_REGISTER + APEXC_STATE: info->i = cpustate->running; break; |
| 921 | 922 | case CPUINFO_INT_REGISTER + APEXC_ML_FULL: info->i = effective_address(cpustate, cpustate->ml); break; |
| r7205 | r7206 | |
| 940 | 941 | case CPUINFO_STR_REGISTER + APEXC_A: sprintf(info->s, "A :%08X", cpustate->a); break; |
| 941 | 942 | case CPUINFO_STR_REGISTER + APEXC_R: sprintf(info->s, "R :%08X", cpustate->r); break; |
| 942 | 943 | case CPUINFO_STR_REGISTER + APEXC_ML: sprintf(info->s, "ML:%03X", cpustate->ml); break; |
| 944 | case CPUINFO_STR_REGISTER + APEXC_PC: sprintf(info->s, "PC:%03X", cpustate->pc); break; |
| 943 | 945 | case CPUINFO_STR_REGISTER + APEXC_WS: sprintf(info->s, "WS:%01X", cpustate->working_store); break; |
| 944 | 946 | |
| 945 | 947 | case CPUINFO_STR_REGISTER + APEXC_STATE: sprintf(info->s, "CPU state:%01X", cpustate->running ? TRUE : FALSE); break; |
src/emu/cpu/apexc/apexcdsm.c
| r7205 | r7206 | |
| 51 | 51 | |
| 52 | 52 | For vector instructions, replace the first space on the right of the mnemonic |
| 53 | 53 | with a 'v'. |
| 54 | |
| 55 | 01-Feb-2010 (Robbbert): |
| 56 | I've added the actual address, (as shown in the extreme left of the debugger |
| 57 | output), so that you can see much easier how the program will flow. Example: |
| 58 | |
| 59 | +C XXX(##/##) XXX(##/##) |
| 60 | |
| 61 | The X value shows where the data word is located, and the Y value is the |
| 62 | address of the next instruction. |
| 54 | 63 | */ |
| 55 | 64 | enum _format_type {branch, shiftl, shiftr, multiply, store, swap, one_address, two_address}; |
| 56 | 65 | typedef enum _format_type format_type; |
| r7205 | r7206 | |
| 104 | 113 | case two_address: |
| 105 | 114 | case branch: |
| 106 | 115 | case swap: |
| 107 | | buffer += sprintf(buffer, "%-10s", mnemonic); /* 10 chars*/ |
| 116 | buffer += sprintf(buffer, " %-10s", mnemonic); /* 10 chars*/ |
| 108 | 117 | break; |
| 109 | 118 | |
| 110 | 119 | case shiftl: |
| r7205 | r7206 | |
| 113 | 122 | n = c6; |
| 114 | 123 | else |
| 115 | 124 | n = 64-c6; |
| 116 | | buffer += sprintf(buffer, "%-2s(%2d) ", mnemonic, n); /* 10 chars */ |
| 125 | buffer += sprintf(buffer, " %-2s(%2d) ", mnemonic, n); /* 10 chars */ |
| 117 | 126 | break; |
| 118 | 127 | |
| 119 | 128 | case multiply: |
| 120 | 129 | n = 33-c6; |
| 121 | 130 | if (n == 32) |
| 122 | 131 | /* case "32" : do not show bit specifier */ |
| 123 | | buffer += sprintf(buffer, "%-10s", mnemonic); /* 10 chars */ |
| 132 | buffer += sprintf(buffer, " %-10s", mnemonic); /* 10 chars */ |
| 124 | 133 | else |
| 125 | | buffer += sprintf(buffer, "%-2s(%2d) ", mnemonic, n); /* 10 chars */ |
| 134 | buffer += sprintf(buffer, " %-2s(%2d) ", mnemonic, n); /* 10 chars */ |
| 126 | 135 | break; |
| 127 | 136 | |
| 128 | 137 | case store: |
| 129 | 138 | if (c6 == 0) |
| 130 | 139 | { /* case "1-32" : do not show bit specifier */ |
| 131 | | buffer += sprintf(buffer, "%-10s", mnemonic); /* 10 chars*/ |
| 140 | buffer += sprintf(buffer, " %-10s", mnemonic); /* 10 chars*/ |
| 132 | 141 | } |
| 133 | 142 | else if (c6 & 0x20) |
| 134 | 143 | { /* case "1-n" */ |
| 135 | 144 | n = c6-32; |
| 136 | | buffer += sprintf(buffer, "%-2s (1-%02d) ", mnemonic, n); /* 10 chars */ |
| 145 | buffer += sprintf(buffer, " %-2s (1-%02d) ", mnemonic, n); /* 10 chars */ |
| 137 | 146 | } |
| 138 | 147 | else |
| 139 | 148 | { /* case "n-32" */ |
| 140 | 149 | n = c6+1; |
| 141 | | buffer += sprintf(buffer, "%-2s(%02d-32) ", mnemonic, n); /* 8 chars */ |
| 150 | buffer += sprintf(buffer, " %-2s(%02d-32) ", mnemonic, n); /* 8 chars */ |
| 142 | 151 | } |
| 143 | 152 | } |
| 144 | 153 | |
| r7205 | r7206 | |
| 147 | 156 | { |
| 148 | 157 | case branch: |
| 149 | 158 | buffer--; /* eat last char */ |
| 150 | | buffer += sprintf(buffer, "<(%02d/%02d) >=", (x >> 5) & 0x1f, x & 0x1f); /* 10+1 chars */ |
| 159 | buffer += sprintf(buffer, "<%03X(%02d/%02d) >=", x<<2, (x >> 5) & 0x1f, x & 0x1f); /* 10+1 chars */ |
| 151 | 160 | break; |
| 152 | 161 | |
| 153 | 162 | case multiply: |
| 154 | 163 | case swap: |
| 155 | | buffer += sprintf(buffer, "(%02d) ", (x >> 5) & 0x1f); /* 10 chars */ |
| 164 | buffer += sprintf(buffer, " (%02d) ", (x >> 5) & 0x1f); /* 10 chars */ |
| 156 | 165 | break; |
| 157 | 166 | |
| 158 | 167 | case one_address: |
| 159 | 168 | case shiftl: |
| 160 | 169 | case shiftr: |
| 161 | | buffer += sprintf(buffer, " "); /* 10 chars */ |
| 170 | buffer += sprintf(buffer, " "); /* 10 chars */ |
| 162 | 171 | break; |
| 163 | 172 | |
| 164 | 173 | case two_address: |
| 165 | 174 | case store: |
| 166 | | buffer += sprintf(buffer, "(%02d/%02d) ", (x >> 5) & 0x1f, x & 0x1f); /* 10 chars */ |
| 175 | buffer += sprintf(buffer, "%03X(%02d/%02d) ", x<<2, (x >> 5) & 0x1f, x & 0x1f); /* 10 chars */ |
| 167 | 176 | break; |
| 168 | 177 | } |
| 169 | 178 | |
| 170 | 179 | /* print Y address */ |
| 171 | | buffer += sprintf(buffer, "(%02d/%02d)", (y >> 5) & 0x1f, y & 0x1f); /* 7 chars */ |
| 180 | buffer += sprintf(buffer, "%03X(%02d/%02d)", y<<2, (y >> 5) & 0x1f, y & 0x1f); /* 7 chars */ |
| 172 | 181 | |
| 173 | 182 | return 4; |
| 174 | 183 | } |