rosapps/devutils/cputointel/m68k/M68kBrain.c

   1
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include "M68kBrain.h"
   5 #include "m68k.h"
   6 #include "../misc.h"
   7
   8 /* retun
   9  * 0 = Ok
  10  * 1 = unimplemt
  11  * 2 = Unkonwn Opcode
  12  * 3 = can not open read file
  13  * 4 = can not open write file
  14  * 5 = can not seek to end of read file
  15  * 6 = can not get the file size of the read file
  16  * 7 = read file size is Zero
  17  * 8 = can not alloc memory
  18  * 9 = can not read file
  19  */
  20
  21 CPU_INT M68KBrain(   CPU_BYTE *cpu_buffer,
  22                      CPU_UNINT cpu_pos,
  23                      CPU_UNINT cpu_size,
  24                      CPU_UNINT BaseAddress,
  25                      CPU_UNINT cpuarch,
  26                      FILE *outfp)
  27 {
  28     CPU_UNINT cpu_oldpos;
  29     CPU_INT cpuint;
  30     CPU_INT retcode = 0;
  31     CPU_INT retsize;
  32
  33     /* now we start the process */
  34     while (cpu_pos<cpu_size)
  35     {
  36         cpu_oldpos = cpu_pos;
  37
  38         cpuint = cpu_buffer[cpu_pos];
  39
  40         /* Abcd */
  41         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Abcd))) == ConvertBitToByte(cpuM68kInit_Abcd))
  42         {
  43             retsize = M68k_Abcd( outfp, cpu_buffer, cpu_pos, cpu_size,
  44                                  BaseAddress, cpuarch);
  45             if (retsize<0)
  46                  retcode = 1;
  47             else
  48                  cpu_pos += retsize;
  49         }
  50         /* Add */
  51         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Add))) == ConvertBitToByte(cpuM68kInit_Add))
  52         {
  53             retsize = M68k_Add( outfp, cpu_buffer, cpu_pos, cpu_size,
  54                                 BaseAddress, cpuarch);
  55             if (retsize<0)
  56                  retcode = 1;
  57             else
  58                  cpu_pos += retsize;
  59         }
  60         /* Addi */
  61         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Addi))) == ConvertBitToByte(cpuM68kInit_Addi))
  62         {
  63             retsize = M68k_Addi( outfp, cpu_buffer, cpu_pos, cpu_size,
  64                                  BaseAddress, cpuarch);
  65             if (retsize<0)
  66                  retcode = 1;
  67             else
  68                  cpu_pos += retsize;
  69         }
  70         /* Addq */
  71         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Addq))) == ConvertBitToByte(cpuM68kInit_Addq))
  72         {
  73             retsize = M68k_Addq( outfp, cpu_buffer, cpu_pos, cpu_size,
  74                                  BaseAddress, cpuarch);
  75             if (retsize<0)
  76                  retcode = 1;
  77             else
  78                  cpu_pos += retsize;
  79         }
  80         /* Addx */
  81         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Addx))) == ConvertBitToByte(cpuM68kInit_Addx))
  82         {
  83             retsize = M68k_Addx( outfp, cpu_buffer, cpu_pos, cpu_size,
  84                                  BaseAddress, cpuarch);
  85             if (retsize<0)
  86                  retcode = 1;
  87             else
  88                  cpu_pos += retsize;
  89         }
  90         /* And */
  91         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_And))) == ConvertBitToByte(cpuM68kInit_And))
  92         {
  93             retsize = M68k_Add( outfp, cpu_buffer, cpu_pos, cpu_size,
  94                                 BaseAddress, cpuarch);
  95             if (retsize<0)
  96                  retcode = 1;
  97             else
  98                  cpu_pos += retsize;
  99         }
 100         /* Andi */
 101         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Andi))) == ConvertBitToByte(cpuM68kInit_Andi))
 102         {
 103             retsize = M68k_Andi( outfp, cpu_buffer, cpu_pos, cpu_size,
 104                                  BaseAddress, cpuarch);
 105             if (retsize<0)
 106                  retcode = 1;
 107             else
 108                  cpu_pos += retsize;
 109         }
 110         /* AndToCCR */
 111         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_AndToCCRF))) == ConvertBitToByte(cpuM68kInit_AndToCCRF))
 112         {
 113             cpuint = cpu_buffer[cpu_pos+1];
 114             if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_AndToCCRS))) == ConvertBitToByte(cpuM68kInit_AndToCCRS))
 115             {
 116                 cpu_pos++;
 117                 retsize = M68k_AndToCCR( outfp, cpu_buffer, cpu_pos, cpu_size,
 118                                          BaseAddress, cpuarch);
 119                 if (retsize<0)
 120                     retcode = 1;
 121                 else
 122                     cpu_pos += retsize;
 123             }
 124             else
 125             {
 126                 cpuint = cpu_buffer[cpu_pos];
 127             }
 128         }
 129
 130         /* Bhi */
 131         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bhi))) == ConvertBitToByte(cpuM68kInit_Bhi))
 132         {
 133             retsize = M68k_Bhi( outfp, cpu_buffer, cpu_pos, cpu_size,
 134                                 BaseAddress, cpuarch);
 135             if (retsize<0)
 136                  retcode = 1;
 137             else
 138                  cpu_pos += retsize;
 139         }
 140
 141         /* Bls */
 142         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bls))) == ConvertBitToByte(cpuM68kInit_Bls))
 143         {
 144             retsize = M68k_Bls( outfp, cpu_buffer, cpu_pos, cpu_size,
 145                                 BaseAddress, cpuarch);
 146             if (retsize<0)
 147                  retcode = 1;
 148             else
 149                  cpu_pos += retsize;
 150         }
 151
 152         /* Bcc */
 153         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bcc))) == ConvertBitToByte(cpuM68kInit_Bcc))
 154         {
 155             retsize = M68k_Bcc( outfp, cpu_buffer, cpu_pos, cpu_size,
 156                                 BaseAddress, cpuarch);
 157             if (retsize<0)
 158                  retcode = 1;
 159             else
 160                  cpu_pos += retsize;
 161         }
 162
 163         /* Bcs */
 164         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bcs))) == ConvertBitToByte(cpuM68kInit_Bcs))
 165         {
 166             retsize = M68k_Bcs( outfp, cpu_buffer, cpu_pos, cpu_size,
 167                                 BaseAddress, cpuarch);
 168             if (retsize<0)
 169                  retcode = 1;
 170             else
 171                  cpu_pos += retsize;
 172         }
 173
 174         /* Bne */
 175         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bne))) == ConvertBitToByte(cpuM68kInit_Bne))
 176         {
 177             retsize = M68k_Bne( outfp, cpu_buffer, cpu_pos, cpu_size,
 178                                 BaseAddress, cpuarch);
 179             if (retsize<0)
 180                  retcode = 1;
 181             else
 182                  cpu_pos += retsize;
 183         }
 184
 185         /* Beq */
 186         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Beq))) == ConvertBitToByte(cpuM68kInit_Beq))
 187         {
 188             retsize = M68k_Beq( outfp, cpu_buffer, cpu_pos, cpu_size,
 189                                 BaseAddress, cpuarch);
 190             if (retsize<0)
 191                  retcode = 1;
 192             else
 193                  cpu_pos += retsize;
 194         }
 195
 196         /* Bvc */
 197         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bvc))) == ConvertBitToByte(cpuM68kInit_Bvc))
 198         {
 199             retsize = M68k_Bvc( outfp, cpu_buffer, cpu_pos, cpu_size,
 200                                 BaseAddress, cpuarch);
 201             if (retsize<0)
 202                  retcode = 1;
 203             else
 204                  cpu_pos += retsize;
 205         }
 206
 207         /* Bvs */
 208         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bvs))) == ConvertBitToByte(cpuM68kInit_Bvs))
 209         {
 210             retsize = M68k_Bvs( outfp, cpu_buffer, cpu_pos, cpu_size,
 211                                 BaseAddress, cpuarch);
 212             if (retsize<0)
 213                  retcode = 1;
 214             else
 215                  cpu_pos += retsize;
 216         }
 217
 218         /* Bpl */
 219         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bpl))) == ConvertBitToByte(cpuM68kInit_Bpl))
 220         {
 221             retsize = M68k_Bpl( outfp, cpu_buffer, cpu_pos, cpu_size,
 222                                 BaseAddress, cpuarch);
 223             if (retsize<0)
 224                  retcode = 1;
 225             else
 226                  cpu_pos += retsize;
 227         }
 228
 229         /* Bmi */
 230         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bmi))) == ConvertBitToByte(cpuM68kInit_Bmi))
 231         {
 232             retsize = M68k_Bmi( outfp, cpu_buffer, cpu_pos, cpu_size,
 233                                 BaseAddress, cpuarch);
 234             if (retsize<0)
 235                  retcode = 1;
 236             else
 237                  cpu_pos += retsize;
 238         }
 239
 240         /* Bge */
 241         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bge))) == ConvertBitToByte(cpuM68kInit_Bge))
 242         {
 243             retsize = M68k_Bge( outfp, cpu_buffer, cpu_pos, cpu_size,
 244                                 BaseAddress, cpuarch);
 245             if (retsize<0)
 246                  retcode = 1;
 247             else
 248                  cpu_pos += retsize;
 249         }
 250
 251         /* Blt */
 252         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Blt))) == ConvertBitToByte(cpuM68kInit_Blt))
 253         {
 254             retsize = M68k_Blt( outfp, cpu_buffer, cpu_pos, cpu_size,
 255                                 BaseAddress, cpuarch);
 256             if (retsize<0)
 257                  retcode = 1;
 258             else
 259                  cpu_pos += retsize;
 260         }
 261
 262         /* Bgt */
 263         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bgt))) == ConvertBitToByte(cpuM68kInit_Bgt))
 264         {
 265             retsize = M68k_Bgt( outfp, cpu_buffer, cpu_pos, cpu_size,
 266                                 BaseAddress, cpuarch);
 267             if (retsize<0)
 268                  retcode = 1;
 269             else
 270                  cpu_pos += retsize;
 271         }
 272
 273         /* Ble */
 274         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Ble))) == ConvertBitToByte(cpuM68kInit_Ble))
 275         {
 276             retsize = M68k_Ble( outfp, cpu_buffer, cpu_pos, cpu_size,
 277                                 BaseAddress, cpuarch);
 278             if (retsize<0)
 279                  retcode = 1;
 280             else
 281                  cpu_pos += retsize;
 282         }
 283
 284         /* Found all Opcode and breakout and return no error found */
 285         if (cpu_pos >=cpu_size)
 286         {
 287             break;
 288         }
 289
 290         /* Check if we have found a cpu opcode */
 291         if (cpu_oldpos == cpu_pos)
 292         {
 293             if (retcode == 0)
 294             {
 295                 /* no unimplement error where found so we return a msg for unknown opcode */
 296                 printf("Unkonwn Opcode found at 0x%8x opcode 0x%2x\n",cpu_oldpos+BaseAddress,(unsigned int)cpu_buffer[cpu_oldpos]);
 297                 retcode = 2;
 298             }
 299         }
 300
 301         /* Erorro Found ? */
 302         if (retcode!=0)
 303         {
 304             /* Erorro Found break and return the error code */
 305             break;
 306         }
 307     }
 308     return retcode;
 309 }