Rev 7405 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
7406 | pavelyakov | 1 | // version 0.02 |
7405 | pavelyakov | 2 | // Author: Pavel Iakovlev |
7406 | pavelyakov | 3 | // http://shell-storm.org/online/Online-Assembler-and-Disassembler/?inst=&arch=arm#assembly - online compiler (Little endian:) |
7405 | pavelyakov | 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 | |||
7406 | pavelyakov | 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:) |
7405 | pavelyakov | 29 | |
7406 | pavelyakov | 30 | dword test_bytecode = "\x01\x00\xa0\xe3\x02\x50\xa0\xe3\x10\x25\xa0\xe1"; |
31 | |||
32 | // -------------------- |
||
33 | |||
7405 | pavelyakov | 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 | { |
||
7406 | pavelyakov | 103 | //PC = reg.r15 >> 2 & 0xFFFFFF; |
7405 | pavelyakov | 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 |
||
7406 | pavelyakov | 142 | //PC <<= 2; |
7405 | pavelyakov | 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 | |||
7406 | pavelyakov | 159 | //reg.r15 = flag << 28 | PC | pMode; |
7405 | pavelyakov | 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; |
||
7406 | pavelyakov | 190 | word sdvig = 0; |
191 | word context = 0; |
||
192 | byte typeSdvig = 0; |
||
7405 | pavelyakov | 193 | opcode = command >> 21 & 0xF; |
194 | Rd += command >> 12 & 0xF << 2; |
||
195 | Rn += command >> 16 & 0xF << 2; |
||
7406 | pavelyakov | 196 | context = command & 0xFFF; |
7405 | pavelyakov | 197 | |
7406 | pavelyakov | 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 |
||
7405 | pavelyakov | 206 | { |
7406 | pavelyakov | 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; |
||
7405 | pavelyakov | 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; |
||
7406 | pavelyakov | 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; |
||
7405 | pavelyakov | 273 | } |
7406 | pavelyakov | 274 | IF(reg.r2 == 4) while(1); |
7405 | pavelyakov | 275 | } |
276 | |||
277 | |||
278 | |||
279 | ______STOP______:=><=>><>><>><>><>><>=><=>><> |