source: dev/BasicCompiler64/NumOpe_Arithmetic.cpp@ 3

Last change on this file since 3 was 3, checked in by dai_9181, 17 years ago
File size: 16.4 KB
Line 
1#include "../BasicCompiler_Common/common.h"
2#include "Opcode.h"
3
4void GetStackData_ToRegister(int *type,int sp){
5 /*NumOpeポーランドのスタック蓄積による演算内容（2つのデータ）を
6 レジスタedx:eax、ecx:ebxに取得する*/
7
8 if(type[sp-1]==DEF_DOUBLE){
9 //fld qword ptr[esp]
10 op_fld_ptr_esp(DEF_DOUBLE);
11
12 //fistp qword ptr[esp]
13 OpBuffer[obp++]=(char)0xDF;
14 OpBuffer[obp++]=(char)0x3C;
15 OpBuffer[obp++]=(char)0x24;
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 OpBuffer[obp++]=(char)0xDF;
32 OpBuffer[obp++]=(char)0x3C;
33 OpBuffer[obp++]=(char)0x24;
34
35 //pop ebx
36 op_pop(REG_EBX);
37
38 //pop ecx
39 op_pop(REG_ECX);
40 }
41 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
42 //pop ebx
43 op_pop(REG_EBX);
44
45 //pop ecx
46 op_pop(REG_ECX);
47 }
48 else{
49 //pop eax
50 op_pop(REG_EAX);
51
52 if(IsSignedType(type[sp-1])){
53 //符号拡張
54 //edx:eax ← eax
55
56 //cdq
57 OpBuffer[obp++]=(char)0x99;
58 }
59 else{
60 //ビット拡張
61 //edx:eax ← eax
62
63 //xor rdx,rdx
64 op_zero_reg(REG_RDX);
65 }
66
67 //mov ebx,eax
68 OpBuffer[obp++]=(char)0x8B;
69 OpBuffer[obp++]=(char)0xD8;
70
71 //mov ecx,edx
72 OpBuffer[obp++]=(char)0x8B;
73 OpBuffer[obp++]=(char)0xCA;
74 }
75
76 //第1項を64ビットに対応させる
77 if(type[sp-2]==DEF_DOUBLE){
78 //fld qword ptr[esp]
79 op_fld_ptr_esp(DEF_DOUBLE);
80
81 //fistp qword ptr[esp]
82 OpBuffer[obp++]=(char)0xDF;
83 OpBuffer[obp++]=(char)0x3C;
84 OpBuffer[obp++]=(char)0x24;
85
86 //pop eax
87 op_pop(REG_EAX);
88
89 //pop edx
90 op_pop(REG_EDX);
91 }
92 else if(type[sp-2]==DEF_SINGLE){
93 //fld dword ptr[esp]
94 op_fld_ptr_esp(DEF_SINGLE);
95
96 //sub esp,4
97 op_sub_esp(4);
98
99 //fistp qword ptr[esp]
100 OpBuffer[obp++]=(char)0xDF;
101 OpBuffer[obp++]=(char)0x3C;
102 OpBuffer[obp++]=(char)0x24;
103
104 //pop eax
105 op_pop(REG_EAX);
106
107 //pop edx
108 op_pop(REG_EDX);
109 }
110 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
111 //pop eax
112 op_pop(REG_EAX);
113
114 //pop edx
115 op_pop(REG_EDX);
116 }
117 else{
118 //pop eax
119 op_pop(REG_EAX);
120
121 if(IsSignedType(type[sp-2])){
122 //符号拡張
123 //edx:eax ← eax
124
125 //cdq
126 OpBuffer[obp++]=(char)0x99;
127 }
128 else{
129 //ビット拡張
130 //edx:eax ← eax
131
132 //xor rdx,rdx
133 op_zero_reg(REG_RDX);
134 }
135 }
136}
137
138BOOL CalcTwoTerm_Arithmetic(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer){
139 /* value[sp-2] = value[sp-2] + value[sp-1]
140 value[sp-2] = value[sp-2] - value[sp-1]
141 value[sp-2] = value[sp-2] * value[sp-1] */
142
143 int reg1,reg2;
144
145 int sp;
146 sp=*pStackPointer;
147
148 int AnswerType;
149 AnswerType=NeutralizationType(type[sp-2],index_stack[sp-2],type[sp-1],index_stack[sp-1]);
150
151 if(type[sp-2]==DEF_DOUBLE||type[sp-2]==DEF_SINGLE||
152 type[sp-1]==DEF_DOUBLE||type[sp-1]==DEF_SINGLE){
153 /////////////
154 // 実数演算
155 /////////////
156
157 int xmm_reg1,xmm_reg2;
158
159 //2つの項を適切なレジスタにセット
160 SetTowTermToReg_RealCalc(AnswerType,type,sp,&xmm_reg1,&xmm_reg2);
161
162 if(AnswerType==DEF_DOUBLE){
163 ///////////////////////
164 // Double演算
165 ///////////////////////
166
167 if(idCalc==CALC_ADDITION){
168 //addsd xmm_reg1,xmm_reg2
169 OpBuffer[obp++]=(char)0xF2;
170 OpBuffer[obp++]=(char)0x0F;
171 OpBuffer[obp++]=(char)0x58;
172 OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2));
173 }
174 else if(idCalc==CALC_SUBTRACTION){
175 //subsd xmm_reg1,xmm_reg2
176 OpBuffer[obp++]=(char)0xF2;
177 OpBuffer[obp++]=(char)0x0F;
178 OpBuffer[obp++]=(char)0x5C;
179 OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2));
180 }
181 else if(idCalc==CALC_PRODUCT){
182 //mulsd xmm_reg1,xmm_reg2
183 OpBuffer[obp++]=(char)0xF2;
184 OpBuffer[obp++]=(char)0x0F;
185 OpBuffer[obp++]=(char)0x59;
186 OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2));
187 }
188
189 if(xmm_reg1==REG_XMM4){
190 //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
191 pobj_sf->push(REG_XMM4,sizeof(double));
192 }
193 }
194 if(AnswerType==DEF_SINGLE){
195 ///////////////////////
196 // Single演算
197 ///////////////////////
198
199 if(idCalc==CALC_ADDITION){
200 //addss xmm_reg1,xmm_reg2
201 OpBuffer[obp++]=(char)0xF3;
202 OpBuffer[obp++]=(char)0x0F;
203 OpBuffer[obp++]=(char)0x58;
204 OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2));
205 }
206 else if(idCalc==CALC_SUBTRACTION){
207 //subss xmm_reg1,xmm_reg2
208 OpBuffer[obp++]=(char)0xF3;
209 OpBuffer[obp++]=(char)0x0F;
210 OpBuffer[obp++]=(char)0x5C;
211 OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2));
212 }
213 else if(idCalc==CALC_PRODUCT){
214 //mulss xmm_reg1,xmm_reg2
215 OpBuffer[obp++]=(char)0xF3;
216 OpBuffer[obp++]=(char)0x0F;
217 OpBuffer[obp++]=(char)0x59;
218 OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2));
219 }
220
221 if(xmm_reg1==REG_XMM4){
222 //movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
223 pobj_sf->push(REG_XMM4,sizeof(float));
224 }
225 }
226 }
227 else if(Is64Type(type[sp-2])||Is64Type(type[sp-1])){
228 //////////////////////
229 // 64ビット整数演算
230 //////////////////////
231
232 SetTowTermToReg_Whole64Calc(type,sp,&reg1,&reg2);
233
234 if(idCalc==CALC_ADDITION){
235 //add reg1,reg2
236 op_add64_reg(reg1,reg2);
237 }
238 else if(idCalc==CALC_SUBTRACTION){
239 //sub reg1,reg2
240 op_sub64_reg(reg1,reg2);
241 }
242 else if(idCalc==CALC_PRODUCT){
243 //mul reg1,reg2
244 op_imul_reg(sizeof(_int64),reg1,reg2);
245 }
246
247 if(reg1==REG_R14){
248 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
249 pobj_sf->push(REG_R14);
250 }
251 }
252 else{
253 //32ビット以下の整数演算
254
255 SetTowTermToReg_Whole32Calc(type,sp,&reg1,&reg2);
256
257 if(idCalc==CALC_ADDITION){
258 //add reg1,reg2
259 op_add32_reg(reg1,reg2);
260 }
261 else if(idCalc==CALC_SUBTRACTION){
262 //sub reg1,reg2
263 op_sub32_reg(reg1,reg2);
264 }
265 else if(idCalc==CALC_PRODUCT){
266 //mul reg1,reg2
267 op_imul_reg(sizeof(long),reg1,reg2);
268 }
269
270 if(reg1==REG_R14){
271 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
272 pobj_sf->push(REG_R14);
273 }
274 }
275
276 sp--;
277 type[sp-1]=AnswerType;
278
279 *pStackPointer=sp;
280
281 return 1;
282}
283
284
285
286BOOL Calc_Mod(int *type,LONG_PTR *index_stack,int *pStackPointer){
287 //value[sp-2]%=value[sp-1]
288 //剰余演算
289
290 int reg1,reg2;
291 int AnswerType;
292
293 int sp;
294 sp=*pStackPointer;
295
296 if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
297 //実数演算は行えないため、エラー扱い
298 SetError(45,"mod",cp);
299 return 0;
300 }
301
302 /////////////////////////
303 // 64ビット整数演算のみ
304 /////////////////////////
305
306 AnswerType=NeutralizationType(type[sp-2],index_stack[sp-2],type[sp-1],index_stack[sp-1]);
307
308 //2つの項を適切なレジスタにセット
309 SetTowTermToReg_Whole64Calc(type,sp,&reg1,&reg2);
310
311 if(reg2==REG_RAX||reg2==REG_RDX){
312 //mov r15,reg2
313 op_mov64_ToReg_FromReg(REG_R15,reg2);
314
315 reg2=REG_R15;
316 }
317
318 //mov qword ptr[rsp+offset],rax ※スタックフレームを利用
319 pobj_sf->push(REG_RAX);
320
321 if(reg1!=REG_RDX){
322 //mov qword ptr[rsp+offset],rdx ※スタックフレームを利用
323 pobj_sf->push(REG_RDX);
324 }
325
326 //mov rax,reg1
327 op_mov64_ToReg_FromReg(REG_RAX,reg1);
328
329 if(IsSignedType(type[sp-2])){
330 //符号拡張
331 //rdx:rax ← rax
332
333 //cqo
334 OpBuffer[obp++]=(char)0x48;
335 OpBuffer[obp++]=(char)0x99;
336 }
337 else{
338 //ビット拡張
339 //rdx:rax ← rax
340
341 //xor rdx,rdx
342 op_zero_reg(REG_RDX);
343 }
344
345 if(IsSignedType(AnswerType)){
346 //idiv reg2
347 op_idiv64_reg(reg2);
348 }
349 else{
350 //div reg2
351 op_div64_reg(reg2);
352 }
353
354 //mov rax,qword ptr[rsp+offset] ※スタックフレームを利用
355 pobj_sf->pop(REG_RAX);
356
357 //mov reg1,rdx
358 op_mov64_ToReg_FromReg(reg1,REG_RDX);
359
360 if(reg1!=REG_RDX){
361 //mov rdx,qword ptr[rsp+offset] ※スタックフレームを利用
362 pobj_sf->pop(REG_RDX);
363 }
364
365 if(reg1==REG_R14){
366 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
367 pobj_sf->push(REG_R14);
368 }
369
370 sp--;
371 type[sp-1]=AnswerType;
372
373
374 *pStackPointer=sp;
375
376 return 1;
377}
378
379BOOL Calc_Divide(int *type,int *pStackPointer,int BaseType){
380 //value[sp-2]/=value[sp-1];
381 //除算
382
383 int sp;
384 sp=*pStackPointer;
385
386 ///////////////////////
387 // 実数演算のみ
388 ///////////////////////
389
390 int AnswerType;
391 if(type[sp-2]==DEF_SINGLE&&type[sp-1]==DEF_SINGLE&&BaseType==DEF_SINGLE) AnswerType=DEF_SINGLE;
392 else AnswerType=DEF_DOUBLE;
393
394 int xmm_reg1,xmm_reg2;
395
396 //2つの項を適切なレジスタにセット
397 SetTowTermToReg_RealCalc(AnswerType,type,sp,&xmm_reg1,&xmm_reg2);
398
399 if(AnswerType==DEF_DOUBLE){
400 ///////////////////////
401 // Double演算
402 ///////////////////////
403
404 //divsd xmm_reg1,xmm_reg2
405 OpBuffer[obp++]=(char)0xF2;
406 OpBuffer[obp++]=(char)0x0F;
407 OpBuffer[obp++]=(char)0x5E;
408 OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2));
409
410 if(xmm_reg1==REG_XMM4){
411 //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
412 pobj_sf->push(REG_XMM4,sizeof(double));
413 }
414 }
415 if(AnswerType==DEF_SINGLE){
416 ///////////////////////
417 // Single演算
418 ///////////////////////
419
420 //divss xmm_reg1,xmm_reg2
421 OpBuffer[obp++]=(char)0xF3;
422 OpBuffer[obp++]=(char)0x0F;
423 OpBuffer[obp++]=(char)0x5E;
424 OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2));
425
426 if(xmm_reg1==REG_XMM4){
427 //movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
428 pobj_sf->push(REG_XMM4,sizeof(float));
429 }
430 }
431
432 sp--;
433 type[sp-1]=AnswerType;
434
435
436 *pStackPointer=sp;
437
438 return 1;
439}
440
441BOOL Calc_IntDivide(int *type,LONG_PTR *index_stack,int *pStackPointer){
442 //value[sp-2]/=value[sp-1]
443 //除算（整数）
444
445 int reg1,reg2;
446 int AnswerType;
447
448 int sp;
449 sp=*pStackPointer;
450
451 if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
452 //実数演算は行えないため、エラー扱い
453 SetError(45,"mod",cp);
454 return 0;
455 }
456
457 /////////////////////////
458 // 64ビット整数演算のみ
459 /////////////////////////
460
461 AnswerType=NeutralizationType(type[sp-2],index_stack[sp-2],type[sp-1],index_stack[sp-1]);
462
463 //2つの項を適切なレジスタにセット
464 SetTowTermToReg_Whole64Calc(type,sp,&reg1,&reg2);
465
466 if(reg2==REG_RAX||reg2==REG_RDX){
467 //mov r15,reg2
468 op_mov64_ToReg_FromReg(REG_R15,reg2);
469
470 reg2=REG_R15;
471 }
472
473 //mov qword ptr[rsp+offset],rdx ※スタックフレームを利用
474 pobj_sf->push(REG_RDX);
475
476 if(reg1!=REG_RAX){
477 //mov qword ptr[rsp+offset],rax ※スタックフレームを利用
478 pobj_sf->push(REG_RAX);
479 }
480
481 //mov rax,reg1
482 op_mov64_ToReg_FromReg(REG_RAX,reg1);
483
484 if(IsSignedType(type[sp-2])){
485 //符号拡張
486 //rdx:rax ← rax
487
488 //cqo
489 OpBuffer[obp++]=(char)0x48;
490 OpBuffer[obp++]=(char)0x99;
491 }
492 else{
493 //ビット拡張
494 //rdx:rax ← rax
495
496 //xor rdx,rdx
497 op_zero_reg(REG_RDX);
498 }
499
500 if(IsSignedType(AnswerType)){
501 //idiv reg2
502 op_idiv64_reg(reg2);
503 }
504 else{
505 //div reg2
506 op_div64_reg(reg2);
507 }
508
509 //mov reg1,rax
510 op_mov64_ToReg_FromReg(reg1,REG_RAX);
511
512 if(reg1!=REG_RAX){
513 //mov rax,qword ptr[rsp+offset] ※スタックフレームを利用
514 pobj_sf->pop(REG_RAX);
515 }
516
517 //mov rdx,qword ptr[rsp+offset] ※スタックフレームを利用
518 pobj_sf->pop(REG_RDX);
519
520
521 if(reg1==REG_R14){
522 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
523 pobj_sf->push(REG_R14);
524 }
525
526 sp--;
527 type[sp-1]=AnswerType;
528
529
530 *pStackPointer=sp;
531
532 return 1;
533}
534
535BOOL Calc_MinusMark(int *type,int sp){
536 //value[sp-1]=-value[sp-1]
537 //符号反転
538
539 int xmm_reg;
540 int reg;
541 int i32data;
542
543 if(type[sp-1]==DEF_DOUBLE){
544 SetOneTermToReg_RealCalc(type[sp-1],&xmm_reg);
545
546 double dbl;
547 dbl=-1;
548 i32data=AddDataTable((char *)&dbl,sizeof(double));
549
550 //mulsd xmm_reg,qword ptr[data table offset] ※data = -1
551 OpBuffer[obp++]=(char)0xF2;
552 OpBuffer[obp++]=(char)0x0F;
553 OpBuffer[obp++]=(char)0x59;
554 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3);
555 OpBuffer[obp++]=(char)0x25;
556 *((long *)(OpBuffer+obp))=i32data;
557 pobj_DataTableSchedule->add();
558 obp+=sizeof(long);
559
560 if(xmm_reg==REG_XMM4){
561 //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
562 pobj_sf->push(REG_XMM4,sizeof(double));
563 }
564 }
565 else if(type[sp-1]==DEF_SINGLE){
566 SetOneTermToReg_RealCalc(type[sp-1],&xmm_reg);
567
568 float flt;
569 flt=-1;
570 i32data=AddDataTable((char *)&flt,sizeof(float));
571
572 //mulss xmm_reg,dword ptr[data table offset] ※data = -1
573 OpBuffer[obp++]=(char)0xF3;
574 OpBuffer[obp++]=(char)0x0F;
575 OpBuffer[obp++]=(char)0x59;
576 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3);
577 OpBuffer[obp++]=(char)0x25;
578 *((long *)(OpBuffer+obp))=i32data;
579 pobj_DataTableSchedule->add();
580 obp+=sizeof(long);
581
582 if(xmm_reg==REG_XMM4){
583 //movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
584 pobj_sf->push(REG_XMM4,sizeof(float));
585 }
586 }
587 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
588 SetOneTermToReg_Whole64Calc(type[sp-1],&reg);
589
590 //imul reg,-1
591 op_imul_value(sizeof(_int64),reg,-1);
592
593 if(reg==REG_R14){
594 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
595 pobj_sf->push(REG_R14);
596 }
597
598 type[sp-1]=DEF_INT64; //QWordはInt64へ
599 }
600 else if(IsWholeNumberType(type[sp-1])){
601 SetOneTermToReg_Whole32Calc(type[sp-1],&reg);
602
603 //imul reg,-1
604 op_imul_value(sizeof(long),reg,-1);
605
606 if(reg==REG_R14){
607 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
608 pobj_sf->push(REG_R14);
609 }
610
611 type[sp-1]=GetSignedType(type[sp-1]);
612 }
613
614 return 1;
615}
616
617BOOL Calc_Power(int *type,int *pStackPointer){
618 //べき乗（実数演算のみ）
619
620 int sp;
621 sp=*pStackPointer;
622
623
624 //2つの項を適切なレジスタにセット
625 int xmm_reg1,xmm_reg2;
626 SetTowTermToReg_RealCalc(DEF_DOUBLE,type,sp,&xmm_reg1,&xmm_reg2);
627
628
629 //////////////////////////////////////////////////////
630 ///// レジスタ資源のバックアップ
631 { BACKUP_REGISTER_RESOURCE
632 //////////////////////////////////////////////////////
633
634
635 ////////////////
636 // 呼び出し
637 ////////////////
638
639 if(xmm_reg1==REG_XMM1){
640 //movsd xmm0,xmm_reg1
641 op_movsd_RR(REG_XMM0,xmm_reg1);
642
643 //movsd xmm1,xmm_reg2
644 op_movsd_RR(REG_XMM1,xmm_reg2);
645 }
646 else{
647 //movsd xmm1,xmm_reg2
648 op_movsd_RR(REG_XMM1,xmm_reg2);
649
650 //movsd xmm0,xmm_reg1
651 op_movsd_RR(REG_XMM0,xmm_reg1);
652 }
653
654 //call pow
655 extern SUBINFO *pSub_pow;
656 op_call(pSub_pow);
657
658 //movsd xmm4,xmm0
659 op_movsd_RR(REG_XMM4,REG_XMM0);
660
661
662 /////////////////////////////////////////////
663 ////// レジスタ資源を復元
664 RESTORE_REGISTER_RESOURCE
665 }////////////////////////////////////////////
666
667
668 //////////////////////////////////
669 // 戻り値を所定のレジスタへ格納
670 //////////////////////////////////
671
672 if(xmm_reg1==REG_XMM4){
673 //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
674 pobj_sf->push(REG_XMM0,sizeof(double));
675 }
676 else{
677 //movsd xmm_reg1,xmm4
678 op_movsd_RR(xmm_reg1,REG_XMM4);
679 }
680
681
682 sp--;
683 type[sp-1]=DEF_DOUBLE;
684
685 *pStackPointer=sp;
686 return 1;
687}
688
689BOOL Calc_Shift(int idCalc,int *type,int *pStackPointer){
690 //ビットシフト
691
692 int sp;
693 sp=*pStackPointer;
694
695 if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
696 //いずれかの項が実数のとき
697 SetError(45,"<<",cp);
698 return 0;
699 }
700
701
702 /////////////////////////
703 // 64ビット整数演算のみ
704 /////////////////////////
705 int reg1,reg2;
706
707 //2つの項を適切なレジスタにセット
708 SetTowTermToReg_Whole64Calc(type,sp,&reg1,&reg2);
709
710 int sw=0;
711 if(reg1==REG_RCX){
712 //mov r15,rcx
713 op_mov64_ToReg_FromReg(REG_R15,REG_RCX);
714
715 reg1=REG_R15;
716 }
717 else if(reg2!=REG_RCX){
718 sw=1;
719
720 //mov qword ptr[rsp+offset],rcx ※スタックフレームを利用
721 pobj_sf->push(REG_RCX);
722 }
723
724 //mov rcx,reg2
725 op_mov64_ToReg_FromReg(REG_RCX,reg2);
726
727 if(idCalc==CALC_SHL){
728 //左シフトは符号あり、なしは同様の動きをする
729
730 //32ビット型にする
731 if(!Is64Type(type[sp-2])){
732 ExtendTypeTo32(type[sp-2],reg1);
733
734 if(IsSignedType(type[sp-2])) type[sp-2]=DEF_LONG;
735 else type[sp-2]=DEF_DWORD;
736 }
737
738 //shl reg1,cl
739 op_shl_reg(GetTypeSize(type[sp-2],-1),reg1);
740 }
741 else if(idCalc==CALC_SHR){
742 if(IsSignedType(type[sp-2])){
743 //符号あり
744
745 //sar
746 op_sar_reg(GetTypeSize(type[sp-2],-1),reg1);
747 }
748 else{
749 //符号なし
750
751 //shr
752 op_shr_reg(GetTypeSize(type[sp-2],-1),reg1);
753 }
754 }
755
756 if(sw==0){
757 //mov rcx,r15
758 op_mov64_ToReg_FromReg(REG_RCX,REG_R15);
759 }
760 else{
761 //mov rcx,qword ptr[rsp+offset] ※スタックフレームを利用
762 pobj_sf->pop(REG_RCX);
763 }
764
765 if(reg1==REG_R14){
766 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
767 pobj_sf->push(REG_R14);
768 }
769
770 sp--;
771
772 *pStackPointer=sp;
773 return 1;
774}
Note: See TracBrowser for help on using the repository browser.