Index: trunk/abdev/BasicCompiler64/BasicCompiler.rc =================================================================== --- trunk/abdev/BasicCompiler64/BasicCompiler.rc (revision 149) +++ trunk/abdev/BasicCompiler64/BasicCompiler.rc (revision 149) @@ -0,0 +1,412 @@ +//Microsoft Developer Studio generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// 日本語 resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_JPN) +#ifdef _WIN32 +LANGUAGE LANG_JAPANESE, SUBLANG_DEFAULT +#pragma code_page(932) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE DISCARDABLE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE DISCARDABLE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE DISCARDABLE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +#if defined(APSTUDIO_INVOKED) || defined(JPN) +#if defined(APSTUDIO_INVOKED) +IDD_MAIN$(JPN) DIALOG DISCARDABLE 0, 0, 205, 229 +#else +IDD_MAIN DIALOG DISCARDABLE 0, 0, 205, 229 +#endif +STYLE DS_MODALFRAME | WS_CAPTION | WS_SYSMENU +CAPTION "ActiveBasic Compiler&Debugger" +FONT 9, "ＭＳ Ｐゴシック" +BEGIN + DEFPUSHBUTTON "コンパイル",IDOK,148,208,50,14 + LTEXT "出力先:",IDC_STATIC,7,10,23,8 + EDITTEXT IDC_EXEPATH,34,7,164,14,ES_AUTOHSCROLL + CONTROL "Progress1",IDC_PROGRESS,"msctls_progress32",0x0,13,56, + 179,14 + GROUPBOX "進行状況",IDC_STATIC,7,31,191,45 + LTEXT "準備中...",IDC_MESSAGE,13,44,161,8 + GROUPBOX "メッセージ リスト",IDC_STATIC,7,83,191,117 + EDITTEXT IDC_ERRORLIST,13,113,179,80,ES_MULTILINE | + ES_AUTOVSCROLL | ES_AUTOHSCROLL | WS_DISABLED | + WS_VSCROLL | WS_HSCROLL + CONTROL "エラー",IDC_SHOWERROR,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,13,97,35,10 + CONTROL "デバッグ",IDC_SHOWDEBUG,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,50,97,35,10 + EDITTEXT IDC_DEBUGLIST,13,113,179,80,ES_MULTILINE | + ES_AUTOVSCROLL | ES_AUTOHSCROLL | NOT WS_VISIBLE | + WS_DISABLED | WS_VSCROLL | WS_HSCROLL + LTEXT "Version",IDC_STATIC_VERSION,7,214,140,8 +END +#endif + +#if defined(APSTUDIO_INVOKED) || defined(JPN) +#if defined(APSTUDIO_INVOKED) +IDD_VARLIST$(JPN) DIALOG DISCARDABLE 0, 0, 215, 199 +#else +IDD_VARLIST DIALOG DISCARDABLE 0, 0, 215, 199 +#endif +STYLE WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME +CAPTION "ブレーク ポイント" +FONT 9, "ＭＳ Ｐゴシック" +BEGIN + PUSHBUTTON "閉じる",IDCANCEL,165,6,50,14 + LTEXT "対象領域:",IDC_STATIC,2,9,30,8 + LTEXT "対象スレッド:",IDC_STATIC,2,26,38,8 + COMBOBOX IDC_THREADCOMBO,43,24,69,100,CBS_DROPDOWNLIST | CBS_SORT | + WS_VSCROLL | WS_TABSTOP + CONTROL "Tree1",IDC_VARTREE,"SysTreeView32",TVS_HASBUTTONS | + TVS_HASLINES | TVS_LINESATROOT | WS_BORDER | WS_TABSTOP, + 0,88,215,111 + CONTROL "グローバル",IDC_GLOBAL,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,43,6,47,14 + CONTROL "ローカル",IDC_LOCAL,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,92,6,47,14 + LTEXT "プロシージャ:",IDC_STATIC,2,43,39,8 + COMBOBOX IDC_PROCCOMBO,43,40,69,116,CBS_DROPDOWNLIST | WS_VSCROLL | + WS_TABSTOP + CONTROL "システム変数を表示しない",IDC_HIDESYSVAR,"Button", + BS_AUTOCHECKBOX | WS_TABSTOP,117,44,93,10 + PUSHBUTTON "ステップ(IN)",IDC_STEPIN,4,64,50,14 + CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,59,215,1 + CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,81,215,1 + PUSHBUTTON "ステップ(OVER)",IDC_STEPOVER,57,64,50,14 +END +#endif + +#if defined(APSTUDIO_INVOKED) || defined(JPN) +#if defined(APSTUDIO_INVOKED) +IDD_CLIPMAIN$(JPN) DIALOGEX 0, 0, 332, 88 +#else +IDD_CLIPMAIN DIALOGEX 0, 0, 332, 88 +#endif +STYLE WS_CHILD +FONT 9, "ＭＳ Ｐゴシック" +BEGIN + PUSHBUTTON "コンパイル",IDOK,0,0,37,13 + EDITTEXT IDC_EXEPATH,285,57,24,12,ES_AUTOHSCROLL | ES_READONLY | + NOT WS_VISIBLE + EDITTEXT IDC_ERRORLIST,38,14,129,74,ES_MULTILINE | ES_AUTOVSCROLL | + ES_AUTOHSCROLL | WS_DISABLED | WS_VSCROLL | WS_HSCROLL + CONTROL "ビルド",IDC_SHOWERROR,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,0,20,37,12 + CONTROL "デバッグ",IDC_SHOWDEBUG,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,0,34,37,12 + EDITTEXT IDC_DEBUGLIST,38,15,179,73,ES_MULTILINE | ES_AUTOVSCROLL | + ES_AUTOHSCROLL | NOT WS_VISIBLE | WS_DISABLED | + WS_VSCROLL | WS_HSCROLL + CONTROL "Progress1",IDC_PROGRESS,"msctls_progress32",PBS_SMOOTH, + 38,1,293,12 + LTEXT "準備中...",IDC_MESSAGE,286,47,24,8,NOT WS_VISIBLE, + WS_EX_TRANSPARENT + CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,16,39,1 +END +#endif + +#if defined(APSTUDIO_INVOKED) || defined(ENG) +#if defined(APSTUDIO_INVOKED) +IDD_CLIPMAIN$(ENG) DIALOGEX 0, 0, 332, 88 +#else +IDD_CLIPMAIN DIALOGEX 0, 0, 332, 88 +#endif +STYLE WS_CHILD +FONT 9, "ＭＳ Ｐゴシック", 0, 0, 0x1 +BEGIN + PUSHBUTTON "Compile",IDOK,0,0,37,11 + EDITTEXT IDC_EXEPATH,285,57,24,12,ES_AUTOHSCROLL | ES_READONLY | + NOT WS_VISIBLE + EDITTEXT IDC_ERRORLIST,38,13,129,75,ES_MULTILINE | ES_AUTOVSCROLL | + ES_AUTOHSCROLL | WS_DISABLED | WS_VSCROLL | WS_HSCROLL + CONTROL "Error",IDC_SHOWERROR,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,0,17,37,10 + CONTROL "Debug",IDC_SHOWDEBUG,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,0,28,37,10 + EDITTEXT IDC_DEBUGLIST,38,14,179,74,ES_MULTILINE | ES_AUTOVSCROLL | + ES_AUTOHSCROLL | NOT WS_VISIBLE | WS_DISABLED | + WS_VSCROLL | WS_HSCROLL + CONTROL "Progress1",IDC_PROGRESS,"msctls_progress32",PBS_SMOOTH, + 38,0,293,12 + LTEXT "Waiting...",IDC_MESSAGE,286,47,24,8,NOT WS_VISIBLE, + WS_EX_TRANSPARENT + CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,13,39,1 +END +#endif + +#if defined(APSTUDIO_INVOKED) || defined(ENG) +#if defined(APSTUDIO_INVOKED) +IDD_MAIN$(ENG) DIALOG DISCARDABLE 0, 0, 205, 229 +#else +IDD_MAIN DIALOG DISCARDABLE 0, 0, 205, 229 +#endif +STYLE DS_MODALFRAME | WS_CAPTION | WS_SYSMENU +CAPTION "ActiveBasic Compiler&Debugger" +FONT 9, "ＭＳ Ｐゴシック" +BEGIN + DEFPUSHBUTTON "Compile",IDOK,148,208,50,14 + LTEXT "Output:",IDC_STATIC,7,10,22,8 + EDITTEXT IDC_EXEPATH,34,7,164,14,ES_AUTOHSCROLL + CONTROL "Progress1",IDC_PROGRESS,"msctls_progress32",0x0,13,56, + 179,14 + GROUPBOX "Advance situation",IDC_STATIC,7,31,191,45 + LTEXT "ready...",IDC_MESSAGE,13,44,161,8 + GROUPBOX "Message list",IDC_STATIC,7,83,191,117 + EDITTEXT IDC_ERRORLIST,13,113,179,80,ES_MULTILINE | + ES_AUTOVSCROLL | ES_AUTOHSCROLL | WS_DISABLED | + WS_VSCROLL | WS_HSCROLL + CONTROL "Error",IDC_SHOWERROR,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,13,97,30,10 + CONTROL "Debug",IDC_SHOWDEBUG,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,50,97,35,10 + EDITTEXT IDC_DEBUGLIST,13,113,179,80,ES_MULTILINE | + ES_AUTOVSCROLL | ES_AUTOHSCROLL | NOT WS_VISIBLE | + WS_DISABLED | WS_VSCROLL | WS_HSCROLL + LTEXT "Version 4.00 Global Edition beta1",IDC_STATIC,7,214,98, + 8 +END +#endif + +#if defined(APSTUDIO_INVOKED) || defined(ENG) +#if defined(APSTUDIO_INVOKED) +IDD_VARLIST$(ENG) DIALOG DISCARDABLE 0, 0, 215, 199 +#else +IDD_VARLIST DIALOG DISCARDABLE 0, 0, 215, 199 +#endif +STYLE WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME +CAPTION "Breakpoint" +FONT 9, "ＭＳ Ｐゴシック" +BEGIN + PUSHBUTTON "Close",IDCANCEL,165,6,50,14 + LTEXT "Level:",IDC_STATIC,2,9,18,8 + LTEXT "Thread:",IDC_STATIC,2,26,22,8 + COMBOBOX IDC_THREADCOMBO,43,24,69,100,CBS_DROPDOWNLIST | CBS_SORT | + WS_VSCROLL | WS_TABSTOP + CONTROL "Tree1",IDC_VARTREE,"SysTreeView32",TVS_HASBUTTONS | + TVS_HASLINES | TVS_LINESATROOT | WS_BORDER | WS_TABSTOP, + 0,88,215,111 + CONTROL "Global",IDC_GLOBAL,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,43,6,47,14 + CONTROL "Local",IDC_LOCAL,"Button",BS_AUTORADIOBUTTON | + BS_PUSHLIKE,92,6,47,14 + LTEXT "Procedure:",IDC_STATIC,2,43,31,8 + COMBOBOX IDC_PROCCOMBO,43,40,69,116,CBS_DROPDOWNLIST | WS_VSCROLL | + WS_TABSTOP + CONTROL "Hide system variables",IDC_HIDESYSVAR,"Button", + BS_AUTOCHECKBOX | WS_TABSTOP,117,44,81,10 + PUSHBUTTON "Step In",IDC_STEPIN,4,64,50,14 + CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,59,215,1 + CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,81,215,1 + PUSHBUTTON "Step Over",IDC_STEPOVER,57,64,50,14 +END +#endif + +#if defined(APSTUDIO_INVOKED) || defined(JPN) +#if defined(APSTUDIO_INVOKED) +IDD_DEBUGGER$(JPN) DIALOGEX 0, 0, 291, 148 +#else +IDD_DEBUGGER DIALOGEX 0, 0, 291, 148 +#endif +STYLE WS_CHILD +FONT 9, "ＭＳ Ｐゴシック", 0, 0, 0x1 +BEGIN + LTEXT "対象スレッド:",IDC_STATIC,5,21,38,8 + COMBOBOX IDC_THREADCOMBO,5,30,69,100,CBS_DROPDOWNLIST | CBS_SORT | + WS_VSCROLL | WS_TABSTOP + LTEXT "プロシージャ:",IDC_STATIC,5,49,39,8 + COMBOBOX IDC_PROCCOMBO,5,58,69,116,CBS_DROPDOWNLIST | WS_VSCROLL | + WS_TABSTOP + CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,15,99,1 + LTEXT "dummy",IDC_VARPOS,98,0,35,41,NOT WS_VISIBLE, + WS_EX_STATICEDGE + CONTROL "List2",IDC_WATCHLIST,"SysListView32",LVS_REPORT | + LVS_EDITLABELS | WS_BORDER | WS_TABSTOP,171,9,60,50, + WS_EX_ACCEPTFILES + LTEXT "コマンド",IDC_STATIC,3,3,23,8 +END +#endif + +IDD_DEBUGGER_TOOLBARBASE DIALOG DISCARDABLE 0, 0, 62, 15 +STYLE WS_CHILD | WS_VISIBLE +FONT 9, "ＭＳ Ｐゴシック" +BEGIN +END + +#if defined(APSTUDIO_INVOKED) || defined(ENG) +#if defined(APSTUDIO_INVOKED) +IDD_DEBUGGER$(ENG) DIALOGEX 0, 0, 291, 148 +#else +IDD_DEBUGGER DIALOGEX 0, 0, 291, 148 +#endif +STYLE WS_CHILD +FONT 9, "ＭＳ Ｐゴシック", 0, 0, 0x1 +BEGIN + LTEXT "Thread:",IDC_STATIC,5,21,22,8 + COMBOBOX IDC_THREADCOMBO,5,30,69,100,CBS_DROPDOWNLIST | CBS_SORT | + WS_VSCROLL | WS_TABSTOP + LTEXT "Procedure:",IDC_STATIC,5,49,31,8 + COMBOBOX IDC_PROCCOMBO,5,58,69,116,CBS_DROPDOWNLIST | WS_VSCROLL | + WS_TABSTOP + CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,0,15,99,1 + LTEXT "dummy",IDC_VARPOS,98,0,35,41,NOT WS_VISIBLE, + WS_EX_STATICEDGE + CONTROL "List2",IDC_WATCHLIST,"SysListView32",LVS_REPORT | + LVS_EDITLABELS | WS_BORDER | WS_TABSTOP,171,9,60,50, + WS_EX_ACCEPTFILES + LTEXT "コマンド",IDC_STATIC,3,3,23,8 +END +#endif + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO DISCARDABLE +BEGIN + "IDD_MAIN$(JPN)", DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 198 + TOPMARGIN, 7 + BOTTOMMARGIN, 222 + END + + "IDD_VARLIST$(JPN)", DIALOG + BEGIN + BOTTOMMARGIN, 161 + END + + "IDD_MAIN$(ENG)", DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 198 + TOPMARGIN, 7 + BOTTOMMARGIN, 222 + END + + "IDD_VARLIST$(ENG)", DIALOG + BEGIN + BOTTOMMARGIN, 161 + END + + IDD_DEBUGGER_TOOLBARBASE, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 55 + TOPMARGIN, 7 + BOTTOMMARGIN, 8 + END +END +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_MAIN ICON DISCARDABLE "icon1.ico" +IDI_VARSTRUCT ICON DISCARDABLE "VarStruct.ico" +IDI_VARDATA ICON DISCARDABLE "VarData.ico" +IDI_VARSTR ICON DISCARDABLE "VarStr.ico" +IDI_VARARRAY ICON DISCARDABLE "VarArray.ico" +IDI_VARPTRSTRUCT ICON DISCARDABLE "VarPtrStruct.ico" + +///////////////////////////////////////////////////////////////////////////// +// +// Toolbar +// + +IDR_DEBUGGERTOOLBAR TOOLBAR DISCARDABLE 16, 15 +BEGIN + BUTTON IDC_DEBUG_START + BUTTON IDC_DEBUG_STEPOVER + BUTTON IDC_DEBUG_STEPIN +END + + +///////////////////////////////////////////////////////////////////////////// +// +// Bitmap +// + +IDR_DEBUGGERTOOLBAR BITMAP DISCARDABLE "toolbar_debugger.bmp" +IDR_DEBUGGERTOOLBAR_DISABLED BITMAP DISCARDABLE "toolbar_debugger_disable.bmp" + +///////////////////////////////////////////////////////////////////////////// +// +// Menu +// + +IDR_DEBUGGER_VARLIST_MENU MENU DISCARDABLE +BEGIN + POPUP "dummy" + BEGIN + MENUITEM "一般システム変数を表示する", IDM_SHOW_DEFAULTSYSTEM_VAR + MENUITEM "RADシステム変数を表示する", IDM_SHOW_RAD_VAR + MENUITEM "GUID変数を表示する", IDM_SHOW_GUID_VAR + END +END + +#endif // 日本語 resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + Index: trunk/abdev/BasicCompiler64/BasicCompiler.vcproj =================================================================== --- trunk/abdev/BasicCompiler64/BasicCompiler.vcproj (revision 149) +++ trunk/abdev/BasicCompiler64/BasicCompiler.vcproj (revision 149) @@ -0,0 +1,1641 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index: trunk/abdev/BasicCompiler64/BasicCompiler64.sln =================================================================== --- trunk/abdev/BasicCompiler64/BasicCompiler64.sln (revision 149) +++ trunk/abdev/BasicCompiler64/BasicCompiler64.sln (revision 149) @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 9.00 +# Visual C++ Express 2005 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "BasicCompiler", "BasicCompiler.vcproj", "{864B921B-423B-4F9E-9E6B-31B15968EDF9}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + English_Rel|Win32 = English_Rel|Win32 + Release|Win32 = Release|Win32 + SmallDebug|Win32 = SmallDebug|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {864B921B-423B-4F9E-9E6B-31B15968EDF9}.Debug|Win32.ActiveCfg = Debug|Win32 + {864B921B-423B-4F9E-9E6B-31B15968EDF9}.Debug|Win32.Build.0 = Debug|Win32 + {864B921B-423B-4F9E-9E6B-31B15968EDF9}.English_Rel|Win32.ActiveCfg = English_Rel|Win32 + {864B921B-423B-4F9E-9E6B-31B15968EDF9}.English_Rel|Win32.Build.0 = English_Rel|Win32 + {864B921B-423B-4F9E-9E6B-31B15968EDF9}.Release|Win32.ActiveCfg = Release|Win32 + {864B921B-423B-4F9E-9E6B-31B15968EDF9}.Release|Win32.Build.0 = Release|Win32 + {864B921B-423B-4F9E-9E6B-31B15968EDF9}.SmallDebug|Win32.ActiveCfg = SmallDebug|Win32 + {864B921B-423B-4F9E-9E6B-31B15968EDF9}.SmallDebug|Win32.Build.0 = SmallDebug|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal Index: trunk/abdev/BasicCompiler64/CLockParameter.cpp =================================================================== --- trunk/abdev/BasicCompiler64/CLockParameter.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/CLockParameter.cpp (revision 149) @@ -0,0 +1,15 @@ +#include "../BasicCompiler_Common/common.h" +#include "opcode.h" + +CDBLockParms::CDBLockParms(){ +} +CDBLockParms::~CDBLockParms(){ +} +void CDBLockParms::lock(int level){ + array_LevelCount[level]++; +} +void CDBLockParms::unlock(int level){ + array_LevelCount[level]--; +} + +CDBLockParms obj_DBLockParms; Index: trunk/abdev/BasicCompiler64/CParameter.cpp =================================================================== --- trunk/abdev/BasicCompiler64/CParameter.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/CParameter.cpp (revision 149) @@ -0,0 +1,506 @@ +#include "../BasicCompiler_Common/common.h" +#include "opcode.h" + +int ParamImpl::NewTempParameters( const string &procName, const Parameters ¶ms, int SecondParmNum ){ + if( SecondParmNum == -1 ) SecondParmNum = (int)params.size(); + + /////////////////////////////////////////////////////// + // 一時オブジェクトをあらかじめスタックに積んでおく + /////////////////////////////////////////////////////// + + int stackItemNum = 0; + + useTempObject = false; + + BOOL bEllipse; + if(params.size()){ + if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1; + else bEllipse=0; + } + else bEllipse=0; + + for(int i2=ParmsNum-1;i2>=0;i2--){ + useTempParameters[i2] = false; + + if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0; + + if(i2==0){ + if( params[i2]->GetVarName() == "_System_LocalThis" ){ + //オブジェクトメンバの第一パラメータのThisポインタ + continue; + } + } + if( i2==0||i2==1 ){ + if( params[i2]->GetVarName() == procName ){ + //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト + continue; + } + } + + Type dummyType; + BOOL bByVal; + if(bEllipse){ + NumOpe_GetType( Parms[i2], Type(), dummyType ); + bByVal=1; + } + else{ + dummyType = *params[i2]; + bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE; + } + + + if( !bByVal ){ + //ポインタ参照 + if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){ + //ポインタ指定 + continue; + } + + if( !GetVarType( Parms[i2], Type(), FALSE ) ){ + //変数ではないとき + int reg = REG_RAX; + Type calcType; + NumOpe( ®, Parms[i2], dummyType, calcType ); + + if( !calcType.IsStruct() ){ + //一時参照を作成 + pobj_sf->push( reg ); + pobj_sf->mov_sp( reg ); + + stackItemNum++; + } + + //スタックフレームへコピー + StackOffsetOfTempObject[i2] = pobj_sf->push(reg); + + stackItemNum++; + + bool result = CheckDifferentType( + dummyType, + calcType, + procName.c_str(), + i2); + + if( result ){ + useTempParameters[i2] = true; + useTempObject = true; + + types[i2] = calcType; + } + } + } + } + + return stackItemNum * PTR_SIZE; +} +void ParamImpl::DeleteTempParameters(){ + /////////////////////////////////////////////////////// + // 一時オブジェクトを破棄 + /////////////////////////////////////////////////////// + if( !useTempObject ) return; + + for(int i2=ParmsNum-1;i2>=0;i2--){ + if( useTempParameters[i2] ){ + if( types[i2].IsStruct() ){ + // 構造体の一時メモリ + + //メモリを解放する + + pobj_sf->pop( REG_RCX ); + + //call free + extern UserProc *pSub_free; + op_call(pSub_free); + } + else{ + pobj_sf->pop(); + pobj_sf->pop(); + } + } + } +} + +void ParamImpl::SetStructParameter( int reg, const Type &baseType, const char *expression ){ + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + int object_size = baseType.GetClass().GetSize(); + + //mov rcx,object_size + op_mov_RV(sizeof(_int64),REG_RCX,object_size); + + //call calloc + extern UserProc *pSub_calloc; + op_call(pSub_calloc); + + //mov r11,rax + op_mov_RR(REG_R11,REG_RAX); + + //mov qword ptr[rsp+offset],r11 ※スタックフレームを利用 + pobj_sf->push(REG_R11); + + + Type calcType; + BOOL bUseHeap; + int temp_reg=REG_RAX; + NumOpe( &temp_reg, + expression, + baseType, + calcType, + &bUseHeap ); + + + //mov r11,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->ref(REG_R11); + + + RELATIVE_VAR RelativeVar; + RelativeVar.bOffsetOffset=0; + RelativeVar.offset=0; + RelativeVar.dwKind=VAR_DIRECTMEM; + + SetStructVariableFromRax( + baseType, + calcType, + &RelativeVar,bUseHeap); + + + //mov r11,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R11); + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + + //mov reg,r11 + op_mov_RR(reg,REG_R11); +} + + +void ParamImpl::SetParameter( const string &procName, const Parameters ¶ms, int SecondParmNum ){ + if( SecondParmNum == -1 ) SecondParmNum = (int)params.size(); + + /////////////////////////////////////////////////////////// + // パラメータをレジスタ及びスタックフレームにセット + /////////////////////////////////////////////////////////// + int i2,i3; + + BOOL bEllipse; + if( params.size() ){ + if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1; + else bEllipse=0; + } + else bEllipse=0; + + BOOL bHas_System_LocalThis=0; + if(ParmsNum>=1){ + if( params[0]->GetVarName() == "_System_LocalThis" ){ + bHas_System_LocalThis=1; + } + } + + //戻り値用の変数名を取得 + const char *lpszVarNameToReturn = (procName[0]==1&&procName[1]==ESC_OPERATOR)?"_System_ReturnValue":procName.c_str(); + + //パラメータをレジスタとスタックに格納 + int ParmSize=0; + int reg,temp_reg; + RELATIVE_VAR RelativeVar; + for(i2=ParmsNum-1;i2>=0;i2--){ + if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0; + + if(i2==0){ + if( params[i2]->GetVarName() == "_System_LocalThis" ){ + //オブジェクトメンバの第一パラメータのThisポインタ + continue; + } + } + if(i2==0||i2==1){ + if( params[i2]->GetVarName() == lpszVarNameToReturn ){ + //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト + continue; + } + } + + Type dummyType; + BOOL bByVal; + if(bEllipse){ + NumOpe_GetType( Parms[i2], Type(), dummyType ); + bByVal=1; + } + else{ + dummyType = *params[i2]; + bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE; + } + + int xmm_temp_sw=0; + if(dummyType.IsReal()&&bByVal){ + //実数型 + if(i2==0) reg=REG_XMM0; + else if(i2==1) reg=REG_XMM1; + else if(i2==2) reg=REG_XMM2; + else if(i2==3) reg=REG_XMM3; + else{ + reg=REG_XMM0; + xmm_temp_sw=1; + } + } + else{ + //整数型 + if(i2==0) reg=REG_RCX; + else if(i2==1) reg=REG_RDX; + else if(i2==2) reg=REG_R8; + else if(i2==3) reg=REG_R9; + else reg=REG_RAX; + } + + if(bByVal==1){ + //値参照 + + if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){ + char temp2[255]; + sprintf(temp2,"%s関数の第%dパラメータ",procName,i2+1); + SetError(19,temp2,cp); + continue; + } + + if( dummyType.IsStruct() ){ + SetStructParameter( reg, dummyType, Parms[i2] ); + goto next; + } + + temp_reg=reg; + + extern LONG_PTR ProcPtr_BaseIndex; + LONG_PTR back_ProcPtr_BaseIndex = ProcPtr_BaseIndex; + if( dummyType.IsProcPtr() ){ + ProcPtr_BaseIndex = dummyType.GetIndex(); + } + else{ + ProcPtr_BaseIndex=-1; + } + + BOOL bCalcUseHeap; + Type calcType; + if( !NumOpe( &temp_reg, Parms[i2], dummyType, calcType, &bCalcUseHeap ) ){ + break; + } + + ProcPtr_BaseIndex=back_ProcPtr_BaseIndex; + + if( calcType.IsObject() ){ + if( !dummyType.IsObject() + || + dummyType.IsObject() && + !dummyType.GetClass().IsEqualsOrSubClass( &calcType.GetClass() ) ){ + //キャスト演算子のオーバーロードに対応する + CallCastOperatorProc( reg, calcType, bCalcUseHeap,dummyType ); + } + } + + + if(bEllipse){ + if( calcType.IsReal() ){ + //整数レジスタへコピー + //※cdeclの拡張パラメータは実数の場合も汎用レジスタで引渡し + + if(0<=i2&&i2<=3){ + if(i2==0) reg=REG_RCX; + else if(i2==1) reg=REG_RDX; + else if(i2==2) reg=REG_R8; + else if(i2==3) reg=REG_R9; + + //movd reg,temp_reg + op_movd_RX(reg,temp_reg); + } + } + else if( calcType.IsWhole() ){ + //整数型の場合は、64ビットへ拡張する + ExtendTypeTo64( calcType.GetBasicType(), temp_reg ); + } + } + else{ + //型チェック + // TODO: _System_ReturnValueが考慮されていない？ + if(bHas_System_LocalThis) i3=i2-1; + else i3=i2; + CheckDifferentType( + dummyType, + calcType, + procName.c_str(), + i3); + + if( dummyType.IsDouble() ){ + //Double型へ変換 + ChangeTypeToXmm_Double(calcType.GetBasicType(),reg,temp_reg); + } + else if( dummyType.IsSingle() ){ + //Single型へ変換 + ChangeTypeToXmm_Single(calcType.GetBasicType(),reg,temp_reg); + } + else if( dummyType.IsWhole() ){ + //実数型 → 整数型 + ChangeTypeToWhole(calcType.GetBasicType(),dummyType.GetBasicType(),reg,temp_reg); + } + } + } + else{ + //ポインタ参照 + if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){ + //ポインタ指定 + + temp_reg=reg; + Type calcType; + if( !NumOpe(&temp_reg, Parms[i2]+2, dummyType, calcType) ){ + break; + } + + dummyType.PtrLevelUp(); + + //型チェック + if(bHas_System_LocalThis) i3=i2-1; + else i3=i2; + CheckDifferentType( + dummyType, + calcType, + procName.c_str(), + i3); + + if( calcType.IsReal() ){ + //実数型 → 整数型 + ChangeTypeToWhole( calcType.GetBasicType(), DEF_QWORD,reg,temp_reg); + } + } + else{ + if( useTempParameters[i2] ){ + //一時オブジェクトをコピー + + //mov reg, qword ptr[rsp+offset] + pobj_sf->ref_offset_data( reg, StackOffsetOfTempObject[i2] ); + } + else{ + //変数のアドレスを取得 + Type varType; + if(GetVarOffset( + false, + false, + Parms[i2], + &RelativeVar, + varType)){ + + if( !dummyType.IsAny() ){ + //型チェックを行う + if( dummyType.GetBasicType() == varType.GetBasicType() ){ + if( dummyType.IsObject() ){ + if( !dummyType.GetClass().IsEqualsOrSubClass( &varType.GetClass() ) ){ + SetError(11,Parms[i2],cp); + } + } + else if( dummyType.IsStruct() ){ + if( !dummyType.GetClass().IsEquals( &varType.GetClass() ) ){ + SetError(11,Parms[i2],cp); + } + } + } + else if( (varType.GetBasicType()&FLAG_PTR) + &&((varType.GetBasicType()^FLAG_PTR)==dummyType.GetBasicType())){ + //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき + } + else{ + SetError(11,Parms[i2],cp); + } + } + + //変数アドレスをレジスタにセット + SetVarPtrToReg(reg,&RelativeVar); + + } + } + } + } + +next: + + if(reg==REG_RAX){ + //スタックフレームへコピー + //mov qword ptr[rsp+offset],rax + op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,i2*sizeof(_int64),MOD_BASE_DISP32); + } + else if(xmm_temp_sw){ + //スタックフレームへコピー + + //movlpd qword ptr[rsp+offset],xmm0 + op_movlpd_MR(REG_XMM0,REG_RSP,i2*sizeof(_int64),MOD_BASE_DISP32); + } + + + ///////////////////// + // レジスタをロック + ///////////////////// + + if(0<=i2&&i2<=3){ + // ※rcx, rdx, r8, r9の場合のみ + pobj_BlockReg->lock(reg); + } + } + + //パラメータが収まるだけのスタックフレームを確保 + pobj_sf->parameter_allocate((int)params.size()*sizeof(_int64)+ sizeof(_int64)/*ret用*/ ); +} +void ParamImpl::BackupParameter(int pi_num){ + /////////////////////////////////////////////////////////// + // スタックフレームに存在する既存のパラメータをバックアップ + /////////////////////////////////////////////////////////// + int i2; + + for(i2=0;i2push(REG_R14); + } + + if(3=0;i2--){ + ///////////////////// + // 復元 + ///////////////////// + + if(3pop(REG_R14); + + //mov qword ptr[rsp+offset],r14 + op_mov_MR(sizeof(_int64),REG_R14,REG_RSP,i2*sizeof(_int64),MOD_BASE_DISP32); + } + } +} Index: trunk/abdev/BasicCompiler64/CommandValue.h =================================================================== --- trunk/abdev/BasicCompiler64/CommandValue.h (revision 149) +++ trunk/abdev/BasicCompiler64/CommandValue.h (revision 149) @@ -0,0 +1,96 @@ +/* 命令語定数 */ + +//条件、分岐、繰り返し +#define COM_DO 0x1021 +/* 0x22は「"」なので使用不可 */ +#define COM_GOTO 0x1023 +#define COM_GOSUB 0x1024 +#define COM_LOOP 0x1026 +#define COM_RETURN 0x1027 +/* 0x28は「(」なので使用不可 */ +/* 0x29は「)」なので使用不可 */ +#define COM_FOR 0x1031 +#define COM_NEXT 0x1032 +#define COM_WHILE 0x1036 +#define COM_WEND 0x1037 + +//データ操作 +#define COM_DIM 0x1062 +#define COM_LET 0x1066 +#define COM_DELETE 0x1068 +#define COM_SWEEPINGDELETE 0x1069 + +//その他 +#define COM_DEBUG 0x1073 + +//ポインタ +#define COM_SETDOUBLE 0x10C1 +#define COM_SETSINGLE 0x10C2 +#define COM_SETQWORD 0x10C3 +#define COM_SETDWORD 0x10C4 +#define COM_SETWORD 0x10C5 +#define COM_SETBYTE 0x10C6 + + + +/////////////////////////////////// +// 以下はProjectEditorで使用される + +//入出力コマンド +#define COM_PRINT 0x1150 +#define COM_INPUT 0x1151 +#define COM_OPEN 0x1152 +#define COM_CLOSE 0x1153 +#define COM_FIELD 0x1154 +#define COM_WRITE 0x1155 + +//条件、分岐、繰り返し +#define COM_IF 0x1160 +#define COM_SELECT 0x1161 + +//ファイル操作 +#define COM_CHDIR 0x1170 +#define COM_KILL 0x1171 +#define COM_MKDIR 0x1172 +#define COM_GET 0x1173 +#define COM_PUT 0x1174 + +//グラフィックス +#define COM_CIRCLE 0x1180 +#define COM_LINE 0x1181 +#define COM_PAINT 0x1182 +#define COM_PSET 0x1183 + +//データ操作 +#define COM_CONST 0x1190 +#define COM_TYPEDEF 0x1191 + +//クラス関連 +#define COM_CLASS 0x1195 +#define COM_PRIVATE 0x1196 +#define COM_PUBLIC 0x1197 +#define COM_INHERITS 0x1198 +#define COM_PROTECTED 0x1199 + +//その他 +#define COM_BEEP 0x11A0 +#define COM_CLS 0x11A1 +#define COM_COLOR 0x11A2 +#define COM_DECLARE 0x11A4 +#define COM_DEF 0x11A5 +#define COM_END 0x11A6 +#define COM_FUNCTION 0x11A7 +#define COM_LOCATE 0x11A8 +#define COM_RANDOMIZE 0x11A9 +#define COM_REM 0x11AA +#define COM_SLEEP 0x11AB +#define COM_SUB 0x11AC +#define COM_TYPE 0x11AD +#define COM_VIRTUAL 0x11AE +#define COM_WITH 0x11AF +#define COM_ENUM 0x11B0 + +//ウィンドウ制御 +#define COM_DELWND 0x11C0 +#define COM_MSGBOX 0x11C1 +#define COM_WINDOW 0x11C2 Index: trunk/abdev/BasicCompiler64/Compile_Calc.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Compile_Calc.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Compile_Calc.cpp (revision 149) @@ -0,0 +1,259 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +void SetVariableFromRax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){ + ///////////////////////////////////////////////// + // raxの内容を変数にコピーするコードを抽出 + ///////////////////////////////////////////////// + + if(VarType==DEF_BOOLEAN){ + //bool + SetBooleanVariable(CalcType,pRelativeVar); + } + else if( IsRealNumberType( VarType ) ){ + // Double/Single型変数へレジスタの値を代入 + SetRealVariable(VarType, CalcType, pRelativeVar); + } + else if( IsWholeNumberType( VarType ) || VarType == DEF_OBJECT ){ + int typeSize = GetTypeSize( VarType, -1 ); + + //整数変数へraxの値を格納する + SetWholeVariable( typeSize, CalcType, pRelativeVar ); + } + else{ + SetError(300,NULL,cp); + } +} +void OpcodeCalc(const char *Command){ + int i,i2,i3; + char variable[VN_SIZE]; + + + + ////////////////////////////////////// + // インクリメント・デクリメント + ////////////////////////////////////// + + for(i=0;;i++){ + if(Command[i]=='\"'){ + //ダブルクォートは不正なのでエラー扱い + variable[i]=0; + SetError(3,variable,cp); + return; + } + + if(Command[i]=='('){ + i2=GetStringInPare(variable+i,Command+i); + i+=i2-1; + continue; + } + if(Command[i]=='['){ + i2=GetStringInBracket(variable+i,Command+i); + i+=i2-1; + continue; + } + if(Command[i]=='\0'){ + + /////////////////////////////////// + // インクリメント・デクリメント + /////////////////////////////////// + + if(i>2){ + if(Command[i-2]=='+'&&Command[i-1]=='+'){ + //インクリメント + variable[i-2]=0; + IncDec(CALC_ADDITION,variable,"1"); + return; + } + else if(Command[i-2]=='-'&&Command[i-1]=='-'){ + //デクリメント + variable[i-2]=0; + IncDec(CALC_SUBTRACTION,variable,"1"); + return; + } + } + + + //先端部分の識別子をエラーキーワードにする + for(i=0;;i++){ + if(!IsVariableChar(Command[i])){ + variable[i]=0; + break; + } + variable[i]=Command[i]; + } + + if(GetVarType(variable,Type(),0)){ + //変数リストに該当したとき + SetError(1,NULL,cp); + } + else{ + if(GetConstHash(variable)){ + //定数リストに該当したとき + SetError(1,NULL,cp); + } + else{ + //変数リスト、定数リストに該当しないとき + SetError(3,variable,cp); + } + } + return; + } + + i2=GetCalcId(Command+i,&i3); + if(i2){ + variable[i]=0; + + if(Command[i]=='=') break; + + if(Command[i+1+i3]=='='){ + IncDec(i2,variable,Command+i+1+i3+1); + return; + } + } + + variable[i]=Command[i]; + } + + if(Command[i+1]=='\0'){ + SetError(1,NULL,cp); + return; + } + + + + /////////////////////////////////////////////////////////////// + // インデクサのsetアクセサ（[]=演算子のオーバーロードに対応） + /////////////////////////////////////////////////////////////// + + char ObjName[VN_SIZE],array_element[VN_SIZE]; + GetArrayElement(variable,ObjName,array_element); + if(array_element[0]){ + Type varType; + if( GetVarType(ObjName,varType,0) && varType.IsObject() ){ + char temporary[VN_SIZE]; + sprintf(temporary,"%s.%c%c%c",ObjName,1,ESC_OPERATOR,CALC_ARRAY_SET); + + char temp2[VN_SIZE]; + sprintf(temp2,"%s,%s",array_element,Command+i+1); + + int idProc; + void *pProc; + idProc=GetProc(temporary,(void **)&pProc); + if(idProc){ + CallProc(idProc,pProc,temporary,temp2,Type()); + return; + } + } + } + + + if( lstrcmpi( variable, "This" ) == 0 ){ + SetError(133,NULL,cp); + return; + } + + + //////////////////////////////////////// + // 変数のタイプ型を識別して、演算を行う + //////////////////////////////////////// + + Type varType; + + //型を識別 + if( !GetVarType(variable,varType,false) ){ + + // プロパティ用のメソッドを呼び出す + if(!CallPropertyMethod( variable, Command+i+1, Type() )){ + //エラーを表示 + GetVarType(variable,varType,true); + } + + return; + } + + extern LONG_PTR ProcPtr_BaseIndex; + if(varType.IsProcPtr()) ProcPtr_BaseIndex=varType.GetIndex(); + else ProcPtr_BaseIndex=-1; + + //NumOpe...（rax、またはxmm0に答えが格納される） + int reg=REG_RAX; + BOOL bCalcUseHeap; + Type calcType; + if( !NumOpe(®,Command+i+1,varType,calcType,&bCalcUseHeap) ){ + return; + } + + if(reg!=REG_RAX&&calcType.IsWhole()|| + varType.IsNull()||calcType.IsNull()){ + SetError(300,NULL,cp); + } + + //結果を格納しているレジスタをブロッキング + pobj_BlockReg->lock(reg); + + //変数アドレスを取得 + RELATIVE_VAR VarRelativeVar; + if(!GetVarOffsetReadWrite( + variable, + &VarRelativeVar, + varType)) return; + + //レジスタのブロッキングを解除 + pobj_BlockReg->clear(); + + if(varType.GetBasicType()&FLAG_PTR){ + SetError(14,variable,cp); + return; + } + + if( varType.IsStruct() ){ + //構造体インスタンスへの代入 + SetStructVariableFromRax(varType,calcType,&VarRelativeVar,bCalcUseHeap); + return; + } + + if( calcType.IsObject() && !calcType.Equals( varType ) ){ + bool isUpCast = false; + if( varType.IsObject() ){ + if( varType.GetClass().IsEqualsOrSubClass( &calcType.GetClass() ) ){ + isUpCast = true; + } + } + if( !isUpCast ){ + //キャスト演算子のオーバーロードに対応する + CallCastOperatorProc(REG_RAX,calcType,bCalcUseHeap,varType); + } + } + + if( varType.IsObject() && Smoothie::Meta::blittableTypes.IsExist( calcType ) ){ + // Blittable型をオブジェクトとして扱う + vector userProcs; + Smoothie::Meta::blittableTypes.GetClass( calcType ).GetStaticMethods().Enum( "_Create", userProcs ); + if( userProcs.size() != 1 ){ + SetError(); + return; + } + UserProc *pUserProc = userProcs[0]; + + // mov rcx, rax + op_mov_RR( REG_RCX, REG_RAX ); + + // call System.[TypeClass]._Create + op_call( pUserProc ); + + calcType = pUserProc->ReturnType(); + } + + ///////////////////////////////// + // 右辺、左辺の型チェックを行う + ///////////////////////////////// + + CheckDifferentType(varType,calcType,0,0); + + + ///////////////////////////////////////////////// + // rax（実数はxmm0）の内容を変数にコピー + ///////////////////////////////////////////////// + SetVariableFromRax(varType.GetBasicType(),calcType.GetBasicType(),&VarRelativeVar); +} Index: trunk/abdev/BasicCompiler64/Compile_Calc_PushVar.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Compile_Calc_PushVar.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Compile_Calc_PushVar.cpp (revision 149) @@ -0,0 +1,253 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + + +void SetXmmReg_DoubleVariable(RELATIVE_VAR *pRelativeVar,int xmm_reg){ + if(pRelativeVar->dwKind==VAR_GLOBAL){ + if(pRelativeVar->bOffsetOffset){ + //movlpd xmm_reg,qword ptr[r11+offset] + OpBuffer[obp++]=(char)0x66; + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x12; + OpBuffer[obp++]=(char)(0x83 | REGISTER_OPERAND(xmm_reg)<<3); + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + else{ + //movlpd xmm_reg,qword ptr[offset] + OpBuffer[obp++]=(char)0x66; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x12; + OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3); + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + } + else if( pRelativeVar->dwKind == VAR_REFGLOBAL ){ + SetError(300,NULL,cp); + } + else if(pRelativeVar->dwKind==VAR_LOCAL){ + if(pRelativeVar->bOffsetOffset){ + //movlpd xmm_reg,qword ptr[rsp+r11+offset] + OpBuffer[obp++]=(char)0x66; + OpBuffer[obp++]=(char)0x42; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x12; + OpBuffer[obp++]=(char)(0x84 | REGISTER_OPERAND(xmm_reg)<<3); + OpBuffer[obp++]=(char)0x1C; + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //movlpd xmm_reg,qword ptr[rsp+offset] + OpBuffer[obp++]=(char)0x66; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x12; + OpBuffer[obp++]=(char)(0x84 | REGISTER_OPERAND(xmm_reg)<<3); + OpBuffer[obp++]=(char)0x24; + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + } + else if( pRelativeVar->dwKind == VAR_REFLOCAL ){ + if(pRelativeVar->bOffsetOffset){ + //add r11,qword ptr[rsp+offset] + OpBuffer[obp++]=(char)0x4C; + OpBuffer[obp++]=(char)0x03; + OpBuffer[obp++]=(char)0x9C; + OpBuffer[obp++]=(char)0x24; + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //mov r11,qword ptr[rsp+offset] + op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + + goto directmem; + } + else if(pRelativeVar->dwKind==VAR_DIRECTMEM){ +directmem: + //movlpd xmm_reg,qword ptr[r11] + OpBuffer[obp++]=(char)0x66; + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x12; + OpBuffer[obp++]=(char)(0x03 | REGISTER_OPERAND(xmm_reg)<<3); + } +} +void SetXmmReg_SingleVariable(RELATIVE_VAR *pRelativeVar,int xmm_reg){ + if(pRelativeVar->dwKind==VAR_GLOBAL){ + if(pRelativeVar->bOffsetOffset){ + //movss xmm_reg,dword ptr[r11+offset] + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x10; + OpBuffer[obp++]=(char)(0x83 | REGISTER_OPERAND(xmm_reg)<<3); + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + else{ + //movss xmm_reg,dword ptr[offset] + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x10; + OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3); + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + } + else if( pRelativeVar->dwKind == VAR_REFGLOBAL ){ + SetError(300,NULL,cp); + } + else if(pRelativeVar->dwKind==VAR_LOCAL){ + if(pRelativeVar->bOffsetOffset){ + //movss xmm_reg,dword ptr[rsp+r11+offset] + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x42; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x10; + OpBuffer[obp++]=(char)(0x84 | REGISTER_OPERAND(xmm_reg)<<3); + OpBuffer[obp++]=(char)0x1C; + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //movss xmm_reg,dword ptr[rsp+offset] + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x10; + OpBuffer[obp++]=(char)(0x84 | REGISTER_OPERAND(xmm_reg)<<3); + OpBuffer[obp++]=(char)0x24; + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + } + else if( pRelativeVar->dwKind == VAR_REFLOCAL ){ + if(pRelativeVar->bOffsetOffset){ + //add r11,qword ptr[rsp+offset] + OpBuffer[obp++]=(char)0x4C; + OpBuffer[obp++]=(char)0x03; + OpBuffer[obp++]=(char)0x9C; + OpBuffer[obp++]=(char)0x24; + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //mov r11,qword ptr[rsp+offset] + op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + + goto directmem; + } + else if(pRelativeVar->dwKind==VAR_DIRECTMEM){ +directmem: + //movss xmm_reg,dword ptr[r11] + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x10; + OpBuffer[obp++]=(char)(0x03 | REGISTER_OPERAND(xmm_reg)<<3); + } +} + + +void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg){ + int varSize; + + varSize=GetTypeSize(type,-1); + + if(pRelativeVar->dwKind==VAR_GLOBAL){ + if(pRelativeVar->bOffsetOffset){ + //mov reg, ptr[r11+offset] + op_mov_RM(varSize,reg,REG_R11,(int)pRelativeVar->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + else{ + //mov reg, ptr[offset] + op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset,MOD_DISP32); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + } + else if( pRelativeVar->dwKind == VAR_REFGLOBAL ){ + if(pRelativeVar->bOffsetOffset){ + //add r11,qword ptr[offset] + op_add_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + else{ + //mov r11,qword ptr[offset] + op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + + goto directmem; + } + else if(pRelativeVar->dwKind==VAR_LOCAL){ + if(pRelativeVar->bOffsetOffset){ + //mov reg, ptr[rsp+r11+offset] + op_mov_RM_ex(varSize,reg,REG_RSP,REG_R11,(int)pRelativeVar->offset,USE_OFFSET); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //mov reg, ptr[rsp+offset] + op_mov_RM(varSize,reg,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + } + else if( pRelativeVar->dwKind == VAR_REFLOCAL ){ + if(pRelativeVar->bOffsetOffset){ + //add r11,qword ptr[rsp+offset] + op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //mov r11,qword ptr[rsp+offset] + op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + + goto directmem; + } + else if(pRelativeVar->dwKind==VAR_DIRECTMEM){ +directmem: + //mov reg, ptr[r11] + op_mov_RM(varSize,reg,REG_R11,0,MOD_BASE); + } +} Index: trunk/abdev/BasicCompiler64/Compile_CallProc.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Compile_CallProc.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Compile_CallProc.cpp (revision 149) @@ -0,0 +1,458 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +//ローカル変数アドレススケジュール +DWORD *pLocalVarAddrSchedule; +int LocalVarAddrScheduleNum; + +void Call_DebugSys_SaveContext(){ + //call _System_GetEip + extern UserProc *pSub_System_GetEip; + op_call(pSub_System_GetEip); + + //mov rdx,rax + op_mov_RR(REG_RDX,REG_RAX); + + //mov rcx,rsp + op_mov_RR(REG_RCX,REG_RSP); + + //call _DebugSys_SaveContext + extern UserProc *pSub_DebugSys_SaveContext; + op_call(pSub_DebugSys_SaveContext); +} + +void AddLocalVarAddrSchedule(){ + extern HANDLE hHeap; + + //ローカル変数アドレススケジュールに追加する + pLocalVarAddrSchedule=(DWORD *)HeapReAlloc(hHeap,0,pLocalVarAddrSchedule,(LocalVarAddrScheduleNum+1)*sizeof(DWORD)); + pLocalVarAddrSchedule[LocalVarAddrScheduleNum]=obp; + LocalVarAddrScheduleNum++; +} + + +bool Opcode_CallProcPtr( const char *variable, const char *lpszParms,ProcPointer *pProcPointer){ + + extern BOOL bDebugCompile; + extern BOOL bDebugSupportProc; + if(bDebugCompile&&bDebugSupportProc==0) + Call_DebugSys_SaveContext(); + + + //////////////////////// + // パラメータのセット + //////////////////////// + + //パラメータオブジェクトを生成 + ParamImpl *pobj_parameter=0; + pobj_parameter=new ParamImpl(lpszParms); + + // デフォルト引数を適用 + pobj_parameter->ApplyDefaultParameters( pProcPointer->Params() ); + + //エラーチェック + if( !pobj_parameter->ErrorCheck(variable,pProcPointer->Params() ) ){ + //パラメータにエラーがあるときは処理を終える + return false; + } + + //スタックフレームに存在する既存のパラメータをバックアップ + pobj_parameter->BackupParameter( (int)pProcPointer->Params().size() ); + + //一時オブジェクトを生成 + pobj_parameter->NewTempParameters( variable,pProcPointer->Params() ); + + //レジスタ、スタックフレームにセット + pobj_parameter->SetParameter(variable,pProcPointer->Params() ); + + + + RELATIVE_VAR RelativeVar; + GetVarOffsetReadOnly(variable,&RelativeVar,Type()); + SetVarPtrToReg(REG_RAX,&RelativeVar); + + //mov rax,qword ptr[rax] + op_mov_RM(sizeof(_int64),REG_RAX,REG_RAX,0,MOD_BASE); + + //call rax + OpBuffer[obp++]=(char)0xFF; + OpBuffer[obp++]=(char)0xD0; + + + //レジスタのブロッキングを解除 ※パラメータセット時にロックされたレジスタ + pobj_BlockReg->clear(); + + //一時オブジェクトを破棄 + pobj_parameter->DeleteTempParameters(); + + //スタックフレームに存在する既存のパラメータを復元 + pobj_parameter->RestoreParameter( (int)pProcPointer->Params().size() ); + + //パラメータオブジェクトを破棄 + delete pobj_parameter; + + return true; +} + +bool Opcode_CallProc(const char *Parameter,UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType){ + // TODO: RefTypeは不必要なので削除する + int i2; + + if( pUserProc->IsMacro() ){ + if( lstrcmpi( pUserProc->GetName().c_str(), "Print" ) == 0 ){ + Opcode_Print(Parameter,0); + return true; + } + if( lstrcmpi( pUserProc->GetName().c_str(), "Input" ) == 0 ){ + Opcode_Input(Parameter); + return true; + } + if( lstrcmpi( pUserProc->GetName().c_str(), "Write" ) == 0 ){ + Opcode_Print(Parameter,1); + return true; + } + } + + pUserProc->Using(); + + bool isStatic = false; + const CClass *pobj_c = NULL; + const CMethod *pMethod = NULL; + if( pUserProc->GetParentClassPtr() ){ + //クラスのメンバ関数を呼び出す場合はアクセスチェックを行う + if(ObjectName[0] && (dwFlags&PROCFLAG_NEW)==0){ + if(lstrcmpi(ObjectName,"Super")==0){ + //クラスメンバ関数内から基底クラスの呼び出し + pobj_c=pobj_CompilingClass; + } + else{ + //"->"によってオブジェクトを指定する通常のメンバ関数呼び出し + Type varType; + GetVarType( ObjectName, varType, false ); + pobj_c = &varType.GetClass(); + if( NATURAL_TYPE( varType.GetBasicType() ) != DEF_OBJECT ){ + pobj_c=pobj_DBClass->Find(ObjectName); + if( pobj_c ){ + isStatic = true; + } + else{ + SetError(300,NULL,cp); + } + } + } + } + else{ + if(dwFlags&PROCFLAG_NEW){ + //New演算子によるコンストラクタ呼び出し + pobj_c=pUserProc->GetParentClassPtr(); + } + else{ + //クラスメンバ関数内から同一クラスのメンバ関数の呼び出し + pobj_c=pobj_CompilingClass; + } + } + + + ///////////////////////////////// + // メソッド情報を取得 + ///////////////////////////////// + pMethod = NULL; + if( ! isStatic ) pMethod = pobj_c->GetMethods().GetMethodPtr( pUserProc ); + if( ! pMethod ){ + //動的メソッドが取得できなかったときは静的メソッドを当たる + pMethod = pobj_c->GetStaticMethods().GetMethodPtr( pUserProc ); + if( !pMethod ){ + SetError(300,NULL,cp); + return false; + } + + //静的メンバ + isStatic = true; + } + + + ////////////////////////////// + // アクセスエラーチェック + ////////////////////////////// + + if(ObjectName[0]){ + //外部からの呼び出し + if(pobj_c==pobj_CompilingClass){ + //同一クラスオブジェクトの場合はプライベートアクセスを容認する + if( pMethod->IsNoneAccess() ){ + SetError(109,pUserProc->GetName(),cp); + return false; + } + } + else{ + if( pMethod->IsPrivate() + || pMethod->IsNoneAccess() ){ + SetError(109,pUserProc->GetName(),cp); + return false; + } + if( pMethod->IsProtected() ){ + SetError(110,pUserProc->GetName(),cp); + return false; + } + } + } + else{ + //クラス内部からの呼び出し（継承によるACCESS_NONのみをエラーとする） + if( pMethod->IsNoneAccess() ){ + SetError(109,pUserProc->GetName(),cp); + return false; + } + } + } + + + /////////////////////////////////////////////////////////////// + // _System_LocalThisのダミーをセット + /////////////////////////////////////////////////////////////// + + char temporary[VN_SIZE]={0}; + if( pUserProc->GetParentClassPtr() && isStatic == false ){ + //_System_LocalThis（第一パラメータ）のダミーを作成 + lstrcpy(temporary,"0,"); + } + + if(Parameter[0]=='\0'&&temporary[0]) + temporary[lstrlen(temporary)-1]=0; + else lstrcat(temporary,Parameter); + + + //パラメータセット前のspオフセットを取得（Newの場合はここにThisポインタが格納されている） + int this_sp_offset = pobj_sf->GetNowSp(); + + + //////////////////////// + // パラメータをセット + //////////////////////// + + //パラメータオブジェクトを生成 + ParamImpl *pobj_parameter=0; + pobj_parameter=new ParamImpl(temporary); + + // デフォルト引数を適用 + pobj_parameter->ApplyDefaultParameters( pUserProc->RealParams() ); + + //エラーチェック + if( !pobj_parameter->ErrorCheck(pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetSecondParmNum() ) ){ + //パラメータにエラーがあるときは処理を終える + return false; + } + + if(pUserProc->IsMacro()){ + //マクロ関数の場合は、パラメータ省略を考慮する + pobj_parameter->MacroParameterSupport( pUserProc->RealParams() ); + } + + //スタックフレームに存在する既存のパラメータをバックアップ + pobj_parameter->BackupParameter( (int)pUserProc->RealParams().size() ); + + //一時オブジェクトを生成 + pobj_parameter->NewTempParameters( pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetRealSecondParmNum() ); + + //レジスタ、スタックフレームにセット + pobj_parameter->SetParameter(pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetRealSecondParmNum() ); + + if(pUserProc->ReturnType().IsStruct() ){ + ////////////////////////////////////////////////////// + // 戻り値に構造体インスタンスを持つ場合 + // ※ByRef _System_ReturnValue パラメータをセット + ////////////////////////////////////////////////////// + + + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + int object_size = pUserProc->ReturnType().GetClass().GetSize(); + + //mov rcx,object_size + op_mov_RV(sizeof(_int64),REG_RCX,object_size); + + //call calloc + extern UserProc *pSub_calloc; + op_call(pSub_calloc); + + //mov r13,rax + op_mov_RR(REG_R13,REG_RAX); + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + + if( pUserProc->GetParentClassPtr() && isStatic == false ){ + //mov rdx,r13 + op_mov_RR(REG_RDX,REG_R13); + } + else{ + //mov rcx,r13 + op_mov_RR(REG_RCX,REG_R13); + } + } + + + if( pUserProc->GetParentClassPtr() && isStatic == false ){ + /////////////////////////////// + // メンバ関数の場合 + // thisポインタをrcxで受け渡す + /////////////////////////////// + + if(ObjectName[0] && (dwFlags&PROCFLAG_NEW)==0){ + if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember; + else{ + RELATIVE_VAR RelativeVar; + if( pMethod->IsConst() ){ + //Constアクセスが可能なメソッドの場合 + if( !GetVarOffsetReadOnly( ObjectName, &RelativeVar, Type() ) ){ + return false; + } + } + else{ + //Constアクセスが不可能なメソッドの場合 + if( !GetVarOffsetReadWrite( ObjectName, &RelativeVar, Type() ) ){ + return false; + } + } + + SetVarPtrToReg(REG_RCX,&RelativeVar); + + // 参照を実体ポインタにする + //mov rcx,qword ptr[rcx] + op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE); + } + } + else{ +InClassMember: + if(dwFlags&PROCFLAG_NEW){ + //New演算子によるコンストラクタ呼び出しの場合 + + //mov rcx,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->ref_offset_data(REG_RCX, this_sp_offset); + } + else{ + //自身のオブジェクトのThisポインタをrcxにコピー + SetThisPtrToReg(REG_RCX); + } + } + } + + if( pUserProc->IsVirtual() ){ + //仮想関数（オブジェクトメソッド）呼び出し + //pObj->func_table->func1 + // ->func2 + // ->func3 + + //mov r11,qword ptr[rcx] + op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE); + + i2 = pobj_c->GetFuncNumInVtbl( pUserProc ); + + //call qword ptr[r11+func_index] + if(i2*PTR_SIZE<=0x7F){ + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)0xFF; + OpBuffer[obp++]=(char)0x53; + OpBuffer[obp++]=(char)(i2*PTR_SIZE); + } + else{ + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)0xFF; + OpBuffer[obp++]=(char)0x93; + *((long *)(OpBuffer+obp))=i2*PTR_SIZE; + obp+=sizeof(long); + } + } + else{ + //通常呼び出し + + //call ProcAddr + op_call(pUserProc); + } + + /* 64コンパイラでは不要 + if(pDllProc->bCdecl){ + //add esp,ParmSize + }*/ + + + //レジスタのブロッキングを解除 ※パラメータセット時にロックされたレジスタ + pobj_BlockReg->clear(); + + //一時オブジェクトを破棄 + pobj_parameter->DeleteTempParameters(); + + //スタックフレームに存在する既存のパラメータを復元 + pobj_parameter->RestoreParameter( (int)pUserProc->RealParams().size() ); + + //パラメータオブジェクトを破棄 + delete pobj_parameter; + + return true; +} + +bool Opcode_CallDllProc( const char *lpszParms, DllProc *pDllProc ){ + + extern BOOL bDebugCompile; + extern BOOL bDebugSupportProc; + if(bDebugCompile&&bDebugSupportProc==0&& pDllProc->GetName() != "DebugBreak" ){ + Call_DebugSys_SaveContext(); + } + + + //////////////////////// + // パラメータのセット + //////////////////////// + + //パラメータオブジェクトを生成 + ParamImpl *pobj_parameter=0; + pobj_parameter=new ParamImpl(lpszParms); + + // デフォルト引数を適用 + pobj_parameter->ApplyDefaultParameters( pDllProc->Params() ); + + //エラーチェック + if( !pobj_parameter->ErrorCheck( pDllProc->GetName(), pDllProc->Params() ) ){ + //パラメータにエラーがあるときは処理を終える + return false; + } + + //スタックフレームに存在する既存のパラメータをバックアップ + pobj_parameter->BackupParameter( (int)pDllProc->Params().size() ); + + //一時オブジェクトを生成 + pobj_parameter->NewTempParameters( pDllProc->GetName(), pDllProc->Params() ); + + //レジスタ、スタックフレームにセット + pobj_parameter->SetParameter(pDllProc->GetName(), pDllProc->Params() ); + + + //レジスタのブロッキングを解除 ※パラメータセット時にロックされたレジスタ + pobj_BlockReg->clear(); + + + //動的リンクされたプロシージャの呼び出し + + //call dword ptr[ImportTable] + op_call( pDllProc ); + + /* 64コンパイラでは不要 + if(pDllProc->bCdecl){ + //add esp,ParmSize + }*/ + + //一時オブジェクトを破棄 + pobj_parameter->DeleteTempParameters(); + + //スタックフレームに存在する既存のパラメータを復元 + pobj_parameter->RestoreParameter( (int)pDllProc->Params().size() ); + + //パラメータオブジェクトを破棄 + delete pobj_parameter; + + return true; +} Index: trunk/abdev/BasicCompiler64/Compile_Func.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Compile_Func.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Compile_Func.cpp (revision 149) @@ -0,0 +1,320 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +int GetFunctionFromName(char *FuncName){ + if(lstrcmpi(FuncName,"Len")==0) return FUNC_LEN; + if(lstrcmpi(FuncName,"AddressOf")==0) return FUNC_ADDRESSOF; + if(lstrcmpi(FuncName,"SizeOf")==0) return FUNC_SIZEOF; + if(lstrcmpi(FuncName,"VarPtr")==0) return FUNC_VARPTR; + if(lstrcmpi(FuncName,"ObjPtr")==0) return FUNC_OBJPTR; + if(lstrcmpi(FuncName,"GetDouble")==0) return FUNC_GETDOUBLE; + if(lstrcmpi(FuncName,"GetSingle")==0) return FUNC_GETSINGLE; + if(lstrcmpi(FuncName,"GetQWord")==0) return FUNC_GETQWORD; + if(lstrcmpi(FuncName,"GetDWord")==0) return FUNC_GETDWORD; + if(lstrcmpi(FuncName,"GetWord")==0) return FUNC_GETWORD; + if(lstrcmpi(FuncName,"GetByte")==0) return FUNC_GETBYTE; + return 0; +} +void Opcode_Func_Len( const char *Parameter ){ + BOOL bArrayHead; + + const char *tempParm=Parameter; + char temporary[VN_SIZE]; + char temp2[32]; + Type type; + if( !GetVarType(Parameter,type,0) ){ + sprintf(temporary,"_System_DummyStr2=%s",Parameter); + OpcodeCalc(temporary); + + lstrcpy(temp2,"_System_DummyStr2"); + tempParm=temp2; + + type.SetType( DEF_OBJECT, pobj_DBClass->GetStringClassPtr() ); + } + + if( type.IsStringClass() ){ + //Stringオブジェクトの場合 + sprintf(temporary,"%s.Length",tempParm); + + int reg=REG_RAX; + NumOpe(®,temporary,Type(),Type()); + return; + } + + int SubScripts[MAX_ARRAYDIM]; + RELATIVE_VAR RelativeVar; + if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,SubScripts)) return; + + if(type.GetBasicType()&FLAG_PTR){ + type.SetBasicType( type.GetBasicType() & ( ~FLAG_PTR ) ); + + bArrayHead=1; + } + else bArrayHead=0; + + int typeSize = type.GetSize(); + + if(bArrayHead) typeSize*=JumpSubScripts(SubScripts); + + //mov rax,TypeSize + op_mov_RV(sizeof(_int64),REG_RAX,typeSize); + + return; +} +void Opcode_Func_AddressOf( const char *name ){ + extern int cp; + UserProc *pUserProc; + + extern LONG_PTR ProcPtr_BaseIndex; + if(ProcPtr_BaseIndex!=-1){ + //左辺の型にのっとり、オーバーロードを解決 + + std::vector subs; + GetOverloadSubHash( name, subs ); + if( subs.size() == 0 ){ + SetError(27,name,cp); + return; + } + + //オーバーロードを解決 + pUserProc=OverloadSolution(name,subs,Smoothie::Meta::procPointers[ProcPtr_BaseIndex]->Params(), Type() ); + + if(!pUserProc){ + SetError(27,name,cp); + return; + } + } + else{ + pUserProc=GetSubHash(name); + if(!pUserProc){ + SetError(27,name,cp); + return; + } + } + + if( pUserProc->IsVirtual() ){ + /////////////////////////////// + // 仮想関数の場合 + // thisポインタをrcxにコピー + /////////////////////////////// + + const CClass *pobj_c; + + char ObjectName[VN_SIZE]; + int RefType; + SplitObjectName(name,ObjectName,&RefType); + + if(ObjectName[0]){ + if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember; + else{ + RELATIVE_VAR RelativeVar; + Type type; + if(!GetVarOffsetReadOnly(ObjectName,&RelativeVar,type)) return; + SetVarPtrToReg(REG_RCX,&RelativeVar); + + //参照タイプが整合しているかをチェック + if(type.GetBasicType()!=RefType) SetError(104,ObjectName,cp); + + if(type.IsObjectPtr()){ + //mov rcx,qword ptr[rcx] + op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE); + } + } + } + else{ +InClassMember: + //自身のオブジェクトのThisポインタをrcxにコピー + SetThisPtrToReg(REG_RCX); + + pobj_c=pobj_CompilingClass; + } + + + //仮想関数（オブジェクトメソッド） + //pObj->func_table->func1 + // ->func2 + // ->func3 + + //mov r11,qword ptr[rcx] + op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE); + + int i2 = pobj_c->GetFuncNumInVtbl( pUserProc ); + + //mov rax,qword ptr[r11+func_index] + if(i2*PTR_SIZE<=0x7F){ + op_mov_RM(sizeof(_int64),REG_RAX,REG_R11,i2*PTR_SIZE,MOD_BASE_DISP8); + } + else{ + op_mov_RM(sizeof(_int64),REG_RAX,REG_R11,i2*PTR_SIZE,MOD_BASE_DISP32); + } + } + else{ + //一般の関数 + + //mov rax,ProcAddr + op_mov_RV(sizeof(_int64),REG_RAX,0); + obp-=sizeof(long); + pobj_SubAddrSchedule->add(pUserProc,0); + obp+=sizeof(long); + } + + pUserProc->Using(); +} +void Opcode_Func_SizeOf( const string &typeName ){ + Type tempType; + if( !Type::StringToType( typeName, tempType ) ){ + SetError(3,typeName,cp); + return; + } + + int typeSize = ( tempType.IsObject() ) ? + tempType.GetClass().GetSize() : tempType.GetSize(); + + //mov rax,size + op_mov_RV(sizeof(_int64),REG_RAX,typeSize); +} +void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn ){ + if( isCallOn == false ){ + // 戻り値の型を取得するだけ + + //変数のアドレスを取得 + if(!GetVarType( Parameter, resultType, true )) return; + + resultType.PtrLevelUp(); + + return; + } + + RELATIVE_VAR RelativeVar; + + //変数のアドレスを取得 + if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return; + + int beforeType = resultType.GetBasicType(); + + resultType.PtrLevelUp(); + + SetVarPtrToReg(REG_RAX,&RelativeVar); + + // TODO: 取り除く（この動きはObjPtrに託す） + /* + if( beforeType == DEF_OBJECT && lstrcmpi( Parameter, "This" ) != 0 ){ + //参照をオブジェクトポインタに変更 + + //mov rax,qword ptr[rax] + op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE ); + + SetError(-120,NULL,cp); + }*/ +} +void Opcode_Func_ObjPtr( const char *Parameter, Type &resultType, bool isCallOn ){ + if( isCallOn == false ){ + // 戻り値の型を取得するだけ + + //変数のアドレスを取得 + if(!GetVarType( Parameter, resultType, true )) return; + + resultType.PtrLevelUp(); + + return; + } + + RELATIVE_VAR RelativeVar; + + //変数のアドレスを取得 + if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return; + + int beforeType = resultType.GetBasicType(); + + resultType.PtrLevelUp(); + + SetVarPtrToReg(REG_RAX,&RelativeVar); + + if( lstrcmpi( Parameter, "This" )==0 ){ + // Thisの場合は特別にオブジェクトポインタが返ってくるので、何もせずに抜ける + } + else if( beforeType == DEF_OBJECT ){ + //参照をオブジェクトポインタに変更 + + //mov rax,qword ptr[rax] + op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE ); + } + else{ + SetError(134,NULL,cp ); + } +} +void Opcode_Func_GetPtrData( const char *Parameter, const int type ){ + int reg=REG_RAX; + Type tempType; + if( !NumOpe(®,Parameter,Type(),tempType) ){ + return; + } + if(!tempType.IsWhole()){ + SetError(11,Parameter,cp); + return; + } + + if(type==DEF_DOUBLE){ + //movlpd xmm0,qword ptr[rax] + op_movlpd_RM(REG_XMM0,REG_RAX,0,MOD_BASE); + } + else if(type==DEF_SINGLE){ + //movss xmm0,dword ptr[rax] + op_movss_RM(REG_XMM0,REG_RAX,0,MOD_BASE); + } + else{ + //mov rax,ptr[rax] + op_mov_RM(GetTypeSize(type,-1),REG_RAX,REG_RAX,0,MOD_BASE); + } +} + +bool Opcode_CallFunc( const char *Parameter, const int FuncNum, Type &resultType, bool isCallOn ){ + switch(FuncNum){ + case FUNC_LEN: + if( isCallOn ) Opcode_Func_Len(Parameter); + resultType.SetBasicType( DEF_LONG ); + break; + case FUNC_ADDRESSOF: + if( isCallOn ) Opcode_Func_AddressOf(Parameter); + resultType.SetBasicType( DEF_PTR_VOID ); + break; + case FUNC_SIZEOF: + if( isCallOn ) Opcode_Func_SizeOf(Parameter); + resultType.SetBasicType( DEF_LONG ); + break; + case FUNC_VARPTR: + Opcode_Func_VarPtr( Parameter, resultType, isCallOn ); + break; + case FUNC_OBJPTR: + Opcode_Func_ObjPtr( Parameter, resultType, isCallOn ); + break; + + case FUNC_GETDOUBLE: + if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DOUBLE); + resultType.SetBasicType( DEF_DOUBLE ); + break; + case FUNC_GETSINGLE: + if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_SINGLE); + resultType.SetBasicType( DEF_SINGLE ); + break; + case FUNC_GETQWORD: + if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_QWORD); + resultType.SetBasicType( DEF_QWORD ); + break; + case FUNC_GETDWORD: + if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DWORD); + resultType.SetBasicType( DEF_DWORD ); + break; + case FUNC_GETWORD: + if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_WORD); + resultType.SetBasicType( DEF_WORD ); + break; + case FUNC_GETBYTE: + if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_BYTE); + resultType.SetBasicType( DEF_BYTE ); + break; + default: + return false; + } + return true; +} Index: trunk/abdev/BasicCompiler64/Compile_Interface.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Compile_Interface.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Compile_Interface.cpp (revision 149) @@ -0,0 +1,6 @@ +#include "../BasicCompiler_Common/common.h" +#include "opcode.h" + +bool CastToInterface( int reg, int vtblReg, const CClass &baseClass, const CClass &interfaceClass ){ + return true; +} Index: trunk/abdev/BasicCompiler64/Compile_Object.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Compile_Object.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Compile_Object.cpp (revision 149) @@ -0,0 +1,309 @@ +#include "../BasicCompiler_Common/common.h" +#include "opcode.h" + +void _call_constructor( const CClass *pobj_c,const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){ + //////////////////////////// + // コンストラクタの呼び出し + //////////////////////////// + + //この関数を使用する場合は、 + //・ebxにオブジェクトの個数（複数個の場合のみ） + //・スタックフレームの先頭参照位置に先頭Thisポインタ + //をセットしておかなければならない + + int jnz_back; + + + //jnzの番地 + jnz_back=obp; + + if(bSomeObjects){ + SetError(); + //mov qword ptr[rsp+offset],rbx ※スタックフレームを利用 + pobj_sf->push(REG_RBX); + + // ※ここでプッシュされた値はコンストラクタのthisポインタとなる + //mov qword ptr[rsp+offset],rax ※スタックフレームを利用 + pobj_sf->push(REG_RAX); + } + + + //////////////////////// + // オーバーロードを解決 + //////////////////////// + + std::vector subs; + pobj_c->GetMethods().Enum( pobj_c->GetName().c_str(), subs ); + + UserProc *pUserProc; + if( subs.size() > 0 ){ + //オーバーロードを解決 + pUserProc=OverloadSolutionWithStrParam(pobj_c->GetName().c_str(), + subs,CreateParameter,""); + + if(!pUserProc) return; + } + + //コンストラクタを呼び出す + Opcode_CallProc(CreateParameter, + pUserProc, + PROCFLAG_NEW,"",0); + + { + // 動的型情報をセットする + // obj._System_SetType( _System_TypeBase.Search( strNamespace, name ) ) + subs.clear(); + pobj_c->GetMethods().Enum( "_System_SetType", subs ); + if( subs.size() == 1 ){ + char temporary[VN_SIZE]; + sprintf( temporary, "ActiveBasic.Core._System_TypeBase.Search(\"\",\"%s\"))", pobj_c->GetName().c_str() ); + + Opcode_CallProc(temporary, + subs[0], + PROCFLAG_NEW,"",0); + } + else{ + SetError(); + } + } + + if(bSomeObjects){ + //mov rax,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_RAX); + + //mov rbx,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_RBX); + + //add eax,TypeSize + OpBuffer[obp++]=(char)0x05; + *((long *)(OpBuffer+obp))=ObjectSize; + obp+=sizeof(long); + + //sub ebx,1 + OpBuffer[obp++]=(char)0x83; + OpBuffer[obp++]=(char)0xEB; + OpBuffer[obp++]=(char)0x01; + + //jnz ↑ + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x85; + *((long *)(OpBuffer+obp))=jnz_back-(obp+sizeof(long)); + obp+=sizeof(long); + } +} +void Operator_New( const CClass &classObj, const char *objectSizeStr, const char *parameter, const Type &baseType ){ + int typeSize = classObj.GetSize(); + + if(classObj.IsAbstract()){ + //抽象クラスだったとき + SetError(125,classObj.GetName().c_str(),cp); + } + + BOOL bSomeObjects=0; + if(objectSizeStr[0]){ + bSomeObjects=1; + + int reg=REG_RAX; + Type tempType; + NumOpe(®,objectSizeStr,Type(),tempType); + if( !tempType.IsWhole() ) SetError(49,NULL,cp); + + //※添え字上限値であることを考慮 + //add rax,1 + op_add_RV(REG_RAX,1); + + //オブジェクトの個数をrbxに一時保持 + //※rbxは関数が呼ばれても不変 + //mov rbx,rax + op_mov_RR(REG_RBX,REG_RAX); + + //imul rax,size + op_imul_RV(sizeof(_int64),REG_RAX,typeSize); + + //add rax,OBJECT_HEAD_SIZE + op_add_RV(REG_RAX,OBJECT_HEAD_SIZE); + + //mov rcx,rax + op_mov_RR(REG_RCX,REG_RAX); + } + else{ + //オブジェクトの個数をrbxに一時保持 + //※rbxは関数が呼ばれても不変 + //mov rbx,1 + op_mov_RV(sizeof(_int64),REG_RBX,1); + + //mov rcx,typeSize+OBJECT_HEAD_SIZE + op_mov_RV(sizeof(_int64),REG_RCX,typeSize+OBJECT_HEAD_SIZE); + } + + if( baseType.IsObject() ){ + // オブジェクト インスタンス + // ※DeleteはGCで処理 + + //call _System_GC_malloc_ForObject + extern UserProc *pSub_System_GC_malloc_ForObject; + op_call(pSub_System_GC_malloc_ForObject); + } + else{ + // オブジェクトポインタ + // ※明示的なDeleteが必要 + + //call _System_GC_malloc_ForObjectPtr + extern UserProc *pSub_System_GC_malloc_ForObjectPtr; + op_call(pSub_System_GC_malloc_ForObjectPtr); + } + + + /* + 確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、 + pPtr-=OBJECT_HEAD_SIZE ... ( sizeof(DWORD)*4 ) + pPtr[0]=オブジェクトの個数 + pPtr[1]=オブジェクトのサイズ + pPtr[2]=デストラクタの関数ポインタ + pPtr[3]=reserve + */ + + + //mov qword ptr[rax],rbx（オブジェクトの個数） + op_mov_MR(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE); + + //add rax,PTR_SIZE + op_add_RV(REG_RAX,PTR_SIZE); + + + //mov qword ptr[rax],typeSize（オブジェクトのサイズ） + op_mov_MV(sizeof(_int64),REG_RAX,0,NON_OFFSET,typeSize); + + //add rax,PTR_SIZE + op_add_RV(REG_RAX,PTR_SIZE); + + + const CMethod *method = classObj.GetDestructorMethod(); + if( method == NULL ) return; + + //mov rcx,DestructorProcAddr（デストラクタの関数ポインタ） + op_mov_RV(sizeof(_int64),REG_RCX,0); + obp-=sizeof(long); + pobj_SubAddrSchedule->add(method->pUserProc,0); + method->pUserProc->Using(); + obp+=sizeof(long); + + //mov qword ptr[rax],rcx + op_mov_MR(sizeof(_int64),REG_RCX,REG_RAX,0,MOD_BASE); + + //add rax,PTR_SIZE + op_add_RV(REG_RAX,PTR_SIZE); + + + // リザーブ領域 + //add rax,PTR_SIZE + op_add_RV(REG_RAX,PTR_SIZE); + + + // ※ここでプッシュされた値はNew演算子の戻り値となる + //mov qword ptr[rsp+offset],rax ※スタックフレームを利用 + pobj_sf->push(REG_RAX); + + + ///////////////////////////////////////////////////////////////////// + + //////////////////////////// + // コンストラクタの呼び出し + //////////////////////////// + + _call_constructor(&classObj,parameter,typeSize,bSomeObjects); + + + //mov rax,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_RAX); +} +void OpcodeDelete(const char *Parameter, bool isSweeping){ + int reg=REG_RAX; + Type tempType; + if( !NumOpe(®,Parameter,Type(),tempType) ){ + return; + } + if(!( tempType.IsObjectPtr() || tempType.IsVoidPtr() )) SetError(122,NULL,cp); + + //sub rax,OBJECT_HEAD_SIZE + op_sub_RV(sizeof(_int64),REG_RAX,OBJECT_HEAD_SIZE); + + //mov qword ptr[rsp+offset],rax ※スタックフレームを利用 + pobj_sf->push(REG_RAX); + + + //mov rbx,qword ptr[rax]（オブジェクトの個数） + op_mov_RM(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE); + + //add rax,PTR_SIZE + op_add_RV(REG_RAX,PTR_SIZE); + + + //mov rsi,qword ptr[rax]（オブジェクトのサイズ） + op_mov_RM(sizeof(_int64),REG_RSI,REG_RAX,0,MOD_BASE); + + //add rax,PTR_SIZE + op_add_RV(REG_RAX,PTR_SIZE); + + + //mov rdi,qword ptr[rax]（デストラクタの関数ポインタ） + op_mov_RM(sizeof(_int64),REG_RDI,REG_RAX,0,MOD_BASE); + + //add rax,PTR_SIZE + op_add_RV(REG_RAX,PTR_SIZE); + + + // リザーブ領域 + //add rax,PTR_SIZE + op_add_RV(REG_RAX,PTR_SIZE); + + + //mov rcx,rax + op_mov_RR(REG_RCX,REG_RAX); + + + //jnzの番地 + int jnz_back; + jnz_back=obp; + + //mov qword ptr[rsp+offset],rcx ※スタックフレームを利用 + pobj_sf->push(REG_RCX); + + //call rdi + OpBuffer[obp++]=(char)0xFF; + OpBuffer[obp++]=(char)0xD7; + + //mov rcx,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_RCX); + + //add rcx,rsi + op_add64_reg(REG_RCX,REG_RSI); + + //sub rbx,1 + op_sub_RV(sizeof(_int64),REG_RBX,1); + + //jnz ↑ + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x85; + *((long *)(OpBuffer+obp))=jnz_back-(obp+sizeof(long)); + obp+=sizeof(long); + + + ////////////////////////////////////////// + // オブジェクトメンバ変数用のメモリを解放 + ////////////////////////////////////////// + + //mov rcx,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_RCX); + + if( isSweeping ){ + //call _System_GC_free_for_SweepingDelete + extern UserProc *pSub_System_GC_free_for_SweepingDelete; + op_call(pSub_System_GC_free_for_SweepingDelete); + } + else{ + //call free + extern UserProc *pSub_free; + op_call(pSub_free); + } +} Index: trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp (revision 149) @@ -0,0 +1,865 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +void SystemProc( const UserProc &userProc ){ + if( userProc.GetName() == "_System_GetEip" ){ + //mov rax,qword ptr[rsp] + op_mov_RM(sizeof(_int64),REG_RAX,REG_RSP,0,MOD_BASE); + + //ret + op_ret(); + } + else if( userProc.GetName() == "_System_InitDllGlobalVariables" ){ + //////////////////////////////////////// + // DLLのグローバル領域をコンパイル + //////////////////////////////////////// + extern BOOL bDll; + if(!bDll){ + //ret + op_ret(); + + return; + } + + UserProc *pBackUserProc; + pBackUserProc = &UserProc::CompilingUserProc(); + UserProc::CompileStartForGlobalArea(); + + int BackCp; + BackCp=cp; + cp=-1; + + //sub rsp,スタックフレームサイズ + int StackFrameSchedule; + op_sub_rsp(0xFFFFFFFF); + StackFrameSchedule=obp-sizeof(long); + + extern BOOL bDebugCompile; + if(bDebugCompile){ + //デバッグ用の変数を定義 + DebugVariable(); + } + + //GC用の変数を定義 + InitGCVariables(); + + //_System_StartupProgramの呼び出し + extern UserProc *pSub_System_StartupProgram; + op_call(pSub_System_StartupProgram); + + //クラスに属する静的メンバを定義 + CMember::InitStaticMember(); + + GetGlobalDataForDll(); + + //add rsp,スタックフレームサイズ + op_add_RV(REG_RSP,pobj_sf->GetFrameSize()); + + //スタックフレームスケジュール（subコマンドに渡す値） + *((long *)(OpBuffer+StackFrameSchedule))=pobj_sf->GetFrameSize(); + + UserProc::CompileStartForUserProc( pBackUserProc ); + cp=BackCp; + + //ret + op_ret(); + } + else if( userProc.GetName() == "_System_InitStaticLocalVariables" ){ + //静的ローカルオブジェクトのコンストラクタ呼び出し + + //sub rsp,スタックフレームサイズ + int StackFrameSchedule; + op_sub_rsp(0xFFFFFFFF); + StackFrameSchedule=obp-sizeof(long); + + foreach( Variable *pVar, globalVars ){ + if(memicmp(pVar->GetName().c_str(),"Static%",7)==0){ + //コンストラクタ呼び出し + if( pVar->IsObject() ){ + + //エラー用 + cp=pVar->source_code_address; + + CallConstructor( + pVar->GetName().c_str(), + pVar->GetSubScriptsPtr(), + *pVar, + pVar->paramStrForConstructor.c_str()); + } + } + } + + //add rsp,スタックフレームサイズ + op_add_RV(REG_RSP,pobj_sf->GetFrameSize()); + + //スタックフレームスケジュール（subコマンドに渡す値） + *((long *)(OpBuffer+StackFrameSchedule))=pobj_sf->GetFrameSize(); + + //ret + op_ret(); + } + else if( userProc.GetName() == "_System_Call_Destructor_of_GlobalObject" ){ + //sub rsp,8（※RSPを16バイト境界にあわせるため） + op_sub_rsp(0x8); + + + UserProc *pBackUserProc; + pBackUserProc = &UserProc::CompilingUserProc(); + UserProc::CompileStartForGlobalArea(); + + obj_LexScopes.CallDestructorsOfScopeEnd(); + + UserProc::CompileStartForUserProc( pBackUserProc ); + + + //add rsp,8 + op_add_RV(REG_RSP,0x8); + + //ret + op_ret(); + } + else if( userProc.GetName() == "_System_GetSp" ){ + //mov rax,rsp + op_mov_RR(REG_RAX,REG_RSP); + + //add rax,PTR_SIZE + op_add_RV(REG_RAX,PTR_SIZE); + + //ret + op_ret(); + } + else if( userProc.GetName() == "_allrem" ){ + //乗除演算用の特殊関数（64ビット整数対応） + BYTE Buffer_allrem[]={ + 0x53,0x57,0x33,0xFF,0x8B,0x44,0x24,0x10,0x0B,0xC0,0x7D,0x14,0x47,0x8B,0x54,0x24,0x0C,0xF7,0xD8,0xF7,0xDA,0x83,0xD8,0x00,0x89,0x44,0x24,0x10,0x89,0x54,0x24,0x0C,0x8B,0x44,0x24,0x18,0x0B,0xC0,0x7D,0x13,0x8B,0x54,0x24,0x14,0xF7,0xD8,0xF7,0xDA,0x83,0xD8,0x00,0x89,0x44,0x24,0x18,0x89,0x54,0x24,0x14,0x0B,0xC0,0x75,0x1B,0x8B,0x4C,0x24,0x14,0x8B,0x44,0x24,0x10,0x33,0xD2,0xF7,0xF1,0x8B,0x44,0x24,0x0C,0xF7,0xF1,0x8B,0xC2,0x33,0xD2,0x4F,0x79,0x4E,0xEB,0x53,0x8B,0xD8,0x8B,0x4C,0x24,0x14,0x8B,0x54,0x24,0x10,0x8B,0x44,0x24,0x0C,0xD1,0xEB,0xD1,0xD9,0xD1,0xEA,0xD1,0xD8,0x0B,0xDB,0x75,0xF4,0xF7,0xF1,0x8B,0xC8,0xF7,0x64,0x24,0x18,0x91,0xF7,0x64,0x24,0x14,0x03,0xD1,0x72,0x0E,0x3B,0x54,0x24,0x10,0x77,0x08,0x72,0x0E,0x3B,0x44,0x24,0x0C,0x76,0x08,0x2B,0x44,0x24,0x14,0x1B,0x54,0x24,0x18,0x2B,0x44,0x24,0x0C,0x1B,0x54,0x24,0x10,0x4F,0x79,0x07,0xF7,0xDA,0xF7,0xD8,0x83,0xDA,0x00,0x5F,0x5B,0xC2,0x10,0x00 + }; + + memcpy(OpBuffer+obp,Buffer_allrem,178); + obp+=178; + } + else if( userProc.GetName() == "_allmul" ){ + //乗算用の特殊関数（64ビット整数対応） + BYTE Buffer_allmul[]={ + 0x8B,0x44,0x24,0x08,0x8B,0x4C,0x24,0x10,0x0B,0xC8,0x8B,0x4C,0x24,0x0C,0x75,0x09,0x8B,0x44,0x24,0x04,0xF7,0xE1,0xC2,0x10,0x00,0x53,0xF7,0xE1,0x8B,0xD8,0x8B,0x44,0x24,0x08,0xF7,0x64,0x24,0x14,0x03,0xD8,0x8B,0x44,0x24,0x08,0xF7,0xE1,0x03,0xD3,0x5B,0xC2,0x10,0x00 + }; + + memcpy(OpBuffer+obp,Buffer_allmul,52); + obp+=52; + } + else if( userProc.GetName() == "_alldiv" ){ + //除算用の特殊関数（64ビット整数対応） + BYTE Buffer_alldiv[]={ + 0x57,0x56,0x53,0x33,0xFF,0x8B,0x44,0x24,0x14,0x0B,0xC0,0x7D,0x14,0x47,0x8B,0x54,0x24,0x10,0xF7,0xD8,0xF7,0xDA,0x83,0xD8,0x00,0x89,0x44,0x24,0x14,0x89,0x54,0x24,0x10,0x8B,0x44,0x24,0x1C,0x0B,0xC0,0x7D,0x14,0x47,0x8B,0x54,0x24,0x18,0xF7,0xD8,0xF7,0xDA,0x83,0xD8,0x00,0x89,0x44,0x24,0x1C,0x89,0x54,0x24,0x18,0x0B,0xC0,0x75,0x18,0x8B,0x4C,0x24,0x18,0x8B,0x44,0x24,0x14,0x33,0xD2,0xF7,0xF1,0x8B,0xD8,0x8B,0x44,0x24,0x10,0xF7,0xF1,0x8B,0xD3,0xEB,0x41,0x8B,0xD8,0x8B,0x4C,0x24,0x18,0x8B,0x54,0x24,0x14,0x8B,0x44,0x24,0x10,0xD1,0xEB,0xD1,0xD9,0xD1,0xEA,0xD1,0xD8,0x0B,0xDB,0x75,0xF4,0xF7,0xF1,0x8B,0xF0,0xF7,0x64,0x24,0x1C,0x8B,0xC8,0x8B,0x44,0x24,0x18,0xF7,0xE6,0x03,0xD1,0x72,0x0E,0x3B,0x54,0x24,0x14,0x77,0x08,0x72,0x07,0x3B,0x44,0x24,0x10,0x76,0x01,0x4E,0x33,0xD2,0x8B,0xC6,0x4F,0x75,0x07,0xF7,0xDA,0xF7,0xD8,0x83,0xDA,0x00,0x5B,0x5E,0x5F,0xC2,0x10,0x00 + }; + + memcpy(OpBuffer+obp,Buffer_alldiv,170); + obp+=170; + } + else if( userProc.GetName() == "_allshl" ){ + //符号あり左ビットシフト用の特殊関数（64ビット整数対応） + BYTE Buffer_allshl[]={ + 0x80,0xF9,0x40,0x73,0x15,0x80,0xF9,0x20,0x73,0x06,0x0F,0xA5,0xC2,0xD3,0xE0,0xC3,0x8B,0xD0,0x33,0xC0,0x80,0xE1,0x1F,0xD3,0xE2,0xC3,0x33,0xC0,0x33,0xD2,0xC3 + }; + + memcpy(OpBuffer+obp,Buffer_allshl,31); + obp+=31; + } + else if( userProc.GetName() == "_allshr" ){ + //符号あり右ビットシフト用の特殊関数（64ビット整数対応） + BYTE Buffer_allshr[]={ + 0x80,0xF9,0x40,0x73,0x16,0x80,0xF9,0x20,0x73,0x06,0x0F,0xAD,0xD0,0xD3,0xFA,0xC3,0x8B,0xC2,0xC1,0xFA,0x1F,0x80,0xE1,0x1F,0xD3,0xF8,0xC3,0xC1,0xFA,0x1F,0x8B,0xC2,0xC3 + }; + + memcpy(OpBuffer+obp,Buffer_allshr,33); + obp+=33; + } + else if( userProc.GetName() == "_aullshr" ){ + //符号なし右ビットシフト用の特殊関数（64ビット整数対応） + BYTE Buffer_aullshr[]={ + 0x80,0xF9,0x40, //cmp cl,40h + 0x73,0x15, //jae RETZERO (0040d71a) + 0x80,0xF9,0x20, //cmp cl,20h + 0x73,0x06, //jae MORE32 (0040d710) + 0x0F,0xAD,0xD0, //shrd eax,edx,cl + 0xD3,0xEA, //shr edx,cl + 0xC3, //ret + //MORE32: + 0x8B,0xC2, //mov eax,edx + 0x33,0xD2, //xor edx,edx + 0x80,0xE1,0x1F, //and cl,1Fh + 0xD3,0xE8, //shr eax,cl + 0xC3, //ret + //RETZERO: + 0x33,0xC0, //xor eax,eax + 0x33,0xD2, //xor edx,edx + 0xC3 //ret + }; + + memcpy(OpBuffer+obp,Buffer_aullshr,31); + obp+=31; + } + else{ + SetError(); + } +} +void AutoGeneration(UserProc &userProc){ + if( userProc.GetName() == "InitializeUserTypes" + && userProc.HasParentClass() + && userProc.GetParentClass().GetName() == "_System_TypeBase" ){ + + pobj_DBClass->Compile_System_InitializeUserTypes(); + } + else if( userProc.GetName() == "RegisterGlobalRoots" + && userProc.HasParentClass() + && userProc.GetParentClass().GetName() == "_System_CGarbageCollection" ){ + + Compile_AddGlobalRootsForGc(); + } + else{ + SetError(); + } +} +void _compile_proc(UserProc *pUserProc){ + extern char *basbuf; + extern HANDLE hHeap; + extern GlobalProc **ppSubHash; + extern BOOL bDebugCompile; + int i3,i4; + char temporary[VN_SIZE]; + + if( pUserProc->IsUsing() == false || pUserProc->IsCompiled() ) return; + + if( pUserProc->localVars.size() ){ + SetError(); + return; + } + + pUserProc->CompleteCompile(); + + extern BOOL bSystemProc; + if(memcmp(pUserProc->GetName().c_str(),"_System_",8)==0) bSystemProc=1; + else bSystemProc=0; + + extern BOOL bDebugSupportProc; + if(memcmp(pUserProc->GetName().c_str(),"_DebugSys_",10)==0){ + if(!bDebugCompile){ + return; + } + bDebugSupportProc=1; + } + else bDebugSupportProc=0; + + pUserProc->beginOpAddress=obp; + + //コンパイル中の関数が属するクラス + pobj_CompilingClass=pUserProc->GetParentClassPtr(); + + //コンパイルスタートをクラス管理クラスに追加 + pobj_DBClass->StartCompile( pUserProc ); + + //コンパイル中の関数 + UserProc::CompileStartForUserProc( pUserProc ); + + // コンパイル中の関数が属する名前空間 + Smoothie::Lexical::liveingNamespaceScopes = pUserProc->GetNamespaceScopes(); + + // コンパイル中の関数でImportsされている名前空間 + Smoothie::Temp::importedNamespaces = pUserProc->GetImportedNamespaces(); + + if(pUserProc->IsSystem()){ + //////////////////// + // 特殊関数 + //////////////////// + + extern int AllLocalVarSize; + AllLocalVarSize=0; + + //スタックフレーム管理用オブジェクトを初期化 + extern CStackFrame *pobj_sf; + pobj_sf=new CStackFrame(); + + SystemProc(*pUserProc); + + //スタックフレーム管理用オブジェクトを破棄 + delete pobj_sf; + pobj_sf=0; + + pUserProc->endOpAddress=obp; + return; + } + + cp=pUserProc->GetCodePos(); + for(;;cp++){ + if(IsCommandDelimitation(basbuf[cp])) break; + } + cp--; + + //プロシージャ抜け出しスケジュール（Exit Sub/Function） + extern DWORD *pExitSubSchedule; + extern int ExitSubScheduleNum; + pExitSubSchedule=(DWORD *)HeapAlloc(hHeap,0,1); + ExitSubScheduleNum=0; + + //ラベル用のメモリを確保 + extern LABEL *pLabelNames; + extern int MaxLabelNum; + pLabelNames=(LABEL *)HeapAlloc(hHeap,0,1); + MaxLabelNum=0; + + //Gotoラベルスケジュール + extern GOTOLABELSCHEDULE *pGotoLabelSchedule; + extern int GotoLabelScheduleNum; + pGotoLabelSchedule=(GOTOLABELSCHEDULE *)HeapAlloc(hHeap,0,1); + GotoLabelScheduleNum=0; + + //With情報のメモリを確保 + extern WITHINFO WithInfo; + WithInfo.ppName=(char **)HeapAlloc(hHeap,0,1); + WithInfo.pWithCp=(int *)HeapAlloc(hHeap,0,1); + WithInfo.num=0; + + //重複エラー情報管理のメモリを確保 + extern char **SynonymErrorWords; + extern int SynonymErrorNum; + SynonymErrorNum=0; + SynonymErrorWords=(char **)HeapAlloc(hHeap,0,1); + + //Continueアドレスを初期化 + extern DWORD dwContinueAddress; + dwContinueAddress=-1; + + //ローカル変数に関する情報 + extern int AllLocalVarSize; + AllLocalVarSize=0; + + //ローカル変数アドレススケジュール + extern DWORD *pLocalVarAddrSchedule; + extern int LocalVarAddrScheduleNum; + pLocalVarAddrSchedule=(DWORD *)HeapAlloc(hHeap,0,1); + LocalVarAddrScheduleNum=0; + + //レキシカルスコープ情報を初期化 + obj_LexScopes.Init(obp); + + + ///////////////////////////////////// + // パラメータ用の変数データを考慮 + ///////////////////////////////////// + + //パラメータ用の変数データを考慮 + for(i3=(int)pUserProc->RealParams().size()-1;i3>=0;i3--){ + Parameter ¶m = *pUserProc->RealParams()[i3]; + + Variable *pVar = new Variable( param.GetVarName(), param, false, param.IsRef() ); + + if( param.IsArray() ){ + pVar->SetArray( param.GetSubScriptsPtr() ); + } + + int varSize; + if( param.IsRef() == false && param.IsStruct() ){ + //構造体のByValパラメータ + pVar->ThisIsParameter(); + varSize=PTR_SIZE; + } + else{ + if( param.IsArray() == false ){ + varSize = pVar->GetMemorySize(); + } + else{ + varSize=PTR_SIZE; + } + } + AllLocalVarSize+=varSize; + pVar->offset=AllLocalVarSize; + + //レキシカルスコープ情報 + pVar->ScopeLevel=obj_LexScopes.GetNowLevel(); + pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress(); + pVar->bLiving=TRUE; + + pUserProc->localVars.push_back( pVar ); + } + + //Thisポインタを示すローカルオフセット値をセット + extern int LocalVar_ThisPtrOffset; + LocalVar_ThisPtrOffset=AllLocalVarSize; + + //スタックフレーム管理用クラスを初期化 + extern CStackFrame *pobj_sf; + pobj_sf=new CStackFrame(); + + + /////////////////////// + // ここからコード生成 + + for(i3=(int)pUserProc->RealParams().size()-1;i3>=0;i3--){ + Parameter ¶m = *pUserProc->RealParams()[i3]; + if(i3==3){ + if(param.IsReal()&¶m.IsRef() == false){ + //movsd qword ptr[rsp+0x20],xmm3 + op_movsd_MR(REG_XMM3,REG_RSP,0x20,MOD_BASE_DISP32); + } + else{ + //mov qword ptr[rsp+0x20],r9 + op_mov_MR(sizeof(_int64),REG_R9,REG_RSP,0x20,MOD_BASE_DISP32); + } + } + if(i3==2){ + if(param.IsReal()&¶m.IsRef() == false){ + //movsd qword ptr[rsp+0x18],xmm2 + op_movsd_MR(REG_XMM2,REG_RSP,0x18,MOD_BASE_DISP32); + } + else{ + //mov qword ptr[rsp+0x18],r8 + op_mov_MR(sizeof(_int64),REG_R8,REG_RSP,0x18,MOD_BASE_DISP32); + } + } + if(i3==1){ + if(param.IsReal()&¶m.IsRef() == false){ + //movsd qword ptr[rsp+0x10],xmm1 + op_movsd_MR(REG_XMM1,REG_RSP,0x10,MOD_BASE_DISP32); + } + else{ + //mov qword ptr[rsp+0x10],rdx + op_mov_MR(sizeof(_int64),REG_RDX,REG_RSP,0x10,MOD_BASE_DISP32); + } + } + if(i3==0){ + if(param.IsReal()&¶m.IsRef() == false){ + //movsd qword ptr[rsp+0x8],xmm0 + op_movsd_MR(REG_XMM0,REG_RSP,0x8,MOD_BASE_DISP32); + } + else{ + //mov qword ptr[rsp+0x8],rcx + op_mov_MR(sizeof(_int64),REG_RCX,REG_RSP,0x8,MOD_BASE_DISP32); + } + } + } + + //ret用のアドレスを考慮 + AllLocalVarSize+=sizeof(_int64); + + //sub rsp,スタックフレームサイズ + int StackFrameSchedule; + op_sub_rsp(0xFFFFFFFF); + StackFrameSchedule=obp-sizeof(long); + + //mov qword ptr[rsp+offset],reg ※スタックフレームを利用 + pobj_sf->push(REG_RBX); + pobj_sf->push(REG_RSI); + pobj_sf->push(REG_RDI); + pobj_sf->push(REG_R12); + pobj_sf->push(REG_R13); + pobj_sf->push(REG_R14); + pobj_sf->push(REG_R15); + + //ローカル変数のベース値 + int BaseLocalVar; + BaseLocalVar=AllLocalVarSize; + + if( !pUserProc->ReturnType().IsNull() ){ + //戻り値が存在するとき + + const char *temp = pUserProc->GetName().c_str(); + if( temp[0]==1&&temp[1]==ESC_OPERATOR ){ + temp = "_System_ReturnValue"; + } + + if( pUserProc->ReturnType().IsStruct() ){ + //戻り値用の構造体（値型）はパラメータで引き渡される + } + else{ + if( pUserProc->ReturnType().IsObject() ){ + sprintf(temporary,"%s=Nothing%c%c%s",temp,1,ESC_AS, pUserProc->ReturnType().ToString().c_str() ); + } + else{ + //戻り値用の変数の定義 + sprintf(temporary,"%s%c%c%s",temp,1,ESC_AS, pUserProc->ReturnType().ToString().c_str() ); + } + + OpcodeDim(temporary,0); + } + } + + int RspOffsetSchedule=0; + int RspOffsetSchedule2; + if(bDebugCompile&&bDebugSupportProc==0){ + //mov rdx, qword ptr[rsp+スタックフレームサイズ] + op_mov_RM(sizeof(_int64),REG_RDX,REG_RSP,0,MOD_BASE_DISP32); + RspOffsetSchedule=obp-sizeof(long); + + //mov rcx,rsp + op_mov_RR(REG_RCX,REG_RSP); + + //add rcx,スタックフレームサイズ+sizeof(_int64) ※ret用のサイズを考慮 + op_add_RV(REG_RCX,0); + RspOffsetSchedule2=obp-sizeof(long); + + //call _DebugSys_StartProc + extern UserProc *pSub_DebugSys_StartProc; + op_call(pSub_DebugSys_StartProc); + } + + if(pobj_CompilingClass){ + if( pUserProc->GetName() == pobj_CompilingClass->GetName() ){ + //////////////////////////////////// + // コンストラクタをコンパイルするとき + //////////////////////////////////// + + //コンストラクタのコンパイル開始を通知 + pobj_CompilingClass->NotifyStartConstructorCompile(); + + //基底クラスかどうかの識別 + //（継承元がインターフェイスの場合も基底クラスと見なす） + BOOL bThisIsSuperClass; + if(pobj_CompilingClass->pobj_InheritsClass==0) bThisIsSuperClass=1; + else if( pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod() == NULL ){ + //インターフェイスを継承したときはコンストラクタを持たない + bThisIsSuperClass=1; + } + else bThisIsSuperClass=0; + + if(!bThisIsSuperClass){ + /* サブクラスコンストラクタをコンパイルしているときは、 + 基底クラスのコンストラクタを呼び出す */ + + i3=cp+1; + while(IsCommandDelimitation(basbuf[i3])) i3++; + for(i4=0;;i3++,i4++){ + if(!IsVariableChar(basbuf[i3])){ + temporary[i4]=0; + break; + } + temporary[i4]=basbuf[i3]; + } + if( pobj_CompilingClass->pobj_InheritsClass->GetName() == temporary ){ + //基底クラスのコンストラクタを呼び出す + cp=i3; + for(i4=0;;cp++,i4++){ + if(IsCommandDelimitation(basbuf[cp])){ + temporary[i4]=0; + break; + } + temporary[i4]=basbuf[cp]; + } + if(!(temporary[0]=='('&&temporary[lstrlen(temporary)-1]==')')){ + SetError(1,NULL,cp); + } + RemoveStringPare(temporary); + + Type dummyType; + CallProc( PROC_DEFAULT + , pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc + , pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc->GetName().c_str() + , temporary + , dummyType ); + } + else{ + //基底クラスのコンストラクタを暗黙的に呼び出す + Opcode_CallProc("", + pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc, + 0, + "", + 0); + } + } + + //仮想関数テーブルを初期化 + if( pobj_CompilingClass->IsExistVirtualFunctions() + && !pobj_CompilingClass->IsAbstract() ){ + //関数テーブルに値をセット + int offset = (int)pobj_CompilingClass->GetVtblGlobalOffset(); + + //mov rax,offset + op_mov_RV(sizeof(_int64),REG_RAX,offset); + obp-=sizeof(long); + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + + //Thisポインタをrcxにコピー + SetThisPtrToReg(REG_RCX); + + //mov qword ptr[rcx],rax + op_mov_MR(sizeof(_int64),REG_RAX,REG_RCX,0,MOD_BASE); + } + } + else if( pUserProc->IsDestructor() ){ + //デストラクタをコンパイルしたとき + + //デストラクタのコンパイル開始を通知 + pobj_CompilingClass->NotifyStartDestructorCompile(); + } + } + + ////////////////////////////////////////// + ////////////////////////////////////////// + ////// プロシージャ内をコンパイル //////// + if( pUserProc->IsAutoGeneration() ){ + AutoGeneration( *pUserProc ); + } + else{ + if(pUserProc->IsMacro()){ + CompileBuffer(ESC_ENDMACRO,0); + } + else{ + if(pUserProc->IsSub()){ + CompileBuffer(ESC_ENDSUB,0); + } + else if(pUserProc->IsFunction()){ + CompileBuffer(ESC_ENDFUNCTION,0); + } + } + } + ////////////////////////////////////////// + ////////////////////////////////////////// + + if( pobj_CompilingClass ){ + + if( pobj_CompilingClass->IsCompilingConstructor() ){ + // コンストラクタをコンパイルしていたとき + + // コンストラクタのコンパイルが完了したことを通知 + pobj_CompilingClass->NotifyFinishConstructorCompile(); + } + else if( pUserProc->IsDestructor() ){ + //////////////////////////////////// + //デストラクタをコンパイルしたとき + //////////////////////////////////// + + // デストラクタのコンパイルが完了したことを通知 + pobj_CompilingClass->NotifyFinishDestructorCompile(); + + if(pobj_CompilingClass->pobj_InheritsClass){ + /* サブクラスのデストラクタをコンパイルしているときは、 + 基底クラスのデストラクタを呼び出す */ + + const CMethod *method = pobj_CompilingClass->pobj_InheritsClass->GetDestructorMethod(); + if( method ){ + Opcode_CallProc("", + method->pUserProc, + 0, + "", + 0); + } + } + } + } + + //ラベル用のメモリを解放 + for(i3=0;i3ReturnType().IsNull() ){ + ////////////////////////////////// + // 戻り値をraxまたはxmm0に設定 + ////////////////////////////////// + + RELATIVE_VAR RelativeVar; + + const char *temp = pUserProc->GetName().c_str(); + if( temp[0]==1 && temp[1]==ESC_OPERATOR ){ + temp="_System_ReturnValue"; + } + GetVarOffsetReadWrite(temp,&RelativeVar,Type()); + + i3=pUserProc->ReturnType().GetBasicType(); + + if(i3==DEF_OBJECT || i3==DEF_STRUCT){ + SetVarPtrToReg(REG_RAX,&RelativeVar); + if( i3==DEF_OBJECT ){ + //mov rax,qword ptr[rax] + op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE ); + } + } + else if(i3==DEF_DOUBLE){ + //64ビット実数型 + SetXmmReg_DoubleVariable(&RelativeVar,REG_XMM0); + } + else if(i3==DEF_SINGLE){ + //32ビット実数型 + SetXmmReg_SingleVariable(&RelativeVar,REG_XMM0); + } + else if(IsWholeNumberType(i3)){ + //整数型 + SetReg_WholeVariable(i3,&RelativeVar,REG_RAX); + } + else SetError(300,NULL,cp); + } + + //ローカル変数領域のサイズをスタックフレームに通知 + int iLocalParmSize; + iLocalParmSize=AllLocalVarSize-BaseLocalVar; + pobj_sf->SetLocalParmSize(iLocalParmSize); + + //ローカル変数アドレススケジュール + for(i3=0;i3GetFrameSize(); + } + HeapDefaultFree(pLocalVarAddrSchedule); + foreach( Variable *pVar, pUserProc->localVars ){ + //後にデバッグで利用する + pVar->offset = AllLocalVarSize + pobj_sf->GetFrameSize() - pVar->offset; + } + + //mov reg,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R15); + pobj_sf->pop(REG_R14); + pobj_sf->pop(REG_R13); + pobj_sf->pop(REG_R12); + pobj_sf->pop(REG_RDI); + pobj_sf->pop(REG_RSI); + pobj_sf->pop(REG_RBX); + + int iStackFrameSize; + iStackFrameSize=iLocalParmSize + pobj_sf->GetFrameSize(); + + //add rsp,スタックフレームサイズ + op_add_rsp(iStackFrameSize); + + //ret + op_ret(); + + + //デバッグ用 + if(RspOffsetSchedule){ + *((long *)(OpBuffer+RspOffsetSchedule))=iStackFrameSize; + *((long *)(OpBuffer+RspOffsetSchedule2))=iStackFrameSize+sizeof(_int64); + } + + + //スタックフレームスケジュール（subコマンド） + *((long *)(OpBuffer+StackFrameSchedule))=iStackFrameSize; + + //スタックフレームスケジュールを実行 + pobj_sf->RunningSchedule(); + delete pobj_sf; + pobj_sf=0; + + + pUserProc->endOpAddress=obp; + + + //重複エラー情報管理のメモリを解放 + for(i3=0;i3CompleteCompile(); + + //_System_InitStaticLocalVariablesは一番最後にコンパイル + //※一般関数内の静的変数オブジェクトをすべて収集しなければならない + extern UserProc *pSub_System_InitStaticLocalVariables; + pSub_System_InitStaticLocalVariables->CompleteCompile(); + + //_System_Call_Destructor_of_GlobalObjectは一番最後にコンパイル + extern UserProc *pSub_System_Call_Destructor_of_GlobalObject; + pSub_System_Call_Destructor_of_GlobalObject->CompleteCompile(); + +repeat: + GlobalProc *pGlobalProc; + for(i2=0;i2pNextData; + } + } + + if( IsNeedProcCompile() ){ + //プロシージャコンパイルによって、プロシージャコンパイルが必要になる場合 + goto repeat; + } + + //_System_TypeBase_InitializeUserTypesは最後のほうでコンパイル + pSubStaticMethod_System_TypeBase_InitializeUserTypes->KillCompileStatus(); + CompileBufferInProcedure( *pSubStaticMethod_System_TypeBase_InitializeUserTypes ); + + if( IsNeedProcCompile() ){ + //プロシージャコンパイルによって、プロシージャコンパイルが必要になる場合 + for(i2=0;i2pNextData; + } + } + } + + //_System_InitStaticLocalVariablesは一番最後にコンパイル + pSub_System_InitStaticLocalVariables->KillCompileStatus(); + CompileBufferInProcedure( *pSub_System_InitStaticLocalVariables ); + + //_System_Call_Destructor_of_GlobalObjectは一番最後にコンパイル + pSub_System_Call_Destructor_of_GlobalObject->KillCompileStatus(); + CompileBufferInProcedure( *pSub_System_Call_Destructor_of_GlobalObject ); +} Index: trunk/abdev/BasicCompiler64/Compile_Set_Var.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Compile_Set_Var.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Compile_Set_Var.cpp (revision 149) @@ -0,0 +1,411 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +BOOL IsUse_r11(RELATIVE_VAR *pRelativeVar){ + if(pRelativeVar->bOffsetOffset||pRelativeVar->dwKind==VAR_DIRECTMEM) return 1; + return 0; +} + +void SetStructVariableFromRax( const Type &varType, const Type &calcType, RELATIVE_VAR *pRelativeVar,BOOL bUseHeap){ + int RightTermReg; + pobj_reg=new CRegister(REG_RCX); + + //VarRegにオブジェクトポインタをコピー + int VarReg; + VarReg=pobj_reg->LockReg(); + SetVarPtrToReg(VarReg,pRelativeVar); + + //右辺 + if( calcType.IsReal() ){ + RightTermReg=pobj_reg->LockXmmReg(); + + if( calcType.IsDouble() ){ + //movlsd RightTermReg,xmm0 + op_movsd_RR(RightTermReg,REG_XMM0); + } + else if( calcType.IsSingle() ){ + //movlss RightTermReg,xmm0 + op_movss_RR(RightTermReg,REG_XMM0); + } + } + else{ + RightTermReg=pobj_reg->LockReg(); + + //mov RightTermReg,rax + op_mov_RR(RightTermReg,REG_RAX); + } + + //右辺用レジスタを解除 + if( calcType.IsReal() ) pobj_reg->UnlockXmmReg(); + else pobj_reg->UnlockReg(); + + //左辺用レジスタを解除 + pobj_reg->UnlockReg(); + + //レジスタ管理オブジェクトを破棄 + delete pobj_reg; + pobj_reg=0; + + + if( calcType.IsStruct() ){ + if( varType.GetClass().IsEquals( &calcType.GetClass() ) ){ //等しい + + //双方のオブジェクト型が一致、または派生・継承関係にあるとき + //※コピーを行う + + //mov rsi,RightTermReg + op_mov_RR(REG_RSI,RightTermReg); + + //mov rdi,VarReg + op_mov_RR(REG_RDI,VarReg); + + int object_size = varType.GetClass().GetSize(); + + //mov rcx,object_size + op_mov_RV(sizeof(_int64),REG_RCX,object_size); + + if(bUseHeap){ + //mov rax,rsi + op_mov_RR(REG_RAX,REG_RSI); + } + + //rep movs byte ptr[rdi],byte ptr[rsi] + op_rep_movs(sizeof(BYTE)); + + if(bUseHeap){ + //mov rcx,rax + op_mov_RR(REG_RCX,REG_RAX); + + //call free + extern UserProc *pSub_free; + op_call(pSub_free); + } + + return; + } + } + + SetError(1,NULL,cp); +} + + +void SetDoubleVariable(int type,RELATIVE_VAR *pRelative){ + ////////////////////////// + // Double型変数に書き込む + ////////////////////////// + + //xmm0に型変換 + ChangeTypeToXmm_Double(type,REG_XMM0,REG_RAX); + + if(pRelative->dwKind==VAR_GLOBAL){ + if(pRelative->bOffsetOffset){ + //movsd qword ptr[r11+offset],xmm0 + OpBuffer[obp++]=(char)0xF2; + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x11; + OpBuffer[obp++]=(char)0x83; + *((long *)(OpBuffer+obp))=(int)pRelative->offset; + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + else{ + //movsd qword ptr[offset],xmm0 + OpBuffer[obp++]=(char)0xF2; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x11; + OpBuffer[obp++]=(char)0x04; + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=(int)pRelative->offset; + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + } + else if(pRelative->dwKind==VAR_REFGLOBAL){ + SetError(300,NULL,cp); + } + else if(pRelative->dwKind==VAR_LOCAL){ + if(pRelative->bOffsetOffset){ + //movsd qword ptr[rsp+r11+offset],xmm0 + OpBuffer[obp++]=(char)0xF2; + OpBuffer[obp++]=(char)0x42; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x11; + OpBuffer[obp++]=(char)0x84; + OpBuffer[obp++]=(char)0x1C; + *((long *)(OpBuffer+obp))=(int)pRelative->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //movsd qword ptr[rsp+offset],xmm0 + OpBuffer[obp++]=(char)0xF2; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x11; + OpBuffer[obp++]=(char)0x84; + OpBuffer[obp++]=(char)0x24; + *((long *)(OpBuffer+obp))=(int)pRelative->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + } + else if( pRelative->dwKind == VAR_REFLOCAL ){ + if(pRelative->bOffsetOffset){ + //add r11,qword ptr[rsp+offset] + OpBuffer[obp++]=(char)0x4C; + OpBuffer[obp++]=(char)0x03; + OpBuffer[obp++]=(char)0x9C; + OpBuffer[obp++]=(char)0x24; + *((long *)(OpBuffer+obp))=(int)pRelative->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //mov r11,qword ptr[rsp+offset] + op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + + goto directmem; + } + else if(pRelative->dwKind==VAR_DIRECTMEM){ +directmem: + //movsd qword ptr[r11],xmm0 + OpBuffer[obp++]=(char)0xF2; + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x11; + OpBuffer[obp++]=(char)0x03; + } +} +void SetSingleVariable(int type,RELATIVE_VAR *pRelative){ + ////////////////////////// + // Single型変数に書き込む + ////////////////////////// + + //xmm0に型変換 + ChangeTypeToXmm_Single(type,REG_XMM0,REG_RAX); + + if(pRelative->dwKind==VAR_GLOBAL){ + if(pRelative->bOffsetOffset){ + //movss dword ptr[r11+offset],xmm0 + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x11; + OpBuffer[obp++]=(char)0x83; + *((long *)(OpBuffer+obp))=(int)pRelative->offset; + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + else{ + //movss dword ptr[offset],xmm0 + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x11; + OpBuffer[obp++]=(char)0x04; + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=(int)pRelative->offset; + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + } + else if(pRelative->dwKind==VAR_REFGLOBAL){ + SetError(300,NULL,cp); + } + else if(pRelative->dwKind==VAR_LOCAL){ + if(pRelative->bOffsetOffset){ + //movss dword ptr[rsp+r11+offset],xmm0 + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x42; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x11; + OpBuffer[obp++]=(char)0x84; + OpBuffer[obp++]=(char)0x1C; + *((long *)(OpBuffer+obp))=(int)pRelative->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //movss dword ptr[rsp+offset],xmm0 + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x11; + OpBuffer[obp++]=(char)0x84; + OpBuffer[obp++]=(char)0x24; + *((long *)(OpBuffer+obp))=(int)pRelative->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + } + else if( pRelative->dwKind == VAR_REFLOCAL ){ + if(pRelative->bOffsetOffset){ + //add r11,qword ptr[rsp+offset] + OpBuffer[obp++]=(char)0x4C; + OpBuffer[obp++]=(char)0x03; + OpBuffer[obp++]=(char)0x9C; + OpBuffer[obp++]=(char)0x24; + *((long *)(OpBuffer+obp))=(int)pRelative->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //mov r11,qword ptr[rsp+offset] + op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + + goto directmem; + } + else if(pRelative->dwKind==VAR_DIRECTMEM){ +directmem: + //movss dword ptr[r11],xmm0 + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x11; + OpBuffer[obp++]=(char)0x03; + } +} +void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar){ + if(VarType==DEF_DOUBLE){ + //Double型変数へスタックの内容を格納する + SetDoubleVariable(CalcType,pRelativeVar); + } + else if(VarType==DEF_SINGLE){ + //Single型変数へスタックの内容を格納する + SetSingleVariable(CalcType,pRelativeVar); + } +} +void SetBooleanVariable(int type,RELATIVE_VAR *pRelative){ + if(type==DEF_DOUBLE){ + //Double型 + + //cvttsd2si rax,xmm0 + op_cvttsd2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0); + } + else if(type==DEF_SINGLE){ + //Single型 + + //cvttss2si rax,xmm0 + op_cvttss2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0); + } + + //cmp rax,0 + op_cmp_value(GetTypeSize(type,-1),REG_RAX,0); + + //setne al + op_setne( REG_RAX ); + + SetWholeVariable( sizeof(char), DEF_BYTE, pRelative); +} +void SetWholeVariable(int varSize,int type,RELATIVE_VAR *pRelative){ + if(type==DEF_DOUBLE){ + //Double型 + + //cvttsd2si rax,xmm0 + op_cvttsd2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0); + } + else if(type==DEF_SINGLE){ + //Single型 + + //cvttss2si rax,xmm0 + op_cvttss2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0); + } + else{ + //その他の整数 + + if(varSize==sizeof(_int64)){ + //レジスタの値を64ビット（rax）に拡張する + ExtendTypeTo64(type,REG_RAX); + } + else if(varSize==sizeof(long)){ + //レジスタの値を32ビット（eax）に拡張する + ExtendTypeTo32(type,REG_RAX); + } + else if(varSize==sizeof(short)){ + //レジスタの値を16ビット（ax）に拡張する + ExtendTypeTo16(type,REG_RAX); + } + //8ビットは拡張なし + } + + if(pRelative->dwKind==VAR_GLOBAL){ + if(pRelative->bOffsetOffset){ + //mov ptr[r11+offset],rax/eax/ax/al + op_mov_MR(varSize,REG_RAX,REG_R11,(int)pRelative->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + else{ + //mov ptr[offset],rax/eax/ax/al + op_mov_MR(varSize,REG_RAX,0,(int)pRelative->offset,MOD_DISP32); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + } + else if( pRelative->dwKind == VAR_REFGLOBAL ){ + if(pRelative->bOffsetOffset){ + //add r11,qword ptr[offset] + op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelative->offset, MOD_DISP32 ); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + else{ + //mov r11,qword ptr[offset] + op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelative->offset,MOD_DISP32); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + + goto directmem; + } + else if(pRelative->dwKind==VAR_LOCAL){ + if(pRelative->bOffsetOffset){ + //mov ptr[rsp+r11+offset],rax/eax/ax/al + op_mov_MR_ex(varSize,REG_RAX,REG_RSP,REG_R11,(int)pRelative->offset,USE_OFFSET); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //mov ptr[rsp+offset],rax/eax/ax/al + op_mov_MR(varSize,REG_RAX,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + } + else if( pRelative->dwKind == VAR_REFLOCAL ){ + if(pRelative->bOffsetOffset){ + //add r11,qword ptr[rsp+offset] + op_add_RM( sizeof(_int64), REG_R11, REG_RSP, (int)pRelative->offset, MOD_BASE_DISP32 ); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //mov r11,qword ptr[rsp+offset] + op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + + goto directmem; + } + else if(pRelative->dwKind==VAR_DIRECTMEM){ +directmem: + + //mov ptr[r11],rax/eax/ax/al + op_mov_MR(varSize,REG_RAX,REG_R11,0,MOD_BASE); + } +} Index: trunk/abdev/BasicCompiler64/Compile_Statement.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Compile_Statement.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Compile_Statement.cpp (revision 149) @@ -0,0 +1,1043 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +void OpcodeOthers(const char *Command){ + int i,i2; + UserProc *pUserProc; + + char leftTerm[8192]; + int lastParePos = 0; + for(i=0;;i++){ + if(Command[i]=='\"'){ + //ダブルクォートは不正なのでエラー扱い + leftTerm[i]=0; + SetError(3,leftTerm,cp); + return; + } + + if(Command[i]=='('){ + lastParePos = i; + i2=GetStringInPare(leftTerm+i,Command+i); + i+=i2-1; + continue; + } + if(Command[i]=='['){ + i2=GetStringInBracket(leftTerm+i,Command+i); + i+=i2-1; + continue; + } + if(Command[i]=='\0'){ + leftTerm[i] = 0; + break; + } + + if( IsNumCalcMark( Command, i ) ){ + leftTerm[i] = 0; + break; + } + + leftTerm[i]=Command[i]; + } + if(!( + IsVariableTopChar(leftTerm[0])|| + leftTerm[0]=='.'|| + (leftTerm[0]==1&&leftTerm[1]==ESC_PSMEM) + )){ + SetError(1,NULL,cp); + return; + } + + + if(Command[i]=='\0' && lastParePos == 0){ + ////////////////////////////// + // パラメータ無しのマクロ検索 + ////////////////////////////// + + pUserProc=GetSubHash(Command); + + //GetSubHash内でエラー提示が行われた場合 + if(pUserProc==(UserProc *)-1) return; + + if(pUserProc==0){ + char temporary[VN_SIZE]; + lstrcpy(temporary,Command); + + CharUpper(temporary); + pUserProc=GetSubHash(temporary); + + //GetSubHash内でエラー提示が行われた場合 + if(pUserProc==(UserProc *)-1) return; + } + + if(pUserProc){ + if( !pUserProc->IsMacro() ){ + SetError(10,Command,cp); + } + + Opcode_CallProc("",pUserProc,0,"",0); + + return; + } + } + else if(IsNumCalcMark(Command,i)){ + //代入演算 + OpcodeCalc(Command); + return; + } + + if( pobj_reg ){ + SetError(); + } + pobj_reg=new CRegister(REG_RAX); + + Type resultType; + bool isLiteral; + BOOL bUseHeap; + bool result = TermOpe( leftTerm, Type(), resultType, isLiteral, &bUseHeap, false, NULL, true ); + + delete pobj_reg; + pobj_reg = NULL; + + if( result ){ + + ///////////////////// + // 戻り値の処理 + ///////////////////// + + if( resultType.IsStruct() ){ + //mov r14,rax + op_mov_RR(REG_R14,REG_RAX); + + FreeTempObject(REG_R14,&resultType.GetClass()); + } + + //成功 + return; + } + + // 失敗 + SetError(1, NULL,cp); +} + +void Judgment(char *buffer){ + int reg=REG_RAX; + Type resultType; + if( !NumOpe(®,buffer,Type(),resultType) ){ + return; + } + + int offset; + + if(resultType.IsDouble()){ + double dbl=0; + offset=dataTable.Add( dbl ); + + //comisd xmm0,qword ptr[data table offset] + OpBuffer[obp++]=(char)0x66; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x2F; + OpBuffer[obp++]=(char)0x04; + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=offset; + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + } + else if(resultType.IsSingle()){ + float flt=0; + offset=dataTable.Add( flt ); + + //comiss xmm0,dword ptr[data table offset] + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x2F; + OpBuffer[obp++]=(char)0x04; + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=offset; + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + } + else{ + //整数型 + + //cmp rax,0 + op_cmp_value(resultType.GetSize(),REG_RAX,0); + } +} + +void OpcodeIf(char *Parameter){ + int i,i2,i3; + + for(i=0;;i++){ + if(Parameter[i]=='\0'){ + SetError(21,NULL,cp); + return; + } + if(Parameter[i]==1&&Parameter[i+1]==ESC_THEN){ + Parameter[i]=0; + break; + } + } + + //条件式を実行してフラグをセット + Judgment(Parameter); + + //je (endif、または else まで条件ジャンプ) + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x84; + obp+=sizeof(long); + + //jeの番地 + i3=obp; + + + ///////////////////////// + // If内をコード化 + ///////////////////////// + + //レキシカルスコープをレベルアップ + obj_LexScopes.Start( obp, SCOPE_TYPE_IF ); + + i2=CompileBuffer(ESC_ENDIF,0); + + //レキシカルスコープをレベルダウン + obj_LexScopes.End(); + + + if(i2==ESC_ELSE){ + //jmp (endifまで) + OpBuffer[obp++]=(char)0xE9; + obp+=sizeof(long); + + *((long *)(OpBuffer+i3-sizeof(long)))=obp-i3; //ifからelseへのジャンプ先のオフセット値 + + i3=obp; + + + ///////////////////////// + // Else内をコード化 + ///////////////////////// + + //レキシカルスコープをレベルアップ + obj_LexScopes.Start( obp, SCOPE_TYPE_IF ); + + CompileBuffer(ESC_ENDIF,0); + + //レキシカルスコープをレベルダウン + obj_LexScopes.End(); + + + *((long *)(OpBuffer+i3-sizeof(long)))=obp-i3; //jmpジャンプ先のオフセット値 + } + else{ + *((long *)(OpBuffer+i3-sizeof(long)))=obp-i3; //jeジャンプ先のオフセット値 + } +} + +int GetLabelAddress(char *LabelName,int LineNum){ + extern int MaxLabelNum; + extern LABEL *pLabelNames; + int i; + + if(LabelName){ + for(i=0;ilock((int *)&dwTempContinue); + pobj_TempSchedule->lock((int *)&dwContinueAddress); + + if(!Parameter[0]) SetError(10,"While",cp); + + //条件式を実行してフラグをセット + Judgment(Parameter); + + //je (Wend まで) + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x84; + obp+=sizeof(long); + + //実行中の番地 + int je_schedule=obp; + pobj_TempSchedule->lock(&je_schedule); + + //レキシカルスコープをレベルアップ + obj_LexScopes.Start( obp, SCOPE_TYPE_WHILE ); + + //While内をコンパイル + CompileBuffer(0,COM_WEND); + + obj_LexScopes.CallDestructorsOfScopeEnd(); + + //jmp ... + OpBuffer[obp++]=(char)0xE9; + *((long *)(OpBuffer+obp))=dwContinueAddress-(obp+sizeof(long)); + obp+=sizeof(long); + pobj_TempSchedule->unlock(); + pobj_TempSchedule->unlock(); + + //レキシカルスコープをレベルダウン + obj_LexScopes.End(); + + *((long *)(OpBuffer+je_schedule-sizeof(long)))=obp-je_schedule; //jeジャンプ先のオフセット値 + pobj_TempSchedule->unlock(); + + //Continueアドレスを復元 + dwContinueAddress=dwTempContinue; +} + +char szNextVariable[VN_SIZE]; +void OpcodeFor(char *Parameter){ + extern HANDLE hHeap; + Type resultType; + int i,i2,i3; + char temporary[VN_SIZE],variable[VN_SIZE],JudgeNum[VN_SIZE],StepNum[VN_SIZE]; + bool isError = false; + + //第１パラメータを取得 + i=GetOneParameter(Parameter,0,temporary); + if(!Parameter[i]){ + SetError(12,"For",cp); + isError = true; + goto ErrorStep; + } + + for(i2=0;;i2++){ + if(temporary[i2]=='='){ + variable[i2]=0; + + //カウンタ初期化 + OpcodeCalc(temporary); + break; + } + if(temporary[i2]=='\0'){ + SetError(12,"For",cp); + isError = true; + goto ErrorStep; + } + variable[i2]=temporary[i2]; + } + + //jmp ... + OpBuffer[obp++]=(char)0xE9; + i2=obp; + obp+=sizeof(long); + + //Continueアドレスのバックアップとセット + extern DWORD dwContinueAddress; + DWORD dwTempContinue; + dwTempContinue=dwContinueAddress; + dwContinueAddress=obp; + pobj_TempSchedule->lock((int *)&dwTempContinue); + pobj_TempSchedule->lock((int *)&dwContinueAddress); + + //第２パラメータを取得（to～） + i=GetOneParameter(Parameter,i,JudgeNum); + + //第３パラメータを取得（step～） + if(Parameter[i]){ + i=GetOneParameter(Parameter,i,StepNum); + if(Parameter[i]) SetError(12,"For",cp); + } + else lstrcpy(StepNum,"1"); + + //カウンタを増加させる + sprintf(temporary,"%s=(%s)+(%s)",variable,variable,StepNum); + OpcodeCalc(temporary); + + *((long *)(OpBuffer+i2))=obp-(i2+sizeof(long)); + + //増加か減少かを区別する + sprintf(temporary,"(%s)>=0",StepNum); + + int reg; + reg=REG_RAX; + if( !NumOpe(®,temporary,Type(),resultType) ){ + return; + } + + //cmp rax,0 + op_cmp_value(resultType.GetSize(),REG_RAX,0); + + //je [カウンタ減少の場合の判定] + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x84; + i2=obp; + obp+=sizeof(long); + + //判定（カウンタ増加の場合） + sprintf(temporary,"%s<=(%s)",variable,JudgeNum); + + reg=REG_RAX; + NumOpe(®,temporary,Type(),Type()); + + //jmp [カウンタ減少の場合の判定を飛び越す] + OpBuffer[obp++]=(char)0xE9; + i3=obp; + obp+=sizeof(long); + + *((long *)(OpBuffer+i2))=obp-(i2+sizeof(long)); //jeジャンプ先のオフセット値 + + //判定（カウンタ減少の場合） + sprintf(temporary,"%s>=(%s)",variable,JudgeNum); + + reg=REG_RAX; + NumOpe(®,temporary,Type(),resultType); + + *((long *)(OpBuffer+i3))=obp-(i3+sizeof(long)); //jmpジャンプ先のオフセット値 + + //cmp rax,0 + op_cmp_value(resultType.GetSize(),REG_RAX,0); + +ErrorStep: + + //je ... + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x84; + int je_schedule=obp; + obp+=sizeof(long); + pobj_TempSchedule->lock(&je_schedule); + + //レキシカルスコープをレベルアップ + obj_LexScopes.Start( obp, SCOPE_TYPE_FOR ); + + //For内をコンパイル + CompileBuffer(0,COM_NEXT); + + obj_LexScopes.CallDestructorsOfScopeEnd(); + + if(szNextVariable[0]){ + if(lstrcmp(szNextVariable,variable)!=0){ + SetError(55,szNextVariable,cp); + } + } + + //jmp ... + OpBuffer[obp++]=(char)0xE9; + *((long *)(OpBuffer+obp))=dwContinueAddress-(obp+sizeof(long)); + obp+=sizeof(long); + if( isError == false ){ + pobj_TempSchedule->unlock(); + pobj_TempSchedule->unlock(); + } + + //レキシカルスコープをレベルダウン + obj_LexScopes.End(); + + *((long *)(OpBuffer+je_schedule))=obp-(je_schedule+sizeof(long)); //jeジャンプ先のオフセット値 + pobj_TempSchedule->unlock(); + + //Continueアドレスを復元 + dwContinueAddress=dwTempContinue; +} + +void OpcodeDo(char *Parameter){ + extern HANDLE hHeap; + int i,i2,i3; + + if(Parameter[0]) SetError(10,"Do",cp); + + //Continueアドレスのバックアップとセット + extern DWORD dwContinueAddress; + DWORD dwTempContinue; + dwTempContinue=dwContinueAddress; + dwContinueAddress=obp; + pobj_TempSchedule->lock((int *)&dwTempContinue); + pobj_TempSchedule->lock((int *)&dwContinueAddress); + + //レキシカルスコープをレベルアップ + obj_LexScopes.Start( obp, SCOPE_TYPE_DO ); + + //Do内をコンパイル + CompileBuffer(0,COM_LOOP); + + obj_LexScopes.CallDestructorsOfScopeEnd(); + + extern char *basbuf; + char temporary[VN_SIZE]; + for(i=cp-1;;i--){ + if(IsCommandDelimitation(basbuf[i])){ + i+=3; + if(!(basbuf[i]=='0'||basbuf[i]=='1')){ + //無条件ループ + break; + } + i3=i; + + for(i+=2,i2=0;;i++,i2++){ + if(IsCommandDelimitation(basbuf[i])){ + temporary[i2]=0; + break; + } + temporary[i2]=basbuf[i]; + } + + //条件式を実行してフラグをセット + Judgment(temporary); + + if(basbuf[i3]=='0'){ + //While + + //je 5（ループ終了） + OpBuffer[obp++]=(char)0x74; + OpBuffer[obp++]=(char)0x05; + } + else if(basbuf[i3]=='1'){ + //Until + + //jne 5（ループ終了） + OpBuffer[obp++]=(char)0x75; + OpBuffer[obp++]=(char)0x05; + } + break; + } + } + + //jmp ... + OpBuffer[obp++]=(char)0xE9; + *((long *)(OpBuffer+obp))=dwContinueAddress-(obp+sizeof(long)); + obp+=sizeof(long); + pobj_TempSchedule->unlock(); + pobj_TempSchedule->unlock(); + + //jmp ... + OpBuffer[obp++]=(char)0xE9; + int je_schedule=obp; + obp+=sizeof(long); + pobj_TempSchedule->lock(&je_schedule); + + //レキシカルスコープをレベルダウン + obj_LexScopes.End(); + + *((long *)(OpBuffer+je_schedule))=obp-(je_schedule+sizeof(long)); //jmpジャンプ先のオフセット値 + pobj_TempSchedule->unlock(); + + //Continueアドレスを復元 + dwContinueAddress=dwTempContinue; +} +void OpcodeContinue(void){ + extern DWORD dwContinueAddress; + + if(dwContinueAddress==-1){ + SetError(12,"Continue",cp); + return; + } + + //jmp ...(Continue addr) + OpBuffer[obp++]=(char)0xE9; + + *((long *)(OpBuffer+obp))=dwContinueAddress-(obp+sizeof(long)); + obp+=sizeof(long); +} + +void OpcodeExitSub(void){ + extern DWORD *pExitSubSchedule; + extern int ExitSubScheduleNum; + extern HANDLE hHeap; + + if( UserProc::IsGlobalAreaCompiling() ){ + SetError(12,"Exit Sub/Function",cp); + return; + } + + //未解放のローカルオブジェクトのデストラクタを呼び出す + obj_LexScopes.CallDestructorsOfReturn(); + + //jmp ...(End Sub/Function) + OpBuffer[obp++]=(char)0xE9; + + pExitSubSchedule=(DWORD *)HeapReAlloc(hHeap,0,pExitSubSchedule,(ExitSubScheduleNum+1)*sizeof(DWORD)); + pExitSubSchedule[ExitSubScheduleNum]=obp; + ExitSubScheduleNum++; + + obp+=sizeof(long); +} + +void AddCaseSchedule(void){ + extern DWORD *pCaseSchedule; + extern int CaseScheduleNum; + extern HANDLE hHeap; + + pCaseSchedule=(DWORD *)HeapReAlloc(hHeap,0,pCaseSchedule,(CaseScheduleNum+1)*sizeof(DWORD)); + pCaseSchedule[CaseScheduleNum]=obp; + CaseScheduleNum++; +} +void OpcodeSelect( const char *lpszParms ){ + extern DWORD *pCaseSchedule; + extern int CaseScheduleNum; + extern int NowCaseSchedule; + extern HANDLE hHeap; + extern char *basbuf; + int i,i2,i3,NowCaseCp; + char temporary[VN_SIZE]; + + DWORD *temp_pCaseSchedule; + int temp_CaseScheduleNum; + int temp_NowCaseSchedule; + + temp_pCaseSchedule=pCaseSchedule; + temp_CaseScheduleNum=CaseScheduleNum; + temp_NowCaseSchedule=NowCaseSchedule; + pCaseSchedule=(DWORD *)HeapAlloc(hHeap,0,1); + CaseScheduleNum=0; + NowCaseSchedule=0; + + int reg1=REG_RAX; + Type type1; + if( !NumOpe(®1,lpszParms,Type(), type1 ) ){ + return; + } + + if(type1.IsDouble()){ + //movsd qword ptr[rsp+offset],xmm_reg ※スタックフレームを利用 + pobj_sf->push(reg1,sizeof(double)); + } + else if(type1.IsSingle()){ + //movss dword ptr[rsp+offset],xmm_reg ※スタックフレームを利用 + pobj_sf->push(reg1,sizeof(float)); + } + else{ + ExtendTypeTo64(type1.GetBasicType(),reg1); + + //mov qword ptr[rsp+offset],reg ※スタックフレームを利用 + pobj_sf->push(reg1); + } + + for(i=cp;;i++){ + if(basbuf[i]=='\0'){ + HeapDefaultFree(pCaseSchedule); + pCaseSchedule=temp_pCaseSchedule; + CaseScheduleNum=temp_CaseScheduleNum; + NowCaseSchedule=temp_NowCaseSchedule; + SetError(22,"Select",cp); + return; + } + if(basbuf[i]==1&&basbuf[i+1]==ESC_SELECTCASE){ + for(i2=0;;i++){ + if(basbuf[i]==1&&basbuf[i+1]==ESC_SELECTCASE) i2++; + if(basbuf[i]==1&&basbuf[i+1]==ESC_ENDSELECT){ + i2--; + if(i2==0) break; + } + } + continue; + } + if(basbuf[i]==1&&basbuf[i+1]==ESC_ENDSELECT) break; + + if(basbuf[i]==1&&basbuf[i+1]==ESC_CASE){ + NowCaseCp=i; + + i++; + while(1){ + for(i++,i2=0;;i++,i2++){ + if(basbuf[i]=='\"'){ + i3=GetStringInQuotation(temporary+i2,basbuf+i); + i+=i3-1; + i2+=i3-1; + continue; + } + if(basbuf[i]=='('){ + i3=GetStringInPare(temporary+i2,basbuf+i); + i+=i3-1; + i2+=i3-1; + continue; + } + if(basbuf[i]=='['){ + i3=GetStringInBracket(temporary+i2,basbuf+i); + i+=i3-1; + i2+=i3-1; + continue; + } + + if(IsCommandDelimitation(basbuf[i])){ + temporary[i2]=0; + break; + } + if(basbuf[i]==','){ + temporary[i2]=0; + break; + } + + temporary[i2]=basbuf[i]; + } + + //エラー用 + i2=cp; + cp=NowCaseCp; + + int reg2=REG_RDX; + Type type2; + if( !NumOpe(®2,temporary,type1,type2) ){ + return; + } + + cp=i2; + + if(type1.IsObject()){ + std::vector subs; + type1.GetClass().GetMethods().Enum( CALC_EQUAL, subs ); + if( subs.size() == 0 ){ + return; + } + + Parameters params; + params.push_back( new Parameter( "", Type( type2 ) ) ); + + //オーバーロードを解決 + UserProc *pUserProc; + pUserProc=OverloadSolution("==",subs, params, NULL); + + delete params[0]; + + if(!pUserProc){ + //エラー + return; + } + + + //実体オブジェクト + if(reg2!=REG_RDX){ + //mov rdx,reg2 + op_mov_RR(REG_RDX,reg2); + } + + //mov rcx,qword ptr[rsp+offset] ※スタックフレームから参照 + pobj_sf->ref(REG_RCX); + + //call operator_proc ※ ==演算子 + op_call(pUserProc); + + //test rax,rax + op_test(REG_RAX,REG_RAX); + + //jne ... + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x85; + } + else{ + if(type1.IsDouble()){ + int xmm_reg; + if(IsXmmReg(reg2)) xmm_reg=reg2; + else xmm_reg=REG_XMM5; + ChangeTypeToXmm_Double(type2.GetBasicType(),xmm_reg,reg2); + + //movsd xmm4,qword ptr[rsp+offset] ※スタックフレームから参照 + pobj_sf->ref(REG_XMM4,sizeof(double)); + + //comiss xmm_reg1,xmm_reg2 + op_comisd(xmm_reg,REG_XMM4); + } + else if(type1.IsSingle()){ + int xmm_reg; + if(IsXmmReg(reg2)) xmm_reg=reg2; + else xmm_reg=REG_XMM5; + ChangeTypeToXmm_Single(type2.GetBasicType(),xmm_reg,reg2); + + //movss xmm4,dword ptr[rsp+offset] ※スタックフレームから参照 + pobj_sf->ref(REG_XMM4,sizeof(float)); + + //comiss xmm_reg1,xmm_reg2 + op_comiss(xmm_reg,REG_XMM4); + } + else{ + //その他整数型 + + i2=NeutralizationType(type1.GetBasicType(),-1,type2.GetBasicType(),-1); + + //mov r14,qword ptr[rsp+offset] ※スタックフレームから参照 + pobj_sf->ref(REG_R14); + + //cmp reg2,r14 + op_cmp_reg(GetTypeSize(i2,-1),reg2,REG_R14); + } + + //je ... + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x84; + } + AddCaseSchedule(); + obp+=sizeof(long); + + if(basbuf[i]!=',') break; + } + } + if(basbuf[i]==1&&basbuf[i+1]==ESC_CASEELSE){ + //jmp ... + OpBuffer[obp++]=(char)0xE9; + AddCaseSchedule(); + obp+=sizeof(long); + } + } + + //スタックフレームを1スペースだけ解除 + pobj_sf->pop(REG_NON); + + //レキシカルスコープをレベルアップ + obj_LexScopes.Start( obp, SCOPE_TYPE_SELECT ); + + //Select Case内をコンパイル + CompileBuffer(ESC_ENDSELECT,0); + + //jmp EndSelect + OpBuffer[obp++]=(char)0xE9; + AddCaseSchedule(); + obp+=sizeof(long); + + //最終スケジュール + for(i=NowCaseSchedule;ipush(REG_RAX); + + + if(Parameter[0]=='*'){ + i=GetLabelAddress(Parameter+1,0); + + //jmp ... + OpBuffer[obp++]=(char)0xE9; + if(i==-1){ + pGotoLabelSchedule=(GOTOLABELSCHEDULE *)HeapReAlloc(hHeap,0,pGotoLabelSchedule,(GotoLabelScheduleNum+1)*sizeof(GOTOLABELSCHEDULE)); + pGotoLabelSchedule[GotoLabelScheduleNum].pName=(char *)HeapAlloc(hHeap,0,lstrlen(Parameter+1)+1); + lstrcpy(pGotoLabelSchedule[GotoLabelScheduleNum].pName,Parameter+1); + pGotoLabelSchedule[GotoLabelScheduleNum].pos=obp; + pGotoLabelSchedule[GotoLabelScheduleNum].now_cp=cp; + GotoLabelScheduleNum++; + } + *((long *)(OpBuffer+obp))=i-(obp+sizeof(long)); + obp+=sizeof(long); + } + else{ + LineNum=atoi(Parameter); + i=GetLabelAddress(0,LineNum); + + //jmp ... + OpBuffer[obp++]=(char)0xE9; + if(i==-1){ + pGotoLabelSchedule=(GOTOLABELSCHEDULE *)HeapReAlloc(hHeap,0,pGotoLabelSchedule,(GotoLabelScheduleNum+1)*sizeof(GOTOLABELSCHEDULE)); + pGotoLabelSchedule[GotoLabelScheduleNum].pName=0; + pGotoLabelSchedule[GotoLabelScheduleNum].line=LineNum; + pGotoLabelSchedule[GotoLabelScheduleNum].pos=obp; + pGotoLabelSchedule[GotoLabelScheduleNum].now_cp=cp; + GotoLabelScheduleNum++; + } + *((long *)(OpBuffer+obp))=i-(obp+sizeof(long)); + obp+=sizeof(long); + } + + *((long *)(OpBuffer+schedule2))=obp-schedule; + + //※スタックフレームを元に戻す + pobj_sf->pop(REG_NON); + + SetError(-1,"Gosub ～ Returnステートメントは64ビットコンパイラで利用することはできません。",cp); +} +void OpcodeReturn(char *Parameter){ + if( UserProc::IsGlobalAreaCompiling() ){ + SetError(62,NULL,cp); + } + else{ + //戻り値をセット + if(Parameter[0]){ + UserProc &proc = UserProc::CompilingUserProc(); + + const char *temp = "_System_ReturnValue"; + if(proc.GetName()[0]==1&&proc.GetName()[1]==ESC_OPERATOR) + { + } + else{ + temp=proc.GetName().c_str(); + } + + char temporary[VN_SIZE]; + sprintf(temporary,"%s=%s",temp,Parameter); + OpcodeCalc(temporary); + } + + //プロシージャを抜け出す（C言語のreturnと同様の処理を行う） + OpcodeExitSub(); + } +} + + +//////////// +// ポインタ +//////////// + +void OpcodeSetPtrData(char *Parameter,int type){ + int i; + char temporary[VN_SIZE]; + + if(Parameter[0]=='('){ + i=JumpStringInPare(Parameter,1); + if(Parameter[i+1]=='\0'){ + for(i=0;;i++){ + Parameter[i]=Parameter[i+1]; + if(Parameter[i]=='\0') break; + } + Parameter[i-1]=0; + } + } + + //第１パラメータを取得 + i=GetOneParameter(Parameter,0,temporary); + if(!Parameter[i]){ + SetError(1,NULL,cp); + return; + } + + int reg_ptr=REG_RAX; + Type resultType; + if( !NumOpe(®_ptr,temporary,Type(),resultType) ){ + return; + } + if(!resultType.IsWhole()){ + SetError(11,Parameter,cp); + return; + } + + //結果を格納しているレジスタをブロッキング + pobj_BlockReg->lock(reg_ptr); + + //第２パラメータを取得 + i=GetOneParameter(Parameter,i,temporary); + if(Parameter[i]){ + SetError(1,NULL,cp); + return; + } + + int temp_reg=REG_NON; + if( !NumOpe(&temp_reg,temporary,Type(),resultType) ){ + return; + } + + //レジスタのブロッキングを解除 + pobj_BlockReg->clear(); + + if(type==DEF_DOUBLE){ + ChangeTypeToXmm_Double(resultType.GetBasicType(),REG_XMM0,temp_reg); + + //movsd qword ptr[reg_ptr],xmm0 + op_movsd_MR(REG_XMM0,reg_ptr,0,MOD_BASE); + } + else if(type==DEF_SINGLE){ + ChangeTypeToXmm_Single(resultType.GetBasicType(),REG_XMM0,temp_reg); + + //movss dword ptr[reg_ptr],xmm0 + op_movss_MR(REG_XMM0,reg_ptr,0,MOD_BASE); + } + else{ + ChangeTypeToWhole(resultType.GetBasicType(),type,REG_RCX,temp_reg); + + //mov ptr[reg_ptr],rcx + op_mov_MR(GetTypeSize(type,-1),REG_RCX,reg_ptr,0,MOD_BASE); + } +} Index: trunk/abdev/BasicCompiler64/Compile_Var.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Compile_Var.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Compile_Var.cpp (revision 149) @@ -0,0 +1,1331 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +//変数 +Variables globalVars; +int AllGlobalVarSize; +int AllInitGlobalVarSize; + +int AllLocalVarSize; + + +void SetRelativeOffset( Type &resultType, RELATIVE_VAR *pRelativeVar,const char *lpPtrOffset){ + ///////////////////////////////////////////// + // 先頭ポインタをr12に取得してメモリへ退避 + ///////////////////////////////////////////// + + SetReg_WholeVariable(DEF_INT64,pRelativeVar,REG_R11); + + //mov qword ptr[rsp+offset],r11 ※スタックフレームを利用 + pobj_sf->push(REG_R11); + + + //////////////////////////////// + // 添え字を計算する + //////////////////////////////// + + int reg=REG_NON; + Type type; + NumOpe( ®, lpPtrOffset, Type(), type ); + if( !type.IsWhole() ){ + SetError(46,NULL,cp); + } + ExtendTypeTo64(type.GetBasicType(),reg); + + if(reg==REG_R14){ + //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R14); + } + + if( resultType.PtrLevel() ){ + resultType.PtrLevelDown(); + + int typeSize = resultType.GetSize(); + if(typeSize>=2){ + //imul reg,i2 + op_imul_RV(sizeof(_int64),reg,typeSize); + } + } + else{ + //エラー + SetError(1,NULL,cp); + return; + } + + + ////////////////////////////// + // 先頭ポインタに添え字を加算 + ////////////////////////////// + + //mov r11,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R11); + + //add r11,reg + op_add64_reg(REG_R11,reg); +} +void SetRelativeOffset( RELATIVE_VAR &relativeVar ){ + if(relativeVar.dwKind==VAR_DIRECTMEM){ + //mov r11,qword ptr[r11] + op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE); + } + else{ + //直接参照に切り替え + SetVarPtrToReg(REG_R12,&relativeVar); + relativeVar.dwKind=VAR_DIRECTMEM; + + //mov r11,qword ptr[r12] + op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE); + } +} +bool GetArrayOffset(const int *SubScripts,char *array, const Type &type){ + extern HANDLE hHeap; + int i,i2,i3,i4; + char temporary[VN_SIZE],*pParm[MAX_PARMS]; + + for(i=0,i2=0,i3=0;;i++,i2++){ + if(array[i]=='('){ + i4=GetStringInPare(temporary+i2,array+i); + i+=i4-1; + i2+=i4-1; + continue; + } + if(array[i]=='['){ + i4=GetStringInBracket(temporary+i2,array+i); + i+=i4-1; + i2+=i4-1; + continue; + } + if(array[i]==','||array[i]=='\0'){ + if(SubScripts[i3]==-1){ + for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]); + return false; + } + + temporary[i2]=0; + + pParm[i3]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1); + lstrcpy(pParm[i3],temporary); + + i3++; + + if(array[i]=='\0'){ + if(SubScripts[i3]!=-1){ + for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]); + return false; + } + break; + } + + i2=-1; + continue; + } + temporary[i2]=array[i]; + } + + //mov qword ptr[rsp+offset],r11 ※スタックフレームを利用 + pobj_sf->push(REG_R11); + + //xor r12,r12 + op_zero_reg(REG_R12); + + for(i=i3-1;i>=0;i--){ + //mov qword ptr[rsp+offset],r12 ※スタックフレームを利用 + pobj_sf->push(REG_R12); + + int reg=REG_NON; + Type type; + BOOL bUseHeap; + NumOpe( ®, pParm[i], Type( DEF_LONG ), type, &bUseHeap ); + if( type.IsObject() ){ + //キャスト演算子のオーバーロードに対応する + CallCastOperatorProc(reg, + type, + bUseHeap, Type(DEF_LONG) ); + type.SetBasicType( DEF_LONG ); + } + + if( !type.IsWhole() ){ + SetError(46,NULL,cp); + } + ExtendTypeTo64( type.GetBasicType(), reg ); + + if(reg==REG_R14){ + //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R14); + } + + //mov r12,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R12); + + for(i2=i+1,i4=1;i2pop(REG_R11); + + //add r11,r12 + OpBuffer[obp++]=(char)0x4D; + OpBuffer[obp++]=(char)0x03; + OpBuffer[obp++]=(char)0xDC; + + return true; +} +bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const CClass &objClass, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess){ + + ////////////////////////////////////// + // クラス、配列の構成要素を解析する + ////////////////////////////////////// + + char VarName[VN_SIZE]; //変数名 + char array[VN_SIZE]; //第1次配列 + char lpPtrOffset[VN_SIZE]; //第2次配列 + char NestMember[VN_SIZE]; //入れ子メンバ + CClass::RefType refType; + lstrcpy(VarName,member); + if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false; + + + //////////////////////////// + // メンバオフセットを取得 + //////////////////////////// + + int memberIndex; + int offset = objClass.GetMemberOffset( VarName, &memberIndex ); + if( memberIndex == objClass.GetDynamicMembers().size() ){ + if(isErrorEnabled) SetError(103,VarName,cp); + return false; + } + + CMember *pMember = objClass.GetDynamicMembers()[memberIndex]; + + + //アクセシビリティをチェック + if(&objClass==pobj_CompilingClass){ + //同一クラスオブジェクトの場合はプライベートアクセスを容認する + if(pMember->IsNoneAccess()){ + if(isErrorEnabled) SetError(107,VarName,cp); + return false; + } + } + else{ + if((bPrivateAccess==0&&pMember->IsPrivate())|| + pMember->IsNoneAccess()){ + if(isErrorEnabled) SetError(107,VarName,cp); + return false; + } + else if(bPrivateAccess==0&&pMember->IsProtected()){ + if(isErrorEnabled) SetError(108,VarName,cp); + return false; + } + } + + //Const定義の場合は書き込みアクセスを制限する + //※コンストラクタをコンパイル中の場合は例外的に許可する + if( pMember->IsConst() && //定数メンバである + isWriteAccess && //書き込みアクセスを要求されている + objClass.IsCompilingConstructor() == false //コンストラクタ コンパイル中を除く + ){ + //Const定義の変数に書き込みアクセスをしようとした場合 + SetError(61,VarName,cp); + } + + resultType = pMember->GetType(); + + //ポインタ変数の場合 + if( resultType.IsPointer() ){ + if(pMember->SubScripts[0]==-1){ + lstrcpy(lpPtrOffset,array); + array[0]=0; + } + } + else{ + if(lpPtrOffset[0]){ + if(isErrorEnabled) SetError(16,member,cp); + return false; + } + } + + if(offset){ + //add r11,offset + OpBuffer[obp++]=(char)0x49; + OpBuffer[obp++]=(char)0x81; + OpBuffer[obp++]=(char)0xC3; + *((long *)(OpBuffer+obp))=offset; + obp+=sizeof(long); + } + + if(array[0]){ + //配列オフセット + if(!GetArrayOffset(pMember->SubScripts,array,pMember->GetType())){ + if(isErrorEnabled) SetError(14,member,cp); + } + } + else if(pMember->SubScripts[0]!=-1){ + resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR ); + } + + if(NestMember[0]){ + //入れ子構造の場合 + + if( resultType.IsObject() || resultType.IsStruct() ){ + if( refType != CClass::Dot ){ + if(isErrorEnabled) SetError(104,member,cp); + return false; + } + + if( resultType.IsObject() ){ + // 参照内容へのポインタを抽出 + SetRelativeOffset( *pRelativeVar ); + } + } + else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){ + //構造体ポインタ型メンバ変数 + + if(lpPtrOffset[0]){ + //pObj[n].member + if( ( resultType.IsObjectPtr() || resultType.IsStructPtr() ) + && refType != CClass::Dot ){ + if(isErrorEnabled) SetError(104,member,cp); + return false; + } + + //直接参照に切り替え + SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset); + pRelativeVar->dwKind=VAR_DIRECTMEM; + + lpPtrOffset[0]=0; + } + else{ + //pObj->member + if( (resultType.IsObjectPtr() || resultType.IsStructPtr() ) + && refType != CClass::Pointer ){ + if(isErrorEnabled) SetError(104,member,cp); + return false; + } + + SetRelativeOffset( *pRelativeVar ); + } + } + else if( resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_OBJECT,2) + || resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_STRUCT,2)){ + //構造体ポインタのポインタ型メンバ変数 + + if(lpPtrOffset[0]){ + //ppObj[n]->member + if( refType != CClass::Pointer ){ + if(isErrorEnabled) SetError(104,member,cp); + return false; + } + + //直接参照に切り替え + SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset); + pRelativeVar->dwKind=VAR_DIRECTMEM; + + lpPtrOffset[0]=0; + + //mov r11,qword ptr[r11] + op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE); + } + else{ + if(isErrorEnabled) SetError(104,member,cp); + return false; + } + } + + if(!_member_offset( + isErrorEnabled, + isWriteAccess, + pMember->GetType().GetClass(), + NestMember, + pRelativeVar, + resultType, + 0)) return false; + } + + if(lpPtrOffset[0]){ + SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset); + pRelativeVar->dwKind=VAR_DIRECTMEM; + } + + return true; +} + +int LocalVar_ThisPtrOffset; +void SetThisPtrToReg(int reg){ + //自身のオブジェクトのThisポインタをregにコピー + + RELATIVE_VAR RelativeVar; + RelativeVar.dwKind=VAR_LOCAL; + RelativeVar.bOffsetOffset=0; + RelativeVar.offset=-LocalVar_ThisPtrOffset; + + SetReg_WholeVariable(DEF_PTR_VOID,&RelativeVar,reg); +} +bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss){ + char variable[VN_SIZE]; + + if(NameBuffer[0]=='.'){ + GetWithName(variable); + lstrcat(variable,NameBuffer); + } + else lstrcpy(variable,NameBuffer); + + // 名前空間を分離 + char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE]; + Smoothie::Meta::namespaceScopesCollection.SplitNamespace( variable, namespaceStr, simpleName ); + + // 先頭オブジェクトまたはクラス名と入れ子メンバに分割 + CClass::RefType refType; + char member[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE]; + GetVarFormatString(simpleName,array,lpPtrOffset,member,refType); + + // 名前空間を分離していた場合は結合 + char VarName[VN_SIZE]; + if( namespaceStr[0] ){ + sprintf( VarName, "%s.%s", namespaceStr, simpleName ); + } + else{ + lstrcpy( VarName, simpleName ); + } + + const int *pSubScripts; + bool bConst = false; + + + if( UserProc::IsLocalAreaCompiling() ){ + ////////////////// + // ローカル変数 + ////////////////// + + const Variable *pVar = UserProc::CompilingUserProc().localVars.BackSearch( VarName ); + if( pVar ){ + //ポインタ変数の場合 + if( pVar->IsPointer() ){ + if( !pVar->IsArray() ){ + lstrcpy(lpPtrOffset,array); + array[0]=0; + } + } + else{ + if(lpPtrOffset[0]){ + SetError(16,variable,cp); + pRelativeVar->dwKind=NON_VAR; + return false; + } + } + + pRelativeVar->offset=-pVar->offset; + pRelativeVar->bOffsetOffset=0; + if( pVar->IsRef() ){ + // 参照型 + pRelativeVar->dwKind = VAR_REFLOCAL; + } + else pRelativeVar->dwKind=VAR_LOCAL; + resultType = *pVar; + pSubScripts=pVar->GetSubScriptsPtr(); + bConst = pVar->IsConst(); + + goto ok; + } + } + + + if(pobj_CompilingClass){ + ////////////////////// + // クラスメンバの参照 + ////////////////////// + + if(lstrcmpi(variable,"This")==0){ + //自身のオブジェクトのThisポインタをr11にコピー + SetThisPtrToReg(REG_R11); + + pRelativeVar->dwKind=VAR_DIRECTMEM; + + resultType.SetType( DEF_OBJECT, pobj_CompilingClass ); + return true; + } + + if(memicmp(variable,"This.",5)==0){ + //Thisオブジェクトのメンバを参照するとき + SlideString(variable+5,-5); + lstrcpy(VarName,variable); + } + else{ + //クラス内メンバを参照するとき（通常） + + bool isFound = false; + BOOST_FOREACH( CMember *pMember, pobj_CompilingClass->GetDynamicMembers() ){ + if( pMember->GetName() == VarName ){ + isFound = true; + break; + } + } + if( !isFound ) goto NonClassMember; + } + + //Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき + //（コンストラクタ、デストラクタ内を除く） + const CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo(); + if( isWriteAccess && + pMethod->IsConst() && + pobj_CompilingClass->IsCompilingConstructor() == false && + pobj_CompilingClass->IsCompilingDestructor() == false + ){ + SetError(131, NULL, cp ); + } + + //自身のオブジェクトのThisポインタをr11にコピー + SetThisPtrToReg(REG_R11); + + pRelativeVar->dwKind=VAR_DIRECTMEM; + if(!_member_offset( + isErrorEnabled, + isWriteAccess, + *pobj_CompilingClass, + variable, + pRelativeVar, + resultType,1)) return false; + return true; + } + +NonClassMember: + + { + const Variable *pVar; + + ////////////////////////// + // 静的ローカル変数 + // ※"Static.Object.Method.Variable" + ////////////////////////// + + char temporary[VN_SIZE]; + if( UserProc::IsLocalAreaCompiling() ){ + GetNowStaticVarFullName(VarName,temporary); + + pVar = globalVars.Find( temporary ); + if( pVar ){ + goto GlobalOk; + } + } + + + ////////////////////////// + // クラスの静的メンバ + ////////////////////////// + + if(member[0]){ + lstrcpy(temporary,member); + + // TODO: 名前空間を考慮したコードになっていない + + char tempMember[VN_SIZE]; + char tempArray[VN_SIZE]; + { + CClass::RefType refType; + GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType ); + } + + int typeDefIndex = Smoothie::Meta::typeDefs.GetIndex( VarName ); + if( typeDefIndex != -1 ){ + // TypeDef後の型名だったとき + lstrcpy( VarName, Smoothie::Meta::typeDefs[typeDefIndex].GetBaseName().c_str() ); + } + + char temp2[VN_SIZE]; + sprintf(temp2,"%s.%s",VarName,temporary); + pVar = globalVars.Find( temp2 ); + if( pVar ){ + lstrcpy(member,tempMember); + lstrcpy(array,tempArray); + goto GlobalOk; + } + } + + if(pobj_CompilingClass){ + //自身のクラスから静的メンバを参照する場合 + char temp2[VN_SIZE]; + sprintf(temp2,"%s.%s",pobj_CompilingClass->GetName().c_str(),VarName); + pVar = globalVars.Find( temp2 ); + if( pVar ){ + goto GlobalOk; + } + } + + ///////////////////// + // グローバル変数 + ///////////////////// + + pVar = globalVars.BackSearch( VarName ); + if( pVar ){ + goto GlobalOk; + } + + if(isErrorEnabled) SetError(3,variable,cp); + pRelativeVar->dwKind=NON_VAR; + return false; + + + +GlobalOk: + //ポインタ変数の場合 + if( pVar->IsPointer() ){ + if( !pVar->IsArray() ){ + lstrcpy(lpPtrOffset,array); + array[0]=0; + } + } + else{ + if(lpPtrOffset[0]){ + SetError(16,variable,cp); + pRelativeVar->dwKind=NON_VAR; + return false; + } + } + + pRelativeVar->offset=pVar->offset; + pRelativeVar->bOffsetOffset=0; + if( pVar->IsRef() ){ + // 参照型 + pRelativeVar->dwKind = VAR_REFGLOBAL; + } + else pRelativeVar->dwKind=VAR_GLOBAL; + resultType = *pVar; + pSubScripts=pVar->GetSubScriptsPtr(); + bConst = pVar->IsConst(); + } + + + +ok: + + if( bConst && isWriteAccess ){ + //Const定義の変数に書き込みアクセスをしようとした場合 + if( resultType.IsObject() ){ + //オブジェクト定数 + SetError(130, VarName, cp ); + } + else{ + //一般のConst変数 + SetError(61,VarName,cp); + } + } + + if(array[0]==0&&pSubScripts[0]!=-1){ + //配列の先頭ポインタを示す場合 + resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR ); + if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM); + return true; + } + + if( array[0] || member[0] ){ + //xor r11,r11（r11を0に初期化する） + //※r11は変数ベースアドレスからの相対オフセットを示す + op_zero_reg(REG_R11); + + pRelativeVar->bOffsetOffset=1; + } + if(array[0]){ + if(!GetArrayOffset(pSubScripts,array,resultType)){ + SetError(14,variable,cp); + pRelativeVar->dwKind=NON_VAR; + return false; + } + } + if(member[0]){ + if( resultType.IsObject() || resultType.IsStruct() ){ + //実態オブジェクトのメンバを参照（obj.member） + if( refType != CClass::Dot ){ + SetError(104,VarName,cp); + pRelativeVar->dwKind=NON_VAR; + return false; + } + + if( resultType.IsObject() ){ + // 参照内容へのポインタを抽出 + SetRelativeOffset( *pRelativeVar ); + } + } + else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){ + //ポインタオブジェクトが示すメンバを参照 + if(lpPtrOffset[0]){ + //pObj[n].member + if( refType != CClass::Dot ){ + SetError(104,VarName,cp); + pRelativeVar->dwKind=NON_VAR; + return false; + } + SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset); + pRelativeVar->dwKind=VAR_DIRECTMEM; + } + else{ + //pObj->member + if( refType != CClass::Pointer ){ + SetError(104,VarName,cp); + pRelativeVar->dwKind=NON_VAR; + return false; + } + + SetVarPtrToReg(REG_R12,pRelativeVar); + pRelativeVar->dwKind=VAR_DIRECTMEM; + + //mov r11,qword ptr[r12] + op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE); + } + } + else if( resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_OBJECT,2) || resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_STRUCT,2)){ + //ポインタオブジェクトが示すメンバを参照 + if(lpPtrOffset[0]){ + //ppObj[n]->member + if( refType != CClass::Pointer ){ + SetError(104,VarName,cp); + pRelativeVar->dwKind=NON_VAR; + return false; + } + + SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset); + pRelativeVar->dwKind=VAR_DIRECTMEM; + + + SetVarPtrToReg(REG_R12,pRelativeVar); + + //mov r11,qword ptr[r12] + op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE); + } + else{ + SetError(104,VarName,cp); + pRelativeVar->dwKind=NON_VAR; + return false; + } + } + else{ + SetError(102,VarName,cp); + pRelativeVar->dwKind=NON_VAR; + return false; + } + + if(!_member_offset( + isErrorEnabled, + isWriteAccess, + resultType.GetClass(), + member,pRelativeVar,resultType,0)) return false; + + return true; + } + + if(lpPtrOffset[0]){ + SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset); + pRelativeVar->dwKind=VAR_DIRECTMEM; + } + + return true; +} + +bool SetInitGlobalData(int offset,const Type &type,const int *SubScripts,const char *lpszInitBuf){ + extern BYTE *initGlobalBuf; + int i,i2,i3; + char temporary[VN_SIZE]; + char InitBuf[VN_SIZE]; + lstrcpy( InitBuf, lpszInitBuf ); + + if(InitBuf[0]=='['){ + SlideString(InitBuf+1,-1); + InitBuf[lstrlen(InitBuf)-1]=0; + + int typeSize = type.GetSize(); + + if(SubScripts[0]!=-1){ + typeSize*=JumpSubScripts(SubScripts+1); + i=0; + i2=0; + while(1){ + if(SubScripts[0]GetName().c_str(), NULL ); + + if(!SetInitGlobalData(offset+i3, + pMember->GetType(), + pMember->SubScripts, + temporary)) return false; + } + return true; + } + + SetError(41,0,cp); + return false; + } + + + /////////////////////////////////////// + // 単発式（[]で囲まれていない） + /////////////////////////////////////// + + if( type.IsObject() || type.IsStruct() ){ + //オブジェクトまたは構造体の場合はありえない + SetError(300,NULL,cp); + return false; + } + + if(SubScripts[0]!=-1){ + SetError(41,0,cp); + return false; + } + + double dbl; + _int64 i64data; + Type calcType; + + if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){ + //動的データだった場合 + return false; + } + if( calcType.IsReal() ){ + memcpy(&dbl,&i64data,sizeof(double)); + i64data=(_int64)dbl; + } + else dbl=(double)i64data; + + //型チェック + CheckDifferentType( + type, + calcType, + 0,0); + + if( type.IsDouble() ){ + *(double *)(initGlobalBuf+offset)=(double)dbl; + } + else if( type.IsSingle() ){ + *(float *)(initGlobalBuf+offset)=(float)dbl; + } + else if( type.Is64() || type.IsPointer() ){ + if(type.GetBasicType()==typeOfPtrChar){ + //文字列定数のとき + + char *temp; + temp=(char *)i64data; + i2=dataTable.AddString( temp ); + HeapDefaultFree(temp); + + //mov rax,DataPos + op_mov_RV(sizeof(_int64),REG_RAX,i2); + obp-=sizeof(long); + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + + //mov qword ptr[offset],rax + op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + else{ + *(_int64 *)(initGlobalBuf+offset)=i64data; + } + } + else if( type.IsDWord() || type.IsLong() ){ + *(DWORD *)(initGlobalBuf+offset)=(DWORD)i64data; + } + else if( type.IsWord() || type.IsInteger() ){ + *(WORD *)(initGlobalBuf+offset)=(WORD)i64data; + } + else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){ + *(BYTE *)(initGlobalBuf+offset)=(BYTE)i64data; + } + + return true; +} +bool InitLocalVar(int offset,const Type &type,const int *SubScripts,const char *lpszInitBuf){ + int i,i2,i3; + char temporary[VN_SIZE]; + char InitBuf[VN_SIZE]; + lstrcpy( InitBuf, lpszInitBuf ); + + if(InitBuf[0]=='['){ + SlideString(InitBuf+1,-1); + InitBuf[lstrlen(InitBuf)-1]=0; + + int typeSize = type.GetSize(); + + if(SubScripts[0]!=-1){ + typeSize*=JumpSubScripts(SubScripts+1); + i=0; + i2=0; + while(1){ + if(SubScripts[0]GetName().c_str(), NULL ); + + if(!InitLocalVar(offset+i3, + pMember->GetType(), + pMember->SubScripts, + temporary)) return false; + + if(InitBuf[i]=='\0') break; + } + return true; + } + + SetError(41,0,cp); + return false; + } + + + /////////////////////////////////////// + // 単発式（[]で囲まれていない） + /////////////////////////////////////// + + if(SubScripts[0]!=-1){ + SetError(41,0,cp); + return false; + } + + double dbl; + _int64 i64data; + Type calcType; + + if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){ + //動的データだった場合 + return false; + } + if( calcType.IsReal() ){ + memcpy(&dbl,&i64data,sizeof(double)); + i64data=(_int64)dbl; + } + else dbl=(double)i64data; + + //型チェック + CheckDifferentType( + type, + calcType, + 0,0); + + if( type.IsDouble() ){ + memcpy(&i64data,&dbl,sizeof(double)); + + //mov rax,i64data + op_mov64_ToReg(REG_RAX,i64data); + + //mov qword ptr[rsp+offset],rax + op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else if( type.IsSingle() ){ + float flt; + flt=(float)dbl; + + //mov dword ptr[rsp+offset],value + op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,*(int *)&flt); + obp-=sizeof(long)+sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long)+sizeof(long); + } + else if( type.Is64() || type.IsPointer() ){ + if(type.GetBasicType()==typeOfPtrChar ){ + //文字列定数のとき + + char *temp; + temp=(char *)i64data; + i2=dataTable.AddString( temp ); + HeapDefaultFree(temp); + + //mov rax,i2 + op_mov_RV(sizeof(_int64),REG_RAX,i2); + obp-=sizeof(long); + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + + //mov qword ptr[rsp+offset],rax + op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + if(i64data&0xFFFFFFFF00000000){ + //mov rax,i64data + op_mov64_ToReg(REG_RAX,i64data); + + //mov qword ptr[rsp+offset],rax + op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //mov qword ptr[rsp+offset],value + op_mov_MV(sizeof(_int64),REG_RSP,offset,USE_OFFSET,(int)i64data); + obp-=sizeof(long)+sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long)+sizeof(long); + } + } + } + else if( type.IsDWord() || type.IsLong() ){ + //mov dword ptr[rsp+offset],value + op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int)i64data); + obp-=sizeof(long)+sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long)+sizeof(long); + } + else if( type.IsWord() || type.IsInteger() ){ + //mov word ptr[rsp+offset],value + op_mov_MV(sizeof(short),REG_RSP,offset,USE_OFFSET,(int)i64data); + obp-=sizeof(long)+sizeof(short); + AddLocalVarAddrSchedule(); + obp+=sizeof(long)+sizeof(short); + } + else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){ + //mov byte ptr[rsp+offset],value + op_mov_MV(sizeof(char),REG_RSP,offset,USE_OFFSET,(int)i64data); + obp-=sizeof(long)+sizeof(char); + AddLocalVarAddrSchedule(); + obp+=sizeof(long)+sizeof(char); + } + return true; +} + +void dim( char *VarName,int *SubScripts,Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlags){ + if( UserProc::IsGlobalAreaCompiling() ){ + ///////////////////////// + // グローバル変数 + ///////////////////////// + + //OpcodeOthers( ( (string)"OutputDebugString(Ex\"" + VarName + "\r\n\")" ).c_str() ); + AddGlobalVariable(VarName,SubScripts,type,InitBuf,ConstractParameter,dwFlags); + } + else{ + ///////////////// + // ローカル変数 + ///////////////// + + if( UserProc::CompilingUserProc().localVars.DuplicateCheck( VarName ) ){ + //２重定義のエラー + SetError(15,VarName,cp); + return; + } + + bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false; + + Variable *pVar = new Variable( VarName, type, isConst ); + + if( SubScripts[0] != -1 ){ + //配列あり + pVar->SetArray( SubScripts ); + } + + //コンストラクタ用パラメータ + pVar->paramStrForConstructor = ConstractParameter; + + //レキシカルスコープ + pVar->ScopeLevel=obj_LexScopes.GetNowLevel(); + pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress(); + pVar->bLiving=TRUE; + + //エラー用 + pVar->source_code_address=cp; + + // 変数を追加 + UserProc::CompilingUserProc().localVars.push_back( pVar ); + + //アラインメントを考慮 + if( pVar->IsStruct() ){ + int alignment = pVar->GetClass().iAlign; + + if( alignment ){ + if( AllLocalVarSize % alignment ){ + AllLocalVarSize += alignment - (AllLocalVarSize % alignment); + } + } + + if( alignment == PTR_SIZE*2 ){ + // ポインタに要するサイズよりも一回り大きなアラインメントが指定されているとき + // （例:CONTEXT構造体など） + // 呼び出し側のオフセットズレを考慮する + + if( 0 == ( UserProc::CompilingUserProc().RealParams().GetMemorySize() + PTR_SIZE/*ret分*/ ) % alignment ){ + AllLocalVarSize += PTR_SIZE; + } + } + } + + AllLocalVarSize += pVar->GetMemorySize(); + pVar->offset = AllLocalVarSize; + + //レキシカルスコープ + pVar->ScopeLevel=obj_LexScopes.GetNowLevel(); + pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress(); + pVar->bLiving=TRUE; + + if(InitBuf[0]){ + //初期代入時のみ、書き込みアクセスを許可する + if( isConst ){ + pVar->ConstOff(); + } + + int result = 0; + if( !pVar->IsObject() ){ + result = InitLocalVar(-pVar->offset, + *pVar, + pVar->GetSubScriptsPtr(), + InitBuf); + } + + if(!result){ + //動的な式だった場合は代入演算を行う + char temporary[8192]; + sprintf(temporary,"%s=%s",VarName,InitBuf); + OpcodeCalc(temporary); + } + + if( isConst ){ + pVar->ConstOn(); + } + } + else{ + //0初期化 + + //mov r8, 0 + op_zero_reg( REG_R8 ); + + //mov rdx, VarSize + op_mov_RV( sizeof(_int64), REG_RDX, pVar->GetMemorySize() ); + + //mov rcx, rsp + op_mov_RR( REG_RCX, REG_RSP ); + + //add rcx, offset + op_add_RV( REG_RCX, -pVar->offset ); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + + //call FillMemory + DllProc *pDllProc; + pDllProc=GetDeclareHash("FillMemory"); + op_call( pDllProc ); + } + } + + //コンストラクタ呼び出し + if( type.IsObject() &&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){ + char objectSize[255]; + if( SubScripts[0] == -1 ){ + objectSize[0] = 0; + } + else{ + if( SubScripts[1] != -1 ){ + SetError(300,NULL,cp); + } + sprintf( objectSize, "%d", SubScripts[0] ); + } + Operator_New( type.GetClass(), objectSize, ConstractParameter, type ); + + Type tempType; + RELATIVE_VAR RelativeVar; + GetVarOffset( true, false, VarName, &RelativeVar, tempType ); + if( RelativeVar.dwKind == VAR_DIRECTMEM ){ + SetError(); + } + SetVariableFromRax( DEF_OBJECT, DEF_OBJECT, &RelativeVar ); + } +} +void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){ + if(!IsGeneralReg(reg)) SetError(300,NULL,cp); + + if(pRelativeVar->dwKind==VAR_GLOBAL){ + if(pRelativeVar->bOffsetOffset){ + //add r11,offset + OpBuffer[obp++]=(char)0x49; + OpBuffer[obp++]=(char)0x81; + OpBuffer[obp++]=(char)0xC3; + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + + //mov reg,r11 + op_mov_RR(reg,REG_R11); + } + else{ + //mov reg,offset + op_mov64_ToReg(reg,(int)pRelativeVar->offset); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + } + else if( pRelativeVar->dwKind == VAR_REFGLOBAL ){ + if(pRelativeVar->bOffsetOffset){ + //add r11,qword ptr[offset] + op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 ); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + else{ + //mov r11,qword ptr[offset] + op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + } + + goto directmem; + } + else if(pRelativeVar->dwKind==VAR_LOCAL){ + if(pRelativeVar->bOffsetOffset){ + //add r11,offset + OpBuffer[obp++]=(char)0x49; + OpBuffer[obp++]=(char)0x81; + OpBuffer[obp++]=(char)0xC3; + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + + //add r11,rsp + op_add64_reg(REG_R11,REG_RSP); + + //mov reg,r11 + op_mov_RR(reg,REG_R11); + } + else{ + //mov reg,rsp + op_mov_RR(reg,REG_RSP); + + //add reg,offset + op_add_RV(reg,(int)pRelativeVar->offset); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + } + else if( pRelativeVar->dwKind == VAR_REFLOCAL ){ + if(pRelativeVar->bOffsetOffset){ + //add r11,qword ptr[rsp+offset] + OpBuffer[obp++]=(char)0x4C; + OpBuffer[obp++]=(char)0x03; + OpBuffer[obp++]=(char)0x9C; + OpBuffer[obp++]=(char)0x24; + *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset; + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + else{ + //mov r11,qword ptr[rsp+offset] + op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32); + obp-=sizeof(long); + AddLocalVarAddrSchedule(); + obp+=sizeof(long); + } + + goto directmem; + } + else if(pRelativeVar->dwKind==VAR_DIRECTMEM){ +directmem: + //mov reg,r11 + op_mov_RR(reg,REG_R11); + } +} + +bool Compile_AddGlobalRootsForGc(){ + UserProc *pUserProc_AddGlobalRootPtr = GetClassMethod( "_System_CGarbageCollection", "AddGlobalRootPtr" ); + if( !pUserProc_AddGlobalRootPtr ){ + SetError(3, "_System_CGarbageCollection.AddGlobalRootPtr", -1 ); + return false; + } + + BOOST_FOREACH( const Variable *pVar, globalVars ){ + if( pVar->IsObject() || pVar->IsPointer() || pVar->IsStruct() ){ + // オブジェクトまたはポインタだったとき + // ※構造体も含む（暫定対応） + + // 変数領域に要するLONG_PTR単位の個数を引き渡す + //mov r8,count + op_mov_RV(sizeof(_int64), REG_R8,pVar->GetMemorySize()/PTR_SIZE); + + // ルートポインタを引き渡す + //mov rdx,offset + op_mov_RV(sizeof(_int64), REG_RDX,(int)pVar->offset); + obp-=sizeof(long); + pobj_GlobalVarSchedule->add(); + obp+=sizeof(long); + + // Thisポインタを引き渡す + SetThisPtrToReg(REG_RCX); + + // call AddGlobalRootPtr + op_call( pUserProc_AddGlobalRootPtr ); + + ReallocNativeCodeBuffer(); + } + } + + return true; +} Index: trunk/abdev/BasicCompiler64/Debug.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Debug.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Debug.cpp (revision 149) @@ -0,0 +1,677 @@ +#include "../BasicCompiler_Common/common.h" +#include "opcode.h" + +ULONG_PTR rva_to_real(DWORD p){ + extern DWORD ImageBase; + extern int MemPos_CodeSection; + return p+ImageBase+MemPos_CodeSection; +} + +void ShowVarList(DEBUG_EVENT *pde,BOOL bExit){ + extern DWORD ImageBase; + extern DWORD _DebugSys_dwThreadID[256]; + extern HANDLE hDebugProcess; + extern int MemPos_RWSection; + SIZE_T stAccBytes; + ReadProcessMemory(hDebugProcess, + (void *)(LONG_PTR)(ImageBase+MemPos_RWSection), + _DebugSys_dwThreadID,sizeof(DWORD)*256,&stAccBytes); + + //デバッグダイアログを表示 + extern HINSTANCE hInst; + extern HWND hMainDlg; + extern HWND hDebugWnd; + extern DWORD dwStepRun; + dwStepRun=0; + if(!hDebugWnd) SendMessage(hMainDlg,WM_SHOWVARLIST,0,pde->dwThreadId); + else InitVarList(pde->dwThreadId); + + if(bExit){ + //"中断" + SetDlgItemText(hMainDlg,IDOK,STRING_CLOSE); + + extern HWND hDebuggerToolbar; + SendMessage(hDebuggerToolbar,TB_SETSTATE,IDC_DEBUG_START,TBSTATE_INDETERMINATE); + SendMessage(hDebuggerToolbar,TB_SETSTATE,IDC_DEBUG_STEPOVER,TBSTATE_INDETERMINATE); + SendMessage(hDebuggerToolbar,TB_SETSTATE,IDC_DEBUG_STEPIN,TBSTATE_INDETERMINATE); + } + else{ + //"継続" + SetDlgItemText(hDebugWnd,IDCANCEL,STRING_CONTINUE); + } + while(hDebugWnd&&dwStepRun==0) Sleep(1); +} +void DebugMessage(char *buffer){ + extern HWND hMainDlg; + int pos; + + if(!IsWindowEnabled(GetDlgItem(hMainDlg,IDC_DEBUGLIST))){ + SetDlgItemText(hMainDlg,IDC_DEBUGLIST,""); + EnableWindow(GetDlgItem(hMainDlg,IDC_DEBUGLIST),1); + } + + pos=GetWindowTextLength(GetDlgItem(hMainDlg,IDC_DEBUGLIST)); + SendDlgItemMessage(hMainDlg,IDC_DEBUGLIST,EM_SETSEL,pos,pos); + SendDlgItemMessage(hMainDlg,IDC_DEBUGLIST,EM_REPLACESEL,0,(LPARAM)buffer); +} +SUBINFO *GetSubFromObp(ULONG_PTR pos){ + extern SUBINFO **ppSubHash; + SUBINFO *psi; + int i2; + + for(i2=0;i2CompileAddress) <= pos && + pos < rva_to_real(psi->EndOpAddr)) + return psi; + + psi=psi->pNextData; + } + } + return 0; +} +void ReleaseSingleStep(HANDLE hThread,CONTEXT *pContext){ + //以前にシングルステップ実行をした場合 + extern HANDLE hDebugProcess; + extern DWORD *lpdwDebugThreadID; + extern HANDLE *lphDebugThread; + extern int DebugThreadNum; + extern DWORD ImageBase; + extern int MemPos_CodeSection; + extern int FileSize_CodeSection; + extern char *OpBuffer; + int i2; + SIZE_T stAccBytes; + + //シングルステップOFF + WriteProcessMemory(hDebugProcess, + (void *)(LONG_PTR)(ImageBase+MemPos_CodeSection), + OpBuffer,FileSize_CodeSection,&stAccBytes); + + if(ImageBase+MemPos_CodeSection <= pContext->Rip && + pContext->Rip < ImageBase+MemPos_CodeSection+FileSize_CodeSection){ + //オリジナルコード内のみ、シングルステップ用の"int 3"を考慮 + pContext->Rip--; + SetThreadContext(hThread,pContext); + } + + //他のスレッドのサスペンドを解除 + for(i2=0;i2CompileAddress)-(long)Context.Rip){ + //プロシージャの終端位置の場合はステップインを行う + goto StepIn; + } + + //スレッドのプロシージャ実行状況を取得 + bRet=ReadProcessMemory(hDebugProcess, + (void *)(LONG_PTR)(ImageBase+MemPos_RWSection), + dwData,sizeof(DWORD)*256,&stAccBytes); + if(!bRet) MessageBox(hMainDlg,"プロセスメモリーの読み込みに失敗","error",MB_OK); + for(i2=0;;i2++){ + if(dwData[i2]==de.dwThreadId) break; + } + GetDebugThreadInfo(i2); + + extern int GlobalOpBufferSize; + extern DEBUG_PROCINFO dpi; + if(ImageBase+MemPos_CodeSection<=dpi.lpqwObp[dpi.num]&& + dpi.lpqwObp[dpi.num]CompileAddress), + SingleStepCodeBuffer+psi->CompileAddress, + psi->EndOpAddr-psi->CompileAddress, + &stAccBytes); + } + DeleteDebugThreadInfo(); + + //次の命令語のブレーク命令は解除しておく（シングルステップ実行後のみ） + //（オリジナルコード内のみ） + if(i3&&ImageBase+MemPos_CodeSection<=Context.Rip&&Context.RipbCompile) + HeapDefaultFree(psi->pVar); + + psi=psi->pNextData; + } + } + + //列挙型に関するメモリを解放 + DeleteEnumInfo(); + + //クラスに関するメモリを解放 + delete pobj_DBClass; + pobj_DBClass=0; + + //サブルーチン情報のメモリ解放 + DeleteSubInfo(); + + //定数に関する情報を解放 + DeleteConstInfo(); + + //ソースコードを解放 + extern char *pBaseBuffer; + HeapDefaultFree(pBaseBuffer); + + //コードと行番号の関係を解放 + extern LINEINFO *pLineInfo; + HeapDefaultFree(pLineInfo); + + //コードバッファを解放 + extern char *OpBuffer; + if(OpBuffer){ + HeapDefaultFree(OpBuffer); + OpBuffer=0; + } +} Index: trunk/abdev/BasicCompiler64/FunctionValue.h =================================================================== --- trunk/abdev/BasicCompiler64/FunctionValue.h (revision 149) +++ trunk/abdev/BasicCompiler64/FunctionValue.h (revision 149) @@ -0,0 +1,23 @@ +/* 関数定数 */ + +//データ型変換 +#define FUNC_CUDBL 0x0210 + +//文字列 +#define FUNC_LEN 0x031D + +//メモリ操作 +#define FUNC_VARPTR 0x0591 +#define FUNC_OBJPTR 0x0592 + +//その他 +#define FUNC_ADDRESSOF 0x0619 +#define FUNC_SIZEOF 0x0620 + +//ポインタ +#define FUNC_GETDOUBLE 0x0630 +#define FUNC_GETSINGLE 0x0631 +#define FUNC_GETQWORD 0x0632 +#define FUNC_GETDWORD 0x0634 +#define FUNC_GETWORD 0x0635 +#define FUNC_GETBYTE 0x0636 Index: trunk/abdev/BasicCompiler64/MakePeHdr.cpp =================================================================== --- trunk/abdev/BasicCompiler64/MakePeHdr.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/MakePeHdr.cpp (revision 149) @@ -0,0 +1,1716 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + + +//////////////////////////// +// 特殊関数の構造体ポインタ +//////////////////////////// + +// グローバル関数、静的メソッド +UserProc + *pSub_System_StartupProgram, + *pSub_DebugSys_StartProc, + *pSub_DebugSys_EndProc, + *pSub_DebugSys_SaveContext, + *pSub_System_GetEip, + *pSub_System_InitDllGlobalVariables, + *pSub_System_InitStaticLocalVariables, + *pSub_System_Call_Destructor_of_GlobalObject, + *pSub_System_GetSp, + *pSub_pow, + *pSub_calloc, + *pSub_realloc, + *pSub_free, + *pSub_System_GC_malloc_ForObject, + *pSub_System_GC_malloc_ForObjectPtr, + *pSub_System_GC_free_for_SweepingDelete, + *pSubStaticMethod_System_TypeBase_InitializeUserTypes; + +// 動的メソッド +UserProc + *pUserProc_System_CGarbageCollection_RegisterGlobalRoots; + + +////////////////////////////// +// 各セクションの位置とサイズ +int FileSize_CodeSection, + FileSize_ExportSection, + FileSize_ImportSection, + FileSize_DataSection, + FileSize_RWSection, + FileSize_RSrcSection, + FileSize_RelocSection, + FileSize_DebugSection; +int FilePos_CodeSection, + FilePos_ExportSection, + FilePos_ImportSection, + FilePos_DataSection, + FilePos_RWSection, + FilePos_RSrcSection, + FilePos_RelocSection, + FilePos_DebugSection; +int MemSize_CodeSection, + MemSize_ExportSection, + MemSize_ImportSection, + MemSize_DataSection, + MemSize_RWSection, + MemSize_RSrcSection, + MemSize_RelocSection, + MemSize_DebugSection; +int MemPos_CodeSection, + MemPos_ExportSection, + MemPos_ImportSection, + MemPos_DataSection, + MemPos_RWSection, + MemPos_RSrcSection, + MemPos_RelocSection, + MemPos_DebugSection; +int bUse_CodeSection, + bUse_ExportSection, + bUse_ImportSection, + bUse_DataSection, + bUse_RWSection, + bUse_RSrcSection, + bUse_RelocSection, + bUse_DebugSection; + + +void DebugVariable(void){ + char temporary[255]; + sprintf(temporary,"_DebugSys_dwThreadID[255]%c%cDWord",1,ESC_AS); + OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR); + sprintf(temporary,"_DebugSys_ProcNum[255]%c%cDWord",1,ESC_AS); + OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR); + sprintf(temporary,"_DebugSys_lplpObp[255]%c%c*ULONG_PTR",1,ESC_AS); + OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR); + sprintf(temporary,"_DebugSys_lplpSpBase[255]%c%c*ULONG_PTR",1,ESC_AS); + OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR); +} + +void Compile(void){ + extern HWND hMainDlg; + extern HWND hOwnerEditor; + extern HANDLE hHeap; + extern BOOL bDebugCompile; + extern BOOL bDll; + extern DWORD ImageBase; + extern int obp_AllocSize; + extern char *basbuf; + extern char OutputFileName[MAX_PATH]; + int i,i2,i3,i4,i5; + char temporary[MAX_PATH],*temp2; + HANDLE hFile; + + + //コードセクションのメモリ上の位置 + MemPos_CodeSection= 0x1000; + + //データセクションのメモリ上の位置（仮定） + MemPos_DataSection= 0x10000000; + + + //エクスポート セクションを利用するかどうか + if(bDll) bUse_ExportSection=1; + else bUse_ExportSection=0; + + + ////////////////// + // データテーブル + dataTable.Init(); + if(bDebugCompile){ + dataTable.Add( (long)0x00000002 ); + } + + + ////////////////////// + // コード生成前の準備 + ////////////////////// + + //重複エラー情報管理のメモリを確保（グローバル領域コンパイル用） + extern char **SynonymErrorWords; + extern int SynonymErrorNum; + SynonymErrorNum=0; + SynonymErrorWords=(char **)HeapAlloc(hHeap,0,1); + + //列挙体に関する情報の初期化 + CEnumParent::InitEnum(); + + //列挙体からクラスコードを生成 + char *temp; + temp=CEnumParent::GenerateCodes(); + AddSourceCode(temp); + HeapDefaultFree(temp); + + //関数ポインタ情報を初期化 + Smoothie::Meta::procPointers.clear(); + + // 名前空間情報を取得 + NamespaceScopesCollection::CollectNamespaces( + Smoothie::Lexical::source.GetBuffer(), + Smoothie::Meta::namespaceScopesCollection + ); + + //クラス名を取得（詳細情報はGetAllClassInfoで取得） + // GetSubInfo関数の中で参照されるオブジェクト名を事前に取得する。 + // ※オブジェクトの内容までは取得しない + pobj_DBClass=new CDBClass(); + pobj_DBClass->InitNames(); + + //TypeDef情報を初期化 + Smoothie::Meta::typeDefs.Init(); + + //定数情報を取得 + GetConstInfo(); + + //サブルーチン（ユーザー定義、DLL関数）の識別子、アドレスを取得 + pobj_CompilingClass=0; + GetSubInfo(); + + //クラス情報を取得（※注 - GetSubInfoの後に呼び出す） + pobj_DBClass->GetAllClassInfo(); + + //コードと行番号の関係 + extern LINEINFO *pLineInfo; + extern int MaxLineInfoNum; + pLineInfo=(LINEINFO *)HeapAlloc(hHeap,0,1); + MaxLineInfoNum=0; + + + /////////////////////////// + // 最低限必要な関数を取得 + /////////////////////////// + cp=-1; + + if(pSub_System_StartupProgram=GetSubHash("_System_StartupProgram",1)) + pSub_System_StartupProgram->Using(); + + if(pSub_DebugSys_StartProc=GetSubHash("_DebugSys_StartProc",1)) + pSub_DebugSys_StartProc->Using(); + + if(pSub_DebugSys_EndProc=GetSubHash("_DebugSys_EndProc",1)) + pSub_DebugSys_EndProc->Using(); + + if(pSub_DebugSys_SaveContext=GetSubHash("_DebugSys_SaveContext",1)) + pSub_DebugSys_SaveContext->Using(); + + if(pSub_System_GetEip=GetSubHash("_System_GetEip",1)){ + pSub_System_GetEip->Using(); + pSub_System_GetEip->ThisIsSystemProc(); + } + + if(pSub_System_InitDllGlobalVariables=GetSubHash("_System_InitDllGlobalVariables",1)){ + pSub_System_InitDllGlobalVariables->Using(); + pSub_System_InitDllGlobalVariables->ThisIsSystemProc(); + } + + if(pSub_System_InitStaticLocalVariables=GetSubHash("_System_InitStaticLocalVariables",1)){ + pSub_System_InitStaticLocalVariables->Using(); + pSub_System_InitStaticLocalVariables->ThisIsSystemProc(); + } + + if(pSub_System_Call_Destructor_of_GlobalObject=GetSubHash("_System_Call_Destructor_of_GlobalObject",1)){ + pSub_System_Call_Destructor_of_GlobalObject->Using(); + pSub_System_Call_Destructor_of_GlobalObject->ThisIsSystemProc(); + } + + if(pSub_System_GetSp=GetSubHash("_System_GetSp",1)){ + pSub_System_GetSp->Using(); + pSub_System_GetSp->ThisIsSystemProc(); + } + + if(pSub_pow=GetSubHash("pow",1)) + pSub_pow->Using(); + + if(pSub_calloc=GetSubHash("calloc",1)) + pSub_calloc->Using(); + + if(pSub_realloc=GetSubHash("realloc",1)) + pSub_realloc->Using(); + + if(pSub_free=GetSubHash("free",1)) + pSub_free->Using(); + + if( pSub_System_GC_malloc_ForObject = GetSubHash( "_System_GC_malloc_ForObject",1 ) ) + pSub_System_GC_malloc_ForObject->Using(); + + if( pSub_System_GC_malloc_ForObjectPtr = GetSubHash( "_System_GC_malloc_ForObjectPtr",1 ) ) + pSub_System_GC_malloc_ForObjectPtr->Using(); + + if( pSub_System_GC_free_for_SweepingDelete = GetSubHash( "_System_GC_free_for_SweepingDelete",1 ) ) + pSub_System_GC_free_for_SweepingDelete->Using(); + + if( pSubStaticMethod_System_TypeBase_InitializeUserTypes = GetSubHash( "ActiveBasic.Core._System_TypeBase.InitializeUserTypes",1 ) ){ + pSubStaticMethod_System_TypeBase_InitializeUserTypes->Using(); + pSubStaticMethod_System_TypeBase_InitializeUserTypes->ThisIsAutoGenerationProc(); + } + + if( pUserProc_System_CGarbageCollection_RegisterGlobalRoots = GetClassMethod( "_System_CGarbageCollection", "RegisterGlobalRoots" ) ){ + pUserProc_System_CGarbageCollection_RegisterGlobalRoots->Using(); + pUserProc_System_CGarbageCollection_RegisterGlobalRoots->ThisIsAutoGenerationProc(); + } + + + + //データテーブルスケジュール + pobj_DataTableSchedule=new CSchedule(); + pobj_DataTableSchedule->SetFlag(SCHEDULE_FLAG_RELOC); + + //インポートテーブルスケジュール + //※x64はRPI（実行中アドレス）からのオフセットになるため、再配置が不要 + pobj_ImportAddrSchedule=new CImportAddrSchedule(); + + //プロシージャポインタスケジュール + pobj_SubAddrSchedule=new CSubAddrSchedule(); + + //グローバル変数アドレススケジュール + pobj_GlobalVarSchedule=new CSchedule(); + pobj_GlobalVarSchedule->SetFlag(SCHEDULE_FLAG_RELOC); + + //グローバル変数の初期バッファ + extern BYTE *initGlobalBuf; + initGlobalBuf=(BYTE *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,1); + + //リロケーション情報 + pobj_Reloc=new CReloc(); + + //一時スケジューリングポインタ + pobj_TempSchedule=new CTempSchedule(); + + obp_AllocSize=8192*2; + OpBuffer=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,obp_AllocSize); + obp=0; + + //レジスタのブロッキングを管理するためのオブジェクトを生成 + pobj_BlockReg=new CBlockReg; + + //レキシカルスコープ情報を初期化 + obj_LexScopes.Init(obp); + + + ///////////////////////////////////////////////////////////////// + // デバッグコンパイル用のログを生成する + ///////////////////////////////////////////////////////////////// +#ifdef _DEBUG + { + ofstream ofs("middle_code.txt"); + ofs << basbuf << endl; + ofs.close(); + } +#endif + + + ////////////////////// + // グローバル実行領域 + ////////////////////// + + cp=-1; + UserProc::CompileStartForGlobalArea(); + + if(!bDll){ + // 名前空間が初期化されているかをチェック + if( Smoothie::Lexical::liveingNamespaceScopes.size() ){ + SetError(); + } + + //ラベル用のメモリを確保 + extern LABEL *pLabelNames; + extern int MaxLabelNum; + pLabelNames=(LABEL *)HeapAlloc(hHeap,0,1); + MaxLabelNum=0; + + //Gotoラベルスケジュール + extern GOTOLABELSCHEDULE *pGotoLabelSchedule; + extern int GotoLabelScheduleNum; + pGotoLabelSchedule=(GOTOLABELSCHEDULE *)HeapAlloc(hHeap,0,1); + GotoLabelScheduleNum=0; + + //With情報のメモリを確保 + extern WITHINFO WithInfo; + WithInfo.ppName=(char **)HeapAlloc(hHeap,0,1); + WithInfo.pWithCp=(int *)HeapAlloc(hHeap,0,1); + WithInfo.num=0; + + //Continueアドレスを初期化 + extern DWORD dwContinueAddress; + dwContinueAddress=-1; + + //スタックフレーム管理用クラスを初期化 + extern CStackFrame *pobj_sf; + pobj_sf=new CStackFrame(); + + + //未完成 + //OpBuffer[obp++]=(char)0xCC; + + //sub rsp,スタックフレームサイズ + int StackFrameSchedule; + op_sub_rsp(0xFFFFFFFF); + StackFrameSchedule=obp-sizeof(long); + + if(bDebugCompile){ + //デバッグ用の変数を定義 + DebugVariable(); + } + + //GC用の変数を定義 + InitGCVariables(); + + //_System_StartupProgramの呼び出し + op_call(pSub_System_StartupProgram); + + //クラスに属する静的メンバを定義 + CMember::InitStaticMember(); + + //グローバル実行領域をコンパイル開始 + CompileBuffer(0,0); + + //ラベル用のメモリを解放 + for(i=0;iGetFrameSize()); + + //xor rax,rax（raxを0に初期化する） + op_zero_reg(REG_RAX); + + //ret + op_ret(); + + //グローバル実行領域のコードサイズ + extern int GlobalOpBufferSize; + GlobalOpBufferSize=obp; + + //スタックフレームスケジュール（subコマンドに渡す値） + *((long *)(OpBuffer+StackFrameSchedule))=pobj_sf->GetFrameSize(); + + //スタックフレームスケジュールを実行 + pobj_sf->RunningSchedule(); + delete pobj_sf; + pobj_sf=0; + + //With情報のメモリを解放 + for(i=0;iIsUsing() ){ + pDllProc=pDllProc->pNextData; + continue; + } +/* + //エラーチェック + HINSTANCE hLib; + hLib=LoadLibrary( pDllProc->GetDllFileName().c_str() ); + if(!hLib){ + extern char OutputFileName[MAX_PATH]; + char temp2[MAX_PATH],temp3[MAX_PATH]; + _splitpath(OutputFileName,temp2,temp3,NULL,NULL); + lstrcat(temp2,temp3); + lstrcpy(temp3,pDllProc->GetDllFileName().c_str()); + GetFullPath(temp3,temp2); + hLib=LoadLibrary(temp3); + + if(!hLib){ + SetError(-106,pDllProc->GetDllFileName().c_str(),pDllProc->GetCodePos()); + } + } + + if(hLib){ + if(!GetProcAddress(hLib,pDllProc->GetAlias().c_str())){ + FreeLibrary(hLib); + SetError(-107,pDllProc->GetAlias(),pDllProc->GetCodePos()); + } + FreeLibrary(hLib); + } +*/ + pDllProc=pDllProc->pNextData; + } + } + + + + ///////////////////////////// + // リソースデータを読み込む + ///////////////////////////// + extern char ResourceFileName[MAX_PATH]; + GetResourceData(ResourceFileName); + + + ////////////////////////////// + // エクスポート情報（DLLのみ） + ////////////////////////////// + IMAGE_EXPORT_DIRECTORY ImageExportDirectory; + DWORD *lpdwExportAddressTable; + DWORD *lpdwExportNamePointerTable; + WORD *lpwExportOrdinalTable; + char lpExportNames[8192]; + int ExportNamesLength; + int ExportNum; + int DllMain_EntryPoint; + + DllMain_EntryPoint=-1; + ExportNum=0; + ExportNamesLength=0; + lpdwExportAddressTable=(DWORD *)HeapAlloc(hHeap,0,1); + lpdwExportNamePointerTable=(DWORD *)HeapAlloc(hHeap,0,1); + lpwExportOrdinalTable=(WORD *)HeapAlloc(hHeap,0,1); + + if(bUse_ExportSection){ + _splitpath(OutputFileName,NULL,NULL,lpExportNames,temporary); + lstrcat(lpExportNames,temporary); + ExportNamesLength=lstrlen(lpExportNames)+1; + + extern GlobalProc **ppSubHash; + GlobalProc *pUserProc,*psi2; + while(1){ + //辞書順にサーチ + temporary[0]=0; + for(i=0,psi2=0;iIsExport()){ + if(temporary[0]=='\0'){ + lstrcpy(temporary,pUserProc->GetName().c_str()); + psi2=pUserProc; + } + else{ + i3=lstrlen(temporary); + i4=(int)pUserProc->GetName().size(); + if(i3GetName().c_str(),i3)>0){ + lstrcpy(temporary,pUserProc->GetName().c_str()); + psi2=pUserProc; + } + } + } + pUserProc=pUserProc->pNextData; + } + } + if(psi2==0) break; + pUserProc=psi2; + + pUserProc->ExportOff(); + + if( pUserProc->GetName() == "DllMain" ){ + DllMain_EntryPoint=pUserProc->beginOpAddress; + } + + lpdwExportAddressTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportAddressTable,(ExportNum+1)*sizeof(DWORD)); + lpdwExportAddressTable[ExportNum]=pUserProc->beginOpAddress; + + lpdwExportNamePointerTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportNamePointerTable,(ExportNum+1)*sizeof(DWORD)); + lpdwExportNamePointerTable[ExportNum]=ExportNamesLength; + + lpwExportOrdinalTable=(WORD *)HeapReAlloc(hHeap,0,lpwExportOrdinalTable,(ExportNum+1)*sizeof(WORD)); + lpwExportOrdinalTable[ExportNum]=ExportNum; + + lstrcpy(lpExportNames+ExportNamesLength,pUserProc->GetName().c_str()); + ExportNamesLength+=lstrlen(lpExportNames+ExportNamesLength)+1; + + ExportNum++; + } + for(i=0;iIsUsing() ){ + pDllProc=pDllProc->pNextData; + continue; + } + + if( pDllProc->GetDllFileName().size() > 16 ){ + SetError(7,NULL,cp); + break; + } + for(i2=0;i2GetDllFileName() == ppDllNames[i2] ){ + break; + } + } + if(i2==ImportDllNum){ + ppDllNames=(char **)HeapReAlloc(hHeap,0,ppDllNames,(ImportDllNum+1)*sizeof(char **)); + ppDllNames[ImportDllNum]=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,16); + lstrcpy(ppDllNames[ImportDllNum],pDllProc->GetDllFileName().c_str()); + ImportDllNum++; + } + + pDllProc=pDllProc->pNextData; + } + } + + //IMAGE_IMPORT_DESCRIPTOR、及びルックアップ テーブル サイズの計算 + IMAGE_IMPORT_DESCRIPTOR *pImportDescriptor; + int LookupSize; + LookupSize=0; + pImportDescriptor=(IMAGE_IMPORT_DESCRIPTOR *)HeapAlloc(hHeap,0,(ImportDllNum+1)*sizeof(IMAGE_IMPORT_DESCRIPTOR)); + for(i=0;iIsUsing() ){ + pDllProc=pDllProc->pNextData; + continue; + } + + if( pDllProc->GetDllFileName() == ppDllNames[i] ){ + //ルックアップデータのサイズを追加 + LookupSize+=sizeof(_int64); + } + + pDllProc=pDllProc->pNextData; + } + } + LookupSize+=sizeof(_int64); //NULL用 + } + memset(&pImportDescriptor[i],0,sizeof(IMAGE_IMPORT_DESCRIPTOR)); + for(i=0;iIsUsing() ){ + pDllProc=pDllProc->pNextData; + continue; + } + + if( pDllProc->GetDllFileName() == ppDllNames[i] ){ + //ルックアップの位置をセット（後にインポート アドレス テーブルにセットしなおされる） + pDllProc->SetLookupAddress( i5*sizeof(_int64) ); + + //ルックアップ テーブルの値をセット + pLookupTable[i5++]= + LookupSize+ //インポート アドレス テーブル + LookupSize+ //ルックアップテーブル + (ImportDllNum+1)*sizeof(IMAGE_IMPORT_DESCRIPTOR)+ //IMAGE_IMPORT_DESCRIPTOR + ImportDllNum*0x10+ //DLL名の羅列 + HintSize; //ヒント名へのオフセット + + //ヒント テーブル + pHintTable[HintSize++]=0; + pHintTable[HintSize++]=0; + lstrcpy(pHintTable+HintSize,pDllProc->GetAlias().c_str()); + i4=(int)pDllProc->GetAlias().size(); + HintSize+=i4+1; + if(i4%2==0) pHintTable[HintSize++]=0; + + if(HintAllocSizepNextData; + } + } + pLookupTable[i5++]=0; + } + + + if(bDll){ + //DLLの場合はリロケーション情報を仮生成 + //※正式な生成は各セクションのメモリ上のサイズが決定してから再度行う。 + pobj_Reloc->ResetRelocBuffer(); + } + + + + //グローバル変数情報を扱う構造体も初期バッファの有無による配置を行う + //（デバッグ情報で利用される） + extern int AllInitGlobalVarSize; + foreach( Variable *pVar, globalVars ){ + if(pVar->offset&0x80000000){ + pVar->offset=(pVar->offset&0x7FFFFFFF)+AllInitGlobalVarSize; + } + } + + + + //////////////////////////////////// + // デバッグセクションを生成 + //////////////////////////////////// + + //機械語コードとBasicコードの関係を整理 + extern LINEINFO *pLineInfo; + extern int MaxLineInfoNum; + int MinObp,MaxObp; + LINEINFO *pTempLineInfo; + pTempLineInfo=(LINEINFO *)HeapAlloc(hHeap,0,MaxLineInfoNum*sizeof(LINEINFO)); + i2=0; + MaxObp=0; + while(1){ + for(i3=0,MinObp=0x0FFFFFFF;i3make(); + } + + + + ///////////////////////////////////// + // 各セクションの位置とサイズを計算 + ///////////////////////////////////// + + //コードセッションのファイル上のサイズ + if(obp%FILE_ALIGNMENT) FileSize_CodeSection=obp+(FILE_ALIGNMENT-obp%FILE_ALIGNMENT); + else FileSize_CodeSection=obp; + if(FileSize_CodeSection) bUse_CodeSection=1; + else bUse_CodeSection=0; + + //エクスポートセクションのファイル上のサイズ + i= sizeof(IMAGE_EXPORT_DIRECTORY)+ //エクスポートディレクトリテーブルを飛び越す + ExportNum*sizeof(DWORD)+ //エクスポート アドレス テーブルを飛び越す + ExportNum*sizeof(DWORD)+ //エクスポート名ポインタ テーブルを飛び越す + ExportNum*sizeof(WORD)+ //エクスポート序数テーブルを飛び越す + ExportNamesLength; //シンボル名バッファ + if(bUse_ExportSection){ + if(i%FILE_ALIGNMENT) FileSize_ExportSection=i+(FILE_ALIGNMENT-i%FILE_ALIGNMENT); + else FileSize_ExportSection=i; + } + else FileSize_ExportSection=0; + + //インポートセクションのファイル上のサイズ + i= + LookupSize+ //インポート アドレス テーブル + LookupSize+ //ルックアップテーブル + (ImportDllNum+1)*sizeof(IMAGE_IMPORT_DESCRIPTOR)+ //IMAGE_IMPORT_DESCRIPTOR + ImportDllNum*0x10+ //DLL名の羅列 + HintSize; //ヒント名 + if(i%FILE_ALIGNMENT) FileSize_ImportSection=i+(FILE_ALIGNMENT-i%FILE_ALIGNMENT); + else FileSize_ImportSection=i; + bUse_ImportSection=1; //インポートセクションは必ず存在する + + //データセクションのファイル上のサイズ + if(dataTable.GetSize()%FILE_ALIGNMENT) FileSize_DataSection=dataTable.GetSize()+(FILE_ALIGNMENT-dataTable.GetSize()%FILE_ALIGNMENT); + else FileSize_DataSection=dataTable.GetSize(); + if(FileSize_DataSection) bUse_DataSection=1; + else bUse_DataSection=0; + + //リライタブルセクションのファイル上のサイズ（グローバル変数の初期情報のみを格納） + extern int AllInitGlobalVarSize; + if(AllInitGlobalVarSize%FILE_ALIGNMENT) FileSize_RWSection=AllInitGlobalVarSize+(FILE_ALIGNMENT-AllInitGlobalVarSize%FILE_ALIGNMENT); + else{ + if(AllInitGlobalVarSize) FileSize_RWSection=AllInitGlobalVarSize; + else FileSize_RWSection=FILE_ALIGNMENT; + } + bUse_RWSection=1; + + //リソースセクションのファイル上のサイズ + char *RSrcSectionBuffer; + int RSrcSectionSize; + RSrcSectionBuffer=GetRSrcSectionBuffer(&RSrcSectionSize); + if(RSrcSectionSize%FILE_ALIGNMENT) FileSize_RSrcSection=RSrcSectionSize+(FILE_ALIGNMENT-RSrcSectionSize%FILE_ALIGNMENT); + else FileSize_RSrcSection=RSrcSectionSize; + if(FileSize_RSrcSection) bUse_RSrcSection=1; + else bUse_RSrcSection=0; + + //リロケーションセクションのファイル上のサイズ + if(pobj_Reloc->length%FILE_ALIGNMENT) FileSize_RelocSection=pobj_Reloc->length+(FILE_ALIGNMENT-pobj_Reloc->length%FILE_ALIGNMENT); + else FileSize_RelocSection=pobj_Reloc->length; + if(FileSize_RelocSection) bUse_RelocSection=1; + else bUse_RelocSection=0; + + //デバッグセクションのファイル上のサイズ + if(pobj_DebugSection->length%FILE_ALIGNMENT) FileSize_DebugSection=pobj_DebugSection->length+(FILE_ALIGNMENT-pobj_DebugSection->length%FILE_ALIGNMENT); + else FileSize_DebugSection=pobj_DebugSection->length; + if(FileSize_DebugSection) bUse_DebugSection=1; + else bUse_DebugSection=0; + + + //各セッションのファイル上の位置 + FilePos_CodeSection= EXE_HEADER_SIZE; + FilePos_ExportSection= FilePos_CodeSection+ + FileSize_CodeSection; + FilePos_ImportSection= FilePos_ExportSection+ + FileSize_ExportSection; + FilePos_DataSection= FilePos_ImportSection+ + FileSize_ImportSection; + FilePos_RWSection= FilePos_DataSection+ + FileSize_DataSection; + FilePos_RSrcSection= FilePos_RWSection+ + FileSize_RWSection; + FilePos_RelocSection= FilePos_RSrcSection+ + FileSize_RSrcSection; + FilePos_DebugSection= FilePos_RelocSection+ + FileSize_RelocSection; + + //コードセッションのメモリ上のサイズ + if(FileSize_CodeSection%MEM_ALIGNMENT) MemSize_CodeSection=FileSize_CodeSection+(MEM_ALIGNMENT-FileSize_CodeSection%MEM_ALIGNMENT); + else MemSize_CodeSection=FileSize_CodeSection; + + //エクスポートセクションのメモリ上のサイズ + if(FileSize_ExportSection%MEM_ALIGNMENT) MemSize_ExportSection=FileSize_ExportSection+(MEM_ALIGNMENT-FileSize_ExportSection%MEM_ALIGNMENT); + else MemSize_ExportSection=FileSize_ExportSection; + + //インポートセクションのメモリ上のサイズ + if(FileSize_ImportSection%MEM_ALIGNMENT) MemSize_ImportSection=FileSize_ImportSection+(MEM_ALIGNMENT-FileSize_ImportSection%MEM_ALIGNMENT); + else MemSize_ImportSection=FileSize_ImportSection; + + //データセクションのメモリ上のサイズ + if(FileSize_DataSection%MEM_ALIGNMENT) MemSize_DataSection=FileSize_DataSection+(MEM_ALIGNMENT-FileSize_DataSection%MEM_ALIGNMENT); + else MemSize_DataSection=FileSize_DataSection; + + //リライタブルセクションのメモリ上のサイズ + extern int AllGlobalVarSize; + i=AllInitGlobalVarSize+AllGlobalVarSize; + if(i%MEM_ALIGNMENT) MemSize_RWSection=i+(MEM_ALIGNMENT-i%MEM_ALIGNMENT); + else MemSize_RWSection=i; + + //リソースセクションのメモリ上のサイズ + if(FileSize_RSrcSection%MEM_ALIGNMENT) MemSize_RSrcSection=FileSize_RSrcSection+(MEM_ALIGNMENT-FileSize_RSrcSection%MEM_ALIGNMENT); + else MemSize_RSrcSection=FileSize_RSrcSection; + + //リロケーションセクションのメモリ上のサイズ + if(FileSize_RelocSection%MEM_ALIGNMENT) MemSize_RelocSection=FileSize_RelocSection+(MEM_ALIGNMENT-FileSize_RelocSection%MEM_ALIGNMENT); + else MemSize_RelocSection=FileSize_RelocSection; + + //デバッグセクションのメモリ上のサイズ + if(FileSize_DebugSection%MEM_ALIGNMENT) MemSize_DebugSection=FileSize_DebugSection+(MEM_ALIGNMENT-FileSize_DebugSection%MEM_ALIGNMENT); + else MemSize_DebugSection=FileSize_DebugSection; + + + //各セッションのメモリ上の位置 + if(bUse_ExportSection) MemPos_ExportSection= 0x1000+ + MemSize_CodeSection; + else MemPos_ExportSection=0; + if(bUse_ImportSection) MemPos_ImportSection= 0x1000+ + MemSize_CodeSection+ + MemSize_ExportSection; + else MemPos_ImportSection=0; + if(bUse_DataSection) MemPos_DataSection= 0x1000+ + MemSize_CodeSection+ + MemSize_ExportSection+ + MemSize_ImportSection; + else MemPos_DataSection=0; + if(bUse_RWSection) MemPos_RWSection= 0x1000+ + MemSize_CodeSection+ + MemSize_ExportSection+ + MemSize_ImportSection+ + MemSize_DataSection; + else MemPos_RWSection=0; + if(bUse_RSrcSection) MemPos_RSrcSection= 0x1000+ + MemSize_CodeSection+ + MemSize_ExportSection+ + MemSize_ImportSection+ + MemSize_DataSection+ + MemSize_RWSection; + else MemPos_RSrcSection=0; + if(bUse_RelocSection) MemPos_RelocSection= 0x1000+ + MemSize_CodeSection+ + MemSize_ExportSection+ + MemSize_ImportSection+ + MemSize_DataSection+ + MemSize_RWSection+ + MemSize_RSrcSection; + else MemPos_RelocSection=0; + if(bUse_DebugSection) MemPos_DebugSection= 0x1000+ + MemSize_CodeSection+ + MemSize_ExportSection+ + MemSize_ImportSection+ + MemSize_DataSection+ + MemSize_RWSection+ + MemSize_RSrcSection+ + MemSize_RelocSection; + else MemPos_DebugSection=0; + + + + ///////////////////////////// + // GC用の変数スケジュール + ///////////////////////////// + PerformedGcVarSchedule(); + + + //////////////////////////// + // エクスポート情報の再配置 + //////////////////////////// + if(bUse_ExportSection){ + for(i=0;iIsUsing() ){ + pDllProc=pDllProc->pNextData; + continue; + } + + if( pDllProc->GetDllFileName() == ppDllNames[i] ){ + //ルックアップ テーブル + pLookupTable[i5++]+=MemPos_ImportSection; + } + + pDllProc=pDllProc->pNextData; + } + } + i5++; + } + + + //////////////////////////////////////// + //仮想関数データテーブルスケジュール + pobj_DBClass->ActionVtblSchedule(ImageBase,MemPos_CodeSection); + + + ////////////////////////////// + // データテーブルスケジュール + for(i=0;inum;i++){ + *((long *)(OpBuffer+pobj_DataTableSchedule->pObpValues[i]))+=ImageBase+MemPos_DataSection; + } + delete pobj_DataTableSchedule; + + + ////////////////////////////////// + // インポートテーブルスケジュール（インポート アドレス テーブルを指し示させる） + // ※x86はRVAからのオフセット。x64はRPI（実行中アドレス）からのオフセット + for(i=0;inum;i++){ + DllProc *pDllProc; + pDllProc=pobj_ImportAddrSchedule->ppdi[i]; + *((long *)(OpBuffer+pobj_ImportAddrSchedule->pObpValues[i]))= + MemPos_ImportSection+ + pDllProc->GetLookupAddress() + -(MemPos_CodeSection+pobj_ImportAddrSchedule->pObpValues[i]+sizeof(long)); + } + delete pobj_ImportAddrSchedule; + + + //////////////////////////////////// + // プロシージャポインタスケジュール + for(i=0;inum;i++){ + if(pobj_SubAddrSchedule->ppsi[i]->beginOpAddress==0 + &&pobj_SubAddrSchedule->ppsi[i]->endOpAddress==0){ + SetError(300,NULL,-1); + } + + if(pobj_SubAddrSchedule->pbCall[i]){ + *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))= + pobj_SubAddrSchedule->ppsi[i]->beginOpAddress-(pobj_SubAddrSchedule->pObpValues[i]+sizeof(long)); + } + else{ + *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))= + pobj_SubAddrSchedule->ppsi[i]->beginOpAddress+ImageBase+MemPos_CodeSection; + } + } + delete pobj_SubAddrSchedule; + + + if(bDll){ + //DLLの場合はリロケーション情報を生成 + pobj_Reloc->ResetRelocBuffer(); + } + + delete pobj_TempSchedule; + + + + ////////////////////////////////////// + // グローバル変数アドレススケジュール + ////////////////////////////////////// + + /* + GlobalArea1 - 初期バッファあり + GlobalArea2 - 初期バッファなし + */ + for(i=0;inum;i++){ + if(*((long *)(OpBuffer+pobj_GlobalVarSchedule->pObpValues[i])) & 0x80000000){ + //初期バッファなし + *((long *)(OpBuffer+pobj_GlobalVarSchedule->pObpValues[i]))= + AllInitGlobalVarSize+ + (*((long *)(OpBuffer+pobj_GlobalVarSchedule->pObpValues[i])) & 0x7FFFFFFF)+ + ImageBase+MemPos_RWSection; + } + else{ + //初期バッファあり + *((long *)(OpBuffer+pobj_GlobalVarSchedule->pObpValues[i]))+= + ImageBase+MemPos_RWSection; + } + } + delete pobj_GlobalVarSchedule; + + + //////////////////////////////// + // リソースアドレススケジュール + extern DWORD *lpdwRSrcAddrSchedule; + extern int RSrcAddrScheduleNum; + for(i=0;ilength; + ImagePeHdr.OptionalHeader.DataDirectory[6].VirtualAddress=0; + ImagePeHdr.OptionalHeader.DataDirectory[6].Size=0; + ImagePeHdr.OptionalHeader.DataDirectory[7].VirtualAddress=0; + ImagePeHdr.OptionalHeader.DataDirectory[7].Size=0; + ImagePeHdr.OptionalHeader.DataDirectory[8].VirtualAddress=0; + ImagePeHdr.OptionalHeader.DataDirectory[8].Size=0; + ImagePeHdr.OptionalHeader.DataDirectory[9].VirtualAddress=0; + ImagePeHdr.OptionalHeader.DataDirectory[9].Size=0; + ImagePeHdr.OptionalHeader.DataDirectory[10].VirtualAddress=0; + ImagePeHdr.OptionalHeader.DataDirectory[10].Size=0; + ImagePeHdr.OptionalHeader.DataDirectory[11].VirtualAddress=0; + ImagePeHdr.OptionalHeader.DataDirectory[11].Size=0; + ImagePeHdr.OptionalHeader.DataDirectory[12].VirtualAddress=MemPos_ImportSection;//インポート アドレス テーブル + ImagePeHdr.OptionalHeader.DataDirectory[12].Size=LookupSize; + ImagePeHdr.OptionalHeader.DataDirectory[13].VirtualAddress=0; + ImagePeHdr.OptionalHeader.DataDirectory[13].Size=0; + ImagePeHdr.OptionalHeader.DataDirectory[14].VirtualAddress=0; + ImagePeHdr.OptionalHeader.DataDirectory[14].Size=0; + ImagePeHdr.OptionalHeader.DataDirectory[15].VirtualAddress=0; + ImagePeHdr.OptionalHeader.DataDirectory[15].Size=0; + + + //コードセクションヘッダ + IMAGE_SECTION_HEADER CodeSectionHeader; + memset((char *)CodeSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME); + lstrcpy((char *)CodeSectionHeader.Name,".text"); + CodeSectionHeader.Misc.VirtualSize= obp; + CodeSectionHeader.VirtualAddress= MemPos_CodeSection; //開始アドレス + CodeSectionHeader.SizeOfRawData= FileSize_CodeSection; + CodeSectionHeader.PointerToRawData= FilePos_CodeSection; //ファイル上の開始アドレス + CodeSectionHeader.PointerToRelocations= 0; + CodeSectionHeader.PointerToLinenumbers= 0; + CodeSectionHeader.NumberOfRelocations= 0; + CodeSectionHeader.NumberOfLinenumbers= 0; + CodeSectionHeader.Characteristics= IMAGE_SCN_MEM_EXECUTE| + IMAGE_SCN_MEM_READ| + IMAGE_SCN_CNT_CODE; + + //エクスポートセクションヘッダ + IMAGE_SECTION_HEADER ExportSectionHeader; + memset((char *)ExportSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME); + lstrcpy((char *)ExportSectionHeader.Name,".edata"); + ExportSectionHeader.Misc.VirtualSize= MemSize_ExportSection; + ExportSectionHeader.VirtualAddress= MemPos_ExportSection; //開始アドレス + ExportSectionHeader.SizeOfRawData= FileSize_ExportSection; //サイズ + ExportSectionHeader.PointerToRawData= FilePos_ExportSection; //ファイル上の開始アドレス + ExportSectionHeader.PointerToRelocations= 0; + ExportSectionHeader.PointerToLinenumbers= 0; + ExportSectionHeader.NumberOfRelocations= 0; + ExportSectionHeader.NumberOfLinenumbers= 0; + ExportSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA| + IMAGE_SCN_MEM_READ; + + //インポートセクションヘッダ + IMAGE_SECTION_HEADER ImportSectionHeader; + memset((char *)ImportSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME); + lstrcpy((char *)ImportSectionHeader.Name,".idata"); + ImportSectionHeader.Misc.VirtualSize= + LookupSize+ //インポートアドレステーブル + LookupSize+ //ルックアップテーブル + (ImportDllNum+1)*sizeof(IMAGE_IMPORT_DESCRIPTOR)+ + 16*ImportDllNum+ //DLL名 + HintSize; //ヒント名（関数名）テーブル + ImportSectionHeader.VirtualAddress= MemPos_ImportSection; //開始アドレス + ImportSectionHeader.SizeOfRawData= FileSize_ImportSection; //サイズ + ImportSectionHeader.PointerToRawData= FilePos_ImportSection; //ファイル上の開始アドレス + ImportSectionHeader.PointerToRelocations= 0; + ImportSectionHeader.PointerToLinenumbers= 0; + ImportSectionHeader.NumberOfRelocations= 0; + ImportSectionHeader.NumberOfLinenumbers= 0; + ImportSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA| + IMAGE_SCN_MEM_READ; + + //データセクションヘッダ + IMAGE_SECTION_HEADER DataSectionHeader; + memset((char *)DataSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME); + lstrcpy((char *)DataSectionHeader.Name,".sdata"); + DataSectionHeader.Misc.VirtualSize= MemSize_DataSection; + DataSectionHeader.VirtualAddress= MemPos_DataSection; + DataSectionHeader.SizeOfRawData= FileSize_DataSection; + DataSectionHeader.PointerToRawData= FilePos_DataSection; + DataSectionHeader.PointerToRelocations= 0; + DataSectionHeader.PointerToLinenumbers= 0; + DataSectionHeader.NumberOfRelocations= 0; + DataSectionHeader.NumberOfLinenumbers= 0; + DataSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA| + IMAGE_SCN_MEM_READ| + IMAGE_SCN_MEM_WRITE; + + //リライタブルセクションヘッダ + IMAGE_SECTION_HEADER RWSectionHeader; + memset((char *)RWSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME); + lstrcpy((char *)RWSectionHeader.Name,".data"); + RWSectionHeader.Misc.VirtualSize= AllInitGlobalVarSize+AllGlobalVarSize; + RWSectionHeader.VirtualAddress= MemPos_RWSection; + RWSectionHeader.SizeOfRawData= FileSize_RWSection; + RWSectionHeader.PointerToRawData= FilePos_RWSection; + RWSectionHeader.PointerToRelocations= 0; + RWSectionHeader.PointerToLinenumbers= 0; + RWSectionHeader.NumberOfRelocations= 0; + RWSectionHeader.NumberOfLinenumbers= 0; + RWSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA| + IMAGE_SCN_MEM_READ| + IMAGE_SCN_MEM_WRITE; + + //リソースセクションヘッダ + IMAGE_SECTION_HEADER RSrcSectionHeader; + memset((char *)RSrcSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME); + lstrcpy((char *)RSrcSectionHeader.Name,".rsrc"); + RSrcSectionHeader.Misc.VirtualSize= RSrcSectionSize; + RSrcSectionHeader.VirtualAddress= MemPos_RSrcSection; + RSrcSectionHeader.SizeOfRawData= FileSize_RSrcSection; + RSrcSectionHeader.PointerToRawData= FilePos_RSrcSection; + RSrcSectionHeader.PointerToRelocations= 0; + RSrcSectionHeader.PointerToLinenumbers= 0; + RSrcSectionHeader.NumberOfRelocations= 0; + RSrcSectionHeader.NumberOfLinenumbers= 0; + RSrcSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA| + IMAGE_SCN_MEM_READ; + + //リロケーションセクションヘッダ + IMAGE_SECTION_HEADER RelocSectionHeader; + memset((char *)RelocSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME); + lstrcpy((char *)RelocSectionHeader.Name,".reloc"); + RelocSectionHeader.Misc.VirtualSize= pobj_Reloc->length; + RelocSectionHeader.VirtualAddress= MemPos_RelocSection; //開始アドレス + RelocSectionHeader.SizeOfRawData= FileSize_RelocSection; //サイズ + RelocSectionHeader.PointerToRawData= FilePos_RelocSection; //ファイル上の開始アドレス + RelocSectionHeader.PointerToRelocations= 0; + RelocSectionHeader.PointerToLinenumbers= 0; + RelocSectionHeader.NumberOfRelocations= 0; + RelocSectionHeader.NumberOfLinenumbers= 0; + RelocSectionHeader.Characteristics= IMAGE_SCN_CNT_INITIALIZED_DATA| + IMAGE_SCN_MEM_DISCARDABLE| + IMAGE_SCN_MEM_READ; + + //デバッグセクションヘッダ + IMAGE_SECTION_HEADER DebugSectionHeader; + memset((char *)DebugSectionHeader.Name,0,IMAGE_SIZEOF_SHORT_NAME); + lstrcpy((char *)DebugSectionHeader.Name,".debug"); + DebugSectionHeader.Misc.VirtualSize= pobj_DebugSection->length; + DebugSectionHeader.VirtualAddress= MemPos_DebugSection; //開始アドレス + DebugSectionHeader.SizeOfRawData= FileSize_DebugSection; //サイズ + DebugSectionHeader.PointerToRawData= FilePos_DebugSection; //ファイル上の開始アドレス + DebugSectionHeader.PointerToRelocations= 0; + DebugSectionHeader.PointerToLinenumbers= 0; + DebugSectionHeader.NumberOfRelocations= 0; + DebugSectionHeader.NumberOfLinenumbers= 0; + DebugSectionHeader.Characteristics= IMAGE_SCN_MEM_DISCARDABLE| + IMAGE_SCN_MEM_READ; + + + hFile=CreateFile(OutputFileName,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL); + if(hFile==INVALID_HANDLE_VALUE){ + SetError(53,OutputFileName,-1); + goto EndWriteOpcode; + } + + //ヘッダ + WriteFile(hFile,(void *)&ImageDosHeader,sizeof(IMAGE_DOS_HEADER),(DWORD *)&i2,NULL); + i=i2; + + //Dosスタブ + WriteFile(hFile,DosStubBuffer,DosStubSize,(DWORD *)&i2,NULL); + i+=i2; + + //0x0100までNULLを並べる + temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,0x0100-i); + WriteFile(hFile,temp2,0x0100-i,(DWORD *)&i2,NULL); + HeapDefaultFree(temp2); + i+=i2; + + //PEヘッダ + WriteFile(hFile,&ImagePeHdr,sizeof(IMAGE_NT_HEADERS64),(DWORD *)&i2,NULL); + i+=i2; + + //コード セクション ヘッダ + WriteFile(hFile,&CodeSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL); + i+=i2; + + if(bUse_ExportSection){ + //エクスポート セクション ヘッダ + WriteFile(hFile,&ExportSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL); + i+=i2; + } + if(bUse_ImportSection){ + //インポート セクション ヘッダ + WriteFile(hFile,&ImportSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL); + i+=i2; + } + if(bUse_DataSection){ + //データ セクション ヘッダ + WriteFile(hFile,&DataSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL); + i+=i2; + } + if(bUse_RWSection){ + //リライタブルセクションヘッダ + WriteFile(hFile,&RWSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL); + i+=i2; + } + if(bUse_RSrcSection){ + //リソースセクションヘッダ + WriteFile(hFile,&RSrcSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL); + i+=i2; + } + if(bUse_RelocSection){ + //リロケーションセクションヘッダ + WriteFile(hFile,&RelocSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL); + i+=i2; + } + if(bUse_DebugSection){ + //デバッグセクションヘッダ + WriteFile(hFile,&DebugSectionHeader,sizeof(IMAGE_SECTION_HEADER),(DWORD *)&i2,NULL); + i+=i2; + } + + //EXE_HEADER_SIZEまでNULLを並べる + temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,EXE_HEADER_SIZE-i); + WriteFile(hFile,temp2,EXE_HEADER_SIZE-i,(DWORD *)&i2,NULL); + HeapDefaultFree(temp2); + i+=i2; + + //コード + WriteFile(hFile,OpBuffer,obp,(DWORD *)&i2,NULL); + i+=i2; + + //FilePos_ExportSectionまでNULLを並べる + temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,FilePos_ExportSection-i); + WriteFile(hFile,temp2,FilePos_ExportSection-i,(DWORD *)&i2,NULL); + HeapDefaultFree(temp2); + i+=i2; + + if(bUse_ExportSection){ + //エクスポート ディレクトリ テーブル + WriteFile(hFile,&ImageExportDirectory,sizeof(IMAGE_EXPORT_DIRECTORY),(DWORD *)&i2,NULL); + i+=i2; + + //エクスポート アドレス テーブル + WriteFile(hFile,lpdwExportAddressTable,ExportNum*sizeof(DWORD),(DWORD *)&i2,NULL); + i+=i2; + + //エクスポート名ポインタ テーブル + WriteFile(hFile,lpdwExportNamePointerTable,ExportNum*sizeof(DWORD),(DWORD *)&i2,NULL); + i+=i2; + + //エクスポート序数テーブル + WriteFile(hFile,lpwExportOrdinalTable,ExportNum*sizeof(WORD),(DWORD *)&i2,NULL); + i+=i2; + + //シンボル名 + WriteFile(hFile,lpExportNames,ExportNamesLength,(DWORD *)&i2,NULL); + i+=i2; + } + + //FilePos_ImportSectionまでNULLを並べる + temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,FilePos_ImportSection-i); + WriteFile(hFile,temp2,FilePos_ImportSection-i,(DWORD *)&i2,NULL); + HeapDefaultFree(temp2); + i+=i2; + + if(bUse_ImportSection){ + //インポート アドレス テーブル + WriteFile(hFile,pLookupTable,LookupSize,(DWORD *)&i2,NULL); + i+=i2; + + //ルックアップ テーブル + WriteFile(hFile,pLookupTable,LookupSize,(DWORD *)&i2,NULL); + i+=i2; + + //インポート ディレクトリ テーブル（Nullディレクトリ テーブルを含む） + for(i3=0;i3<(ImportDllNum+1);i3++){ + WriteFile(hFile,&pImportDescriptor[i3],sizeof(IMAGE_IMPORT_DESCRIPTOR),(DWORD *)&i2,NULL); + i+=i2; + } + + //DLL名 + for(i3=0;i3buffer,pobj_Reloc->length,(DWORD *)&i2,NULL); + i+=i2; + } + + //ファイルアラインメントを考慮 + if(i%FILE_ALIGNMENT){ + temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,FILE_ALIGNMENT-i%FILE_ALIGNMENT); + WriteFile(hFile,temp2,FILE_ALIGNMENT-i%FILE_ALIGNMENT,(DWORD *)&i2,NULL); + HeapDefaultFree(temp2); + i+=i2; + } + + if(bUse_DebugSection){ + //デバッグセクション + WriteFile(hFile,pobj_DebugSection->buffer,pobj_DebugSection->length,(DWORD *)&i2,NULL); + i+=i2; + } + + //ファイルアラインメントを考慮 + if(i%FILE_ALIGNMENT){ + temp2=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,FILE_ALIGNMENT-i%FILE_ALIGNMENT); + WriteFile(hFile,temp2,FILE_ALIGNMENT-i%FILE_ALIGNMENT,(DWORD *)&i2,NULL); + HeapDefaultFree(temp2); + i+=i2; + } + + //書き込み終了 + CloseHandle(hFile); + + +EndWriteOpcode: + + //Dosスタブ用のメモリを解放 + HeapDefaultFree(DosStubBuffer); + + //エクスポート テーブル情報を解放 + HeapDefaultFree(lpdwExportAddressTable); + HeapDefaultFree(lpdwExportNamePointerTable); + HeapDefaultFree(lpwExportOrdinalTable); + + //インポートDLL情報を解放 + HeapDefaultFree(pImportDescriptor); + for(i=0;iGetStringClassPtr(), "", parameter, Type( DEF_OBJECT, *pobj_DBClass->GetStringClassPtr() ) ); + + free( parameter ); + + //mov reg,rax + op_mov_RR( reg, REG_RAX ); + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// +} + +void SetUseRegFromRax(int type,int UseReg,int XmmReg){ + if(IsRealNumberType(type)){ + //実数型 + if(XmmReg==REG_XMM4){ + if(type==DEF_DOUBLE){ + //movsd qword ptr[rsp+offset],xmm0 ※スタックフレームを利用 + pobj_sf->push(REG_XMM0,sizeof(double)); + } + if(type==DEF_SINGLE){ + //movss dword ptr[rsp+offset],xmm0 ※スタックフレームを利用 + pobj_sf->push(REG_XMM0,sizeof(float)); + } + } + else{ + if(type==DEF_DOUBLE){ + //movsd xmm_reg,xmm0 + op_movsd_RR(XmmReg,REG_XMM0); + } + else if(type==DEF_SINGLE){ + //movss xmm_reg,xmm0 + op_movss_RR(XmmReg,REG_XMM0); + } + } + } + else{ + //整数型 + if(UseReg==REG_R14){ + //mov qword ptr[rsp+offset],rax ※スタックフレームを利用 + pobj_sf->push(REG_RAX); + } + else{ + //mov reg,rax + op_mov_RR(UseReg,REG_RAX); + } + } +} + +void ExtendRegToBigType( int reg, int bigBasicType, int baseBasicType ){ + switch( Type::GetBasicSize( bigBasicType ) ){ + case sizeof(_int64): + ExtendTypeTo64(baseBasicType,reg); + break; + case sizeof(long): + ExtendTypeTo32(baseBasicType,reg); + break; + case sizeof(short): + ExtendTypeTo16(baseBasicType,reg); + break; + } +} + + +bool VarToReg( RELATIVE_VAR &relativeVar, const Type &baseType, Type &resultType ){ + int UseReg=pobj_reg->GetNextReg(); + int XmmReg=pobj_reg->GetNextXmmReg(); + + //大きな型への暗黙の変換 + int bigType = AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType()); + + if(resultType.GetBasicType()&FLAG_PTR){ + //配列ポインタ + resultType.SetBasicType( GetPtrType(resultType.GetBasicType()^FLAG_PTR) ); + + SetVarPtrToReg(UseReg,&relativeVar); + } + else if(resultType.IsReal()){ + //実数型 + if( resultType.IsDouble() ) + SetXmmReg_DoubleVariable(&relativeVar,XmmReg); + if( resultType.IsSingle() ) + SetXmmReg_SingleVariable(&relativeVar,XmmReg); + } + else if( resultType.IsWhole() || resultType.IsObject()){ + //整数型 + SetReg_WholeVariable(resultType.GetBasicType(),&relativeVar,UseReg); + } + else if( resultType.IsStruct() ){ + //構造体ポインタをUseRegへ格納（構造体は値型） + SetVarPtrToReg(UseReg,&relativeVar); + } + else{ + return false; + } + + if( resultType.GetBasicType() != bigType ){ + // 大きな型へ変換された場合 + // ※レジスタの値をキャストする + ExtendRegToBigType( UseReg, bigType, resultType.GetBasicType() ); + + resultType.SetBasicType( bigType ); + } + + return true; +} +bool TermMemberOpe( const CClass &objClass, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member ){ + + int UseReg=pobj_reg->GetNextReg(); + int XmmReg=pobj_reg->GetNextXmmReg(); + + + if( GetMemberType( objClass, member, resultType, 0, false ) ){ + // メンバが見つかったとき + + //オブジェクトポインタをr11にコピー + op_mov_RR( REG_R11, UseReg ); + + RELATIVE_VAR relativeVar; + relativeVar.dwKind=VAR_DIRECTMEM; + + if( !_member_offset( + true, //エラー表示あり + false, //読み込み専用 + objClass, + member,&relativeVar,resultType,0)){ + return false; + } + + if( !VarToReg( relativeVar, baseType, resultType ) ){ + SetError(11,termFull,cp); + } + + return true; + } + + + /////////////////////////////////////////////////////////////////// + // 動的メソッドを検索 + /////////////////////////////////////////////////////////////////// + vector userProcs; + + char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1]; + CClass::RefType refType; + lstrcpy( methodName, member ); + GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType); + + objClass.GetMethods().Enum( methodName, userProcs ); + UserProc *pUserProc; + if(userProcs.size()){ + //オーバーロードを解決 + pUserProc=OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft); + + if( pUserProc ){ + + resultType = pUserProc->ReturnType(); + + + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + //オブジェクトポインタをスタックに入れておく + //mov qword ptr[rsp+offset],reg ※スタックフレームを利用 + pobj_sf->push( UseReg ); + + if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){ + //レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + + return false; + } + + pobj_sf->pop(); + + ///////////////////// + // 戻り値の処理 + ///////////////////// + + //大きな型への暗黙の変換 + int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() ); + + if( resultType.GetBasicType() != bigType ){ + // 大きな型へ変換された場合 + // ※レジスタの値をキャストする + ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() ); + + resultType.SetBasicType( bigType ); + } + + SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg); + + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + + return true; + } + } + + return false; +} +bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool isWantObject, bool *pIsClassName, bool isProcedureCallOnly ){ + char parameter[VN_SIZE]; + + // Withを解決 + char termFull[VN_SIZE]; + if(term[0]=='.'){ + GetWithName(termFull); + lstrcat(termFull,term); + } + else lstrcpy(termFull,term); + + char termLeft[VN_SIZE]; + lstrcpy(termLeft,termFull); + + // パース + char member[VN_SIZE]; + CClass::RefType refType; + if( SplitMemberName( termFull, termLeft, member, refType ) ){ + /////////////////////////////////////////////////////////////////// + // オブジェクトとメンバに分解できるとき + // termLeft.member + /////////////////////////////////////////////////////////////////// + + isLiteral = false; + + // オブジェクト側の型を取得 + bool isClassName = false; + Type leftType; + if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){ + if( isClassName == false && Smoothie::Meta::blittableTypes.IsExist( leftType ) ){ + // 左側のオブジェクト部分がBlittable型のとき + + char temporary[VN_SIZE]; + lstrcpy( temporary, termLeft ); + sprintf( termLeft, "%s(%s)", + Smoothie::Meta::blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(), + temporary ); + } + } + + if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, true, &isClassName ) ){ + goto globalArea; + } + + if( isClassName ){ + // 静的メンバ/メソッドの場合 + goto globalArea; + } + + if( !leftType.HasMember() ){ + // メンバを持たない型の場合 + return false; + } + + return TermMemberOpe( leftType.GetClass(), baseType, resultType, termFull, termLeft, member ); + } +globalArea: + + ////////////////////////////////////////////// + // クラス名かどうかをチェック（静的メンバ用） + ////////////////////////////////////////////// + + if( pIsClassName ){ + if( pobj_DBClass->Find( termFull ) ){ + *pIsClassName = true; + return true; + } + } + + + ///////////////////////////////////////////////////////////////// + // グローバル属性エリア + ///////////////////////////////////////////////////////////////// + + int UseReg=pobj_reg->GetNextReg(); + int XmmReg=pobj_reg->GetNextXmmReg(); + + + if(lstrcmpi(termFull,"This")==0 && isProcedureCallOnly == false ){ + //Thisオブジェクト + resultType.SetType( DEF_OBJECT, pobj_CompilingClass ); + + SetThisPtrToReg( UseReg ); + + isLiteral = false; + + return true; + } + + + ////////////////////////////////////// + // 関数（DLL、ユーザー定義、組み込み） + ////////////////////////////////////// + char procName[VN_SIZE]; + char temporary[8192]; + + int i2=GetCallProcName(termFull,procName); + if(termFull[i2]=='('){ + int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1); + + void *pInfo; + int idProc=GetProc(procName,(void **)&pInfo); + + if(idProc){ + //閉じカッコ")"に続く文字がNULLでないとき + if(termFull[i2+1+i4+1]!='\0'){ + SetError(42,NULL,cp); + } + + + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + + //////////////// + // 呼び出し + //////////////// + + CallProc(idProc,pInfo,procName,parameter,resultType); + + + ///////////////////// + // 戻り値の処理 + ///////////////////// + + //大きな型への暗黙の変換 + int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() ); + + if( resultType.GetBasicType() != bigType ){ + // 大きな型へ変換された場合 + // ※レジスタの値をキャストする + ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() ); + + resultType.SetBasicType( bigType ); + } + + SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg); + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + + if(resultType.IsStruct()){ + //構造体が戻ったときはヒープ領域にインスタンスが格納されている + //※後にfreeする必要あり + // TODO: 解放はGCに任せる + *pbUseHeap = 1; + } + + isLiteral = false; + + return true; + } + else if(GetConstCalcBuffer(procName,parameter,temporary)){ + ///////////////////////// + // マクロ関数 + ///////////////////////// + + //閉じカッコ")"に続く文字がNULLでないときはエラーにする + if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp); + + //マクロ関数の場合 + NumOpe(&UseReg,temporary,Type(),resultType); + + if(!IS_LITERAL(resultType.GetIndex())){ + //リテラル値ではなかったとき + isLiteral = false; + } + + return true; + } + } + else if( isProcedureCallOnly ){ + // 関数呼び出し以外は受け付けない + return false; + } + + + //////////////////////////////// + // インデクサ（getアクセサ） + //////////////////////////////// + + char VarName[VN_SIZE],ArrayElements[VN_SIZE]; + GetArrayElement(termFull,VarName,ArrayElements); + if(ArrayElements[0]){ + GetVarType(VarName,resultType,false); + if( resultType.IsObject() ){ + CallIndexerGetterProc(UseReg,&resultType.GetClass(),VarName,ArrayElements,resultType); + + isLiteral = false; + + return true; + } + } + + + //////////////////////////////// + // 変数 + //////////////////////////////// + + RELATIVE_VAR relativeVar; + if(GetVarOffset( + false, //エラー表示なし + false, //読み込み専用 + termFull, + &relativeVar,resultType)){ + ////////// + // 変数 + ////////// + + if( !VarToReg( relativeVar, baseType, resultType ) ){ + SetError(11,termFull,cp); + } + + isLiteral = false; + + return true; + } + +/* + //////////////////////////////// + // 型名 + //////////////////////////////// + + if( Type::StringToType( termFull, resultType ) ){ + resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST ); + return true; + }*/ + + + ///////////////////////////////// + // プロパティ用のメソッド + ///////////////////////////////// + + //配列要素を排除 + GetArrayElement(termFull,VarName,ArrayElements); + + if(GetSubHash(VarName,0)){ + + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + CallPropertyMethod(termFull,NULL,resultType); + + //大きな型への暗黙の変換 + int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() ); + + if( resultType.GetBasicType() != bigType ){ + // 大きな型へ変換された場合 + // ※レジスタの値をキャストする + ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() ); + + resultType.SetBasicType( bigType ); + } + + SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg); + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + + if(resultType.IsStruct()){ + //構造体が戻ったときはヒープ領域にインスタンスが格納されている + //※後にfreeする必要あり + // TODO: 解放はGCに任せる + *pbUseHeap = 1; + } + + isLiteral = false; + + return true; + } + + + return false; +} + +bool NumOpe( int *pReg, + const char *expression, + const Type &baseType, + Type &resultType, + BOOL *pbUseHeap ){ + + int i,i2,i3; + char temporary[1024],temp2[1024]; + + if(expression[0]=='\0'){ + SetError(1,NULL,cp); + return false; + } + + if(expression[0]==1&& expression[1]==ESC_NEW ){ + //New演算子（オブジェクト生成） + + if( pobj_BlockReg->check(REG_RAX) ){ + SetError(); + } + + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + if( !Operator_New( expression+2, baseType, resultType ) ){ + return false; + } + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + + //mov reg,rax + op_mov_RR( *pReg, REG_RAX ); + + return true; + } + + if( !baseType.IsNull() && expression[0] == '[' ){ + // リテラル配列の場合 + + if( !baseType.IsPointer() ){ + SetError(1,NULL,cp); + return false; + } + Type tempBaseType( baseType ); + tempBaseType.PtrLevelDown(); + + char *buffer = (char *)malloc( lstrlen( expression ) + 1 ); + lstrcpy( buffer, expression ); + RemoveStringBracket( buffer ); + + void *binary = malloc( 1 ); + int num = 0; + + i = 0; + while( buffer[i] ){ + i = GetOneParameter( buffer, i, temporary ); + if( buffer[i] == ',' ){ + i++; + } + + Type resultType; + _int64 i64data; + if( !StaticCalculation( true, temporary, tempBaseType.GetBasicType(), &i64data, resultType ) ){ + return false; + } + if( !resultType.IsWhole() ){ + // TODO: 実数に未対応 + SetError(); + return false; + } + + binary = realloc( binary, ( num + 1 ) * tempBaseType.GetSize() ); + memcpy( (char *)binary + (num * tempBaseType.GetSize()), &i64data, tempBaseType.GetSize() ); + num++; + } + + i2 = dataTable.AddBinary( binary, num * tempBaseType.GetSize() ); + + //mov reg,i2 + op_mov_RV(sizeof(_int64),*pReg,i2); + obp-=sizeof(long); + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + + free( buffer ); + + resultType = baseType; + + return true; + } + + + ///////////////////////////////// + // 式要素を逆ポーランド式で取得 + ///////////////////////////////// + + char *values[255]; + long calc[255]; + long stack[255]; + int pnum; + if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){ + for(i=0;inum; + + //リテラル演算の場合を考慮した演算前のデータテーブルスケジュール位置 + int Before_DataTableScheduleNum; + Before_DataTableScheduleNum=pobj_DataTableSchedule->num; + + //リテラル演算の場合を考慮した演算前の再配置スケジュール + CReloc *pobj_BackReloc; + pobj_BackReloc=new CReloc(); + pobj_BackReloc->copy(pobj_Reloc); + + //リテラル演算の場合を考慮した演算前のスタックフレームスケジュール位置 + int Before_StackFrameScheduleNum; + Before_StackFrameScheduleNum=pobj_sf->num; + + double dbl; + int sp; + int type_stack[255]; + LONG_PTR index_stack[255]; + bool isNothing_stack[255]; + BOOL bUseHeap[255]; + _int64 i64data; + int UseReg,XmmReg; + BOOL bXmm; + for(i=0,sp=0;iIsEqualsOrSubClass( (CClass *)index_stack[sp-2] ) || ((CClass *)index_stack[sp-2])->IsEqualsOrSubClass( (CClass *)index_stack[sp-1] ) + )){ + // ダウンキャストを許可する + } + else if( idCalc == CALC_AS + && type_stack[sp-1] == ( DEF_OBJECT | FLAG_CAST ) && ((CClass *)index_stack[sp-1])->IsInterface() + ){ + // インターフェイスへのキャスト + // TODO: 実装 + CastToInterface( pobj_reg->GetLockingReg(), REG_R15, *(CClass *)index_stack[sp-2], *(CClass *)index_stack[sp-1] ); + } + else{ + //オーバーロードされたオペレータを呼び出す + i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,bUseHeap,sp); + if(i2==0){ + if(idCalc==CALC_EQUAL) lstrcpy(temp2,"=="); + else GetCalcName(idCalc,temp2); + sprintf(temporary,"Operator %s",temp2); + SetError(27,temporary,cp); + goto error; + } + else if(i2==-1) goto error; + + continue; + } + } + + if(!CheckCalcType(idCalc,type_stack,sp)) goto error; + } + + switch(idCalc){ + //数値 + case 0: + index_stack[sp]=-1; + isNothing_stack[sp] = false; + bUseHeap[sp]=0; + + UseReg=pobj_reg->GetNextReg(); + XmmReg=pobj_reg->GetNextXmmReg(); + + bXmm=0; + + char *term; + term=values[i]; + + if( calc[i+1]%100 == CALC_AS ){ + // As演算子の右辺値 + //型名 + if( Type::StringToType( term, resultType ) ){ + resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST ); + } + else{ + SetError(3, term, cp ); + goto error; + } + + type_stack[sp] = resultType.GetBasicType(); + index_stack[sp] = resultType.GetIndex(); + sp++; + + break; + } + + if(term[0]=='\"'){ + //リテラル文字列 + if(!RemoveStringQuotes(term)){ + SetError(43,NULL,cp); + goto error; + } + i3=lstrlen(term); +StrLiteral: + + if( baseType.IsObject() || baseType.IsNull() ){ + //要求タイプがオブジェクト、または未定のとき + + //String型オブジェクトを生成 + NewStringObject(UseReg,term); + + type_stack[sp]=DEF_OBJECT; + index_stack[sp]=(LONG_PTR)pobj_DBClass->GetStringClassPtr(); + bLiteralCalculation=0; + + if(bXmm) pobj_reg->LockXmmReg(); + else pobj_reg->LockReg(); + + sp++; + break; + } + + type_stack[sp]=typeOfPtrChar; + bLiteralCalculation=0; + + i2 = dataTable.AddString( term, i3 ); + + //mov reg,i2 + op_mov_RV(sizeof(_int64),UseReg,i2); + obp-=sizeof(long); + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + + if(UseReg==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + } + else if((term[0]=='e'||term[0]=='E')&& + (term[1]=='x'||term[1]=='X')&& + term[2]=='\"'){ + //拡張版リテラル文字列（エスケープシーケンス可能） + if(!RemoveStringQuotes(term+2)){ + SetError(43,NULL,cp); + goto error; + } + i3=FormatString_EscapeSequence(term+2); + term+=2; + + goto StrLiteral; + } + else if(IsVariableTopChar(term[0])|| + term[0]=='*'|| + (term[0]=='.'&&IsVariableTopChar(term[1]))){ + ////////////////// + // 何らかの識別子 + + bool isLiteral; + if( TermOpe( term, baseType, resultType, isLiteral, &bUseHeap[sp] ) ){ + if(resultType.IsNull()){ + //戻り値が存在しないとき + for(i2=0;;i2++){ + if(term[i2]=='('||term[i2]=='\0'){ + term[i2]=0; + break; + } + } + SetError(38,term,cp); + + goto error; + } + + type_stack[sp] = resultType.GetBasicType(); + index_stack[sp] = resultType.GetIndex(); + + if( !isLiteral ){ + bLiteralCalculation=0; + } + + if( resultType.GetBasicType() & FLAG_CAST ){ + // 型名のみ + SetError(); + } + else{ + if( resultType.IsReal() == false && UseReg==REG_R14 ){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + if( resultType.IsReal() && XmmReg==REG_XMM4 ){ + if(resultType.IsDouble()){ + //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用 + pobj_sf->push(REG_XMM4,sizeof(double)); + } + if(resultType.IsSingle()){ + //movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用 + pobj_sf->push(REG_XMM4,sizeof(float)); + } + } + + if( resultType.IsReal() ){ + pobj_reg->LockXmmReg(); + } + else{ + pobj_reg->LockReg(); + } + } + + sp++; + break; + } + + + // Nothing + if( lstrcmp( term, "Nothing" ) == 0 ){ + isNothing_stack[sp] = true; + + type_stack[sp] = DEF_OBJECT; + if( baseType.IsObject() ){ + index_stack[sp] = baseType.GetIndex(); + } + else{ + index_stack[sp] = (LONG_PTR)pobj_DBClass->GetObjectClassPtr(); + } + + bLiteralCalculation = 0; + + //xor reg,reg + op_zero_reg( UseReg ); + + if(UseReg==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + + pobj_reg->LockReg(); + sp++; + break; + } + + + ////////////// + // 定数の場合 + ////////////// + + i3 = CDBConst::obj.GetBasicType(term); + if(i3){ + if( CDBConst::obj.IsStringPtr( term ) ){ + //リテラル文字列 + + double dbl = CDBConst::obj.GetDoubleData(term); + memcpy(&i64data,&dbl,sizeof(double)); + + //バイト数 + i3=lstrlen((char *)i64data); + + memcpy(term,(char *)i64data,i3); + term[i3]=0; + goto StrLiteral; + } + + type_stack[sp] = i3; + if(IsRealNumberType(i3)){ + //実数 + double dbl = CDBConst::obj.GetDoubleData(term); + memcpy(&i64data,&dbl,sizeof(double)); + goto Literal; + } + else if(IsWholeNumberType(i3)){ + //整数 + i64data = CDBConst::obj.GetWholeData(term); + goto Literal; + } + /*else if(i3==DEF_STRING){ + //リテラル文字列 + + //バイト数 + i3=(int)dbl; + + memcpy(term,temporary,i3); + goto StrLiteral; + }*/ + else{ + SetError(1,NULL,0); + goto error; + } + } + + + //該当する識別子が見当たらないときはエラー扱いにする + bError=1; + SetError(3,term,cp); + type_stack[sp]=DEF_DOUBLE; + } + else{ + //リテラル値 + type_stack[sp]=GetLiteralValue(term,&i64data,baseType.GetBasicType()); +Literal: + if(type_stack[sp]==DEF_DOUBLE){ + //64ビット浮動小数型 + bXmm=1; + + if(XmmReg==REG_XMM4){ + //mov r14,i64data + op_mov64_ToReg(REG_R14,i64data); + + + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + else{ + i3 = dataTable.Add( i64data ); + + //movlpd xmm_reg,qword ptr[data table offset] + OpBuffer[obp++]=(char)0x66; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x12; + OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3); + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=i3; + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + } + } + else if(type_stack[sp]==DEF_SINGLE){ + //32ビット浮動小数型 + bXmm=1; + + float flt; + int i32data; + memcpy(&dbl,&i64data,sizeof(double)); + flt=(float)dbl; + memcpy(&i32data,&flt,sizeof(long)); + + if(XmmReg==REG_XMM4){ + SetError(); // TODO: 未実装 + //push term + op_push_value(i32data); + } + else{ + i3=dataTable.Add( i32data ); + + //movss xmm_reg,dword ptr[data table offset] + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x10; + OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3); + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=i3; + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + } + } + else{ + //整数 + + index_stack[sp]=GetLiteralIndex(i64data); + + //mov reg,i64data + op_mov64_ToReg(UseReg,i64data); + + if(UseReg==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + } + } + + if(bXmm) pobj_reg->LockXmmReg(); + else pobj_reg->LockReg(); + + sp++; + break; + + //論理演算子 + case CALC_XOR: + case CALC_OR: + case CALC_AND: + if(!CalcTwoTerm_Logical(idCalc,type_stack,index_stack,&sp)) goto error; + break; + case CALC_NOT: + //value[sp-1]=Not value[sp-1] + //NOT演算子 + if(!Calc_Not(type_stack,sp)) goto error; + break; + + //比較演算子 + case CALC_PE: //value[sp-2] <= value[sp-1] + case CALC_QE: //value[sp-2] >= value[sp-1] + case CALC_P: //value[sp-2] < value[sp-1] + case CALC_Q: //value[sp-2] > value[sp-1] + case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1] + case CALC_EQUAL: //value[sp-2] = value[sp-1] + if(!CalcTwoTerm_Relational(idCalc,type_stack,index_stack,&sp)) goto error; + break; + + //ビットシフト + case CALC_SHL: //value[sp-2] << value[sp-1] + case CALC_SHR: //value[sp-2] >> value[sp-1] + if(!Calc_Shift(idCalc,type_stack,&sp)) goto error; + break; + + //算術演算 + case CALC_ADDITION: + case CALC_SUBTRACTION: + case CALC_PRODUCT: + if(!CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp)) goto error; + break; + case CALC_MOD: + //value[sp-2]%=value[sp-1] + //剰余演算 + if(!Calc_Mod(type_stack,index_stack,&sp)) goto error; + break; + case CALC_QUOTIENT: + //value[sp-2]/=value[sp-1]; + //除算 + if(!Calc_Divide(type_stack,&sp,baseType.GetBasicType())) goto error; + break; + case CALC_INTQUOTIENT: + //value[sp-2]/=value[sp-1] + //整数除算 + if(!Calc_IntDivide(type_stack,index_stack,&sp)) goto error; + break; + case CALC_MINUSMARK: + //value[sp-1]=-value[sp-1] + //符号反転 + if(!Calc_MinusMark(type_stack,sp)) goto error; + break; + case CALC_POWER: + //べき乗演算（浮動小数点演算のみ） + if(!Calc_Power(type_stack,&sp)) goto error; + break; + case CALC_AS: + //キャスト + if(!Calc_Cast(type_stack,index_stack,&sp)) goto error; + break; + case CALC_BYVAL: + //ポインタ型→参照型 + if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){ + //ポインタ型ではないとき + SetError( 3, NULL, cp ); + goto error; + } + + type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] ); + + break; + + default: + SetError(300,NULL,cp); + goto error; + } + } + + if(bError) goto error; + + if(sp!=1){ + SetError(1,NULL,cp); + goto error; + } + + if(bLiteralCalculation){ + //右辺値が数値の定数式の場合 + Type resultType; + StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType); + + obp=BeforeObp; + pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum; + pobj_DataTableSchedule->num=Before_DataTableScheduleNum; + pobj_Reloc->copy(pobj_BackReloc); + pobj_sf->num=Before_StackFrameScheduleNum; + *pobj_reg=objReg_Backup; + + if(resultType.IsReal()){ + if(baseType.IsReal()) resultType=baseType; + + XmmReg=pobj_reg->LockXmmReg(); + + if(resultType.IsDouble()){ + i3 = dataTable.Add( i64data ); + + //movlpd xmm_reg,qword ptr[data table offset] + OpBuffer[obp++]=(char)0x66; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x12; + OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3); + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=i3; + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + } + if(resultType.IsSingle()){ + memcpy(&dbl,&i64data,sizeof(_int64)); + + float flt; + int i32data; + flt=(float)dbl; + memcpy(&i32data,&flt,sizeof(long)); + + i3 = dataTable.Add( i32data ); + + //movss xmm_reg,dword ptr[data table offset] + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x10; + OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3); + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=i3; + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + } + } + else{ + if(!resultType.Is64()){ + //整数（符号有り/無し） + + i3=(long)i64data; + + if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF; + if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF; + + i64data=(_int64)i3; + } + + UseReg=pobj_reg->LockReg(); + + //mov reg,i64data + op_mov64_ToReg(UseReg,i64data); + } + + type_stack[0]=resultType.GetBasicType(); + index_stack[0]=resultType.GetIndex(); + } + else{ + //右辺値が数値の定数式ではないとき + if(IS_LITERAL(index_stack[0])) index_stack[0]=-1; + } + + if(pbUseHeap) *pbUseHeap=bUseHeap[0]; + + if(IsRealNumberType(type_stack[0])) + *pReg=pobj_reg->UnlockXmmReg(); + else + *pReg=pobj_reg->UnlockReg(); + + + if(bInitRegSwitch){ + //整合性をチェック（バグ回避） + pobj_reg->bug_check(); + + //作業レジスタを解放 + delete pobj_reg; + pobj_reg=0; + } + + resultType.SetType( type_stack[0], index_stack[0] ); + + bool isSuccessful = true; + goto finish; + + + + ////////////////// + // エラー処理 + ////////////////// + +error: + + *pobj_reg=objReg_Backup; + + if(bInitRegSwitch){ + //作業レジスタを解放 + delete pobj_reg; + pobj_reg=0; + } + + isSuccessful = false; + goto finish; + + + + +finish: + + for(i=0;ipush(REG_XMM4,sizeof(double)); + } + } + if(AnswerType==DEF_SINGLE){ + /////////////////////// + // Single演算 + /////////////////////// + + if(idCalc==CALC_ADDITION){ + //addss xmm_reg1,xmm_reg2 + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x58; + OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2)); + } + else if(idCalc==CALC_SUBTRACTION){ + //subss xmm_reg1,xmm_reg2 + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x5C; + OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2)); + } + else if(idCalc==CALC_PRODUCT){ + //mulss xmm_reg1,xmm_reg2 + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x59; + OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2)); + } + + if(xmm_reg1==REG_XMM4){ + //movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用 + pobj_sf->push(REG_XMM4,sizeof(float)); + } + } + } + else if(Is64Type(type[sp-2])||Is64Type(type[sp-1])){ + ////////////////////// + // 64ビット整数演算 + ////////////////////// + + SetTowTermToReg_Whole64Calc(type,sp,®1,®2); + + if(idCalc==CALC_ADDITION){ + //add reg1,reg2 + op_add64_reg(reg1,reg2); + } + else if(idCalc==CALC_SUBTRACTION){ + //sub reg1,reg2 + op_sub64_reg(reg1,reg2); + } + else if(idCalc==CALC_PRODUCT){ + //mul reg1,reg2 + op_imul_RR(sizeof(_int64),reg1,reg2); + } + + if(reg1==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + } + else{ + //32ビット以下の整数演算 + + SetTowTermToReg_Whole32Calc(type,sp,®1,®2); + + if(idCalc==CALC_ADDITION){ + //add reg1,reg2 + op_add32_reg(reg1,reg2); + } + else if(idCalc==CALC_SUBTRACTION){ + //sub reg1,reg2 + op_sub32_reg(reg1,reg2); + } + else if(idCalc==CALC_PRODUCT){ + //mul reg1,reg2 + op_imul_RR(sizeof(long),reg1,reg2); + } + + if(reg1==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + } + + sp--; + type[sp-1]=AnswerType; + + *pStackPointer=sp; + + return 1; +} + + + +BOOL Calc_Mod(int *type,LONG_PTR *index_stack,int *pStackPointer){ + //value[sp-2]%=value[sp-1] + //剰余演算 + + int reg1,reg2; + int AnswerType; + + int sp; + sp=*pStackPointer; + + if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){ + //実数演算は行えないため、エラー扱い + SetError(45,"mod",cp); + return 0; + } + + ///////////////////////// + // 64ビット整数演算のみ + ///////////////////////// + + AnswerType=NeutralizationType(type[sp-2],index_stack[sp-2],type[sp-1],index_stack[sp-1]); + + //2つの項を適切なレジスタにセット + SetTowTermToReg_Whole64Calc(type,sp,®1,®2); + + if(reg2==REG_RAX||reg2==REG_RDX){ + //mov r15,reg2 + op_mov_RR(REG_R15,reg2); + + reg2=REG_R15; + } + + //raxまたはrdxが使用中かどうかを調べる( true/使用中, false/未使用 ) + bool isUsingRax = pobj_reg->IsUsing( REG_RAX ); + bool isUsingRdx = pobj_reg->IsUsing( REG_RDX ); + + if(reg1!=REG_RDX && isUsingRdx){ + //結果レジスタがrdxでない場合（使用されている可能性があるとき） + + //mov qword ptr[rsp+offset],rdx ※スタックフレームを利用 + pobj_sf->push(REG_RDX); + } + + if(reg1!=REG_RAX && isUsingRax){ + //結果レジスタがraxでない場合（使用されている可能性があるとき） + + //mov qword ptr[rsp+offset],rax ※スタックフレームを利用 + pobj_sf->push(REG_RAX); + } + + { + + //mov rax,reg1 + op_mov_RR(REG_RAX,reg1); + + if(IsSignedType(type[sp-2])){ + //符号拡張 + //rdx:rax ← rax + + //cqo + OpBuffer[obp++]=(char)0x48; + OpBuffer[obp++]=(char)0x99; + } + else{ + //ビット拡張 + //rdx:rax ← rax + + //xor rdx,rdx + op_zero_reg(REG_RDX); + } + + if(IsSignedType(AnswerType)){ + //idiv reg2 + op_idiv64_reg(reg2); + } + else{ + //div reg2 + op_div64_reg(reg2); + } + + //mov reg1,rdx + op_mov_RR(reg1,REG_RDX); + + } + + if(reg1!=REG_RAX && isUsingRax){ + //結果レジスタがraxでない場合（使用されている可能性があるとき） + + //mov rax,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_RAX); + } + + if(reg1!=REG_RDX && isUsingRdx){ + //結果レジスタがrdxでない場合（使用されている可能性があるとき） + + //mov rdx,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_RDX); + } + + + if(reg1==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + + sp--; + type[sp-1]=AnswerType; + + + *pStackPointer=sp; + + return 1; +} + +BOOL Calc_Divide(int *type,int *pStackPointer,int BaseType){ + //value[sp-2]/=value[sp-1]; + //除算 + + int sp; + sp=*pStackPointer; + + /////////////////////// + // 実数演算のみ + /////////////////////// + + int AnswerType; + if(type[sp-2]==DEF_SINGLE&&type[sp-1]==DEF_SINGLE&&BaseType==DEF_SINGLE) AnswerType=DEF_SINGLE; + else AnswerType=DEF_DOUBLE; + + int xmm_reg1,xmm_reg2; + + //2つの項を適切なレジスタにセット + SetTowTermToReg_RealCalc(AnswerType,type,sp,&xmm_reg1,&xmm_reg2); + + if(AnswerType==DEF_DOUBLE){ + /////////////////////// + // Double演算 + /////////////////////// + + //divsd xmm_reg1,xmm_reg2 + OpBuffer[obp++]=(char)0xF2; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x5E; + OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2)); + + if(xmm_reg1==REG_XMM4){ + //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用 + pobj_sf->push(REG_XMM4,sizeof(double)); + } + } + if(AnswerType==DEF_SINGLE){ + /////////////////////// + // Single演算 + /////////////////////// + + //divss xmm_reg1,xmm_reg2 + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x5E; + OpBuffer[obp++]=(char)(0xC0 | REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2)); + + if(xmm_reg1==REG_XMM4){ + //movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用 + pobj_sf->push(REG_XMM4,sizeof(float)); + } + } + + sp--; + type[sp-1]=AnswerType; + + + *pStackPointer=sp; + + return 1; +} + +BOOL Calc_IntDivide(int *type,LONG_PTR *index_stack,int *pStackPointer){ + //value[sp-2]/=value[sp-1] + //除算（整数） + + int reg1,reg2; + int AnswerType; + + int sp; + sp=*pStackPointer; + + if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){ + //実数演算は行えないため、エラー扱い + SetError(45,"mod",cp); + return 0; + } + + ///////////////////////// + // 64ビット整数演算のみ + ///////////////////////// + + AnswerType=NeutralizationType(type[sp-2],index_stack[sp-2],type[sp-1],index_stack[sp-1]); + + //2つの項を適切なレジスタにセット + SetTowTermToReg_Whole64Calc(type,sp,®1,®2); + + if(reg2==REG_RAX||reg2==REG_RDX){ + //mov r15,reg2 + op_mov_RR(REG_R15,reg2); + + reg2=REG_R15; + } + + //raxまたはrdxが使用中かどうかを調べる( true/使用中, false/未使用 ) + bool isUsingRax = pobj_reg->IsUsing( REG_RAX ); + bool isUsingRdx = pobj_reg->IsUsing( REG_RDX ); + + if(reg1!=REG_RDX && isUsingRdx){ + //結果レジスタがrdxでない場合（使用されている可能性があるとき） + + //mov qword ptr[rsp+offset],rdx ※スタックフレームを利用 + pobj_sf->push(REG_RDX); + } + + if(reg1!=REG_RAX && isUsingRax){ + //結果レジスタがraxでない場合（使用されている可能性があるとき） + + //mov qword ptr[rsp+offset],rax ※スタックフレームを利用 + pobj_sf->push(REG_RAX); + } + + { + + //mov rax,reg1 + op_mov_RR(REG_RAX,reg1); + + if(IsSignedType(type[sp-2])){ + //符号拡張 + //rdx:rax ← rax + + //cqo + OpBuffer[obp++]=(char)0x48; + OpBuffer[obp++]=(char)0x99; + } + else{ + //ビット拡張 + //rdx:rax ← rax + + //xor rdx,rdx + op_zero_reg(REG_RDX); + } + + if(IsSignedType(AnswerType)){ + //idiv reg2 + op_idiv64_reg(reg2); + } + else{ + //div reg2 + op_div64_reg(reg2); + } + + //mov reg1,rax + op_mov_RR(reg1,REG_RAX); + + } + + if(reg1!=REG_RAX && isUsingRax){ + //結果レジスタがraxでない場合（使用されている可能性があるとき） + + //mov rax,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_RAX); + } + + if(reg1!=REG_RDX && isUsingRdx){ + //結果レジスタがrdxでない場合（使用されている可能性があるとき） + + //mov rdx,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_RDX); + } + + + if(reg1==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + + sp--; + type[sp-1]=AnswerType; + + *pStackPointer=sp; + + return 1; +} + +BOOL Calc_MinusMark(int *type,int sp){ + //value[sp-1]=-value[sp-1] + //符号反転 + + int xmm_reg; + int reg; + int i32data; + + if(type[sp-1]==DEF_DOUBLE){ + SetOneTermToReg_RealCalc(type[sp-1],&xmm_reg); + + double dbl; + dbl=-1; + i32data = dataTable.Add( dbl ); + + //mulsd xmm_reg,qword ptr[data table offset] ※data = -1 + OpBuffer[obp++]=(char)0xF2; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x59; + OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3); + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=i32data; + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + + if(xmm_reg==REG_XMM4){ + //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用 + pobj_sf->push(REG_XMM4,sizeof(double)); + } + } + else if(type[sp-1]==DEF_SINGLE){ + SetOneTermToReg_RealCalc(type[sp-1],&xmm_reg); + + float flt; + flt=-1; + i32data = dataTable.Add( flt ); + + //mulss xmm_reg,dword ptr[data table offset] ※data = -1 + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x59; + OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3); + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=i32data; + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + + if(xmm_reg==REG_XMM4){ + //movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用 + pobj_sf->push(REG_XMM4,sizeof(float)); + } + } + else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ + SetOneTermToReg_Whole64Calc(type[sp-1],®); + + //imul reg,-1 + op_imul_RV(sizeof(_int64),reg,-1); + + if(reg==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + + type[sp-1]=DEF_INT64; //QWordはInt64へ + } + else if(IsWholeNumberType(type[sp-1])){ + SetOneTermToReg_Whole32Calc(type[sp-1],®); + + //imul reg,-1 + op_imul_RV(sizeof(long),reg,-1); + + if(reg==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + + type[sp-1]=GetSignedType(type[sp-1]); + } + + return 1; +} + +BOOL Calc_Power(int *type,int *pStackPointer){ + //べき乗（実数演算のみ） + + int sp; + sp=*pStackPointer; + + + //2つの項を適切なレジスタにセット + int xmm_reg1,xmm_reg2; + SetTowTermToReg_RealCalc(DEF_DOUBLE,type,sp,&xmm_reg1,&xmm_reg2); + + + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + + //////////////// + // 呼び出し + //////////////// + + if(xmm_reg1==REG_XMM1){ + //movsd xmm0,xmm_reg1 + op_movsd_RR(REG_XMM0,xmm_reg1); + + //movsd xmm1,xmm_reg2 + op_movsd_RR(REG_XMM1,xmm_reg2); + } + else{ + //movsd xmm1,xmm_reg2 + op_movsd_RR(REG_XMM1,xmm_reg2); + + //movsd xmm0,xmm_reg1 + op_movsd_RR(REG_XMM0,xmm_reg1); + } + + //call pow + extern UserProc *pSub_pow; + op_call(pSub_pow); + + //movsd xmm4,xmm0 + op_movsd_RR(REG_XMM4,REG_XMM0); + + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + + + ////////////////////////////////// + // 戻り値を所定のレジスタへ格納 + ////////////////////////////////// + + if(xmm_reg1==REG_XMM4){ + //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用 + pobj_sf->push(REG_XMM0,sizeof(double)); + } + else{ + //movsd xmm_reg1,xmm4 + op_movsd_RR(xmm_reg1,REG_XMM4); + } + + + sp--; + type[sp-1]=DEF_DOUBLE; + + *pStackPointer=sp; + return 1; +} + +BOOL Calc_Shift(int idCalc,int *type,int *pStackPointer){ + //ビットシフト + + int sp; + sp=*pStackPointer; + + if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){ + //いずれかの項が実数のとき + SetError(45,"<<",cp); + return 0; + } + + + ///////////////////////// + // 64ビット整数演算のみ + ///////////////////////// + int reg1,reg2; + + //2つの項を適切なレジスタにセット + SetTowTermToReg_Whole64Calc(type,sp,®1,®2); + + int sw=0; + if(reg1==REG_RCX){ + //mov r15,rcx + op_mov_RR(REG_R15,REG_RCX); + + reg1=REG_R15; + } + else if(reg2!=REG_RCX){ + sw=1; + + //mov qword ptr[rsp+offset],rcx ※スタックフレームを利用 + pobj_sf->push(REG_RCX); + } + + //mov rcx,reg2 + op_mov_RR(REG_RCX,reg2); + + if(idCalc==CALC_SHL){ + //左シフトは符号あり、なしは同様の動きをする + + //32ビット型にする + if(!Is64Type(type[sp-2])){ + ExtendTypeTo32(type[sp-2],reg1); + + if(IsSignedType(type[sp-2])) type[sp-2]=DEF_LONG; + else type[sp-2]=DEF_DWORD; + } + + //shl reg1,cl + op_shl_reg(GetTypeSize(type[sp-2],-1),reg1); + } + else if(idCalc==CALC_SHR){ + if(IsSignedType(type[sp-2])){ + //符号あり + + //sar + op_sar_reg(GetTypeSize(type[sp-2],-1),reg1); + } + else{ + //符号なし + + //shr + op_shr_reg(GetTypeSize(type[sp-2],-1),reg1); + } + } + + if(sw==0){ + //mov rcx,r15 + op_mov_RR(REG_RCX,REG_R15); + } + else{ + //mov rcx,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_RCX); + } + + if(reg1==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + + sp--; + + *pStackPointer=sp; + return 1; +} Index: trunk/abdev/BasicCompiler64/NumOpe_Logical.cpp =================================================================== --- trunk/abdev/BasicCompiler64/NumOpe_Logical.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/NumOpe_Logical.cpp (revision 149) @@ -0,0 +1,153 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +BOOL CalcTwoTerm_Logical(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer){ + //value[sp-2] xor= value[sp-1] + //xor演算 + + int sp; + sp=*pStackPointer; + + if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){ + //いずれかの項が実数のとき + SetError(45,"xor",cp); + return 0; + } + + int reg1,reg2; + + if(Is64Type(type[sp-2])||Is64Type(type[sp-1])){ + ////////////////////// + // 64ビット整数演算 + ////////////////////// + + SetTowTermToReg_Whole64Calc(type,sp,®1,®2); + + if(idCalc==CALC_XOR){ + //xor reg1,reg2 + op_xor_reg(sizeof(_int64),reg1,reg2); + } + else if(idCalc==CALC_OR){ + //or reg1,reg2 + op_or_reg(sizeof(_int64),reg1,reg2); + } + else if(idCalc==CALC_AND){ + //and reg1,reg2 + op_and_reg(sizeof(_int64),reg1,reg2); + } + + if(reg1==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + + sp--; + type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]); + } + else{ + //32ビット以下の整数演算 + + SetTowTermToReg_Whole32Calc(type,sp,®1,®2); + + if(idCalc==CALC_ADDITION){ + //add reg1,reg2 + op_xor_reg(sizeof(long),reg1,reg2); + } + else if(idCalc==CALC_OR){ + //or reg1,reg2 + op_or_reg(sizeof(long),reg1,reg2); + } + else if(idCalc==CALC_AND){ + //and reg1,reg2 + op_and_reg(sizeof(long),reg1,reg2); + } + + if(reg1==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + + sp--; + type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]); + } + + *pStackPointer=sp; + return 1; +} + +BOOL Calc_Not(int *type,int sp){ + //value[sp-1]=Not value[sp-1] + //NOT演算子 + + if(IsRealNumberType(type[sp-1])){ + //実数のとき + SetError(45,"Not",cp); + return 0; + } + + int reg; + + if( type[sp - 1] == DEF_BOOLEAN ){ + SetOneTermToReg_Whole32Calc(type[sp-1],®); + + if( reg != REG_RAX ){ + //mov rax,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_RAX); + } + + //cmp reg,0 + op_cmp_value(GetTypeSize(type[sp-1],-1),reg,0); + + //setne al + op_setne( REG_RAX ); + + //and rax,000000FFh + op_and64_value(REG_RAX,(int)0xFF); + + //neg + op_neg( REG_RAX ); + + //sbb rax, rax + op_sbb_RR( sizeof(_int64), REG_RAX, REG_RAX ); + + //add rax, 1 + op_add_RV( REG_RAX, 1 ); + + if( reg != REG_RAX ){ + //mov reg,rax + op_mov_RR( reg, REG_RAX ); + + //mov qword ptr[rsp+offset],rax ※スタックフレームを利用 + pobj_sf->push(REG_RAX); + } + + if(reg==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + } + else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){ + SetOneTermToReg_Whole64Calc(type[sp-1],®); + + //not reg + op_not_reg(sizeof(_int64),reg); + + if(reg==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + } + else if(IsWholeNumberType(type[sp-1])){ + SetOneTermToReg_Whole32Calc(type[sp-1],®); + + //not reg + op_not_reg(sizeof(long),reg); + + if(reg==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + } + + return 1; +} Index: trunk/abdev/BasicCompiler64/NumOpe_Relation.cpp =================================================================== --- trunk/abdev/BasicCompiler64/NumOpe_Relation.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/NumOpe_Relation.cpp (revision 149) @@ -0,0 +1,164 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +BOOL CalcTwoTerm_Relational(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer){ + int reg1,reg2; + int AnswerType; + + int sp; + sp=*pStackPointer; + + AnswerType=NeutralizationType(type[sp-2],index_stack[sp-2],type[sp-1],index_stack[sp-1]); + + if(IsRealNumberType(AnswerType)){ + //////////////// + // 実数演算 + //////////////// + int xmm_reg1,xmm_reg2; + + //2つの項を適切なレジスタにセット + SetTowTermToReg_RealCalc(AnswerType,type,sp,&xmm_reg1,&xmm_reg2); + + if(AnswerType==DEF_DOUBLE){ + //comisd xmm_reg1,xmm_reg2 + op_comisd(xmm_reg1,xmm_reg2); + } + else if(AnswerType==DEF_SINGLE){ + //comiss xmm_reg1,xmm_reg2 + op_comiss(xmm_reg1,xmm_reg2); + } + + //Xmmレジスタを解放 + pobj_reg->UnlockXmmReg(); + + //汎用レジスタを確保 + reg1=pobj_reg->LockReg(); + } + else if(Is64Type(AnswerType)){ + ////////////////////// + // 64ビット整数演算 + ////////////////////// + + //2つの項を適切なレジスタにセット + SetTowTermToReg_Whole64Calc(type,sp,®1,®2); + + //cmp reg1,reg2 + op_cmp_reg(sizeof(_int64),reg1,reg2); + } + else{ + ////////////////////// + // 32ビット整数演算 + ////////////////////// + + //2つの項を適切なレジスタにセット + SetTowTermToReg_Whole32Calc(type,sp,®1,®2); + + //cmp reg1,reg2 + op_cmp_reg(sizeof(long),reg1,reg2); + } + + + //////////////////// + // 条件分岐 + //////////////////// + + if(idCalc==CALC_PE){ + // reg1 <= reg2 + if(IsSignedType(AnswerType)&&IsWholeNumberType(AnswerType)){ + //符号あり演算 + //jle + OpBuffer[obp++]=(char)0x7E; + } + else{ + //符号なし演算 + //jbe + OpBuffer[obp++]=(char)0x76; + } + } + else if(idCalc==CALC_QE){ + // reg1 >= reg2 + if(IsSignedType(AnswerType)&&IsWholeNumberType(AnswerType)){ + //符号あり演算 + //jge + OpBuffer[obp++]=(char)0x7D; + } + else{ + //符号なし演算 + //jae + OpBuffer[obp++]=(char)0x73; + } + } + else if(idCalc==CALC_P){ + // reg1 < reg2 + if(IsSignedType(AnswerType)&&IsWholeNumberType(AnswerType)){ + //符号あり演算 + //jl + OpBuffer[obp++]=(char)0x7C; + } + else{ + //符号なし演算 + //jb + OpBuffer[obp++]=(char)0x72; + } + } + else if(idCalc==CALC_Q){ + // reg1 > reg2 + if(IsSignedType(AnswerType)&&IsWholeNumberType(AnswerType)){ + //符号あり演算 + //jg + OpBuffer[obp++]=(char)0x7F; + } + else{ + //符号なし演算 + //ja + OpBuffer[obp++]=(char)0x77; + } + } + else if(idCalc==CALC_NOTEQUAL){ + // reg1 <> reg2 + + //jne + OpBuffer[obp++]=(char)0x75; + } + else if(idCalc==CALC_EQUAL){ + // reg1 = reg2 + + //je + OpBuffer[obp++]=(char)0x74; + } + OpBuffer[obp++]=(char)0x05; + + + ////////////////////// + // FALSEをセット + ////////////////////// + + //xor reg1,reg1 + op_zero_reg(reg1); + + //jmp 7（次のmovを飛び越す） + OpBuffer[obp++]=(char)0xEB; + OpBuffer[obp++]=(char)0x07; + + + /////////////////// + // Trueをセット + /////////////////// + + //mov reg1,1 + op_mov_RV(sizeof(_int64),reg1,1); + + + if(reg1==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + + sp--; + + *pStackPointer=sp; + + type[sp-1]=DEF_BOOLEAN; + + return 1; +} Index: trunk/abdev/BasicCompiler64/NumOpe_TypeOperation.cpp =================================================================== --- trunk/abdev/BasicCompiler64/NumOpe_TypeOperation.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/NumOpe_TypeOperation.cpp (revision 149) @@ -0,0 +1,561 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +void ExtendTypeTo64(int type,int reg){ + if(type==DEF_LONG){ + //movsxd reg64,reg32 + op_movsxd(reg,reg); + } + else if(type==DEF_DWORD){ + //and reg,00000000FFFFFFFFh + } + else if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){ + //movsx reg64,reg16 + op_movsx64_FromReg16(reg,reg); + } + else if(type==DEF_WORD){ + //and reg,000000000000FFFFh + op_and64_value(reg,(int)0xFFFF); + } + else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){ + //movsx reg64,reg8 + op_movsx64_FromReg8(reg,reg); + } + else if(type==DEF_BYTE || type==DEF_BOOLEAN){ + //and reg,00000000000000FFh + op_and64_value(reg,(int)0x00FF); + } +} +void ExtendTypeTo32(int type,int reg){ + if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){ + //movsx reg32,reg16 + op_movsx32_FromReg16(reg,reg); + } + else if(type==DEF_WORD){ + //and reg,0000FFFFh + op_and32_value(reg,(int)0xFFFF); + } + else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){ + //movsx reg32,reg8 + op_movsx32_FromReg8(reg,reg); + } + else if(type==DEF_BYTE || type==DEF_BOOLEAN){ + //and reg,000000FFh + op_and32_value(reg,(int)0xFF); + } +} +void ExtendTypeTo16(int type,int reg){ + if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){ + //movsx reg16,reg8 + op_movsx16_FromReg8(reg,reg); + } + else if(type==DEF_BYTE){ + //and reg,000000FFh + op_and32_value(reg,(int)0xFF); + } +} + +void ChangeTypeToXmm_Double(int type,int xmm_reg,int general_reg){ + if(type==DEF_DOUBLE){ + //なにもしない + } + else if(type==DEF_SINGLE){ + //Single型 + + //cvtss2sd + op_cvtss2sd(xmm_reg,xmm_reg); + } + else if(Is64Type(type)){ + //64ビット整数型 + + //cvtsi2sd xmm_reg,reg + op_cvtsi2sd_reg(sizeof(_int64),xmm_reg,general_reg); + + if(type==DEF_QWORD){ + //符号なし + + //test reg,reg + op_test(general_reg,general_reg); + + //jge 9 + OpBuffer[obp++]=(char)0x7D; + OpBuffer[obp++]=(char)0x09; + + //addsd xmm_reg,qword ptr[offset] ※offset value:43f0000000000000 + int temp; + _int64 i64data=0x43f0000000000000; + temp=dataTable.Add( i64data ); + OpBuffer[obp++]=(char)0xF2; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x58; + OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3); + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=temp; + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + } + } + else if(type==DEF_DWORD){ + //符号なし32ビット値 + + //64ビットにレジスタ値を拡張 + ExtendTypeTo64(type,general_reg); + + //cvtsi2sd xmm_reg,reg + op_cvtsi2sd_reg(sizeof(_int64),xmm_reg,general_reg); + } + else{ + //その他整数 + + //32ビットにレジスタ値を拡張 + ExtendTypeTo32(type,general_reg); + + //cvtsi2sd xmm_reg,reg + op_cvtsi2sd_reg(sizeof(long),xmm_reg,general_reg); + } +} +void ChangeTypeToXmm_Single(int type,int xmm_reg,int general_reg){ + if(type==DEF_DOUBLE){ + //Double型 + + //cvtsd2ss + op_cvtsd2ss(xmm_reg,xmm_reg); + } + else if(type==DEF_SINGLE){ + //なにもしない + } + else if(Is64Type(type)){ + //64ビット整数型 + + //cvtsi2ss xmm_reg,reg + op_cvtsi2ss_reg(sizeof(_int64),xmm_reg,general_reg); + + if(type==DEF_QWORD){ + //符号なし + + //test reg,reg + op_test(general_reg,general_reg); + + //jge 9 + OpBuffer[obp++]=(char)0x7D; + OpBuffer[obp++]=(char)0x09; + + //addss xmm_reg,dword ptr[offset] ※offset value:5f800000 + int temp; + long i32data=0x5f800000; + temp=dataTable.Add( i32data ); + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x58; + OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3); + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=temp; + pobj_DataTableSchedule->add(); + obp+=sizeof(long); + } + } + else if(type==DEF_DWORD){ + //符号なし32ビット値 + + //64ビットにレジスタ値を拡張 + ExtendTypeTo64(type,general_reg); + + //cvtsi2ss xmm_reg,reg + op_cvtsi2ss_reg(sizeof(_int64),xmm_reg,general_reg); + } + else{ + //その他整数 + + //32ビットにレジスタ値を拡張 + ExtendTypeTo32(type,general_reg); + + //cvtsi2ss xmm_reg,reg + op_cvtsi2ss_reg(sizeof(long),xmm_reg,general_reg); + } +} + +void ChangeTypeToWhole(int OldType,int NewType,int reg,int xmm_reg){ + if(OldType==DEF_DOUBLE){ + if(Is64Type(NewType)){ + //cvttsd2si reg,xmm_reg + op_cvttsd2si_xmm(sizeof(_int64),reg,xmm_reg); + } + else{ + //cvttsd2si reg,xmm_reg + op_cvttsd2si_xmm(sizeof(long),reg,xmm_reg); + } + } + else if(OldType==DEF_SINGLE){ + if(Is64Type(NewType)){ + //cvttss2si reg,xmm_reg + op_cvttss2si_xmm(sizeof(_int64),reg,xmm_reg); + } + else{ + //cvttss2si reg,xmm_reg + op_cvttss2si_xmm(sizeof(long),reg,xmm_reg); + } + } + else{ + //整数から整数へ変換 + + if(Is64Type(NewType)){ + ExtendTypeTo64(OldType,reg); + } + else if(GetTypeSize(NewType,-1)==sizeof(long)){ + ExtendTypeTo32(OldType,reg); + } + else if(GetTypeSize(NewType,-1)==sizeof(short)){ + ExtendTypeTo16(OldType,reg); + } + } +} + + + +///////////////////////////////////////// +// 1つの項を適切なレジスタへセット +///////////////////////////////////////// + +void SetOneTermToReg_RealCalc(int TermType,int *pXmmReg){ + int xmm_reg; + + if(IsRealNumberType(TermType)){ + //実数型 + xmm_reg=pobj_reg->GetLockingXmmReg(); + + if(xmm_reg==REG_XMM4){ + if(TermType==DEF_DOUBLE){ + //movlpd xmm4,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(xmm_reg,sizeof(double)); + } + if(TermType==DEF_SINGLE){ + //movss xmm4,dword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(xmm_reg,sizeof(float)); + } + } + } + else{ + SetError(300,NULL,cp); + } + + *pXmmReg=xmm_reg; +} +void SetOneTermToReg_Whole64Calc(int TermType,int *pReg){ + //1つの項を適切なレジスタへセット（64ビット整数演算用） + int reg; + + reg=pobj_reg->GetLockingReg(); + + if(reg==REG_R14){ + //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R14); + } + + //レジスタ値を64ビットに拡張 + ExtendTypeTo64(TermType,reg); + + *pReg=reg; +} +void SetOneTermToReg_Whole32Calc(int TermType,int *pReg){ + //1つの項を適切なレジスタへセット（32ビット整数演算用） + int reg; + + reg=pobj_reg->GetLockingReg(); + + if(reg==REG_R14){ + //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R14); + } + + //レジスタ値を32ビットに拡張 + ExtendTypeTo32(TermType,reg); + + *pReg=reg; +} + + + +///////////////////////////////////////// +// 2つの項を適切なレジスタへセット +///////////////////////////////////////// + +void SetTowTermToReg_RealCalc(int AnswerType,int *type,int sp,int *pXmmReg1,int *pXmmReg2){ + //2つの項を適切なレジスタへセット（Double演算用） + int xmm_reg1,xmm_reg2,temp_reg; + + + /////////////////// + // 第2項 + /////////////////// + + if(IsRealNumberType(type[sp-1])){ + //実数型 + xmm_reg2=pobj_reg->UnlockXmmReg(); + + if(xmm_reg2==REG_XMM4){ + xmm_reg2=REG_XMM5; + + if(type[sp-1]==DEF_DOUBLE){ + //movlpd xmm5,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(xmm_reg2,sizeof(double)); + } + if(type[sp-1]==DEF_SINGLE){ + //movss xmm5,dword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(xmm_reg2,sizeof(float)); + } + } + else{ + if(!IsRealNumberType(type[sp-2])){ + if(type[sp-1]==DEF_DOUBLE){ + //movsd xmm5,xmm_reg + OpBuffer[obp++]=(char)0xF2; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x10; + OpBuffer[obp++]=(char)(0xE8 | REGISTER_OPERAND(xmm_reg2)); + } + if(type[sp-1]==DEF_SINGLE){ + //movss xmm5,xmm_reg + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x10; + OpBuffer[obp++]=(char)(0xE8 | REGISTER_OPERAND(xmm_reg2)); + } + + xmm_reg2=REG_XMM5; + } + } + } + else{ + //整数値 + + temp_reg=pobj_reg->UnlockReg(); + + if(temp_reg==REG_R14){ + //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R14); + } + + xmm_reg2=REG_XMM5; + } + + //汎用レジスタ（temp_reg）をXMMレジスタ（xmm_reg2）にコピー + if(AnswerType==DEF_DOUBLE) + ChangeTypeToXmm_Double(type[sp-1],xmm_reg2,temp_reg); + if(AnswerType==DEF_SINGLE) + ChangeTypeToXmm_Single(type[sp-1],xmm_reg2,temp_reg); + + + /////////////////// + // 第1項 + /////////////////// + + if(IsRealNumberType(type[sp-2])){ + //実数 + xmm_reg1=pobj_reg->GetLockingXmmReg(); + + if(xmm_reg1==REG_XMM4){ + if(type[sp-2]==DEF_DOUBLE){ + //movlpd xmm4,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(xmm_reg1,sizeof(double)); + } + if(type[sp-2]==DEF_SINGLE){ + //movss xmm4,dword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(xmm_reg1,sizeof(float)); + } + } + } + else{ + //整数 + + temp_reg=pobj_reg->UnlockReg(); + + if(temp_reg==REG_R14){ + //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R14); + } + + xmm_reg1=pobj_reg->LockXmmReg(); + } + + //汎用レジスタ（temp_reg）をXMMレジスタ（xmm_reg1）にコピー + if(AnswerType==DEF_DOUBLE) + ChangeTypeToXmm_Double(type[sp-2],xmm_reg1,temp_reg); + if(AnswerType==DEF_SINGLE) + ChangeTypeToXmm_Single(type[sp-2],xmm_reg1,temp_reg); + + + *pXmmReg1=xmm_reg1; + *pXmmReg2=xmm_reg2; +} +void SetTowTermToReg_Whole64Calc(int *type,int sp,int *pReg1,int *pReg2){ + //2つの項を適切なレジスタへセット（64ビット整数演算用） + int reg1,reg2; + + ////////////////// + // 第2項 + ////////////////// + reg2=pobj_reg->UnlockReg(); + + if(reg2==REG_R14){ + //mov r15,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R15); + + reg2=REG_R15; + } + + //レジスタ値を64ビットに拡張 + ExtendTypeTo64(type[sp-1],reg2); + + + ////////////////// + // 第1項 + ////////////////// + reg1=pobj_reg->GetLockingReg(); + + if(reg1==REG_R14){ + //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R14); + } + + //レジスタ値を64ビットに拡張 + ExtendTypeTo64(type[sp-2],reg1); + + + *pReg1=reg1; + *pReg2=reg2; +} +void SetTowTermToReg_Whole32Calc(int *type,int sp,int *pReg1,int *pReg2){ + //2つの項を適切なレジスタへセット（32ビット整数演算用） + int reg1,reg2; + + ////////////////// + // 第2項 + ////////////////// + reg2=pobj_reg->UnlockReg(); + + if(reg2==REG_R14){ + //mov r15,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R15); + + reg2=REG_R15; + } + + //レジスタ値を32ビットに拡張 + ExtendTypeTo32(type[sp-1],reg2); + + + ////////////////// + // 第1項 + ////////////////// + reg1=pobj_reg->GetLockingReg(); + + if(reg1==REG_R14){ + //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R14); + } + + //レジスタ値を32ビットに拡張 + ExtendTypeTo32(type[sp-2],reg1); + + + *pReg1=reg1; + *pReg2=reg2; +} + + + +//////////////////////////// +// As 演算子によるキャスト +//////////////////////////// + +BOOL Calc_Cast(int *type,LONG_PTR *index_stack,int *pStackPointer){ + //キャスト + + int sp; + sp=*pStackPointer; + + int CastType; + CastType=type[sp-1]; + if((CastType&FLAG_CAST)==0){ + SetError(47,NULL,cp); + return 0; + } + CastType=CastType&(~FLAG_CAST); + + int xmm_reg,reg; + + if(IsRealNumberType(CastType)){ + //実数型へキャスト + + if(IsRealNumberType(type[sp-2])){ + SetOneTermToReg_RealCalc(type[sp-2],&xmm_reg); + } + else{ + if(Is64Type(type[sp-2])) + SetOneTermToReg_Whole64Calc(type[sp-2],®); + else if(IsWholeNumberType(type[sp-2])) + SetOneTermToReg_Whole32Calc(type[sp-2],®); + + pobj_reg->UnlockReg(); + + xmm_reg=pobj_reg->LockXmmReg(); + } + + if(CastType==DEF_DOUBLE){ + //Double型にデータ変換 + ChangeTypeToXmm_Double(type[sp-2],xmm_reg,reg); + } + else if(CastType==DEF_SINGLE){ + //Single型にデータ変換 + ChangeTypeToXmm_Single(type[sp-2],xmm_reg,reg); + } + + if(xmm_reg==REG_XMM4){ + //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用 + pobj_sf->push(REG_XMM4,sizeof(double)); + } + } + else{ + //その他整数型へ変換 + + if(IsRealNumberType(type[sp-2])){ + SetOneTermToReg_RealCalc(type[sp-2],&xmm_reg); + + pobj_reg->UnlockXmmReg(); + + reg=pobj_reg->LockReg(); + + //整数型へデータ変換 + ChangeTypeToWhole(type[sp-2],CastType,reg,xmm_reg); + + if(reg==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + } + else{ + reg=pobj_reg->GetLockingReg(); + + if(reg==REG_R14){ + //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R14); + } + + //整数型へデータ変換 + ChangeTypeToWhole(type[sp-2],CastType,reg,0); + + if(reg==REG_R14){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push(REG_R14); + } + } + } + + type[sp-2]=CastType; + index_stack[sp-2]=index_stack[sp-1]; + + sp--; + + *pStackPointer=sp; + return 1; +} Index: trunk/abdev/BasicCompiler64/Opcode.h =================================================================== --- trunk/abdev/BasicCompiler64/Opcode.h (revision 149) +++ trunk/abdev/BasicCompiler64/Opcode.h (revision 149) @@ -0,0 +1,516 @@ +//Opcode.h + + +//レジスタを示す定数 +#define REG_EAX 1 +#define REG_EBX 2 +#define REG_ECX 3 +#define REG_EDX 4 +#define REG_ESP 5 +#define REG_EBP 6 + +#define REGISTER_OPERAND(reg) (reg&0x07) + +#define REG_NON -1 +#define REG_RAX 0x00 //reg:000 +#define REG_RCX 0x01 //reg:001 +#define REG_RDX 0x02 //reg:010 +#define REG_RBX 0x03 //reg:011 +#define REG_RSP 0x04 //reg:100 +#define REG_RBP 0x05 //reg:101 +#define REG_RSI 0x06 //reg:110 +#define REG_RDI 0x07 //reg:111 +#define REG_R8 0x08 //reg:000（REXプリフィックス） +#define REG_R9 0x09 //reg:001（REXプリフィックス） +#define REG_R10 0x0A //reg:010（REXプリフィックス） +#define REG_R11 0x0B //reg:011（REXプリフィックス） +#define REG_R12 0x0C //reg:100（REXプリフィックス） +#define REG_R13 0x0D //reg:101（REXプリフィックス） +#define REG_R14 0x0E //reg:110（REXプリフィックス） +#define REG_R15 0x0F //reg:111（REXプリフィックス） + +#define REG_XMM0 0x10 //reg:000 +#define REG_XMM1 0x11 //reg:001 +#define REG_XMM2 0x12 //reg:010 +#define REG_XMM3 0x13 //reg:011 +#define REG_XMM4 0x14 //reg:100 +#define REG_XMM5 0x15 //reg:101 +#define REG_XMM6 0x16 //reg:110 +#define REG_XMM7 0x17 //reg:111 +#define REG_XMM8 0x18 //reg:000 +#define REG_XMM9 0x19 //reg:001 +#define REG_XMM10 0x1A //reg:010 +#define REG_XMM11 0x1B //reg:011 +#define REG_XMM12 0x1C //reg:100 +#define REG_XMM13 0x1D //reg:101 +#define REG_XMM14 0x1E //reg:110 +#define REG_XMM15 0x1F //reg:111 + +#define IS_XMM_REG(reg) (reg&0x10) + + + +//変数の種類 +#define NON_VAR 0 +#define VAR_GLOBAL 1 // Global Variable +#define VAR_REFGLOBAL 2 // Global Refference Variable +#define VAR_LOCAL 3 // Local Variable +#define VAR_REFLOCAL 4 // Local Refference Variable +#define VAR_DIRECTMEM 5 // Direct memory + + +extern int cp; +extern int obp; +extern char *OpBuffer; + +#define breakpoint OpBuffer[obp++]=(char)0xCC; + + +//ラベルアドレス +struct LABEL{ + char *pName; + int line; + DWORD address; +}; + +//Goto未知ラベル +struct GOTOLABELSCHEDULE{ + char *pName; + int line; + DWORD pos; + DWORD now_cp; +}; + + +//プロシージャの種類 +#define PROC_DEFAULT 1 //ユーザー定義関数 +#define PROC_DLL 2 //DLL関数 +#define PROC_BUILTIN 3 //コンパイラ埋め込み型 +#define PROC_PTR 4 //関数ポインタ + +//プロシージャ +struct PROCEDURE{ + char name[255]; + int address; + int types[MAX_PARMS]; + _int8 ByVal[MAX_PARMS]; + BOOL ReturnType; +}; + +//With情報 +struct WITHINFO{ + char **ppName; + int *pWithCp; + int num; +}; + + +class CStackFrame:public CSchedule{ + /////////////////////////// + // スタックフレーム管理 + /////////////////////////// + + int lowest_sp; //スタックポインタの最下位位置 + int now_sp; //スタックポインタ + int max_parm_size; //パラメータの最大サイズ + int local_parm_size; //ローカル領域のパラメータサイズ + +public: + //コンストラクタ + CStackFrame(); + + //デストラクタ + ~CStackFrame(); + + void SetLocalParmSize(int size); + int GetFrameSize(); + int GetNowSp(); + void mov_sp( int reg ); + int push(int reg); + void push(int xmm_reg,int varSize); + void ref_offset_data( int reg, int sp_offset ); + void ref(int reg); + void ref(int xmm_reg,int varSize); + void pop(int reg = REG_NON); + void pop(int xmm_reg,int varSize); + void parameter_allocate(int size); + void RunningSchedule(void); + + void error_check(void); +}; +extern CStackFrame *pobj_sf; + + +class CBlockReg{ + int array_BlockReg[256]; + int num; + +public: + CBlockReg(); + void lock(int reg); + void unlock(int reg); + BOOL check(int reg); + void clear(void); + + //レジスタのバックアップと復旧 + void backup(); + void restore(); +}; +extern CBlockReg *pobj_BlockReg; +class CRegister{ + //////////////////// + // レジスタ管理 + //////////////////// + + //利用可能なレジスタを列挙する関数 + void EnumRegister(int *pRegList,int nMaxList,int *array_reg,int *sp,int AnswerReg); + + int array_UseReg[16],sp_UseReg; + + int array_XmmReg[16]; + int sp_XmmReg; + + int init_sp_reg,init_sp_xmm_reg; + +public: + CRegister(){}; + CRegister(int AnswerReg); + ~CRegister(){}; + + //コンパイラにバグがないかをチェックする機構 + void bug_check(); + + //汎用レジスタ + int GetNextReg(); + int GetLockingReg(); + int LockReg(); + int UnlockReg(); + + //XMMレジスタ + int GetNextXmmReg(); + int GetLockingXmmReg(); + int LockXmmReg(); + int UnlockXmmReg(); + + //レジスタが利用中かどうかを調べる + bool IsUsing( int reg ); + + //レジスタのバックアップと復旧 + void backup(); + void restore(); +}; +extern CRegister *pobj_reg; + + +#define BACKUP_REGISTER_RESOURCE \ + /* レジスタをスタックフレームにバックアップ */ \ + pobj_BlockReg->backup(); \ + if(pobj_reg) pobj_reg->backup(); \ + \ + /* レジスタブロッキングオブジェクトを退避して再生成 */ \ + CBlockReg *pobj_BlockReg_back; \ + pobj_BlockReg_back=pobj_BlockReg; \ + pobj_BlockReg=new CBlockReg; \ + \ + /* レジスタ管理オブジェクトポインタを退避して0をセット */ \ + CRegister *pobj_reg_back; \ + pobj_reg_back=pobj_reg; \ + pobj_reg=0; + +#define RESTORE_REGISTER_RESOURCE \ + /* レジスタブロッキングオブジェクトポインタを復元 */ \ + delete pobj_BlockReg; \ + pobj_BlockReg=pobj_BlockReg_back; \ + \ + /* レジスタ管理オブジェクトポインタを復元 */ \ + delete pobj_reg; \ + pobj_reg=pobj_reg_back; \ + \ + /* レジスタをスタックフレームから復元 */ \ + if(pobj_reg) pobj_reg->restore(); \ + pobj_BlockReg->restore(); + + + +//RSrcSection.cpp +char *GetRSrcSectionBuffer(int *pLen); + +//Compile.cpp +void ChangeOpcode(char *Command); +void GetGlobalDataForDll(void); +DWORD CompileBuffer(char Return_Sequence,WORD Return_Command); + +//Register.cpp +BOOL IsGeneralReg(int reg); +BOOL IsXmmReg(int reg); +BOOL IsVolatileReg(int reg); +void IfR14Push( int reg ); + +//Compile_Calc.cpp +void SetVariableFromRax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar); +void OpcodeCalc(const char *Command); + +//NumOpe.cpp +bool TermOpe( + const char *term, + const Type &baseType, + Type &resultType, + bool &isLiteral, + BOOL *pbUseHeap, + bool isWantObject = false, + bool *pIsClassName = NULL, + bool isProcedureCallOnly = false ); +bool NumOpe( int *pReg, + const char *Command, + const Type &baseType, + Type &resultType, + BOOL *pbUseHeap = NULL ); + +//NumOpe_Arithmetic.cpp +BOOL CalcTwoTerm_Arithmetic(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer); +BOOL Calc_Mod(int *type,LONG_PTR *index_stack,int *pStackPointer); +BOOL Calc_Divide(int *type,int *pStackPointer,int BaseType); +BOOL Calc_IntDivide(int *type,LONG_PTR *index_stack,int *pStackPointer); +BOOL Calc_MinusMark(int *type,int sp); +BOOL Calc_Power(int *type,int *pStackPointer); +BOOL Calc_Shift(int idCalc,int *type,int *pStackPointer); + +//NumOpe_Logical.cpp +BOOL CalcTwoTerm_Logical(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer); +BOOL Calc_Not(int *type,int sp); + +//NumOpe_Relation.cpp +BOOL CalcTwoTerm_Relational(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer); + +//NumOpe_TypeOperation.cpp +void ExtendTypeTo64(int type,int reg); +void ExtendTypeTo32(int type,int reg); +void ExtendTypeTo16(int type,int reg); +void ChangeTypeToXmm_Double(int type,int xmm_reg,int general_reg); +void ChangeTypeToXmm_Single(int type,int xmm_reg,int general_reg); +void ChangeTypeToWhole(int OldType,int NewType,int reg,int xmm_reg); +void SetOneTermToReg_RealCalc(int TermType,int *pXmmReg); +void SetOneTermToReg_Whole64Calc(int TermType,int *pReg); +void SetOneTermToReg_Whole32Calc(int TermType,int *pReg); +void SetTowTermToReg_RealCalc(int AnswerType,int *type,int sp,int *pXmmReg1,int *pXmmReg2); +void SetTowTermToReg_Whole64Calc(int *type,int sp,int *pReg1,int *pReg2); +void SetTowTermToReg_Whole32Calc(int *type,int sp,int *pReg1,int *pReg2); +BOOL Calc_Cast(int *type,LONG_PTR *index_stack,int *pStackPointer); + +//Compile_Set_Var.cpp +BOOL IsUse_r11(RELATIVE_VAR *pRelativeVar); +void SetStructVariableFromRax( const Type &varType, const Type &calcType, RELATIVE_VAR *pRelativeVar,BOOL bUseHeap); +void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar); +void SetBooleanVariable(int type,RELATIVE_VAR *pRelative); +void SetWholeVariable(int varSize,int type,RELATIVE_VAR *pRelative); + +//increment.cpp +void IncDec(int idCalc, const char *lpszLeft, const char *lpszRight); + +//Compile_Calc_PushVar.cpp +void SetXmmReg_DoubleVariable(RELATIVE_VAR *pRelativeVar,int xmm_reg); +void SetXmmReg_SingleVariable(RELATIVE_VAR *pRelativeVar,int xmm_reg); +void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg); + +//Compile_Interface.cpp +bool CastToInterface( int reg, int vtblReg, const CClass &baseClass, const CClass &interfaceClass ); + +//Compile_Object.cpp +void Operator_New( const CClass &classObj, const char *objectSizeStr, const char *parameter,const Type &baseTypeInfo ); +void OpcodeDelete(const char *Parameter, bool isSweeping); + +//Compile_Var.cpp +bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const CClass &objClass, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess); +void SetThisPtrToReg(int reg); +bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss = NULL); +bool SetInitGlobalData(int offset,const Type &type,const int *SubScripts,const char *InitBuf); +#define DIMFLAG_INITDEBUGVAR 0x01 +#define DIMFLAG_NONCALL_CONSTRACTOR 0x02 +#define DIMFLAG_STATIC 0x04 +#define DIMFLAG_CONST 0x08 +void dim( char *VarName,int *SubScripts,Type &type, const char *InitBuf,const char *ConstractParameter,DWORD dwFlags); +void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar); +bool Compile_AddGlobalRootsForGc(); + +//ParamImpl.cpp +class ParamImpl{ + char *Parms[255]; + vector types; + int ParmsNum; + + Type returnType; + + //一時オブジェクト管理用 + bool useTempObject; + bool useTempParameters[255]; + int StackOffsetOfTempObject[255]; + +public: + ParamImpl(const char *buffer); + ParamImpl(const Parameters ¶ms); + ~ParamImpl(); + void SetReturnType( const Type &returnType ); + +private: + bool EvaluateOverloadScore( int level, const Parameters &targetParms, const Type &targetResultType ); + +public: + UserProc *_OverloadSolution( const char *name, std::vector &subs, bool isEnabledReturnType = false ); + UserProc *OverloadSolution( const char *name, std::vector &subs, bool isEnabledReturnType = false ); + + void ApplyDefaultParameters( const Parameters ¶ms ); + bool ErrorCheck( const string &procName, const Parameters ¶ms, int SecondParmNum = -1 ); + void MacroParameterSupport( const Parameters ¶ms ); + void SetStructParameter( int reg, const Type &baseType, const char *expression ); + void SetParameter( const string &procName, const Parameters ¶ms, int SecondParmNum = -1 ); + + //一時オブジェクトパラメータの生成と破棄 + int NewTempParameters( const string &procName, const Parameters ¶ms, int SecondParmNum = -1 ); + void DeleteTempParameters(); + + void BackupParameter(int pi_num); + void RestoreParameter(int pi_num); +}; + +//CLockParameter.cpp +#define MAX_LOCKPARMS 255 +class CDBLockParms{ +public: + int array_LevelCount[MAX_LOCKPARMS]; + CDBLockParms(); + ~CDBLockParms(); + + void lock(int level); + void unlock(int level); +}; + +//Compile_CallProc.cpp +void AddLocalVarAddrSchedule(); +#define PROCFLAG_NEW 1 +bool Opcode_CallProcPtr(const char *variable, const char *lpszParms,ProcPointer *pProcPointer); +bool Opcode_CallProc(const char *Parameter,UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType); +bool Opcode_CallDllProc( const char *lpszParms,DllProc *pDllProc); + +//Compile_ProcOp.cpp +void CompileLocal(); + +//Compile_Func.cpp +int GetFunctionFromName(char *FuncName); +bool Opcode_CallFunc( const char *Parameter, const int FuncNum, Type &ReturnTypeInfo, bool isCallOn = true ); + +//OperatorProc.cpp +void FreeTempObject(int reg,const CClass *pobj_c); +int CallOperatorProc(int idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp); +void CallCastOperatorProc(int reg,Type &calcType,BOOL bCalcUseHeap,const Type &toType); +void CallIndexerGetterProc(int reg,const CClass *pobj_Class,char *ObjectName,char *Parameter,Type &resultType); + +//Compile_Statement.cpp +void OpcodeOthers(const char *Command); +void OpcodeIf(char *Parameter); +void OpcodeGoto(char *Parameter); +void OpcodeWhile(char *Parameter); +void OpcodeFor(char *Parameter); +void OpcodeDo(char *Parameter); +void OpcodeContinue(void); +void OpcodeExitSub(void); +void OpcodeSelect( const char *Parameter ); +void OpcodeCase(char *Parameter); +void OpcodeGosub(char *Parameter); +void OpcodeReturn(char *Parameter); +void OpcodeSetPtrData(char *Parameter,int type); + + +//InsertOpcode.cpp +void InsertDimStatement_ToProcHead(char *lpszCommand); + + + +//////////////////////////////// +// AMD64機械語生成に利用する関数郡 +//////////////////////////////// + +//Mod（モード） +#define MOD_BASE (char)0x00 +#define MOD_DISP32 (char)0xFF +#define MOD_BASE_DISP8 (char)0x40 +#define MOD_BASE_DISP32 (char)0x80 +#define MOD_REG (char)0xC0 + +#define USE_OFFSET 1 +#define NON_OFFSET 0 + +//amd64_main.cpp +BOOL IsSafeReg(int reg); +void op_push(int reg); +void op_push_value(long data); +void op_pop(int reg); +void op_mov_RV (int op_size,int reg,int i32data); +void op_mov_RV64 (int reg,_int64 i64data); +void op_mov_RM (int op_size,int reg,int base_reg,int offset,char mod); +void op_mov_RM_ex (int op_size,int reg,int base_reg1,int base_reg2,int offset,BOOL bUseOffset); +void op_mov_MR (int op_size,int reg,int base_reg,int offset,char mod); +void op_mov_MR_ex (int op_size,int reg,int base_reg1,int base_reg2,int offset,BOOL bUseOffset); +void op_mov_MV (int op_size,int base_reg,int offset,BOOL bUseOffset,int i32data); +void op_mov_RR (int reg1,int reg2); +void op_mov64_ToReg (int reg,_int64 i64data); +void op_mov64_ToReg (int reg,int i32data); +void op_movsxd (int reg64,int reg32); +void op_movsx64_FromReg16 (int reg64,int reg16); +void op_movsx64_FromReg8 (int reg64,int reg8); +void op_movsx32_FromReg16 (int reg32,int reg16); +void op_movsx32_FromReg8 (int reg32,int reg8); +void op_movsx16_FromReg8 (int reg32,int reg8); +void op_inc (int reg); +void op_dec (int reg); +void op_add_RM (int op_size,int reg,int base_reg,int offset,char mod); +void op_add_RV (int reg,int offset); +void op_add64_reg (int reg1,int reg2); +void op_add32_reg (int reg1,int reg2); +void op_sub_RV (int op_size,int reg,int i32data); +void op_sub64_reg (int reg1,int reg2); +void op_sub32_reg (int reg1,int reg2); +void op_sbb_RR ( int op_size, int reg1, int reg2 ); +void op_imul_RR (int op_size,int reg1,int reg2); +void op_imul_RV (int op_size,int reg,int i32data); +void op_div64_reg (int reg); +void op_idiv64_reg (int reg); +void op_shl_reg (int op_size,int reg); +void op_sar_reg (int op_size,int reg); +void op_shr_reg (int op_size,int reg); +void op_and_reg (int op_size,int reg1,int reg2); +void op_and64_value (int reg,int offset); +void op_and32_value (int reg,int offset); +void op_or_reg (int op_size,int reg1,int reg2); +void op_xor_reg (int op_size,int reg1,int reg2); +void op_not_reg (int op_size,int reg); +void op_neg ( int reg ); +void op_test (int reg1,int reg2); +void op_cmp_reg (int op_size,int reg1,int reg2); +void op_cmp_value (int op_size,int reg,char byte_data); +void op_setne (int reg); +void op_movlpd_MR (int xmm_reg,int base_reg,int offset,char mod); +void op_movlpd_RM (int xmm_reg,int base_reg,int offset,char mod); +void op_movsd_RR (int xmm_reg1,int xmm_reg2); +void op_movsd_MR (int xmm_reg,int base_reg,int offset,char mod); +void op_movss_RR (int xmm_reg1,int xmm_reg2); +void op_movss_RM (int xmm_reg,int base_reg,int offset,char mod); +void op_movss_MR (int xmm_reg,int base_reg,int offset,char mod); +void op_movd_RX (int reg,int xmm_reg); +void op_cvtsd2ss (int xmm_reg1,int xmm_reg2); +void op_cvtss2sd (int xmm_reg1,int xmm_reg2); +void op_cvttsd2si_xmm (int op_size,int reg,int xmm_reg); +void op_cvttss2si_xmm (int op_size,int reg,int xmm_reg); +void op_cvtsi2sd_reg (int op_size,int xmm_reg,int reg); +void op_cvtsi2ss_reg (int op_size,int xmm_reg,int reg); +void op_comisd (int xmm_reg1,int xmm_reg2); +void op_comiss (int xmm_reg1,int xmm_reg2); +void op_rep_movs (int op_size); +void op_add_rsp(int num); +void op_sub_rsp(int num); +void op_add_esp(int num); +void op_sub_esp(int num); +void op_fld_ptr_esp(int type); +void op_zero_reg(int reg); +void op_call( UserProc *pUserProc ); +void op_call( DllProc *pDllProc ); +void op_ret(); Index: trunk/abdev/BasicCompiler64/OperatorProc.cpp =================================================================== --- trunk/abdev/BasicCompiler64/OperatorProc.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/OperatorProc.cpp (revision 149) @@ -0,0 +1,343 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +void FreeTempObject(int reg,const CClass *pobj_c){ + if(!IsSafeReg(reg)) SetError(300,NULL,cp); + + //////////////////////////////////////////////// + // 演算過程で利用した一時オブジェクトを破棄 + // Thisポインタをr14レジスタを介して渡す + //////////////////////////////////////////////// + + const CMethod *method = pobj_c->GetDestructorMethod(); + if( method ){ + //mov rcx,reg + op_mov_RR(REG_RCX,reg); + + //call DestructorProcAddr + op_call( method->pUserProc ); + } + + //mov rcx,reg + op_mov_RR(REG_RCX,reg); + + //call free + extern UserProc *pSub_free; + op_call(pSub_free); +} + +int CallOperatorProc(int idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp){ + //オーバーロードされたオペレータ関数を呼び出す + CClass *pobj_c; + pobj_c=(CClass *)index_stack[sp-2]; + + std::vector subs; + pobj_c->GetMethods().Enum( idCalc, subs ); + if( subs.size() == 0 ){ + return 0; + } + + + //項の数 + BOOL bTwoTerm=1; + if(idCalc==CALC_AS) bTwoTerm=0; + + + ///////////////////////////////////////////// + // オーバーロード解決用のパラメータを設定 + ///////////////////////////////////////////// + + Parameters params; + + if(bTwoTerm){ + params.push_back( new Parameter( "", Type( type_stack[sp-1], index_stack[sp-1] ) ) ); + } + + //オーバーロードを解決 + char temporary[255]; + if(idCalc==CALC_EQUAL) lstrcpy(temporary,"=="); + else GetCalcName(idCalc,temporary); + UserProc *pUserProc = OverloadSolution( temporary, subs, params, baseType ); + + if(!pUserProc){ + if(bTwoTerm){ + delete params[0]; + } + return -1; + } + else{ + //オーバーロードされていないが、パラメータ個数が一致しないとき + if(params.size()!=pUserProc->Params().size()){ + if(bTwoTerm){ + delete params[0]; + } + return -1; + } + } + + for(int i=0;i<(int)params.size();i++){ + CheckDifferentType( + pUserProc->Params()[i]->GetBasicType(), + pUserProc->Params()[i]->GetIndex(), + params[i]->GetBasicType(), + params[i]->GetIndex(), + "", + i); + } + + if(bTwoTerm){ + delete params[0]; + } + + int right_side_size = GetTypeSize(type_stack[sp-1],index_stack[sp-1]); + + if(bTwoTerm){ + if( pUserProc->RealParams()[1]->IsStruct() &&pUserProc->RealParams()[1]->IsRef() == false ){ + //一時オブジェクトはメソッド内で破棄される + bUseHeap[sp-1]=0; + } + } + + + if( pUserProc->ReturnType().IsStruct() ){ + ////////////////////////////////////////////////////// + // 戻り値に構造体インスタンスを持つ場合 + // ※ByRef _System_ReturnValue パラメータ用領域を取得 + ////////////////////////////////////////////////////// + + + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + int object_size = pUserProc->ReturnType().GetClass().GetSize(); + + //mov rcx,object_size + op_mov_RV(sizeof(_int64),REG_RCX,object_size); + + //call calloc + extern UserProc *pSub_calloc; + op_call(pSub_calloc); + + //mov r13,rax + op_mov_RR(REG_R13,REG_RAX); + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + } + + int reg1,reg2; + if(bTwoTerm){ + //右の項（実数の場合が未完成） + SetOneTermToReg_Whole64Calc(type_stack[sp-1],®2); + pobj_reg->UnlockReg(); + if( !pUserProc->RealParams()[1]->IsRef() == false ){ + //一時参照を作成 + pobj_sf->push( reg2 ); + pobj_sf->mov_sp( reg2 ); + } + } + + //左の項 + SetOneTermToReg_Whole64Calc(DEF_INT64,®1); + pobj_reg->UnlockReg(); + + //ヒープ解放用に退避 + if(bUseHeap[sp-1]){ + //mov qword ptr[rsp+offset],reg2 ※スタックフレームを利用 + pobj_sf->push(reg2); + } + if(bUseHeap[sp-2]){ + //mov qword ptr[rsp+offset],reg1 ※スタックフレームを利用 + pobj_sf->push(reg1); + } + + + + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + if(reg1==REG_RDX||reg1==REG_R8){ + //mov r14,reg1 + op_mov_RR(REG_R14,reg1); + reg1=REG_R14; + } + + + if(bTwoTerm){ + if( pUserProc->ReturnType().IsStruct() ){ + //mov r8,reg2 + op_mov_RR(REG_R8,reg2); + } + else{ + //mov rdx,reg2 + op_mov_RR(REG_RDX,reg2); + } + } + + if( pUserProc->ReturnType().IsStruct() ){ + //mov rdx,r13 + op_mov_RR(REG_RDX,REG_R13); + } + + //mov rcx,reg1 + op_mov_RR(REG_RCX,reg1); + + //call operator_proc + op_call(pUserProc); + + if( !pUserProc->ReturnType().IsNull() ){ + //戻り値を一時的に退避 + + //mov r13,rax + op_mov_RR(REG_R13,REG_RAX); + } + + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + + + + if(bUseHeap[sp-2]||bUseHeap[sp-1]){ + + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + if(bUseHeap[sp-2]){ + //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R14); + + FreeTempObject(REG_R14,(CClass *)index_stack[sp-2]); + } + if(bUseHeap[sp-1]){ + //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R14); + + FreeTempObject(REG_R14,(CClass *)index_stack[sp-1]); + } + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + } + + if(bTwoTerm){ + if( !pUserProc->RealParams()[1]->IsRef() == false ){ + //一時参照を破棄 + pobj_sf->pop(); + } + } + + if( !pUserProc->ReturnType().IsNull() ){ + //戻り値をreg1にセット + reg1=pobj_reg->LockReg(); + + //mov reg1,r13 + op_mov_RR(reg1,REG_R13); + } + + sp--; + type_stack[sp-1]=pUserProc->ReturnType().GetBasicType(); + index_stack[sp-1]=pUserProc->ReturnType().GetIndex(); + + if( pUserProc->ReturnType().IsStruct() ){ + //構造体が戻ったときはヒープ領域にインスタンスが格納されている + //※後にfreeする必要あり + bUseHeap[sp-1]=1; + } + else bUseHeap[sp-1]=0; + + return 1; +} + +void CallCastOperatorProc(int reg,Type &calcType,BOOL bCalcUseHeap,const Type &toType){ + int type_stack[10]; + LONG_PTR index_stack[10]; + BOOL array_bUseHeap[10]; + int sp=2; + int iRet; + + + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + //regを第一項目としてロック + pobj_reg=new CRegister(reg); + pobj_reg->LockReg(); + + if(bCalcUseHeap){ + //未解放のインスタンスが存在する旨を示す警告 + SetError(-105,NULL,cp); + } + + //左辺 + type_stack[0]=calcType.GetBasicType(); + index_stack[0]=calcType.GetIndex(); + array_bUseHeap[0]=0; + type_stack[1]=toType.GetBasicType(); + index_stack[1]=toType.GetIndex(); + array_bUseHeap[1]=0; + + iRet=CallOperatorProc(CALC_AS,toType,type_stack,index_stack,array_bUseHeap,sp); + + pobj_reg->UnlockReg(); + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + + + if(iRet==1){ + //成功したとき + calcType.SetType( type_stack[0], index_stack[0] ); + return; + } + else if(iRet==-1){ + //エラーが発行されたとき + return; + } + + //エラーを発行 + SetError(-1,"キャスト演算子がオーバーロードされていません。",cp); +} + +//インデクサ（getter）を呼び出す +void CallIndexerGetterProc(int reg,const CClass *pobj_Class,char *ObjectName,char *Parameter,Type &resultType ){ + + std::vector subs; + pobj_Class->GetMethods().Enum( CALC_ARRAY_GET, subs ); + if( subs.size() == 0 ){ + return; + } + + ////////////////////////////////////////////////////// + ///// レジスタ資源のバックアップ + { BACKUP_REGISTER_RESOURCE + ////////////////////////////////////////////////////// + + Opcode_CallProc(Parameter,subs[0],0,ObjectName,DEF_OBJECT); + resultType = subs[0]->ReturnType(); + + //mov reg,rax + op_mov_RR(reg,REG_RAX); + + ///////////////////////////////////////////// + ////// レジスタ資源を復元 + RESTORE_REGISTER_RESOURCE + }//////////////////////////////////////////// + +} Index: trunk/abdev/BasicCompiler64/Register.cpp =================================================================== --- trunk/abdev/BasicCompiler64/Register.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/Register.cpp (revision 149) @@ -0,0 +1,316 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + + +//エラー用 +extern int cp; + + +//////////////////////////// +// レジスタのブロッキング +//////////////////////////// + +CBlockReg *pobj_BlockReg; + +CBlockReg::CBlockReg(){ + num=0; +} +void CBlockReg::lock(int reg){ + if(check(reg)){ + SetError(300,NULL,cp); + } + array_BlockReg[num++]=reg; +} +void CBlockReg::unlock(int reg){ + int i; + for(i=0;i=0;i--){ + if(IS_XMM_REG(array_BlockReg[i])){ + //movlpd qword ptr[rsp+offset],xmm_reg ※スタックフレームを利用 + pobj_sf->push(array_BlockReg[i],sizeof(double)); + } + else{ + //mov qword ptr[rsp+offset],reg ※スタックフレームを利用 + pobj_sf->push(array_BlockReg[i]); + } + } +} +void CBlockReg::restore(){ + int i; + + for(i=0;ipop(array_BlockReg[i],sizeof(double)); + } + else{ + //mov reg,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(array_BlockReg[i]); + } + } +} + + +/////////////////// +// レジスタ管理 +/////////////////// + +const int CalculationRegister[]={ + REG_RAX, + REG_RCX, + REG_RDX, + REG_RBX, + REG_RSI, + REG_RDI, + REG_R8, + REG_R9, + REG_R10 +}; + +const int CalculationXmmRegister[]={ + REG_XMM0, + REG_XMM1, + REG_XMM2, + REG_XMM3, + /*XMM4、XMM5は演算時に一時的に利用*/ +/* REG_XMM6, + REG_XMM7, + REG_XMM8, + REG_XMM9, + REG_XMM10, + REG_XMM11, + REG_XMM12, + REG_XMM13, + REG_XMM14, + REG_XMM15 関数呼び出し時のレジスタ保持を未搭載のため、保留*/ +}; + +CRegister *pobj_reg; + +void CRegister::EnumRegister(int *pRegList,int nMaxList,int *array_reg,int *sp,int AnswerReg){ + int i,i2,sw=0; + + i2=nMaxList-1; + for(i=0;i2>=0;i++,i2--){ + if(AnswerReg==pRegList[i2]){ + sw=1; + i--; + continue; + } + + if(pobj_BlockReg->check(pRegList[i2])){ + //レジスタがブロッキングされているとき + i--; + continue; + } + + array_reg[i]=pRegList[i2]; + } + + if(sw){ + array_reg[i++]=AnswerReg; + + //エラーチェック + if(pobj_BlockReg->check(AnswerReg)) SetError(300,NULL,cp); + } + + *sp=i-1; +} + +CRegister::CRegister(int AnswerReg){ + /* 例： AnswerReg=REG_RCX ※REG_RCXをスタックの最後尾へセット + ※r15、r14は一時保存用として利用する + ※r13は同一関数内の単発処理用の一時保存レジスタとして利用する + ※r12、r11は配列計算用として利用する + array_UseReg[0]=REG_R10 + array_UseReg[1]=REG_R9 + array_UseReg[2]=REG_R8 + array_UseReg[3]=REG_RBX + array_UseReg[4]=REG_RDX + array_UseReg[5]=REG_RAX + array_UseReg[6]=REG_RCX */ + + + /////////////////////////////////////////////////////////// + //array_UseRegに、計算に利用するレジスタリストを作成 + /////////////////////////////////////////////////////////// + + EnumRegister( + (int *)CalculationRegister, + sizeof(CalculationRegister)/sizeof(int), + array_UseReg, + &sp_UseReg, + AnswerReg); + + + + /////////////////////////////////////////////////////////// + //array_XmmRegに、計算に利用するレジスタリストを作成 + /////////////////////////////////////////////////////////// + + EnumRegister( + (int *)CalculationXmmRegister, + sizeof(CalculationXmmRegister)/sizeof(int), + array_XmmReg, + &sp_XmmReg, + AnswerReg); + + + init_sp_reg=sp_UseReg; + init_sp_xmm_reg=sp_XmmReg; +} +void CRegister::bug_check(){ + if(init_sp_reg!=sp_UseReg|| + init_sp_xmm_reg!=sp_XmmReg) SetError(300,NULL,cp); +} +int CRegister::GetNextReg(){ + if(sp_UseReg<0) return REG_R14; + return array_UseReg[sp_UseReg]; +} +int CRegister::GetLockingReg(){ + UnlockReg(); + return LockReg(); +} +int CRegister::LockReg(){ + int reg; + reg=GetNextReg(); + + sp_UseReg--; + + return reg; +} +int CRegister::UnlockReg(){ + sp_UseReg++; + return GetNextReg(); +} +int CRegister::GetNextXmmReg(){ + if(sp_XmmReg<0) return REG_XMM4; + return array_XmmReg[sp_XmmReg]; +} +int CRegister::GetLockingXmmReg(){ + UnlockXmmReg(); + return LockXmmReg(); +} +int CRegister::LockXmmReg(){ + int xmm_reg; + xmm_reg=GetNextXmmReg(); + + sp_XmmReg--; + + return xmm_reg; +} +int CRegister::UnlockXmmReg(){ + sp_XmmReg++; + return GetNextXmmReg(); +} +bool CRegister::IsUsing( int reg ){ + int i; + + //汎用レジスタを調べる + for(i=init_sp_reg;i>sp_UseReg;i--){ + if( array_UseReg[i] == reg ) return true; + } + + //XMMレジスタを調べる + for(i=init_sp_xmm_reg;i>sp_XmmReg;i--){ + if( array_XmmReg[i] == reg ) return true; + } + + //ブロックされている場合を考慮 + if( pobj_BlockReg->check( reg ) ) return true; + + //使用中でないとき + return false; +} +void CRegister::backup(){ + int i; + + //汎用レジスタを退避 + for(i=init_sp_reg;i>sp_UseReg;i--){ + //mov qword ptr[rsp+offset],reg ※スタックフレームを利用 + pobj_sf->push(array_UseReg[i]); + } + + //XMMレジスタを退避 + for(i=init_sp_xmm_reg;i>sp_XmmReg;i--){ + //mov qword ptr[rsp+offset],reg ※スタックフレームを利用 + pobj_sf->push(array_XmmReg[i],sizeof(_int64)); + } +} +void CRegister::restore(){ + int i; + + //XMMレジスタを復元 + if(sp_XmmReg<0) i=0; + else i=sp_XmmReg+1; + for(;i<=init_sp_xmm_reg;i++){ + //mov reg,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(array_XmmReg[i],sizeof(_int64)); + } + + //汎用レジスタを復元 + if(sp_UseReg<0) i=0; + else i=sp_UseReg+1; + for(;i<=init_sp_reg;i++){ + //mov reg,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(array_UseReg[i]); + } +} + + + +//////////////////////// +// その他 +//////////////////////// + +BOOL IsGeneralReg(int reg){ + if(REG_RAX<=reg&®<=REG_R15) return 1; + return 0; +} +BOOL IsXmmReg(int reg){ + if(REG_XMM0<=reg&®<=REG_XMM15) return 1; + return 0; +} +BOOL IsVolatileReg(int reg){ + if(reg==REG_RAX|| + reg==REG_RCX|| + reg==REG_RDX|| + REG_R8<=reg&®<=REG_R11|| + REG_XMM0<=reg&®<=REG_XMM5){ + //値を保持する必要なし + return 1; + } + else{ + //値を保持する必要あり + return 0; + } +} + +void IfR14Push( int reg ){ + if( reg == REG_R14 ){ + //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用 + pobj_sf->push( REG_R14 ); + } +} Index: trunk/abdev/BasicCompiler64/amd64_main.cpp =================================================================== --- trunk/abdev/BasicCompiler64/amd64_main.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/amd64_main.cpp (revision 149) @@ -0,0 +1,1809 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + + +BOOL IsSafeReg(int reg){ + switch(reg){ + case REG_RBX: + case REG_RSI: + case REG_RDI: + case REG_R12: + case REG_R13: + case REG_R14: + case REG_R15: + return 1; + default: + break; + } + return 0; +} + + + +////////////////////// +// rexプリフィックス +////////////////////// +void set_rex(int op_size,int reg,int index_reg,int base_reg){ + char RexByte; + + if(reg==REG_NON&&index_reg==REG_NON){ + ///////////////////////////////////// + // レジスタをr/mのみに指定するとき + ///////////////////////////////////// + + if((base_reg&0x08)==0){ + if(op_size==sizeof(char)&&(base_reg&0x04)){ + // r/m に spl,bpl,sil,dilを指定するとき + RexByte=0x40; + } + else RexByte=0; + } + else RexByte=(char)0x41; + } + else{ + ///////////////// + // 通常 + ///////////////// + + if((reg&0x08)==0){ + //reg … rax～rdi + + if((index_reg&0x08)==0){ + if((base_reg&0x08)==0) RexByte=0; + else RexByte=(char)0x41; + } + else{ + if((base_reg&0x08)==0) RexByte=(char)0x42; + else RexByte=(char)0x43; + } + } + else{ + //reg … r8～r15 + + if((index_reg&0x08)==0){ + if((base_reg&0x08)==0) RexByte=(char)0x44; + else RexByte=(char)0x45; + } + else{ + if((base_reg&0x08)==0) RexByte=(char)0x46; + else RexByte=(char)0x47; + } + } + } + + if(op_size==sizeof(_int64)){ + //64ビットオペランド + RexByte|=0x48; + } + + if(RexByte) OpBuffer[obp++]=RexByte; +} + + + +///////////////////////////////////////////////// +// ModR/Mバイト、SIBバイト、ディスプレースメント +///////////////////////////////////////////////// + +//スケール +#define SCALE_NON (char)0x00 +#define SCALE_2 (char)0x40 +#define SCALE_4 (char)0x80 +#define SCALE_8 (char)0xC0 + +//インデックスなし +#define INDEX_NON 0x04 + +void set_mod_rm_sib_disp(char mod,int reg,int scale,int index_reg,int base_reg,int disp){ + if(mod==MOD_DISP32){ + //ModR/Mバイト + OpBuffer[obp++]=(char)( REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(0x04)); + + base_reg=0x05; + index_reg=INDEX_NON; + } + else{ + //ModR/Mバイト + OpBuffer[obp++]=(char)(mod | REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(base_reg)); + } + + + //レジスタモードの場合は、ここで終了 + if(mod==MOD_REG) return; + + + if(REGISTER_OPERAND(base_reg)==0x04||mod==MOD_DISP32){ + ////////////////////// + // SIBバイトを使う + ////////////////////// + + OpBuffer[obp++]=(char)(scale| REGISTER_OPERAND(index_reg)<<3 | REGISTER_OPERAND(base_reg)); + } + + //ディスプレースメントを必要としない場合は、ここで終了 + if(mod==MOD_BASE) return; + + + ////////////////////////// + // ディスプレースメント + ////////////////////////// + + if(mod==MOD_BASE_DISP8) OpBuffer[obp++]=(char)disp; + else{ + *((long *)(OpBuffer+obp))=disp; + obp+=sizeof(long); + } +} + + + +void __op_format(int op_size,char op_prefix,char opcode1,char opcode2,int reg,int base_reg,int offset,char mod){ + //命令プリフィックス + if(op_prefix) OpBuffer[obp++]=op_prefix; + + //rexプリフィックス + set_rex(op_size,reg,0,base_reg); + + //オペコード + OpBuffer[obp++]=opcode1; + if(opcode2) OpBuffer[obp++]=opcode2; + + //ModR/M, SIB, disp + set_mod_rm_sib_disp(mod,reg,SCALE_NON,INDEX_NON,base_reg,offset); +} + + + + +////////////////////////// +// スタック関連 +////////////////////////// + +void op_push(int reg){ + //スタックにレジスタの値をプッシュ + + if(REG_RAX<=reg&®<=REG_RDI){ + /* rax～rdi + 0101 0xxx */ + OpBuffer[obp++]=(char)(0x50| REGISTER_OPERAND(reg) ); + } + if(REG_R8<=reg&®<=REG_R15){ + /* r8～r15 + 0100 0001 0101 0xxx */ + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)(0x50| REGISTER_OPERAND(reg) ); + } +} +void op_push_value(long data){ + //スタックにリテラル値をプッシュ + if(-128<=data&&data<=127){ + //push 8ビット値 + OpBuffer[obp++]=(char)0x6A; + OpBuffer[obp++]=(char)data; + } + else{ + //push 32ビット値 + OpBuffer[obp++]=(char)0x68; + *((long *)(OpBuffer+obp))=data; + obp+=sizeof(long); + } +} +void op_pop(int reg){ + //スタックの内容をレジスタにポップ + if(REG_RAX<=reg&®<=REG_RDI){ + /* rax～rdi + 0101 1xxx */ + OpBuffer[obp++]=(char)(0x58| REGISTER_OPERAND(reg) ); + } + if(REG_R8<=reg&®<=REG_R15){ + /* r8～r15 + 0100 0001 0101 1xxx */ + OpBuffer[obp++]=(char)0x41; + OpBuffer[obp++]=(char)(0x58| REGISTER_OPERAND(reg) ); + } +} + + + +/////////////////// +// mov関連 +/////////////////// + +void op_mov_RV(int op_size,int reg,int i32data){ + //mov reg,i32data + + //rexプリフィックス + set_rex(op_size,REG_NON,REG_NON,reg); + + if(op_size==sizeof(_int64)){ + //オペコード + OpBuffer[obp++]=(char)0xC7; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg) ); + } + else{ + //レジスタ + OpBuffer[obp++]=(char)(0xB8| REGISTER_OPERAND(reg) ); + } + + //即値 + *((long *)(OpBuffer+obp))=i32data; + obp+=sizeof(long); +} +void op_mov_RV64(int reg,_int64 i64data){ + //mov reg,i64data + + //rexプリフィックス + set_rex(sizeof(_int64),REG_NON,REG_NON,reg); + + //レジスタ + OpBuffer[obp++]=(char)(0xB8| REGISTER_OPERAND(reg) ); + + //即値 + *((_int64 *)(OpBuffer+obp))=i64data; + obp+=sizeof(_int64); +} +void op_mov_RM(int op_size,int reg,int base_reg,int offset,char mod){ + //mov reg64,qword ptr[base_reg+offset] + //mov reg32,dword ptr[base_reg+offset] + //mov reg16,word ptr[base_reg+offset] + //mov reg8,byte ptr[base_reg+offset] + + //16ビット演算の命令プリフィックス + char op_prefix=0; + if(op_size==sizeof(short)) op_prefix=(char)0x66; + + //オペコード + char opcode; + if(op_size==sizeof(char)) opcode=(char)0x8A; + else opcode=(char)0x8B; + + __op_format(op_size,op_prefix,opcode,0,reg,base_reg,offset,mod); +} +void op_mov_RM_ex(int op_size,int reg,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){ + //mov reg64,qword ptr[base_reg1+base_reg2+offset] + //mov reg32,dword ptr[base_reg1+base_reg2+offset] + //mov reg16,word ptr[base_reg1+base_reg2+offset] + //mov reg8,byte ptr[base_reg1+base_reg2+offset] + + if(base_reg1==REG_RSP){ + //SIBバイトのindex部にrspは指定できない + base_reg1=base_reg2; + base_reg2=REG_RSP; + } + + //16ビット演算のプリフィックス + if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66; + + //rexプリフィックス + set_rex(op_size,reg,base_reg1,base_reg2); + + //オペコード + if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x8A; + else OpBuffer[obp++]=(char)0x8B; + + if(bUseOffset){ + /////////////////////////// + // オフセット値を使う + /////////////////////////// + + //レジスタ + OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(reg)<<3); + + //ベースレジスタ + OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2)); + + //オフセット値 + *((long *)(OpBuffer+obp))=offset; + obp+=sizeof(long); + } + else{ + /////////////////////////// + // オフセット値を使わない + /////////////////////////// + + //レジスタ + OpBuffer[obp++]=(char)(0x04| REGISTER_OPERAND(reg)<<3); + + //ベースレジスタ + OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2)); + } +} +void op_mov_MR(int op_size,int reg,int base_reg,int offset,char mod){ + //mov qword ptr[base_reg+offset],reg64 + //mov dword ptr[base_reg+offset],reg32 + //mov word ptr[base_reg+offset],reg16 + //mov byte ptr[base_reg+offset],reg8 + + //16ビット演算の命令プリフィックス + char op_prefix=0; + if(op_size==sizeof(short)) op_prefix=(char)0x66; + + //オペコード + char opcode; + if(op_size==sizeof(char)) opcode=(char)0x88; + else opcode=(char)0x89; + + __op_format(op_size,op_prefix,opcode,0,reg,base_reg,offset,mod); +} +void op_mov_MR_ex(int op_size,int reg,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){ + //mov qword ptr[base_reg1+base_reg2+offset],reg64 + //mov dword ptr[base_reg1+base_reg2+offset],reg32 + //mov word ptr[base_reg1+base_reg2+offset],reg16 + //mov byte ptr[base_reg1+base_reg2+offset],reg8 + + if(base_reg1==REG_RSP){ + //SIBバイトのindex部にrspは指定できない + base_reg1=base_reg2; + base_reg2=REG_RSP; + } + + //16ビット演算のプリフィックス + if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66; + + //rexプリフィックス + set_rex(op_size,reg,base_reg1,base_reg2); + + //オペコード + if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x88; + else OpBuffer[obp++]=(char)0x89; + + if(bUseOffset==USE_OFFSET){ + ////////////////////////// + //オフセット値を使う + ////////////////////////// + + //レジスタ + OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(reg)<<3); + + //ベースレジスタ + OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2)); + + //オフセット値 + *((long *)(OpBuffer+obp))=offset; + obp+=sizeof(long); + } + else{ + ////////////////////////// + //オフセット値を使わない + ////////////////////////// + + //レジスタ + OpBuffer[obp++]=(char)(0x04| REGISTER_OPERAND(reg)<<3); + + //ベースレジスタ + OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2)); + } +} + +void op_mov_MV(int op_size,int base_reg,int offset,BOOL bUseOffset,int i32data){ + //mov ptr[base_reg+offset],i32data + //mov ptr[base_reg ],i32data + + //16ビット演算のプリフィックス + if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66; + + //rexプリフィックス + set_rex(op_size,0,0,base_reg); + + //オペコード + if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0xC6; + else OpBuffer[obp++]=(char)0xC7; + + if(bUseOffset==USE_OFFSET){ + ////////////////////////// + //オフセット値を使う + ////////////////////////// + + //ModR/M, SIB, disp + set_mod_rm_sib_disp(MOD_BASE_DISP32,0,SCALE_NON,INDEX_NON,base_reg,offset); + } + else{ + //ModR/M, SIB, disp + set_mod_rm_sib_disp(MOD_BASE,0,SCALE_NON,INDEX_NON,base_reg,0); + } + + //即値 + if(op_size==sizeof(_int64)||op_size==sizeof(long)){ + //32/64ビット + *((long *)(OpBuffer+obp))=i32data; + obp+=sizeof(long); + } + else if(op_size==sizeof(short)){ + //16ビット + *((short *)(OpBuffer+obp))=(short)i32data; + obp+=sizeof(short); + } + else if(op_size==sizeof(char)){ + //16ビット + *((char *)(OpBuffer+obp))=(char)i32data; + obp++; + } +} + +void op_mov_RR(int reg1,int reg2){ + //mov reg1,reg2 + char RexByte=-1; + + if(reg1==reg2) return; + + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x4D; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + // [8bit rex] 1000 1011 11xx xbbb + OpBuffer[obp++]=RexByte; + OpBuffer[obp++]=(char)0x8B; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} + + + +/////////////////// +// mov64関連 +/////////////////// + +void op_mov64_ToReg(int reg,_int64 i64data){ + //mov reg,i64data + + if(REG_RAX<=reg&®<=REG_RDI){ + /* rax～rdi + 0100 1000 1011 1xxx [64bit data] */ + OpBuffer[obp++]=(char)0x48; + OpBuffer[obp++]=(char)(0xB8| REGISTER_OPERAND(reg) ); + *((_int64 *)(OpBuffer+obp))=i64data; + obp+=sizeof(_int64); + } + if(REG_R8<=reg&®<=REG_R15){ + /* r8～r15 + 0100 1001 1011 1xxx [64bit data] */ + OpBuffer[obp++]=(char)0x49; + OpBuffer[obp++]=(char)(0xB8| REGISTER_OPERAND(reg) ); + *((_int64 *)(OpBuffer+obp))=i64data; + obp+=sizeof(_int64); + } +} +void op_mov64_ToReg(int reg,int i32data){ + //mov reg,i32data + + if(REG_RAX<=reg&®<=REG_RDI){ + /* rax～rdi + 0100 1000 1100 0111 1100 0xxx [32bit data] */ + OpBuffer[obp++]=(char)0x48; + OpBuffer[obp++]=(char)0xC7; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg) ); + *((long *)(OpBuffer+obp))=i32data; + obp+=sizeof(long); + } + if(REG_R8<=reg&®<=REG_R15){ + /* r8～r15 + 0100 1001 1100 0111 1100 0xxx [32bit data] */ + OpBuffer[obp++]=(char)0x49; + OpBuffer[obp++]=(char)0xC7; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg) ); + *((long *)(OpBuffer+obp))=i32data; + obp+=sizeof(long); + } +} +void op_movsxd(int reg64,int reg32){ + //movsxd reg64,reg32 + char RexByte=-1; + + if(REG_RAX<=reg64&®64<=REG_RDI){ + if(REG_RAX<=reg32&®32<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg32&®32<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg64&®64<=REG_R15){ + if(REG_RAX<=reg32&®32<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg32&®32<=REG_R15) RexByte=(char)0x4D; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + //[8bit rex] 0110 0011 11rr rbbb + OpBuffer[obp++]=RexByte; + OpBuffer[obp++]=(char)0x63; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg64)<<3 | REGISTER_OPERAND(reg32)); +} +void op_movsx64_FromReg16(int reg64,int reg16){ + //movsx reg64,reg16 + char RexByte=-1; + + if(REG_RAX<=reg64&®64<=REG_RDI){ + if(REG_RAX<=reg16&®16<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg16&®16<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg64&®64<=REG_R15){ + if(REG_RAX<=reg16&®16<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg16&®16<=REG_R15) RexByte=(char)0x4D; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + //[8bit rex] 0000 1111 1011 1111 11rr rbbb + OpBuffer[obp++]=RexByte; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0xBF; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg64)<<3 | REGISTER_OPERAND(reg16)); +} +void op_movsx64_FromReg8(int reg64,int reg8){ + //movsx reg64,reg8 + char RexByte=-1; + + if(REG_RAX<=reg64&®64<=REG_RDI){ + if(REG_RAX<=reg8&®8<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg8&®8<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg64&®64<=REG_R15){ + if(REG_RAX<=reg8&®8<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg8&®8<=REG_R15) RexByte=(char)0x4D; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + //[8bit rex] 0000 1111 1011 1110 11rr rbbb + OpBuffer[obp++]=RexByte; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0xBE; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg64)<<3 | REGISTER_OPERAND(reg8)); +} + + + +////////////////// +// mov32関連 +////////////////// + +void op_movsx32_FromReg16(int reg32,int reg16){ + //movsx reg32,reg16 + char RexByte=-1; + + if(REG_RAX<=reg32&®32<=REG_RDI){ + if(REG_RAX<=reg16&®16<=REG_RDI) RexByte=0; + if(REG_R8<=reg16&®16<=REG_R15) RexByte=(char)0x41; + } + if(REG_R8<=reg32&®32<=REG_R15){ + if(REG_RAX<=reg16&®16<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg16&®16<=REG_R15) RexByte=(char)0x45; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + //[8bit rex] 0000 1111 1011 1111 11rr rbbb + if(RexByte) OpBuffer[obp++]=RexByte; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0xBF; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg32)<<3 | REGISTER_OPERAND(reg16)); +} +void op_movsx32_FromReg8(int reg32,int reg8){ + //movsx reg32,reg8 + char RexByte=-1; + + if(REG_RAX<=reg32&®32<=REG_RDI){ + if(REG_RAX<=reg8&®8<=REG_RBX) RexByte=0; + if(REG_RSP<=reg8&®8<=REG_RDI) RexByte=(char)0x40; + if(REG_R8<=reg8&®8<=REG_R15) RexByte=(char)0x41; + } + if(REG_R8<=reg32&®32<=REG_R15){ + if(REG_RAX<=reg8&®8<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg8&®8<=REG_R15) RexByte=(char)0x45; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + //[8bit rex] 0000 1111 1011 1110 11rr rbbb + if(RexByte) OpBuffer[obp++]=RexByte; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0xBE; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg32)<<3 | REGISTER_OPERAND(reg8)); +} + + + +///////////////////// +// mov16関連 +///////////////////// + +void op_movsx16_FromReg8(int reg32,int reg8){ + //movsx reg16,reg8 + char RexByte=-1; + + if(REG_RAX<=reg32&®32<=REG_RDI){ + if(REG_RAX<=reg8&®8<=REG_RBX) RexByte=0; + if(REG_RSP<=reg8&®8<=REG_RDI) RexByte=(char)0x40; + if(REG_R8<=reg8&®8<=REG_R15) RexByte=(char)0x41; + } + if(REG_R8<=reg32&®32<=REG_R15){ + if(REG_RAX<=reg8&®8<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg8&®8<=REG_R15) RexByte=(char)0x45; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + //0110 0110 [8bit rex] 0000 1111 1011 1110 11rr rbbb + OpBuffer[obp++]=(char)0x66; + if(RexByte) OpBuffer[obp++]=RexByte; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0xBE; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg32)<<3 | REGISTER_OPERAND(reg8)); +} + + + +////////////////////////////////// +// インクリメント・デクリメント +////////////////////////////////// + +void op_inc(int reg){ + //inc reg + + //16ビット演算の命令プリフィックス + char op_prefix=0; + + //オペコード + char opcode=(char)0xFF; + + __op_format(sizeof(_int64),op_prefix,opcode,0,0,reg,0,MOD_REG); +} +void op_dec(int reg){ + op_inc(reg); + OpBuffer[obp-1]=OpBuffer[obp-1]|0x08; +} + + + +///////////////////// +// add関連 +///////////////////// + +void op_add_RM(int op_size,int reg,int base_reg,int offset,char mod){ + //add reg64,qword ptr[base_reg+offset] + //add reg32,dword ptr[base_reg+offset] + //add reg16,word ptr[base_reg+offset] + //add reg8,byte ptr[base_reg+offset] + + //16ビット演算の命令プリフィックス + char op_prefix=0; + if(op_size==sizeof(short)) op_prefix=(char)0x66; + + //オペコード + char opcode; + if(op_size==sizeof(char)) opcode=(char)0x02; + else opcode=(char)0x03; + + __op_format(op_size,op_prefix,opcode,0,reg,base_reg,offset,mod); +} + +void op_add_RV(int reg,int offset){ + //add reg,offset + char RexByte=-1; + + if(REG_RAX<=reg&®<=REG_RDI) RexByte=0x48; + if(REG_R8<=reg&®<=REG_R15) RexByte=0x49; + + if(RexByte==-1) SetError(300,NULL,cp); + + if(reg==REG_RAX){ + //raxのみ特殊 + + // [8bit rex] 0000 0101 [32bit offset] + OpBuffer[obp++]=(char)RexByte; + OpBuffer[obp++]=(char)0x05; + *((long *)(OpBuffer+obp))=offset; + obp+=sizeof(long); + } + else{ + //rax以外 + + //[8bit rex] 1000 0001 1100 0xxx [32bit offset] + OpBuffer[obp++]=(char)RexByte; + OpBuffer[obp++]=(char)0x81; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)); + *((long *)(OpBuffer+obp))=offset; + obp+=sizeof(long); + } +} +void op_add64_reg(int reg1,int reg2){ + //add reg1,reg2 + char RexByte=-1; + + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x4D; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + //[8bit rex] 0000 0011 11rr rbbb + OpBuffer[obp++]=(char)RexByte; + OpBuffer[obp++]=(char)0x03; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} +void op_add32_reg(int reg1,int reg2){ + //add reg1,reg2 + char RexByte=-1; + + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=0; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x41; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x45; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + //[8bit rex] 0000 0011 11rr rbbb + if(RexByte) OpBuffer[obp++]=(char)RexByte; + OpBuffer[obp++]=(char)0x03; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} + + + +//////////////////////// +// sub関連 +//////////////////////// + +void op_sub_RV(int op_size,int reg,int i32data){ + //sub reg,i32data + + //rexプリフィックス + set_rex(op_size,REG_NON,REG_NON,reg); + + if(reg==REG_RAX){ + //raxのみ特殊 + OpBuffer[obp++]=(char)0x2D; + } + else{ + //オペコード + OpBuffer[obp++]=(char)0x81; + + //レジスタ + OpBuffer[obp++]=(char)(0xE8| REGISTER_OPERAND(reg) ); + } + + //即値 + *((long *)(OpBuffer+obp))=i32data; + obp+=sizeof(long); +} +void op_sub64_reg(int reg1,int reg2){ + //sub reg1,reg2 + char RexByte=-1; + + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x4D; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + //[8bit rex] 0010 1011 11rr rbbb + OpBuffer[obp++]=(char)RexByte; + OpBuffer[obp++]=(char)0x2B; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} +void op_sub32_reg(int reg1,int reg2){ + //sub reg1,reg2 + char RexByte=-1; + + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=0; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x41; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x45; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + //[8bit rex] 0010 1011 11rr rbbb + if(RexByte) OpBuffer[obp++]=(char)RexByte; + OpBuffer[obp++]=(char)0x2B; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} +void op_sbb_RR( int op_size, int reg1, int reg2 ){ + //sbb reg1,reg2 + + //rexプリフィックス + set_rex(0,reg1,0,reg2); + + //オペコード + OpBuffer[obp++]=(char)0x1B; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} + + + +//////////////////////// +// imul関連 +//////////////////////// + +void op_imul_RR(int op_size,int reg1,int reg2){ + //imul reg1,reg2 + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x4D; + } + } + else{ + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=0; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x41; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x45; + } + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + //オペコード + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0xAF; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} +void op_imul_RV(int op_size,int reg,int i32data){ + //imul reg,i32data + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x4D; + } + else{ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=0; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x45; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + if(-128<=i32data&&i32data<=127){ + //オペコード + OpBuffer[obp++]=(char)0x6B; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg)); + + //値 + OpBuffer[obp++]=(char)i32data; + } + else{ + //オペコード + OpBuffer[obp++]=(char)0x69; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg)); + + //値 + *((long *)(OpBuffer+obp))=i32data; + obp+=sizeof(long); + } +} + + + +//////////////////////// +// div、idiv関連 +//////////////////////// + +void op_div64_reg(int reg){ + //div reg + char RexByte=-1; + + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x49; + + if(RexByte==-1) SetError(300,NULL,cp); + + //rexプリフィックス + OpBuffer[obp++]=(char)RexByte; + + //オペコード + OpBuffer[obp++]=(char)0xF7; + + //レジスタ + OpBuffer[obp++]=(char)(0xF0| REGISTER_OPERAND(reg)); +} +void op_idiv64_reg(int reg){ + //idiv reg + char RexByte=-1; + + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x49; + + if(RexByte==-1) SetError(300,NULL,cp); + + //rexプリフィックス + OpBuffer[obp++]=(char)RexByte; + + //オペコード + OpBuffer[obp++]=(char)0xF7; + + //レジスタ + OpBuffer[obp++]=(char)(0xF8| REGISTER_OPERAND(reg)); +} + + + +//////////////////// +// ビットシフト関連 +//////////////////// + +void op_shl_reg(int op_size,int reg){ + //shl reg,cl + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x49; + } + else if(op_size==sizeof(char)){ + if(REG_RAX<=reg&®<=REG_RBX) RexByte=0; + if(REG_RSP<=reg&®<=REG_RDI) RexByte=(char)0x40; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x41; + } + else{ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=0; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x41; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //16ビット演算のプリフィックス + if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66; + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + //オペコード + if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0xD2; + else OpBuffer[obp++]=(char)0xD3; + + //レジスタ + OpBuffer[obp++]=(char)(0xE0| REGISTER_OPERAND(reg)); +} +void op_sar_reg(int op_size,int reg){ + //sar reg,cl + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x49; + } + else if(op_size==sizeof(char)){ + if(REG_RAX<=reg&®<=REG_RBX) RexByte=0; + if(REG_RSP<=reg&®<=REG_RDI) RexByte=(char)0x40; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x41; + } + else{ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=0; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x41; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //16ビット演算のプリフィックス + if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66; + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + //オペコード + if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0xD2; + else OpBuffer[obp++]=(char)0xD3; + + //レジスタ + OpBuffer[obp++]=(char)(0xF8| REGISTER_OPERAND(reg)); +} +void op_shr_reg(int op_size,int reg){ + //shr reg,cl + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x49; + } + else if(op_size==sizeof(char)){ + if(REG_RAX<=reg&®<=REG_RBX) RexByte=0; + if(REG_RSP<=reg&®<=REG_RDI) RexByte=(char)0x40; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x41; + } + else{ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=0; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x41; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //16ビット演算のプリフィックス + if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66; + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + //オペコード + if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0xD2; + else OpBuffer[obp++]=(char)0xD3; + + //レジスタ + OpBuffer[obp++]=(char)(0xE8| REGISTER_OPERAND(reg)); +} + + + +//////////////////// +// and 関連 +//////////////////// + +void op_and_reg(int op_size,int reg1,int reg2){ + //and reg1,reg2 + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x4D; + } + } + else{ + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=0; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x41; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x45; + } + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + //オペコード + OpBuffer[obp++]=(char)0x23; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} +void op_and64_value(int reg,int offset){ + //and reg,offset + char RexByte=-1; + + if(REG_RAX<=reg&®<=REG_RDI) (char)RexByte=0x48; + if(REG_R8<=reg&®<=REG_R15) (char)RexByte=0x49; + + if(RexByte==-1) SetError(300,NULL,cp); + + if(reg==REG_RAX){ + //raxのみ特殊 + + // [8bit rex] 0010 0101 [32bit offset] + OpBuffer[obp++]=(char)RexByte; + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=offset; + obp+=sizeof(long); + } + else{ + //rax以外 + + //[8bit rex] 1000 0001 1100 0xxx [32bit offset] + OpBuffer[obp++]=(char)RexByte; + OpBuffer[obp++]=(char)0x81; + OpBuffer[obp++]=(char)(0xE0| REGISTER_OPERAND(reg)); + *((long *)(OpBuffer+obp))=offset; + obp+=sizeof(long); + } +} +void op_and32_value(int reg,int offset){ + //and reg,offset + char RexByte=-1; + + if(REG_RAX<=reg&®<=REG_RDI) RexByte=0; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x41; + + if(RexByte==-1) SetError(300,NULL,cp); + + if(reg==REG_RAX){ + //eaxのみ特殊 + + // [8bit rex] 0010 0101 [32bit offset] + OpBuffer[obp++]=(char)0x25; + *((long *)(OpBuffer+obp))=offset; + obp+=sizeof(long); + } + else{ + //eax以外 + + //[8bit rex] 1000 0001 1100 0xxx [32bit offset] + if(RexByte) OpBuffer[obp++]=(char)RexByte; + OpBuffer[obp++]=(char)0x81; + OpBuffer[obp++]=(char)(0xE0| REGISTER_OPERAND(reg)); + *((long *)(OpBuffer+obp))=offset; + obp+=sizeof(long); + } +} + + + +//////////////////////// +// or 関連 +//////////////////////// + +void op_or_reg(int op_size,int reg1,int reg2){ + //or reg1,reg2 + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x4D; + } + } + else{ + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=0; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x41; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x45; + } + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + //オペコード + OpBuffer[obp++]=(char)0x0B; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} + + + +//////////////////////// +// xor 関連 +//////////////////////// + +void op_xor_reg(int op_size,int reg1,int reg2){ + //xor reg1,reg2 + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x4D; + } + } + else{ + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=0; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x41; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x45; + } + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + //オペコード + OpBuffer[obp++]=(char)0x33; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} + + + +/////////////////////// +// not 関連 +/////////////////////// + +void op_not_reg(int op_size,int reg){ + //not reg + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x49; + } + else{ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=0; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x41; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + //オペコード + OpBuffer[obp++]=(char)0xF7; + + //レジスタ + OpBuffer[obp++]=(char)(0xD0| REGISTER_OPERAND(reg)); +} +void op_neg( int reg ){ + //neg reg + + //オペコード + OpBuffer[obp++]=(char)0xF7; + + //レジスタ + OpBuffer[obp++]=(char)(0xD8| REGISTER_OPERAND(reg)); +} + + + +//////////////////// +// test関連 +//////////////////// + +void op_test(int reg1,int reg2){ + //test reg1,reg2 + char RexByte=-1; + + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x4D; + } + + if(RexByte==-1) SetError(300,NULL,cp); + + //[8bit rex] 1000 0101 11rr rbbb + OpBuffer[obp++]=(char)RexByte; + OpBuffer[obp++]=(char)0x85; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} + + + +///////////////////// +// cmp 関連 +///////////////////// + +void op_cmp_reg(int op_size,int reg1,int reg2){ + //cmp reg1,reg2 + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x4D; + } + } + else{ + if(REG_RAX<=reg1&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=0; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x41; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x45; + } + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + //オペコード + OpBuffer[obp++]=(char)0x3B; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2)); +} +void op_cmp_value(int op_size,int reg,char byte_data){ + //cmp reg,byte_data + + if(op_size==sizeof(char)&®==REG_RAX){ + //alレジスタの場合は特殊 + OpBuffer[obp++]=(char)0x3C; + + //8ビット値 + OpBuffer[obp++]=byte_data; + + return; + } + + //16ビット演算のプリフィックス + if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66; + + //rexプリフィックス + set_rex(op_size,REG_NON,REG_NON,reg); + + //オペコード + if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x80; + else OpBuffer[obp++]=(char)0x83; + + //レジスタ + OpBuffer[obp++]=(char)(0xF8| REGISTER_OPERAND(reg)); + + //8ビット値 + OpBuffer[obp++]=byte_data; +} +void op_setne( int reg ){ + //オペコード + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x95; + + //レジスタ + OpBuffer[obp++]=(char)( 0xC0 | REGISTER_OPERAND(reg) ); +} + + +//////////////////// +// SSE2関連 +//////////////////// + +void op_movlpd_MR(int xmm_reg,int base_reg,int offset,char mod){ + //movlpd qword ptr[base_reg+offset],xmm_reg + __op_format(0,(char)0x66,(char)0x0F,(char)0x13,xmm_reg,base_reg,offset,mod); +} +void op_movlpd_RM(int xmm_reg,int base_reg,int offset,char mod){ + //movlpd xmm_reg,qword ptr[base_reg+offset] + __op_format(0,(char)0x66,(char)0x0F,(char)0x12,xmm_reg,base_reg,offset,mod); +} +void op_movsd_RR(int xmm_reg1,int xmm_reg2){ + if(xmm_reg1==xmm_reg2) return; + + //movsd xmm_reg1,xmm_reg2 + __op_format(0,(char)0xF2,(char)0x0F,(char)0x10,xmm_reg1,xmm_reg2,0,MOD_REG); +} +void op_movsd_MR(int xmm_reg,int base_reg,int offset,char mod){ + //movsd qword ptr[reg+offset],xmm_reg + //movsd qword ptr[reg],xmm_reg + __op_format(0,(char)0xF2,(char)0x0F,(char)0x11,xmm_reg,base_reg,offset,mod); +} +void op_movss_RR(int xmm_reg1,int xmm_reg2){ + if(xmm_reg1==xmm_reg2) return; + + //movss xmm_reg1,xmm_reg2 + __op_format(0,(char)0xF3,(char)0x0F,(char)0x10,xmm_reg1,xmm_reg2,0,MOD_REG); +} +void op_movss_RM(int xmm_reg,int base_reg,int offset,char mod){ + //movss xmm_reg,dword ptr[base_reg+offset] + __op_format(0,(char)0xF3,(char)0x0F,(char)0x10,xmm_reg,base_reg,offset,mod); +} +void op_movss_MR(int xmm_reg,int base_reg,int offset,char mod){ + //movss dword ptr[reg+offset],xmm_reg + //movss dword ptr[reg],xmm_reg + __op_format(0,(char)0xF3,(char)0x0F,(char)0x11,xmm_reg,base_reg,offset,mod); +} + +void op_movd_RX(int reg,int xmm_reg){ + __op_format(sizeof(_int64),(char)0x66,(char)0x0F,(char)0x7E,xmm_reg,reg,0,MOD_REG); +} + +void op_cvtsd2ss(int xmm_reg1,int xmm_reg2){ + //cvtsd2ss xmm_reg1,xmm_reg2 + + //オペコード + OpBuffer[obp++]=(char)0xF2; + + //rexプリフィックス + set_rex(sizeof(long),xmm_reg1,0,xmm_reg2); + + //オペコード + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x5A; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2)); +} +void op_cvtss2sd(int xmm_reg1,int xmm_reg2){ + //cvtss2sd xmm_reg1,xmm_reg2 + + //オペコード + OpBuffer[obp++]=(char)0xF3; + + //rexプリフィックス + set_rex(0,xmm_reg1,0,xmm_reg2); + + //オペコード + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x5A; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2)); +} +void op_cvttsd2si_xmm(int op_size,int reg,int xmm_reg){ + //cvttsd2si reg,xmm_reg + + //オペコード + OpBuffer[obp++]=(char)0xF2; + + //rexプリフィックス + set_rex(op_size,reg,0,xmm_reg); + + //オペコード + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x2C; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(xmm_reg)); +} +void op_cvttss2si_xmm(int op_size,int reg,int xmm_reg){ + //cvttss2si reg,xmm_reg + + //オペコード + OpBuffer[obp++]=(char)0xF3; + + //rexプリフィックス + set_rex(op_size,reg,0,xmm_reg); + + //オペコード + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x2C; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(xmm_reg)); +} +void op_cvtsi2sd_reg(int op_size,int xmm_reg,int reg){ + //cvtsi2sd xmm_reg,reg + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_XMM0<=xmm_reg&&xmm_reg<=REG_XMM7){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x49; + } + if(REG_XMM8<=xmm_reg&&xmm_reg<=REG_XMM15){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x4D; + } + } + else{ + if(REG_XMM0<=xmm_reg&&xmm_reg<=REG_XMM7){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=0; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x41; + } + if(REG_XMM8<=xmm_reg&&xmm_reg<=REG_XMM15){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x45; + } + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //オペコード + OpBuffer[obp++]=(char)0xF2; + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + //オペコード + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x2A; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(xmm_reg)<<3 | REGISTER_OPERAND(reg)); +} +void op_cvtsi2ss_reg(int op_size,int xmm_reg,int reg){ + //cvtsi2ss xmm_reg,reg + char RexByte=-1; + + if(op_size==sizeof(_int64)){ + if(REG_XMM0<=xmm_reg&&xmm_reg<=REG_XMM7){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x49; + } + if(REG_XMM8<=xmm_reg&&xmm_reg<=REG_XMM15){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x4D; + } + } + else{ + if(REG_XMM0<=xmm_reg&&xmm_reg<=REG_XMM7){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=0; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x41; + } + if(REG_XMM8<=xmm_reg&&xmm_reg<=REG_XMM15){ + if(REG_RAX<=reg&®<=REG_RDI) RexByte=(char)0x44; + if(REG_R8<=reg&®<=REG_R15) RexByte=(char)0x45; + } + } + + if(RexByte==-1) SetError(300,NULL,cp); + + + //オペコード + OpBuffer[obp++]=(char)0xF3; + + //rexプリフィックス + if(RexByte) OpBuffer[obp++]=(char)RexByte; + + //オペコード + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x2A; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(xmm_reg)<<3 | REGISTER_OPERAND(reg)); +} +void op_comisd(int xmm_reg1,int xmm_reg2){ + //comisd xmm_reg1,xmm_reg2 + + //オペコード + OpBuffer[obp++]=(char)0x66; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x2F; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2)); +} +void op_comiss(int xmm_reg1,int xmm_reg2){ + //comiss xmm_reg1,xmm_reg2 + + //オペコード + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x2F; + + //レジスタ + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(xmm_reg1)<<3 | REGISTER_OPERAND(xmm_reg2)); +} + + + +///////////////////// +// ストリング関係 +///////////////////// + +void op_rep_movs(int op_size){ + if(op_size==sizeof(BYTE)){ + //rep movs byte ptr[edi],byte ptr[esi] + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0xA4; + } + else if(op_size==sizeof(short)){ + //rep movs word ptr[edi],word ptr[esi] + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x66; + OpBuffer[obp++]=(char)0xA5; + } + else if(op_size==sizeof(long)){ + //rep movs dword ptr[edi],dword ptr[esi] + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0xA5; + } +} + + + + +void op_add_rsp(int num){ + //スタックポインタの加算（pop方向） + + //add rsp,num + if(0xFFFFFF80&num){ + OpBuffer[obp++]=(char)0x48; + OpBuffer[obp++]=(char)0x81; + OpBuffer[obp++]=(char)0xC4; + *((long *)(OpBuffer+obp))=num; + obp+=sizeof(long); + } + else{ + //「-128 < num < 127」の場合 + OpBuffer[obp++]=(char)0x48; + OpBuffer[obp++]=(char)0x83; + OpBuffer[obp++]=(char)0xC4; + OpBuffer[obp++]=(char)num; + } +} +void op_sub_rsp(int num){ + //スタックポインタの減算（push方向） + + //sub rsp,num + if(0xFFFFFF80&num){ + OpBuffer[obp++]=(char)0x48; + OpBuffer[obp++]=(char)0x81; + OpBuffer[obp++]=(char)0xEC; + *((long *)(OpBuffer+obp))=num; + obp+=sizeof(long); + } + else{ + //「-128 < num < 127」の場合 + OpBuffer[obp++]=(char)0x48; + OpBuffer[obp++]=(char)0x83; + OpBuffer[obp++]=(char)0xEC; + OpBuffer[obp++]=(char)num; + } +} + + +void op_add_esp(int num){ + //スタックポインタの加算（pop方向） + + //add esp,num + if(0xFFFFFF80&num){ + OpBuffer[obp++]=(char)0x81; + OpBuffer[obp++]=(char)0xC4; + *((long *)(OpBuffer+obp))=num; + obp+=sizeof(long); + } + else{ + //「-128 < num < 127」の場合 + OpBuffer[obp++]=(char)0x83; + OpBuffer[obp++]=(char)0xC4; + OpBuffer[obp++]=(char)num; + } +} +void op_sub_esp(int num){ + //スタックポインタの減算（push方向） + + //sub esp,num + if(0xFFFFFF80&num){ + OpBuffer[obp++]=(char)0x81; + OpBuffer[obp++]=(char)0xEC; + *((long *)(OpBuffer+obp))=num; + obp+=sizeof(long); + } + else{ + //「-128 < num < 127」の場合 + OpBuffer[obp++]=(char)0x83; + OpBuffer[obp++]=(char)0xEC; + OpBuffer[obp++]=(char)num; + } +} + + + +////////////////////////////// +// 浮動小数点関連 +////////////////////////////// + +void op_fld_ptr_esp(int type){ + //スタックポインタが示すバッファのデータを浮動小数点レジスタへロード + + if(type==DEF_DOUBLE){ + //fld qword ptr[esp] + OpBuffer[obp++]=(char)0xDD; + OpBuffer[obp++]=(char)0x04; + OpBuffer[obp++]=(char)0x24; + } + else if(type==DEF_SINGLE){ + //fld dword ptr[esp] + OpBuffer[obp++]=(char)0xD9; + OpBuffer[obp++]=(char)0x04; + OpBuffer[obp++]=(char)0x24; + } + else if(type==DEF_INT64){ + //fild qword ptr[esp] + OpBuffer[obp++]=(char)0xDF; + OpBuffer[obp++]=(char)0x2C; + OpBuffer[obp++]=(char)0x24; + } + else if(type==DEF_LONG){ + //fild dword ptr[esp] + OpBuffer[obp++]=(char)0xDB; + OpBuffer[obp++]=(char)0x04; + OpBuffer[obp++]=(char)0x24; + } +} + + + +////////////////////////////// +// レジスタ関連 +////////////////////////////// + +void op_zero_reg(int reg){ + //レジスタに0をセット + + if(REG_RAX<=reg&®<=REG_RDI){ + /* rax～rdi + 0100 1000 0011 0011 11 xxx xxx */ + OpBuffer[obp++]=(char)0x48; + OpBuffer[obp++]=(char)0x33; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg)); + } + if(REG_R8<=reg&®<=REG_R15){ + /* r8～r15 + 0100 1101 0011 0011 11 xxx xxx */ + OpBuffer[obp++]=(char)0x4D; + OpBuffer[obp++]=(char)0x33; + OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg)); + } +} + + + +///////////////////////////// +// 関数呼び出し +///////////////////////////// + +void op_call( UserProc *pUserProc ){ + OpBuffer[obp++] = (char)0xE8; + pobj_SubAddrSchedule->add( pUserProc, 1 ); + pUserProc->Using(); + obp += sizeof(long); +} +void op_call( DllProc *pDllProc ){ + OpBuffer[obp++] = (char)0xFF; + OpBuffer[obp++] = (char)0x15; + pobj_ImportAddrSchedule->add(pDllProc); + obp += sizeof(long); + + pDllProc->Using(); +} +void op_ret(){ + OpBuffer[obp++]=(char)0xC3; +} Index: trunk/abdev/BasicCompiler64/increment.cpp =================================================================== --- trunk/abdev/BasicCompiler64/increment.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/increment.cpp (revision 149) @@ -0,0 +1,158 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + +void IncDec(int idCalc, const char *lpszLeft, const char *lpszRight){ + + /////////////////////////// + // 変数アドレスを取得 + /////////////////////////// + + RELATIVE_VAR VarRelativeVar; + Type varType; + if(!GetVarOffsetReadWrite( + lpszLeft, + &VarRelativeVar, + varType)) return; + + //変数オフセットを一時退避 + if(IsUse_r11(&VarRelativeVar)){ + //mov qword ptr[rsp+offset],r11 ※スタックフレームを利用 + pobj_sf->push(REG_R11); + } + + + /////////////////////////////////// + // レジスタへ変数の内容をコピー + /////////////////////////////////// + + int reg; + if( varType.IsDouble() ){ + reg=REG_XMM0; + SetXmmReg_DoubleVariable(&VarRelativeVar,reg); + } + else if( varType.IsSingle() ){ + reg=REG_XMM0; + SetXmmReg_SingleVariable(&VarRelativeVar,reg); + } + else{ + reg=REG_RAX; + SetReg_WholeVariable(varType.GetBasicType(),&VarRelativeVar,reg); + } + + + if(varType.IsWhole()&&lstrcmp(lpszRight,"1")==0&& + (idCalc==CALC_ADDITION||idCalc==CALC_SUBTRACTION)){ + if(idCalc==CALC_ADDITION){ + //インクリメント + op_inc(REG_RAX); + } + else if(idCalc==CALC_SUBTRACTION){ + //デクリメント + op_dec(REG_RAX); + } + } + else{ + //結果を格納しているレジスタをブロッキング + pobj_BlockReg->lock(reg); + + //右辺を計算 + Type calcType; + if(reg==REG_RAX) reg=REG_RCX; + else reg=REG_RAX; + NumOpe(®,lpszRight,varType,calcType); + + //レジスタのブロッキングを解除 + pobj_BlockReg->clear(); + + + if(varType.IsPointer()&&calcType.IsWhole()&&(!calcType.IsPointer())){ + //左辺がポインタ型、右辺が整数型の場合は、エラーをださないようにする + calcType = varType; + } + + + ///////////////////////////////// + // 右辺、左辺の型チェックを行う + ///////////////////////////////// + + CheckDifferentType(varType,calcType,0,0); + + + //レジスタ管理オブジェクトを生成 + pobj_reg=new CRegister(REG_RAX); + + //左辺用レジスタ + if(varType.IsReal()) + pobj_reg->LockXmmReg(); + else + pobj_reg->LockReg(); + + //右辺値レジスタ + if(varType.IsDouble()) + ChangeTypeToXmm_Double(calcType.GetBasicType(), + pobj_reg->LockXmmReg(), + pobj_reg->GetNextReg()); + else if(varType.IsSingle()) + ChangeTypeToXmm_Single(calcType.GetBasicType(), + pobj_reg->LockXmmReg(), + pobj_reg->GetNextReg()); + else + ChangeTypeToWhole(calcType.GetBasicType(),varType.GetBasicType(), + pobj_reg->LockReg(), + pobj_reg->GetNextXmmReg()); + + int type_stack[255],sp; + LONG_PTR index_stack[255]; + type_stack[0]=varType.GetBasicType(); + type_stack[1]=varType.GetBasicType(); + index_stack[0]=varType.GetIndex(); + index_stack[1]=varType.GetIndex(); + sp=2; + + switch(idCalc){ + case CALC_XOR: + case CALC_OR: + case CALC_AND: + CalcTwoTerm_Logical(idCalc,type_stack,index_stack,&sp); + break; + case CALC_SHL: + case CALC_SHR: + Calc_Shift(idCalc,type_stack,&sp); + break; + case CALC_ADDITION: + case CALC_SUBTRACTION: + case CALC_PRODUCT: + CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp); + break; + case CALC_MOD: + Calc_Mod(type_stack,index_stack,&sp); + break; + case CALC_QUOTIENT: + Calc_Divide(type_stack,&sp,varType.GetBasicType()); + break; + case CALC_INTQUOTIENT: + Calc_IntDivide(type_stack,index_stack,&sp); + break; + case CALC_POWER: + Calc_Power(type_stack,&sp); + break; + } + + //レジスタ管理オブジェクトを解放 + delete pobj_reg; + pobj_reg=0; + } + + + ///////////////////////////////////////////////// + // rax（実数はxmm0）の内容を変数にコピー + ///////////////////////////////////////////////// + + //変数オフセットを復元 + if(IsUse_r11(&VarRelativeVar)){ + //mov r11,qword ptr[rsp+offset] ※スタックフレームを利用 + pobj_sf->pop(REG_R11); + } + + SetVariableFromRax(varType.GetBasicType(),varType.GetBasicType(),&VarRelativeVar); +} Index: trunk/abdev/BasicCompiler64/manifest.xml =================================================================== --- trunk/abdev/BasicCompiler64/manifest.xml (revision 149) +++ trunk/abdev/BasicCompiler64/manifest.xml (revision 149) @@ -0,0 +1,22 @@ + + + +Description + + + + + + Index: trunk/abdev/BasicCompiler64/resource.h =================================================================== --- trunk/abdev/BasicCompiler64/resource.h (revision 149) +++ trunk/abdev/BasicCompiler64/resource.h (revision 149) @@ -0,0 +1,56 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by BasicCompiler.rc +// +#define IDD_MAIN 101 +#define IDD_VARLIST 103 +#define IDI_MAIN 108 +#define IDI_VARSTRUCT 109 +#define IDI_VARDATA 110 +#define IDI_VARSTR 111 +#define IDI_VARARRAY 112 +#define IDI_VARPTRSTRUCT 113 +#define IDD_CLIPMAIN 114 +#define IDD_DEBUGGER 115 +#define IDR_DEBUGGERTOOLBAR 117 +#define IDD_DEBUGGER_TOOLBARBASE 120 +#define IDR_DEBUGGER_VARLIST_MENU 122 +#define IDR_DEBUGGERTOOLBAR_DISABLED 125 +#define IDC_EXEPATH 1000 +#define IDC_PROGRESS 1001 +#define IDC_ERRORLIST 1002 +#define IDC_MESSAGE 1003 +#define IDC_DEBUGLIST 1005 +#define IDC_SHOWERROR 1006 +#define IDC_SHOWDEBUG 1007 +#define IDC_THREADCOMBO 1014 +#define IDC_VARTREE 1015 +#define IDC_GLOBAL 1016 +#define IDC_LOCAL 1017 +#define IDC_PROCCOMBO 1018 +#define IDC_HIDESYSVAR 1019 +#define IDC_STEPIN 1021 +#define IDC_STEPOVER 1022 +#define IDC_ESP 1023 +#define IDC_DUMMYCANCEL 1024 +#define IDC_TAB1 1025 +#define IDC_VARPOS 1029 +#define IDC_WATCHLIST 1033 +#define IDC_STATIC_VERSION 1034 +#define IDC_DEBUG_START 40003 +#define IDC_DEBUG_STEPOVER 40004 +#define IDC_DEBUG_STEPIN 40005 +#define IDM_SHOW_DEFAULTSYSTEM_VAR 40007 +#define IDM_SHOW_RAD_VAR 40008 +#define IDM_SHOW_GUID_VAR 40009 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 126 +#define _APS_NEXT_COMMAND_VALUE 40010 +#define _APS_NEXT_CONTROL_VALUE 1035 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif Index: trunk/abdev/BasicCompiler64/resource_back.h =================================================================== --- trunk/abdev/BasicCompiler64/resource_back.h (revision 149) +++ trunk/abdev/BasicCompiler64/resource_back.h (revision 149) @@ -0,0 +1,55 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by BasicCompiler.rc +// +#define IDD_MAIN 101 +#define IDD_VARLIST 103 +#define IDI_MAIN 108 +#define IDI_VARSTRUCT 109 +#define IDI_VARDATA 110 +#define IDI_VARSTR 111 +#define IDI_VARARRAY 112 +#define IDI_VARPTRSTRUCT 113 +#define IDD_CLIPMAIN 114 +#define IDD_DEBUGGER 115 +#define IDR_DEBUGGERTOOLBAR 117 +#define IDD_DEBUGGER_TOOLBARBASE 120 +#define IDR_DEBUGGER_VARLIST_MENU 122 +#define IDC_EXEPATH 1000 +#define IDC_PROGRESS 1001 +#define IDC_ERRORLIST 1002 +#define IDC_MESSAGE 1003 +#define IDC_DEBUGLIST 1005 +#define IDC_SHOWERROR 1006 +#define IDC_SHOWDEBUG 1007 +#define IDC_THREADCOMBO 1014 +#define IDC_VARTREE 1015 +#define IDC_GLOBAL 1016 +#define IDC_LOCAL 1017 +#define IDC_PROCCOMBO 1018 +#define IDC_HIDESYSVAR 1019 +#define IDC_STEPIN 1021 +#define IDC_STEPOVER 1022 +#define IDC_ESP 1023 +#define IDC_DUMMYCANCEL 1024 +#define IDC_TAB1 1025 +#define IDC_VARPOS 1029 +#define IDC_WATCHLIST 1033 +#define IDC_STATIC_VERSION 1034 +#define IDC_DEBUG_START 40003 +#define IDC_DEBUG_STEPOVER 40004 +#define IDC_DEBUG_STEPIN 40005 +#define IDM_SHOW_DEFAULTSYSTEM_VAR 40007 +#define IDM_SHOW_RAD_VAR 40008 +#define IDM_SHOW_GUID_VAR 40009 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 125 +#define _APS_NEXT_COMMAND_VALUE 40010 +#define _APS_NEXT_CONTROL_VALUE 1035 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif Index: trunk/abdev/BasicCompiler64/stack_frame.cpp =================================================================== --- trunk/abdev/BasicCompiler64/stack_frame.cpp (revision 149) +++ trunk/abdev/BasicCompiler64/stack_frame.cpp (revision 149) @@ -0,0 +1,158 @@ +#include "../BasicCompiler_Common/common.h" +#include "Opcode.h" + + +///////////////////////// +// スタックフレーム管理 +///////////////////////// + +CStackFrame::CStackFrame(){ + lowest_sp=0; + now_sp=0; + local_parm_size=0; + max_parm_size=0; +} +CStackFrame::~CStackFrame(){ + //オブジェクト破棄時に不整合がないかをチェック（バグ回避） + error_check(); +} +void CStackFrame::SetLocalParmSize(int size){ + local_parm_size=size; +} +int CStackFrame::GetFrameSize(){ + int answer_sp; + + answer_sp=lowest_sp-max_parm_size; + + if((local_parm_size%0x10)==0){ + if((answer_sp%0x10)==0){ + //関数のエントリポイントで128ビット境界ラインに合わせるため + return -(answer_sp-0x08); + } + return -(answer_sp-0x10); + } + + if((answer_sp%0x10)==0){ + //関数のエントリポイントで128ビット境界ラインに合わせるため + return -(answer_sp-0x10); + } + return -(answer_sp-0x08); +} +int CStackFrame::GetNowSp(){ + return now_sp; +} +void CStackFrame::mov_sp( int reg ){ + //mov reg,rsp + op_mov_RR( reg, REG_RSP ); + + //add reg,now_sp + op_add_RV( reg, now_sp ); + + //スケジュールをセット + obp-=sizeof(long); + add(); + obp+=sizeof(long); +} +int CStackFrame::push(int reg){ + now_sp-=sizeof(_int64); + if(lowest_sp>now_sp) lowest_sp=now_sp; + + if(reg==REG_NON) return now_sp; + + //mov qword ptr[rsp+offset],reg + op_mov_MR(sizeof(_int64),reg,REG_RSP,now_sp,MOD_BASE_DISP32); + + //スケジュールをセット + obp-=sizeof(long); + add(); + obp+=sizeof(long); + + return now_sp; +} +void CStackFrame::push(int xmm_reg,int varSize){ + now_sp-=sizeof(_int64); + if(lowest_sp>now_sp) lowest_sp=now_sp; + + if(varSize==sizeof(double)){ + //movlpd qword ptr[rsp+offset],xmm_reg + op_movlpd_MR(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32); + } + if(varSize==sizeof(float)){ + //movss dword ptr[rsp+offset],xmm_reg + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x11; + OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(xmm_reg)<<3 ); + OpBuffer[obp++]=(char)0x24; + *((long *)(OpBuffer+obp))=now_sp; + obp+=sizeof(long); + } + + //スケジュールをセット + obp-=sizeof(long); + add(); + obp+=sizeof(long); +} +void CStackFrame::ref_offset_data( int reg, int sp_offset ){ + //mov reg,qword ptr[rsp+offset] ※スタックフレームを利用 + op_mov_RM(sizeof(_int64),reg,REG_RSP,sp_offset,MOD_BASE_DISP32); + + //スケジュールをセット + obp-=sizeof(long); + add(); + obp+=sizeof(long); +} +void CStackFrame::ref(int reg){ + ref_offset_data( reg, now_sp ); +} +void CStackFrame::ref(int xmm_reg,int varSize){ + if(varSize==sizeof(double)){ + //movlpd xmm_reg,qword ptr[rsp+offset] + op_movlpd_RM(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32); + } + if(varSize==sizeof(float)){ + //movss xmm_reg,dword ptr[rsp+offset] + OpBuffer[obp++]=(char)0xF3; + OpBuffer[obp++]=(char)0x0F; + OpBuffer[obp++]=(char)0x10; + OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(xmm_reg)<<3 ); + OpBuffer[obp++]=(char)0x24; + *((long *)(OpBuffer+obp))=now_sp; + obp+=sizeof(long); + } + + //スケジュールをセット + obp-=sizeof(long); + add(); + obp+=sizeof(long); +} +void CStackFrame::pop(int reg){ + if(reg!=REG_NON) ref(reg); + + now_sp+=sizeof(_int64); +} +void CStackFrame::pop(int xmm_reg,int varSize){ + ref(xmm_reg,varSize); + + now_sp+=sizeof(_int64); +} +void CStackFrame::parameter_allocate(int size){ + if(max_parm_size