API tools faq
paste
Advertisement
Twili

badn64.c

Twili
Oct 17th, 2017
188
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 23.85 KB | None | 0 0
raw download clone embed print report
  1. #include <badn64.h>
  2. #include <stdio.h>
  3.  
  4. /*
  5. RAM: rambus dynamic Random-Access Memory
  6. REG: rdram REGisters
  7. RCP: Reality CoProcessor
  8. LEO: LEO registers (64DD)
  9. IPL: Initial Program Load (64DD)
  10. STA: STAtic ram
  11. ROM: ROM (cartridge)
  12. PIF: Program Information File
  13. */
  14.  
  15. /* enumerated memory segments */
  16. enum SEGMENT{RAM, REG, RCP, LEO, IPL, STA, ROM, PIF};
  17.  
  18. /* lookup table for the purpose of translating n64 memory segments to our segments */
  19. BYTE LUT[0x20]=
  20. {/* 0x00           0x03 0x04 0x05 0x06      0x08                                    */
  21.      RAM,   0,   0, REG, RCP, LEO, IPL,   0, STA,   0,   0,   0,   0,   0,   0,   0,
  22.      
  23.  /* 0x10                                                                       0x1F */
  24.      ROM,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, PIF
  25. };
  26.  
  27. WORD loop;
  28.  
  29. /* function for sign extension of immediate values */
  30. WORD extend(HALF imm);
  31. WORD extend(HALF imm)
  32. {
  33.      WORD extended;
  34.      if(sign(imm)==0x8000)
  35.      {
  36.           extended=0xffff0000|imm;
  37.      }
  38.      else
  39.      {
  40.           extended=imm;
  41.      }
  42.      return extended;
  43. }
  44.  
  45. /* function for reading 32 bits */
  46. WORD read32(BYTE *mem[8], WORD ptr);
  47. WORD read32(BYTE *mem[8], WORD ptr)
  48. {
  49.      BYTE temp=(ptr>>24)&0x1f;
  50.      switch(LUT[temp])
  51.      {
  52.           case REG:
  53.                ptr&=0x0fffff;
  54.                break;
  55.           case PIF:
  56.                ptr&=0x3fffff;
  57.                break;
  58.           default:
  59.                ptr&=0xffffff;
  60.                break;
  61.      }
  62.      return (WORD)((mem[LUT[temp]][ptr]<<24)|(mem[LUT[temp]][ptr+1]<<16)|(mem[LUT[temp]][ptr+2]<<8)|mem[LUT[temp]][ptr+3]);
  63. }
  64.  
  65. void handle_pi(BYTE *mem[8], WORD ptr);
  66. void handle_pi(BYTE *mem[8], WORD ptr)
  67. {
  68.      WORD dram_addr, cart_addr, rd_len, wr_len;
  69.      dram_addr=read32(mem,0xa4600000);
  70.      cart_addr=read32(mem,0xa4600004)&0xffffff;
  71.      rd_len=1+read32(mem,0xa4600008);
  72.      wr_len=1+read32(mem,0xa460000c);
  73.      if(ptr==0x600008)
  74.      {
  75.      }
  76.      else if(ptr==0x60000c)
  77.      {
  78.           for(loop=0;loop<wr_len;loop+=1)
  79.           {
  80.                mem[RAM][dram_addr+loop]=mem[ROM][cart_addr+loop];
  81.           }
  82.      }
  83. }
  84.  
  85. /* function for writing 32 bits */
  86. void write32(BYTE *mem[8], WORD ptr, WORD val);
  87. void write32(BYTE *mem[8], WORD ptr, WORD val)
  88. {
  89.      BYTE handle=9;
  90.      BYTE temp=(ptr>>24)&0x1f;
  91.      switch(LUT[temp])
  92.      {
  93.           case REG:
  94.                ptr&=0x0fffff;
  95.                break;
  96.           case RCP:
  97.                handle=(ptr&0xf00000)>>20;
  98.                ptr&=0xffffff;
  99.                break;
  100.           case PIF:
  101.                ptr&=0x3fffff;
  102.                break;
  103.           default:
  104.                ptr&=0xffffff;
  105.                break;
  106.      }
  107.      mem[LUT[temp]][ptr]=(val>>24)&0xff;
  108.      mem[LUT[temp]][ptr+1]=(val>>16)&0xff;
  109.      mem[LUT[temp]][ptr+2]=(val>>8)&0xff;
  110.      mem[LUT[temp]][ptr+3]=val&0xff;
  111.      switch(handle)
  112.      {
  113.           case 6:
  114.                handle_pi(mem,ptr);
  115.                break;
  116.      }
  117. }
  118.  
  119. int main(int argc, char **argv)
  120. {
  121.      const char names[32][3]=
  122.      {
  123.           "r0", "at", "v0", "v1",
  124.           "a0", "a1", "a2", "a3",
  125.           "t0", "t1", "t2", "t3",
  126.           "t4", "t5", "t6", "t7",
  127.           "s0", "s1", "s2", "s3",
  128.           "s4", "s5", "s6", "s7",
  129.           "t8", "t9", "k0", "k1",
  130.           "gp", "sp", "fp", "ra"
  131.      };
  132.      BYTE *mem[8], delay=0, depth=0;
  133.      WORD CPU[32]={0},CP0[32]={0},pc=0xa4000040,tick=0,ticks,inst;
  134.      unsigned long long sixtyfour;
  135.      WORD hi, lo;
  136.      FILE *cart=fopen(argv[1],"rb");
  137.      fseek(cart,0,SEEK_END);
  138.      loop=ftell(cart);
  139.      WORD sizes[8]=
  140.      {
  141.           0x800000, /* RAM */
  142.           0x100000, /* REG */
  143.           0x80001c, /* RCP */
  144.           0x0005c0, /* LEO */
  145.           0x400000, /* IPL */
  146.           0x008000, /* STA */
  147.           loop,     /* ROM */
  148.           0x000800  /* PIF */
  149.      };
  150.      for(loop=0;loop<8;loop+=1)
  151.      {
  152.           mem[loop]=(BYTE*)calloc(sizes[loop],1); /* allocate our memory segments and init to zero */
  153.      }
  154.      fseek(cart,0,SEEK_SET);
  155.      fread(mem[ROM],1,sizes[ROM],cart);
  156.      fclose(cart);
  157.      for(loop=0;loop<0xfc0;loop+=1)
  158.      {
  159.           mem[RCP][0x40+loop]=mem[ROM][0x40+loop];
  160.      }
  161.      write32(mem,0xa4001000,0x3c0dbfc0); /* SP IMEM +0 */
  162.      write32(mem,0xa4001004,0x8da807fc); /* SP IMEM +4 */
  163.      write32(mem,0xa4001008,0x25ad07c0); /* SP IMEM +8 */
  164.      write32(mem,0xa400100c,0x31080080); /* SP IMEM +0xC */
  165.      write32(mem,0xa4001010,0x5500fffc); /* SP IMEM +0x10*/
  166.      write32(mem,0xa4001014,0x3c0dbfc0); /* SP IMEM +0x14*/
  167.      write32(mem,0xa4001018,0x8da80024); /* SP IMEM +0x18*/
  168.      write32(mem,0xa400101c,0x3c0bb000); /* SP IMEM +0x1C*/
  169.      write32(mem,0xa4040010,1);          /* SP status */
  170.      write32(mem,0xa4300004,0x02020102); /* MI version*/
  171.      write32(mem,0xa4600014,0x40);       /* PI dom1 latency */
  172.      write32(mem,0xa4600018,0x12);       /* PI dom1 pulse width */
  173.      write32(mem,0xa460001c,7);          /* PI dom1 page size */
  174.      write32(mem,0xa4600020,3);          /* PI dom1 dom1 release*/
  175.      CPU[S4]=1;                          /* tv type */
  176.      CPU[S6]=0x3f;                       /* seed */
  177.      CPU[T3]=pc;
  178.      CPU[SP]=0xa4001ff0;                 /* Stack Pointer */
  179.      CPU[RA]=0xa4001550;                 /* Return Address*/
  180.      /*printf("How many ticks? ");*/
  181.      /*scanf("%d",&ticks);*/
  182.      while(tick<0xffffffff)
  183.      {
  184.           if(pc==read32(mem,0xb0000008))
  185.           {
  186.                printf("%10d\n",tick);
  187.                break;
  188.           }
  189.           inst=read32(mem,pc);
  190.           switch(op(inst))
  191.           {
  192.                case SPECIAL:
  193.                     switch(funct(inst))
  194.                     {
  195.                          case SLL:
  196.                               CPU[rd(inst)]=CPU[rt(inst)]<<sa(inst);
  197.                               break;
  198.                          case SRL:
  199.                               CPU[rd(inst)]=CPU[rt(inst)]>>sa(inst);
  200.                               break;
  201.                          case SLLV:
  202.                               CPU[rd(inst)]=CPU[rt(inst)]<<(CPU[rs(inst)]&0x1f);
  203.                               break;
  204.                          case SRLV:
  205.                               CPU[rd(inst)]=CPU[rt(inst)]>>(CPU[rs(inst)]&0x1f);
  206.                               break;
  207.                          case JR:
  208.                               if(delay==0)
  209.                               {
  210.                                    delay=1;
  211.                               }
  212.                               else if(delay==3)
  213.                               {
  214.                                    pc=CPU[rs(inst)]-4;
  215.                                    if(pc==CPU[RA]-4)
  216.                                    {
  217.                                         depth-=1;
  218.                                         printf("%10d %08x: ",tick+1,pc+4);
  219.                                         for(loop=0;loop<depth;loop+=1)
  220.                                         {
  221.                                              printf(" ");
  222.                                         }
  223.                                         printf("returned from function\n");
  224.                                    }
  225.                                    delay=0;
  226.                               }
  227.                               break;
  228.                          case JALR:
  229.                               if(delay==0)
  230.                               {
  231.                                    CPU[rd(inst)]=pc+8;
  232.                                    delay=1;
  233.                               }
  234.                               else if(delay==3)
  235.                               {
  236.                                    pc=CPU[rs(inst)]-4;
  237.                                    delay=0;
  238.                               }
  239.                               break;
  240.                          case MFLO:
  241.                               CPU[rd(inst)]=lo;
  242.                               break;
  243.                          case MULTU:
  244.                               sixtyfour=CPU[rs(inst)]*CPU[rt(inst)];
  245.                               hi=sixtyfour>>32;
  246.                               lo=sixtyfour&0xffffffff;
  247.                               break;
  248.                          case ADD:
  249.                               CPU[rd(inst)]=CPU[rs(inst)]+CPU[rt(inst)];
  250.                               break;
  251.                          case ADDU:
  252.                               CPU[rd(inst)]=CPU[rs(inst)]+CPU[rt(inst)];
  253.                               break;
  254.                          case SUBU:
  255.                               CPU[rd(inst)]=CPU[rs(inst)]-CPU[rt(inst)];
  256.                               break;
  257.                          case AND:
  258.                               CPU[rd(inst)]=CPU[rs(inst)]&CPU[rt(inst)];
  259.                               break;
  260.                          case OR:
  261.                               CPU[rd(inst)]=CPU[rs(inst)]|CPU[rt(inst)];
  262.                               break;
  263.                          case XOR:
  264.                               CPU[rd(inst)]=CPU[rs(inst)]^CPU[rt(inst)];
  265.                               break;
  266.                          case SLT:
  267.                               CPU[rd(inst)]=0;
  268.                               if((int)(CPU[rs(inst)])<(int)(CPU[rt(inst)]))
  269.                               {
  270.                                    CPU[rd(inst)]=1;
  271.                               }
  272.                               break;
  273.                          case SLTU:
  274.                               CPU[rd(inst)]=0;
  275.                               if(CPU[rs(inst)]<CPU[rt(inst)])
  276.                               {
  277.                                    CPU[rd(inst)]=1;
  278.                               }
  279.                               break;
  280.                     }
  281.                     break;
  282.                case REGIMM:
  283.                     switch(rt(inst))
  284.                     {
  285.                          case BLTZ:
  286.                               if(delay==0)
  287.                               {
  288.                                    delay=1;
  289.                               }
  290.                               else if(delay==3)
  291.                               {
  292.                                    if(CPU[rs(inst)]<0)
  293.                                    {
  294.                                         pc+=extend(imm(inst)<<2)-4;
  295.                                    }
  296.                                    pc+=4;
  297.                                    delay=0;
  298.                               }
  299.                               break;
  300.                          case BGEZ:
  301.                               if(delay==0)
  302.                               {
  303.                                    delay=1;
  304.                               }
  305.                               else if(delay==3)
  306.                               {
  307.                                    if(CPU[rs(inst)]>=0)
  308.                                    {
  309.                                         pc+=extend(imm(inst)<<2)-4;
  310.                                    }
  311.                                    pc+=4;
  312.                                    delay=0;
  313.                               }
  314.                               break;
  315.                          case BLTZL:
  316.                               if(delay==0)
  317.                               {
  318.                                    if(CPU[rs(inst)]<0)
  319.                                    {
  320.                                         delay=1;
  321.                                    }
  322.                                    else
  323.                                    {
  324.                                         pc+=4;
  325.                                    }
  326.                               }
  327.                               else if(delay==3)
  328.                               {
  329.                                    pc+=extend(imm(inst)<<2);
  330.                                    delay=0;
  331.                               }
  332.                               break;
  333.                          case BGEZL:
  334.                               if(delay==0)
  335.                               {
  336.                                    if(CPU[rs(inst)]>=0)
  337.                                    {
  338.                                         delay=1;
  339.                                    }
  340.                                    else
  341.                                    {
  342.                                         pc+=4;
  343.                                    }
  344.                               }
  345.                               else if(delay==3)
  346.                               {
  347.                                    pc+=extend(imm(inst)<<2);
  348.                                    delay=0;
  349.                               }
  350.                               break;
  351.                          case BLTZAL:
  352.                               if(delay==0)
  353.                               {
  354.                                    CPU[RA]=pc+8;
  355.                                    delay=1;
  356.                               }
  357.                               else if(delay==3)
  358.                               {
  359.                                    if(CPU[rs(inst)]<0)
  360.                                    {
  361.                                         pc+=extend(imm(inst)<<2)-4;
  362.                                    }
  363.                                    pc+=4;
  364.                                    delay=0;
  365.                               }
  366.                               break;
  367.                          case BGEZAL:
  368.                               if(delay==0)
  369.                               {
  370.                                    CPU[RA]=pc+8;
  371.                                    delay=1;
  372.                               }
  373.                               else if(delay==3)
  374.                               {
  375.                                    if(CPU[rs(inst)]>=0)
  376.                                    {
  377.                                         pc+=extend(imm(inst)<<2)-4;
  378.                                    }
  379.                                    pc+=4;
  380.                                    delay=0;
  381.                               }
  382.                               break;
  383.                          case BLTZALL:
  384.                               if(delay==0)
  385.                               {
  386.                                    CPU[RA]=pc+8;
  387.                                    if(CPU[rs(inst)]<0)
  388.                                    {
  389.                                         delay=1;
  390.                                    }
  391.                                    else
  392.                                    {
  393.                                         pc+=4;
  394.                                    }
  395.                               }
  396.                               else if(delay==3)
  397.                               {
  398.                                    pc+=extend(imm(inst)<<2);
  399.                                    delay=0;
  400.                               }
  401.                               break;
  402.                          case BGEZALL:
  403.                               if(delay==0)
  404.                               {
  405.                                    CPU[RA]=pc+8;
  406.                                    if(CPU[rs(inst)]>=0)
  407.                                    {
  408.                                         delay=1;
  409.                                    }
  410.                                    else
  411.                                    {
  412.                                         pc+=4;
  413.                                    }
  414.                               }
  415.                               else if(delay==3)
  416.                               {
  417.                                    pc+=extend(imm(inst)<<2);
  418.                                    delay=0;
  419.                               }
  420.                               break;
  421.                     }
  422.                     break;
  423.                case J:
  424.                     if(delay==0)
  425.                     {
  426.                          delay=1;
  427.                     }
  428.                     else if(delay==3)
  429.                     {
  430.                          pc=((pc&0xf0000000)|target(inst))-4;
  431.                          delay=0;
  432.                     }
  433.                     break;
  434.                case JAL:
  435.                     if(delay==0)
  436.                     {
  437.                          CPU[RA]=pc+8;
  438.                          delay=1;
  439.                     }
  440.                     else if(delay==3)
  441.                     {
  442.                          printf("%10d %08x: ",tick+1,pc);
  443.                          for(loop=0;loop<depth;loop+=1)
  444.                          {
  445.                               printf(" ");
  446.                          }
  447.                          pc=((pc&0xf0000000)|target(inst))-4;
  448.                          printf("jumped inside function (%08x)\n",pc+4);
  449.                          depth+=1;
  450.                          delay=0;
  451.                     }
  452.                     break;
  453.                case BEQ:
  454.                     if(delay==0)
  455.                     {
  456.                          delay=1;
  457.                     }
  458.                     else if(delay==3)
  459.                     {
  460.                          if(CPU[rs(inst)]==CPU[rt(inst)])
  461.                          {
  462.                               pc+=extend(imm(inst)<<2)-4;
  463.                          }
  464.                          pc+=4;
  465.                          delay=0;
  466.                     }
  467.                     break;
  468.                case BNE:
  469.                     if(delay==0)
  470.                     {
  471.                          delay=1;
  472.                     }
  473.                     else if(delay==3)
  474.                     {
  475.                          if(CPU[rs(inst)]!=CPU[rt(inst)])
  476.                          {
  477.                               pc+=extend(imm(inst)<<2)-4;
  478.                          }
  479.                          pc+=4;
  480.                          delay=0;
  481.                     }
  482.                     break;
  483.                case BLEZ:
  484.                     if(delay==0)
  485.                     {
  486.                          delay=1;
  487.                     }
  488.                     else if(delay==3)
  489.                     {
  490.                          if(CPU[rs(inst)]<=0)
  491.                          {
  492.                               pc+=extend(imm(inst)<<2)-4;
  493.                          }
  494.                          pc+=4;
  495.                          delay=0;
  496.                     }
  497.                     break;
  498.                case BGTZ:
  499.                     if(delay==0)
  500.                     {
  501.                          delay=1;
  502.                     }
  503.                     else if(delay==3)
  504.                     {
  505.                          if(CPU[rs(inst)]>0)
  506.                          {
  507.                               pc+=extend(imm(inst)<<2)-4;
  508.                          }
  509.                          pc+=4;
  510.                          delay=0;
  511.                     }
  512.                     break;
  513.                case ADDI:
  514.                     CPU[rt(inst)]=CPU[rs(inst)]+extend(imm(inst));
  515.                     break;
  516.                case ADDIU:
  517.                     CPU[rt(inst)]=CPU[rs(inst)]+extend(imm(inst));
  518.                     break;
  519.                case SLTI:
  520.                     CPU[rt(inst)]=0;
  521.                     if((int)(CPU[rs(inst)])<(int)(extend(imm(inst))))
  522.                     {
  523.                          CPU[rt(inst)]=1;
  524.                     }
  525.                     break;
  526.                case SLTIU:
  527.                     CPU[rt(inst)]=0;
  528.                     if(CPU[rs(inst)]<extend(imm(inst)))
  529.                     {
  530.                          CPU[rt(inst)]=1;
  531.                     }
  532.                     break;
  533.                case ANDI:
  534.                     CPU[rt(inst)]=CPU[rs(inst)]&imm(inst);
  535.                     break;
  536.                case ORI:
  537.                     CPU[rt(inst)]=CPU[rs(inst)]|imm(inst);
  538.                     break;
  539.                case XORI:
  540.                     CPU[rt(inst)]=CPU[rs(inst)]^imm(inst);
  541.                     break;
  542.                case LUI:
  543.                     CPU[rt(inst)]=imm(inst)<<16;
  544.                     break;
  545.                case COP0:
  546.                     switch(rs(inst))
  547.                     {
  548.                          case MT:
  549.                               CP0[rd(inst)]=CPU[rt(inst)];
  550.                               break;
  551.                     }
  552.                     break;
  553.                case BEQL:
  554.                     if(delay==0)
  555.                     {
  556.                          if(CPU[rs(inst)]==CPU[rt(inst)])
  557.                          {
  558.                               delay=1;
  559.                          }
  560.                          else
  561.                          {
  562.                               pc+=4;
  563.                          }
  564.                     }
  565.                     else if(delay==3)
  566.                     {
  567.                          pc+=extend(imm(inst)<<2);
  568.                          delay=0;
  569.                     }
  570.                     break;
  571.                case BNEL:
  572.                     if(delay==0)
  573.                     {
  574.                          if(CPU[rs(inst)]!=CPU[rt(inst)])
  575.                          {
  576.                               delay=1;
  577.                          }
  578.                          else
  579.                          {
  580.                               pc+=4;
  581.                          }
  582.                     }
  583.                     else if(delay==3)
  584.                     {
  585.                          pc+=extend(imm(inst)<<2);
  586.                          delay=0;
  587.                     }
  588.                     break;
  589.                case BLEZL:
  590.                     if(delay==0)
  591.                     {
  592.                          if(CPU[rs(inst)]<=0)
  593.                          {
  594.                               delay=1;
  595.                          }
  596.                          else
  597.                          {
  598.                               pc+=4;
  599.                          }
  600.                     }
  601.                     else if(delay==3)
  602.                     {
  603.                          pc+=extend(imm(inst)<<2);
  604.                          delay=0;
  605.                     }
  606.                     break;
  607.                case BGTZL:
  608.                     if(delay==0)
  609.                     {
  610.                          if(CPU[rs(inst)]>0)
  611.                          {
  612.                               delay=1;
  613.                          }
  614.                          else
  615.                          {
  616.                               pc+=4;
  617.                          }
  618.                     }
  619.                     else if(delay==3)
  620.                     {
  621.                          pc+=extend(imm(inst)<<2);
  622.                          delay=0;
  623.                     }
  624.                     break;
  625.                case LW:
  626.                     loop=CPU[rs(inst)]+extend(imm(inst));
  627.                     CPU[rt(inst)]=read32(mem,loop);
  628.                     break;
  629.                case LBU:
  630.                     loop=CPU[rs(inst)]+extend(imm(inst));
  631.                     CPU[rt(inst)]=read32(mem,loop)>>24;
  632.                     break;
  633.                case SB:
  634.                     loop=CPU[rs(inst)]+extend(imm(inst));
  635.                     switch(LUT[(loop>>24)&0x1f])
  636.                     {
  637.                          case REG:
  638.                               mem[REG][loop&0x0fffff]=CPU[rt(inst)]&0xff;
  639.                               break;
  640.                          case PIF:
  641.                               mem[PIF][loop&0x3fffff]=CPU[rt(inst)]&0xff;
  642.                               break;
  643.                          default:
  644.                               mem[LUT[(loop>>24)&0x1f]][loop&0xffffff]=CPU[rt(inst)]&0xff;
  645.                               break;
  646.                     }
  647.                     break;
  648.                case SW:
  649.                     loop=CPU[rs(inst)]+extend(imm(inst));
  650.                     write32(mem,loop,CPU[rt(inst)]);
  651.                     break;
  652.                case CACHE:
  653.                     break;
  654.           }
  655.           pc+=4;
  656.           tick+=1;
  657.           if(delay>0)
  658.           {
  659.                delay+=1;
  660.                tick-=1;
  661.                if(delay==3)
  662.                {
  663.                     pc-=8;
  664.                     tick+=1;
  665.                }
  666.           }
  667.      }
  668.      for(loop=0;loop<32;loop+=1)
  669.      {
  670.           printf("%s: %08x ",names[loop],CPU[loop]);
  671.           if(loop%4==3)
  672.           {
  673.                printf("\n");
  674.           }
  675.      }
  676.      printf("pc: %08x\n",pc);
  677.      system("pause");
  678.      for(loop=0;loop<8;loop+=1)
  679.      {
  680.           free(mem[loop]);
  681.      }
  682.      return 0;
  683. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!