source: dev/trunk/ab5.0/abdev/compiler_x86/NumOpe_Relation.cpp@ 797

Last change on this file since 797 was 465, checked in by dai_9181, 17 years ago

Messenger/ErrorMessengerクラスを導入。SetError関数によるエラー生成を廃止した。
File size: 29.3 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 compiler.errorMessenger.OutputFatalError();
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 const 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 const 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 const 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 compiler.codeGenerator.op_je( 2 );
332
333 //xor ecx,ecx
334 compiler.codeGenerator.op_xor_RR( REG_ECX );
335
336 //mov dword ptr[esp],ecx
337 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
338 }
339 else if(Is64Type(AnswerType)){
340 ////////////////////
341 // 64ビット整数演算
342 ////////////////////
343
344 // 第1項 >= 第2項
345
346 //第1項 edx:eax
347 //第2項 ecx:ebx
348 GetStackData_ToRegister(type_stack,sp);
349
350 //cmp edx,ecx
351 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
352
353 const PertialSchedule *pFalsePertialSchedule1;
354 if(IsSignedType(AnswerType)){
355 //符号あり演算
356
357 //jl FalseSchedule1（偽へジャンプ）
358 pFalsePertialSchedule1 = compiler.codeGenerator.op_jl( 0, sizeof(char), true );
359 }
360 else{
361 //符号なし演算
362
363 //jb FalseSchedule1（偽へジャンプ）
364 pFalsePertialSchedule1 = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
365 }
366
367 const PertialSchedule *pTruePertialSchedule;
368 if(IsSignedType(AnswerType)){
369 //符号あり演算
370
371 //jg TrueSchedule（真へジャンプ）
372 pTruePertialSchedule = compiler.codeGenerator.op_jg( 0, sizeof(char), true );
373 }
374 else{
375 //符号なし演算
376
377 //ja TrueSchedule（真へジャンプ）
378 pTruePertialSchedule = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
379 }
380
381 //cmp eax,ebx
382 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
383
384 //jb FalseSchedule2（偽へジャンプ）
385 const PertialSchedule *pFalsePertialSchedule2 = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
386
387 //TrueScheduleのジャンプ先の設定
388 compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule );
389
390 //mov eax,1
391 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
392
393 //jmp 2（演算終了位置へジャンプ）
394 compiler.codeGenerator.op_jmp( 2 );
395
396 //FalseScheduleのジャンプ先の設定
397 compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule1 );
398 compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule2 );
399
400 //xor eax,eax（eaxを0にする）
401 compiler.codeGenerator.op_zero_reg(REG_EAX);
402
403 //push eax
404 compiler.codeGenerator.op_push(REG_EAX);
405 }
406 else{
407 ////////////////////
408 // 32ビット整数演算
409 ////////////////////
410
411 //pop ebx
412 compiler.codeGenerator.op_pop(REG_EBX);
413
414 //pop eax
415 compiler.codeGenerator.op_pop(REG_EAX);
416
417 // どちらかのサイズが足りない場合は自動拡張する
418 AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
419
420 //sub esp,4
421 compiler.codeGenerator.op_sub_esp(4);
422
423 //mov ecx,1
424 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
425
426 //cmp eax,ebx
427 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
428
429 if(IsSignedType(AnswerType)){
430 //符号あり演算
431
432 //jge 2（次のxorを飛び越す）符号有り
433 compiler.codeGenerator.op_jge( 2 );
434 }
435 else{
436 //符号なし演算
437
438 //jae 2（次のxorを飛び越す）
439 compiler.codeGenerator.op_jae( 2 );
440 }
441
442 //xor ecx,ecx
443 compiler.codeGenerator.op_xor_RR( REG_ECX );
444
445 //mov dword ptr[esp],ecx
446 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
447 }
448
449 sp--;
450 type_stack[sp-1]=DEF_BOOLEAN;
451
452 *pStackPointer=sp;
453 return 1;
454}
455
456BOOL Calc_Relation_P(int *type_stack,LONG_PTR *index_stack,int *pStackPointer){
457 //value[sp-2]<value[sp-1]
458
459 int sp;
460 sp=*pStackPointer;
461
462 int AnswerType;
463 AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
464
465 if(IsRealNumberType(AnswerType)){
466 //////////////
467 // 実数演算
468 //////////////
469
470 if(type_stack[sp-1]==DEF_DOUBLE){
471 //fld qword ptr[esp]
472 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
473
474 //add esp,8
475 compiler.codeGenerator.op_add_esp(8);
476 }
477 else if(type_stack[sp-1]==DEF_SINGLE){
478 //fld dword ptr[esp]
479 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
480
481 //add esp,4
482 compiler.codeGenerator.op_add_esp(4);
483 }
484 else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
485 //64ビット整数値
486
487 //fild qword ptr[esp]
488 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
489
490 //add esp,8
491 compiler.codeGenerator.op_add_esp(8);
492 }
493 else{
494 //その他整数型
495
496 //fild dword ptr[esp]
497 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
498
499 //add esp,4
500 compiler.codeGenerator.op_add_esp(4);
501 }
502
503 if(type_stack[sp-2]==DEF_DOUBLE){
504 //fld qword ptr[esp]
505 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
506
507 //add esp,4
508 compiler.codeGenerator.op_add_esp(4);
509 }
510 else if(type_stack[sp-2]==DEF_SINGLE){
511 //fld dword ptr[esp]
512 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
513 }
514 else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
515 //64ビット整数値
516
517 //fild qword ptr[esp]
518 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
519
520 //add esp,4
521 compiler.codeGenerator.op_add_esp(4);
522 }
523 else{
524 //その他整数型
525
526 //fild dword ptr[esp]
527 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
528 }
529
530 //fcompp
531 compiler.codeGenerator.op_fcompp();
532
533 //fnstsw ax
534 compiler.codeGenerator.op_fnstsw_ax();
535
536 //mov ecx,1
537 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
538
539 //test ah,01h
540 compiler.codeGenerator.op_test_ah( (char)0x01 );
541
542 //jne 2
543 compiler.codeGenerator.op_jne( 2 );
544
545 //xor ecx,ecx
546 compiler.codeGenerator.op_xor_RR( REG_ECX );
547
548 //mov dword ptr[esp],ecx
549 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
550 }
551 else if(Is64Type(AnswerType)){
552 ////////////////////
553 // 64ビット整数演算
554 ////////////////////
555
556 // 第1項 < 第2項
557
558 //第1項 edx:eax
559 //第2項 ecx:ebx
560 GetStackData_ToRegister(type_stack,sp);
561
562 //cmp edx,ecx
563 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
564
565 const PertialSchedule *pTruePertialSchedule1;
566 if(IsSignedType(AnswerType)){
567 //符号あり演算
568
569 //jl TrueSchedule1（真へジャンプ）
570 pTruePertialSchedule1 = compiler.codeGenerator.op_jl( 0, sizeof(char), true );
571 }
572 else{
573 //符号なし演算
574
575 //jb TrueSchedule1（真へジャンプ）
576 pTruePertialSchedule1 = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
577 }
578
579 const PertialSchedule *pFalsePertialSchedule;
580 if(IsSignedType(AnswerType)){
581 //符号あり演算
582
583 //jg FalseSchedule（偽へジャンプ）
584 pFalsePertialSchedule = compiler.codeGenerator.op_jg( 0, sizeof(char), true );
585 }
586 else{
587 //符号なし演算
588
589 //ja FalseSchedule（偽へジャンプ）
590 pFalsePertialSchedule = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
591 }
592
593 //cmp eax,ebx
594 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
595
596 //jb TrueSchedule2（真へジャンプ）
597 const PertialSchedule *pTruePertialSchedule2 = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
598
599 //FalseScheduleのジャンプ先の設定
600 compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule );
601
602 //xor eax,eax（eaxを0にする）
603 compiler.codeGenerator.op_zero_reg(REG_EAX);
604
605 //jmp 5（演算終了位置へジャンプ）
606 compiler.codeGenerator.op_jmp( 5 );
607
608 //TrueScheduleのジャンプ先の設定
609 compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule1 );
610 compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule2 );
611
612 //mov eax,1
613 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
614
615 //push eax
616 compiler.codeGenerator.op_push(REG_EAX);
617 }
618 else{
619 ///////////////////
620 //32ビット整数演算
621 ///////////////////
622
623 //pop ebx
624 compiler.codeGenerator.op_pop(REG_EBX);
625
626 //pop eax
627 compiler.codeGenerator.op_pop(REG_EAX);
628
629 // どちらかのサイズが足りない場合は自動拡張する
630 AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
631
632 //sub esp,4
633 compiler.codeGenerator.op_sub_esp(4);
634
635 //mov ecx,1
636 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
637
638 //cmp eax,ebx
639 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
640
641 if(IsSignedType(AnswerType)){
642 //符号あり演算
643
644 //jl 2（次のxorを飛び越す）
645 compiler.codeGenerator.op_jl( 2 );
646 }
647 else{
648 //符号なし演算
649
650 //jb 2（次のxorを飛び越す）
651 compiler.codeGenerator.op_jb( 2 );
652 }
653
654 //xor ecx,ecx
655 compiler.codeGenerator.op_xor_RR( REG_ECX );
656
657 //mov dword ptr[esp],ecx
658 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
659 }
660
661 sp--;
662 type_stack[sp-1]=DEF_BOOLEAN;
663
664 *pStackPointer=sp;
665 return 1;
666}
667
668BOOL Calc_Relation_Q(int *type_stack,LONG_PTR *index_stack,int *pStackPointer){
669 //value[sp-2]>value[sp-1]
670
671 int sp;
672 sp=*pStackPointer;
673
674 int AnswerType;
675 AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
676
677 if(IsRealNumberType(AnswerType)){
678 //////////////
679 // 実数演算
680 //////////////
681
682 if(type_stack[sp-1]==DEF_DOUBLE){
683 //fld qword ptr[esp]
684 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
685
686 //add esp,8
687 compiler.codeGenerator.op_add_esp(8);
688 }
689 else if(type_stack[sp-1]==DEF_SINGLE){
690 //fld dword ptr[esp]
691 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
692
693 //add esp,4
694 compiler.codeGenerator.op_add_esp(4);
695 }
696 else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
697 //64ビット整数値
698
699 //fild qword ptr[esp]
700 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
701
702 //add esp,8
703 compiler.codeGenerator.op_add_esp(8);
704 }
705 else{ //Long、DWord
706 //fild dword ptr[esp]
707 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
708
709 //add esp,4
710 compiler.codeGenerator.op_add_esp(4);
711 }
712
713 if(type_stack[sp-2]==DEF_DOUBLE){
714 //fld qword ptr[esp]
715 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
716
717 //add esp,4
718 compiler.codeGenerator.op_add_esp(4);
719 }
720 else if(type_stack[sp-2]==DEF_SINGLE){
721 //fld dword ptr[esp]
722 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
723 }
724 else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
725 //64ビット整数値
726
727 //fild qword ptr[esp]
728 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
729
730 //add esp,4
731 compiler.codeGenerator.op_add_esp(4);
732 }
733 else{ //Long、DWord
734 //fild dword ptr[esp]
735 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
736 }
737
738 //fcompp
739 compiler.codeGenerator.op_fcompp();
740
741 //fnstsw ax
742 compiler.codeGenerator.op_fnstsw_ax();
743
744 //mov ecx,1
745 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
746
747 //test ah,41
748 compiler.codeGenerator.op_test_ah( (char)0x41 );
749
750 //je 2（次のxorを飛び越す）
751 compiler.codeGenerator.op_je( 2 );
752
753 //xor ecx,ecx
754 compiler.codeGenerator.op_xor_RR( REG_ECX );
755
756 //mov dword ptr[esp],ecx
757 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
758 }
759 else if(Is64Type(AnswerType)){
760 ////////////////////
761 // 64ビット整数演算
762 ////////////////////
763
764 // 第1項 > 第2項
765
766 //第1項 edx:eax
767 //第2項 ecx:ebx
768 GetStackData_ToRegister(type_stack,sp);
769
770 //cmp edx,ecx
771 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
772
773 const PertialSchedule *pTruePertialSchedule1;
774 if(IsSignedType(AnswerType)){
775 //符号有り
776
777 //jg TrueSchedule1（真へジャンプ）
778 pTruePertialSchedule1 = compiler.codeGenerator.op_jg( 0, sizeof(char), true );
779 }
780 else{
781 //符号無し
782
783 //ja TrueSchedule1（真へジャンプ）
784 pTruePertialSchedule1 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
785 }
786
787 const PertialSchedule *pFalsePertialSchedule;
788 if(IsSignedType(AnswerType)){
789 //符号有り
790
791 //jl FalseSchedule（偽へジャンプ）
792 pFalsePertialSchedule = compiler.codeGenerator.op_jl( 0, sizeof(char), true );
793 }
794 else{
795 //符号無し
796
797 //jb FalseSchedule（偽へジャンプ）
798 pFalsePertialSchedule = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
799 }
800
801 //cmp eax,ebx
802 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
803
804 //ja TrueSchedule2（真へジャンプ）
805 const PertialSchedule *pTruePertialSchedule2 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
806
807 //FalseScheduleのジャンプ先の設定
808 compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule );
809
810 //xor eax,eax（eaxを0にする）
811 compiler.codeGenerator.op_zero_reg(REG_EAX);
812
813 //jmp 5（演算終了位置へジャンプ）
814 compiler.codeGenerator.op_jmp( 5 );
815
816 //TrueScheduleのジャンプ先の設定
817 compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule1 );
818 compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule2 );
819
820 //mov eax,1
821 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
822
823 //push eax
824 compiler.codeGenerator.op_push(REG_EAX);
825 }
826 else{
827 ////////////////////
828 // 32ビット整数演算
829 ////////////////////
830
831 //pop ebx
832 compiler.codeGenerator.op_pop(REG_EBX);
833
834 //pop eax
835 compiler.codeGenerator.op_pop(REG_EAX);
836
837 // どちらかのサイズが足りない場合は自動拡張する
838 AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
839
840 //sub esp,4
841 compiler.codeGenerator.op_sub_esp(4);
842
843 //mov ecx,1
844 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
845
846 //cmp eax,ebx
847 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
848
849 if(IsSignedType(AnswerType)){
850 //jg 2（次のxorを飛び越す）
851 compiler.codeGenerator.op_jg( 2 );
852 }
853 else{
854 //ja 2（次のxorを飛び越す）
855 compiler.codeGenerator.op_ja( 2 );
856 }
857
858 //xor ecx,ecx
859 compiler.codeGenerator.op_xor_RR( REG_ECX );
860
861 //mov dword ptr[esp],ecx
862 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
863 }
864
865 sp--;
866 type_stack[sp-1]=DEF_BOOLEAN;
867
868 *pStackPointer=sp;
869 return 1;
870}
871
872BOOL Calc_Relation_NotEqual(int *type,int *pStackPointer){
873 //value[sp-2]<>value[sp-1]
874
875 int sp;
876 sp=*pStackPointer;
877
878 if(type[sp-2]==DEF_DOUBLE||type[sp-2]==DEF_SINGLE||
879 type[sp-1]==DEF_DOUBLE||type[sp-1]==DEF_SINGLE){
880 //////////////
881 // 実数演算
882 //////////////
883
884 if(type[sp-1]==DEF_DOUBLE){
885 //fld qword ptr[esp]
886 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
887
888 //add esp,8
889 compiler.codeGenerator.op_add_esp(8);
890 }
891 else if(type[sp-1]==DEF_SINGLE){
892 //fld dword ptr[esp]
893 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
894
895 //add esp,4
896 compiler.codeGenerator.op_add_esp(4);
897 }
898 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
899 //64ビット整数値
900
901 //fild qword ptr[esp]
902 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
903
904 //add esp,8
905 compiler.codeGenerator.op_add_esp(8);
906 }
907 else{ //Long、DWord
908 //fild dword ptr[esp]
909 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
910
911 //add esp,4
912 compiler.codeGenerator.op_add_esp(4);
913 }
914
915 if(type[sp-2]==DEF_DOUBLE){
916 //fld qword ptr[esp]
917 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
918
919 //add esp,4
920 compiler.codeGenerator.op_add_esp(4);
921 }
922 else if(type[sp-2]==DEF_SINGLE){
923 //fld dword ptr[esp]
924 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
925 }
926 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
927 //64ビット整数値
928
929 //fild qword ptr[esp]
930 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
931
932 //add esp,4
933 compiler.codeGenerator.op_add_esp(4);
934 }
935 else{ //Long、DWord
936 //fild dword ptr[esp]
937 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
938 }
939
940 //fcompp
941 compiler.codeGenerator.op_fcompp();
942
943 //fnstsw ax
944 compiler.codeGenerator.op_fnstsw_ax();
945
946 //mov ecx,1
947 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
948
949 //test ah,40
950 compiler.codeGenerator.op_test_ah( (char)0x40 );
951
952 //je 2
953 compiler.codeGenerator.op_je( 2 );
954
955 //xor ecx,ecx
956 compiler.codeGenerator.op_xor_RR( REG_ECX );
957
958 //mov dword ptr[esp],ecx
959 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
960 }
961 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
962 type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
963 ////////////////////
964 // 64ビット整数演算
965 ////////////////////
966
967 // 第1項 <> 第2項
968
969 //第1項 edx:eax
970 //第2項 ecx:ebx
971 GetStackData_ToRegister(type,sp);
972
973 //cmp eax,ebx
974 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
975
976 //jne TrueSchedule1（真へジャンプ）
977 const PertialSchedule *pTruePertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
978
979 //cmp edx,ecx
980 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
981
982 //jne TrueSchedule2（真へジャンプ）
983 const PertialSchedule *pTruePertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
984
985 //xor eax,eax（eaxを0にする）
986 compiler.codeGenerator.op_zero_reg(REG_EAX);
987
988 //jmp 5（演算終了位置へジャンプ）
989 compiler.codeGenerator.op_jmp( 5 );
990
991 //TrueScheduleのジャンプ先の設定
992 compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule1 );
993 compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule2 );
994
995 //mov eax,1
996 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
997
998 //push eax
999 compiler.codeGenerator.op_push(REG_EAX);
1000 }
1001 else{
1002 ////////////////////
1003 // 32ビット整数演算
1004 ////////////////////
1005
1006 //pop eax
1007 compiler.codeGenerator.op_pop(REG_EAX);
1008
1009 //pop ebx
1010 compiler.codeGenerator.op_pop(REG_EBX);
1011
1012 // どちらかのサイズが足りない場合は自動拡張する
1013 AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
1014
1015 //sub esp,4
1016 compiler.codeGenerator.op_sub_esp(4);
1017
1018 //xor eax,ebx
1019 compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
1020
1021 //je 5（次のmovを飛び越す）
1022 compiler.codeGenerator.op_je( 5 );
1023
1024 //mov eax,1
1025 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
1026
1027 //mov dword ptr[esp],eax
1028 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
1029 }
1030
1031 sp--;
1032 type[sp-1]=DEF_BOOLEAN;
1033
1034 *pStackPointer=sp;
1035 return 1;
1036}
1037
1038BOOL Calc_Relation_Equal(int *type,int *pStackPointer){
1039 //value[sp-2]=value[sp-1]
1040
1041 int sp;
1042 sp=*pStackPointer;
1043
1044 if(type[sp-2]==DEF_DOUBLE||type[sp-2]==DEF_SINGLE||
1045 type[sp-1]==DEF_DOUBLE||type[sp-1]==DEF_SINGLE){
1046 //////////////
1047 // 実数演算
1048 //////////////
1049
1050 if(type[sp-1]==DEF_DOUBLE){
1051 //fld qword ptr[esp]
1052 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1053
1054 //add esp,8
1055 compiler.codeGenerator.op_add_esp(8);
1056 }
1057 else if(type[sp-1]==DEF_SINGLE){
1058 //fld dword ptr[esp]
1059 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1060
1061 //add esp,4
1062 compiler.codeGenerator.op_add_esp(4);
1063 }
1064 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
1065 //64ビット整数値
1066
1067 //fild qword ptr[esp]
1068 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
1069
1070 //add esp,8
1071 compiler.codeGenerator.op_add_esp(8);
1072 }
1073 else{ //Long、DWord
1074 //fild dword ptr[esp]
1075 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
1076
1077 //add esp,4
1078 compiler.codeGenerator.op_add_esp(4);
1079 }
1080
1081 if(type[sp-2]==DEF_DOUBLE){
1082 //fld qword ptr[esp]
1083 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1084
1085 //add esp,4
1086 compiler.codeGenerator.op_add_esp(4);
1087 }
1088 else if(type[sp-2]==DEF_SINGLE){
1089 //fld dword ptr[esp]
1090 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1091 }
1092 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
1093 //64ビット整数値
1094
1095 //fild qword ptr[esp]
1096 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
1097
1098 //add esp,4
1099 compiler.codeGenerator.op_add_esp(4);
1100 }
1101 else{ //Long、DWord
1102 //fild dword ptr[esp]
1103 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
1104 }
1105
1106 //fcompp
1107 compiler.codeGenerator.op_fcompp();
1108
1109 //fnstsw ax
1110 compiler.codeGenerator.op_fnstsw_ax();
1111
1112 //mov ecx,1
1113 compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
1114
1115 //test ah,40
1116 compiler.codeGenerator.op_test_ah( (char)0x40 );
1117
1118 //jne 2（次のxorを飛び越す）
1119 compiler.codeGenerator.op_jne( 2 );
1120
1121 //xor ecx,ecx
1122 compiler.codeGenerator.op_xor_RR( REG_ECX );
1123
1124 //mov dword ptr[esp],ecx
1125 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
1126 }
1127 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
1128 type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
1129 ////////////////////
1130 // 64ビット整数演算
1131 ////////////////////
1132
1133 // 第1項 == 第2項
1134
1135 //第1項 edx:eax
1136 //第2項 ecx:ebx
1137 GetStackData_ToRegister(type,sp);
1138
1139 //cmp eax,ebx
1140 compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
1141
1142 //jne FalseSchedule1（偽へジャンプ）
1143 const PertialSchedule *pFalsePertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
1144
1145 //cmp edx,ecx
1146 compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
1147
1148 //jne FalseSchedule2（偽へジャンプ）
1149 const PertialSchedule *pFalsePertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
1150
1151 //mov eax,1
1152 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
1153
1154 //jmp 2（演算終了位置へジャンプ）
1155 compiler.codeGenerator.op_jmp( 2 );
1156
1157 //FalseScheduleのジャンプ先の設定
1158 compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule1 );
1159 compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule2 );
1160
1161 //xor eax,eax（eaxを0にする）
1162 compiler.codeGenerator.op_zero_reg(REG_EAX);
1163
1164 //push eax
1165 compiler.codeGenerator.op_push(REG_EAX);
1166 }
1167 else{
1168 ////////////////////
1169 // 32ビット整数演算
1170 ////////////////////
1171
1172 //pop eax
1173 compiler.codeGenerator.op_pop(REG_EAX);
1174
1175 //pop ebx
1176 compiler.codeGenerator.op_pop(REG_EBX);
1177
1178 // どちらかのサイズが足りない場合は自動拡張する
1179 AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
1180
1181 //sub esp,4
1182 compiler.codeGenerator.op_sub_esp(4);
1183
1184 //xor eax,ebx
1185 compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
1186
1187 //je 4（次のxorとjmpを飛び越す）
1188 compiler.codeGenerator.op_je( 4 );
1189
1190 //xor eax,eax
1191 compiler.codeGenerator.op_xor_RR( REG_EAX );
1192
1193 //jmp 5
1194 compiler.codeGenerator.op_jmp( 5 );
1195
1196 //mov eax,1
1197 compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
1198
1199 //mov dword ptr[esp],eax
1200 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
1201 }
1202
1203 sp--;
1204 type[sp-1]=DEF_BOOLEAN;
1205
1206 *pStackPointer=sp;
1207 return 1;
1208}
Note: See TracBrowser for help on using the repository browser.