Context Navigation

source: dev/BasicCompiler64/Compile_Var.cpp@ 62

Last change on this file since 62 was 62, checked in by dai_9181, 17 years ago
グローバル変数に対してByRefを指定できるようにした
File size: 34.1 KB

Line
1	#include "../BasicCompiler_Common/common.h"
2	#include "Opcode.h"
3
4	//変数
5	VARIABLE *GlobalVar;
6	int MaxGlobalVarNum;
7	int AllGlobalVarSize;
8	int AllInitGlobalVarSize;
9	VARIABLE *LocalVar;
10	int MaxLocalVarNum;
11	int AllLocalVarSize;
12
13
14	void SetRelativeOffset(int pType,LONG_PTR lpIndex,RELATIVE_VAR pRelativeVar,char *lpPtrOffset){
15	int i2;
16
17
18	/////////////////////////////////////////////
19	// 先頭ポインタをr12に取得してメモリへ退避
20	/////////////////////////////////////////////
21
22	SetReg_WholeVariable(DEF_INT64,pRelativeVar,REG_R11);
23
24	//mov qword ptr[rsp+offset],r11 ※スタックフレームを利用
25	pobj_sf->push(REG_R11);
26
27
28	////////////////////////////////
29	// 添え字を計算する
30	////////////////////////////////
31
32	int reg=REG_NON;
33	i2=NumOpe(&reg,lpPtrOffset,0,0,0);
34	if(!IsWholeNumberType(i2)) SetError(46,NULL,cp);
35	ExtendTypeTo64(i2,reg);
36
37	if(reg==REG_R14){
38	//mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
39	pobj_sf->pop(REG_R14);
40	}
41
42	if(PTR_LEVEL(*pType)){
43	pType=MAKE_PTR_TYPE(NATURAL_TYPE(pType),PTR_LEVEL(*pType)-1);
44	if((*pType)==DEF_OBJECT){
45	//imul reg,objsize
46	op_imul_value(sizeof(_int64),reg,GetSizeOfClassMember((CClass *)lpIndex,NULL,NULL));
47	}
48	else{
49	i2=GetTypeSize(*pType,-1);
50	if(i2>=2){
51	//imul reg,i2
52	op_imul_value(sizeof(_int64),reg,i2);
53	}
54	}
55	}
56	else{
57	//エラー
58	SetError(1,NULL,cp);
59	return;
60	}
61
62
63	//////////////////////////////
64	// 先頭ポインタに添え字を加算
65	//////////////////////////////
66
67	//mov r11,qword ptr[rsp+offset] ※スタックフレームを利用
68	pobj_sf->pop(REG_R11);
69
70	//add r11,reg
71	op_add64_reg(REG_R11,reg);
72	}
73	BOOL GetArrayOffset(int SubScripts,char array,int type,LONG_PTR lpIndex){
74	extern HANDLE hHeap;
75	int i,i2,i3,i4,TypeSize;
76	char temporary[VN_SIZE],*pParm[MAX_PARMS];
77
78	for(i=0,i2=0,i3=0;;i++,i2++){
79	if(array[i]=='('){
80	i4=GetStringInPare(temporary+i2,array+i);
81	i+=i4-1;
82	i2+=i4-1;
83	continue;
84	}
85	if(array[i]=='['){
86	i4=GetStringInBracket(temporary+i2,array+i);
87	i+=i4-1;
88	i2+=i4-1;
89	continue;
90	}
91	if(array[i]==','\|\|array[i]=='\0'){
92	if(SubScripts[i3]==-1){
93	for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
94	return 0;
95	}
96
97	temporary[i2]=0;
98
99	pParm[i3]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
100	lstrcpy(pParm[i3],temporary);
101
102	i3++;
103
104	if(array[i]=='\0'){
105	if(SubScripts[i3]!=-1){
106	for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
107	return 0;
108	}
109	break;
110	}
111
112	i2=-1;
113	continue;
114	}
115	temporary[i2]=array[i];
116	}
117
118	//mov qword ptr[rsp+offset],r11 ※スタックフレームを利用
119	pobj_sf->push(REG_R11);
120
121	//xor r12,r12
122	op_zero_reg(REG_R12);
123
124	for(i=i3-1;i>=0;i--){
125	//mov qword ptr[rsp+offset],r12 ※スタックフレームを利用
126	pobj_sf->push(REG_R12);
127
128	int reg=REG_NON;
129	TYPEINFO TypeInfo;
130	BOOL bUseHeap;
131	TypeInfo.type=NumOpe(&reg,pParm[i],DEF_LONG,-1,&TypeInfo.u.lpIndex,&bUseHeap);
132	if(TypeInfo.type==DEF_OBJECT){
133	//キャスト演算子のオーバーロードに対応する
134	CallCastOperatorProc(reg,
135	TypeInfo.type,TypeInfo.u.lpIndex,
136	bUseHeap,DEF_LONG,-1);
137	TypeInfo.type=DEF_LONG;
138	}
139
140	if(!IsWholeNumberType(TypeInfo.type)) SetError(46,NULL,cp);
141	ExtendTypeTo64(TypeInfo.type,reg);
142
143	if(reg==REG_R14){
144	//mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
145	pobj_sf->pop(REG_R14);
146	}
147
148	//mov r12,qword ptr[rsp+offset] ※スタックフレームを利用
149	pobj_sf->pop(REG_R12);
150
151	for(i2=i+1,i4=1;i2<i3;i2++) i4*=SubScripts[i2]+1;
152
153	//imul reg,i4
154	op_imul_value(sizeof(_int64),reg,i4);
155
156	//add r12,reg
157	op_add64_reg(REG_R12,reg);
158
159	HeapDefaultFree(pParm[i]);
160	}
161
162	TypeSize=GetTypeSize(type,lpIndex);
163
164	//imul r12,TypeSize
165	OpBuffer[obp++]=(char)0x4D;
166	OpBuffer[obp++]=(char)0x69;
167	OpBuffer[obp++]=(char)0xE4;
168	((long )(OpBuffer+obp))=TypeSize;
169	obp+=sizeof(long);
170
171	//mov r11,qword ptr[rsp+offset] ※スタックフレームを利用
172	pobj_sf->pop(REG_R11);
173
174	//add r11,r12
175	OpBuffer[obp++]=(char)0x4D;
176	OpBuffer[obp++]=(char)0x03;
177	OpBuffer[obp++]=(char)0xDC;
178
179	return 1;
180	}
181	BOOL GetMemberOffset(bool isErrorEnabled, bool isWriteAccess, CClass pobj_c, char member, int pType, RELATIVE_VAR pRelativeVar, LONG_PTR *plpNestIndex, BOOL bPrivateAccess){
182	int i,offset;
183
184
185	//////////////////////////////////////
186	// クラス、配列の構成要素を解析する
187	//////////////////////////////////////
188
189	char VarName[VN_SIZE]; //変数名
190	char array[VN_SIZE]; //第1次配列
191	char lpPtrOffset[VN_SIZE]; //第2次配列
192	char NestMember[VN_SIZE]; //入れ子メンバ
193	int RefType; //"."参照のときは0、"->"参照のときは1
194	lstrcpy(VarName,member);
195	if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;
196
197
198	////////////////////////////
199	// メンバオフセットを取得
200	////////////////////////////
201
202	offset=GetSizeOfClassMember(pobj_c,VarName,&i);
203	if(i==pobj_c->iMemberNum){
204	if(isErrorEnabled) SetError(103,VarName,cp);
205	return 0;
206	}
207
208	CMember *pMember=pobj_c->ppobj_Member[i];
209
210
211	//アクセシビリティをチェック
212	if(pobj_c==pobj_CompilingClass){
213	//同一クラスオブジェクトの場合はプライベートアクセスを容認する
214	if(pMember->dwAccess==ACCESS_NON){
215	if(isErrorEnabled) SetError(107,VarName,cp);
216	return 0;
217	}
218	}
219	else{
220	if((bPrivateAccess==0&&pMember->dwAccess==ACCESS_PRIVATE)\|\|
221	pMember->dwAccess==ACCESS_NON){
222	if(isErrorEnabled) SetError(107,VarName,cp);
223	return 0;
224	}
225	else if(bPrivateAccess==0&&pMember->dwAccess==ACCESS_PROTECTED){
226	if(isErrorEnabled) SetError(108,VarName,cp);
227	return 0;
228	}
229	}
230
231	//Const定義の場合は書き込みアクセスを制限する
232	//※コンストラクタをコンパイル中の場合は例外的に許可する
233	if( pMember->IsConst() && //定数メンバである
234	isWriteAccess && //書き込みアクセスを要求されている
235	pobj_c->IsCompilingConstructor() == false //コンストラクタコンパイル中を除く
236	){
237	//Const定義の変数に書き込みアクセスをしようとした場合
238	SetError(61,VarName,cp);
239	}
240
241	*pType=pMember->TypeInfo.type;
242	*plpNestIndex=pMember->TypeInfo.u.lpIndex;
243
244	//ポインタ変数の場合
245	if(IsPtrType(*pType)){
246	if(pMember->SubScripts[0]==-1){
247	lstrcpy(lpPtrOffset,array);
248	array[0]=0;
249	}
250	}
251	else{
252	if(lpPtrOffset[0]){
253	if(isErrorEnabled) SetError(16,member,cp);
254	return 0;
255	}
256	}
257
258	if(offset){
259	//add r11,offset
260	OpBuffer[obp++]=(char)0x49;
261	OpBuffer[obp++]=(char)0x81;
262	OpBuffer[obp++]=(char)0xC3;
263	((long )(OpBuffer+obp))=offset;
264	obp+=sizeof(long);
265	}
266
267	if(array[0]){
268	//配列オフセット
269	if(!GetArrayOffset(pMember->SubScripts,array,*pType,pMember->TypeInfo.u.lpIndex)){
270	if(isErrorEnabled) SetError(14,member,cp);
271	}
272	}
273	else if(pMember->SubScripts[0]!=-1){
274	*pType\|=FLAG_PTR;
275	}
276
277	if(NestMember[0]){
278	//入れ子構造の場合
279
280	if(*pType==DEF_OBJECT && pMember->IsRef() == false){
281	if(RefType!=DEF_OBJECT){
282	if(isErrorEnabled) SetError(104,member,cp);
283	return 0;
284	}
285	}
286	else if(pType==DEF_PTR_OBJECT \|\| ( pType==DEF_OBJECT && pMember->IsRef() )){
287	//構造体ポインタ型メンバ変数
288
289	if(lpPtrOffset[0]){
290	//pObj[n].member
291	if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_OBJECT){
292	if(isErrorEnabled) SetError(104,member,cp);
293	return 0;
294	}
295
296	//直接参照に切り替え
297	SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
298	pRelativeVar->dwKind=VAR_DIRECTMEM;
299
300	lpPtrOffset[0]=0;
301	}
302	else{
303	//pObj->member
304	if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_PTR_OBJECT){
305	if(isErrorEnabled) SetError(104,member,cp);
306	return 0;
307	}
308
309	if(pRelativeVar->dwKind==VAR_DIRECTMEM){
310	//mov r11,qword ptr[r11]
311	op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
312	}
313	else{
314	//直接参照に切り替え
315	SetVarPtrToReg(REG_R12,pRelativeVar);
316	pRelativeVar->dwKind=VAR_DIRECTMEM;
317
318	//mov r11,qword ptr[r12]
319	op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
320	}
321	}
322	}
323	else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
324	//構造体ポインタのポインタ型メンバ変数
325
326	if(lpPtrOffset[0]){
327	//ppObj[n]->member
328	if(RefType!=DEF_PTR_OBJECT){
329	if(isErrorEnabled) SetError(104,member,cp);
330	return 0;
331	}
332
333	//直接参照に切り替え
334	SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
335	pRelativeVar->dwKind=VAR_DIRECTMEM;
336
337	lpPtrOffset[0]=0;
338
339	//mov r11,qword ptr[r11]
340	op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
341	}
342	else{
343	if(isErrorEnabled) SetError(104,member,cp);
344	return 0;
345	}
346	}
347
348	if(!GetMemberOffset(
349	isErrorEnabled,
350	isWriteAccess,
351	pMember->TypeInfo.u.pobj_Class,
352	NestMember,
353	pType,
354	pRelativeVar,
355	plpNestIndex,
356	0)) return 0;
357	}
358
359	if(lpPtrOffset[0]){
360	SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
361	pRelativeVar->dwKind=VAR_DIRECTMEM;
362	}
363
364	return 1;
365	}
366	void GetWithName(char *buffer){
367	extern WITHINFO WithInfo;
368	int i;
369
370	buffer[0]=0;
371	for(i=0;i<WithInfo.num;i++)
372	lstrcat(buffer,WithInfo.ppName[i]);
373	}
374
375	int LocalVar_ThisPtrOffset;
376	void SetThisPtrToReg(int reg){
377	//自身のオブジェクトのThisポインタをregにコピー
378
379	extern VARIABLE *LocalVar;
380	RELATIVE_VAR RelativeVar;
381	RelativeVar.dwKind=VAR_LOCAL;
382	RelativeVar.bOffsetOffset=0;
383	RelativeVar.offset=-LocalVar_ThisPtrOffset;
384
385	SetReg_WholeVariable(DEF_PTR_VOID,&RelativeVar,reg);
386	}
387	BOOL GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char NameBuffer,int pType,RELATIVE_VAR pRelativeVar,LONG_PTR plpIndex,int *pss){
388	extern BOOL bCompilingGlobal;
389	int i,RefType;
390	LONG_PTR lpIndex;
391	char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
392
393	if(NameBuffer[0]=='.'){
394	GetWithName(variable);
395	lstrcat(variable,NameBuffer);
396	}
397	else lstrcpy(variable,NameBuffer);
398
399	if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
400	// 戻り値オブジェクトのメンバを直接参照しているとき
401	//例: func().member
402
403	void *pInfo;
404	int idProc=GetProc(VarName,&pInfo);
405
406	if(idProc){
407	pRelativeVar->dwKind=VAR_DIRECTMEM;
408
409	//////////////////////////////////////////////////////
410	///// レジスタ資源のバックアップ
411	{ BACKUP_REGISTER_RESOURCE
412	//////////////////////////////////////////////////////
413
414	////////////////
415	// 呼び出し
416	////////////////
417
418	*pType=CallProc(idProc,pInfo,VarName,array,&lpIndex);
419
420	//戻り値をr11にコピー
421	op_mov_RR( REG_R11, REG_RAX );
422
423	/////////////////////////////////////////////
424	////// レジスタ資源を復元
425	RESTORE_REGISTER_RESOURCE
426	}////////////////////////////////////////////
427
428	LONG_PTR lp2;
429	if(!GetMemberOffset(
430	isErrorEnabled,
431	isWriteAccess,
432	(CClass *)lpIndex,
433	member,pType,pRelativeVar,&lp2,0)) return 0;
434	if(plpIndex) *plpIndex=lp2;
435
436	return 1;
437	}
438	}
439
440
441
442	lstrcpy(VarName,variable);
443	GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
444
445	int *pSubScripts;
446	bool bConst = false;
447
448
449	if(bCompilingGlobal==0){
450	//////////////////
451	// ローカル変数
452	//////////////////
453
454	for(i=MaxLocalVarNum-1;i>=0;i--){ //レキシカルスコープを考慮してバックサーチ
455	if( LocalVar[i].bLiving //現在のスコープで有効なもの
456	&& LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel() //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
457	){
458	if(lstrcmp(VarName,LocalVar[i].name)==0) break;
459	}
460	}
461	if(i>=0){
462	//ポインタ変数の場合
463	if(IsPtrType(LocalVar[i].type)){
464	if(LocalVar[i].SubScripts[0]==-1){
465	lstrcpy(lpPtrOffset,array);
466	array[0]=0;
467	}
468	}
469	else{
470	if(lpPtrOffset[0]){
471	SetError(16,variable,cp);
472	pRelativeVar->dwKind=NON_VAR;
473	return 0;
474	}
475	}
476
477	pRelativeVar->offset=-LocalVar[i].offset;
478	pRelativeVar->bOffsetOffset=0;
479	if(LocalVar[i].fRef){
480	// 参照型
481	pRelativeVar->dwKind = VAR_REFLOCAL;
482	}
483	else pRelativeVar->dwKind=VAR_LOCAL;
484	*pType=LocalVar[i].type;
485	lpIndex=LocalVar[i].u.index;
486	if(plpIndex) *plpIndex=lpIndex;
487	pSubScripts=LocalVar[i].SubScripts;
488	bConst = LocalVar[i].bConst;
489
490	goto ok;
491	}
492	}
493
494
495	if(pobj_CompilingClass){
496	//////////////////////
497	// クラスメンバの参照
498	//////////////////////
499
500	if(lstrcmpi(variable,"This")==0){
501	//自身のオブジェクトのThisポインタをr11にコピー
502	SetThisPtrToReg(REG_R11);
503
504	*pType=DEF_OBJECT;
505	pRelativeVar->dwKind=VAR_DIRECTMEM;
506
507	if(plpIndex) *plpIndex=(LONG_PTR)pobj_CompilingClass;
508	return 1;
509	}
510
511	if(memicmp(variable,"This.",5)==0){
512	//Thisオブジェクトのメンバを参照するとき
513	SlideString(variable+5,-5);
514	lstrcpy(VarName,variable);
515	}
516	else{
517	//クラス内メンバを参照するとき（通常）
518
519	for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
520	if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
521	}
522	if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
523	}
524
525	//Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
526	//（コンストラクタ、デストラクタ内を除く）
527	CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
528	if( isWriteAccess &&
529	pMethod->isConst &&
530	pobj_CompilingClass->IsCompilingConstructor() == false &&
531	pobj_CompilingClass->IsCompilingDestructor() == false
532	){
533	SetError(131, NULL, cp );
534	}
535
536	//自身のオブジェクトのThisポインタをr11にコピー
537	SetThisPtrToReg(REG_R11);
538
539	pRelativeVar->dwKind=VAR_DIRECTMEM;
540	if(!GetMemberOffset(
541	isErrorEnabled,
542	isWriteAccess,
543	pobj_CompilingClass,
544	variable,
545	pType,
546	pRelativeVar,
547	&lpIndex,1)) return 0;
548	if(plpIndex) *plpIndex=lpIndex;
549	return 1;
550	}
551
552	NonClassMember:
553
554	//////////////////////////
555	// 静的ローカル変数
556	// ※"Static.Object.Method.Variable"
557	//////////////////////////
558
559	char temporary[VN_SIZE];
560	extern SUBINFO *pCompilingSubInfo;
561	if(pCompilingSubInfo){
562	GetNowStaticVarFullName(VarName,temporary);
563
564	for(i=0;i<MaxGlobalVarNum;i++){
565	if(lstrcmp(temporary,GlobalVar[i].name)==0) break;
566	}
567	if(i!=MaxGlobalVarNum){
568	goto GlobalOk;
569	}
570	}
571
572
573	//////////////////////////
574	// クラスの静的メンバ
575	//////////////////////////
576
577	if(member[0]){
578	lstrcpy(temporary,member);
579
580	char tempMember[VN_SIZE];
581	char tempArray[VN_SIZE];
582	GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);
583
584	char temp2[VN_SIZE];
585	sprintf(temp2,"%s.%s",VarName,temporary);
586	for(i=0;i<MaxGlobalVarNum;i++){
587	if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
588	}
589
590	if(i!=MaxGlobalVarNum){
591	lstrcpy(member,tempMember);
592	lstrcpy(array,tempArray);
593	goto GlobalOk;
594	}
595	}
596
597	if(pobj_CompilingClass){
598	//自身のクラスから静的メンバを参照する場合
599	char temp2[VN_SIZE];
600	sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
601	for(i=0;i<MaxGlobalVarNum;i++){
602	if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
603	}
604
605	if(i!=MaxGlobalVarNum){
606	goto GlobalOk;
607	}
608	}
609
610	/////////////////////
611	// グローバル変数
612	/////////////////////
613
614	for(i=MaxGlobalVarNum-1;i>=0;i--){ //レキシカルスコープを考慮してバックサーチ
615	if( GlobalVar[i].bLiving //現在のスコープで有効なもの
616	&& GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel() //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
617	){
618	if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
619	}
620	}
621	if(i>=0){
622	goto GlobalOk;
623	}
624
625	if(isErrorEnabled) SetError(3,variable,cp);
626	pRelativeVar->dwKind=NON_VAR;
627	return 0;
628
629
630
631	GlobalOk:
632	//ポインタ変数の場合
633	if(IsPtrType(GlobalVar[i].type)){
634	if(GlobalVar[i].SubScripts[0]==-1){
635	lstrcpy(lpPtrOffset,array);
636	array[0]=0;
637	}
638	}
639	else{
640	if(lpPtrOffset[0]){
641	SetError(16,variable,cp);
642	pRelativeVar->dwKind=NON_VAR;
643	return 0;
644	}
645	}
646
647	pRelativeVar->offset=GlobalVar[i].offset;
648	pRelativeVar->bOffsetOffset=0;
649	if(GlobalVar[i].fRef){
650	// 参照型
651	pRelativeVar->dwKind = VAR_REFGLOBAL;
652	}
653	else pRelativeVar->dwKind=VAR_GLOBAL;
654	*pType=GlobalVar[i].type;
655	lpIndex=GlobalVar[i].u.index;
656	if(plpIndex) *plpIndex=lpIndex;
657	pSubScripts=GlobalVar[i].SubScripts;
658	bConst = GlobalVar[i].bConst;
659
660
661
662	ok:
663
664	if( bConst && isWriteAccess ){
665	//Const定義の変数に書き込みアクセスをしようとした場合
666	if( *pType == DEF_OBJECT ){
667	//オブジェクト定数
668	SetError(130, VarName, cp );
669	}
670	else{
671	//一般のConst変数
672	SetError(61,VarName,cp);
673	}
674	}
675
676	if(array[0]==0&&pSubScripts[0]!=-1){
677	//配列の先頭ポインタを示す場合
678	*pType\|=FLAG_PTR;
679	if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
680	return 1;
681	}
682
683	if( array[0] \|\| member[0] ){
684	//xor r11,r11（r11を0に初期化する）
685	//※r11は変数ベースアドレスからの相対オフセットを示す
686	op_zero_reg(REG_R11);
687
688	pRelativeVar->bOffsetOffset=1;
689	}
690	if(array[0]){
691	if(!GetArrayOffset(pSubScripts,array,*pType,lpIndex)){
692	SetError(14,variable,cp);
693	pRelativeVar->dwKind=NON_VAR;
694	return 0;
695	}
696	}
697	if(member[0]){
698	if(*pType==DEF_OBJECT){
699	//実態オブジェクトのメンバを参照（obj.member）
700	if(RefType!=DEF_OBJECT){
701	SetError(104,VarName,cp);
702	pRelativeVar->dwKind=NON_VAR;
703	return 0;
704	}
705	}
706	else if(*pType==DEF_PTR_OBJECT){
707	//ポインタオブジェクトが示すメンバを参照
708	if(lpPtrOffset[0]){
709	//pObj[n].member
710	if(RefType!=DEF_OBJECT){
711	SetError(104,VarName,cp);
712	pRelativeVar->dwKind=NON_VAR;
713	return 0;
714	}
715	SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
716	pRelativeVar->dwKind=VAR_DIRECTMEM;
717	}
718	else{
719	//pObj->member
720	if(RefType!=DEF_PTR_OBJECT){
721	SetError(104,VarName,cp);
722	pRelativeVar->dwKind=NON_VAR;
723	return 0;
724	}
725
726	SetVarPtrToReg(REG_R12,pRelativeVar);
727	pRelativeVar->dwKind=VAR_DIRECTMEM;
728
729	//mov r11,qword ptr[r12]
730	op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
731	}
732	}
733	else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
734	//ポインタオブジェクトが示すメンバを参照
735	if(lpPtrOffset[0]){
736	//ppObj[n]->member
737	if(RefType!=DEF_PTR_OBJECT){
738	SetError(104,VarName,cp);
739	pRelativeVar->dwKind=NON_VAR;
740	return 0;
741	}
742
743	SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
744	pRelativeVar->dwKind=VAR_DIRECTMEM;
745
746
747	SetVarPtrToReg(REG_R12,pRelativeVar);
748
749	//mov r11,qword ptr[r12]
750	op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
751	}
752	else{
753	SetError(104,VarName,cp);
754	pRelativeVar->dwKind=NON_VAR;
755	return 0;
756	}
757	}
758	else{
759	SetError(102,VarName,cp);
760	pRelativeVar->dwKind=NON_VAR;
761	return 0;
762	}
763
764	LONG_PTR lp2;
765	if(!GetMemberOffset(
766	isErrorEnabled,
767	isWriteAccess,
768	(CClass *)lpIndex,
769	member,pType,pRelativeVar,&lp2,0)) return 0;
770	if(plpIndex) *plpIndex=lp2;
771
772	return 1;
773	}
774
775	if(lpPtrOffset[0]){
776	SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
777	pRelativeVar->dwKind=VAR_DIRECTMEM;
778	}
779
780	return 1;
781	}
782
783	BOOL SetInitGlobalData(int offset,int type,LONG_PTR lpIndex,int SubScripts,char InitBuf){
784	extern BYTE *initGlobalBuf;
785	int i,i2,i3,TypeSize;
786	char temporary[VN_SIZE];
787
788	if(InitBuf[0]=='['){
789	SlideString(InitBuf+1,-1);
790	InitBuf[lstrlen(InitBuf)-1]=0;
791
792	TypeSize=GetTypeSize(type,lpIndex);
793
794	if(SubScripts[0]!=-1){
795	TypeSize*=JumpSubScripts(SubScripts+1);
796	i=0;
797	i2=0;
798	while(1){
799	if(SubScripts[0]<i2){
800	SetError(41,0,cp);
801	return 0;
802	}
803	i=GetOneParameter(InitBuf,i,temporary);
804	if(!SetInitGlobalData(
805	offset+i2*TypeSize,
806	type,
807	lpIndex,
808	SubScripts+1,
809	temporary)) return 0;
810	i2++;
811	if(InitBuf[i]=='\0') break;
812	}
813	return -1;
814	}
815
816	if(type==DEF_OBJECT){
817	CClass *pobj_c;
818	pobj_c=(CClass *)lpIndex;
819
820	for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
821	i=GetOneParameter(InitBuf,i,temporary);
822
823	i3=GetSizeOfClassMember(pobj_c,pobj_c->ppobj_Member[i2]->name,NULL);
824
825	if(!SetInitGlobalData(offset+i3,
826	pobj_c->ppobj_Member[i2]->TypeInfo.type,
827	pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
828	pobj_c->ppobj_Member[i2]->SubScripts,
829	temporary)) return 0;
830
831	if(InitBuf[i]=='\0') break;
832	}
833	if(i2+1!=pobj_c->iMemberNum){
834	SetError(41,0,cp);
835	return 0;
836	}
837	return 1;
838	}
839
840	SetError(41,0,cp);
841	return 0;
842	}
843
844
845	///////////////////////////////////////
846	// 単発式（[]で囲まれていない）
847	///////////////////////////////////////
848
849	if( type == DEF_OBJECT){
850	//オブジェクトの場合はありえない
851	SetError(300,NULL,cp);
852	return 0;
853	}
854
855	if(SubScripts[0]!=-1){
856	SetError(41,0,cp);
857	return 0;
858	}
859
860	double dbl;
861	_int64 i64data;
862	int CalcType;
863	LONG_PTR lpCalcIndex;
864
865	CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
866	if(!CalcType){
867	//動的データだった場合
868	return 0;
869	}
870	if(IsRealNumberType(CalcType)){
871	memcpy(&dbl,&i64data,sizeof(double));
872	i64data=(_int64)dbl;
873	}
874	else dbl=(double)i64data;
875
876	//型チェック
877	CheckDifferentType(
878	type,
879	lpIndex,
880	CalcType,
881	lpCalcIndex,
882	0,0);
883
884	if(type==DEF_DOUBLE)
885	(double )(initGlobalBuf+offset)=(double)dbl;
886	else if(type==DEF_SINGLE)
887	(float )(initGlobalBuf+offset)=(float)dbl;
888	else if(type==DEF_INT64\|\|type==DEF_QWORD\|\|IsPtrType(type)){
889	if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
890	//文字列定数のとき
891
892	char *temp;
893	temp=(char *)i64data;
894	i2=dataTable.AddString( temp );
895	HeapDefaultFree(temp);
896
897	//mov rax,DataPos
898	op_mov_RV(sizeof(_int64),REG_RAX,i2);
899	obp-=sizeof(long);
900	pobj_DataTableSchedule->add();
901	obp+=sizeof(long);
902
903	//mov qword ptr[offset],rax
904	op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32);
905	obp-=sizeof(long);
906	pobj_GlobalVarSchedule->add();
907	obp+=sizeof(long);
908	}
909	else{
910	(_int64 )(initGlobalBuf+offset)=i64data;
911	}
912	}
913	else if(type==DEF_LONG\|\|type==DEF_DWORD)
914	(DWORD )(initGlobalBuf+offset)=(DWORD)i64data;
915	else if(type==DEF_INTEGER\|\|type==DEF_WORD \|\| (isUnicode&&type==DEF_CHAR))
916	(WORD )(initGlobalBuf+offset)=(WORD)i64data;
917	else if(type==DEF_SBYTE\|\|type==DEF_BYTE\|\|type==DEF_BOOLEAN \|\| (isUnicode==false&&type==DEF_CHAR))
918	(BYTE )(initGlobalBuf+offset)=(BYTE)i64data;
919
920	return 1;
921	}
922	BOOL InitLocalVar(int offset,int type,LONG_PTR lpIndex,int SubScripts,char InitBuf){
923	int i,i2,i3,TypeSize;
924	char temporary[VN_SIZE];
925
926	if(InitBuf[0]=='['){
927	SlideString(InitBuf+1,-1);
928	InitBuf[lstrlen(InitBuf)-1]=0;
929
930	TypeSize=GetTypeSize(type,lpIndex);
931
932	if(SubScripts[0]!=-1){
933	TypeSize*=JumpSubScripts(SubScripts+1);
934	i=0;
935	i2=0;
936	while(1){
937	if(SubScripts[0]<i2){
938	SetError(41,0,cp);
939	return 0;
940	}
941	i=GetOneParameter(InitBuf,i,temporary);
942	if(!InitLocalVar(
943	offset+i2*TypeSize,
944	type,
945	lpIndex,
946	SubScripts+1,
947	temporary)) return 0;
948	i2++;
949	if(InitBuf[i]=='\0') break;
950	}
951	return -1;
952	}
953
954	if(type==DEF_OBJECT){
955	CClass *pobj_c;
956	pobj_c=(CClass *)lpIndex;
957
958	for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
959	i=GetOneParameter(InitBuf,i,temporary);
960
961	i3=GetSizeOfClassMember(pobj_c,pobj_c->ppobj_Member[i2]->name,NULL);
962
963	if(!InitLocalVar(offset+i3,
964	pobj_c->ppobj_Member[i2]->TypeInfo.type,
965	pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
966	pobj_c->ppobj_Member[i2]->SubScripts,
967	temporary)) return 0;
968
969	if(InitBuf[i]=='\0') break;
970	}
971	if(i2+1!=pobj_c->iMemberNum){
972	SetError(41,0,cp);
973	return 0;
974	}
975	return 1;
976	}
977
978	SetError(41,0,cp);
979	return 0;
980	}
981
982
983	///////////////////////////////////////
984	// 単発式（[]で囲まれていない）
985	///////////////////////////////////////
986
987	if(SubScripts[0]!=-1){
988	SetError(41,0,cp);
989	return 0;
990	}
991
992	double dbl;
993	_int64 i64data;
994	int CalcType;
995	LONG_PTR lpCalcIndex;
996	CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
997	if(!CalcType){
998	//動的データだった場合
999	return 0;
1000	}
1001	if(IsRealNumberType(CalcType)){
1002	memcpy(&dbl,&i64data,sizeof(double));
1003	i64data=(_int64)dbl;
1004	}
1005	else dbl=(double)i64data;
1006
1007	//型チェック
1008	CheckDifferentType(
1009	type,
1010	lpIndex,
1011	CalcType,
1012	lpCalcIndex,
1013	0,0);
1014
1015	if(type==DEF_DOUBLE){
1016	memcpy(&i64data,&dbl,sizeof(double));
1017
1018	//mov rax,i64data
1019	op_mov64_ToReg(REG_RAX,i64data);
1020
1021	//mov qword ptr[rsp+offset],rax
1022	op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
1023	obp-=sizeof(long);
1024	AddLocalVarAddrSchedule();
1025	obp+=sizeof(long);
1026	}
1027	else if(type==DEF_SINGLE){
1028	float flt;
1029	flt=(float)dbl;
1030
1031	//mov dword ptr[rsp+offset],value
1032	op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int )&flt);
1033	obp-=sizeof(long)+sizeof(long);
1034	AddLocalVarAddrSchedule();
1035	obp+=sizeof(long)+sizeof(long);
1036	}
1037	else if(type==DEF_INT64\|\|type==DEF_QWORD\|\|IsPtrType(type)){
1038	if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
1039	//文字列定数のとき
1040
1041	char *temp;
1042	temp=(char *)i64data;
1043	i2=dataTable.AddString( temp );
1044	HeapDefaultFree(temp);
1045
1046	//mov rax,i2
1047	op_mov_RV(sizeof(_int64),REG_RAX,i2);
1048	obp-=sizeof(long);
1049	pobj_DataTableSchedule->add();
1050	obp+=sizeof(long);
1051
1052	//mov qword ptr[rsp+offset],rax
1053	op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
1054	obp-=sizeof(long);
1055	AddLocalVarAddrSchedule();
1056	obp+=sizeof(long);
1057	}
1058	else{
1059	if(i64data&0xFFFFFFFF00000000){
1060	//mov rax,i64data
1061	op_mov64_ToReg(REG_RAX,i64data);
1062
1063	//mov qword ptr[rsp+offset],rax
1064	op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
1065	obp-=sizeof(long);
1066	AddLocalVarAddrSchedule();
1067	obp+=sizeof(long);
1068	}
1069	else{
1070	//mov qword ptr[rsp+offset],value
1071	op_mov_MV(sizeof(_int64),REG_RSP,offset,USE_OFFSET,(int)i64data);
1072	obp-=sizeof(long)+sizeof(long);
1073	AddLocalVarAddrSchedule();
1074	obp+=sizeof(long)+sizeof(long);
1075	}
1076	}
1077	}
1078	else if(type==DEF_LONG\|\|type==DEF_DWORD){
1079	//mov dword ptr[rsp+offset],value
1080	op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int)i64data);
1081	obp-=sizeof(long)+sizeof(long);
1082	AddLocalVarAddrSchedule();
1083	obp+=sizeof(long)+sizeof(long);
1084	}
1085	else if(type==DEF_INTEGER\|\|type==DEF_WORD \|\| (isUnicode&&type==DEF_CHAR)){
1086	//mov word ptr[rsp+offset],value
1087	op_mov_MV(sizeof(short),REG_RSP,offset,USE_OFFSET,(int)i64data);
1088	obp-=sizeof(long)+sizeof(short);
1089	AddLocalVarAddrSchedule();
1090	obp+=sizeof(long)+sizeof(short);
1091	}
1092	else if(type==DEF_SBYTE\|\|type==DEF_BYTE\|\|type==DEF_BOOLEAN \|\| (isUnicode==false&&type==DEF_CHAR)){
1093	//mov byte ptr[rsp+offset],value
1094	op_mov_MV(sizeof(char),REG_RSP,offset,USE_OFFSET,(int)i64data);
1095	obp-=sizeof(long)+sizeof(char);
1096	AddLocalVarAddrSchedule();
1097	obp+=sizeof(long)+sizeof(char);
1098	}
1099	return 1;
1100	}
1101
1102
1103	void dim(char *Parameter,DWORD dwFlags){
1104	extern BOOL bCompilingGlobal;
1105	extern HANDLE hHeap;
1106	int i2,i3,VarSize;
1107	char VarName[VN_SIZE];
1108
1109	//参照型かどうか
1110	bool isRef = false;
1111
1112	i2 = 0;
1113
1114	if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
1115	//参照型
1116	isRef = true;
1117	Parameter += 2;
1118	}
1119
1120	if(dwFlags & DIMFLAG_CONST){
1121
1122	//////////////////////////////////
1123	// 定数変数の場合を考慮
1124	//////////////////////////////////
1125	for(;;i2++){
1126	if(Parameter[i2] == '=' \|\|
1127	Parameter[i2] == 1 && Parameter[i2] == ESC_AS \|\|
1128	Parameter[i2] =='('){
1129	VarName[i2] = 0;
1130	break;
1131	}
1132	VarName[i2] = Parameter[i2];
1133	}
1134
1135	//定数と２重定義されていないる場合は抜け出す
1136	if(CDBConst::obj.GetType(VarName)){
1137	return;
1138	}
1139
1140	//定数マクロとして定義されている場合は抜け出す
1141	if(GetConstHash(VarName)){
1142	return;
1143	}
1144	}
1145
1146
1147	//構文を解析
1148	int SubScripts[MAX_ARRAYDIM];
1149	TYPEINFO TypeInfo;
1150	char InitBuf[8192];
1151	char ConstractParameter[VN_SIZE];
1152	if(!GetDimentionFormat(Parameter, isRef , VarName,SubScripts,&TypeInfo,InitBuf,ConstractParameter))
1153	return;
1154
1155
1156	//定数と２重定義されていないかを調べる
1157	if(CDBConst::obj.GetType(VarName)){
1158	SetError(15,VarName,cp);
1159	return;
1160	}
1161
1162	//定数マクロとして定義されている場合
1163	if(GetConstHash(VarName)){
1164	SetError(15,VarName,cp);
1165	return;
1166	}
1167
1168
1169	//タイプサイズを取得
1170	int TypeSize;
1171	TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
1172
1173	if(dwFlags&DIMFLAG_STATIC){
1174	if(bCompilingGlobal){
1175	SetError(60,NULL,cp);
1176	return;
1177	}
1178
1179	/////////////////////
1180	// Static変数
1181	// ※"Static.Object.Method.Variable"
1182	/////////////////////
1183
1184	char temporary[VN_SIZE];
1185	GetNowStaticVarFullName(VarName,temporary);
1186
1187	AddGlobalVariable(isRef,temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
1188
1189	/*
1190	Note: 静的変数のコンストラクタ呼び出しは
1191	_System_InitStaticLocalVariables関数内で一括して行う
1192	*/
1193	}
1194	else{
1195	if(bCompilingGlobal){
1196	/////////////////////////
1197	// グローバル変数
1198	/////////////////////////
1199
1200	AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
1201	}
1202	else{
1203	/////////////////
1204	// ローカル変数
1205	/////////////////
1206
1207	for(i2=0;i2<MaxLocalVarNum;i2++){
1208	if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
1209	if(lstrcmp(LocalVar[i2].name,VarName)==0){
1210	//２重定義のエラー
1211	SetError(15,VarName,cp);
1212	return;
1213	}
1214	}
1215	}
1216
1217	LocalVar=(VARIABLE )HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)sizeof(VARIABLE));
1218	VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
1219	MaxLocalVarNum++;
1220
1221	if( isRef ){
1222	//参照型
1223	pVar->fRef = REF_VARIABLE;
1224	TypeSize = PTR_SIZE;
1225	}
1226	else pVar->fRef=0;
1227
1228	for(i2=1,i3=0;i3<255;i3++){
1229	//配列要素数
1230	pVar->SubScripts[i3]=SubScripts[i3];
1231
1232	if(SubScripts[i3]==-1) break;
1233	i2*=SubScripts[i3]+1;
1234	}
1235	VarSize=TypeSize*i2;
1236	if(VarSize%8) VarSize+=8-(VarSize%8);
1237
1238	//変数データを追加
1239	lstrcpy(pVar->name,VarName);
1240	if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
1241	else pVar->bConst = false;
1242	if(SubScripts[0]==-1) pVar->bArray=0;
1243	else pVar->bArray=1;
1244	pVar->type=TypeInfo.type;
1245	pVar->u.index=TypeInfo.u.lpIndex;
1246	AllLocalVarSize+=VarSize;
1247	pVar->offset=AllLocalVarSize;
1248
1249	//レキシカルスコープ
1250	pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
1251	pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
1252	pVar->bLiving=TRUE;
1253
1254	if(InitBuf[0]){
1255	//初期代入時のみ、書き込みアクセスを許可する
1256	bool bConstBack = pVar->bConst;
1257	pVar->bConst = false;
1258
1259	int result = InitLocalVar(-pVar->offset,
1260	pVar->type,
1261	pVar->u.index,
1262	pVar->SubScripts,
1263	InitBuf);
1264
1265	if(!result){
1266	//動的な式だった場合は代入演算を行う
1267	if( isRef ){
1268	SetRefVariable( VarName, InitBuf );
1269	}
1270	else{
1271	char temporary[8192];
1272	sprintf(temporary,"%s=%s",VarName,InitBuf);
1273	OpcodeCalc(temporary);
1274	}
1275	}
1276
1277	pVar->bConst = bConstBack;
1278	}
1279	else{
1280	//0初期化
1281
1282	//mov r8, 0
1283	op_zero_reg( REG_R8 );
1284
1285	//mov rdx, VarSize
1286	op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
1287
1288	//mov rcx, rsp
1289	op_mov_RR( REG_RCX, REG_RSP );
1290
1291	//add rcx, offset
1292	op_add64_value( REG_RCX, -pVar->offset );
1293	obp-=sizeof(long);
1294	AddLocalVarAddrSchedule();
1295	obp+=sizeof(long);
1296
1297	//call FillMemory
1298	DECLAREINFO *pdi;
1299	pdi=GetDeclareHash("FillMemory");
1300	op_call( pdi );
1301	}
1302	}
1303
1304	//コンストラクタ呼び出し
1305	if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
1306	CallConstructor(VarName,SubScripts,TypeInfo,ConstractParameter);
1307	}
1308	}
1309
1310	if(TypeInfo.type==DEF_OBJECT){
1311	if(TypeInfo.u.pobj_Class->IsAbstract()){
1312	//抽象クラスだったとき
1313	SetError(125,TypeInfo.u.pobj_Class->name,cp);
1314	}
1315	}
1316	}
1317	void OpcodeDim(char *Parameter,DWORD dwFlags){
1318	int i,i2,i3,IsStr=0;
1319	char temporary[8192];
1320
1321	for(i=0,i2=0;;i++,i2++){
1322	if(Parameter[i]=='\"') IsStr^=1;
1323	if(Parameter[i]=='('&&IsStr==0){
1324	i3=GetStringInPare(temporary+i2,Parameter+i);
1325	i+=i3-1;
1326	i2+=i3-1;
1327	continue;
1328	}
1329	if(Parameter[i]=='['&&IsStr==0){
1330	i3=GetStringInBracket(temporary+i2,Parameter+i);
1331	i+=i3-1;
1332	i2+=i3-1;
1333	continue;
1334	}
1335	if((Parameter[i]==','&&IsStr==0)\|\|
1336	Parameter[i]=='\0'){
1337	temporary[i2]=0;
1338
1339	dim(temporary,dwFlags);
1340
1341	if(Parameter[i]=='\0') break;
1342	i2=-1;
1343	continue;
1344	}
1345	temporary[i2]=Parameter[i];
1346	}
1347	}
1348
1349	void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
1350	if(!IsGeneralReg(reg)) SetError(300,NULL,cp);
1351
1352	if(pRelativeVar->dwKind==VAR_GLOBAL){
1353	if(pRelativeVar->bOffsetOffset){
1354	//add r11,offset
1355	OpBuffer[obp++]=(char)0x49;
1356	OpBuffer[obp++]=(char)0x81;
1357	OpBuffer[obp++]=(char)0xC3;
1358	((long )(OpBuffer+obp))=(int)pRelativeVar->offset;
1359	pobj_GlobalVarSchedule->add();
1360	obp+=sizeof(long);
1361
1362	//mov reg,r11
1363	op_mov64_ToReg_FromReg(reg,REG_R11);
1364	}
1365	else{
1366	//mov reg,offset
1367	op_mov64_ToReg(reg,(int)pRelativeVar->offset);
1368	obp-=sizeof(long);
1369	pobj_GlobalVarSchedule->add();
1370	obp+=sizeof(long);
1371	}
1372	}
1373	else if( pRelativeVar->dwKind == VAR_REFGLOBAL ){
1374	if(pRelativeVar->bOffsetOffset){
1375	//add r11,qword ptr[offset]
1376	op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
1377	obp-=sizeof(long);
1378	pobj_GlobalVarSchedule->add();
1379	obp+=sizeof(long);
1380	}
1381	else{
1382	//mov r11,qword ptr[offset]
1383	op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
1384	obp-=sizeof(long);
1385	pobj_GlobalVarSchedule->add();
1386	obp+=sizeof(long);
1387	}
1388
1389	goto directmem;
1390	}
1391	else if(pRelativeVar->dwKind==VAR_LOCAL){
1392	if(pRelativeVar->bOffsetOffset){
1393	//add r11,offset
1394	OpBuffer[obp++]=(char)0x49;
1395	OpBuffer[obp++]=(char)0x81;
1396	OpBuffer[obp++]=(char)0xC3;
1397	((long )(OpBuffer+obp))=(int)pRelativeVar->offset;
1398	AddLocalVarAddrSchedule();
1399	obp+=sizeof(long);
1400
1401	//add r11,rsp
1402	op_add64_reg(REG_R11,REG_RSP);
1403
1404	//mov reg,r11
1405	op_mov64_ToReg_FromReg(reg,REG_R11);
1406	}
1407	else{
1408	//mov reg,rsp
1409	op_mov64_ToReg_FromReg(reg,REG_RSP);
1410
1411	//add reg,offset
1412	op_add64_value(reg,(int)pRelativeVar->offset);
1413	obp-=sizeof(long);
1414	AddLocalVarAddrSchedule();
1415	obp+=sizeof(long);
1416	}
1417	}
1418	else if( pRelativeVar->dwKind == VAR_REFLOCAL ){
1419	if(pRelativeVar->bOffsetOffset){
1420	//add r11,qword ptr[rsp+offset]
1421	OpBuffer[obp++]=(char)0x4C;
1422	OpBuffer[obp++]=(char)0x03;
1423	OpBuffer[obp++]=(char)0x9C;
1424	OpBuffer[obp++]=(char)0x24;
1425	((long )(OpBuffer+obp))=(int)pRelativeVar->offset;
1426	AddLocalVarAddrSchedule();
1427	obp+=sizeof(long);
1428	}
1429	else{
1430	//mov r11,qword ptr[rsp+offset]
1431	op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
1432	obp-=sizeof(long);
1433	AddLocalVarAddrSchedule();
1434	obp+=sizeof(long);
1435	}
1436
1437	goto directmem;
1438	}
1439	else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
1440	directmem:
1441	//mov reg,r11
1442	op_mov64_ToReg_FromReg(reg,REG_R11);
1443	}
1444	}

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

Download in other formats: