source: dev/trunk/abdev/BasicCompiler32/NumOpe_Relation.cpp@ 238

Last change on this file since 238 was 238, checked in by dai_9181, 17 years ago
File size: 28.8 KB
Line 
1#include "stdafx.h"
2
3#include <Compiler.h>
4
5#include "../BasicCompiler_Common/common.h"
6#include "Opcode.h"
7
8void AutoExtendToBigType( int *type_stack,int sp, int reg1, int reg2 ){
9 /*
10 int bigSize = GetTypeSize( type_stack[sp-1], -1 );
11 if( bigSize != GetTypeSize( type_stack[sp-2], -1 ) ){
12 int extReg = reg2;
13 int oldType = type_stack[sp-2];
14 if( bigSize < GetTypeSize( type_stack[sp-2], -1 ) ){
15 bigSize = GetTypeSize( type_stack[sp-2], -1 );
16 extReg = reg1;
17 oldType = type_stack[sp-1];
18 }
19 if( bigSize == 2 ){
20 ExtendTypeTo16( oldType, extReg );
21 }
22 else if( bigSize == 4 ){
23 ExtendTypeTo32( oldType, extReg );
24 }
25 else{
26 SetError();
27 }
28 }*/
29}
30
31
32BOOL Calc_Relation_PE(int *type_stack,LONG_PTR *index_stack,int *pStackPointer){
33 //value[sp-2]<=value[sp-1]
34
35 int sp;
36 sp=*pStackPointer;
37
38 int AnswerType;
39 AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
40
41 if(IsRealNumberType(AnswerType)){
42 //////////////
43 // 実数演算
44 //////////////
45
46 if(type_stack[sp-1]==DEF_DOUBLE){
47 //fld qword ptr[esp]
48 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
49
50 //add esp,8
51 compiler.codeGenerator.op_add_esp(8);
52 }
53 else if(type_stack[sp-1]==DEF_SINGLE){
54 //fld dword ptr[esp]
55 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
56
57 //add esp,4
58 compiler.codeGenerator.op_add_esp(4);
59 }
60 else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
61 //64ビット整数値
62
63 //fild qword ptr[esp]
64 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
65
66 //add esp,8
67 compiler.codeGenerator.op_add_esp(8);
68 }
69 else{
70 //その他整数型
71
72 //fild dword ptr[esp]
73 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
74
75 //add esp,4
76 compiler.codeGenerator.op_add_esp(4);
77 }
78
79 if(type_stack[sp-2]==DEF_DOUBLE){
80 //fld qword ptr[esp]
81 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
82
83 //add esp,4
84 compiler.codeGenerator.op_add_esp(4);
85 }
86 else if(type_stack[sp-2]==DEF_SINGLE){
87 //fld dword ptr[esp]
88 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
89 }
90 else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
91 //64ビット整数値
92
93 //fild qword ptr[esp]
94 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
95
96 //add esp,4
97 compiler.codeGenerator.op_add_esp(4);
98 }
99 else{
100 //その他整数型
101
102 //fild dword ptr[esp]
103 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
104 }
105
106 //fcompp
107 compiler.codeGenerator.op_fcompp();
108
109 //fnstsw ax
110 compiler.codeGenerator.op_fnstsw_ax();
111
112 //mov ecx,1
113 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
114
115 //test ah,41h
116 compiler.codeGenerator.op_test_ah( (char)0x41 );
117
118 //jne 5
119 compiler.codeGenerator.PutOld(
120 (char)0x75,
121 (char)0x02
122 );
123
124 //xor ecx,ecx（ecxを0にする）
125 compiler.codeGenerator.op_zero_reg(REG_ECX);
126
127 //mov dword ptr[esp],ecx
128 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
129 }
130 else if(Is64Type(AnswerType)){
131 ////////////////////
132 // 64ビット整数演算
133 ////////////////////
134
135 // 第1項 <= 第2項
136
137 //第1項 edx:eax
138 //第2項 ecx:ebx
139 GetStackData_ToRegister(type_stack,sp);
140
141 //cmp edx,ecx
142 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
143
144 CodeGenerator::PertialSchedule *pFalsePertialSchedule1;
145 if(IsSignedType(type_stack[sp-2])==0&&IsSignedType(type_stack[sp-1])==0){
146 //符号なし演算
147
148 //ja FalseSchedule1（偽へジャンプ）
149 pFalsePertialSchedule1 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
150 }
151 else{
152 //符号あり演算
153
154 //jg FalseSchedule1（偽へジャンプ）
155 pFalsePertialSchedule1 = compiler.codeGenerator.op_jg( 0, sizeof(char), true );
156 }
157
158 CodeGenerator::PertialSchedule *pTruePertialSchedule;
159 if(IsSignedType(type_stack[sp-2])==0&&IsSignedType(type_stack[sp-1])==0){
160 //符号なし演算
161
162 //jb TrueSchedule（真へジャンプ）
163 pTruePertialSchedule = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
164 }
165 else{
166 //符号あり演算
167
168 //jl TrueSchedule（真へジャンプ）
169 pTruePertialSchedule = compiler.codeGenerator.op_jl( 0, sizeof(char), true );
170 }
171
172 //cmp eax,ebx
173 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
174
175 //ja FalseSchedule2（偽へジャンプ）
176 CodeGenerator::PertialSchedule *pFalsePertialSchedule2 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
177
178 //TrueScheduleのジャンプ先の設定
179 compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule );
180
181 //mov eax,1
182 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
183
184 //jmp 2（演算終了位置へジャンプ）
185 compiler.codeGenerator.op_jmp( 2 );
186
187 //FalseScheduleのジャンプ先の設定
188 compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule1 );
189 compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule2 );
190
191 //xor eax,eax（eaxを0にする）
192 compiler.codeGenerator.op_zero_reg(REG_EAX);
193
194 //push eax
195 compiler.codeGenerator.op_push(REG_EAX);
196 }
197 else{
198 ////////////////////
199 // 32ビット整数演算
200 ////////////////////
201
202 //pop ebx
203 compiler.codeGenerator.op_pop(REG_EBX);
204
205 //pop eax
206 compiler.codeGenerator.op_pop(REG_EAX);
207
208 // どちらかのサイズが足りない場合は自動拡張する
209 AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
210
211 //sub esp,4
212 compiler.codeGenerator.op_sub_esp(4);
213
214 //mov ecx,1
215 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
216
217 //cmp eax,ebx
218 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
219
220 if(IsSignedType(type_stack[sp-2])==0&&IsSignedType(type_stack[sp-1])==0){
221 //符号なし演算
222
223 //jbe 2（次のxorを飛び越す）
224 compiler.codeGenerator.op_jbe( 2 );
225 }
226 else{
227 //符号あり演算
228
229 //jle 2（次のxorを飛び越す）
230 compiler.codeGenerator.op_jle( 2 );
231 }
232
233 //xor ecx,ecx
234 compiler.codeGenerator.op_xor_RR( REG_ECX );
235
236 //mov dword ptr[esp],ecx
237 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
238 }
239
240 sp--;
241 type_stack[sp-1]=DEF_BOOLEAN;
242
243 *pStackPointer=sp;
244 return 1;
245}
246
247BOOL Calc_Relation_QE(int *type_stack,LONG_PTR *index_stack,int *pStackPointer){
248 //value[sp-2]>=value[sp-1]
249
250 int sp;
251 sp=*pStackPointer;
252
253 int AnswerType;
254 AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
255
256 if(IsRealNumberType(AnswerType)){
257 //浮動小数点演算
258 if(type_stack[sp-1]==DEF_DOUBLE){
259 //fld qword ptr[esp]
260 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
261
262 //add esp,8
263 compiler.codeGenerator.op_add_esp(8);
264 }
265 else if(type_stack[sp-1]==DEF_SINGLE){
266 //fld dword ptr[esp]
267 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
268
269 //add esp,4
270 compiler.codeGenerator.op_add_esp(4);
271 }
272 else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
273 //64ビット整数値
274
275 //fild qword ptr[esp]
276 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
277
278 //add esp,8
279 compiler.codeGenerator.op_add_esp(8);
280 }
281 else{
282 //その他整数型
283
284 //fild dword ptr[esp]
285 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
286
287 //add esp,4
288 compiler.codeGenerator.op_add_esp(4);
289 }
290
291 if(type_stack[sp-2]==DEF_DOUBLE){
292 //fld qword ptr[esp]
293 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
294
295 //add esp,4
296 compiler.codeGenerator.op_add_esp(4);
297 }
298 else if(type_stack[sp-2]==DEF_SINGLE){
299 //fld dword ptr[esp]
300 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
301 }
302 else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
303 //64ビット整数値
304
305 //fild qword ptr[esp]
306 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
307
308 //add esp,4
309 compiler.codeGenerator.op_add_esp(4);
310 }
311 else{
312 //その他整数型
313
314 //fild dword ptr[esp]
315 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
316 }
317
318 //fcompp
319 compiler.codeGenerator.op_fcompp();
320
321 //fnstsw ax
322 compiler.codeGenerator.op_fnstsw_ax();
323
324 //mov ecx,1
325 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
326
327 //test ah,1
328 compiler.codeGenerator.op_test_ah( (char)0x01 );
329
330 //je 2（次のxorを飛び越す）
331 OpBuffer[obp++]=(char)0x74;
332 OpBuffer[obp++]=(char)0x02;
333
334 //xor ecx,ecx
335 compiler.codeGenerator.op_xor_RR( REG_ECX );
336
337 //mov dword ptr[esp],ecx
338 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
339 }
340 else if(Is64Type(AnswerType)){
341 ////////////////////
342 // 64ビット整数演算
343 ////////////////////
344 int TrueSchedule,
345 FalseSchedule1,
346 FalseSchedule2;
347
348 // 第1項 >= 第2項
349
350 //第1項 edx:eax
351 //第2項 ecx:ebx
352 GetStackData_ToRegister(type_stack,sp);
353
354 //cmp edx,ecx
355 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
356
357 if(IsSignedType(AnswerType)){
358 //符号あり演算
359
360 //jl FalseSchedule1（偽へジャンプ）
361 OpBuffer[obp++]=(char)0x7C;
362 }
363 else{
364 //符号なし演算
365
366 //jb FalseSchedule1（偽へジャンプ）
367 OpBuffer[obp++]=(char)0x72;
368 }
369 FalseSchedule1=obp;
370 obp++;
371
372 if(IsSignedType(AnswerType)){
373 //符号あり演算
374
375 //jg TrueSchedule（真へジャンプ）
376 OpBuffer[obp++]=(char)0x7F;
377 }
378 else{
379 //符号なし演算
380
381 //ja TrueSchedule（真へジャンプ）
382 OpBuffer[obp++]=(char)0x77;
383 }
384 TrueSchedule=obp;
385 obp++;
386
387 //cmp eax,ebx
388 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
389
390 //jb FalseSchedule2（偽へジャンプ）
391 OpBuffer[obp++]=(char)0x72;
392 FalseSchedule2=obp;
393 obp++;
394
395 //TrueScheduleのジャンプ先の設定
396 OpBuffer[TrueSchedule]=obp-(TrueSchedule+1);
397
398 //mov eax,1
399 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
400
401 //jmp 2（演算終了位置へジャンプ）
402 OpBuffer[obp++]=(char)0xEB;
403 OpBuffer[obp++]=(char)0x02;
404
405 //FalseScheduleのジャンプ先の設定
406 OpBuffer[FalseSchedule1]=obp-(FalseSchedule1+1);
407 OpBuffer[FalseSchedule2]=obp-(FalseSchedule2+1);
408
409 //xor eax,eax（eaxを0にする）
410 compiler.codeGenerator.op_zero_reg(REG_EAX);
411
412 //push eax
413 compiler.codeGenerator.op_push(REG_EAX);
414 }
415 else{
416 ////////////////////
417 // 32ビット整数演算
418 ////////////////////
419
420 //pop ebx
421 compiler.codeGenerator.op_pop(REG_EBX);
422
423 //pop eax
424 compiler.codeGenerator.op_pop(REG_EAX);
425
426 // どちらかのサイズが足りない場合は自動拡張する
427 AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
428
429 //sub esp,4
430 compiler.codeGenerator.op_sub_esp(4);
431
432 //mov ecx,1
433 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
434
435 //cmp eax,ebx
436 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
437
438 if(IsSignedType(AnswerType)){
439 //符号あり演算
440
441 //jge 2（次のxorを飛び越す）符号有り
442 OpBuffer[obp++]=(char)0x7D;
443 OpBuffer[obp++]=(char)0x02;
444 }
445 else{
446 //符号なし演算
447
448 //jae 2（次のxorを飛び越す）
449 OpBuffer[obp++]=(char)0x73;
450 OpBuffer[obp++]=(char)0x02;
451 }
452
453 //xor ecx,ecx
454 compiler.codeGenerator.op_xor_RR( REG_ECX );
455
456 //mov dword ptr[esp],ecx
457 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
458 }
459
460 sp--;
461 type_stack[sp-1]=DEF_BOOLEAN;
462
463 *pStackPointer=sp;
464 return 1;
465}
466
467BOOL Calc_Relation_P(int *type_stack,LONG_PTR *index_stack,int *pStackPointer){
468 //value[sp-2]<value[sp-1]
469
470 int sp;
471 sp=*pStackPointer;
472
473 int AnswerType;
474 AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
475
476 if(IsRealNumberType(AnswerType)){
477 //////////////
478 // 実数演算
479 //////////////
480
481 if(type_stack[sp-1]==DEF_DOUBLE){
482 //fld qword ptr[esp]
483 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
484
485 //add esp,8
486 compiler.codeGenerator.op_add_esp(8);
487 }
488 else if(type_stack[sp-1]==DEF_SINGLE){
489 //fld dword ptr[esp]
490 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
491
492 //add esp,4
493 compiler.codeGenerator.op_add_esp(4);
494 }
495 else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
496 //64ビット整数値
497
498 //fild qword ptr[esp]
499 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
500
501 //add esp,8
502 compiler.codeGenerator.op_add_esp(8);
503 }
504 else{
505 //その他整数型
506
507 //fild dword ptr[esp]
508 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
509
510 //add esp,4
511 compiler.codeGenerator.op_add_esp(4);
512 }
513
514 if(type_stack[sp-2]==DEF_DOUBLE){
515 //fld qword ptr[esp]
516 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
517
518 //add esp,4
519 compiler.codeGenerator.op_add_esp(4);
520 }
521 else if(type_stack[sp-2]==DEF_SINGLE){
522 //fld dword ptr[esp]
523 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
524 }
525 else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
526 //64ビット整数値
527
528 //fild qword ptr[esp]
529 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
530
531 //add esp,4
532 compiler.codeGenerator.op_add_esp(4);
533 }
534 else{
535 //その他整数型
536
537 //fild dword ptr[esp]
538 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
539 }
540
541 //fcompp
542 compiler.codeGenerator.op_fcompp();
543
544 //fnstsw ax
545 compiler.codeGenerator.op_fnstsw_ax();
546
547 //mov ecx,1
548 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
549
550 //test ah,01h
551 compiler.codeGenerator.op_test_ah( (char)0x01 );
552
553 //jne 2
554 OpBuffer[obp++]=(char)0x75;
555 OpBuffer[obp++]=(char)0x02;
556
557 //xor ecx,ecx
558 compiler.codeGenerator.op_xor_RR( REG_ECX );
559
560 //mov dword ptr[esp],ecx
561 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
562 }
563 else if(Is64Type(AnswerType)){
564 ////////////////////
565 // 64ビット整数演算
566 ////////////////////
567 int TrueSchedule1,
568 TrueSchedule2,
569 FalseSchedule;
570
571 // 第1項 < 第2項
572
573 //第1項 edx:eax
574 //第2項 ecx:ebx
575 GetStackData_ToRegister(type_stack,sp);
576
577 //cmp edx,ecx
578 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
579
580 if(IsSignedType(AnswerType)){
581 //符号あり演算
582
583 //jl TrueSchedule1（真へジャンプ）
584 OpBuffer[obp++]=(char)0x7C;
585 }
586 else{
587 //符号なし演算
588
589 //jb TrueSchedule1（真へジャンプ）
590 OpBuffer[obp++]=(char)0x72;
591 }
592 TrueSchedule1=obp;
593 obp++;
594
595 if(IsSignedType(AnswerType)){
596 //符号あり演算
597
598 //jg FalseSchedule（偽へジャンプ）
599 OpBuffer[obp++]=(char)0x7F;
600 }
601 else{
602 //符号なし演算
603
604 //ja FalseSchedule（偽へジャンプ）
605 OpBuffer[obp++]=(char)0x77;
606 }
607 FalseSchedule=obp;
608 obp++;
609
610 //cmp eax,ebx
611 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
612
613 //jb TrueSchedule2（真へジャンプ）
614 OpBuffer[obp++]=(char)0x72;
615 TrueSchedule2=obp;
616 obp++;
617
618 //FalseScheduleのジャンプ先の設定
619 OpBuffer[FalseSchedule]=obp-(FalseSchedule+1);
620
621 //xor eax,eax（eaxを0にする）
622 compiler.codeGenerator.op_zero_reg(REG_EAX);
623
624 //jmp 5（演算終了位置へジャンプ）
625 OpBuffer[obp++]=(char)0xEB;
626 OpBuffer[obp++]=(char)0x05;
627
628 //TrueScheduleのジャンプ先の設定
629 OpBuffer[TrueSchedule1]=obp-(TrueSchedule1+1);
630 OpBuffer[TrueSchedule2]=obp-(TrueSchedule2+1);
631
632 //mov eax,1
633 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
634
635 //push eax
636 compiler.codeGenerator.op_push(REG_EAX);
637 }
638 else{
639 ///////////////////
640 //32ビット整数演算
641 ///////////////////
642
643 //pop ebx
644 compiler.codeGenerator.op_pop(REG_EBX);
645
646 //pop eax
647 compiler.codeGenerator.op_pop(REG_EAX);
648
649 // どちらかのサイズが足りない場合は自動拡張する
650 AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
651
652 //sub esp,4
653 compiler.codeGenerator.op_sub_esp(4);
654
655 //mov ecx,1
656 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
657
658 //cmp eax,ebx
659 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
660
661 if(IsSignedType(AnswerType)){
662 //符号あり演算
663
664 //jl 2（次のxorを飛び越す）
665 OpBuffer[obp++]=(char)0x7C;
666 OpBuffer[obp++]=(char)0x02;
667 }
668 else{
669 //符号なし演算
670
671 //jb 2（次のxorを飛び越す）
672 OpBuffer[obp++]=(char)0x72;
673 OpBuffer[obp++]=(char)0x02;
674 }
675
676 //xor ecx,ecx
677 compiler.codeGenerator.op_xor_RR( REG_ECX );
678
679 //mov dword ptr[esp],ecx
680 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
681 }
682
683 sp--;
684 type_stack[sp-1]=DEF_BOOLEAN;
685
686 *pStackPointer=sp;
687 return 1;
688}
689
690BOOL Calc_Relation_Q(int *type_stack,LONG_PTR *index_stack,int *pStackPointer){
691 //value[sp-2]>value[sp-1]
692
693 int sp;
694 sp=*pStackPointer;
695
696 int AnswerType;
697 AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
698
699 if(IsRealNumberType(AnswerType)){
700 //////////////
701 // 実数演算
702 //////////////
703
704 if(type_stack[sp-1]==DEF_DOUBLE){
705 //fld qword ptr[esp]
706 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
707
708 //add esp,8
709 compiler.codeGenerator.op_add_esp(8);
710 }
711 else if(type_stack[sp-1]==DEF_SINGLE){
712 //fld dword ptr[esp]
713 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
714
715 //add esp,4
716 compiler.codeGenerator.op_add_esp(4);
717 }
718 else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
719 //64ビット整数値
720
721 //fild qword ptr[esp]
722 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
723
724 //add esp,8
725 compiler.codeGenerator.op_add_esp(8);
726 }
727 else{ //Long、DWord
728 //fild dword ptr[esp]
729 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
730
731 //add esp,4
732 compiler.codeGenerator.op_add_esp(4);
733 }
734
735 if(type_stack[sp-2]==DEF_DOUBLE){
736 //fld qword ptr[esp]
737 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
738
739 //add esp,4
740 compiler.codeGenerator.op_add_esp(4);
741 }
742 else if(type_stack[sp-2]==DEF_SINGLE){
743 //fld dword ptr[esp]
744 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
745 }
746 else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
747 //64ビット整数値
748
749 //fild qword ptr[esp]
750 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
751
752 //add esp,4
753 compiler.codeGenerator.op_add_esp(4);
754 }
755 else{ //Long、DWord
756 //fild dword ptr[esp]
757 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
758 }
759
760 //fcompp
761 compiler.codeGenerator.op_fcompp();
762
763 //fnstsw ax
764 compiler.codeGenerator.op_fnstsw_ax();
765
766 //mov ecx,1
767 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
768
769 //test ah,41
770 compiler.codeGenerator.op_test_ah( (char)0x41 );
771
772 //je 2（次のxorを飛び越す）
773 OpBuffer[obp++]=(char)0x74;
774 OpBuffer[obp++]=(char)0x02;
775
776 //xor ecx,ecx
777 compiler.codeGenerator.op_xor_RR( REG_ECX );
778
779 //mov dword ptr[esp],ecx
780 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
781 }
782 else if(Is64Type(AnswerType)){
783 ////////////////////
784 // 64ビット整数演算
785 ////////////////////
786 int FalseSchedule,
787 TrueSchedule1,
788 TrueSchedule2;
789
790 // 第1項 > 第2項
791
792 //第1項 edx:eax
793 //第2項 ecx:ebx
794 GetStackData_ToRegister(type_stack,sp);
795
796 //cmp edx,ecx
797 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
798
799 if(IsSignedType(AnswerType)){
800 //符号有り
801
802 //jg TrueSchedule1（真へジャンプ）
803 OpBuffer[obp++]=(char)0x7F;
804 }
805 else{
806 //符号無し
807
808 //ja TrueSchedule1（真へジャンプ）
809 OpBuffer[obp++]=(char)0x77;
810 }
811 TrueSchedule1=obp;
812 obp++;
813
814 if(IsSignedType(AnswerType)){
815 //符号有り
816
817 //jl FalseSchedule（偽へジャンプ）
818 OpBuffer[obp++]=(char)0x7C;
819 }
820 else{
821 //符号無し
822
823 //jb FalseSchedule（偽へジャンプ）
824 OpBuffer[obp++]=(char)0x72;
825 }
826 FalseSchedule=obp;
827 obp++;
828
829 //cmp eax,ebx
830 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
831
832 //ja TrueSchedule2（真へジャンプ）
833 OpBuffer[obp++]=(char)0x77;
834 TrueSchedule2=obp;
835 obp++;
836
837 //FalseScheduleのジャンプ先の設定
838 OpBuffer[FalseSchedule]=obp-(FalseSchedule+1);
839
840 //xor eax,eax（eaxを0にする）
841 compiler.codeGenerator.op_zero_reg(REG_EAX);
842
843 //jmp 5（演算終了位置へジャンプ）
844 OpBuffer[obp++]=(char)0xEB;
845 OpBuffer[obp++]=(char)0x05;
846
847 //TrueScheduleのジャンプ先の設定
848 OpBuffer[TrueSchedule1]=obp-(TrueSchedule1+1);
849 OpBuffer[TrueSchedule2]=obp-(TrueSchedule2+1);
850
851 //mov eax,1
852 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
853
854 //push eax
855 compiler.codeGenerator.op_push(REG_EAX);
856 }
857 else{
858 ////////////////////
859 // 32ビット整数演算
860 ////////////////////
861
862 //pop ebx
863 compiler.codeGenerator.op_pop(REG_EBX);
864
865 //pop eax
866 compiler.codeGenerator.op_pop(REG_EAX);
867
868 // どちらかのサイズが足りない場合は自動拡張する
869 AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
870
871 //sub esp,4
872 compiler.codeGenerator.op_sub_esp(4);
873
874 //mov ecx,1
875 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
876
877 //cmp eax,ebx
878 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
879
880 if(IsSignedType(AnswerType)){
881 //jg 2（次のxorを飛び越す）
882 OpBuffer[obp++]=(char)0x7F;
883 OpBuffer[obp++]=(char)0x02;
884 }
885 else{
886 //ja 2（次のxorを飛び越す）
887 OpBuffer[obp++]=(char)0x77;
888 OpBuffer[obp++]=(char)0x02;
889 }
890
891 //xor ecx,ecx
892 compiler.codeGenerator.op_xor_RR( REG_ECX );
893
894 //mov dword ptr[esp],ecx
895 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
896 }
897
898 sp--;
899 type_stack[sp-1]=DEF_BOOLEAN;
900
901 *pStackPointer=sp;
902 return 1;
903}
904
905BOOL Calc_Relation_NotEqual(int *type,int *pStackPointer){
906 //value[sp-2]<>value[sp-1]
907
908 int sp;
909 sp=*pStackPointer;
910
911 if(type[sp-2]==DEF_DOUBLE||type[sp-2]==DEF_SINGLE||
912 type[sp-1]==DEF_DOUBLE||type[sp-1]==DEF_SINGLE){
913 //////////////
914 // 実数演算
915 //////////////
916
917 if(type[sp-1]==DEF_DOUBLE){
918 //fld qword ptr[esp]
919 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
920
921 //add esp,8
922 compiler.codeGenerator.op_add_esp(8);
923 }
924 else if(type[sp-1]==DEF_SINGLE){
925 //fld dword ptr[esp]
926 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
927
928 //add esp,4
929 compiler.codeGenerator.op_add_esp(4);
930 }
931 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
932 //64ビット整数値
933
934 //fild qword ptr[esp]
935 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
936
937 //add esp,8
938 compiler.codeGenerator.op_add_esp(8);
939 }
940 else{ //Long、DWord
941 //fild dword ptr[esp]
942 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
943
944 //add esp,4
945 compiler.codeGenerator.op_add_esp(4);
946 }
947
948 if(type[sp-2]==DEF_DOUBLE){
949 //fld qword ptr[esp]
950 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
951
952 //add esp,4
953 compiler.codeGenerator.op_add_esp(4);
954 }
955 else if(type[sp-2]==DEF_SINGLE){
956 //fld dword ptr[esp]
957 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
958 }
959 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
960 //64ビット整数値
961
962 //fild qword ptr[esp]
963 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
964
965 //add esp,4
966 compiler.codeGenerator.op_add_esp(4);
967 }
968 else{ //Long、DWord
969 //fild dword ptr[esp]
970 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
971 }
972
973 //fcompp
974 compiler.codeGenerator.op_fcompp();
975
976 //fnstsw ax
977 compiler.codeGenerator.op_fnstsw_ax();
978
979 //mov ecx,1
980 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
981
982 //test ah,40
983 compiler.codeGenerator.op_test_ah( (char)0x40 );
984
985 //je 2
986 compiler.codeGenerator.op_je( 2 );
987
988 //xor ecx,ecx
989 compiler.codeGenerator.op_xor_RR( REG_ECX );
990
991 //mov dword ptr[esp],ecx
992 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
993 }
994 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
995 type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
996 ////////////////////
997 // 64ビット整数演算
998 ////////////////////
999
1000 // 第1項 <> 第2項
1001
1002 //第1項 edx:eax
1003 //第2項 ecx:ebx
1004 GetStackData_ToRegister(type,sp);
1005
1006 //cmp eax,ebx
1007 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
1008
1009 //jne TrueSchedule1（真へジャンプ）
1010 CodeGenerator::PertialSchedule *pTruePertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
1011
1012 //cmp edx,ecx
1013 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
1014
1015 //jne TrueSchedule2（真へジャンプ）
1016 CodeGenerator::PertialSchedule *pTruePertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
1017
1018 //xor eax,eax（eaxを0にする）
1019 compiler.codeGenerator.op_zero_reg(REG_EAX);
1020
1021 //jmp 5（演算終了位置へジャンプ）
1022 compiler.codeGenerator.op_jmp( 5 );
1023
1024 //TrueScheduleのジャンプ先の設定
1025 compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule1 );
1026 compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule2 );
1027
1028 //mov eax,1
1029 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
1030
1031 //push eax
1032 compiler.codeGenerator.op_push(REG_EAX);
1033 }
1034 else{
1035 ////////////////////
1036 // 32ビット整数演算
1037 ////////////////////
1038
1039 //pop eax
1040 compiler.codeGenerator.op_pop(REG_EAX);
1041
1042 //pop ebx
1043 compiler.codeGenerator.op_pop(REG_EBX);
1044
1045 // どちらかのサイズが足りない場合は自動拡張する
1046 AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
1047
1048 //sub esp,4
1049 compiler.codeGenerator.op_sub_esp(4);
1050
1051 //xor eax,ebx
1052 compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
1053
1054 //je 5（次のmovを飛び越す）
1055 compiler.codeGenerator.op_je( 5 );
1056
1057 //mov eax,1
1058 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
1059
1060 //mov dword ptr[esp],eax
1061 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
1062 }
1063
1064 sp--;
1065 type[sp-1]=DEF_BOOLEAN;
1066
1067 *pStackPointer=sp;
1068 return 1;
1069}
1070
1071BOOL Calc_Relation_Equal(int *type,int *pStackPointer){
1072 //value[sp-2]=value[sp-1]
1073
1074 int sp;
1075 sp=*pStackPointer;
1076
1077 if(type[sp-2]==DEF_DOUBLE||type[sp-2]==DEF_SINGLE||
1078 type[sp-1]==DEF_DOUBLE||type[sp-1]==DEF_SINGLE){
1079 //////////////
1080 // 実数演算
1081 //////////////
1082
1083 if(type[sp-1]==DEF_DOUBLE){
1084 //fld qword ptr[esp]
1085 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1086
1087 //add esp,8
1088 compiler.codeGenerator.op_add_esp(8);
1089 }
1090 else if(type[sp-1]==DEF_SINGLE){
1091 //fld dword ptr[esp]
1092 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1093
1094 //add esp,4
1095 compiler.codeGenerator.op_add_esp(4);
1096 }
1097 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
1098 //64ビット整数値
1099
1100 //fild qword ptr[esp]
1101 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
1102
1103 //add esp,8
1104 compiler.codeGenerator.op_add_esp(8);
1105 }
1106 else{ //Long、DWord
1107 //fild dword ptr[esp]
1108 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
1109
1110 //add esp,4
1111 compiler.codeGenerator.op_add_esp(4);
1112 }
1113
1114 if(type[sp-2]==DEF_DOUBLE){
1115 //fld qword ptr[esp]
1116 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1117
1118 //add esp,4
1119 compiler.codeGenerator.op_add_esp(4);
1120 }
1121 else if(type[sp-2]==DEF_SINGLE){
1122 //fld dword ptr[esp]
1123 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1124 }
1125 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
1126 //64ビット整数値
1127
1128 //fild qword ptr[esp]
1129 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
1130
1131 //add esp,4
1132 compiler.codeGenerator.op_add_esp(4);
1133 }
1134 else{ //Long、DWord
1135 //fild dword ptr[esp]
1136 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
1137 }
1138
1139 //fcompp
1140 compiler.codeGenerator.op_fcompp();
1141
1142 //fnstsw ax
1143 compiler.codeGenerator.op_fnstsw_ax();
1144
1145 //mov ecx,1
1146 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
1147
1148 //test ah,40
1149 compiler.codeGenerator.op_test_ah( (char)0x40 );
1150
1151 //jne 2（次のxorを飛び越す）
1152 compiler.codeGenerator.op_jne( 2 );
1153
1154 //xor ecx,ecx
1155 compiler.codeGenerator.op_xor_RR( REG_ECX );
1156
1157 //mov dword ptr[esp],ecx
1158 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
1159 }
1160 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
1161 type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
1162 ////////////////////
1163 // 64ビット整数演算
1164 ////////////////////
1165
1166 // 第1項 == 第2項
1167
1168 //第1項 edx:eax
1169 //第2項 ecx:ebx
1170 GetStackData_ToRegister(type,sp);
1171
1172 //cmp eax,ebx
1173 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
1174
1175 //jne FalseSchedule1（偽へジャンプ）
1176 CodeGenerator::PertialSchedule *pFalsePertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
1177
1178 //cmp edx,ecx
1179 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
1180
1181 //jne FalseSchedule2（偽へジャンプ）
1182 CodeGenerator::PertialSchedule *pFalsePertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
1183
1184 //mov eax,1
1185 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
1186
1187 //jmp 2（演算終了位置へジャンプ）
1188 compiler.codeGenerator.op_jmp( 2 );
1189
1190 //FalseScheduleのジャンプ先の設定
1191 compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule1 );
1192 compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule2 );
1193
1194 //xor eax,eax（eaxを0にする）
1195 compiler.codeGenerator.op_zero_reg(REG_EAX);
1196
1197 //push eax
1198 compiler.codeGenerator.op_push(REG_EAX);
1199 }
1200 else{
1201 ////////////////////
1202 // 32ビット整数演算
1203 ////////////////////
1204
1205 //pop eax
1206 compiler.codeGenerator.op_pop(REG_EAX);
1207
1208 //pop ebx
1209 compiler.codeGenerator.op_pop(REG_EBX);
1210
1211 // どちらかのサイズが足りない場合は自動拡張する
1212 AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
1213
1214 //sub esp,4
1215 compiler.codeGenerator.op_sub_esp(4);
1216
1217 //xor eax,ebx
1218 compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
1219
1220 //je 4（次のxorとjmpを飛び越す）
1221 compiler.codeGenerator.op_je( 4 );
1222
1223 //xor eax,eax
1224 compiler.codeGenerator.op_xor_RR( REG_EAX );
1225
1226 //jmp 5
1227 compiler.codeGenerator.op_jmp( 5 );
1228
1229 //mov eax,1
1230 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
1231
1232 //mov dword ptr[esp],eax
1233 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
1234 }
1235
1236 sp--;
1237 type[sp-1]=DEF_BOOLEAN;
1238
1239 *pStackPointer=sp;
1240 return 1;
1241}
Note: See TracBrowser for help on using the repository browser.