Context Navigation

source: dev/BasicCompiler64/Compile_Var.cpp@ 55

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

・コマンドラインオプション "/unicode" に対応。
・Unicode文字セットを使用する場合に "UNICODE" が自動的に#defineされるようにしました。
・SByte型（8ビット符号付き整数型）を追加。
・Char型を文字型に変更。
・プロジェクトオプションから「Unicode文字セットを使用する」チェックを選択できるようにしました。

File size: 33.5 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	pRelativeVar->dwKind=VAR_GLOBAL;
650	*pType=GlobalVar[i].type;
651	lpIndex=GlobalVar[i].u.index;
652	if(plpIndex) *plpIndex=lpIndex;
653	pSubScripts=GlobalVar[i].SubScripts;
654	bConst = GlobalVar[i].bConst;
655
656
657
658	ok:
659
660	if( bConst && isWriteAccess ){
661	//Const定義の変数に書き込みアクセスをしようとした場合
662	if( *pType == DEF_OBJECT ){
663	//オブジェクト定数
664	SetError(130, VarName, cp );
665	}
666	else{
667	//一般のConst変数
668	SetError(61,VarName,cp);
669	}
670	}
671
672	if(array[0]==0&&pSubScripts[0]!=-1){
673	//配列の先頭ポインタを示す場合
674	*pType\|=FLAG_PTR;
675	if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
676	return 1;
677	}
678
679	if( array[0] \|\| member[0] ){
680	//xor r11,r11（r11を0に初期化する）
681	//※r11は変数ベースアドレスからの相対オフセットを示す
682	op_zero_reg(REG_R11);
683
684	pRelativeVar->bOffsetOffset=1;
685	}
686	if(array[0]){
687	if(!GetArrayOffset(pSubScripts,array,*pType,lpIndex)){
688	SetError(14,variable,cp);
689	pRelativeVar->dwKind=NON_VAR;
690	return 0;
691	}
692	}
693	if(member[0]){
694	if(*pType==DEF_OBJECT){
695	//実態オブジェクトのメンバを参照（obj.member）
696	if(RefType!=DEF_OBJECT){
697	SetError(104,VarName,cp);
698	pRelativeVar->dwKind=NON_VAR;
699	return 0;
700	}
701	}
702	else if(*pType==DEF_PTR_OBJECT){
703	//ポインタオブジェクトが示すメンバを参照
704	if(lpPtrOffset[0]){
705	//pObj[n].member
706	if(RefType!=DEF_OBJECT){
707	SetError(104,VarName,cp);
708	pRelativeVar->dwKind=NON_VAR;
709	return 0;
710	}
711	SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
712	pRelativeVar->dwKind=VAR_DIRECTMEM;
713	}
714	else{
715	//pObj->member
716	if(RefType!=DEF_PTR_OBJECT){
717	SetError(104,VarName,cp);
718	pRelativeVar->dwKind=NON_VAR;
719	return 0;
720	}
721
722	SetVarPtrToReg(REG_R12,pRelativeVar);
723	pRelativeVar->dwKind=VAR_DIRECTMEM;
724
725	//mov r11,qword ptr[r12]
726	op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
727	}
728	}
729	else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
730	//ポインタオブジェクトが示すメンバを参照
731	if(lpPtrOffset[0]){
732	//ppObj[n]->member
733	if(RefType!=DEF_PTR_OBJECT){
734	SetError(104,VarName,cp);
735	pRelativeVar->dwKind=NON_VAR;
736	return 0;
737	}
738
739	SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
740	pRelativeVar->dwKind=VAR_DIRECTMEM;
741
742
743	SetVarPtrToReg(REG_R12,pRelativeVar);
744
745	//mov r11,qword ptr[r12]
746	op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
747	}
748	else{
749	SetError(104,VarName,cp);
750	pRelativeVar->dwKind=NON_VAR;
751	return 0;
752	}
753	}
754	else{
755	SetError(102,VarName,cp);
756	pRelativeVar->dwKind=NON_VAR;
757	return 0;
758	}
759
760	LONG_PTR lp2;
761	if(!GetMemberOffset(
762	isErrorEnabled,
763	isWriteAccess,
764	(CClass *)lpIndex,
765	member,pType,pRelativeVar,&lp2,0)) return 0;
766	if(plpIndex) *plpIndex=lp2;
767
768	return 1;
769	}
770
771	if(lpPtrOffset[0]){
772	SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
773	pRelativeVar->dwKind=VAR_DIRECTMEM;
774	}
775
776	return 1;
777	}
778
779	BOOL SetInitGlobalData(int offset,int type,LONG_PTR lpIndex,int SubScripts,char InitBuf){
780	extern BYTE *initGlobalBuf;
781	int i,i2,i3,TypeSize;
782	char temporary[VN_SIZE];
783
784	if(InitBuf[0]=='['){
785	SlideString(InitBuf+1,-1);
786	InitBuf[lstrlen(InitBuf)-1]=0;
787
788	TypeSize=GetTypeSize(type,lpIndex);
789
790	if(SubScripts[0]!=-1){
791	TypeSize*=JumpSubScripts(SubScripts+1);
792	i=0;
793	i2=0;
794	while(1){
795	if(SubScripts[0]<i2){
796	SetError(41,0,cp);
797	return 0;
798	}
799	i=GetOneParameter(InitBuf,i,temporary);
800	if(!SetInitGlobalData(
801	offset+i2*TypeSize,
802	type,
803	lpIndex,
804	SubScripts+1,
805	temporary)) return 0;
806	i2++;
807	if(InitBuf[i]=='\0') break;
808	}
809	return -1;
810	}
811
812	if(type==DEF_OBJECT){
813	CClass *pobj_c;
814	pobj_c=(CClass *)lpIndex;
815
816	for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
817	i=GetOneParameter(InitBuf,i,temporary);
818
819	i3=GetSizeOfClassMember(pobj_c,pobj_c->ppobj_Member[i2]->name,NULL);
820
821	if(!SetInitGlobalData(offset+i3,
822	pobj_c->ppobj_Member[i2]->TypeInfo.type,
823	pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
824	pobj_c->ppobj_Member[i2]->SubScripts,
825	temporary)) return 0;
826
827	if(InitBuf[i]=='\0') break;
828	}
829	if(i2+1!=pobj_c->iMemberNum){
830	SetError(41,0,cp);
831	return 0;
832	}
833	return 1;
834	}
835
836	SetError(41,0,cp);
837	return 0;
838	}
839
840
841	///////////////////////////////////////
842	// 単発式（[]で囲まれていない）
843	///////////////////////////////////////
844
845	if( type == DEF_OBJECT){
846	//オブジェクトの場合はありえない
847	SetError(300,NULL,cp);
848	return 0;
849	}
850
851	if(SubScripts[0]!=-1){
852	SetError(41,0,cp);
853	return 0;
854	}
855
856	double dbl;
857	_int64 i64data;
858	int CalcType;
859	LONG_PTR lpCalcIndex;
860
861	CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
862	if(!CalcType){
863	//動的データだった場合
864	return 0;
865	}
866	if(IsRealNumberType(CalcType)){
867	memcpy(&dbl,&i64data,sizeof(double));
868	i64data=(_int64)dbl;
869	}
870	else dbl=(double)i64data;
871
872	//型チェック
873	CheckDifferentType(
874	type,
875	lpIndex,
876	CalcType,
877	lpCalcIndex,
878	0,0);
879
880	if(type==DEF_DOUBLE)
881	(double )(initGlobalBuf+offset)=(double)dbl;
882	else if(type==DEF_SINGLE)
883	(float )(initGlobalBuf+offset)=(float)dbl;
884	else if(type==DEF_INT64\|\|type==DEF_QWORD\|\|IsPtrType(type)){
885	if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
886	//文字列定数のとき
887
888	char *temp;
889	temp=(char *)i64data;
890	i2=AddDataTable(temp,lstrlen(temp));
891	HeapDefaultFree(temp);
892
893	//mov rax,DataPos
894	op_mov_RV(sizeof(_int64),REG_RAX,i2);
895	obp-=sizeof(long);
896	pobj_DataTableSchedule->add();
897	obp+=sizeof(long);
898
899	//mov qword ptr[offset],rax
900	op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32);
901	obp-=sizeof(long);
902	pobj_GlobalVarSchedule->add();
903	obp+=sizeof(long);
904	}
905	else{
906	(_int64 )(initGlobalBuf+offset)=i64data;
907	}
908	}
909	else if(type==DEF_LONG\|\|type==DEF_DWORD)
910	(DWORD )(initGlobalBuf+offset)=(DWORD)i64data;
911	else if(type==DEF_INTEGER\|\|type==DEF_WORD \|\| (isUnicode&&type==DEF_CHAR))
912	(WORD )(initGlobalBuf+offset)=(WORD)i64data;
913	else if(type==DEF_SBYTE\|\|type==DEF_BYTE\|\|type==DEF_BOOLEAN \|\| (isUnicode==false&&type==DEF_CHAR))
914	(BYTE )(initGlobalBuf+offset)=(BYTE)i64data;
915
916	return 1;
917	}
918	BOOL InitLocalVar(int offset,int type,LONG_PTR lpIndex,int SubScripts,char InitBuf){
919	int i,i2,i3,TypeSize;
920	char temporary[VN_SIZE];
921
922	if(InitBuf[0]=='['){
923	SlideString(InitBuf+1,-1);
924	InitBuf[lstrlen(InitBuf)-1]=0;
925
926	TypeSize=GetTypeSize(type,lpIndex);
927
928	if(SubScripts[0]!=-1){
929	TypeSize*=JumpSubScripts(SubScripts+1);
930	i=0;
931	i2=0;
932	while(1){
933	if(SubScripts[0]<i2){
934	SetError(41,0,cp);
935	return 0;
936	}
937	i=GetOneParameter(InitBuf,i,temporary);
938	if(!InitLocalVar(
939	offset+i2*TypeSize,
940	type,
941	lpIndex,
942	SubScripts+1,
943	temporary)) return 0;
944	i2++;
945	if(InitBuf[i]=='\0') break;
946	}
947	return -1;
948	}
949
950	if(type==DEF_OBJECT){
951	CClass *pobj_c;
952	pobj_c=(CClass *)lpIndex;
953
954	for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
955	i=GetOneParameter(InitBuf,i,temporary);
956
957	i3=GetSizeOfClassMember(pobj_c,pobj_c->ppobj_Member[i2]->name,NULL);
958
959	if(!InitLocalVar(offset+i3,
960	pobj_c->ppobj_Member[i2]->TypeInfo.type,
961	pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
962	pobj_c->ppobj_Member[i2]->SubScripts,
963	temporary)) return 0;
964
965	if(InitBuf[i]=='\0') break;
966	}
967	if(i2+1!=pobj_c->iMemberNum){
968	SetError(41,0,cp);
969	return 0;
970	}
971	return 1;
972	}
973
974	SetError(41,0,cp);
975	return 0;
976	}
977
978
979	///////////////////////////////////////
980	// 単発式（[]で囲まれていない）
981	///////////////////////////////////////
982
983	if(SubScripts[0]!=-1){
984	SetError(41,0,cp);
985	return 0;
986	}
987
988	double dbl;
989	_int64 i64data;
990	int CalcType;
991	LONG_PTR lpCalcIndex;
992	CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
993	if(!CalcType){
994	//動的データだった場合
995	return 0;
996	}
997	if(IsRealNumberType(CalcType)){
998	memcpy(&dbl,&i64data,sizeof(double));
999	i64data=(_int64)dbl;
1000	}
1001	else dbl=(double)i64data;
1002
1003	//型チェック
1004	CheckDifferentType(
1005	type,
1006	lpIndex,
1007	CalcType,
1008	lpCalcIndex,
1009	0,0);
1010
1011	if(type==DEF_DOUBLE){
1012	memcpy(&i64data,&dbl,sizeof(double));
1013
1014	//mov rax,i64data
1015	op_mov64_ToReg(REG_RAX,i64data);
1016
1017	//mov qword ptr[rsp+offset],rax
1018	op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
1019	obp-=sizeof(long);
1020	AddLocalVarAddrSchedule();
1021	obp+=sizeof(long);
1022	}
1023	else if(type==DEF_SINGLE){
1024	float flt;
1025	flt=(float)dbl;
1026
1027	//mov dword ptr[rsp+offset],value
1028	op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int )&flt);
1029	obp-=sizeof(long)+sizeof(long);
1030	AddLocalVarAddrSchedule();
1031	obp+=sizeof(long)+sizeof(long);
1032	}
1033	else if(type==DEF_INT64\|\|type==DEF_QWORD\|\|IsPtrType(type)){
1034	if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
1035	//文字列定数のとき
1036
1037	char *temp;
1038	temp=(char *)i64data;
1039	i2=AddDataTable(temp,lstrlen(temp));
1040	HeapDefaultFree(temp);
1041
1042	//mov rax,i2
1043	op_mov_RV(sizeof(_int64),REG_RAX,i2);
1044	obp-=sizeof(long);
1045	pobj_DataTableSchedule->add();
1046	obp+=sizeof(long);
1047
1048	//mov qword ptr[rsp+offset],rax
1049	op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
1050	obp-=sizeof(long);
1051	AddLocalVarAddrSchedule();
1052	obp+=sizeof(long);
1053	}
1054	else{
1055	if(i64data&0xFFFFFFFF00000000){
1056	//mov rax,i64data
1057	op_mov64_ToReg(REG_RAX,i64data);
1058
1059	//mov qword ptr[rsp+offset],rax
1060	op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
1061	obp-=sizeof(long);
1062	AddLocalVarAddrSchedule();
1063	obp+=sizeof(long);
1064	}
1065	else{
1066	//mov qword ptr[rsp+offset],value
1067	op_mov_MV(sizeof(_int64),REG_RSP,offset,USE_OFFSET,(int)i64data);
1068	obp-=sizeof(long)+sizeof(long);
1069	AddLocalVarAddrSchedule();
1070	obp+=sizeof(long)+sizeof(long);
1071	}
1072	}
1073	}
1074	else if(type==DEF_LONG\|\|type==DEF_DWORD){
1075	//mov dword ptr[rsp+offset],value
1076	op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int)i64data);
1077	obp-=sizeof(long)+sizeof(long);
1078	AddLocalVarAddrSchedule();
1079	obp+=sizeof(long)+sizeof(long);
1080	}
1081	else if(type==DEF_INTEGER\|\|type==DEF_WORD \|\| (isUnicode&&type==DEF_CHAR)){
1082	//mov word ptr[rsp+offset],value
1083	op_mov_MV(sizeof(short),REG_RSP,offset,USE_OFFSET,(int)i64data);
1084	obp-=sizeof(long)+sizeof(short);
1085	AddLocalVarAddrSchedule();
1086	obp+=sizeof(long)+sizeof(short);
1087	}
1088	else if(type==DEF_SBYTE\|\|type==DEF_BYTE\|\|type==DEF_BOOLEAN \|\| (isUnicode==false&&type==DEF_CHAR)){
1089	//mov byte ptr[rsp+offset],value
1090	op_mov_MV(sizeof(char),REG_RSP,offset,USE_OFFSET,(int)i64data);
1091	obp-=sizeof(long)+sizeof(char);
1092	AddLocalVarAddrSchedule();
1093	obp+=sizeof(long)+sizeof(char);
1094	}
1095	return 1;
1096	}
1097
1098
1099	void dim(char *Parameter,DWORD dwFlags){
1100	extern BOOL bCompilingGlobal;
1101	extern HANDLE hHeap;
1102	int i2,i3,VarSize;
1103	char VarName[VN_SIZE];
1104
1105	//参照型かどうか
1106	bool isRef = false;
1107
1108	i2 = 0;
1109
1110	if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
1111	//参照型
1112	isRef = true;
1113	Parameter += 2;
1114	}
1115
1116	if(dwFlags & DIMFLAG_CONST){
1117
1118	//////////////////////////////////
1119	// 定数変数の場合を考慮
1120	//////////////////////////////////
1121	for(;;i2++){
1122	if(Parameter[i2] == '=' \|\|
1123	Parameter[i2] == 1 && Parameter[i2] == ESC_AS \|\|
1124	Parameter[i2] =='('){
1125	VarName[i2] = 0;
1126	break;
1127	}
1128	VarName[i2] = Parameter[i2];
1129	}
1130
1131	//定数と２重定義されていないる場合は抜け出す
1132	if(CDBConst::obj.GetType(VarName)){
1133	return;
1134	}
1135
1136	//定数マクロとして定義されている場合は抜け出す
1137	if(GetConstHash(VarName)){
1138	return;
1139	}
1140	}
1141
1142
1143	//構文を解析
1144	int SubScripts[MAX_ARRAYDIM];
1145	TYPEINFO TypeInfo;
1146	char InitBuf[8192];
1147	char ConstractParameter[VN_SIZE];
1148	if(!GetDimentionFormat(Parameter, isRef , VarName,SubScripts,&TypeInfo,InitBuf,ConstractParameter))
1149	return;
1150
1151
1152	//定数と２重定義されていないかを調べる
1153	if(CDBConst::obj.GetType(VarName)){
1154	SetError(15,VarName,cp);
1155	return;
1156	}
1157
1158	//定数マクロとして定義されている場合
1159	if(GetConstHash(VarName)){
1160	SetError(15,VarName,cp);
1161	return;
1162	}
1163
1164
1165	//タイプサイズを取得
1166	int TypeSize;
1167	TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
1168
1169	if(dwFlags&DIMFLAG_STATIC){
1170	if(bCompilingGlobal){
1171	SetError(60,NULL,cp);
1172	return;
1173	}
1174
1175	/////////////////////
1176	// Static変数
1177	// ※"Static.Object.Method.Variable"
1178	/////////////////////
1179
1180	char temporary[VN_SIZE];
1181	GetNowStaticVarFullName(VarName,temporary);
1182
1183	AddGlobalVariable(temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
1184
1185	/*
1186	Note: 静的変数のコンストラクタ呼び出しは
1187	_System_InitStaticLocalVariables関数内で一括して行う
1188	*/
1189	}
1190	else{
1191	if(bCompilingGlobal){
1192	/////////////////////////
1193	// グローバル変数
1194	/////////////////////////
1195
1196	AddGlobalVariable(VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
1197	}
1198	else{
1199	/////////////////
1200	// ローカル変数
1201	/////////////////
1202
1203	for(i2=0;i2<MaxLocalVarNum;i2++){
1204	if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
1205	if(lstrcmp(LocalVar[i2].name,VarName)==0){
1206	//２重定義のエラー
1207	SetError(15,VarName,cp);
1208	return;
1209	}
1210	}
1211	}
1212
1213	LocalVar=(VARIABLE )HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)sizeof(VARIABLE));
1214	VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
1215	MaxLocalVarNum++;
1216
1217	if( isRef ){
1218	//参照型
1219	pVar->fRef = REF_VARIABLE;
1220	TypeSize = PTR_SIZE;
1221	}
1222	else pVar->fRef=0;
1223
1224	for(i2=1,i3=0;i3<255;i3++){
1225	//配列要素数
1226	pVar->SubScripts[i3]=SubScripts[i3];
1227
1228	if(SubScripts[i3]==-1) break;
1229	i2*=SubScripts[i3]+1;
1230	}
1231	VarSize=TypeSize*i2;
1232	if(VarSize%8) VarSize+=8-(VarSize%8);
1233
1234	//変数データを追加
1235	lstrcpy(pVar->name,VarName);
1236	if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
1237	else pVar->bConst = false;
1238	if(SubScripts[0]==-1) pVar->bArray=0;
1239	else pVar->bArray=1;
1240	pVar->type=TypeInfo.type;
1241	pVar->u.index=TypeInfo.u.lpIndex;
1242	AllLocalVarSize+=VarSize;
1243	pVar->offset=AllLocalVarSize;
1244
1245	//レキシカルスコープ
1246	pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
1247	pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
1248	pVar->bLiving=TRUE;
1249
1250	if(InitBuf[0]){
1251	//初期代入時のみ、書き込みアクセスを許可する
1252	bool bConstBack = pVar->bConst;
1253	pVar->bConst = false;
1254
1255	int result = InitLocalVar(-pVar->offset,
1256	pVar->type,
1257	pVar->u.index,
1258	pVar->SubScripts,
1259	InitBuf);
1260
1261	if(!result){
1262	//動的な式だった場合は代入演算を行う
1263	if( isRef ){
1264	SetRefVariable( VarName, InitBuf );
1265	}
1266	else{
1267	char temporary[8192];
1268	sprintf(temporary,"%s=%s",VarName,InitBuf);
1269	OpcodeCalc(temporary);
1270	}
1271	}
1272
1273	pVar->bConst = bConstBack;
1274	}
1275	else{
1276	//0初期化
1277
1278	//mov r8, 0
1279	op_zero_reg( REG_R8 );
1280
1281	//mov rdx, VarSize
1282	op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
1283
1284	//mov rcx, rsp
1285	op_mov_RR( REG_RCX, REG_RSP );
1286
1287	//add rcx, offset
1288	op_add64_value( REG_RCX, -pVar->offset );
1289	obp-=sizeof(long);
1290	AddLocalVarAddrSchedule();
1291	obp+=sizeof(long);
1292
1293	//call FillMemory
1294	DECLAREINFO *pdi;
1295	pdi=GetDeclareHash("FillMemory");
1296	op_call( pdi );
1297	}
1298	}
1299
1300	//コンストラクタ呼び出し
1301	if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
1302	CallConstructor(VarName,SubScripts,TypeInfo,ConstractParameter);
1303	}
1304	}
1305
1306	if(TypeInfo.type==DEF_OBJECT){
1307	if(TypeInfo.u.pobj_Class->IsAbstract()){
1308	//抽象クラスだったとき
1309	SetError(125,TypeInfo.u.pobj_Class->name,cp);
1310	}
1311	}
1312	}
1313	void OpcodeDim(char *Parameter,DWORD dwFlags){
1314	int i,i2,i3,IsStr=0;
1315	char temporary[8192];
1316
1317	for(i=0,i2=0;;i++,i2++){
1318	if(Parameter[i]=='\"') IsStr^=1;
1319	if(Parameter[i]=='('&&IsStr==0){
1320	i3=GetStringInPare(temporary+i2,Parameter+i);
1321	i+=i3-1;
1322	i2+=i3-1;
1323	continue;
1324	}
1325	if(Parameter[i]=='['&&IsStr==0){
1326	i3=GetStringInBracket(temporary+i2,Parameter+i);
1327	i+=i3-1;
1328	i2+=i3-1;
1329	continue;
1330	}
1331	if((Parameter[i]==','&&IsStr==0)\|\|
1332	Parameter[i]=='\0'){
1333	temporary[i2]=0;
1334
1335	dim(temporary,dwFlags);
1336
1337	if(Parameter[i]=='\0') break;
1338	i2=-1;
1339	continue;
1340	}
1341	temporary[i2]=Parameter[i];
1342	}
1343	}
1344
1345	void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
1346	if(!IsGeneralReg(reg)) SetError(300,NULL,cp);
1347
1348	if(pRelativeVar->dwKind==VAR_GLOBAL){
1349	if(pRelativeVar->bOffsetOffset){
1350	//add r11,offset
1351	OpBuffer[obp++]=(char)0x49;
1352	OpBuffer[obp++]=(char)0x81;
1353	OpBuffer[obp++]=(char)0xC3;
1354	((long )(OpBuffer+obp))=(int)pRelativeVar->offset;
1355	pobj_GlobalVarSchedule->add();
1356	obp+=sizeof(long);
1357
1358	//mov reg,r11
1359	op_mov64_ToReg_FromReg(reg,REG_R11);
1360	}
1361	else{
1362	//mov reg,offset
1363	op_mov64_ToReg(reg,(int)pRelativeVar->offset);
1364	obp-=sizeof(long);
1365	pobj_GlobalVarSchedule->add();
1366	obp+=sizeof(long);
1367	}
1368	}
1369	else if(pRelativeVar->dwKind==VAR_LOCAL){
1370	if(pRelativeVar->bOffsetOffset){
1371	//add r11,offset
1372	OpBuffer[obp++]=(char)0x49;
1373	OpBuffer[obp++]=(char)0x81;
1374	OpBuffer[obp++]=(char)0xC3;
1375	((long )(OpBuffer+obp))=(int)pRelativeVar->offset;
1376	AddLocalVarAddrSchedule();
1377	obp+=sizeof(long);
1378
1379	//add r11,rsp
1380	op_add64_reg(REG_R11,REG_RSP);
1381
1382	//mov reg,r11
1383	op_mov64_ToReg_FromReg(reg,REG_R11);
1384	}
1385	else{
1386	//mov reg,rsp
1387	op_mov64_ToReg_FromReg(reg,REG_RSP);
1388
1389	//add reg,offset
1390	op_add64_value(reg,(int)pRelativeVar->offset);
1391	obp-=sizeof(long);
1392	AddLocalVarAddrSchedule();
1393	obp+=sizeof(long);
1394	}
1395	}
1396	else if( pRelativeVar->dwKind == VAR_REFLOCAL ){
1397	if(pRelativeVar->bOffsetOffset){
1398	//add r11,qword ptr[rsp+offset]
1399	OpBuffer[obp++]=(char)0x4C;
1400	OpBuffer[obp++]=(char)0x03;
1401	OpBuffer[obp++]=(char)0x9C;
1402	OpBuffer[obp++]=(char)0x24;
1403	((long )(OpBuffer+obp))=(int)pRelativeVar->offset;
1404	AddLocalVarAddrSchedule();
1405	obp+=sizeof(long);
1406	}
1407	else{
1408	//mov r11,qword ptr[rsp+offset]
1409	op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
1410	obp-=sizeof(long);
1411	AddLocalVarAddrSchedule();
1412	obp+=sizeof(long);
1413	}
1414
1415	goto directmem;
1416	}
1417	else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
1418	directmem:
1419	//mov reg,r11
1420	op_mov64_ToReg_FromReg(reg,REG_R11);
1421	}
1422	}

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

Download in other formats: