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

Last change on this file since 193 was 97, checked in by dai_9181, 18 years ago

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