source: dev/trunk/abdev/BasicCompiler64/Compile_Var.cpp@ 308

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

静的リンクライブラリにより、複数のグローバル領域が存在することになったのでそれぞれを関数ベースに分けた

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