source: dev/trunk/abdev/BasicCompiler32/NumOpe_Logical.cpp@ 293

Last change on this file since 293 was 290, checked in by dai_9181, 17 years ago

ジェネリクスのベースを実装
File size: 10.3 KB
Line 
1#include "stdafx.h"
2
3#include <Compiler.h>
4
5#include "../BasicCompiler_Common/common.h"
6#include "Opcode.h"
7
8BOOL Calc_Xor(int *type,LONG_PTR *index_stack,int *pStackPointer){
9 //value[sp-2] xor= value[sp-1]
10 //xor演算
11
12 int sp;
13 sp=*pStackPointer;
14
15 if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
16 //いずれかの項が実数のとき
17 SetError(45,"xor",cp);
18 return 0;
19 }
20
21 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
22 type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
23 ////////////////////
24 // 64ビット整数演算
25 ////////////////////
26
27 //第2項を64ビットに対応させる
28 if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
29 //第2項が64ビット整数値のとき
30
31 //pop ebx
32 compiler.codeGenerator.op_pop(REG_EBX);
33
34 //pop ecx
35 compiler.codeGenerator.op_pop(REG_ECX);
36 }
37 else{
38 //第2項がその他整数値のとき
39
40 //pop eax
41 compiler.codeGenerator.op_pop(REG_EAX);
42
43 if(IsSignedType(type[sp-1])){
44 //符号拡張
45 //edx:eax ← eax
46
47 //cdq
48 compiler.codeGenerator.op_cdq();
49 }
50 else{
51 //ビット拡張
52 //edx:eax ← eax
53
54 //xor edx,edx
55 compiler.codeGenerator.op_zero_reg(REG_EDX);
56 }
57
58 //mov ebx,eax
59 compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
60
61 //mov ecx,edx
62 compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
63 }
64
65 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
66 //第1項が64ビット整数値のとき
67
68 //xor dword ptr[esp],ebx
69 compiler.codeGenerator.PutOld(
70 (char)0x31,
71 (char)0x1C,
72 (char)0x24
73 );
74
75 //xor dword ptr[esp+sizeof(long)],ecx
76 compiler.codeGenerator.PutOld(
77 (char)0x31,
78 (char)0x4C,
79 (char)0x24,
80 (char)0x04
81 );
82 }
83 else{
84 //第1項がその他整数値のとき
85 if(IsSignedType(type[sp-2])){
86 //pop eax
87 compiler.codeGenerator.op_pop(REG_EAX);
88
89 //符号拡張
90 //edx:eax ← eax
91
92 //cdq
93 compiler.codeGenerator.op_cdq();
94 }
95 else{
96 //pop eax
97 compiler.codeGenerator.op_pop(REG_EAX);
98
99 //ビット拡張
100 //edx:eax ← eax
101
102 //xor edx,edx
103 compiler.codeGenerator.op_zero_reg(REG_EDX);
104 }
105
106 //xor ebx,eax
107 compiler.codeGenerator.op_xor_RR( REG_EBX, REG_EAX );
108
109 //xor ecx,edx
110 compiler.codeGenerator.op_xor_RR( REG_ECX, REG_EDX );
111
112 //push ecx
113 compiler.codeGenerator.op_push(REG_ECX);
114
115 //push ebx
116 compiler.codeGenerator.op_push(REG_EBX);
117 }
118
119 sp--;
120 if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
121 else type[sp-1]=DEF_INT64;
122 }
123 else{
124 ////////////////////
125 // 整数演算
126 ////////////////////
127
128 //pop ebx
129 compiler.codeGenerator.op_pop(REG_EBX);
130
131 //pop eax
132 compiler.codeGenerator.op_pop(REG_EAX);
133
134 //sub esp,4
135 compiler.codeGenerator.op_sub_esp(4);
136
137 //xor eax,ebx
138 compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
139
140 //mov dword ptr[esp],eax
141 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
142
143 sp--;
144 type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
145 }
146
147 *pStackPointer=sp;
148 return 1;
149}
150
151BOOL Calc_Or(int *type,LONG_PTR *index_stack,int *pStackPointer){
152 //value[sp-2] or= value[sp-1]
153 //or演算
154
155 int sp;
156 sp=*pStackPointer;
157
158 if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
159 //いずれかの項が実数のとき
160 SetError(45,"or",cp);
161 return 0;
162 }
163
164 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
165 type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
166 ////////////////////
167 // 64ビット整数演算
168 ////////////////////
169
170 //第2項を64ビットに対応させる
171 if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
172 //第2項が64ビット整数値のとき
173
174 //pop ebx
175 compiler.codeGenerator.op_pop(REG_EBX);
176
177 //pop ecx
178 compiler.codeGenerator.op_pop(REG_ECX);
179 }
180 else{
181 //第2項が32ビット整数値のとき
182
183 //pop eax
184 compiler.codeGenerator.op_pop(REG_EAX);
185
186 if(IsSignedType(type[sp-1])){
187 //符号拡張
188 //edx:eax ← eax
189
190 //cdq
191 compiler.codeGenerator.op_cdq();
192 }
193 else{
194 //ビット拡張
195 //edx:eax ← eax
196
197 //xor edx,edx
198 compiler.codeGenerator.op_zero_reg(REG_EDX);
199 }
200
201 //mov ebx,eax
202 compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
203
204 //mov ecx,edx
205 compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
206 }
207
208 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
209 //第1項が64ビット整数値のとき
210
211 //or dword ptr[esp],ebx
212 compiler.codeGenerator.PutOld(
213 (char)0x09,
214 (char)0x1C,
215 (char)0x24
216 );
217
218 //or dword ptr[esp+sizeof(long)],ecx
219 compiler.codeGenerator.PutOld(
220 (char)0x09,
221 (char)0x4C,
222 (char)0x24,
223 (char)0x04
224 );
225 }
226 else{
227 //第1項が32ビット整数値のとき
228 if(IsSignedType(type[sp-2])){
229 //pop eax
230 compiler.codeGenerator.op_pop(REG_EAX);
231
232 //符号拡張
233 //edx:eax ← eax
234
235 //cdq
236 compiler.codeGenerator.op_cdq();
237 }
238 else{
239 //pop eax
240 compiler.codeGenerator.op_pop(REG_EAX);
241
242 //ビット拡張
243 //edx:eax ← eax
244
245 //xor edx,edx
246 compiler.codeGenerator.op_zero_reg(REG_EDX);
247 }
248
249 //or ebx,eax
250 compiler.codeGenerator.op_or_RR( sizeof(long), REG_EBX, REG_EAX );
251
252 //or ecx,edx
253 compiler.codeGenerator.op_or_RR( sizeof(long), REG_ECX, REG_EDX );
254
255 //push ecx
256 compiler.codeGenerator.op_push(REG_ECX);
257
258 //push ebx
259 compiler.codeGenerator.op_push(REG_EBX);
260 }
261
262 sp--;
263 if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
264 else type[sp-1]=DEF_INT64;
265 }
266 else{
267 ////////////////////
268 // 32ビット整数演算
269 ////////////////////
270
271 //pop ebx
272 compiler.codeGenerator.op_pop(REG_EBX);
273
274 //pop eax
275 compiler.codeGenerator.op_pop(REG_EAX);
276
277 //sub esp,4
278 compiler.codeGenerator.op_sub_esp(4);
279
280 //or eax,ebx
281 compiler.codeGenerator.op_or_RR( sizeof(long), REG_EAX, REG_EBX );
282
283 //mov dword ptr[esp],eax
284 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
285
286 sp--;
287 type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
288 }
289
290 *pStackPointer=sp;
291 return 1;
292}
293
294BOOL Calc_And(int *type,LONG_PTR *index_stack,int *pStackPointer){
295 //value[sp-2] and= value[sp-1]
296 //and演算
297
298 int sp;
299 sp=*pStackPointer;
300
301 if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
302 //いずれかの項が実数のとき
303 SetError(45,"and",cp);
304 return 0;
305 }
306
307 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
308 type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
309 ////////////////////
310 // 64ビット整数演算
311 ////////////////////
312
313 //第2項を64ビットに対応させる
314 if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
315 //第2項が64ビット整数値のとき
316
317 //pop ebx
318 compiler.codeGenerator.op_pop(REG_EBX);
319
320 //pop ecx
321 compiler.codeGenerator.op_pop(REG_ECX);
322 }
323 else{
324 //第2項が32ビット整数値のとき
325
326 //pop eax
327 compiler.codeGenerator.op_pop(REG_EAX);
328
329 if(IsSignedType(type[sp-1])){
330 //符号拡張
331 //edx:eax ← eax
332
333 //cdq
334 compiler.codeGenerator.op_cdq();
335 }
336 else{
337 //ビット拡張
338 //edx:eax ← eax
339
340 //xor edx,edx
341 compiler.codeGenerator.op_zero_reg(REG_EDX);
342 }
343
344 //mov ebx,eax
345 compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
346
347 //mov ecx,edx
348 compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
349 }
350
351 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
352 //第1項が64ビット整数値のとき
353
354 //and dword ptr[esp],ebx
355 compiler.codeGenerator.PutOld(
356 (char)0x21,
357 (char)0x1C,
358 (char)0x24
359 );
360
361 //and dword ptr[esp+sizeof(long)],ecx
362 compiler.codeGenerator.PutOld(
363 (char)0x21,
364 (char)0x4C,
365 (char)0x24,
366 (char)0x04
367 );
368 }
369 else{
370 //第1項が32ビット整数値のとき
371 if(IsSignedType(type[sp-2])){
372 //pop eax
373 compiler.codeGenerator.op_pop(REG_EAX);
374
375 //符号拡張
376 //edx:eax ← eax
377
378 //cdq
379 compiler.codeGenerator.op_cdq();
380 }
381 else{
382 //pop eax
383 compiler.codeGenerator.op_pop(REG_EAX);
384
385 //ビット拡張
386 //edx:eax ← eax
387
388 //xor edx,edx
389 compiler.codeGenerator.op_zero_reg(REG_EDX);
390 }
391
392 //and ebx,eax
393 compiler.codeGenerator.op_and_RR( REG_EBX, REG_EAX );
394
395 //and ecx,edx
396 compiler.codeGenerator.op_and_RR( REG_ECX, REG_EDX );
397
398 //push ecx
399 compiler.codeGenerator.op_push(REG_ECX);
400
401 //push ebx
402 compiler.codeGenerator.op_push(REG_EBX);
403 }
404
405 sp--;
406 if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
407 else type[sp-1]=DEF_INT64;
408 }
409 else{
410 ////////////////////
411 // 32ビット整数演算
412 ////////////////////
413
414 //pop ebx
415 compiler.codeGenerator.op_pop(REG_EBX);
416
417 //pop eax
418 compiler.codeGenerator.op_pop(REG_EAX);
419
420 //sub esp,4
421 compiler.codeGenerator.op_sub_esp(4);
422
423 //and eax,ebx
424 compiler.codeGenerator.op_and_RR( REG_EAX, REG_EBX );
425
426 //mov dword ptr[esp],eax
427 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
428
429 sp--;
430 type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
431 }
432
433 *pStackPointer=sp;
434 return 1;
435}
436
437BOOL Calc_Not(int *type,int sp){
438 //value[sp-1]=Not value[sp-1]
439 //NOT演算子
440
441 if(IsRealNumberType(type[sp-1])){
442 //実数のとき
443 SetError(45,"Not",cp);
444 return 0;
445 }
446
447 if( type[sp - 1] == DEF_BOOLEAN ){
448 //pop eax
449 compiler.codeGenerator.op_pop( REG_EAX );
450
451 //cmp eax,0
452 compiler.codeGenerator.op_cmp_value(Type(type[sp-1],-1).GetSize(),REG_EAX,0);
453
454 //setne al
455 compiler.codeGenerator.op_setne( REG_EAX );
456
457 //and eax,000000FFh
458 compiler.codeGenerator.op_and_RV(REG_EAX,(int)0xFF);
459
460 //neg
461 compiler.codeGenerator.op_neg( REG_EAX );
462
463 //sbb eax, eax
464 compiler.codeGenerator.op_sbb_RR( REG_EAX, REG_EAX );
465
466 //add eax, 1
467 compiler.codeGenerator.op_add_RV8( REG_EAX, 1 );
468
469 //push eax
470 compiler.codeGenerator.op_push( REG_EAX );
471 }
472 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
473 ////////////////////
474 // 64ビット整数演算
475 ////////////////////
476
477 //not dword ptr[esp]
478 compiler.codeGenerator.PutOld(
479 (char)0xF7,
480 (char)0x14,
481 (char)0x24
482 );
483
484 //not dword ptr[esp+4]
485 compiler.codeGenerator.PutOld(
486 (char)0xF7,
487 (char)0x54,
488 (char)0x24,
489 (char)0x04
490 );
491 }
492 else{
493 ////////////////////
494 // 32ビット整数演算
495 ////////////////////
496
497 //not dword ptr[esp]
498 compiler.codeGenerator.PutOld(
499 (char)0xF7,
500 (char)0x14,
501 (char)0x24
502 );
503 }
504
505 return 1;
506}
Note: See TracBrowser for help on using the repository browser.