source: dev/trunk/ab5.0/abdev/compiler_x64/Compile_Var.cpp @ 514

Last change on this file since 514 was 514, checked in by dai_9181, 15 years ago

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