Context Navigation

source: dev/BasicCompiler64/Compile_Var.cpp@ 40

Last change on this file since 40 was 40, checked in by dai_9181, 17 years ago
ByRef修飾子を関数戻り値とDimステートメントで指定可能にした。
File size: 32.2 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	char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
391
392	if(NameBuffer[0]=='.'){
393	GetWithName(variable);
394	lstrcat(variable,NameBuffer);
395	}
396	else lstrcpy(variable,NameBuffer);
397
398	lstrcpy(VarName,variable);
399	GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
400
401	LONG_PTR lpIndex;
402	int *pSubScripts;
403	bool bConst = false;
404
405
406	if(bCompilingGlobal==0){
407	//////////////////
408	// ローカル変数
409	//////////////////
410
411	for(i=MaxLocalVarNum-1;i>=0;i--){ //レキシカルスコープを考慮してバックサーチ
412	if( LocalVar[i].bLiving //現在のスコープで有効なもの
413	&& LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel() //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
414	){
415	if(lstrcmp(VarName,LocalVar[i].name)==0) break;
416	}
417	}
418	if(i>=0){
419	//ポインタ変数の場合
420	if(IsPtrType(LocalVar[i].type)){
421	if(LocalVar[i].SubScripts[0]==-1){
422	lstrcpy(lpPtrOffset,array);
423	array[0]=0;
424	}
425	}
426	else{
427	if(lpPtrOffset[0]){
428	SetError(16,variable,cp);
429	pRelativeVar->dwKind=NON_VAR;
430	return 0;
431	}
432	}
433
434	pRelativeVar->offset=-LocalVar[i].offset;
435	pRelativeVar->bOffsetOffset=0;
436	if(LocalVar[i].fRef){
437	// 参照型
438	pRelativeVar->dwKind = VAR_REFLOCAL;
439	}
440	else pRelativeVar->dwKind=VAR_LOCAL;
441	*pType=LocalVar[i].type;
442	lpIndex=LocalVar[i].u.index;
443	if(plpIndex) *plpIndex=lpIndex;
444	pSubScripts=LocalVar[i].SubScripts;
445	bConst = LocalVar[i].bConst;
446
447	goto ok;
448	}
449	}
450
451
452	if(pobj_CompilingClass){
453	//////////////////////
454	// クラスメンバの参照
455	//////////////////////
456
457	if(lstrcmpi(variable,"This")==0){
458	//自身のオブジェクトのThisポインタをr11にコピー
459	SetThisPtrToReg(REG_R11);
460
461	*pType=DEF_OBJECT;
462	pRelativeVar->dwKind=VAR_DIRECTMEM;
463
464	if(plpIndex) *plpIndex=(LONG_PTR)pobj_CompilingClass;
465	return 1;
466	}
467
468	if(memicmp(variable,"This.",5)==0){
469	//Thisオブジェクトのメンバを参照するとき
470	SlideString(variable+5,-5);
471	lstrcpy(VarName,variable);
472	}
473	else{
474	//クラス内メンバを参照するとき（通常）
475
476	for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
477	if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
478	}
479	if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
480	}
481
482	//Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
483	//（コンストラクタ、デストラクタ内を除く）
484	CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
485	if( isWriteAccess &&
486	pMethod->isConst &&
487	pobj_CompilingClass->IsCompilingConstructor() == false &&
488	pobj_CompilingClass->IsCompilingDestructor() == false
489	){
490	SetError(131, NULL, cp );
491	}
492
493	//自身のオブジェクトのThisポインタをr11にコピー
494	SetThisPtrToReg(REG_R11);
495
496	pRelativeVar->dwKind=VAR_DIRECTMEM;
497	if(!GetMemberOffset(
498	isErrorEnabled,
499	isWriteAccess,
500	pobj_CompilingClass,
501	variable,
502	pType,
503	pRelativeVar,
504	&lpIndex,1)) return 0;
505	if(plpIndex) *plpIndex=lpIndex;
506	return 1;
507	}
508
509	NonClassMember:
510
511	//////////////////////////
512	// 静的ローカル変数
513	// ※"Static.Object.Method.Variable"
514	//////////////////////////
515
516	char temporary[VN_SIZE];
517	extern SUBINFO *pCompilingSubInfo;
518	if(pCompilingSubInfo){
519	GetNowStaticVarFullName(VarName,temporary);
520
521	for(i=0;i<MaxGlobalVarNum;i++){
522	if(lstrcmp(temporary,GlobalVar[i].name)==0) break;
523	}
524	if(i!=MaxGlobalVarNum){
525	goto GlobalOk;
526	}
527	}
528
529
530	//////////////////////////
531	// クラスの静的メンバ
532	//////////////////////////
533
534	if(member[0]){
535	lstrcpy(temporary,member);
536
537	char tempMember[VN_SIZE];
538	char tempArray[VN_SIZE];
539	GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);
540
541	char temp2[VN_SIZE];
542	sprintf(temp2,"%s.%s",VarName,temporary);
543	for(i=0;i<MaxGlobalVarNum;i++){
544	if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
545	}
546
547	if(i!=MaxGlobalVarNum){
548	lstrcpy(member,tempMember);
549	lstrcpy(array,tempArray);
550	goto GlobalOk;
551	}
552	}
553
554	if(pobj_CompilingClass){
555	//自身のクラスから静的メンバを参照する場合
556	char temp2[VN_SIZE];
557	sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
558	for(i=0;i<MaxGlobalVarNum;i++){
559	if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
560	}
561
562	if(i!=MaxGlobalVarNum){
563	goto GlobalOk;
564	}
565	}
566
567
568	/////////////////////
569	// グローバル変数
570	/////////////////////
571
572	for(i=MaxGlobalVarNum-1;i>=0;i--){ //レキシカルスコープを考慮してバックサーチ
573	if( GlobalVar[i].bLiving //現在のスコープで有効なもの
574	&& GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel() //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
575	){
576	if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
577	}
578	}
579	if(i>=0){
580	goto GlobalOk;
581	}
582
583	if(isErrorEnabled) SetError(3,variable,cp);
584	pRelativeVar->dwKind=NON_VAR;
585	return 0;
586
587
588
589	GlobalOk:
590	//ポインタ変数の場合
591	if(IsPtrType(GlobalVar[i].type)){
592	if(GlobalVar[i].SubScripts[0]==-1){
593	lstrcpy(lpPtrOffset,array);
594	array[0]=0;
595	}
596	}
597	else{
598	if(lpPtrOffset[0]){
599	SetError(16,variable,cp);
600	pRelativeVar->dwKind=NON_VAR;
601	return 0;
602	}
603	}
604
605	pRelativeVar->offset=GlobalVar[i].offset;
606	pRelativeVar->bOffsetOffset=0;
607	pRelativeVar->dwKind=VAR_GLOBAL;
608	*pType=GlobalVar[i].type;
609	lpIndex=GlobalVar[i].u.index;
610	if(plpIndex) *plpIndex=lpIndex;
611	pSubScripts=GlobalVar[i].SubScripts;
612	bConst = GlobalVar[i].bConst;
613
614
615
616	ok:
617
618	if( bConst && isWriteAccess ){
619	//Const定義の変数に書き込みアクセスをしようとした場合
620	if( *pType == DEF_OBJECT ){
621	//オブジェクト定数
622	SetError(130, VarName, cp );
623	}
624	else{
625	//一般のConst変数
626	SetError(61,VarName,cp);
627	}
628	}
629
630	if(array[0]==0&&pSubScripts[0]!=-1){
631	//配列の先頭ポインタを示す場合
632	*pType\|=FLAG_PTR;
633	if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
634	return 1;
635	}
636
637	if(array[0]\|\|member[0]){
638	//xor r11,r11（r11を0に初期化する）
639	//※r11は変数ベースアドレスからの相対オフセットを示す
640	op_zero_reg(REG_R11);
641
642	pRelativeVar->bOffsetOffset=1;
643	}
644	if(array[0]){
645	if(!GetArrayOffset(pSubScripts,array,*pType,lpIndex)){
646	SetError(14,variable,cp);
647	pRelativeVar->dwKind=NON_VAR;
648	return 0;
649	}
650	}
651	if(member[0]){
652	if(*pType==DEF_OBJECT){
653	//実態オブジェクトのメンバを参照（obj.member）
654	if(RefType!=DEF_OBJECT){
655	SetError(104,VarName,cp);
656	pRelativeVar->dwKind=NON_VAR;
657	return 0;
658	}
659	}
660	else if(*pType==DEF_PTR_OBJECT){
661	//ポインタオブジェクトが示すメンバを参照
662	if(lpPtrOffset[0]){
663	//pObj[n].member
664	if(RefType!=DEF_OBJECT){
665	SetError(104,VarName,cp);
666	pRelativeVar->dwKind=NON_VAR;
667	return 0;
668	}
669	SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
670	pRelativeVar->dwKind=VAR_DIRECTMEM;
671	}
672	else{
673	//pObj->member
674	if(RefType!=DEF_PTR_OBJECT){
675	SetError(104,VarName,cp);
676	pRelativeVar->dwKind=NON_VAR;
677	return 0;
678	}
679
680	SetVarPtrToReg(REG_R12,pRelativeVar);
681	pRelativeVar->dwKind=VAR_DIRECTMEM;
682
683	//mov r11,qword ptr[r12]
684	op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
685	}
686	}
687	else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
688	//ポインタオブジェクトが示すメンバを参照
689	if(lpPtrOffset[0]){
690	//ppObj[n]->member
691	if(RefType!=DEF_PTR_OBJECT){
692	SetError(104,VarName,cp);
693	pRelativeVar->dwKind=NON_VAR;
694	return 0;
695	}
696
697	SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
698	pRelativeVar->dwKind=VAR_DIRECTMEM;
699
700
701	SetVarPtrToReg(REG_R12,pRelativeVar);
702
703	//mov r11,qword ptr[r12]
704	op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
705	}
706	else{
707	SetError(104,VarName,cp);
708	pRelativeVar->dwKind=NON_VAR;
709	return 0;
710	}
711	}
712	else{
713	SetError(102,VarName,cp);
714	pRelativeVar->dwKind=NON_VAR;
715	return 0;
716	}
717
718	LONG_PTR lp2;
719	if(!GetMemberOffset(
720	isErrorEnabled,
721	isWriteAccess,
722	(CClass *)lpIndex,
723	member,pType,pRelativeVar,&lp2,0)) return 0;
724	if(plpIndex) *plpIndex=lp2;
725
726	return 1;
727	}
728
729	if(lpPtrOffset[0]){
730	SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
731	pRelativeVar->dwKind=VAR_DIRECTMEM;
732	}
733
734	return 1;
735	}
736
737	BOOL SetInitGlobalData(int offset,int type,LONG_PTR lpIndex,int SubScripts,char InitBuf){
738	extern BYTE *initGlobalBuf;
739	int i,i2,i3,TypeSize;
740	char temporary[VN_SIZE];
741
742	if(InitBuf[0]=='['){
743	SlideString(InitBuf+1,-1);
744	InitBuf[lstrlen(InitBuf)-1]=0;
745
746	TypeSize=GetTypeSize(type,lpIndex);
747
748	if(SubScripts[0]!=-1){
749	TypeSize*=JumpSubScripts(SubScripts+1);
750	i=0;
751	i2=0;
752	while(1){
753	if(SubScripts[0]<i2){
754	SetError(41,0,cp);
755	return 0;
756	}
757	i=GetOneParameter(InitBuf,i,temporary);
758	if(!SetInitGlobalData(
759	offset+i2*TypeSize,
760	type,
761	lpIndex,
762	SubScripts+1,
763	temporary)) return 0;
764	i2++;
765	if(InitBuf[i]=='\0') break;
766	}
767	return -1;
768	}
769
770	if(type==DEF_OBJECT){
771	CClass *pobj_c;
772	pobj_c=(CClass *)lpIndex;
773
774	for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
775	i=GetOneParameter(InitBuf,i,temporary);
776
777	i3=GetSizeOfClassMember(pobj_c,pobj_c->ppobj_Member[i2]->name,NULL);
778
779	if(!SetInitGlobalData(offset+i3,
780	pobj_c->ppobj_Member[i2]->TypeInfo.type,
781	pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
782	pobj_c->ppobj_Member[i2]->SubScripts,
783	temporary)) return 0;
784
785	if(InitBuf[i]=='\0') break;
786	}
787	if(i2+1!=pobj_c->iMemberNum){
788	SetError(41,0,cp);
789	return 0;
790	}
791	return 1;
792	}
793
794	SetError(41,0,cp);
795	return 0;
796	}
797
798
799	///////////////////////////////////////
800	// 単発式（[]で囲まれていない）
801	///////////////////////////////////////
802
803	if( type == DEF_OBJECT){
804	//オブジェクトの場合はありえない
805	SetError(300,NULL,cp);
806	return 0;
807	}
808
809	if(SubScripts[0]!=-1){
810	SetError(41,0,cp);
811	return 0;
812	}
813
814	double dbl;
815	_int64 i64data;
816	int CalcType;
817	LONG_PTR lpCalcIndex;
818
819	CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
820	if(!CalcType){
821	//動的データだった場合
822	return 0;
823	}
824	if(IsRealNumberType(CalcType)){
825	memcpy(&dbl,&i64data,sizeof(double));
826	i64data=(_int64)dbl;
827	}
828	else dbl=(double)i64data;
829
830	//型チェック
831	CheckDifferentType(
832	type,
833	lpIndex,
834	CalcType,
835	lpCalcIndex,
836	0,0);
837
838	if(type==DEF_DOUBLE)
839	(double )(initGlobalBuf+offset)=(double)dbl;
840	else if(type==DEF_SINGLE)
841	(float )(initGlobalBuf+offset)=(float)dbl;
842	else if(type==DEF_INT64\|\|type==DEF_QWORD\|\|IsPtrType(type)){
843	if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
844	//文字列定数のとき
845
846	char *temp;
847	temp=(char *)i64data;
848	i2=AddDataTable(temp,lstrlen(temp));
849	HeapDefaultFree(temp);
850
851	//mov rax,DataPos
852	op_mov_RV(sizeof(_int64),REG_RAX,i2);
853	obp-=sizeof(long);
854	pobj_DataTableSchedule->add();
855	obp+=sizeof(long);
856
857	//mov qword ptr[offset],rax
858	op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32);
859	obp-=sizeof(long);
860	pobj_GlobalVarSchedule->add();
861	obp+=sizeof(long);
862	}
863	else{
864	(_int64 )(initGlobalBuf+offset)=i64data;
865	}
866	}
867	else if(type==DEF_LONG\|\|type==DEF_DWORD)
868	(DWORD )(initGlobalBuf+offset)=(DWORD)i64data;
869	else if(type==DEF_INTEGER\|\|type==DEF_WORD)
870	(WORD )(initGlobalBuf+offset)=(WORD)i64data;
871	else if(type==DEF_CHAR\|\|type==DEF_BYTE\|\|type==DEF_BOOLEAN)
872	(BYTE )(initGlobalBuf+offset)=(BYTE)i64data;
873
874	return 1;
875	}
876	BOOL InitLocalVar(int offset,int type,LONG_PTR lpIndex,int SubScripts,char InitBuf){
877	int i,i2,i3,TypeSize;
878	char temporary[VN_SIZE];
879
880	if(InitBuf[0]=='['){
881	SlideString(InitBuf+1,-1);
882	InitBuf[lstrlen(InitBuf)-1]=0;
883
884	TypeSize=GetTypeSize(type,lpIndex);
885
886	if(SubScripts[0]!=-1){
887	TypeSize*=JumpSubScripts(SubScripts+1);
888	i=0;
889	i2=0;
890	while(1){
891	if(SubScripts[0]<i2){
892	SetError(41,0,cp);
893	return 0;
894	}
895	i=GetOneParameter(InitBuf,i,temporary);
896	if(!InitLocalVar(
897	offset+i2*TypeSize,
898	type,
899	lpIndex,
900	SubScripts+1,
901	temporary)) return 0;
902	i2++;
903	if(InitBuf[i]=='\0') break;
904	}
905	return -1;
906	}
907
908	if(type==DEF_OBJECT){
909	CClass *pobj_c;
910	pobj_c=(CClass *)lpIndex;
911
912	for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
913	i=GetOneParameter(InitBuf,i,temporary);
914
915	i3=GetSizeOfClassMember(pobj_c,pobj_c->ppobj_Member[i2]->name,NULL);
916
917	if(!InitLocalVar(offset+i3,
918	pobj_c->ppobj_Member[i2]->TypeInfo.type,
919	pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
920	pobj_c->ppobj_Member[i2]->SubScripts,
921	temporary)) return 0;
922
923	if(InitBuf[i]=='\0') break;
924	}
925	if(i2+1!=pobj_c->iMemberNum){
926	SetError(41,0,cp);
927	return 0;
928	}
929	return 1;
930	}
931
932	SetError(41,0,cp);
933	return 0;
934	}
935
936	if(SubScripts[0]!=-1){
937	SetError(41,0,cp);
938	return 0;
939	}
940
941	double dbl;
942	_int64 i64data;
943	int CalcType;
944	LONG_PTR lpCalcIndex;
945	CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
946	if(!CalcType){
947	//動的データだった場合
948	return 0;
949	}
950	if(IsRealNumberType(CalcType)){
951	memcpy(&dbl,&i64data,sizeof(double));
952	i64data=(_int64)dbl;
953	}
954	else dbl=(double)i64data;
955
956	//型チェック
957	CheckDifferentType(
958	type,
959	lpIndex,
960	CalcType,
961	lpCalcIndex,
962	0,0);
963
964	if(type==DEF_DOUBLE){
965	memcpy(&i64data,&dbl,sizeof(double));
966
967	//mov rax,i64data
968	op_mov64_ToReg(REG_RAX,i64data);
969
970	//mov qword ptr[rsp+offset],rax
971	op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
972	obp-=sizeof(long);
973	AddLocalVarAddrSchedule();
974	obp+=sizeof(long);
975	}
976	else if(type==DEF_SINGLE){
977	float flt;
978	flt=(float)dbl;
979
980	//mov dword ptr[rsp+offset],value
981	op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int )&flt);
982	obp-=sizeof(long)+sizeof(long);
983	AddLocalVarAddrSchedule();
984	obp+=sizeof(long)+sizeof(long);
985	}
986	else if(type==DEF_INT64\|\|type==DEF_QWORD\|\|IsPtrType(type)){
987	if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
988	//文字列定数のとき
989
990	char *temp;
991	temp=(char *)i64data;
992	i2=AddDataTable(temp,lstrlen(temp));
993	HeapDefaultFree(temp);
994
995	//mov rax,i2
996	op_mov_RV(sizeof(_int64),REG_RAX,i2);
997	obp-=sizeof(long);
998	pobj_DataTableSchedule->add();
999	obp+=sizeof(long);
1000
1001	//mov qword ptr[rsp+offset],rax
1002	op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
1003	obp-=sizeof(long);
1004	AddLocalVarAddrSchedule();
1005	obp+=sizeof(long);
1006	}
1007	else{
1008	if(i64data&0xFFFFFFFF00000000){
1009	//mov rax,i64data
1010	op_mov64_ToReg(REG_RAX,i64data);
1011
1012	//mov qword ptr[rsp+offset],rax
1013	op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
1014	obp-=sizeof(long);
1015	AddLocalVarAddrSchedule();
1016	obp+=sizeof(long);
1017	}
1018	else{
1019	//mov qword ptr[rsp+offset],value
1020	op_mov_MV(sizeof(_int64),REG_RSP,offset,USE_OFFSET,(int)i64data);
1021	obp-=sizeof(long)+sizeof(long);
1022	AddLocalVarAddrSchedule();
1023	obp+=sizeof(long)+sizeof(long);
1024	}
1025	}
1026	}
1027	else if(type==DEF_LONG\|\|type==DEF_DWORD){
1028	//mov dword ptr[rsp+offset],value
1029	op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int)i64data);
1030	obp-=sizeof(long)+sizeof(long);
1031	AddLocalVarAddrSchedule();
1032	obp+=sizeof(long)+sizeof(long);
1033	}
1034	else if(type==DEF_INTEGER\|\|type==DEF_WORD){
1035	//mov word ptr[rsp+offset],value
1036	op_mov_MV(sizeof(short),REG_RSP,offset,USE_OFFSET,(int)i64data);
1037	obp-=sizeof(long)+sizeof(short);
1038	AddLocalVarAddrSchedule();
1039	obp+=sizeof(long)+sizeof(short);
1040	}
1041	else if(type==DEF_CHAR\|\|type==DEF_BYTE\|\|type==DEF_BOOLEAN){
1042	//mov byte ptr[rsp+offset],value
1043	op_mov_MV(sizeof(char),REG_RSP,offset,USE_OFFSET,(int)i64data);
1044	obp-=sizeof(long)+sizeof(char);
1045	AddLocalVarAddrSchedule();
1046	obp+=sizeof(long)+sizeof(char);
1047	}
1048	return 1;
1049	}
1050
1051
1052	void dim(char *Parameter,DWORD dwFlags){
1053	extern BOOL bCompilingGlobal;
1054	extern HANDLE hHeap;
1055	int i2,i3,VarSize;
1056	char VarName[VN_SIZE];
1057
1058	//参照型かどうか
1059	bool isRef = false;
1060
1061	i2 = 0;
1062
1063	if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
1064	//参照型
1065	isRef = true;
1066	Parameter += 2;
1067	}
1068
1069	if(dwFlags & DIMFLAG_CONST){
1070
1071	//////////////////////////////////
1072	// 定数変数の場合を考慮
1073	//////////////////////////////////
1074	for(;;i2++){
1075	if(Parameter[i2] == '=' \|\|
1076	Parameter[i2] == 1 && Parameter[i2] == ESC_AS \|\|
1077	Parameter[i2] =='('){
1078	VarName[i2] = 0;
1079	break;
1080	}
1081	VarName[i2] = Parameter[i2];
1082	}
1083
1084	//定数と２重定義されていないる場合は抜け出す
1085	if(CDBConst::obj.GetType(VarName)){
1086	return;
1087	}
1088
1089	//定数マクロとして定義されている場合は抜け出す
1090	if(GetConstHash(VarName)){
1091	return;
1092	}
1093	}
1094
1095
1096	//構文を解析
1097	int SubScripts[MAX_ARRAYDIM];
1098	TYPEINFO TypeInfo;
1099	char InitBuf[8192];
1100	char ConstractParameter[VN_SIZE];
1101	if(!GetDimentionFormat(Parameter, isRef , VarName,SubScripts,&TypeInfo,InitBuf,ConstractParameter))
1102	return;
1103
1104
1105	//定数と２重定義されていないかを調べる
1106	if(CDBConst::obj.GetType(VarName)){
1107	SetError(15,VarName,cp);
1108	return;
1109	}
1110
1111	//定数マクロとして定義されている場合
1112	if(GetConstHash(VarName)){
1113	SetError(15,VarName,cp);
1114	return;
1115	}
1116
1117
1118	//タイプサイズを取得
1119	int TypeSize;
1120	TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
1121
1122	if(dwFlags&DIMFLAG_STATIC){
1123	if(bCompilingGlobal){
1124	SetError(60,NULL,cp);
1125	return;
1126	}
1127
1128	/////////////////////
1129	// Static変数
1130	// ※"Static.Object.Method.Variable"
1131	/////////////////////
1132
1133	char temporary[VN_SIZE];
1134	GetNowStaticVarFullName(VarName,temporary);
1135
1136	AddGlobalVariable(temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
1137
1138	/*
1139	Note: 静的変数のコンストラクタ呼び出しは
1140	_System_InitStaticLocalVariables関数内で一括して行う
1141	*/
1142	}
1143	else{
1144	if(bCompilingGlobal){
1145	/////////////////////////
1146	// グローバル変数
1147	/////////////////////////
1148
1149	AddGlobalVariable(VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
1150	}
1151	else{
1152	/////////////////
1153	// ローカル変数
1154	/////////////////
1155
1156	for(i2=0;i2<MaxLocalVarNum;i2++){
1157	if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
1158	if(lstrcmp(LocalVar[i2].name,VarName)==0){
1159	//２重定義のエラー
1160	SetError(15,VarName,cp);
1161	return;
1162	}
1163	}
1164	}
1165
1166	LocalVar=(VARIABLE )HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)sizeof(VARIABLE));
1167	VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
1168	MaxLocalVarNum++;
1169
1170	if( isRef ){
1171	//参照型
1172	pVar->fRef = REF_VARIABLE;
1173	TypeSize = PTR_SIZE;
1174	}
1175	else pVar->fRef=0;
1176
1177	for(i2=1,i3=0;i3<255;i3++){
1178	//配列要素数
1179	pVar->SubScripts[i3]=SubScripts[i3];
1180
1181	if(SubScripts[i3]==-1) break;
1182	i2*=SubScripts[i3]+1;
1183	}
1184	VarSize=TypeSize*i2;
1185	if(VarSize%8) VarSize+=8-(VarSize%8);
1186
1187	//変数データを追加
1188	lstrcpy(pVar->name,VarName);
1189	if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
1190	else pVar->bConst = false;
1191	if(SubScripts[0]==-1) pVar->bArray=0;
1192	else pVar->bArray=1;
1193	pVar->type=TypeInfo.type;
1194	pVar->u.index=TypeInfo.u.lpIndex;
1195	AllLocalVarSize+=VarSize;
1196	pVar->offset=AllLocalVarSize;
1197
1198	//レキシカルスコープ
1199	pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
1200	pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
1201	pVar->bLiving=TRUE;
1202
1203	if(InitBuf[0]){
1204	//初期代入時のみ、書き込みアクセスを許可する
1205	bool bConstBack = pVar->bConst;
1206	pVar->bConst = false;
1207
1208	int result = InitLocalVar(-pVar->offset,
1209	pVar->type,
1210	pVar->u.index,
1211	pVar->SubScripts,
1212	InitBuf);
1213
1214	if(!result){
1215	//動的な式だった場合は代入演算を行う
1216	if( isRef ){
1217	SetRefVariable( VarName, InitBuf );
1218	}
1219	else{
1220	char temporary[8192];
1221	sprintf(temporary,"%s=%s",VarName,InitBuf);
1222	OpcodeCalc(temporary);
1223	}
1224	}
1225
1226	pVar->bConst = bConstBack;
1227	}
1228	else{
1229	//0初期化
1230
1231	//mov r8, 0
1232	op_zero_reg( REG_R8 );
1233
1234	//mov rdx, VarSize
1235	op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
1236
1237	//mov rcx, rsp
1238	op_mov_RR( REG_RCX, REG_RSP );
1239
1240	//add rcx, offset
1241	op_add64_value( REG_RCX, -pVar->offset );
1242	obp-=sizeof(long);
1243	AddLocalVarAddrSchedule();
1244	obp+=sizeof(long);
1245
1246	//call FillMemory
1247	DECLAREINFO *pdi;
1248	pdi=GetDeclareHash("FillMemory");
1249	op_call( pdi );
1250	}
1251	}
1252
1253	//コンストラクタ呼び出し
1254	if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
1255	CallConstractor(VarName,SubScripts,TypeInfo,ConstractParameter);
1256	}
1257	}
1258
1259	if(TypeInfo.type==DEF_OBJECT){
1260	if(TypeInfo.u.pobj_Class->IsAbstract()){
1261	//抽象クラスだったとき
1262	SetError(125,TypeInfo.u.pobj_Class->name,cp);
1263	}
1264	}
1265	}
1266	void OpcodeDim(char *Parameter,DWORD dwFlags){
1267	int i,i2,i3,IsStr=0;
1268	char temporary[8192];
1269
1270	for(i=0,i2=0;;i++,i2++){
1271	if(Parameter[i]=='\"') IsStr^=1;
1272	if(Parameter[i]=='('&&IsStr==0){
1273	i3=GetStringInPare(temporary+i2,Parameter+i);
1274	i+=i3-1;
1275	i2+=i3-1;
1276	continue;
1277	}
1278	if(Parameter[i]=='['&&IsStr==0){
1279	i3=GetStringInBracket(temporary+i2,Parameter+i);
1280	i+=i3-1;
1281	i2+=i3-1;
1282	continue;
1283	}
1284	if((Parameter[i]==','&&IsStr==0)\|\|
1285	Parameter[i]=='\0'){
1286	temporary[i2]=0;
1287
1288	dim(temporary,dwFlags);
1289
1290	if(Parameter[i]=='\0') break;
1291	i2=-1;
1292	continue;
1293	}
1294	temporary[i2]=Parameter[i];
1295	}
1296	}
1297
1298	void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
1299	if(!IsGeneralReg(reg)) SetError(300,NULL,cp);
1300
1301	if(pRelativeVar->dwKind==VAR_GLOBAL){
1302	if(pRelativeVar->bOffsetOffset){
1303	//add r11,offset
1304	OpBuffer[obp++]=(char)0x49;
1305	OpBuffer[obp++]=(char)0x81;
1306	OpBuffer[obp++]=(char)0xC3;
1307	((long )(OpBuffer+obp))=(int)pRelativeVar->offset;
1308	pobj_GlobalVarSchedule->add();
1309	obp+=sizeof(long);
1310
1311	//mov reg,r11
1312	op_mov64_ToReg_FromReg(reg,REG_R11);
1313	}
1314	else{
1315	//mov reg,offset
1316	op_mov64_ToReg(reg,(int)pRelativeVar->offset);
1317	obp-=sizeof(long);
1318	pobj_GlobalVarSchedule->add();
1319	obp+=sizeof(long);
1320	}
1321	}
1322	else if(pRelativeVar->dwKind==VAR_LOCAL){
1323	if(pRelativeVar->bOffsetOffset){
1324	//add r11,offset
1325	OpBuffer[obp++]=(char)0x49;
1326	OpBuffer[obp++]=(char)0x81;
1327	OpBuffer[obp++]=(char)0xC3;
1328	((long )(OpBuffer+obp))=(int)pRelativeVar->offset;
1329	AddLocalVarAddrSchedule();
1330	obp+=sizeof(long);
1331
1332	//add r11,rsp
1333	op_add64_reg(REG_R11,REG_RSP);
1334
1335	//mov reg,r11
1336	op_mov64_ToReg_FromReg(reg,REG_R11);
1337	}
1338	else{
1339	//mov reg,rsp
1340	op_mov64_ToReg_FromReg(reg,REG_RSP);
1341
1342	//add reg,offset
1343	op_add64_value(reg,(int)pRelativeVar->offset);
1344	obp-=sizeof(long);
1345	AddLocalVarAddrSchedule();
1346	obp+=sizeof(long);
1347	}
1348	}
1349	else if( pRelativeVar->dwKind == VAR_REFLOCAL ){
1350	if(pRelativeVar->bOffsetOffset){
1351	//add r11,qword ptr[rsp+offset]
1352	OpBuffer[obp++]=(char)0x4C;
1353	OpBuffer[obp++]=(char)0x03;
1354	OpBuffer[obp++]=(char)0x9C;
1355	OpBuffer[obp++]=(char)0x24;
1356	((long )(OpBuffer+obp))=(int)pRelativeVar->offset;
1357	AddLocalVarAddrSchedule();
1358	obp+=sizeof(long);
1359	}
1360	else{
1361	//mov r11,qword ptr[rsp+offset]
1362	op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
1363	obp-=sizeof(long);
1364	AddLocalVarAddrSchedule();
1365	obp+=sizeof(long);
1366	}
1367
1368	goto directmem;
1369	}
1370	else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
1371	directmem:
1372	//mov reg,r11
1373	op_mov64_ToReg_FromReg(reg,REG_R11);
1374	}
1375	}

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

Download in other formats: