Context Navigation

source: dev/BasicCompiler64/NumOpe.cpp@ 64

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

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

Download in other formats: