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

Last change on this file since 226 was 225, checked in by dai_9181, 17 years ago

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