source: dev/BasicCompiler64/NumOpe.cpp@ 3

Last change on this file since 3 was 3, checked in by dai_9181, 17 years ago
File size: 21.0 KB
RevLine 
[3]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,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 if(IsStringSubsituation(pobj_Class)){
247 //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
248
249 //String型オブジェクトを生成
250 NewStringObject(UseReg,term);
251
252 extern CClass *pobj_StringClass;
253 type[sp]=DEF_OBJECT;
254 index_stack[sp]=(LONG_PTR)pobj_StringClass;
255 bUseHeap[sp]=1;
256 bLiteralCalculation=0;
257
258 if(bXmm) pobj_reg->LockXmmReg();
259 else pobj_reg->LockReg();
260
261 sp++;
262 break;
263 }
264 }
265
266 type[sp]=DEF_PTR_BYTE;
267 bLiteralCalculation=0;
268
269 i2=AddDataTable(term,i3);
270
271 //mov reg,i2
272 op_mov_RV(sizeof(_int64),UseReg,i2);
273 obp-=sizeof(long);
274 pobj_DataTableSchedule->add();
275 obp+=sizeof(long);
276
277 if(UseReg==REG_R14){
278 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
279 pobj_sf->push(REG_R14);
280 }
281 }
282 else if((term[0]=='e'||term[0]=='E')&&
283 (term[1]=='x'||term[1]=='X')&&
284 term[2]=='\"'){
285 //拡張版リテラル文字列（エスケープシーケンス可能）
286 if(!RemoveStringQuotes(term+2)){
287 SetError(43,NULL,cp);
288 goto error;
289 }
290 i3=FormatString_EscapeSequence(term+2);
291 term+=2;
292
293 goto StrLiteral;
294 }
295 else if(IsVariableTopChar(term[0])||
296 term[0]=='*'||
297 (term[0]=='.'&&IsVariableTopChar(term[1]))){
298 //////////////////
299 // 何らかの識別子
300
301 //////////////////////////////////////
302 // 関数（DLL、ユーザー定義、組み込み）
303 //////////////////////////////////////
304
305 i2=GetCallProcName(term,temporary);
306 if(term[i2]=='('){
307 i4=GetStringInPare_RemovePare(temp2,term+i2+1);
308
309 int idProc;
310 void *pInfo;
311 idProc=GetProc(temporary,&pInfo);
312
313 if(idProc){
314 //閉じカッコ")"に続く文字がNULLでないときはエラーにする
315 if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
316
317
318 //////////////////////////////////////////////////////
319 ///// レジスタ資源のバックアップ
320 { BACKUP_REGISTER_RESOURCE
321 //////////////////////////////////////////////////////
322
323
324 ////////////////
325 // 呼び出し
326 ////////////////
327
328 i2=CallProc(idProc,pInfo,temporary,temp2,&index_stack[sp]);
329 if(i2==-1){
330 //戻り値が存在しないとき
331 for(i2=2;;i2++){
332 if(term[i2]=='('||term[i2]=='\0'){
333 term[i2]=0;
334 break;
335 }
336 }
337 SetError(38,term,cp);
338
339 //レジスタ資源を復元
340 RESTORE_REGISTER_RESOURCE
341
342 goto error;
343 }
344
345
346 /////////////////////
347 // 戻り値の処理
348 /////////////////////
349
350 //大きな型への暗黙の変換
351 type[sp]=AutoBigCast(BaseType,i2);
352 bLiteralCalculation=0;
353
354 SetUseRegFromRax(i2,UseReg,XmmReg);
355
356 if(IsRealNumberType(i2)) bXmm=1;
357 else bXmm=0;
358
359 /////////////////////////////////////////////
360 ////// レジスタ資源を復元
361 RESTORE_REGISTER_RESOURCE
362 }////////////////////////////////////////////
363
364
365 if(bXmm) pobj_reg->LockXmmReg();
366 else pobj_reg->LockReg();
367
368 if(i2==DEF_OBJECT){
369 //Object型が戻ったときはヒープ領域にインスタンスが格納されている
370 //※後にfreeする必要あり
371 bUseHeap[sp]=1;
372 }
373
374 sp++;
375 break;
376 }
377 else if(GetConstCalcBuffer(temporary,temp2,temp3)){
378 /////////////////////////
379 // マクロ関数
380 /////////////////////////
381
382 //閉じカッコ")"に続く文字がNULLでないときはエラーにする
383 if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
384
385 //マクロ関数の場合
386 i2=NumOpe(&UseReg,temp3,0,0,&index_stack[sp]);
387
388 if(!IS_LITERAL(index_stack[sp])){
389 //リテラル値ではなかったとき
390 bLiteralCalculation=0;
391 }
392
393 type[sp]=i2;
394
395 if(IsRealNumberType(i2)) pobj_reg->LockXmmReg();
396 else pobj_reg->LockReg();
397
398 sp++;
399 break;
400 }
401 }
402
403
404 char variable[VN_SIZE],array_element[VN_SIZE];
405 CClass *pobj_c;
406 GetArrayElement(term,variable,array_element);
407 if(array_element[0]){
408 i2=GetVarType(variable,(LONG_PTR *)&pobj_c,0);
409 if(i2==DEF_OBJECT){
410 TYPEINFO RetTypeInfo;
411 CallArrayOperatorProc(UseReg,pobj_c,variable,array_element,RetTypeInfo);
412 type[sp]=RetTypeInfo.type;
413 index_stack[sp]=RetTypeInfo.u.lpIndex;
414 bLiteralCalculation=0;
415
416 if(IsRealNumberType(RetTypeInfo.type)) pobj_reg->LockXmmReg();
417 else pobj_reg->LockReg();
418 sp++;
419 break;
420 }
421 }
422
423
424 RELATIVE_VAR RelativeVar;
425 if(GetVarOffset(0,term,&i2,&RelativeVar,&index_stack[sp])){
426 //////////
427 // 変数
428 //////////
429
430 //大きな型への暗黙の変換
431 type[sp]=AutoBigCast(BaseType,i2);
432 bLiteralCalculation=0;
433
434 if(type[sp]!=i2){
435 //大きな型へ変換された場合（レジスタを0に初期化する）
436
437 //xor reg,reg
438 op_zero_reg(UseReg);
439 }
440
441 if(i2&FLAG_PTR){
442 //配列ポインタ
443 type[sp]=GetPtrType(i2^FLAG_PTR,index_stack[sp]);
444
445 SetVarPtrToReg(UseReg,&RelativeVar);
446 }
447 else if(IsRealNumberType(i2)){
448 //実数型
449 bXmm=1;
450
451 if(i2==DEF_DOUBLE)
452 SetXmmReg_DoubleVariable(&RelativeVar,XmmReg);
453 if(i2==DEF_SINGLE)
454 SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
455 }
456 else if(IsWholeNumberType(i2)){
457 //整数型
458 SetReg_WholeVariable(i2,&RelativeVar,UseReg);
459 }
460 else if(i2==DEF_OBJECT){
461 //オブジェクト ポインタをUseRegへ格納
462 SetVarPtrToReg(UseReg,&RelativeVar);
463 }
464 else SetError(11,term,cp);
465
466 if(bXmm==0&&UseReg==REG_R14){
467 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
468 pobj_sf->push(REG_R14);
469 }
470 if(bXmm&&XmmReg==REG_XMM4){
471 if(i2==DEF_DOUBLE){
472 //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
473 pobj_sf->push(REG_XMM4,sizeof(double));
474 }
475 if(i2==DEF_SINGLE){
476 //movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
477 pobj_sf->push(REG_XMM4,sizeof(float));
478 }
479 }
480
481 if(bXmm) pobj_reg->LockXmmReg();
482 else pobj_reg->LockReg();
483 sp++;
484 break;
485 }
486
487
488 //////////////
489 // 定数の場合
490 //////////////
491
492 i3=GetConstValue(term,&dbl,temporary,&index_stack[sp]);
493 if(i3!=-1){
494 type[sp]=i3;
495 if(IsRealNumberType(i3)){
496 //実数
497 memcpy(&i64data,&dbl,sizeof(double));
498 goto Literal;
499 }
500 else if(IsWholeNumberType(i3)){
501 //整数
502 i64data=(_int64)dbl;
503 goto Literal;
504 }
505 else if(Is64Type(i3)){
506 //64ビット整数値
507 memcpy(&i64data,&dbl,sizeof(_int64));
508 goto Literal;
509 }
510 else if(i3==DEF_STRING){
511 //リテラル文字列
512
513 //バイト数
514 i3=(int)dbl;
515
516 memcpy(term,temporary,i3);
517 goto StrLiteral;
518 }
519 else{
520 SetError(1,NULL,0);
521 goto error;
522 }
523 }
524
525
526 //////////////
527 // 型名の場合
528 //////////////
529
530 LONG_PTR lp;
531 i3=GetTypeFixed(term,&lp);
532 if(i3!=-1){
533 type[sp]=i3|FLAG_CAST;
534 index_stack[sp]=lp;
535 sp++;
536 break;
537 }
538
539
540
541 /////////////////////////////////
542 // プロパティ用のメソッド
543 /////////////////////////////////
544
545 //配列要素を排除
546 char VarName[VN_SIZE],ArrayElements[VN_SIZE];
547 GetArrayElement(term,VarName,ArrayElements);
548
549 if(GetSubHash(VarName,0)){
550
551 //////////////////////////////////////////////////////
552 ///// レジスタ資源のバックアップ
553 { BACKUP_REGISTER_RESOURCE
554 //////////////////////////////////////////////////////
555
556 TYPEINFO RetTypeInfo;
557 CallPropertyMethod(term,NULL,&RetTypeInfo);
558
559 //大きな型への暗黙の変換
560 type[sp]=AutoBigCast(BaseType,RetTypeInfo.type);
561
562 index_stack[sp]=RetTypeInfo.u.lpIndex;
563 bLiteralCalculation=0;
564
565 SetUseRegFromRax(RetTypeInfo.type,UseReg,XmmReg);
566
567 if(IsRealNumberType(i2)) bXmm=1;
568 else bXmm=0;
569
570 /////////////////////////////////////////////
571 ////// レジスタ資源を復元
572 RESTORE_REGISTER_RESOURCE
573 }////////////////////////////////////////////
574
575 if(type[sp]==DEF_OBJECT){
576 //Object型が戻ったときはヒープ領域にインスタンスが格納されている
577 //※後にfreeする必要あり
578 bUseHeap[sp]=1;
579 }
580
581 if(bXmm) pobj_reg->LockXmmReg();
582 else pobj_reg->LockReg();
583 sp++;
584 break;
585 }
586
587
588
589 //該当する識別子が見当たらないときはエラー扱いにする
590 bError=1;
591 SetError(3,term,cp);
592 type[sp]=DEF_DOUBLE;
593 }
594 else{
595 //リテラル値
596 type[sp]=GetLiteralValue(term,&i64data,BaseType);
597Literal:
598 if(type[sp]==DEF_DOUBLE){
599 //64ビット浮動小数型
600 bXmm=1;
601
602 if(XmmReg==REG_XMM4){
603 //mov r14,i64data
604 op_mov64_ToReg(REG_R14,i64data);
605
606
607 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
608 pobj_sf->push(REG_R14);
609 }
610 else{
611 i3=AddDataTable((char *)&i64data,sizeof(_int64));
612
613 //movlpd xmm_reg,qword ptr[data table offset]
614 OpBuffer[obp++]=(char)0x66;
615 OpBuffer[obp++]=(char)0x0F;
616 OpBuffer[obp++]=(char)0x12;
617 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
618 OpBuffer[obp++]=(char)0x25;
619 *((long *)(OpBuffer+obp))=i3;
620 pobj_DataTableSchedule->add();
621 obp+=sizeof(long);
622 }
623 }
624 else if(type[sp]==DEF_SINGLE){
625 //32ビット浮動小数型
626 bXmm=1;
627
628 float flt;
629 int i32data;
630 memcpy(&dbl,&i64data,sizeof(double));
631 flt=(float)dbl;
632 memcpy(&i32data,&flt,sizeof(long));
633
634 if(XmmReg==REG_XMM4){
635 //push term
636 op_push_value(i32data);
637 }
638 else{
639 i3=AddDataTable((char *)&i32data,sizeof(long));
640
641 //movss xmm_reg,dword ptr[data table offset]
642 OpBuffer[obp++]=(char)0xF3;
643 OpBuffer[obp++]=(char)0x0F;
644 OpBuffer[obp++]=(char)0x10;
645 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
646 OpBuffer[obp++]=(char)0x25;
647 *((long *)(OpBuffer+obp))=i3;
648 pobj_DataTableSchedule->add();
649 obp+=sizeof(long);
650 }
651 }
652 else{
653 //整数
654
655 index_stack[sp]=GetLiteralIndex(i64data);
656
657 //mov reg,i64data
658 op_mov64_ToReg(UseReg,i64data);
659
660 if(UseReg==REG_R14){
661 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
662 pobj_sf->push(REG_R14);
663 }
664 }
665 }
666
667 if(bXmm) pobj_reg->LockXmmReg();
668 else pobj_reg->LockReg();
669
670 sp++;
671 break;
672
673 //論理演算子
674 case CALC_XOR:
675 case CALC_OR:
676 case CALC_AND:
677 if(!CalcTwoTerm_Logical(idCalc,type,index_stack,&sp)) goto error;
678 break;
679 case CALC_NOT:
680 //value[sp-1]=Not value[sp-1]
681 //NOT演算子
682 if(!Calc_Not(type,sp)) goto error;
683 break;
684
685 //比較演算子
686 case CALC_PE: //value[sp-2] <= value[sp-1]
687 case CALC_QE: //value[sp-2] >= value[sp-1]
688 case CALC_P: //value[sp-2] < value[sp-1]
689 case CALC_Q: //value[sp-2] > value[sp-1]
690 case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
691 case CALC_EQUAL: //value[sp-2] = value[sp-1]
692 if(!CalcTwoTerm_Relational(idCalc,type,index_stack,&sp)) goto error;
693 break;
694
695 //ビットシフト
696 case CALC_SHL: //value[sp-2] << value[sp-1]
697 case CALC_SHR: //value[sp-2] >> value[sp-1]
698 if(!Calc_Shift(idCalc,type,&sp)) goto error;
699 break;
700
701 //算術演算
702 case CALC_ADDITION:
703 case CALC_SUBTRACTION:
704 case CALC_PRODUCT:
705 if(!CalcTwoTerm_Arithmetic(idCalc,type,index_stack,&sp)) goto error;
706 break;
707 case CALC_MOD:
708 //value[sp-2]%=value[sp-1]
709 //剰余演算
710 if(!Calc_Mod(type,index_stack,&sp)) goto error;
711 break;
712 case CALC_QUOTIENT:
713 //value[sp-2]/=value[sp-1];
714 //除算
715 if(!Calc_Divide(type,&sp,BaseType)) goto error;
716 break;
717 case CALC_INTQUOTIENT:
718 //value[sp-2]/=value[sp-1]
719 //整数除算
720 if(!Calc_IntDivide(type,index_stack,&sp)) goto error;
721 break;
722 case CALC_MINUSMARK:
723 //value[sp-1]=-value[sp-1]
724 //符号反転
725 if(!Calc_MinusMark(type,sp)) goto error;
726 break;
727 case CALC_POWER:
728 //べき乗演算（浮動小数点演算のみ）
729 if(!Calc_Power(type,&sp)) goto error;
730 break;
731 case CALC_AS:
732 //キャスト
733 if(!Calc_Cast(type,index_stack,&sp)) goto error;
734 break;
735
736 default:
737 SetError(300,NULL,cp);
738 break;
739 }
740 }
741
742 if(bError) goto error;
743
744 if(sp!=1){
745 SetError(1,NULL,cp);
746 goto error;
747 }
748
749 if(bLiteralCalculation){
750 //右辺値が数値の定数式の場合
751 LONG_PTR lpClassIndex;
752 i2=StaticCalculation(true, Command,BaseType,&i64data,&lpClassIndex);
753
754 obp=BeforeObp;
755 pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
756 pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
757 pobj_Reloc->copy(pobj_BackReloc);
758 pobj_sf->num=Before_StackFrameScheduleNum;
759 *pobj_reg=objReg_Backup;
760
761 if(IsRealNumberType(i2)){
762 if(IsRealNumberType(BaseType)) i2=BaseType;
763
764 XmmReg=pobj_reg->LockXmmReg();
765
766 if(i2==DEF_DOUBLE){
767 i3=AddDataTable((char *)&i64data,sizeof(_int64));
768
769 //movlpd xmm_reg,qword ptr[data table offset]
770 OpBuffer[obp++]=(char)0x66;
771 OpBuffer[obp++]=(char)0x0F;
772 OpBuffer[obp++]=(char)0x12;
773 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
774 OpBuffer[obp++]=(char)0x25;
775 *((long *)(OpBuffer+obp))=i3;
776 pobj_DataTableSchedule->add();
777 obp+=sizeof(long);
778 }
779 if(i2==DEF_SINGLE){
780 memcpy(&dbl,&i64data,sizeof(_int64));
781
782 float flt;
783 int i32data;
784 flt=(float)dbl;
785 memcpy(&i32data,&flt,sizeof(long));
786
787 i3=AddDataTable((char *)&i32data,sizeof(long));
788
789 //movss xmm_reg,dword ptr[data table offset]
790 OpBuffer[obp++]=(char)0xF3;
791 OpBuffer[obp++]=(char)0x0F;
792 OpBuffer[obp++]=(char)0x10;
793 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
794 OpBuffer[obp++]=(char)0x25;
795 *((long *)(OpBuffer+obp))=i3;
796 pobj_DataTableSchedule->add();
797 obp+=sizeof(long);
798 }
799 }
800 else{
801 if(!Is64Type(i2)){
802 //整数（符号有り/無し）
803
804 i3=(long)i64data;
805
806 if(GetTypeSize(i2,-1)==sizeof(char)) i3=i3&0x000000FF;
807 if(GetTypeSize(i2,-1)==sizeof(short)) i3=i3&0x0000FFFF;
808
809 i64data=(_int64)i3;
810 }
811
812 UseReg=pobj_reg->LockReg();
813
814 //mov reg,i64data
815 op_mov64_ToReg(UseReg,i64data);
816 }
817
818 type[0]=i2;
819 index_stack[0]=lpClassIndex;
820 }
821 else{
822 //右辺値が数値の定数式ではないとき
823 if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
824 }
825
826 if(plpIndex) *plpIndex=index_stack[0];
827 if(pbUseHeap) *pbUseHeap=bUseHeap[0];
828
829 if(IsRealNumberType(type[0]))
830 *pReg=pobj_reg->UnlockXmmReg();
831 else
832 *pReg=pobj_reg->UnlockReg();
833
834
835 if(bInitRegSwitch){
836 //整合性をチェック（バグ回避）
837 pobj_reg->bug_check();
838
839 //作業レジスタを解放
840 delete pobj_reg;
841 pobj_reg=0;
842 }
843
844 int RetType;
845 RetType=type[0];
846 goto finish;
847
848
849
850 //////////////////
851 // エラー処理
852 //////////////////
853
854error:
855
856 *pobj_reg=objReg_Backup;
857
858 if(bInitRegSwitch){
859 //作業レジスタを解放
860 delete pobj_reg;
861 pobj_reg=0;
862 }
863
864 RetType=-1;
865 goto finish;
866
867
868
869
870finish:
871
872 for(i=0;i<pnum;i++){
873 if(values[i]) HeapDefaultFree(values[i]);
874 }
875
876 //再配置スケジュールバックアップ情報を解放
877 delete pobj_BackReloc;
878
879 return RetType;
880}
Note: See TracBrowser for help on using the repository browser.