source: dev/BasicCompiler64/NumOpe.cpp@ 41

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

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