arm/cpu.c

   1 #include "cpu_definitions.h"
   2 #include <stdio.h>
   3 /* CPU Status flags */
   4 uint64_t N = 0x00000000; //Negative
   5 uint64_t Z = 0x00000000; //Zero
   6 uint64_t C = 0x00000000; //Carry (or Unsigned Overflow)
   7 uint64_t V = 0x00000000; //Overflow (Signed)
   8
   9 uint64_t PC = 0x00000000; //Program Counter
  10 uint64_t *MEMORY; //Memory
  11
  12 void interpret(uint64_t opcode) {
  13         switch(opcode) { //ADC (Add with Carry)
  14         /* Add/subtract (with carry).  */
  15                 case 0x1a000000:
  16                         MEMORY[pc+1] = MEMORY[pc+2] + MEMORY[pc+3] + C;
  17                         //dest = op_1 + op_2 + Carry
  18                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
  19                                 C = 0x00000001;
  20                                 pc = pc + 1;
  21                                 break;
  22                         }
  23                         if (MEMORY[pc+1] < 0x00000000) { //negative?
  24                                 N = 0x00000001;
  25                                 pc = pc + 1;
  26                                 break;
  27                         }
  28                         if (MEMORY[pc+1] = 0x00000000) { //zero?
  29                                 Z = 0x00000001;
  30                                 pc = pc + 1;
  31                                 break;
  32                         }
  33                         pc = pc + 1;
  34                         break;
  35                 case 0x3a000000: //ADCS (Add with Carry With Status)
  36                         MEMORY[pc+1] = MEMORY[pc+2] + MEMORY[pc+3] + C;
  37                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
  38                                 C = 0x00000001;
  39                                 pc = pc + 1;
  40                                 break;
  41                         }
  42                         if (MEMORY[pc+1] < 0x00000000) { //negative?
  43                                 N = 0x00000001;
  44                                 pc = pc + 1;
  45                                 break;
  46                         }
  47                         if (MEMORY[pc+1] = 0x00000000) { //zero?
  48                                 Z = 0x00000001;
  49                                 pc = pc + 1;
  50                                 break;
  51                         }
  52                         //dest = op_1 + op_2 + Carry
  53                         pc = pc + 1;
  54                         break;
  55                 case 0x5a000000: //SBC (Subtract with Carry)
  56                         MEMORY[pc+1] = MEMORY[pc+2] - MEMORY[pc+3] - ~C;
  57                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
  58                                 C = 0x00000001;
  59                                 pc = pc + 1;
  60                                 break;
  61                         }
  62                         if (MEMORY[pc+1] < 0x00000000) { //negative?
  63                                 N = 0x00000001;
  64                                 pc = pc + 1;
  65                                 break;
  66                         }
  67                         if (MEMORY[pc+1] = 0x00000000) { //zero?
  68                                 Z = 0x00000001;
  69                                 pc = pc + 1;
  70                                 break;
  71                         }
  72                         //dest = op_1 - op_2 - NOT(Carry)
  73                         pc = pc + 1;
  74                         break;
  75                 case 0x7a000000: //SBCS (Subtract with Carry With Status)
  76                         MEMORY[pc+1] = MEMORY[pc+2] - MEMORY[pc+3] - ~C;
  77                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
  78                                 C = 0x00000001;
  79                                 pc = pc + 1;
  80                                 break;
  81                         }
  82                         if (MEMORY[pc+1] < 0x00000000) { //negative?
  83                                 N = 0x00000001;
  84                                 pc = pc + 1;
  85                                 break;
  86                         }
  87                         if (MEMORY[pc+1] = 0x00000000) { //zero?
  88                                 Z = 0x00000001;
  89                                 pc = pc + 1;
  90                                 break;
  91                         }
  92                         //dest = op_1 - op_2 - NOT(Carry)
  93                         pc = pc + 1;
  94                         break;
  95                 case 0x5a0003e0: //NGC (Negate with Carry) (This instruction is an alias of SBC.)
  96                         MEMORY[pc+1] = MEMORY[pc+2] - MEMORY[pc+3] - ~C;
  97                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
  98                                 C = 0x00000001;
  99                                 pc = pc + 1;
 100                                 break;
 101                         }
 102                         if (MEMORY[pc+1] < 0x00000000) { //negative?
 103                                 N = 0x00000001;
 104                                 pc = pc + 1;
 105                                 break;
 106                         }
 107                         if (MEMORY[pc+1] = 0x00000000) { //zero?
 108                                 Z = 0x00000001;
 109                                 pc = pc + 1;
 110                                 break;
 111                         }
 112                         //dest = op_1 - op_2 - NOT(Carry)
 113                         pc = pc + 1;
 114                         break;
 115                 case 0x7a0003e0: //NGCS (Negate with Carry With Status) (This instruction is an alias of SBCS.)
 116                         MEMORY[pc+1] = MEMORY[pc+2] - MEMORY[pc+3] - ~C;
 117                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
 118                                 C = 0x00000001;
 119                                 pc = pc + 1;
 120                                 break;
 121                         }
 122                         if (MEMORY[pc+1] < 0x00000000) { //negative?
 123                                 N = 0x00000001;
 124                                 pc = pc + 1;
 125                                 break;
 126                         }
 127                         if (MEMORY[pc+1] = 0x00000000) { //zero?
 128                                 Z = 0x00000001;
 129                                 pc = pc + 1;
 130                                 break;
 131                         }
 132                         //dest = op_1 - op_2 - NOT(Carry)
 133                         pc = pc + 1;
 134                         break;
 135                 /* Add/subtract (extended register).  */
 136                 case 0x0b200000: //ADD (adds...)
 137                         MEMORY[pc+1] = MEMORY[pc+2] + MEMORY[pc+3];
 138                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
 139                                 C = 0x00000001;
 140                                 pc = pc + 1;
 141                                 break;
 142                         }
 143                         if (MEMORY[pc+1] < 0x00000000) { //negative?
 144                                 N = 0x00000001;
 145                                 pc = pc + 1;
 146                                 break;
 147                         }
 148                         if (MEMORY[pc+1] = 0x00000000) { //zero?
 149                                 Z = 0x00000001;
 150                                 pc = pc + 1;
 151                                 break;
 152                         }
 153                         //dest = op_1 + op_2
 154                         pc = pc + 1;
 155                         break;
 156                 case 0x2b200000: //ADDS (adds With Status)
 157                         MEMORY[pc+1] = MEMORY[pc+2] + MEMORY[pc+3];
 158                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
 159                                 C = 0x00000001;
 160                                 pc = pc + 1;
 161                                 break;
 162                         }
 163                         if (MEMORY[pc+1] < 0x00000000) { //negative?
 164                                 N = 0x00000001;
 165                                 pc = pc + 1;
 166                                 break;
 167                         }
 168                         if (MEMORY[pc+1] = 0x00000000) { //zero?
 169                                 Z = 0x00000001;
 170                                 pc = pc + 1;
 171                                 break;
 172                         }
 173                         //dest = op_1 + op_2
 174                         pc = pc + 1;
 175                         break;
 176                 case 0x2b20001f: //CMN (Compare Negative)
 177                         N = MEMORY[pc+2] - ~MEMORY[pc+3];
 178                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
 179                                 C = 0x00000001;
 180                                 pc = pc + 1;
 181                                 break;
 182                         }
 183                         if (MEMORY[pc+1] = 0x00000000) { //zero?
 184                                 Z = 0x00000001;
 185                                 pc = pc + 1;
 186                                 break;
 187                         }
 188                         //<flags> = op_1 - (NOT op_2)  ; result is not stored, only flags updated
 189                         pc = pc + 1;
 190                         break;
 191                 case 0x4b200000: //SUB (substracts)
 192                         MEMORY[pc+1] = MEMORY[pc+2] - MEMORY[pc+3];
 193                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
 194                                 C = 0x00000001;
 195                                 pc = pc + 1;
 196                                 break;
 197                         }
 198                         if (MEMORY[pc+1] < 0x00000000) { //negative?
 199                                 N = 0x00000001;
 200                                 pc = pc + 1;
 201                                 break;
 202                         }
 203                         if (MEMORY[pc+1] = 0x00000000) { //zero?
 204                                 Z = 0x00000001;
 205                                 pc = pc + 1;
 206                                 break;
 207                         }
 208                         //dest = op_1 - op_2
 209                         pc = pc + 1;
 210                         break;
 211                 case 0x6b200000: //SUBS (substracts with status)
 212                         MEMORY[pc+1] = MEMORY[pc+2] - MEMORY[pc+3];
 213                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
 214                                 C = 0x00000001;
 215                                 pc = pc + 1;
 216                                 break;
 217                         }
 218                         if (MEMORY[pc+1] < 0x00000000) { //negative?
 219                                 N = 0x00000001;
 220                                 pc = pc + 1;
 221                                 break;
 222                         }
 223                         if (MEMORY[pc+1] = 0x00000000) { //zero?
 224                                 Z = 0x00000001;
 225                                 pc = pc + 1;
 226                                 break;
 227                         }
 228                         //dest = op_1 - op_2
 229                         pc = pc + 1;
 230                         break;
 231                 case 0x6b20001f: //CMP (COMPARE)
 232                         N = MEMORY[pc+2] - MEMORY[pc+3];
 233                         if (MEMORY[pc+1] => 0xffffffff) { //overflow (unsigned signed)?
 234                                 C = 0x00000001;
 235                                 pc = pc + 1;
 236                                 break;
 237                         }
 238                         if (MEMORY[pc+1] = 0x00000000) { //zero?
 239                                 Z = 0x00000001;
 240                                 pc = pc + 1;
 241                                 break;
 242                         }
 243                         //<flags> = op_1 - op_2  ; result is not stored, only flags updated
 244                         pc = pc + 1;
 245                         break;
 246         }
 247 }