source: dev/trunk/abdev/BasicCompiler32/NumOpe_Arithmetic.cpp@ 210

Last change on this file since 210 was 206, checked in by dai_9181, 17 years ago

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