rosapps/devutils/cputointel/From/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 /*
   9  * DummyBrain is example how you create you own cpu brain to translate from
  10  * cpu to intel assembler, I have not add DummyBrain to the loader it is not
  11  * need it in our example. When you write you own brain, it must be setup in
  12  * misc.c function LoadPFileImage and PEFileStart, PEFileStart maybe does not
  13  * need the brain you have writen so you do not need setup it there then.
  14  *
  15  * input param:
  16  *         cpu_buffer   : the memory buffer with loaded program we whant translate
  17  *         cpu_pos      : the positions in the cpu_buffer
  18  *         cpu_size     : the alloced memory size of the cpu_buffer
  19  *         BaseAddress  : the virtual memory address we setup to use.
  20  *         cpuarch      : the sub arch for the brain, example if it exists more one
  21  *                        cpu with same desgin but few other opcode or extend opcode
  22  *         outfp        : the output file pointer
  23  *
  24  * return value
  25  *         0            : Ok
  26  *         1            : unimplemt
  27  *         2            : Unkonwn Opcode
  28  *         3            : unimplement cpu
  29  *         4            : unknown machine
  30  */
  31
  32 CPU_INT M68KBrain(   CPU_BYTE *cpu_buffer,
  33                      CPU_UNINT cpu_pos,
  34                      CPU_UNINT cpu_size,
  35                      CPU_UNINT BaseAddress,
  36                      CPU_UNINT cpuarch,
  37                      FILE *outfp)
  38 {
  39     CPU_UNINT cpu_oldpos;
  40     CPU_INT cpuint;
  41     CPU_INT retcode = 0;
  42     CPU_INT retsize;
  43
  44     /* now we start the process */
  45     while (cpu_pos<cpu_size)
  46     {
  47         cpu_oldpos = cpu_pos;
  48
  49         cpuint = cpu_buffer[cpu_pos];
  50
  51         /* Abcd */
  52         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Abcd))) == ConvertBitToByte(cpuM68kInit_Abcd))
  53         {
  54             retsize = M68k_Abcd( outfp, cpu_buffer, cpu_pos, cpu_size,
  55                                  BaseAddress, cpuarch);
  56             if (retsize<0)
  57                  retcode = 1;
  58             else
  59                  cpu_pos += retsize;
  60         }
  61         /* Add */
  62         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Add))) == ConvertBitToByte(cpuM68kInit_Add))
  63         {
  64             retsize = M68k_Add( outfp, cpu_buffer, cpu_pos, cpu_size,
  65                                 BaseAddress, cpuarch);
  66             if (retsize<0)
  67                  retcode = 1;
  68             else
  69                  cpu_pos += retsize;
  70         }
  71         /* Addi */
  72         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Addi))) == ConvertBitToByte(cpuM68kInit_Addi))
  73         {
  74             retsize = M68k_Addi( outfp, cpu_buffer, cpu_pos, cpu_size,
  75                                  BaseAddress, cpuarch);
  76             if (retsize<0)
  77                  retcode = 1;
  78             else
  79                  cpu_pos += retsize;
  80         }
  81         /* Addq */
  82         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Addq))) == ConvertBitToByte(cpuM68kInit_Addq))
  83         {
  84             retsize = M68k_Addq( outfp, cpu_buffer, cpu_pos, cpu_size,
  85                                  BaseAddress, cpuarch);
  86             if (retsize<0)
  87                  retcode = 1;
  88             else
  89                  cpu_pos += retsize;
  90         }
  91         /* Addx */
  92         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Addx))) == ConvertBitToByte(cpuM68kInit_Addx))
  93         {
  94             retsize = M68k_Addx( outfp, cpu_buffer, cpu_pos, cpu_size,
  95                                  BaseAddress, cpuarch);
  96             if (retsize<0)
  97                  retcode = 1;
  98             else
  99                  cpu_pos += retsize;
 100         }
 101         /* And */
 102         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_And))) == ConvertBitToByte(cpuM68kInit_And))
 103         {
 104             retsize = M68k_Add( outfp, cpu_buffer, cpu_pos, cpu_size,
 105                                 BaseAddress, cpuarch);
 106             if (retsize<0)
 107                  retcode = 1;
 108             else
 109                  cpu_pos += retsize;
 110         }
 111         /* Andi */
 112         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Andi))) == ConvertBitToByte(cpuM68kInit_Andi))
 113         {
 114             retsize = M68k_Andi( outfp, cpu_buffer, cpu_pos, cpu_size,
 115                                  BaseAddress, cpuarch);
 116             if (retsize<0)
 117                  retcode = 1;
 118             else
 119                  cpu_pos += retsize;
 120         }
 121         /* AndToCCR */
 122         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_AndToCCRF))) == ConvertBitToByte(cpuM68kInit_AndToCCRF))
 123         {
 124             cpuint = cpu_buffer[cpu_pos+1];
 125             if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_AndToCCRS))) == ConvertBitToByte(cpuM68kInit_AndToCCRS))
 126             {
 127                 cpu_pos++;
 128                 retsize = M68k_AndToCCR( outfp, cpu_buffer, cpu_pos, cpu_size,
 129                                          BaseAddress, cpuarch);
 130                 if (retsize<0)
 131                     retcode = 1;
 132                 else
 133                     cpu_pos += retsize;
 134             }
 135             else
 136             {
 137                 cpuint = cpu_buffer[cpu_pos];
 138             }
 139         }
 140
 141         /* Bhi */
 142         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bhi))) == ConvertBitToByte(cpuM68kInit_Bhi))
 143         {
 144             retsize = M68k_Bhi( 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         /* Bls */
 153         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bls))) == ConvertBitToByte(cpuM68kInit_Bls))
 154         {
 155             retsize = M68k_Bls( 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         /* Bcc */
 164         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bcc))) == ConvertBitToByte(cpuM68kInit_Bcc))
 165         {
 166             retsize = M68k_Bcc( 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         /* Bcs */
 175         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bcs))) == ConvertBitToByte(cpuM68kInit_Bcs))
 176         {
 177             retsize = M68k_Bcs( 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         /* Bne */
 186         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bne))) == ConvertBitToByte(cpuM68kInit_Bne))
 187         {
 188             retsize = M68k_Bne( 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         /* Beq */
 197         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Beq))) == ConvertBitToByte(cpuM68kInit_Beq))
 198         {
 199             retsize = M68k_Beq( 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         /* Bvc */
 208         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bvc))) == ConvertBitToByte(cpuM68kInit_Bvc))
 209         {
 210             retsize = M68k_Bvc( 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         /* Bvs */
 219         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bvs))) == ConvertBitToByte(cpuM68kInit_Bvs))
 220         {
 221             retsize = M68k_Bvs( 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         /* Bpl */
 230         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bpl))) == ConvertBitToByte(cpuM68kInit_Bpl))
 231         {
 232             retsize = M68k_Bpl( 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         /* Bmi */
 241         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bmi))) == ConvertBitToByte(cpuM68kInit_Bmi))
 242         {
 243             retsize = M68k_Bmi( 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         /* Bge */
 252         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bge))) == ConvertBitToByte(cpuM68kInit_Bge))
 253         {
 254             retsize = M68k_Bge( 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         /* Blt */
 263         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Blt))) == ConvertBitToByte(cpuM68kInit_Blt))
 264         {
 265             retsize = M68k_Blt( 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         /* Bgt */
 274         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Bgt))) == ConvertBitToByte(cpuM68kInit_Bgt))
 275         {
 276             retsize = M68k_Bgt( 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         /* Ble */
 285         if ((cpuint - (cpuint & GetMaskByte(cpuM68kInit_Ble))) == ConvertBitToByte(cpuM68kInit_Ble))
 286         {
 287             retsize = M68k_Ble( outfp, cpu_buffer, cpu_pos, cpu_size,
 288                                 BaseAddress, cpuarch);
 289             if (retsize<0)
 290                  retcode = 1;
 291             else
 292                  cpu_pos += retsize;
 293         }
 294
 295         /* Found all Opcode and breakout and return no error found */
 296         if (cpu_pos >=cpu_size)
 297         {
 298             break;
 299         }
 300
 301         /* Check if we have found a cpu opcode */
 302         if (cpu_oldpos == cpu_pos)
 303         {
 304             if (retcode == 0)
 305             {
 306                 /* no unimplement error where found so we return a msg for unknown opcode */
 307                 printf("Unkonwn Opcode found at 0x%8x opcode 0x%2x\n",cpu_oldpos+BaseAddress,(unsigned int)cpu_buffer[cpu_oldpos]);
 308                 retcode = 2;
 309             }
 310         }
 311
 312         /* Erorro Found ? */
 313         if (retcode!=0)
 314         {
 315             /* Erorro Found break and return the error code */
 316             break;
 317         }
 318     }
 319     return retcode;
 320 }