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

Last change on this file since 433 was 290, checked in by dai_9181, 17 years ago

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