source: dev/BasicCompiler64/NumOpe.cpp@ 63

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

CClass::GetSize、CClass::GetMemberOffsetを追加
File size: 21.5 KB
Line 
1#include "../BasicCompiler_Common/common.h"
2#include "Opcode.h"
3
4void NewStringObject(int reg,LPSTR lpszText){
5 ///////////////////////////////////////////////////////
6 // lpszTextを元にStringオブジェクトを生成し、
7 // オブジェクトポインタをregに格納する
8 ///////////////////////////////////////////////////////
9
10
11 //////////////////////////////////////////////////////
12 ///// レジスタ資源のバックアップ
13 { BACKUP_REGISTER_RESOURCE
14 //////////////////////////////////////////////////////
15
16 extern CClass *pobj_StringClass;
17 int object_size = pobj_StringClass->GetSize();
18
19 //mov rcx,object_size
20 op_mov_RV(sizeof(_int64),REG_RCX,object_size);
21
22 //call calloc
23 extern SUBINFO *pSub_calloc;
24 op_call(pSub_calloc);
25
26 //mov r11,rax
27 op_mov_RR(REG_R11,REG_RAX);
28
29 //mov qword ptr[rsp+offset],r11 ※スタックフレームを利用
30 pobj_sf->push(REG_R11);
31
32 //mov rcx,rax
33 op_mov_RR(REG_RCX,REG_RAX);
34
35 //call constructor
36 op_call(pobj_StringClass->GetConstructorMethod()->psi);
37
38 // TODO: Ex表記による文字列長に対応する
39 int i2 = dataTable.AddString( lpszText );
40
41 //mov rax,i2
42 op_mov_RV(sizeof(_int64),REG_RAX,i2);
43 obp-=sizeof(long);
44 pobj_DataTableSchedule->add();
45 obp+=sizeof(long);
46
47
48 //mov r11,qword ptr[rsp+offset] ※スタックフレームを利用
49 pobj_sf->ref(REG_R11);
50
51
52 RELATIVE_VAR RelativeVar;
53 RelativeVar.bOffsetOffset=0;
54 RelativeVar.offset=0;
55 RelativeVar.dwKind=VAR_DIRECTMEM;
56
57 SetObjectVariableFromRax((LONG_PTR)pobj_StringClass,DEF_PTR_BYTE,-1,&RelativeVar,0);
58
59 //mov r11,qword ptr[rsp+offset] ※スタックフレームを利用
60 pobj_sf->pop(REG_R11);
61
62
63 /////////////////////////////////////////////
64 ////// レジスタ資源を復元
65 RESTORE_REGISTER_RESOURCE
66 }////////////////////////////////////////////
67
68 //mov reg,r11
69 op_mov_RR(reg,REG_R11);
70}
71
72void SetUseRegFromRax(int type,int UseReg,int XmmReg){
73 if(IsRealNumberType(type)){
74 //実数型
75 if(XmmReg==REG_XMM4){
76 if(type==DEF_DOUBLE){
77 //movsd qword ptr[rsp+offset],xmm0 ※スタックフレームを利用
78 pobj_sf->push(REG_XMM0,sizeof(double));
79 }
80 if(type==DEF_SINGLE){
81 //movss dword ptr[rsp+offset],xmm0 ※スタックフレームを利用
82 pobj_sf->push(REG_XMM0,sizeof(float));
83 }
84 }
85 else{
86 if(type==DEF_DOUBLE){
87 //movsd xmm_reg,xmm0
88 op_movsd_RR(XmmReg,REG_XMM0);
89 }
90 else if(type==DEF_SINGLE){
91 //movss xmm_reg,xmm0
92 op_movss_RR(XmmReg,REG_XMM0);
93 }
94 }
95 }
96 else{
97 //整数型
98 if(UseReg==REG_R14){
99 //mov qword ptr[rsp+offset],rax ※スタックフレームを利用
100 pobj_sf->push(REG_RAX);
101 }
102 else{
103 //mov reg,rax
104 op_mov64_ToReg_FromReg(UseReg,REG_RAX);
105 }
106 }
107}
108
109int NumOpe(int *pReg,const char *Command,int BaseType,LONG_PTR lpBaseIndex,LONG_PTR *plpIndex,BOOL *pbUseHeap){
110 extern HANDLE hHeap;
111 int i,i2,i3,i4;
112 char temporary[1024],temp2[1024],temp3[1024];
113
114 if(Command[0]=='\0'){
115 SetError(1,NULL,cp);
116 return 0;
117 }
118
119 if(Command[0]==1&&Command[1]==ESC_NEW){
120 //New演算子（オブジェクト生成）
121 return Operator_New(Command+2,plpIndex);
122 }
123
124
125 /////////////////////////////////
126 // 式要素を逆ポーランド式で取得
127 /////////////////////////////////
128
129 char *values[255];
130 long calc[255];
131 long stack[255];
132 int pnum;
133 if(!GetNumOpeElements(Command,&pnum,values,calc,stack)){
134 for(i=0;i<pnum;i++){
135 if(values[i]) HeapDefaultFree(values[i]);
136 }
137 return 0;
138 }
139
140
141 BOOL bInitRegSwitch=0;
142 if(!pobj_reg){
143 bInitRegSwitch=1;
144
145 //作業用レジスタを取得
146 pobj_reg=new CRegister(*pReg);
147 }
148
149 //エラー時の復旧用
150 CRegister objReg_Backup;
151 objReg_Backup=*pobj_reg;
152
153
154
155 ////////////////////////////////
156 // 演算部分のコード生成を開始
157 ////////////////////////////////
158
159 BOOL bError;
160 bError=0;
161
162 //リテラル値のみの計算かどうかを判別するためのフラグ
163 BOOL bLiteralCalculation=1;
164
165 //リテラル演算の場合を考慮した演算前のバッファ位置
166 int BeforeObp;
167 BeforeObp=obp;
168
169 //リテラル演算の場合を考慮した演算前のプロシージャスケジュール位置
170 //※64ビットの掛け算、除算などで特殊関数が呼ばれるため
171 int Before_ProcAddrScheduleNum;
172 Before_ProcAddrScheduleNum=pobj_SubAddrSchedule->num;
173
174 //リテラル演算の場合を考慮した演算前のデータテーブルスケジュール位置
175 int Before_DataTableScheduleNum;
176 Before_DataTableScheduleNum=pobj_DataTableSchedule->num;
177
178 //リテラル演算の場合を考慮した演算前の再配置スケジュール
179 CReloc *pobj_BackReloc;
180 pobj_BackReloc=new CReloc();
181 pobj_BackReloc->copy(pobj_Reloc);
182
183 //リテラル演算の場合を考慮した演算前のスタックフレームスケジュール位置
184 int Before_StackFrameScheduleNum;
185 Before_StackFrameScheduleNum=pobj_sf->num;
186
187 double dbl;
188 int sp;
189 int type[255];
190 LONG_PTR index_stack[255];
191 BOOL bUseHeap[255];
192 _int64 i64data;
193 int UseReg,XmmReg;
194 BOOL bXmm;
195 for(i=0,sp=0;i<pnum;i++){
196 int idCalc;
197 idCalc=calc[i]%100;
198
199 if(idCalc){
200 if(type[sp-2]==DEF_OBJECT){
201 //オーバーロードされたオペレータを呼び出す
202 TYPEINFO BaseTypeInfo={BaseType,lpBaseIndex};
203 i2=CallOperatorProc(idCalc,&BaseTypeInfo,type,index_stack,bUseHeap,sp);
204 if(i2==0){
205 if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
206 else GetCalcName(idCalc,temp2);
207 sprintf(temporary,"Operator %s",temp2);
208 SetError(27,temporary,cp);
209 goto error;
210 }
211 else if(i2==-1) goto error;
212
213 continue;
214 }
215
216 if(!CheckCalcType(idCalc,type,sp)) goto error;
217 }
218
219 switch(idCalc){
220 //数値
221 case 0:
222 index_stack[sp]=-1;
223 bUseHeap[sp]=0;
224
225 UseReg=pobj_reg->GetNextReg();
226 XmmReg=pobj_reg->GetNextXmmReg();
227
228 bXmm=0;
229
230 char *term;
231 term=values[i];
232
233 if(term[0]=='\"'){
234 //リテラル文字列
235 if(!RemoveStringQuotes(term)){
236 SetError(43,NULL,cp);
237 goto error;
238 }
239 i3=lstrlen(term);
240StrLiteral:
241
242 if(BaseType==DEF_OBJECT){
243 CClass *pobj_Class;
244 pobj_Class=(CClass *)lpBaseIndex;
245 TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex};
246 if(IsStringSubsituation(pobj_Class)
247 || IsStringObjectType(&BaseTypeInfo)){
248 //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
249
250 //String型オブジェクトを生成
251 NewStringObject(UseReg,term);
252
253 extern CClass *pobj_StringClass;
254 type[sp]=DEF_OBJECT;
255 index_stack[sp]=(LONG_PTR)pobj_StringClass;
256 bUseHeap[sp]=1;
257 bLiteralCalculation=0;
258
259 if(bXmm) pobj_reg->LockXmmReg();
260 else pobj_reg->LockReg();
261
262 sp++;
263 break;
264 }
265 }
266
267 type[sp]=DEF_PTR_BYTE;
268 bLiteralCalculation=0;
269
270 i2 = dataTable.AddString( term, i3 );
271
272 //mov reg,i2
273 op_mov_RV(sizeof(_int64),UseReg,i2);
274 obp-=sizeof(long);
275 pobj_DataTableSchedule->add();
276 obp+=sizeof(long);
277
278 if(UseReg==REG_R14){
279 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
280 pobj_sf->push(REG_R14);
281 }
282 }
283 else if((term[0]=='e'||term[0]=='E')&&
284 (term[1]=='x'||term[1]=='X')&&
285 term[2]=='\"'){
286 //拡張版リテラル文字列（エスケープシーケンス可能）
287 if(!RemoveStringQuotes(term+2)){
288 SetError(43,NULL,cp);
289 goto error;
290 }
291 i3=FormatString_EscapeSequence(term+2);
292 term+=2;
293
294 goto StrLiteral;
295 }
296 else if(IsVariableTopChar(term[0])||
297 term[0]=='*'||
298 (term[0]=='.'&&IsVariableTopChar(term[1]))){
299 //////////////////
300 // 何らかの識別子
301
302 //////////////////////////////////////
303 // 関数（DLL、ユーザー定義、組み込み）
304 //////////////////////////////////////
305
306 i2=GetCallProcName(term,temporary);
307 if(term[i2]=='('){
308 i4=GetStringInPare_RemovePare(temp2,term+i2+1);
309
310 int idProc;
311 void *pInfo;
312 idProc=GetProc(temporary,&pInfo);
313
314 if(idProc){
315 //閉じカッコ")"に続く文字がNULLでないとき
316 if(term[i2+1+i4+1]!='\0'){
317 if( term[i2+1+i4+1] == '.'
318 || term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
319 goto NonProc;
320 }
321 else{
322 SetError(42,NULL,cp);
323 }
324 }
325
326
327 //////////////////////////////////////////////////////
328 ///// レジスタ資源のバックアップ
329 { BACKUP_REGISTER_RESOURCE
330 //////////////////////////////////////////////////////
331
332
333 ////////////////
334 // 呼び出し
335 ////////////////
336
337 i2=CallProc(idProc,pInfo,temporary,temp2,&index_stack[sp]);
338 if(i2==-1){
339 //戻り値が存在しないとき
340 for(i2=2;;i2++){
341 if(term[i2]=='('||term[i2]=='\0'){
342 term[i2]=0;
343 break;
344 }
345 }
346 SetError(38,term,cp);
347
348 //レジスタ資源を復元
349 RESTORE_REGISTER_RESOURCE
350
351 goto error;
352 }
353
354
355 /////////////////////
356 // 戻り値の処理
357 /////////////////////
358
359 //大きな型への暗黙の変換
360 type[sp]=AutoBigCast(BaseType,i2);
361 bLiteralCalculation=0;
362
363 SetUseRegFromRax(i2,UseReg,XmmReg);
364
365 if(IsRealNumberType(i2)) bXmm=1;
366 else bXmm=0;
367
368 /////////////////////////////////////////////
369 ////// レジスタ資源を復元
370 RESTORE_REGISTER_RESOURCE
371 }////////////////////////////////////////////
372
373
374 if(bXmm) pobj_reg->LockXmmReg();
375 else pobj_reg->LockReg();
376
377 if(i2==DEF_OBJECT){
378 //Object型が戻ったときはヒープ領域にインスタンスが格納されている
379 //※後にfreeする必要あり
380 bUseHeap[sp]=1;
381 }
382
383 sp++;
384 break;
385 }
386 else if(GetConstCalcBuffer(temporary,temp2,temp3)){
387 /////////////////////////
388 // マクロ関数
389 /////////////////////////
390
391 //閉じカッコ")"に続く文字がNULLでないときはエラーにする
392 if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
393
394 //マクロ関数の場合
395 i2=NumOpe(&UseReg,temp3,0,0,&index_stack[sp]);
396
397 if(!IS_LITERAL(index_stack[sp])){
398 //リテラル値ではなかったとき
399 bLiteralCalculation=0;
400 }
401
402 type[sp]=i2;
403
404 if(IsRealNumberType(i2)) pobj_reg->LockXmmReg();
405 else pobj_reg->LockReg();
406
407 sp++;
408 break;
409 }
410 }
411NonProc:
412
413
414 //インデクサ（getアクセサ）
415 char variable[VN_SIZE],array_element[VN_SIZE];
416 CClass *pobj_c;
417 GetArrayElement(term,variable,array_element);
418 if(array_element[0]){
419 i2=GetVarType(variable,(LONG_PTR *)&pobj_c,0);
420 if(i2==DEF_OBJECT){
421 TYPEINFO RetTypeInfo;
422 CallIndexerGetterProc(UseReg,pobj_c,variable,array_element,RetTypeInfo);
423 type[sp]=RetTypeInfo.type;
424 index_stack[sp]=RetTypeInfo.u.lpIndex;
425 bLiteralCalculation=0;
426
427 if(IsRealNumberType(RetTypeInfo.type)) pobj_reg->LockXmmReg();
428 else pobj_reg->LockReg();
429 sp++;
430 break;
431 }
432 }
433
434
435 RELATIVE_VAR RelativeVar;
436 if(GetVarOffset(
437 false, //エラー表示あり
438 false, //読み込み専用
439 term,
440 &i2,&RelativeVar,&index_stack[sp])){
441 //////////
442 // 変数
443 //////////
444
445 //大きな型への暗黙の変換
446 type[sp]=AutoBigCast(BaseType,i2);
447 bLiteralCalculation=0;
448
449 if(type[sp]!=i2){
450 //大きな型へ変換された場合（レジスタを0に初期化する）
451
452 //xor reg,reg
453 op_zero_reg(UseReg);
454 }
455
456 if(i2&FLAG_PTR){
457 //配列ポインタ
458 type[sp]=GetPtrType(i2^FLAG_PTR,index_stack[sp]);
459
460 SetVarPtrToReg(UseReg,&RelativeVar);
461 }
462 else if(IsRealNumberType(i2)){
463 //実数型
464 bXmm=1;
465
466 if(i2==DEF_DOUBLE)
467 SetXmmReg_DoubleVariable(&RelativeVar,XmmReg);
468 if(i2==DEF_SINGLE)
469 SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
470 }
471 else if(IsWholeNumberType(i2)){
472 //整数型
473 SetReg_WholeVariable(i2,&RelativeVar,UseReg);
474 }
475 else if(i2==DEF_OBJECT){
476 //オブジェクト ポインタをUseRegへ格納
477 SetVarPtrToReg(UseReg,&RelativeVar);
478 }
479 else SetError(11,term,cp);
480
481 if(bXmm==0&&UseReg==REG_R14){
482 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
483 pobj_sf->push(REG_R14);
484 }
485 if(bXmm&&XmmReg==REG_XMM4){
486 if(i2==DEF_DOUBLE){
487 //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
488 pobj_sf->push(REG_XMM4,sizeof(double));
489 }
490 if(i2==DEF_SINGLE){
491 //movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
492 pobj_sf->push(REG_XMM4,sizeof(float));
493 }
494 }
495
496 if(bXmm) pobj_reg->LockXmmReg();
497 else pobj_reg->LockReg();
498 sp++;
499 break;
500 }
501
502
503 //////////////
504 // 定数の場合
505 //////////////
506
507 i3 = CDBConst::obj.GetType(term);
508 if(i3){
509 type[sp] = i3;
510 if(IsRealNumberType(i3)){
511 //実数
512 double dbl = CDBConst::obj.GetDoubleData(term);
513 memcpy(&i64data,&dbl,sizeof(double));
514 goto Literal;
515 }
516 else if(IsWholeNumberType(i3)){
517 //整数
518 i64data = CDBConst::obj.GetWholeData(term);
519 goto Literal;
520 }
521 /*else if(i3==DEF_STRING){
522 //リテラル文字列
523
524 //バイト数
525 i3=(int)dbl;
526
527 memcpy(term,temporary,i3);
528 goto StrLiteral;
529 }*/
530 else{
531 SetError(1,NULL,0);
532 goto error;
533 }
534 }
535
536
537
538 //////////////
539 // 型名の場合
540 //////////////
541
542 LONG_PTR lp;
543 i3=GetTypeFixed(term,&lp);
544 if(i3!=-1){
545 type[sp]=i3|FLAG_CAST;
546 index_stack[sp]=lp;
547 sp++;
548 break;
549 }
550
551
552
553 /////////////////////////////////
554 // プロパティ用のメソッド
555 /////////////////////////////////
556
557 //配列要素を排除
558 char VarName[VN_SIZE],ArrayElements[VN_SIZE];
559 GetArrayElement(term,VarName,ArrayElements);
560
561 if(GetSubHash(VarName,0)){
562
563 //////////////////////////////////////////////////////
564 ///// レジスタ資源のバックアップ
565 { BACKUP_REGISTER_RESOURCE
566 //////////////////////////////////////////////////////
567
568 TYPEINFO RetTypeInfo;
569 CallPropertyMethod(term,NULL,&RetTypeInfo);
570
571 //大きな型への暗黙の変換
572 type[sp]=AutoBigCast(BaseType,RetTypeInfo.type);
573
574 index_stack[sp]=RetTypeInfo.u.lpIndex;
575 bLiteralCalculation=0;
576
577 SetUseRegFromRax(RetTypeInfo.type,UseReg,XmmReg);
578
579 if(IsRealNumberType(type[sp])) bXmm=1;
580 else bXmm=0;
581
582 /////////////////////////////////////////////
583 ////// レジスタ資源を復元
584 RESTORE_REGISTER_RESOURCE
585 }////////////////////////////////////////////
586
587 if(type[sp]==DEF_OBJECT){
588 //Object型が戻ったときはヒープ領域にインスタンスが格納されている
589 //※後にfreeする必要あり
590 bUseHeap[sp]=1;
591 }
592
593 if(bXmm) pobj_reg->LockXmmReg();
594 else pobj_reg->LockReg();
595 sp++;
596 break;
597 }
598
599
600
601 //該当する識別子が見当たらないときはエラー扱いにする
602 bError=1;
603 SetError(3,term,cp);
604 type[sp]=DEF_DOUBLE;
605 }
606 else{
607 //リテラル値
608 type[sp]=GetLiteralValue(term,&i64data,BaseType);
609Literal:
610 if(type[sp]==DEF_DOUBLE){
611 //64ビット浮動小数型
612 bXmm=1;
613
614 if(XmmReg==REG_XMM4){
615 //mov r14,i64data
616 op_mov64_ToReg(REG_R14,i64data);
617
618
619 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
620 pobj_sf->push(REG_R14);
621 }
622 else{
623 i3 = dataTable.Add( i64data );
624
625 //movlpd xmm_reg,qword ptr[data table offset]
626 OpBuffer[obp++]=(char)0x66;
627 OpBuffer[obp++]=(char)0x0F;
628 OpBuffer[obp++]=(char)0x12;
629 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
630 OpBuffer[obp++]=(char)0x25;
631 *((long *)(OpBuffer+obp))=i3;
632 pobj_DataTableSchedule->add();
633 obp+=sizeof(long);
634 }
635 }
636 else if(type[sp]==DEF_SINGLE){
637 //32ビット浮動小数型
638 bXmm=1;
639
640 float flt;
641 int i32data;
642 memcpy(&dbl,&i64data,sizeof(double));
643 flt=(float)dbl;
644 memcpy(&i32data,&flt,sizeof(long));
645
646 if(XmmReg==REG_XMM4){
647 //push term
648 op_push_value(i32data);
649 }
650 else{
651 i3=dataTable.Add( i32data );
652
653 //movss xmm_reg,dword ptr[data table offset]
654 OpBuffer[obp++]=(char)0xF3;
655 OpBuffer[obp++]=(char)0x0F;
656 OpBuffer[obp++]=(char)0x10;
657 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
658 OpBuffer[obp++]=(char)0x25;
659 *((long *)(OpBuffer+obp))=i3;
660 pobj_DataTableSchedule->add();
661 obp+=sizeof(long);
662 }
663 }
664 else{
665 //整数
666
667 index_stack[sp]=GetLiteralIndex(i64data);
668
669 //mov reg,i64data
670 op_mov64_ToReg(UseReg,i64data);
671
672 if(UseReg==REG_R14){
673 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
674 pobj_sf->push(REG_R14);
675 }
676 }
677 }
678
679 if(bXmm) pobj_reg->LockXmmReg();
680 else pobj_reg->LockReg();
681
682 sp++;
683 break;
684
685 //論理演算子
686 case CALC_XOR:
687 case CALC_OR:
688 case CALC_AND:
689 if(!CalcTwoTerm_Logical(idCalc,type,index_stack,&sp)) goto error;
690 break;
691 case CALC_NOT:
692 //value[sp-1]=Not value[sp-1]
693 //NOT演算子
694 if(!Calc_Not(type,sp)) goto error;
695 break;
696
697 //比較演算子
698 case CALC_PE: //value[sp-2] <= value[sp-1]
699 case CALC_QE: //value[sp-2] >= value[sp-1]
700 case CALC_P: //value[sp-2] < value[sp-1]
701 case CALC_Q: //value[sp-2] > value[sp-1]
702 case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
703 case CALC_EQUAL: //value[sp-2] = value[sp-1]
704 if(!CalcTwoTerm_Relational(idCalc,type,index_stack,&sp)) goto error;
705 break;
706
707 //ビットシフト
708 case CALC_SHL: //value[sp-2] << value[sp-1]
709 case CALC_SHR: //value[sp-2] >> value[sp-1]
710 if(!Calc_Shift(idCalc,type,&sp)) goto error;
711 break;
712
713 //算術演算
714 case CALC_ADDITION:
715 case CALC_SUBTRACTION:
716 case CALC_PRODUCT:
717 if(!CalcTwoTerm_Arithmetic(idCalc,type,index_stack,&sp)) goto error;
718 break;
719 case CALC_MOD:
720 //value[sp-2]%=value[sp-1]
721 //剰余演算
722 if(!Calc_Mod(type,index_stack,&sp)) goto error;
723 break;
724 case CALC_QUOTIENT:
725 //value[sp-2]/=value[sp-1];
726 //除算
727 if(!Calc_Divide(type,&sp,BaseType)) goto error;
728 break;
729 case CALC_INTQUOTIENT:
730 //value[sp-2]/=value[sp-1]
731 //整数除算
732 if(!Calc_IntDivide(type,index_stack,&sp)) goto error;
733 break;
734 case CALC_MINUSMARK:
735 //value[sp-1]=-value[sp-1]
736 //符号反転
737 if(!Calc_MinusMark(type,sp)) goto error;
738 break;
739 case CALC_POWER:
740 //べき乗演算（浮動小数点演算のみ）
741 if(!Calc_Power(type,&sp)) goto error;
742 break;
743 case CALC_AS:
744 //キャスト
745 if(!Calc_Cast(type,index_stack,&sp)) goto error;
746 break;
747 case CALC_BYVAL:
748 //ポインタ型→参照型
749 if( PTR_LEVEL( type[sp-1] ) <= 0 ){
750 //ポインタ型ではないとき
751 SetError( 3, NULL, cp );
752 goto error;
753 }
754
755 type[sp-1] = PTR_LEVEL_DOWN( type[sp-1] );
756
757 break;
758
759 default:
760 SetError(300,NULL,cp);
761 goto error;
762 }
763 }
764
765 if(bError) goto error;
766
767 if(sp!=1){
768 SetError(1,NULL,cp);
769 goto error;
770 }
771
772 if(bLiteralCalculation){
773 //右辺値が数値の定数式の場合
774 LONG_PTR lpClassIndex;
775 i2=StaticCalculation(true, Command,BaseType,&i64data,&lpClassIndex);
776
777 obp=BeforeObp;
778 pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
779 pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
780 pobj_Reloc->copy(pobj_BackReloc);
781 pobj_sf->num=Before_StackFrameScheduleNum;
782 *pobj_reg=objReg_Backup;
783
784 if(IsRealNumberType(i2)){
785 if(IsRealNumberType(BaseType)) i2=BaseType;
786
787 XmmReg=pobj_reg->LockXmmReg();
788
789 if(i2==DEF_DOUBLE){
790 i3 = dataTable.Add( i64data );
791
792 //movlpd xmm_reg,qword ptr[data table offset]
793 OpBuffer[obp++]=(char)0x66;
794 OpBuffer[obp++]=(char)0x0F;
795 OpBuffer[obp++]=(char)0x12;
796 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
797 OpBuffer[obp++]=(char)0x25;
798 *((long *)(OpBuffer+obp))=i3;
799 pobj_DataTableSchedule->add();
800 obp+=sizeof(long);
801 }
802 if(i2==DEF_SINGLE){
803 memcpy(&dbl,&i64data,sizeof(_int64));
804
805 float flt;
806 int i32data;
807 flt=(float)dbl;
808 memcpy(&i32data,&flt,sizeof(long));
809
810 i3 = dataTable.Add( i32data );
811
812 //movss xmm_reg,dword ptr[data table offset]
813 OpBuffer[obp++]=(char)0xF3;
814 OpBuffer[obp++]=(char)0x0F;
815 OpBuffer[obp++]=(char)0x10;
816 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
817 OpBuffer[obp++]=(char)0x25;
818 *((long *)(OpBuffer+obp))=i3;
819 pobj_DataTableSchedule->add();
820 obp+=sizeof(long);
821 }
822 }
823 else{
824 if(!Is64Type(i2)){
825 //整数（符号有り/無し）
826
827 i3=(long)i64data;
828
829 if(GetTypeSize(i2,-1)==sizeof(char)) i3=i3&0x000000FF;
830 if(GetTypeSize(i2,-1)==sizeof(short)) i3=i3&0x0000FFFF;
831
832 i64data=(_int64)i3;
833 }
834
835 UseReg=pobj_reg->LockReg();
836
837 //mov reg,i64data
838 op_mov64_ToReg(UseReg,i64data);
839 }
840
841 type[0]=i2;
842 index_stack[0]=lpClassIndex;
843 }
844 else{
845 //右辺値が数値の定数式ではないとき
846 if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
847 }
848
849 if(plpIndex) *plpIndex=index_stack[0];
850 if(pbUseHeap) *pbUseHeap=bUseHeap[0];
851
852 if(IsRealNumberType(type[0]))
853 *pReg=pobj_reg->UnlockXmmReg();
854 else
855 *pReg=pobj_reg->UnlockReg();
856
857
858 if(bInitRegSwitch){
859 //整合性をチェック（バグ回避）
860 pobj_reg->bug_check();
861
862 //作業レジスタを解放
863 delete pobj_reg;
864 pobj_reg=0;
865 }
866
867 int RetType;
868 RetType=type[0];
869 goto finish;
870
871
872
873 //////////////////
874 // エラー処理
875 //////////////////
876
877error:
878
879 *pobj_reg=objReg_Backup;
880
881 if(bInitRegSwitch){
882 //作業レジスタを解放
883 delete pobj_reg;
884 pobj_reg=0;
885 }
886
887 RetType=-1;
888 goto finish;
889
890
891
892
893finish:
894
895 for(i=0;i<pnum;i++){
896 if(values[i]) HeapDefaultFree(values[i]);
897 }
898
899 //再配置スケジュールバックアップ情報を解放
900 delete pobj_BackReloc;
901
902 return RetType;
903}
Note: See TracBrowser for help on using the repository browser.