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

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