Subversion Repositories Kolibri OS

Rev

Rev 7405 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. // version 0.02
  2. // Author: Pavel Iakovlev
  3. // http://shell-storm.org/online/Online-Assembler-and-Disassembler/?inst=&arch=arm#assembly - online compiler (Little endian:)
  4.  
  5.  
  6. #pragma option OST
  7. #pragma option ON
  8. #pragma option cri-
  9. #pragma option -CPA
  10. #initallvar 0
  11. #jumptomain FALSE
  12.  
  13. #startaddress 0x10000
  14.  
  15. #code32 TRUE
  16.  
  17. char   os_name[8]   = {'M','E','N','U','E','T','0','1'};
  18. dword  os_version   = 0x00000001;
  19. dword  start_addr   = #main;
  20. dword  final_addr   = #______STOP______+32;
  21. dword  alloc_mem    = 20000;
  22. dword  x86esp_reg   = 20000;
  23. dword  I_Param      = #param;
  24. dword  I_Path       = #program_path;
  25. char param[4096] ={0};
  26. char program_path[4096] = {0};
  27.  
  28. // test opcode arm, compiler (http://shell-storm.org/online/Online-Assembler-and-Disassembler/?inst=mov+r0%2C1%0D%0Amov+r5%2C2%0D%0Amov+r2%2C+r0%2C+lsl+r5&arch=arm#assembly) (Little endian:)
  29.  
  30. dword test_bytecode = "\x01\x00\xa0\xe3\x02\x50\xa0\xe3\x10\x25\xa0\xe1";
  31.  
  32. // --------------------
  33.  
  34. struct _reg // registers arm
  35. {
  36.         dword r0;
  37.         dword r1;
  38.         dword r2;
  39.         dword r3;
  40.         dword r4;
  41.         dword r5;
  42.         dword r6;
  43.         dword r7;
  44.         dword r8;
  45.         dword r9;
  46.         dword r10;
  47.         dword r11;
  48.         dword r12; // (Intra-Procedure-call scratch register)
  49.         dword r13; // (Stack Pointer)
  50.         dword r14; // (Link Register)
  51.         dword r15; // PC (Program Counter)
  52. };
  53.  
  54. _reg reg = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; // clear and init registers
  55. dword REG = #reg;
  56.  
  57. struct _flags
  58. {
  59.         byte negative;
  60.         byte zero;
  61.         byte carry;
  62.         byte overflow;
  63. };
  64.  
  65. _flags flags = {0,0,0,0}; // clear and init flags
  66.  
  67. struct _mode
  68. {
  69.         byte User;
  70.         byte FastInterrupt;
  71.         byte Interrupt;
  72.         byte Supervisor;
  73. };
  74.  
  75. _mode mode = {0,0,0,0}; // processor mode
  76.  
  77. struct _mask
  78. {
  79.         byte IRQ;
  80.         byte FIRQ;
  81. };
  82.  
  83. _mask mask = {0,0}; // processor mask
  84.  
  85. void main()
  86. {
  87.  
  88.         callOpcode(#test_bytecode,3);
  89.        
  90.         EAX = -1;
  91.         $int 0x40;
  92. }
  93.  
  94. dword callOpcode(dword binary, lengthInstruction)
  95. {
  96.         dword command = 0;
  97.         dword PC = 0;
  98.         byte flag = 0;
  99.         byte pMask = 0;
  100.         byte pMode = 0;
  101.         while(lengthInstruction)
  102.         {
  103.                 //PC    = reg.r15 >> 2 & 0xFFFFFF;
  104.                 flag  = reg.r15 >> 28;
  105.                 pMask = reg.r15 >> 26;
  106.                
  107.                 flags.negative = flag & 0x8;
  108.                 flags.zero     = flag & 0x4;
  109.                 flags.carry    = flag & 0x2;
  110.                 flags.overflow = flag & 0x1;
  111.                
  112.                 mask.IRQ  = pMask & 0x2;
  113.                 mask.FIRQ = pMask & 0x1;
  114.                
  115.                 switch(reg.r15 & 3)
  116.                 {
  117.                         case 0:
  118.                                 DSDWORD[#mode] = 0x000000FF;
  119.                         break;
  120.                         case 1:
  121.                                 DSDWORD[#mode] = 0x0000FF00;
  122.                         break;
  123.                         case 2:
  124.                                 DSDWORD[#mode] = 0x00FF0000;
  125.                         break;
  126.                         case 3:
  127.                                 DSDWORD[#mode] = 0xFF000000;
  128.                         break;
  129.                 }
  130.                
  131.                 command = DSDWORD[binary + PC]; // generation PC instruction
  132.                 //EAX = DSDWORD[command >> 28 << 2 + #opcodeExec]; // get opcodeExecition call instruction
  133.                 //EAX(command); // call opcodeExecition
  134.                 //IF (command & 0xC000000 == 0) opcodeExec0(command);
  135.                 IF (command & 0x0FFFFFF0 == 0x12FFF10) BranchExchange(command);
  136.                 ELSE IF (command & 0x0FF00FF0 == 0x1000090) SingleDataSwap(command);
  137.                 ELSE IF (command & 0x0FC000F0 == 0x0000090) Multiply(command);
  138.                 ELSE IF (command & 0x0FC000F0 == 0x0800090) MultiplyLong(command);
  139.                 ELSE IF (command & 0x0C000000 == 0x0000000) DataProcessing(command);
  140.                
  141.                 PC += 4; // addition 4 for reg15 or PC instruction
  142.                 //PC <<= 2;
  143.                
  144.                 flag = 0;
  145.                 IF (flags.negative) flag |= 0x8;
  146.                 IF (flags.zero)     flag |= 0x4;
  147.                 IF (flags.carry)    flag |= 0x2;
  148.                 IF (flags.overflow) flag |= 0x1;
  149.                
  150.                 pMask = 0;
  151.                 IF (mask.IRQ)  pMask |= 0x2;
  152.                 IF (mask.FIRQ) pMask |= 0x1;
  153.                
  154.                 IF (mode.User)               pMode = 0;
  155.                 ELSE IF (mode.FastInterrupt) pMode = 1;
  156.                 ELSE IF (mode.Interrupt)     pMode = 2;
  157.                 ELSE IF (mode.Supervisor)    pMode = 3;
  158.                
  159.                 //reg.r15 = flag << 28 | PC | pMode;
  160.                 lengthInstruction--;
  161.         }
  162. }
  163.  
  164. dword Multiply(dword command)
  165. {
  166.        
  167. }
  168.  
  169. dword MultiplyLong(dword command)
  170. {
  171.        
  172. }
  173.  
  174. dword SingleDataSwap(dword command)
  175. {
  176.        
  177. }
  178.  
  179. dword BranchExchange(dword command)
  180. {
  181.        
  182. }
  183.  
  184. dword DataProcessing(dword command) // Data Processing / PSR Transfer
  185. {
  186.         dword opcode = 0;
  187.         dword Rd = #reg;
  188.         dword Rn = #reg;
  189.         dword operand = 0;
  190.         word sdvig = 0;
  191.         word context = 0;
  192.         byte typeSdvig = 0;
  193.         opcode = command >> 21 & 0xF;
  194.         Rd += command >> 12 & 0xF << 2;
  195.         Rn += command >> 16 & 0xF << 2;
  196.         context = command & 0xFFF;
  197.  
  198.         IF (command & 0x2000000) operand = context;
  199.         ELSE operand = DSDWORD[context & 1111b << 2 + #reg];
  200.        
  201.         typeSdvig = context >> 5 & 11b;
  202.         IF (context & 10000b) sdvig = DSBYTE[context >> 8 & 1111b << 2 + #reg];
  203.         ELSE sdvig = context >> 7 & 11111b;
  204.  
  205.         switch (typeSdvig) // type sdvig
  206.         {
  207.                 case 0: // logic left
  208.                         operand <<= sdvig;
  209.                         if(sdvig == 2) while(1);
  210.                 break;
  211.                 case 1: // logic right
  212.                         operand >>= sdvig;
  213.                 break;
  214.                 case 2: // arifmetic left
  215.                        
  216.                 break;
  217.                 case 3: // arifmetic right
  218.                        
  219.                 break;
  220.         }
  221.        
  222.         switch (opcode)
  223.         {
  224.                 case 0: // and
  225.                         DSDWORD[Rd] = DSDWORD[Rn] & operand;
  226.                 break;
  227.                 case 1: // eor
  228.                         DSDWORD[Rd] = DSDWORD[Rn] | operand;
  229.                 break;
  230.                 case 2: // sub
  231.                         DSDWORD[Rd] = DSDWORD[Rn] - operand;
  232.                 break;
  233.                 case 3: // rsb
  234.                         DSDWORD[Rd] = operand - DSDWORD[Rn];
  235.                 break;
  236.                 case 4: // add
  237.                         DSDWORD[Rd] = DSDWORD[Rn] + operand;
  238.                 break;
  239.                 case 5: // adc
  240.                         DSDWORD[Rd] = DSDWORD[Rn] + operand;
  241.                 break;
  242.                 case 6: // sbc
  243.                        
  244.                 break;
  245.                 case 7: // rsc
  246.                        
  247.                 break;
  248.                 case 8: // tst
  249.                        
  250.                 break;
  251.                 case 9: // teq
  252.                        
  253.                 break;
  254.                 case 10: // cmp
  255.                        
  256.                 break;
  257.                 case 11: // cmn
  258.                        
  259.                 break;
  260.                 case 12: // orr
  261.                         DSDWORD[Rd] = DSDWORD[Rn] | operand;
  262.                 break;
  263.                 case 13: // mov
  264.                         DSDWORD[Rd] = operand;
  265.                 break;
  266.                 case 14: // bic
  267.                         $not operand;
  268.                         DSDWORD[Rd] = DSDWORD[Rn] & operand;
  269.                 break;
  270.                 case 15: // mvn
  271.                         DSDWORD[Rd] = DSDWORD[Rn] + operand;
  272.                 break;
  273.         }
  274.         IF(reg.r2 == 4) while(1);
  275. }
  276.  
  277.  
  278.  
  279. ______STOP______: