source: dev/BasicCompiler64/NumOpe_TypeOperation.cpp@ 3

Last change on this file since 3 was 3, checked in by dai_9181, 17 years ago
File size: 12.3 KB
Line 
1#include "../BasicCompiler_Common/common.h"
2#include "Opcode.h"
3
4void ExtendTypeTo64(int type,int reg){
5 if(type==DEF_LONG){
6 //movsxd reg64,reg32
7 op_movsxd(reg,reg);
8 }
9 else if(type==DEF_DWORD){
10 //and reg,00000000FFFFFFFFh
11 }
12 else if(type==DEF_INTEGER){
13 //movsx reg64,reg16
14 op_movsx64_FromReg16(reg,reg);
15 }
16 else if(type==DEF_WORD){
17 //and reg,000000000000FFFFh
18 op_and64_value(reg,(int)0xFFFF);
19 }
20 else if(type==DEF_CHAR){
21 //movsx reg64,reg8
22 op_movsx64_FromReg8(reg,reg);
23 }
24 else if(type==DEF_BYTE){
25 //and reg,00000000000000FFh
26 op_and64_value(reg,(int)0x00FF);
27 }
28}
29void ExtendTypeTo32(int type,int reg){
30 if(type==DEF_INTEGER){
31 //movsx reg32,reg16
32 op_movsx32_FromReg16(reg,reg);
33 }
34 else if(type==DEF_WORD){
35 //and reg,0000FFFFh
36 op_and32_value(reg,(int)0xFFFF);
37 }
38 else if(type==DEF_CHAR){
39 //movsx reg32,reg8
40 op_movsx32_FromReg8(reg,reg);
41 }
42 else if(type==DEF_BYTE){
43 //and reg,000000FFh
44 op_and32_value(reg,(int)0xFF);
45 }
46}
47void ExtendTypeTo16(int type,int reg){
48 if(type==DEF_CHAR){
49 //movsx reg16,reg8
50 op_movsx16_FromReg8(reg,reg);
51 }
52 else if(type==DEF_BYTE){
53 //and reg,000000FFh
54 op_and32_value(reg,(int)0xFF);
55 }
56}
57
58void ChangeTypeToXmm_Double(int type,int xmm_reg,int general_reg){
59 if(type==DEF_DOUBLE){
60 //なにもしない
61 }
62 else if(type==DEF_SINGLE){
63 //Single型
64
65 //cvtss2sd
66 op_cvtss2sd(xmm_reg,xmm_reg);
67 }
68 else if(Is64Type(type)){
69 //64ビット整数型
70
71 //cvtsi2sd xmm_reg,reg
72 op_cvtsi2sd_reg(sizeof(_int64),xmm_reg,general_reg);
73
74 if(type==DEF_QWORD){
75 //符号なし
76
77 //test reg,reg
78 op_test(general_reg,general_reg);
79
80 //jge 9
81 OpBuffer[obp++]=(char)0x7D;
82 OpBuffer[obp++]=(char)0x09;
83
84 //addsd xmm_reg,qword ptr[offset] ※offset value:43f0000000000000
85 int temp;
86 _int64 i64data=0x43f0000000000000;
87 temp=AddDataTable((char *)&i64data,sizeof(_int64));
88 OpBuffer[obp++]=(char)0xF2;
89 OpBuffer[obp++]=(char)0x0F;
90 OpBuffer[obp++]=(char)0x58;
91 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3);
92 OpBuffer[obp++]=(char)0x25;
93 *((long *)(OpBuffer+obp))=temp;
94 pobj_DataTableSchedule->add();
95 obp+=sizeof(long);
96 }
97 }
98 else if(type==DEF_DWORD){
99 //符号なし32ビット値
100
101 //64ビットにレジスタ値を拡張
102 ExtendTypeTo64(type,general_reg);
103
104 //cvtsi2sd xmm_reg,reg
105 op_cvtsi2sd_reg(sizeof(_int64),xmm_reg,general_reg);
106 }
107 else{
108 //その他整数
109
110 //32ビットにレジスタ値を拡張
111 ExtendTypeTo32(type,general_reg);
112
113 //cvtsi2sd xmm_reg,reg
114 op_cvtsi2sd_reg(sizeof(long),xmm_reg,general_reg);
115 }
116}
117void ChangeTypeToXmm_Single(int type,int xmm_reg,int general_reg){
118 if(type==DEF_DOUBLE){
119 //Double型
120
121 //cvtsd2ss
122 op_cvtsd2ss(xmm_reg,xmm_reg);
123 }
124 else if(type==DEF_SINGLE){
125 //なにもしない
126 }
127 else if(Is64Type(type)){
128 //64ビット整数型
129
130 //cvtsi2ss xmm_reg,reg
131 op_cvtsi2ss_reg(sizeof(_int64),xmm_reg,general_reg);
132
133 if(type==DEF_QWORD){
134 //符号なし
135
136 //test reg,reg
137 op_test(general_reg,general_reg);
138
139 //jge 9
140 OpBuffer[obp++]=(char)0x7D;
141 OpBuffer[obp++]=(char)0x09;
142
143 //addss xmm_reg,dword ptr[offset] ※offset value:5f800000
144 int temp;
145 long i32data=0x5f800000;
146 temp=AddDataTable((char *)&i32data,sizeof(long));
147 OpBuffer[obp++]=(char)0xF3;
148 OpBuffer[obp++]=(char)0x0F;
149 OpBuffer[obp++]=(char)0x58;
150 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3);
151 OpBuffer[obp++]=(char)0x25;
152 *((long *)(OpBuffer+obp))=temp;
153 pobj_DataTableSchedule->add();
154 obp+=sizeof(long);
155 }
156 }
157 else if(type==DEF_DWORD){
158 //符号なし32ビット値
159
160 //64ビットにレジスタ値を拡張
161 ExtendTypeTo64(type,general_reg);
162
163 //cvtsi2ss xmm_reg,reg
164 op_cvtsi2ss_reg(sizeof(_int64),xmm_reg,general_reg);
165 }
166 else{
167 //その他整数
168
169 //32ビットにレジスタ値を拡張
170 ExtendTypeTo32(type,general_reg);
171
172 //cvtsi2ss xmm_reg,reg
173 op_cvtsi2ss_reg(sizeof(long),xmm_reg,general_reg);
174 }
175}
176
177void ChangeTypeToWhole(int OldType,int NewType,int reg,int xmm_reg){
178 if(OldType==DEF_DOUBLE){
179 if(Is64Type(NewType)){
180 //cvttsd2si reg,xmm_reg
181 op_cvttsd2si_xmm(sizeof(_int64),reg,xmm_reg);
182 }
183 else{
184 //cvttsd2si reg,xmm_reg
185 op_cvttsd2si_xmm(sizeof(long),reg,xmm_reg);
186 }
187 }
188 else if(OldType==DEF_SINGLE){
189 if(Is64Type(NewType)){
190 //cvttss2si reg,xmm_reg
191 op_cvttss2si_xmm(sizeof(_int64),reg,xmm_reg);
192 }
193 else{
194 //cvttss2si reg,xmm_reg
195 op_cvttss2si_xmm(sizeof(long),reg,xmm_reg);
196 }
197 }
198 else{
199 //整数から整数へ変換
200
201 if(Is64Type(NewType)){
202 ExtendTypeTo64(OldType,reg);
203 }
204 else if(GetTypeSize(NewType,-1)==sizeof(long)){
205 ExtendTypeTo32(OldType,reg);
206 }
207 else if(GetTypeSize(NewType,-1)==sizeof(short)){
208 ExtendTypeTo16(OldType,reg);
209 }
210 }
211}
212
213
214
215/////////////////////////////////////////
216// 1つの項を適切なレジスタへセット
217/////////////////////////////////////////
218
219void SetOneTermToReg_RealCalc(int TermType,int *pXmmReg){
220 int xmm_reg;
221
222 if(IsRealNumberType(TermType)){
223 //実数型
224 xmm_reg=pobj_reg->GetLockingXmmReg();
225
226 if(xmm_reg==REG_XMM4){
227 if(TermType==DEF_DOUBLE){
228 //movlpd xmm4,qword ptr[rsp+offset] ※スタックフレームを利用
229 pobj_sf->pop(xmm_reg,sizeof(double));
230 }
231 if(TermType==DEF_SINGLE){
232 //movss xmm4,dword ptr[rsp+offset] ※スタックフレームを利用
233 pobj_sf->pop(xmm_reg,sizeof(float));
234 }
235 }
236 }
237 else{
238 SetError(300,NULL,cp);
239 }
240
241 *pXmmReg=xmm_reg;
242}
243void SetOneTermToReg_Whole64Calc(int TermType,int *pReg){
244 //1つの項を適切なレジスタへセット（64ビット整数演算用）
245 int reg;
246
247 reg=pobj_reg->GetLockingReg();
248
249 if(reg==REG_R14){
250 //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
251 pobj_sf->pop(REG_R14);
252 }
253
254 //レジスタ値を64ビットに拡張
255 ExtendTypeTo64(TermType,reg);
256
257 *pReg=reg;
258}
259void SetOneTermToReg_Whole32Calc(int TermType,int *pReg){
260 //1つの項を適切なレジスタへセット（32ビット整数演算用）
261 int reg;
262
263 reg=pobj_reg->GetLockingReg();
264
265 if(reg==REG_R14){
266 //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
267 pobj_sf->pop(REG_R14);
268 }
269
270 //レジスタ値を32ビットに拡張
271 ExtendTypeTo32(TermType,reg);
272
273 *pReg=reg;
274}
275
276
277
278/////////////////////////////////////////
279// 2つの項を適切なレジスタへセット
280/////////////////////////////////////////
281
282void SetTowTermToReg_RealCalc(int AnswerType,int *type,int sp,int *pXmmReg1,int *pXmmReg2){
283 //2つの項を適切なレジスタへセット（Double演算用）
284 int xmm_reg1,xmm_reg2,temp_reg;
285
286
287 ///////////////////
288 // 第2項
289 ///////////////////
290
291 if(IsRealNumberType(type[sp-1])){
292 //実数型
293 xmm_reg2=pobj_reg->UnlockXmmReg();
294
295 if(xmm_reg2==REG_XMM4){
296 xmm_reg2=REG_XMM5;
297
298 if(type[sp-1]==DEF_DOUBLE){
299 //movlpd xmm5,qword ptr[rsp+offset] ※スタックフレームを利用
300 pobj_sf->pop(xmm_reg2,sizeof(double));
301 }
302 if(type[sp-1]==DEF_SINGLE){
303 //movss xmm5,dword ptr[rsp+offset] ※スタックフレームを利用
304 pobj_sf->pop(xmm_reg2,sizeof(float));
305 }
306 }
307 else{
308 if(!IsRealNumberType(type[sp-2])){
309 if(type[sp-1]==DEF_DOUBLE){
310 //movsd xmm5,xmm_reg
311 OpBuffer[obp++]=(char)0xF2;
312 OpBuffer[obp++]=(char)0x0F;
313 OpBuffer[obp++]=(char)0x10;
314 OpBuffer[obp++]=(char)(0xE8 | REGISTER_OPERAND(xmm_reg2));
315 }
316 if(type[sp-1]==DEF_SINGLE){
317 //movss xmm5,xmm_reg
318 OpBuffer[obp++]=(char)0xF3;
319 OpBuffer[obp++]=(char)0x0F;
320 OpBuffer[obp++]=(char)0x10;
321 OpBuffer[obp++]=(char)(0xE8 | REGISTER_OPERAND(xmm_reg2));
322 }
323
324 xmm_reg2=REG_XMM5;
325 }
326 }
327 }
328 else{
329 //整数値
330
331 temp_reg=pobj_reg->UnlockReg();
332
333 if(temp_reg==REG_R14){
334 //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
335 pobj_sf->pop(REG_R14);
336 }
337
338 xmm_reg2=REG_XMM5;
339 }
340
341 //汎用レジスタ（temp_reg）をXMMレジスタ（xmm_reg2）にコピー
342 if(AnswerType==DEF_DOUBLE)
343 ChangeTypeToXmm_Double(type[sp-1],xmm_reg2,temp_reg);
344 if(AnswerType==DEF_SINGLE)
345 ChangeTypeToXmm_Single(type[sp-1],xmm_reg2,temp_reg);
346
347
348 ///////////////////
349 // 第1項
350 ///////////////////
351
352 if(IsRealNumberType(type[sp-2])){
353 //実数
354 xmm_reg1=pobj_reg->GetLockingXmmReg();
355
356 if(xmm_reg1==REG_XMM4){
357 if(type[sp-2]==DEF_DOUBLE){
358 //movlpd xmm4,qword ptr[rsp+offset] ※スタックフレームを利用
359 pobj_sf->pop(xmm_reg1,sizeof(double));
360 }
361 if(type[sp-2]==DEF_SINGLE){
362 //movss xmm4,dword ptr[rsp+offset] ※スタックフレームを利用
363 pobj_sf->pop(xmm_reg1,sizeof(float));
364 }
365 }
366 }
367 else{
368 //整数
369
370 temp_reg=pobj_reg->UnlockReg();
371
372 if(temp_reg==REG_R14){
373 //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
374 pobj_sf->pop(REG_R14);
375 }
376
377 xmm_reg1=pobj_reg->LockXmmReg();
378 }
379
380 //汎用レジスタ（temp_reg）をXMMレジスタ（xmm_reg1）にコピー
381 if(AnswerType==DEF_DOUBLE)
382 ChangeTypeToXmm_Double(type[sp-2],xmm_reg1,temp_reg);
383 if(AnswerType==DEF_SINGLE)
384 ChangeTypeToXmm_Single(type[sp-2],xmm_reg1,temp_reg);
385
386
387 *pXmmReg1=xmm_reg1;
388 *pXmmReg2=xmm_reg2;
389}
390void SetTowTermToReg_Whole64Calc(int *type,int sp,int *pReg1,int *pReg2){
391 //2つの項を適切なレジスタへセット（64ビット整数演算用）
392 int reg1,reg2;
393
394 //////////////////
395 // 第2項
396 //////////////////
397 reg2=pobj_reg->UnlockReg();
398
399 if(reg2==REG_R14){
400 //mov r15,qword ptr[rsp+offset] ※スタックフレームを利用
401 pobj_sf->pop(REG_R15);
402
403 reg2=REG_R15;
404 }
405
406 //レジスタ値を64ビットに拡張
407 ExtendTypeTo64(type[sp-1],reg2);
408
409
410 //////////////////
411 // 第1項
412 //////////////////
413 reg1=pobj_reg->GetLockingReg();
414
415 if(reg1==REG_R14){
416 //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
417 pobj_sf->pop(REG_R14);
418 }
419
420 //レジスタ値を64ビットに拡張
421 ExtendTypeTo64(type[sp-2],reg1);
422
423
424 *pReg1=reg1;
425 *pReg2=reg2;
426}
427void SetTowTermToReg_Whole32Calc(int *type,int sp,int *pReg1,int *pReg2){
428 //2つの項を適切なレジスタへセット（32ビット整数演算用）
429 int reg1,reg2;
430
431 //////////////////
432 // 第2項
433 //////////////////
434 reg2=pobj_reg->UnlockReg();
435
436 if(reg2==REG_R14){
437 //mov r15,qword ptr[rsp+offset] ※スタックフレームを利用
438 pobj_sf->pop(REG_R15);
439
440 reg2=REG_R15;
441 }
442
443 //レジスタ値を32ビットに拡張
444 ExtendTypeTo32(type[sp-1],reg2);
445
446
447 //////////////////
448 // 第1項
449 //////////////////
450 reg1=pobj_reg->GetLockingReg();
451
452 if(reg1==REG_R14){
453 //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
454 pobj_sf->pop(REG_R14);
455 }
456
457 //レジスタ値を32ビットに拡張
458 ExtendTypeTo32(type[sp-2],reg1);
459
460
461 *pReg1=reg1;
462 *pReg2=reg2;
463}
464
465
466
467////////////////////////////
468// As 演算子によるキャスト
469////////////////////////////
470
471BOOL Calc_Cast(int *type,LONG_PTR *index_stack,int *pStackPointer){
472 //キャスト
473
474 int sp;
475 sp=*pStackPointer;
476
477 int CastType;
478 CastType=type[sp-1];
479 if((CastType&FLAG_CAST)==0){
480 SetError(47,NULL,cp);
481 return 0;
482 }
483 CastType=CastType&(~FLAG_CAST);
484
485 int xmm_reg,reg;
486
487 if(IsRealNumberType(CastType)){
488 //実数型へキャスト
489
490 if(IsRealNumberType(type[sp-2])){
491 SetOneTermToReg_RealCalc(type[sp-2],&xmm_reg);
492 }
493 else{
494 if(Is64Type(type[sp-2]))
495 SetOneTermToReg_Whole64Calc(type[sp-2],&reg);
496 else if(IsWholeNumberType(type[sp-2]))
497 SetOneTermToReg_Whole32Calc(type[sp-2],&reg);
498
499 pobj_reg->UnlockReg();
500
501 xmm_reg=pobj_reg->LockXmmReg();
502 }
503
504 if(CastType==DEF_DOUBLE){
505 //Double型にデータ変換
506 ChangeTypeToXmm_Double(type[sp-2],xmm_reg,reg);
507 }
508 else if(CastType==DEF_SINGLE){
509 //Single型にデータ変換
510 ChangeTypeToXmm_Single(type[sp-2],xmm_reg,reg);
511 }
512
513 if(xmm_reg==REG_XMM4){
514 //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
515 pobj_sf->push(REG_XMM4,sizeof(double));
516 }
517 }
518 else{
519 //その他整数型へ変換
520
521 if(IsRealNumberType(type[sp-2])){
522 SetOneTermToReg_RealCalc(type[sp-2],&xmm_reg);
523
524 pobj_reg->UnlockXmmReg();
525
526 reg=pobj_reg->LockReg();
527
528 //整数型へデータ変換
529 ChangeTypeToWhole(type[sp-2],CastType,reg,xmm_reg);
530
531 if(reg==REG_R14){
532 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
533 pobj_sf->push(REG_R14);
534 }
535 }
536 else{
537 reg=pobj_reg->GetLockingReg();
538
539 if(reg==REG_R14){
540 //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
541 pobj_sf->pop(REG_R14);
542 }
543
544 //整数型へデータ変換
545 ChangeTypeToWhole(type[sp-2],CastType,reg,0);
546
547 if(reg==REG_R14){
548 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
549 pobj_sf->push(REG_R14);
550 }
551 }
552 }
553
554 type[sp-2]=CastType;
555 index_stack[sp-2]=index_stack[sp-1];
556
557 sp--;
558
559 *pStackPointer=sp;
560 return 1;
561}
Note: See TracBrowser for help on using the repository browser.