Context Navigation

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

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

File size: 32.4 KB

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

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

Download in other formats: