source: dev/trunk/abdev/BasicCompiler64/Compile_Func.cpp@ 342

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

64ビットコンパイラもデリゲートに対応させた
File size: 12.8 KB
Line 
1#include "stdafx.h"
2
3#include <jenga/include/smoothie/Smoothie.h>
4
5#include <Compiler.h>
6
7#include "../BasicCompiler_Common/common.h"
8#include "Opcode.h"
9
10int GetFunctionFromName(char *FuncName){
11 if( lstrcmpi( FuncName, "Len" ) == 0 ) return FUNC_LEN;
12 if( lstrcmpi( FuncName, "AddressOf" ) == 0 ) return FUNC_ADDRESSOF;
13 if( lstrcmpi( FuncName, "SizeOf" ) == 0 ) return FUNC_SIZEOF;
14 if( lstrcmpi( FuncName, "VarPtr" ) == 0 ) return FUNC_VARPTR;
15 if( lstrcmpi( FuncName, "ObjPtr" ) == 0 ) return FUNC_OBJPTR;
16 if( lstrcmpi( FuncName, "__delegate_dynamicmethod_call" ) == 0 ) return FUNC_DELEGATE_DYNAMICMETHOD_CALL;
17 if( lstrcmpi( FuncName, "__delegate_staticmethod_call" ) == 0 ) return FUNC_DELEGATE_STATICMETHOD_CALL;
18 if( lstrcmpi( FuncName, "GetDouble" ) == 0 ) return FUNC_GETDOUBLE;
19 if( lstrcmpi( FuncName, "GetSingle" ) == 0 ) return FUNC_GETSINGLE;
20 if( lstrcmpi( FuncName, "GetQWord" ) == 0 ) return FUNC_GETQWORD;
21 if( lstrcmpi( FuncName, "GetDWord" ) == 0 ) return FUNC_GETDWORD;
22 if( lstrcmpi( FuncName, "GetWord" ) == 0 ) return FUNC_GETWORD;
23 if( lstrcmpi( FuncName, "GetByte" ) == 0 ) return FUNC_GETBYTE;
24 return 0;
25}
26void Opcode_Func_Len( const char *Parameter ){
27 BOOL bArrayHead;
28
29 const char *tempParm=Parameter;
30 char temporary[VN_SIZE];
31 char temp2[32];
32 Type type;
33 if( !GetVarType(Parameter,type,0) ){
34 sprintf(temporary,"_System_DummyStr2=%s",Parameter);
35 OpcodeCalc(temporary);
36
37 lstrcpy(temp2,"_System_DummyStr2");
38 tempParm=temp2;
39
40 type.SetType( DEF_OBJECT, compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
41 }
42
43 if( type.IsStringClass() ){
44 //Stringオブジェクトの場合
45 sprintf(temporary,"%s.Length",tempParm);
46
47 int reg=REG_RAX;
48 NumOpe(&reg,temporary,Type(),Type());
49 return;
50 }
51
52 Subscripts subscripts;
53 RELATIVE_VAR RelativeVar;
54 if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,&subscripts)) return;
55
56 if(type.GetBasicType()&FLAG_PTR){
57 type.SetBasicType( type.GetBasicType() & ( ~FLAG_PTR ) );
58
59 bArrayHead=1;
60 }
61 else bArrayHead=0;
62
63 int typeSize = type.GetSize();
64
65 if(bArrayHead) typeSize*=JumpSubScripts(subscripts);
66
67 //mov rax,TypeSize
68 compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,typeSize);
69
70 return;
71}
72
73void _Opcode_Func_AddressOf( const char *methodInstanceName, const UserProc &userProc )
74{
75 if( userProc.IsVirtual() )
76 {
77 ///////////////////////////////
78 // 仮想関数の場合
79 // thisポインタをrcxにコピー
80 ///////////////////////////////
81
82 const CClass *pobj_c;
83
84 char ObjectName[VN_SIZE];
85 ReferenceKind referenceKind;
86 SplitObjectName(methodInstanceName,ObjectName, referenceKind );
87
88 if(ObjectName[0]){
89 if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
90 else{
91 RELATIVE_VAR RelativeVar;
92 Type type;
93 if(!GetVarOffsetReadOnly(ObjectName,&RelativeVar,type)) return;
94 SetVarPtrToReg(REG_RCX,&RelativeVar);
95
96 //参照タイプが整合しているかをチェック
97 if( !( type.IsObject() && referenceKind == RefDot
98 || type.IsObjectPtr() && referenceKind == RefPointer ) )
99 {
100 SetError(104,ObjectName,cp);
101 }
102
103 if(type.IsObjectPtr()){
104 //mov rcx,qword ptr[rcx]
105 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
106 }
107 }
108 }
109 else{
110InClassMember:
111 //自身のオブジェクトのThisポインタをrcxにコピー
112 SetThisPtrToReg(REG_RCX);
113
114 pobj_c=compiler.pCompilingClass;
115 }
116
117
118 //仮想関数（オブジェクトメソッド）
119 //pObj->func_table->func1
120 // ->func2
121 // ->func3
122
123 //mov r11,qword ptr[rcx]
124 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
125
126 int i2 = pobj_c->GetFuncNumInVtbl( &userProc );
127
128 //mov rax,qword ptr[r11+func_index]
129 if(i2*PTR_SIZE<=0x7F){
130 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RAX,REG_R11,i2*PTR_SIZE,MOD_BASE_DISP8);
131 }
132 else{
133 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RAX,REG_R11,i2*PTR_SIZE,MOD_BASE_DISP32);
134 }
135 }
136 else{
137 //一般の関数
138
139 //mov rax,ProcAddr
140 compiler.codeGenerator.op_addressof( REG_RAX, &userProc );
141 }
142
143 userProc.Using();
144}
145void Opcode_CreateDelegate( const CClass &dgClass, const char *methodInstanceName, const UserProc &userProc )
146{
147 /////////////////////////////////////////////////////////////////
148 // 関数ポインタをpush
149 /////////////////////////////////////////////////////////////////
150
151 //mov rax,AddressOf
152 _Opcode_Func_AddressOf( methodInstanceName, userProc );
153
154
155 if( userProc.GetMethod().IsDynamic() )
156 {
157 //mov rdx,rax
158 compiler.codeGenerator.op_mov_RR( REG_RDX, REG_RAX );
159
160 pobj_BlockReg->lock( REG_RDX );
161
162
163 /////////////////////////////////////////////////////////////////
164 // オブジェクト ポインタをpush
165 /////////////////////////////////////////////////////////////////
166
167 // オブジェクト名を取得
168 char objectName[VN_SIZE];
169 char memberName[VN_SIZE];
170 char *thisPtrName = "This";
171 Type type;
172 if( SplitMemberName( methodInstanceName, objectName, memberName ) )
173 {
174 if( GetVarType( objectName, type, false ) )
175 {
176 thisPtrName = objectName;
177 }
178 }
179
180 // オブジェクト ポインタを取得
181 RELATIVE_VAR relativeVar;
182 GetVarOffsetReadOnly( thisPtrName, &relativeVar, type );
183 if( !type.IsObject() )
184 {
185 extern int cp;
186 SetError(1,NULL,cp);
187 return;
188 }
189
190 SetVarPtrToReg( REG_RAX, &relativeVar );
191
192 //mov rcx,dword ptr[rax]
193 compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RCX, REG_RAX, 0, MOD_BASE );
194
195 pobj_BlockReg->unlock( REG_RDX );
196 }
197 else
198 {
199 //mov rcx,rax
200 compiler.codeGenerator.op_mov_RR( REG_RCX, REG_RAX );
201 }
202
203
204 /////////////////////////////////////////////////////////////////
205 // call _CreateDynamicDelegate/_CreateStaticDelegate
206 /////////////////////////////////////////////////////////////////
207
208 std::vector<const UserProc *> subs;
209 if( userProc.GetMethod().IsDynamic() )
210 {
211 dgClass.GetStaticMethods().Enum( "_CreateDynamicDelegate", subs );
212 }
213 else
214 {
215 dgClass.GetStaticMethods().Enum( "_CreateStaticDelegate", subs );
216 }
217
218 // call _CreateDynamicDelegate
219 compiler.codeGenerator.op_call( subs[0] );
220}
221void Opcode_Func_AddressOf( const char *name, const Type &baseType, bool isCallOn, Type &resultType )
222{
223 extern int cp;
224 const UserProc *pUserProc;
225
226 const Parameters *pBaseParams = NULL;
227 if( baseType.IsProcPtr() )
228 {
229 // 左辺で関数ポインタを要求されているとき
230 pBaseParams = &compiler.GetObjectModule().meta.GetProcPointers()[baseType.GetIndex()]->Params();
231 }
232 else if( baseType.IsDelegate() )
233 {
234 // 左辺でデリゲートを要求されているとき
235 pBaseParams = &baseType.GetClass().GetDelegate().Params();
236 }
237
238 if( pBaseParams )
239 {
240 //左辺の型にのっとり、オーバーロードを解決
241
242 std::vector<const UserProc *> subs;
243 GetOverloadSubHash( name, subs );
244 if( subs.size() == 0 ){
245 SetError(27,name,cp);
246 return;
247 }
248
249 //オーバーロードを解決
250 pUserProc=OverloadSolution( name, subs, *pBaseParams, Type() );
251
252 if( isCallOn && baseType.IsDelegate() )
253 {
254 // コード生成を伴う場合はエラーチェックを行う
255 if( !pUserProc->Params().Equals( *pBaseParams )
256 || !pUserProc->ReturnType().Equals( baseType.GetClass().GetDelegate().ReturnType() ) )
257 {
258 if( baseType.IsDelegate() )
259 {
260 SetError(67, name, cp );
261 }
262 else
263 {
264 SetError(66, name, cp );
265 }
266 }
267 }
268
269 if(!pUserProc){
270 SetError(27,name,cp);
271 return;
272 }
273 }
274 else{
275 pUserProc=GetSubHash(name);
276 if(!pUserProc){
277 SetError(27,name,cp);
278 return;
279 }
280 }
281
282 if( baseType.IsDelegate() )
283 {
284 if( isCallOn )
285 {
286 // デリゲートのとき
287 Opcode_CreateDelegate( baseType.GetClass(), name, *pUserProc );
288 }
289 resultType = baseType;
290 }
291 else
292 {
293 if( isCallOn )
294 {
295 // 関数ポインタのとき
296 _Opcode_Func_AddressOf( name, *pUserProc );
297 }
298 resultType.SetBasicType( DEF_PTR_VOID );
299 }
300}
301void Opcode_Func_SizeOf( const string &typeName ){
302 Type tempType;
303 if( !compiler.StringToType( typeName, tempType ) ){
304 SetError(3,typeName,cp);
305 return;
306 }
307
308 int typeSize = ( tempType.IsObject() ) ?
309 tempType.GetClass().GetSize() : tempType.GetSize();
310
311 //mov rax,size
312 compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,typeSize);
313}
314void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn ){
315 if( isCallOn == false ){
316 // 戻り値の型を取得するだけ
317
318 //変数のアドレスを取得
319 if(!GetVarType( Parameter, resultType, true )) return;
320
321 resultType.PtrLevelUp();
322
323 return;
324 }
325
326 RELATIVE_VAR RelativeVar;
327
328 //変数のアドレスを取得
329 if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
330
331 int beforeType = resultType.GetBasicType();
332
333 resultType.PtrLevelUp();
334
335 SetVarPtrToReg(REG_RAX,&RelativeVar);
336
337 // TODO: 取り除く（この動きはObjPtrに託す）
338 /*
339 if( beforeType == DEF_OBJECT && lstrcmpi( Parameter, "This" ) != 0 ){
340 //参照をオブジェクトポインタに変更
341
342 //mov rax,qword ptr[rax]
343 compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
344
345 SetError(-120,NULL,cp);
346 }*/
347}
348void Opcode_Func_ObjPtr( const char *Parameter, Type &resultType, bool isCallOn ){
349 if( isCallOn == false ){
350 // 戻り値の型を取得するだけ
351
352 //変数のアドレスを取得
353 if(!GetVarType( Parameter, resultType, true )) return;
354
355 resultType.PtrLevelUp();
356
357 return;
358 }
359
360 RELATIVE_VAR RelativeVar;
361
362 //変数のアドレスを取得
363 if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
364
365 int beforeType = resultType.GetBasicType();
366
367 resultType.PtrLevelUp();
368
369 SetVarPtrToReg(REG_RAX,&RelativeVar);
370
371 if( lstrcmpi( Parameter, "This" )==0 ){
372 // Thisの場合は特別にオブジェクトポインタが返ってくるので、何もせずに抜ける
373 }
374 else if( beforeType == DEF_OBJECT ){
375 //参照をオブジェクトポインタに変更
376
377 //mov rax,qword ptr[rax]
378 compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
379 }
380 else{
381 SetError(134,NULL,cp );
382 }
383}
384
385void Opcode_Func_delegate_call( const char *paramsStr, Type &resultType, bool isDynamicCall, bool isCallOn )
386{
387 if( isCallOn )
388 {
389 int i = 0;
390 char methodPtrParamStr[VN_SIZE];
391 i = GetOneParameter( paramsStr, i, methodPtrParamStr );
392
393 char objPtrValueStr[VN_SIZE] = "";
394 if( isDynamicCall )
395 {
396 i = GetOneParameter( paramsStr, i, objPtrValueStr );
397 }
398
399 Opcode_CallDelegate( compiler.pCompilingClass->GetDelegate(), methodPtrParamStr, objPtrValueStr, paramsStr + i );
400 }
401
402 resultType = UserProc::CompilingUserProc().ReturnType();
403}
404
405void Opcode_Func_GetPtrData( const char *Parameter, const int type ){
406 int reg=REG_RAX;
407 Type tempType;
408 if( !NumOpe(&reg,Parameter,Type(),tempType) ){
409 return;
410 }
411 if(!tempType.IsWhole()){
412 SetError(11,Parameter,cp);
413 return;
414 }
415
416 if(type==DEF_DOUBLE){
417 //movlpd xmm0,qword ptr[rax]
418 compiler.codeGenerator.op_movlpd_RM(REG_XMM0,REG_RAX,0,MOD_BASE);
419 }
420 else if(type==DEF_SINGLE){
421 //movss xmm0,dword ptr[rax]
422 compiler.codeGenerator.op_movss_RM(REG_XMM0,REG_RAX,0,MOD_BASE);
423 }
424 else{
425 //mov rax,ptr[rax]
426 compiler.codeGenerator.op_mov_RM(Type(type).GetSize(),REG_RAX,REG_RAX,0,MOD_BASE);
427 }
428}
429
430bool Opcode_CallFunc( const char *Parameter, const int FuncNum, const Type &baseType, Type &resultType, bool isCallOn )
431{
432 switch(FuncNum){
433 case FUNC_LEN:
434 if( isCallOn ) Opcode_Func_Len(Parameter);
435 resultType.SetBasicType( DEF_LONG );
436 break;
437 case FUNC_ADDRESSOF:
438 Opcode_Func_AddressOf( Parameter, baseType, isCallOn, resultType );
439 break;
440 case FUNC_SIZEOF:
441 if( isCallOn ) Opcode_Func_SizeOf(Parameter);
442 resultType.SetBasicType( DEF_LONG );
443 break;
444 case FUNC_VARPTR:
445 Opcode_Func_VarPtr( Parameter, resultType, isCallOn );
446 break;
447 case FUNC_OBJPTR:
448 Opcode_Func_ObjPtr( Parameter, resultType, isCallOn );
449 break;
450 case FUNC_DELEGATE_DYNAMICMETHOD_CALL:
451 Opcode_Func_delegate_call( Parameter, resultType, true, isCallOn );
452 break;
453 case FUNC_DELEGATE_STATICMETHOD_CALL:
454 Opcode_Func_delegate_call( Parameter, resultType, false, isCallOn );
455 break;
456
457 case FUNC_GETDOUBLE:
458 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DOUBLE);
459 resultType.SetBasicType( DEF_DOUBLE );
460 break;
461 case FUNC_GETSINGLE:
462 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_SINGLE);
463 resultType.SetBasicType( DEF_SINGLE );
464 break;
465 case FUNC_GETQWORD:
466 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_QWORD);
467 resultType.SetBasicType( DEF_QWORD );
468 break;
469 case FUNC_GETDWORD:
470 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DWORD);
471 resultType.SetBasicType( DEF_DWORD );
472 break;
473 case FUNC_GETWORD:
474 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_WORD);
475 resultType.SetBasicType( DEF_WORD );
476 break;
477 case FUNC_GETBYTE:
478 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_BYTE);
479 resultType.SetBasicType( DEF_BYTE );
480 break;
481 default:
482 return false;
483 }
484 return true;
485}
Note: See TracBrowser for help on using the repository browser.