Context Navigation

source: dev/BasicCompiler64/NumOpe.cpp@ 19

Last change on this file since 19 was 19, checked in by dai_9181, 17 years ago
64ビットコンパイラでローカル変数の0初期化に対応。 raxまたはrdxを一時保存レジスタとして利用する際に、Mod演算子、\演算子が正常に動作しないバグを修正。
File size: 21.1 KB

Line
1	#include "../BasicCompiler_Common/common.h"
2	#include "Opcode.h"
3
4	void 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
73	void 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
110	int 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);
241	StrLiteral:
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(
426	false, //エラー表示あり
427	false, //読み込み専用
428	term,
429	&i2,&RelativeVar,&index_stack[sp])){
430	//////////
431	// 変数
432	//////////
433
434	//大きな型への暗黙の変換
435	type[sp]=AutoBigCast(BaseType,i2);
436	bLiteralCalculation=0;
437
438	if(type[sp]!=i2){
439	//大きな型へ変換された場合（レジスタを0に初期化する）
440
441	//xor reg,reg
442	op_zero_reg(UseReg);
443	}
444
445	if(i2&FLAG_PTR){
446	//配列ポインタ
447	type[sp]=GetPtrType(i2^FLAG_PTR,index_stack[sp]);
448
449	SetVarPtrToReg(UseReg,&RelativeVar);
450	}
451	else if(IsRealNumberType(i2)){
452	//実数型
453	bXmm=1;
454
455	if(i2==DEF_DOUBLE)
456	SetXmmReg_DoubleVariable(&RelativeVar,XmmReg);
457	if(i2==DEF_SINGLE)
458	SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
459	}
460	else if(IsWholeNumberType(i2)){
461	//整数型
462	SetReg_WholeVariable(i2,&RelativeVar,UseReg);
463	}
464	else if(i2==DEF_OBJECT){
465	//オブジェクトポインタをUseRegへ格納
466	SetVarPtrToReg(UseReg,&RelativeVar);
467	}
468	else SetError(11,term,cp);
469
470	if(bXmm==0&&UseReg==REG_R14){
471	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
472	pobj_sf->push(REG_R14);
473	}
474	if(bXmm&&XmmReg==REG_XMM4){
475	if(i2==DEF_DOUBLE){
476	//movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
477	pobj_sf->push(REG_XMM4,sizeof(double));
478	}
479	if(i2==DEF_SINGLE){
480	//movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
481	pobj_sf->push(REG_XMM4,sizeof(float));
482	}
483	}
484
485	if(bXmm) pobj_reg->LockXmmReg();
486	else pobj_reg->LockReg();
487	sp++;
488	break;
489	}
490
491
492	//////////////
493	// 定数の場合
494	//////////////
495
496	i3 = CDBConst::obj.GetType(term);
497	if(i3){
498	type[sp] = i3;
499	if(IsRealNumberType(i3)){
500	//実数
501	double dbl = CDBConst::obj.GetDoubleData(term);
502	memcpy(&i64data,&dbl,sizeof(double));
503	goto Literal;
504	}
505	else if(IsWholeNumberType(i3)){
506	//整数
507	i64data = CDBConst::obj.GetWholeData(term);
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
531	LONG_PTR lp;
532	i3=GetTypeFixed(term,&lp);
533	if(i3!=-1){
534	type[sp]=i3\|FLAG_CAST;
535	index_stack[sp]=lp;
536	sp++;
537	break;
538	}
539
540
541
542	/////////////////////////////////
543	// プロパティ用のメソッド
544	/////////////////////////////////
545
546	//配列要素を排除
547	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
548	GetArrayElement(term,VarName,ArrayElements);
549
550	if(GetSubHash(VarName,0)){
551
552	//////////////////////////////////////////////////////
553	///// レジスタ資源のバックアップ
554	{ BACKUP_REGISTER_RESOURCE
555	//////////////////////////////////////////////////////
556
557	TYPEINFO RetTypeInfo;
558	CallPropertyMethod(term,NULL,&RetTypeInfo);
559
560	//大きな型への暗黙の変換
561	type[sp]=AutoBigCast(BaseType,RetTypeInfo.type);
562
563	index_stack[sp]=RetTypeInfo.u.lpIndex;
564	bLiteralCalculation=0;
565
566	SetUseRegFromRax(RetTypeInfo.type,UseReg,XmmReg);
567
568	if(IsRealNumberType(type[sp])) bXmm=1;
569	else bXmm=0;
570
571	/////////////////////////////////////////////
572	////// レジスタ資源を復元
573	RESTORE_REGISTER_RESOURCE
574	}////////////////////////////////////////////
575
576	if(type[sp]==DEF_OBJECT){
577	//Object型が戻ったときはヒープ領域にインスタンスが格納されている
578	//※後にfreeする必要あり
579	bUseHeap[sp]=1;
580	}
581
582	if(bXmm) pobj_reg->LockXmmReg();
583	else pobj_reg->LockReg();
584	sp++;
585	break;
586	}
587
588
589
590	//該当する識別子が見当たらないときはエラー扱いにする
591	bError=1;
592	SetError(3,term,cp);
593	type[sp]=DEF_DOUBLE;
594	}
595	else{
596	//リテラル値
597	type[sp]=GetLiteralValue(term,&i64data,BaseType);
598	Literal:
599	if(type[sp]==DEF_DOUBLE){
600	//64ビット浮動小数型
601	bXmm=1;
602
603	if(XmmReg==REG_XMM4){
604	//mov r14,i64data
605	op_mov64_ToReg(REG_R14,i64data);
606
607
608	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
609	pobj_sf->push(REG_R14);
610	}
611	else{
612	i3=AddDataTable((char *)&i64data,sizeof(_int64));
613
614	//movlpd xmm_reg,qword ptr[data table offset]
615	OpBuffer[obp++]=(char)0x66;
616	OpBuffer[obp++]=(char)0x0F;
617	OpBuffer[obp++]=(char)0x12;
618	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
619	OpBuffer[obp++]=(char)0x25;
620	((long )(OpBuffer+obp))=i3;
621	pobj_DataTableSchedule->add();
622	obp+=sizeof(long);
623	}
624	}
625	else if(type[sp]==DEF_SINGLE){
626	//32ビット浮動小数型
627	bXmm=1;
628
629	float flt;
630	int i32data;
631	memcpy(&dbl,&i64data,sizeof(double));
632	flt=(float)dbl;
633	memcpy(&i32data,&flt,sizeof(long));
634
635	if(XmmReg==REG_XMM4){
636	//push term
637	op_push_value(i32data);
638	}
639	else{
640	i3=AddDataTable((char *)&i32data,sizeof(long));
641
642	//movss xmm_reg,dword ptr[data table offset]
643	OpBuffer[obp++]=(char)0xF3;
644	OpBuffer[obp++]=(char)0x0F;
645	OpBuffer[obp++]=(char)0x10;
646	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
647	OpBuffer[obp++]=(char)0x25;
648	((long )(OpBuffer+obp))=i3;
649	pobj_DataTableSchedule->add();
650	obp+=sizeof(long);
651	}
652	}
653	else{
654	//整数
655
656	index_stack[sp]=GetLiteralIndex(i64data);
657
658	//mov reg,i64data
659	op_mov64_ToReg(UseReg,i64data);
660
661	if(UseReg==REG_R14){
662	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
663	pobj_sf->push(REG_R14);
664	}
665	}
666	}
667
668	if(bXmm) pobj_reg->LockXmmReg();
669	else pobj_reg->LockReg();
670
671	sp++;
672	break;
673
674	//論理演算子
675	case CALC_XOR:
676	case CALC_OR:
677	case CALC_AND:
678	if(!CalcTwoTerm_Logical(idCalc,type,index_stack,&sp)) goto error;
679	break;
680	case CALC_NOT:
681	//value[sp-1]=Not value[sp-1]
682	//NOT演算子
683	if(!Calc_Not(type,sp)) goto error;
684	break;
685
686	//比較演算子
687	case CALC_PE: //value[sp-2] <= value[sp-1]
688	case CALC_QE: //value[sp-2] >= value[sp-1]
689	case CALC_P: //value[sp-2] < value[sp-1]
690	case CALC_Q: //value[sp-2] > value[sp-1]
691	case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
692	case CALC_EQUAL: //value[sp-2] = value[sp-1]
693	if(!CalcTwoTerm_Relational(idCalc,type,index_stack,&sp)) goto error;
694	break;
695
696	//ビットシフト
697	case CALC_SHL: //value[sp-2] << value[sp-1]
698	case CALC_SHR: //value[sp-2] >> value[sp-1]
699	if(!Calc_Shift(idCalc,type,&sp)) goto error;
700	break;
701
702	//算術演算
703	case CALC_ADDITION:
704	case CALC_SUBTRACTION:
705	case CALC_PRODUCT:
706	if(!CalcTwoTerm_Arithmetic(idCalc,type,index_stack,&sp)) goto error;
707	break;
708	case CALC_MOD:
709	//value[sp-2]%=value[sp-1]
710	//剰余演算
711	if(!Calc_Mod(type,index_stack,&sp)) goto error;
712	break;
713	case CALC_QUOTIENT:
714	//value[sp-2]/=value[sp-1];
715	//除算
716	if(!Calc_Divide(type,&sp,BaseType)) goto error;
717	break;
718	case CALC_INTQUOTIENT:
719	//value[sp-2]/=value[sp-1]
720	//整数除算
721	if(!Calc_IntDivide(type,index_stack,&sp)) goto error;
722	break;
723	case CALC_MINUSMARK:
724	//value[sp-1]=-value[sp-1]
725	//符号反転
726	if(!Calc_MinusMark(type,sp)) goto error;
727	break;
728	case CALC_POWER:
729	//べき乗演算（浮動小数点演算のみ）
730	if(!Calc_Power(type,&sp)) goto error;
731	break;
732	case CALC_AS:
733	//キャスト
734	if(!Calc_Cast(type,index_stack,&sp)) goto error;
735	break;
736
737	default:
738	SetError(300,NULL,cp);
739	break;
740	}
741	}
742
743	if(bError) goto error;
744
745	if(sp!=1){
746	SetError(1,NULL,cp);
747	goto error;
748	}
749
750	if(bLiteralCalculation){
751	//右辺値が数値の定数式の場合
752	LONG_PTR lpClassIndex;
753	i2=StaticCalculation(true, Command,BaseType,&i64data,&lpClassIndex);
754
755	obp=BeforeObp;
756	pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
757	pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
758	pobj_Reloc->copy(pobj_BackReloc);
759	pobj_sf->num=Before_StackFrameScheduleNum;
760	*pobj_reg=objReg_Backup;
761
762	if(IsRealNumberType(i2)){
763	if(IsRealNumberType(BaseType)) i2=BaseType;
764
765	XmmReg=pobj_reg->LockXmmReg();
766
767	if(i2==DEF_DOUBLE){
768	i3=AddDataTable((char *)&i64data,sizeof(_int64));
769
770	//movlpd xmm_reg,qword ptr[data table offset]
771	OpBuffer[obp++]=(char)0x66;
772	OpBuffer[obp++]=(char)0x0F;
773	OpBuffer[obp++]=(char)0x12;
774	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
775	OpBuffer[obp++]=(char)0x25;
776	((long )(OpBuffer+obp))=i3;
777	pobj_DataTableSchedule->add();
778	obp+=sizeof(long);
779	}
780	if(i2==DEF_SINGLE){
781	memcpy(&dbl,&i64data,sizeof(_int64));
782
783	float flt;
784	int i32data;
785	flt=(float)dbl;
786	memcpy(&i32data,&flt,sizeof(long));
787
788	i3=AddDataTable((char *)&i32data,sizeof(long));
789
790	//movss xmm_reg,dword ptr[data table offset]
791	OpBuffer[obp++]=(char)0xF3;
792	OpBuffer[obp++]=(char)0x0F;
793	OpBuffer[obp++]=(char)0x10;
794	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
795	OpBuffer[obp++]=(char)0x25;
796	((long )(OpBuffer+obp))=i3;
797	pobj_DataTableSchedule->add();
798	obp+=sizeof(long);
799	}
800	}
801	else{
802	if(!Is64Type(i2)){
803	//整数（符号有り/無し）
804
805	i3=(long)i64data;
806
807	if(GetTypeSize(i2,-1)==sizeof(char)) i3=i3&0x000000FF;
808	if(GetTypeSize(i2,-1)==sizeof(short)) i3=i3&0x0000FFFF;
809
810	i64data=(_int64)i3;
811	}
812
813	UseReg=pobj_reg->LockReg();
814
815	//mov reg,i64data
816	op_mov64_ToReg(UseReg,i64data);
817	}
818
819	type[0]=i2;
820	index_stack[0]=lpClassIndex;
821	}
822	else{
823	//右辺値が数値の定数式ではないとき
824	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
825	}
826
827	if(plpIndex) *plpIndex=index_stack[0];
828	if(pbUseHeap) *pbUseHeap=bUseHeap[0];
829
830	if(IsRealNumberType(type[0]))
831	*pReg=pobj_reg->UnlockXmmReg();
832	else
833	*pReg=pobj_reg->UnlockReg();
834
835
836	if(bInitRegSwitch){
837	//整合性をチェック（バグ回避）
838	pobj_reg->bug_check();
839
840	//作業レジスタを解放
841	delete pobj_reg;
842	pobj_reg=0;
843	}
844
845	int RetType;
846	RetType=type[0];
847	goto finish;
848
849
850
851	//////////////////
852	// エラー処理
853	//////////////////
854
855	error:
856
857	*pobj_reg=objReg_Backup;
858
859	if(bInitRegSwitch){
860	//作業レジスタを解放
861	delete pobj_reg;
862	pobj_reg=0;
863	}
864
865	RetType=-1;
866	goto finish;
867
868
869
870
871	finish:
872
873	for(i=0;i<pnum;i++){
874	if(values[i]) HeapDefaultFree(values[i]);
875	}
876
877	//再配置スケジュールバックアップ情報を解放
878	delete pobj_BackReloc;
879
880	return RetType;
881	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: