Changeset 226 in dev for trunk/abdev

Timestamp:

Jul 22, 2007, 4:58:47 AM (17 years ago)

Author:

dai_9181

Message:

 

Location:

trunk/abdev

Files:

• BasicCompiler32/MachineFixed.h (added)
• BasicCompiler64/BasicCompiler.vcproj (modified) (2 diffs)
• BasicCompiler64/CParameter.cpp (modified) (9 diffs)
• BasicCompiler64/CodeGenerator.cpp (added)
• BasicCompiler64/Compile_Calc.cpp (modified) (1 diff)
• BasicCompiler64/Compile_Calc_PushVar.cpp (modified) (12 diffs)
• BasicCompiler64/Compile_CallProc.cpp (modified) (8 diffs)
• BasicCompiler64/Compile_Func.cpp (modified) (9 diffs)
• BasicCompiler64/Compile_Object.cpp (modified) (12 diffs)
• BasicCompiler64/Compile_ProcOp.cpp (modified) (22 diffs)
• BasicCompiler64/Compile_Set_Var.cpp (modified) (19 diffs)
• BasicCompiler64/Compile_Statement.cpp (modified) (13 diffs)
• BasicCompiler64/Compile_Var.cpp (modified) (30 diffs)
• BasicCompiler64/MachineFixed.h (added)
• BasicCompiler64/MakePeHdr.cpp (modified) (4 diffs)
• BasicCompiler64/NumOpe.cpp (modified) (12 diffs)
• BasicCompiler64/NumOpe_Arithmetic.cpp (modified) (18 diffs)
• BasicCompiler64/NumOpe_Logical.cpp (modified) (6 diffs)
• BasicCompiler64/NumOpe_Relation.cpp (modified) (6 diffs)
• BasicCompiler64/NumOpe_TypeOperation.cpp (modified) (16 diffs)
• BasicCompiler64/Opcode.h (modified) (2 diffs)
• BasicCompiler64/OperatorProc.cpp (modified) (9 diffs)
• BasicCompiler64/amd64_main.cpp (modified) (1 diff)
• BasicCompiler64/increment.cpp (modified) (2 diffs)
• BasicCompiler64/stack_frame.cpp (modified) (6 diffs)
• BasicCompiler_Common/include/CodeGenerator.h (modified) (1 diff)
• BasicCompiler_Common/include/NativeCode.h (modified) (3 diffs)
• BasicCompiler_Common/src/LexicalScopingImpl.cpp (modified) (1 diff)

trunk/abdev/BasicCompiler64/BasicCompiler.vcproj

@@ -254 +254 @@
             </File>
             <File
+                RelativePath=".\MachineFixed.h"
+                >
+            </File>
+            <File
                 RelativePath="Opcode.h"
                 >
@@ -784 +788 @@
                     </File>
                     <File
+                        RelativePath=".\CodeGenerator.cpp"
+                        >
+                        <FileConfiguration
+                            Name="Debug|Win32"
+                            >
+                            <Tool
+                                Name="VCCLCompilerTool"
+                                ObjectFile="$(IntDir)\$(InputName)1.obj"
+                                XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
+                            />
+                        </FileConfiguration>
+                        <FileConfiguration
+                            Name="Release|Win32"
+                            >
+                            <Tool
+                                Name="VCCLCompilerTool"
+                                ObjectFile="$(IntDir)\$(InputName)1.obj"
+                                XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
+                            />
+                        </FileConfiguration>
+                    </File>
+                    <File
                         RelativePath=".\stack_frame.cpp"
                         >

trunk/abdev/BasicCompiler64/CParameter.cpp

@@ -1 +1 @@
 #include "stdafx.h"
+
+#include <Compiler.h>
 
 #include "../BasicCompiler_Common/common.h"
@@ -113 +115 @@
                 //call free
                 extern const UserProc *pSub_free;
-                op_call(pSub_free);
+                compiler.codeGenerator.op_call(pSub_free);
             }
             else{
@@ -132 +134 @@
 
         //mov rcx,object_size
-        op_mov_RV(sizeof(_int64),REG_RCX,object_size);
+        compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RCX,object_size);
 
         //call calloc
         extern const UserProc *pSub_calloc;
-        op_call(pSub_calloc);
+        compiler.codeGenerator.op_call(pSub_calloc);
 
         //mov r11,rax
-        op_mov_RR(REG_R11,REG_RAX);
+        compiler.codeGenerator.op_mov_RR(REG_R11,REG_RAX);
 
         //mov qword ptr[rsp+offset],r11     ※スタックフレームを利用
@@ -179 +181 @@
 
     //mov reg,r11
-    op_mov_RR(reg,REG_R11);
+    compiler.codeGenerator.op_mov_RR(reg,REG_R11);
 }
 
@@ -317 +319 @@
 
                         //movd reg,temp_reg
-                        op_movd_RX(reg,temp_reg);
+                        compiler.codeGenerator.op_movd_RX(reg,temp_reg);
                     }
                 }
@@ -430 +432 @@
             //スタックフレームへコピー
             //mov qword ptr[rsp+offset],rax
-            op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,i2*sizeof(_int64),MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,i2*sizeof(_int64),MOD_BASE_DISP32);
         }
         else if(xmm_temp_sw){
@@ -436 +438 @@
 
             //movlpd qword ptr[rsp+offset],xmm0
-            op_movlpd_MR(REG_XMM0,REG_RSP,i2*sizeof(_int64),MOD_BASE_DISP32);
+            compiler.codeGenerator.op_movlpd_MR(REG_XMM0,REG_RSP,i2*sizeof(_int64),MOD_BASE_DISP32);
         }
 
@@ -467 +469 @@
         if(obj_DBLockParms.array_LevelCount[i2]){
             //mov r14,qword ptr[rsp+offset]
-            op_mov_RM(sizeof(_int64),REG_R14,REG_RSP,i2*sizeof(_int64),MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R14,REG_RSP,i2*sizeof(_int64),MOD_BASE_DISP32);
 
             //mov qword ptr[rsp+offset],r14     ※スタックフレームを利用
@@ -503 +505 @@
 
             //mov qword ptr[rsp+offset],r14
-            op_mov_MR(sizeof(_int64),REG_R14,REG_RSP,i2*sizeof(_int64),MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_R14,REG_RSP,i2*sizeof(_int64),MOD_BASE_DISP32);
         }
     }

trunk/abdev/BasicCompiler64/Compile_Calc.cpp

@@ -247 +247 @@
 
         // mov rcx, rax
-        op_mov_RR( REG_RCX, REG_RAX );
+        compiler.codeGenerator.op_mov_RR( REG_RCX, REG_RAX );
 
         // call System.[TypeClass]._Create
-        op_call( pUserProc );
+        compiler.codeGenerator.op_call( pUserProc );
 
         calcType = pUserProc->ReturnType();

trunk/abdev/BasicCompiler64/Compile_Calc_PushVar.cpp

@@ -1 +1 @@
 #include "stdafx.h"
+
+#include <Compiler.h>
 
 #include "../BasicCompiler_Common/common.h"
@@ -71 +73 @@
         else{
             //mov r11,qword ptr[rsp+offset]
-            op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -155 +157 @@
         else{
             //mov r11,qword ptr[rsp+offset]
-            op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -183 +185 @@
         if(pRelativeVar->bOffsetOffset){
             //mov reg, ptr[r11+offset]
-            op_mov_RM(varSize,reg,REG_R11,(int)pRelativeVar->offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_RM(varSize,reg,REG_R11,(int)pRelativeVar->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -190 +192 @@
         else{
             //mov reg, ptr[offset]
-            op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset,MOD_DISP32);
+            compiler.codeGenerator.op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset,MOD_DISP32);
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -199 +201 @@
         if(pRelativeVar->bOffsetOffset){
             //add r11,qword ptr[offset]
-            op_add_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
+            compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -206 +208 @@
         else{
             //mov r11,qword ptr[offset]
-            op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -217 +219 @@
         if(pRelativeVar->bOffsetOffset){
             //mov reg, ptr[rsp+r11+offset]
-            op_mov_RM_ex(varSize,reg,REG_RSP,REG_R11,(int)pRelativeVar->offset,USE_OFFSET);
+            compiler.codeGenerator.op_mov_RM_ex(varSize,reg,REG_RSP,REG_R11,(int)pRelativeVar->offset,USE_OFFSET);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -224 +226 @@
         else{
             //mov reg, ptr[rsp+offset]
-            op_mov_RM(varSize,reg,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_RM(varSize,reg,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -233 +235 @@
         if(pRelativeVar->bOffsetOffset){
             //add r11,qword ptr[rsp+offset]
-            op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_add_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -240 +242 @@
         else{
             //mov r11,qword ptr[rsp+offset]
-            op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -251 +253 @@
 directmem:
         //mov reg, ptr[r11]
-        op_mov_RM(varSize,reg,REG_R11,0,MOD_BASE);
+        compiler.codeGenerator.op_mov_RM(varSize,reg,REG_R11,0,MOD_BASE);
     }
 }

trunk/abdev/BasicCompiler64/Compile_CallProc.cpp

@@ -15 +15 @@
     //call _System_GetEip
     extern const UserProc *pSub_System_GetEip;
-    op_call(pSub_System_GetEip);
+    compiler.codeGenerator.op_call(pSub_System_GetEip);
 
     //mov rdx,rax
-    op_mov_RR(REG_RDX,REG_RAX);
+    compiler.codeGenerator.op_mov_RR(REG_RDX,REG_RAX);
 
     //mov rcx,rsp
-    op_mov_RR(REG_RCX,REG_RSP);
+    compiler.codeGenerator.op_mov_RR(REG_RCX,REG_RSP);
 
     //call _DebugSys_SaveContext
     extern const UserProc *pSub_DebugSys_SaveContext;
-    op_call(pSub_DebugSys_SaveContext);
+    compiler.codeGenerator.op_call(pSub_DebugSys_SaveContext);
 }
 
@@ -79 +79 @@
 
     //mov rax,qword ptr[rax]
-    op_mov_RM(sizeof(_int64),REG_RAX,REG_RAX,0,MOD_BASE);
+    compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RAX,REG_RAX,0,MOD_BASE);
 
     //call rax
@@ -278 +278 @@
 
             //mov rcx,object_size
-            op_mov_RV(sizeof(_int64),REG_RCX,object_size);
+            compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RCX,object_size);
 
             //call calloc
             extern const UserProc *pSub_calloc;
-            op_call(pSub_calloc);
+            compiler.codeGenerator.op_call(pSub_calloc);
 
             //mov r13,rax
-            op_mov_RR(REG_R13,REG_RAX);
+            compiler.codeGenerator.op_mov_RR(REG_R13,REG_RAX);
 
         /////////////////////////////////////////////
@@ -294 +294 @@
         if( pUserProc->GetParentClassPtr() && isStatic == false ){
             //mov rdx,r13
-            op_mov_RR(REG_RDX,REG_R13);
+            compiler.codeGenerator.op_mov_RR(REG_RDX,REG_R13);
         }
         else{
             //mov rcx,r13
-            op_mov_RR(REG_RCX,REG_R13);
+            compiler.codeGenerator.op_mov_RR(REG_RCX,REG_R13);
         }
     }
@@ -330 +330 @@
                 // 参照を実体ポインタにする
                 //mov rcx,qword ptr[rcx]
-                op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
+                compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
             }
         }
@@ -355 +355 @@
 
         //mov r11,qword ptr[rcx]
-        op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
+        compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
 
         i2 = pobj_c->GetFuncNumInVtbl( pUserProc );
@@ -378 +378 @@
 
         //call ProcAddr
-        op_call(pUserProc);
+        compiler.codeGenerator.op_call(pUserProc);
     }
 
@@ -445 +445 @@
 
     //call dword ptr[ImportTable]
-    op_call( pDllProc );
+    compiler.codeGenerator.op_call( pDllProc );
 
     /* 64コンパイラでは不要

trunk/abdev/BasicCompiler64/Compile_Func.cpp

@@ -64 +64 @@
 
     //mov rax,TypeSize
-    op_mov_RV(sizeof(_int64),REG_RAX,typeSize);
+    compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,typeSize);
 
     return;
@@ -124 +124 @@
                 if(type.IsObjectPtr()){
                     //mov rcx,qword ptr[rcx]
-                    op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
+                    compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
                 }
             }
@@ -143 +143 @@
 
         //mov r11,qword ptr[rcx]
-        op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
+        compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
 
         int i2 = pobj_c->GetFuncNumInVtbl( pUserProc );
@@ -149 +149 @@
         //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);
+            compiler.codeGenerator.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);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RAX,REG_R11,i2*PTR_SIZE,MOD_BASE_DISP32);
         }
     }
@@ -159 +159 @@
 
         //mov rax,ProcAddr
-        op_mov_RV(sizeof(_int64),REG_RAX,0);
+        compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,0);
         obp-=sizeof(long);
         pobj_SubAddrSchedule->add(pUserProc,0);
@@ -178 +178 @@
 
     //mov rax,size
-    op_mov_RV(sizeof(_int64),REG_RAX,typeSize);
+    compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,typeSize);
 }
 void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn ){
@@ -209 +209 @@
 
         //mov rax,qword ptr[rax]
-        op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
+        compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
 
         SetError(-120,NULL,cp);
@@ -244 +244 @@
 
         //mov rax,qword ptr[rax]
-        op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
+        compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
     }
     else{
@@ -263 +263 @@
     if(type==DEF_DOUBLE){
         //movlpd xmm0,qword ptr[rax]
-        op_movlpd_RM(REG_XMM0,REG_RAX,0,MOD_BASE);
+        compiler.codeGenerator.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);
+        compiler.codeGenerator.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);
+        compiler.codeGenerator.op_mov_RM(GetTypeSize(type,-1),REG_RAX,REG_RAX,0,MOD_BASE);
     }
 }

trunk/abdev/BasicCompiler64/Compile_Object.cpp

@@ -1 +1 @@
 #include "stdafx.h"
+
+#include <Compiler.h>
 
 #include "../BasicCompiler_Common/common.h"
@@ -113 +115 @@
         //※添え字上限値であることを考慮
         //add rax,1
-        op_add_RV(REG_RAX,1);
+        compiler.codeGenerator.op_add_RV(REG_RAX,1);
 
         //オブジェクトの個数をrbxに一時保持
         //※rbxは関数が呼ばれても不変
         //mov rbx,rax
-        op_mov_RR(REG_RBX,REG_RAX);
+        compiler.codeGenerator.op_mov_RR(REG_RBX,REG_RAX);
 
         //imul rax,size
-        op_imul_RV(sizeof(_int64),REG_RAX,typeSize);
+        compiler.codeGenerator.op_imul_RV(sizeof(_int64),REG_RAX,typeSize);
 
         //add rax,OBJECT_HEAD_SIZE
-        op_add_RV(REG_RAX,OBJECT_HEAD_SIZE);
+        compiler.codeGenerator.op_add_RV(REG_RAX,OBJECT_HEAD_SIZE);
 
         //mov rcx,rax
-        op_mov_RR(REG_RCX,REG_RAX);
+        compiler.codeGenerator.op_mov_RR(REG_RCX,REG_RAX);
     }
     else{
@@ -133 +135 @@
         //※rbxは関数が呼ばれても不変
         //mov rbx,1
-        op_mov_RV(sizeof(_int64),REG_RBX,1);
+        compiler.codeGenerator.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);
+        compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RCX,typeSize+OBJECT_HEAD_SIZE);
     }
 
@@ -145 +147 @@
         //call _System_GC_malloc_ForObject
         extern const UserProc *pSub_System_GC_malloc_ForObject;
-        op_call(pSub_System_GC_malloc_ForObject);
+        compiler.codeGenerator.op_call(pSub_System_GC_malloc_ForObject);
     }
     else{
@@ -153 +155 @@
         //call _System_GC_malloc_ForObjectPtr
         extern const UserProc *pSub_System_GC_malloc_ForObjectPtr;
-        op_call(pSub_System_GC_malloc_ForObjectPtr);
+        compiler.codeGenerator.op_call(pSub_System_GC_malloc_ForObjectPtr);
     }
 
@@ -168 +170 @@
 
     //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);
+    compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);
+
+    //add rax,PTR_SIZE
+    compiler.codeGenerator.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);
+    compiler.codeGenerator.op_mov_MV(sizeof(_int64),REG_RAX,0,NON_OFFSET,typeSize);
+
+    //add rax,PTR_SIZE
+    compiler.codeGenerator.op_add_RV(REG_RAX,PTR_SIZE);
 
 
@@ -185 +187 @@
 
     //mov rcx,DestructorProcAddr（デストラクタの関数ポインタ）
-    op_mov_RV(sizeof(_int64),REG_RCX,0);
+    compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RCX,0);
     obp-=sizeof(long);
     pobj_SubAddrSchedule->add(&method->GetUserProc(),0);
@@ -192 +194 @@
 
     //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);
+    compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RCX,REG_RAX,0,MOD_BASE);
+
+    //add rax,PTR_SIZE
+    compiler.codeGenerator.op_add_RV(REG_RAX,PTR_SIZE);
 
 
     // リザーブ領域
     //add rax,PTR_SIZE
-    op_add_RV(REG_RAX,PTR_SIZE);
+    compiler.codeGenerator.op_add_RV(REG_RAX,PTR_SIZE);
 
 
@@ -229 +231 @@
 
     //sub rax,OBJECT_HEAD_SIZE
-    op_sub_RV(sizeof(_int64),REG_RAX,OBJECT_HEAD_SIZE);
+    compiler.codeGenerator.op_sub_RV(sizeof(_int64),REG_RAX,OBJECT_HEAD_SIZE);
 
     //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
@@ -236 +238 @@
 
     //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);
+    compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);
+
+    //add rax,PTR_SIZE
+    compiler.codeGenerator.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);
+    compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RSI,REG_RAX,0,MOD_BASE);
+
+    //add rax,PTR_SIZE
+    compiler.codeGenerator.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);
+    compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RDI,REG_RAX,0,MOD_BASE);
+
+    //add rax,PTR_SIZE
+    compiler.codeGenerator.op_add_RV(REG_RAX,PTR_SIZE);
 
 
     // リザーブ領域
     //add rax,PTR_SIZE
-    op_add_RV(REG_RAX,PTR_SIZE);
+    compiler.codeGenerator.op_add_RV(REG_RAX,PTR_SIZE);
 
 
     //mov rcx,rax
-    op_mov_RR(REG_RCX,REG_RAX);
+    compiler.codeGenerator.op_mov_RR(REG_RCX,REG_RAX);
 
 
@@ -280 +282 @@
 
     //add rcx,rsi
-    op_add64_reg(REG_RCX,REG_RSI);
+    compiler.codeGenerator.op_add64_reg(REG_RCX,REG_RSI);
 
     //sub rbx,1
-    op_sub_RV(sizeof(_int64),REG_RBX,1);
+    compiler.codeGenerator.op_sub_RV(sizeof(_int64),REG_RBX,1);
 
     //jnz ↑
@@ -302 +304 @@
         //call _System_GC_free_for_SweepingDelete
         extern const UserProc *pSub_System_GC_free_for_SweepingDelete;
-        op_call(pSub_System_GC_free_for_SweepingDelete);
+        compiler.codeGenerator.op_call(pSub_System_GC_free_for_SweepingDelete);
     }
     else{
         //call free
         extern const UserProc *pSub_free;
-        op_call(pSub_free);
+        compiler.codeGenerator.op_call(pSub_free);
     }
 }

trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp

@@ -15 +15 @@
     if( userProc.GetName() == "_System_GetEip" ){
         //mov rax,qword ptr[rsp]
-        op_mov_RM(sizeof(_int64),REG_RAX,REG_RSP,0,MOD_BASE);
+        compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RAX,REG_RSP,0,MOD_BASE);
 
         //ret
-        op_ret();
+        compiler.codeGenerator.op_ret();
     }
     else if( userProc.GetName() == "_System_InitDllGlobalVariables" ){
@@ -27 +27 @@
         if(!bDll){
             //ret
-            op_ret();
+            compiler.codeGenerator.op_ret();
 
             return;
@@ -41 +41 @@
         //sub rsp,スタックフレームサイズ
         int StackFrameSchedule;
-        op_sub_rsp(0xFFFFFFFF);
+        compiler.codeGenerator.op_sub_rsp(0xFFFFFFFF);
         StackFrameSchedule=obp-sizeof(long);
 
@@ -55 +55 @@
         //_System_StartupProgramの呼び出し
         extern const UserProc *pSub_System_StartupProgram;
-        op_call(pSub_System_StartupProgram);
+        compiler.codeGenerator.op_call(pSub_System_StartupProgram);
 
         //クラスに属する静的メンバを定義
@@ -63 +63 @@
 
         //add rsp,スタックフレームサイズ
-        op_add_RV(REG_RSP,pobj_sf->GetFrameSize(0));
+        compiler.codeGenerator.op_add_RV(REG_RSP,pobj_sf->GetFrameSize(0));
 
         //スタックフレームスケジュール（subコマンドに渡す値）
@@ -72 +72 @@
 
         //ret
-        op_ret();
+        compiler.codeGenerator.op_ret();
     }
     else if( userProc.GetName() == "_System_InitStaticLocalVariables" ){
@@ -79 +79 @@
         //sub rsp,スタックフレームサイズ
         int StackFrameSchedule;
-        op_sub_rsp(0xFFFFFFFF);
+        compiler.codeGenerator.op_sub_rsp(0xFFFFFFFF);
         StackFrameSchedule=obp-sizeof(long);
 
@@ -100 +100 @@
 
         //add rsp,スタックフレームサイズ
-        op_add_RV(REG_RSP,pobj_sf->GetFrameSize(0));
+        compiler.codeGenerator.op_add_RV(REG_RSP,pobj_sf->GetFrameSize(0));
 
         //スタックフレームスケジュール（subコマンドに渡す値）
@@ -106 +106 @@
 
         //ret
-        op_ret();
+        compiler.codeGenerator.op_ret();
     }
     else if( userProc.GetName() == "_System_Call_Destructor_of_GlobalObject" ){
         //sub rsp,8（※RSPを16バイト境界にあわせるため）
-        op_sub_rsp(0x8);
+        compiler.codeGenerator.op_sub_rsp(0x8);
 
 
@@ -122 +122 @@
 
         //add rsp,8
-        op_add_RV(REG_RSP,0x8);
+        compiler.codeGenerator.op_add_RV(REG_RSP,0x8);
 
         //ret
-        op_ret();
+        compiler.codeGenerator.op_ret();
     }
     else if( userProc.GetName() == "_System_GetSp" ){
         //mov rax,rsp
-        op_mov_RR(REG_RAX,REG_RSP);
+        compiler.codeGenerator.op_mov_RR(REG_RAX,REG_RSP);
 
         //add rax,PTR_SIZE
-        op_add_RV(REG_RAX,PTR_SIZE);
+        compiler.codeGenerator.op_add_RV(REG_RAX,PTR_SIZE);
 
         //ret
-        op_ret();
+        compiler.codeGenerator.op_ret();
     }
     else if( userProc.GetName() == "_allrem" ){
@@ -276 +276 @@
     compiler.GetNamespaceSupporter().SetImportedNamespaces( pUserProc->GetImportedNamespaces() );
 
+    // コード生成対象を選択
+    compiler.codeGenerator.Select( (const_cast<UserProc *>(pUserProc))->GetNativeCode() );
+
     if(pUserProc->IsSystem()){
         ////////////////////
@@ -408 +411 @@
             if(param.IsReal()&&param.IsRef() == false){
                 //movsd qword ptr[rsp+0x20],xmm3
-                op_movsd_MR(REG_XMM3,REG_RSP,0x20,MOD_BASE_DISP32);
+                compiler.codeGenerator.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);
+                compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_R9,REG_RSP,0x20,MOD_BASE_DISP32);
             }
         }
@@ -418 +421 @@
             if(param.IsReal()&&param.IsRef() == false){
                 //movsd qword ptr[rsp+0x18],xmm2
-                op_movsd_MR(REG_XMM2,REG_RSP,0x18,MOD_BASE_DISP32);
+                compiler.codeGenerator.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);
+                compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_R8,REG_RSP,0x18,MOD_BASE_DISP32);
             }
         }
@@ -428 +431 @@
             if(param.IsReal()&&param.IsRef() == false){
                 //movsd qword ptr[rsp+0x10],xmm1
-                op_movsd_MR(REG_XMM1,REG_RSP,0x10,MOD_BASE_DISP32);
+                compiler.codeGenerator.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);
+                compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RDX,REG_RSP,0x10,MOD_BASE_DISP32);
             }
         }
@@ -438 +441 @@
             if(param.IsReal()&&param.IsRef() == false){
                 //movsd qword ptr[rsp+0x8],xmm0
-                op_movsd_MR(REG_XMM0,REG_RSP,0x8,MOD_BASE_DISP32);
+                compiler.codeGenerator.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);
+                compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RCX,REG_RSP,0x8,MOD_BASE_DISP32);
             }
         }
@@ -452 +455 @@
     //sub rsp,スタックフレームサイズ
     int StackFrameSchedule;
-    op_sub_rsp(0xFFFFFFFF);
+    compiler.codeGenerator.op_sub_rsp(0xFFFFFFFF);
     StackFrameSchedule=obp-sizeof(long);
 
@@ -496 +499 @@
     if(bDebugCompile&&bDebugSupportProc==0){
         //mov rdx, qword ptr[rsp+スタックフレームサイズ]
-        op_mov_RM(sizeof(_int64),REG_RDX,REG_RSP,0,MOD_BASE_DISP32);
+        compiler.codeGenerator.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);
+        compiler.codeGenerator.op_mov_RR(REG_RCX,REG_RSP);
 
         //add rcx,スタックフレームサイズ+sizeof(_int64) ※ret用のサイズを考慮
-        op_add_RV(REG_RCX,0);
+        compiler.codeGenerator.op_add_RV(REG_RCX,0);
         RspOffsetSchedule2=obp-sizeof(long);
 
         //call _DebugSys_StartProc
         extern const UserProc *pSub_DebugSys_StartProc;
-        op_call(pSub_DebugSys_StartProc);
+        compiler.codeGenerator.op_call(pSub_DebugSys_StartProc);
     }
 
@@ -582 +585 @@
 
                     //mov rax,offset
-                    op_mov_RV(sizeof(_int64),REG_RAX,offset);
+                    compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,offset);
                     obp-=sizeof(long);
                     pobj_DataTableSchedule->add();
@@ -591 +594 @@
 
                     //mov qword ptr[rcx],rax
-                    op_mov_MR(sizeof(_int64),REG_RAX,REG_RCX,0,MOD_BASE);
+                    compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RCX,0,MOD_BASE);
             }
         }
@@ -695 +698 @@
         //call _DebugSys_EndProc
         extern const UserProc *pSub_DebugSys_EndProc;
-        op_call(pSub_DebugSys_EndProc);
+        compiler.codeGenerator.op_call(pSub_DebugSys_EndProc);
     }
 
@@ -717 +720 @@
             if( i3==DEF_OBJECT ){
                 //mov rax,qword ptr[rax]
-                op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
+                compiler.codeGenerator.op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
             }
         }
@@ -763 +766 @@
 
     //add rsp,スタックフレームサイズ
-    op_add_rsp(stackFrameAndLocalParamSize);
+    compiler.codeGenerator.op_add_rsp(stackFrameAndLocalParamSize);
 
     //ret
-    op_ret();
+    compiler.codeGenerator.op_ret();
 
 

trunk/abdev/BasicCompiler64/Compile_Set_Var.cpp

@@ -1 +1 @@
 #include "stdafx.h"
+
+#include <Compiler.h>
 
 #include "../BasicCompiler_Common/common.h"
@@ -24 +26 @@
         if( calcType.IsDouble() ){
             //movlsd RightTermReg,xmm0
-            op_movsd_RR(RightTermReg,REG_XMM0);
+            compiler.codeGenerator.op_movsd_RR(RightTermReg,REG_XMM0);
         }
         else if( calcType.IsSingle() ){
             //movlss RightTermReg,xmm0
-            op_movss_RR(RightTermReg,REG_XMM0);
+            compiler.codeGenerator.op_movss_RR(RightTermReg,REG_XMM0);
         }
     }
@@ -35 +37 @@
 
         //mov RightTermReg,rax
-        op_mov_RR(RightTermReg,REG_RAX);
+        compiler.codeGenerator.op_mov_RR(RightTermReg,REG_RAX);
     }
 
@@ -57 +59 @@
 
                 //mov rsi,RightTermReg
-                op_mov_RR(REG_RSI,RightTermReg);
+                compiler.codeGenerator.op_mov_RR(REG_RSI,RightTermReg);
 
                 //mov rdi,VarReg
-                op_mov_RR(REG_RDI,VarReg);
+                compiler.codeGenerator.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);
+                compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RCX,object_size);
 
                 if(bUseHeap){
                     //mov rax,rsi
-                    op_mov_RR(REG_RAX,REG_RSI);
+                    compiler.codeGenerator.op_mov_RR(REG_RAX,REG_RSI);
                 }
 
                 //rep movs byte ptr[rdi],byte ptr[rsi]
-                op_rep_movs(sizeof(BYTE));
+                compiler.codeGenerator.op_rep_movs(sizeof(BYTE));
 
                 if(bUseHeap){
                     //mov rcx,rax
-                    op_mov_RR(REG_RCX,REG_RAX);
+                    compiler.codeGenerator.op_mov_RR(REG_RCX,REG_RAX);
 
                     //call free
                     extern const UserProc *pSub_free;
-                    op_call(pSub_free);
+                    compiler.codeGenerator.op_call(pSub_free);
                 }
 
@@ -165 +167 @@
         else{
             //mov r11,qword ptr[rsp+offset]
-            op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -256 +258 @@
         else{
             //mov r11,qword ptr[rsp+offset]
-            op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -289 +291 @@
 
         //cvttsd2si rax,xmm0
-        op_cvttsd2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0);
+        compiler.codeGenerator.op_cvttsd2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0);
     }
     else if(type==DEF_SINGLE){
@@ -295 +297 @@
 
         //cvttss2si rax,xmm0
-        op_cvttss2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0);
+        compiler.codeGenerator.op_cvttss2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0);
     }
 
     //cmp rax,0
-    op_cmp_value(GetTypeSize(type,-1),REG_RAX,0);
+    compiler.codeGenerator.op_cmp_value(GetTypeSize(type,-1),REG_RAX,0);
 
     //setne al
-    op_setne( REG_RAX );
+    compiler.codeGenerator.op_setne( REG_RAX );
 
     SetWholeVariable( sizeof(char), DEF_BYTE, pRelative);
@@ -311 +313 @@
 
         //cvttsd2si rax,xmm0
-        op_cvttsd2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0);
+        compiler.codeGenerator.op_cvttsd2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0);
     }
     else if(type==DEF_SINGLE){
@@ -317 +319 @@
 
         //cvttss2si rax,xmm0
-        op_cvttss2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0);
+        compiler.codeGenerator.op_cvttss2si_xmm(sizeof(_int64),REG_RAX,REG_XMM0);
     }
     else{
@@ -340 +342 @@
         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);
+            compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,REG_R11,(int)pRelative->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -347 +349 @@
         else{
             //mov ptr[offset],rax/eax/ax/al
-            op_mov_MR(varSize,REG_RAX,0,(int)pRelative->offset,MOD_DISP32);
+            compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,0,(int)pRelative->offset,MOD_DISP32);
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -356 +358 @@
         if(pRelative->bOffsetOffset){
             //add r11,qword ptr[offset]
-            op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelative->offset, MOD_DISP32 );
+            compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelative->offset, MOD_DISP32 );
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -363 +365 @@
         else{
             //mov r11,qword ptr[offset]
-            op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelative->offset,MOD_DISP32);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelative->offset,MOD_DISP32);
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -374 +376 @@
         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);
+            compiler.codeGenerator.op_mov_MR_ex(varSize,REG_RAX,REG_RSP,REG_R11,(int)pRelative->offset,USE_OFFSET);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -381 +383 @@
         else{
             //mov ptr[rsp+offset],rax/eax/ax/al
-            op_mov_MR(varSize,REG_RAX,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -390 +392 @@
         if(pRelative->bOffsetOffset){
             //add r11,qword ptr[rsp+offset]
-            op_add_RM( sizeof(_int64), REG_R11, REG_RSP, (int)pRelative->offset, MOD_BASE_DISP32 );
+            compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_RSP, (int)pRelative->offset, MOD_BASE_DISP32 );
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -397 +399 @@
         else{
             //mov r11,qword ptr[rsp+offset]
-            op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelative->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -409 +411 @@
 
         //mov ptr[r11],rax/eax/ax/al
-        op_mov_MR(varSize,REG_RAX,REG_R11,0,MOD_BASE);
-    }
-}
+        compiler.codeGenerator.op_mov_MR(varSize,REG_RAX,REG_R11,0,MOD_BASE);
+    }
+}

trunk/abdev/BasicCompiler64/Compile_Statement.cpp

@@ -113 +113 @@
         if( resultType.IsStruct() ){
             //mov r14,rax
-            op_mov_RR(REG_R14,REG_RAX);
+            compiler.codeGenerator.op_mov_RR(REG_R14,REG_RAX);
 
             FreeTempObject(REG_R14,&resultType.GetClass());
@@ -166 +166 @@
 
         //cmp rax,0
-        op_cmp_value(resultType.GetSize(),REG_RAX,0);
+        compiler.codeGenerator.op_cmp_value(resultType.GetSize(),REG_RAX,0);
     }
 }
@@ -421 +421 @@
 
     //cmp rax,0
-    op_cmp_value(resultType.GetSize(),REG_RAX,0);
+    compiler.codeGenerator.op_cmp_value(resultType.GetSize(),REG_RAX,0);
 
     //je [カウンタ減少の場合の判定]
@@ -451 +451 @@
 
     //cmp rax,0
-    op_cmp_value(resultType.GetSize(),REG_RAX,0);
+    compiler.codeGenerator.op_cmp_value(resultType.GetSize(),REG_RAX,0);
 
 ErrorStep:
@@ -761 +761 @@
                     if(reg2!=REG_RDX){
                         //mov rdx,reg2
-                        op_mov_RR(REG_RDX,reg2);
+                        compiler.codeGenerator.op_mov_RR(REG_RDX,reg2);
                     }
 
@@ -768 +768 @@
 
                     //call operator_proc    ※ ==演算子
-                    op_call(pUserProc);
+                    compiler.codeGenerator.op_call(pUserProc);
 
                     //test rax,rax
-                    op_test(REG_RAX,REG_RAX);
+                    compiler.codeGenerator.op_test(REG_RAX,REG_RAX);
 
                     //jne ...
@@ -788 +788 @@
 
                         //comiss xmm_reg1,xmm_reg2
-                        op_comisd(xmm_reg,REG_XMM4);
+                        compiler.codeGenerator.op_comisd(xmm_reg,REG_XMM4);
                     }
                     else if(type1.IsSingle()){
@@ -800 +800 @@
 
                         //comiss xmm_reg1,xmm_reg2
-                        op_comiss(xmm_reg,REG_XMM4);
+                        compiler.codeGenerator.op_comiss(xmm_reg,REG_XMM4);
                     }
                     else{
@@ -811 +811 @@
 
                         //cmp reg2,r14
-                        op_cmp_reg(GetTypeSize(i2,-1),reg2,REG_R14);
+                        compiler.codeGenerator.op_cmp_reg(GetTypeSize(i2,-1),reg2,REG_R14);
                     }
 
@@ -893 +893 @@
     //call _System_GetEip
     extern const UserProc *pSub_System_GetEip;
-    op_call(pSub_System_GetEip);
+    compiler.codeGenerator.op_call(pSub_System_GetEip);
 
     //add rax,offset（Gosubステートメントの最終ポイント）
     int schedule=obp,schedule2;
-    op_add_RV(REG_RAX,0);
+    compiler.codeGenerator.op_add_RV(REG_RAX,0);
     schedule2=obp-sizeof(long);
 
@@ -1032 +1032 @@
 
         //movsd qword ptr[reg_ptr],xmm0
-        op_movsd_MR(REG_XMM0,reg_ptr,0,MOD_BASE);
+        compiler.codeGenerator.op_movsd_MR(REG_XMM0,reg_ptr,0,MOD_BASE);
     }
     else if(type==DEF_SINGLE){
@@ -1038 +1038 @@
 
         //movss dword ptr[reg_ptr],xmm0
-        op_movss_MR(REG_XMM0,reg_ptr,0,MOD_BASE);
+        compiler.codeGenerator.op_movss_MR(REG_XMM0,reg_ptr,0,MOD_BASE);
     }
     else{
@@ -1044 +1044 @@
 
         //mov ptr[reg_ptr],rcx
-        op_mov_MR(GetTypeSize(type,-1),REG_RCX,reg_ptr,0,MOD_BASE);
-    }
-}
+        compiler.codeGenerator.op_mov_MR(GetTypeSize(type,-1),REG_RCX,reg_ptr,0,MOD_BASE);
+    }
+}

trunk/abdev/BasicCompiler64/Compile_Var.cpp

@@ -54 +54 @@
         if(typeSize>=2){
             //imul reg,i2
-            op_imul_RV(sizeof(_int64),reg,typeSize);
+            compiler.codeGenerator.op_imul_RV(sizeof(_int64),reg,typeSize);
         }
     }
@@ -72 +72 @@
 
     //add r11,reg
-    op_add64_reg(REG_R11,reg);
+    compiler.codeGenerator.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);
+        compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
     }
     else{
@@ -85 +85 @@
 
         //mov r11,qword ptr[r12]
-        op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
+        compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
     }
 }
@@ -139 +139 @@
 
     //xor r12,r12
-    op_zero_reg(REG_R12);
+    compiler.codeGenerator.op_zero_reg(REG_R12);
 
     for(i=i3-1;i>=0;i--){
@@ -173 +173 @@
 
         //imul reg,i4
-        op_imul_RV(sizeof(_int64),reg,i4);
+        compiler.codeGenerator.op_imul_RV(sizeof(_int64),reg,i4);
 
         //add r12,reg
-        op_add64_reg(REG_R12,reg);
+        compiler.codeGenerator.op_add64_reg(REG_R12,reg);
 
         HeapDefaultFree(pParm[i]);
@@ -352 +352 @@
 
                 //mov r11,qword ptr[r11]
-                op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
+                compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
             }
             else{
@@ -652 +652 @@
         //xor r11,r11（r11を0に初期化する）
         //※r11は変数ベースアドレスからの相対オフセットを示す
-        op_zero_reg(REG_R11);
+        compiler.codeGenerator.op_zero_reg(REG_R11);
 
         pRelativeVar->bOffsetOffset=1;
@@ -701 +701 @@
 
                 //mov r11,qword ptr[r12]
-                op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
+                compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
             }
         }
@@ -721 +721 @@
 
                 //mov r11,qword ptr[r12]
-                op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
+                compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
             }
             else{
@@ -872 +872 @@
 
             //mov rax,DataPos
-            op_mov_RV(sizeof(_int64),REG_RAX,i2);
+            compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,i2);
             obp-=sizeof(long);
             pobj_DataTableSchedule->add();
@@ -878 +878 @@
 
             //mov qword ptr[offset],rax
-            op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32);
+            compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32);
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -1002 +1002 @@
 
         //mov rax,i64data
-        op_mov64_ToReg(REG_RAX,i64data);
+        compiler.codeGenerator.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);
+        compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
         obp-=sizeof(long);
         AddLocalVarAddrSchedule();
@@ -1015 +1015 @@
 
         //mov dword ptr[rsp+offset],value
-        op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,*(int *)&flt);
+        compiler.codeGenerator.op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,*(int *)&flt);
         obp-=sizeof(long)+sizeof(long);
         AddLocalVarAddrSchedule();
@@ -1030 +1030 @@
 
             //mov rax,i2
-            op_mov_RV(sizeof(_int64),REG_RAX,i2);
+            compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,i2);
             obp-=sizeof(long);
             pobj_DataTableSchedule->add();
@@ -1036 +1036 @@
 
             //mov qword ptr[rsp+offset],rax
-            op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -1044 +1044 @@
             if(i64data&0xFFFFFFFF00000000){
                 //mov rax,i64data
-                op_mov64_ToReg(REG_RAX,i64data);
+                compiler.codeGenerator.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);
+                compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
                 obp-=sizeof(long);
                 AddLocalVarAddrSchedule();
@@ -1054 +1054 @@
             else{
                 //mov qword ptr[rsp+offset],value
-                op_mov_MV(sizeof(_int64),REG_RSP,offset,USE_OFFSET,(int)i64data);
+                compiler.codeGenerator.op_mov_MV(sizeof(_int64),REG_RSP,offset,USE_OFFSET,(int)i64data);
                 obp-=sizeof(long)+sizeof(long);
                 AddLocalVarAddrSchedule();
@@ -1063 +1063 @@
     else if( type.IsDWord() || type.IsLong() ){
         //mov dword ptr[rsp+offset],value
-        op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int)i64data);
+        compiler.codeGenerator.op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int)i64data);
         obp-=sizeof(long)+sizeof(long);
         AddLocalVarAddrSchedule();
@@ -1070 +1070 @@
     else if( type.IsWord() || type.IsInteger() ){
         //mov word ptr[rsp+offset],value
-        op_mov_MV(sizeof(short),REG_RSP,offset,USE_OFFSET,(int)i64data);
+        compiler.codeGenerator.op_mov_MV(sizeof(short),REG_RSP,offset,USE_OFFSET,(int)i64data);
         obp-=sizeof(long)+sizeof(short);
         AddLocalVarAddrSchedule();
@@ -1077 +1077 @@
     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);
+        compiler.codeGenerator.op_mov_MV(sizeof(char),REG_RSP,offset,USE_OFFSET,(int)i64data);
         obp-=sizeof(long)+sizeof(char);
         AddLocalVarAddrSchedule();
@@ -1182 +1182 @@
 
             //mov r8, 0
-            op_zero_reg( REG_R8 );
+            compiler.codeGenerator.op_zero_reg( REG_R8 );
 
             //mov rdx, VarSize
-            op_mov_RV( sizeof(_int64), REG_RDX, pVar->GetMemorySize() );
+            compiler.codeGenerator.op_mov_RV( sizeof(_int64), REG_RDX, pVar->GetMemorySize() );
 
             //mov rcx, rsp
-            op_mov_RR( REG_RCX, REG_RSP );
+            compiler.codeGenerator.op_mov_RR( REG_RCX, REG_RSP );
 
             //add rcx, offset
-            op_add_RV( REG_RCX, -pVar->GetOffsetAddress() );
+            compiler.codeGenerator.op_add_RV( REG_RCX, -pVar->GetOffsetAddress() );
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -1199 +1199 @@
             DllProc *pDllProc;
             pDllProc=GetDeclareHash("FillMemory");
-            op_call( pDllProc );
+            compiler.codeGenerator.op_call( pDllProc );
         }
     }
@@ -1240 +1240 @@
 
             //mov reg,r11
-            op_mov_RR(reg,REG_R11);
+            compiler.codeGenerator.op_mov_RR(reg,REG_R11);
         }
         else{
             //mov reg,offset
-            op_mov64_ToReg(reg,(int)pRelativeVar->offset);
+            compiler.codeGenerator.op_mov64_ToReg(reg,(long)pRelativeVar->offset);
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -1253 +1253 @@
         if(pRelativeVar->bOffsetOffset){
             //add r11,qword ptr[offset]
-            op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
+            compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -1260 +1260 @@
         else{
             //mov r11,qword ptr[offset]
-            op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -1279 +1279 @@
 
             //add r11,rsp
-            op_add64_reg(REG_R11,REG_RSP);
+            compiler.codeGenerator.op_add64_reg(REG_R11,REG_RSP);
 
             //mov reg,r11
-            op_mov_RR(reg,REG_R11);
+            compiler.codeGenerator.op_mov_RR(reg,REG_R11);
         }
         else{
             //mov reg,rsp
-            op_mov_RR(reg,REG_RSP);
+            compiler.codeGenerator.op_mov_RR(reg,REG_RSP);
 
             //add reg,offset
-            op_add_RV(reg,(int)pRelativeVar->offset);
+            compiler.codeGenerator.op_add_RV(reg,(int)pRelativeVar->offset);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -1308 +1308 @@
         else{
             //mov r11,qword ptr[rsp+offset]
-            op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -1319 +1319 @@
 directmem:
         //mov reg,r11
-        op_mov_RR(reg,REG_R11);
+        compiler.codeGenerator.op_mov_RR(reg,REG_R11);
     }
 }
@@ -1337 +1337 @@
             // 変数領域に要するLONG_PTR単位の個数を引き渡す
             //mov r8,count
-            op_mov_RV(sizeof(_int64), REG_R8,pVar->GetMemorySize()/PTR_SIZE);
+            compiler.codeGenerator.op_mov_RV(sizeof(_int64), REG_R8,pVar->GetMemorySize()/PTR_SIZE);
 
             // ルートポインタを引き渡す
             //mov rdx,offset
-            op_mov_RV(sizeof(_int64), REG_RDX,(int)pVar->GetOffsetAddress());
+            compiler.codeGenerator.op_mov_RV(sizeof(_int64), REG_RDX,(int)pVar->GetOffsetAddress());
             obp-=sizeof(long);
             pobj_GlobalVarSchedule->add();
@@ -1350 +1350 @@
 
             // call AddGlobalRootPtr
-            op_call( pUserProc_AddGlobalRootPtr );
+            compiler.codeGenerator.op_call( pUserProc_AddGlobalRootPtr );
 
             ReallocNativeCodeBuffer();

trunk/abdev/BasicCompiler64/MakePeHdr.cpp

@@ -391 +391 @@
         pobj_sf=new CStackFrame();
 
+        // コード生成対象を選択
+        compiler.codeGenerator.Select( compiler.globalNativeCode );
+
         trace_for_sourcecodestep( "★★★ グローバル領域のコンパイルを開始" );
 
@@ -399 +402 @@
         //sub rsp,スタックフレームサイズ
         int StackFrameSchedule;
-        op_sub_rsp(0xFFFFFFFF);
+        compiler.codeGenerator.op_sub_rsp(0xFFFFFFFF);
         StackFrameSchedule=obp-sizeof(long);
 
@@ -411 +414 @@
 
         //_System_StartupProgramの呼び出し
-        op_call(pSub_System_StartupProgram);
+        compiler.codeGenerator.op_call(pSub_System_StartupProgram);
 
         //クラスに属する静的メンバを定義
@@ -445 +448 @@
         //call _System_Call_Destructor_of_GlobalObject
         extern const UserProc *pSub_System_Call_Destructor_of_GlobalObject;
-        op_call(pSub_System_Call_Destructor_of_GlobalObject);
+        compiler.codeGenerator.op_call(pSub_System_Call_Destructor_of_GlobalObject);
 
 
         //add rsp,スタックフレームサイズ
         int stackFrameSize = pobj_sf->GetFrameSize(0);
-        op_add_RV( REG_RSP, stackFrameSize );
+        compiler.codeGenerator.op_add_RV( REG_RSP, stackFrameSize );
 
         //xor rax,rax（raxを0に初期化する）
-        op_zero_reg(REG_RAX);
+        compiler.codeGenerator.op_zero_reg(REG_RAX);
 
         //ret
-        op_ret();
+        compiler.codeGenerator.op_ret();
 
         //グローバル実行領域のコードサイズ

trunk/abdev/BasicCompiler64/NumOpe.cpp

@@ -30 +30 @@
 
         //mov reg,rax
-        op_mov_RR( reg, REG_RAX );
+        compiler.codeGenerator.op_mov_RR( reg, REG_RAX );
 
     /////////////////////////////////////////////
@@ -54 +54 @@
             if(type==DEF_DOUBLE){
                 //movsd xmm_reg,xmm0
-                op_movsd_RR(XmmReg,REG_XMM0);
+                compiler.codeGenerator.op_movsd_RR(XmmReg,REG_XMM0);
             }
             else if(type==DEF_SINGLE){
                 //movss xmm_reg,xmm0
-                op_movss_RR(XmmReg,REG_XMM0);
+                compiler.codeGenerator.op_movss_RR(XmmReg,REG_XMM0);
             }
         }
@@ -70 +70 @@
         else{
             //mov reg,rax
-            op_mov_RR(UseReg,REG_RAX);
+            compiler.codeGenerator.op_mov_RR(UseReg,REG_RAX);
         }
     }
@@ -142 +142 @@
 
         //オブジェクトポインタをr11にコピー
-        op_mov_RR( REG_R11, UseReg );
+        compiler.codeGenerator.op_mov_RR( REG_R11, UseReg );
 
         RELATIVE_VAR relativeVar;
@@ -555 +555 @@
 
         //mov reg,rax
-        op_mov_RR( *pReg, REG_RAX );
+        compiler.codeGenerator.op_mov_RR( *pReg, REG_RAX );
 
         return true;
@@ -603 +603 @@
 
         //mov reg,i2
-        op_mov_RV(sizeof(_int64),*pReg,i2);
+        compiler.codeGenerator.op_mov_RV(sizeof(_int64),*pReg,i2);
         obp-=sizeof(long);
         pobj_DataTableSchedule->add();
@@ -796 +796 @@
 
                     //mov reg,i2
-                    op_mov_RV(sizeof(_int64),UseReg,i2);
+                    compiler.codeGenerator.op_mov_RV(sizeof(_int64),UseReg,i2);
                     obp-=sizeof(long);
                     pobj_DataTableSchedule->add();
@@ -895 +895 @@
 
                         //xor reg,reg
-                        op_zero_reg( UseReg );
+                        compiler.codeGenerator.op_zero_reg( UseReg );
 
                         if(UseReg==REG_R14){
@@ -971 +971 @@
                         if(XmmReg==REG_XMM4){
                             //mov r14,i64data
-                            op_mov64_ToReg(REG_R14,i64data);
+                            compiler.codeGenerator.op_mov64_ToReg(REG_R14,i64data);
 
 
@@ -1004 +1004 @@
                             SetError();     // TODO: 未実装
                             //push term
-                            op_push_value(i32data);
+                            //compiler.codeGenerator.op_push_value(i32data);
                         }
                         else{
@@ -1026 +1026 @@
 
                         //mov reg,i64data
-                        op_mov64_ToReg(UseReg,i64data);
+                        compiler.codeGenerator.op_mov64_ToReg(UseReg,i64data);
 
                         if(UseReg==REG_R14){
@@ -1194 +1194 @@
 
             //mov reg,i64data
-            op_mov64_ToReg(UseReg,i64data);
+            compiler.codeGenerator.op_mov64_ToReg(UseReg,i64data);
         }
 

trunk/abdev/BasicCompiler64/NumOpe_Arithmetic.cpp

@@ -104 +104 @@
         if(idCalc==CALC_ADDITION){
             //add reg1,reg2
-            op_add64_reg(reg1,reg2);
+            compiler.codeGenerator.op_add64_reg(reg1,reg2);
         }
         else if(idCalc==CALC_SUBTRACTION){
             //sub reg1,reg2
-            op_sub64_reg(reg1,reg2);
+            compiler.codeGenerator.op_sub64_reg(reg1,reg2);
         }
         else if(idCalc==CALC_PRODUCT){
             //mul reg1,reg2
-            op_imul_RR(sizeof(_int64),reg1,reg2);
+            compiler.codeGenerator.op_imul_RR(sizeof(_int64),reg1,reg2);
         }
 
@@ -127 +127 @@
         if(idCalc==CALC_ADDITION){
             //add reg1,reg2
-            op_add32_reg(reg1,reg2);
+            compiler.codeGenerator.op_add32_reg(reg1,reg2);
         }
         else if(idCalc==CALC_SUBTRACTION){
             //sub reg1,reg2
-            op_sub32_reg(reg1,reg2);
+            compiler.codeGenerator.op_sub32_reg(reg1,reg2);
         }
         else if(idCalc==CALC_PRODUCT){
             //mul reg1,reg2
-            op_imul_RR(sizeof(long),reg1,reg2);
+            compiler.codeGenerator.op_imul_RR(sizeof(long),reg1,reg2);
         }
 
@@ -181 +181 @@
     if(reg2==REG_RAX||reg2==REG_RDX){
         //mov r15,reg2
-        op_mov_RR(REG_R15,reg2);
+        compiler.codeGenerator.op_mov_RR(REG_R15,reg2);
 
         reg2=REG_R15;
@@ -207 +207 @@
 
         //mov rax,reg1
-        op_mov_RR(REG_RAX,reg1);
+        compiler.codeGenerator.op_mov_RR(REG_RAX,reg1);
 
         if(IsSignedType(type[sp-2])){
@@ -222 +222 @@
 
             //xor rdx,rdx
-            op_zero_reg(REG_RDX);
+            compiler.codeGenerator.op_zero_reg(REG_RDX);
         }
 
         if(IsSignedType(AnswerType)){
             //idiv reg2
-            op_idiv64_reg(reg2);
+            compiler.codeGenerator.op_idiv64_reg(reg2);
         }
         else{
             //div reg2
-            op_div64_reg(reg2);
+            compiler.codeGenerator.op_div64_reg(reg2);
         }
 
         //mov reg1,rdx
-        op_mov_RR(reg1,REG_RDX);
+        compiler.codeGenerator.op_mov_RR(reg1,REG_RDX);
 
     }
@@ -357 +357 @@
     if(reg2==REG_RAX||reg2==REG_RDX){
         //mov r15,reg2
-        op_mov_RR(REG_R15,reg2);
+        compiler.codeGenerator.op_mov_RR(REG_R15,reg2);
 
         reg2=REG_R15;
@@ -383 +383 @@
 
         //mov rax,reg1
-        op_mov_RR(REG_RAX,reg1);
+        compiler.codeGenerator.op_mov_RR(REG_RAX,reg1);
 
         if(IsSignedType(type[sp-2])){
@@ -398 +398 @@
 
             //xor rdx,rdx
-            op_zero_reg(REG_RDX);
+            compiler.codeGenerator.op_zero_reg(REG_RDX);
         }
 
         if(IsSignedType(AnswerType)){
             //idiv reg2
-            op_idiv64_reg(reg2);
+            compiler.codeGenerator.op_idiv64_reg(reg2);
         }
         else{
             //div reg2
-            op_div64_reg(reg2);
+            compiler.codeGenerator.op_div64_reg(reg2);
         }
 
         //mov reg1,rax
-        op_mov_RR(reg1,REG_RAX);
+        compiler.codeGenerator.op_mov_RR(reg1,REG_RAX);
 
     }
@@ -499 +499 @@
 
         //imul reg,-1
-        op_imul_RV(sizeof(_int64),reg,-1);
+        compiler.codeGenerator.op_imul_RV(sizeof(_int64),reg,-1);
 
         if(reg==REG_R14){
@@ -512 +512 @@
 
         //imul reg,-1
-        op_imul_RV(sizeof(long),reg,-1);
+        compiler.codeGenerator.op_imul_RV(sizeof(long),reg,-1);
 
         if(reg==REG_R14){
@@ -549 +549 @@
         if(xmm_reg1==REG_XMM1){
             //movsd xmm0,xmm_reg1
-            op_movsd_RR(REG_XMM0,xmm_reg1);
+            compiler.codeGenerator.op_movsd_RR(REG_XMM0,xmm_reg1);
 
             //movsd xmm1,xmm_reg2
-            op_movsd_RR(REG_XMM1,xmm_reg2);
+            compiler.codeGenerator.op_movsd_RR(REG_XMM1,xmm_reg2);
         }
         else{
             //movsd xmm1,xmm_reg2
-            op_movsd_RR(REG_XMM1,xmm_reg2);
+            compiler.codeGenerator.op_movsd_RR(REG_XMM1,xmm_reg2);
 
             //movsd xmm0,xmm_reg1
-            op_movsd_RR(REG_XMM0,xmm_reg1);
+            compiler.codeGenerator.op_movsd_RR(REG_XMM0,xmm_reg1);
         }
 
         //call pow
         extern const UserProc *pSub_pow;
-        op_call(pSub_pow);
+        compiler.codeGenerator.op_call(pSub_pow);
 
         //movsd xmm4,xmm0
-        op_movsd_RR(REG_XMM4,REG_XMM0);
+        compiler.codeGenerator.op_movsd_RR(REG_XMM4,REG_XMM0);
 
 
@@ -586 +586 @@
     else{
         //movsd xmm_reg1,xmm4
-        op_movsd_RR(xmm_reg1,REG_XMM4);
+        compiler.codeGenerator.op_movsd_RR(xmm_reg1,REG_XMM4);
     }
 
@@ -621 +621 @@
     if(reg1==REG_RCX){
         //mov r15,rcx
-        op_mov_RR(REG_R15,REG_RCX);
+        compiler.codeGenerator.op_mov_RR(REG_R15,REG_RCX);
 
         reg1=REG_R15;
@@ -633 +633 @@
 
     //mov rcx,reg2
-    op_mov_RR(REG_RCX,reg2);
+    compiler.codeGenerator.op_mov_RR(REG_RCX,reg2);
 
     if(idCalc==CALC_SHL){
@@ -647 +647 @@
 
         //shl reg1,cl
-        op_shl_reg(GetTypeSize(type[sp-2],-1),reg1);
+        compiler.codeGenerator.op_shl_reg(GetTypeSize(type[sp-2],-1),reg1);
     }
     else if(idCalc==CALC_SHR){
@@ -654 +654 @@
 
             //sar
-            op_sar_reg(GetTypeSize(type[sp-2],-1),reg1);
+            compiler.codeGenerator.op_sar_reg(GetTypeSize(type[sp-2],-1),reg1);
         }
         else{
@@ -660 +660 @@
 
             //shr
-            op_shr_reg(GetTypeSize(type[sp-2],-1),reg1);
+            compiler.codeGenerator.op_shr_reg(GetTypeSize(type[sp-2],-1),reg1);
         }
     }
@@ -666 +666 @@
     if(sw==0){
         //mov rcx,r15
-        op_mov_RR(REG_RCX,REG_R15);
+        compiler.codeGenerator.op_mov_RR(REG_RCX,REG_R15);
     }
     else{

trunk/abdev/BasicCompiler64/NumOpe_Logical.cpp

@@ -1 +1 @@
 #include "stdafx.h"
+
+#include <Compiler.h>
 
 #include "../BasicCompiler_Common/common.h"
@@ -28 +30 @@
         if(idCalc==CALC_XOR){
             //xor reg1,reg2
-            op_xor_reg(sizeof(_int64),reg1,reg2);
+            compiler.codeGenerator.op_xor_reg(sizeof(_int64),reg1,reg2);
         }
         else if(idCalc==CALC_OR){
             //or reg1,reg2
-            op_or_reg(sizeof(_int64),reg1,reg2);
+            compiler.codeGenerator.op_or_reg(sizeof(_int64),reg1,reg2);
         }
         else if(idCalc==CALC_AND){
             //and reg1,reg2
-            op_and_reg(sizeof(_int64),reg1,reg2);
+            compiler.codeGenerator.op_and_reg(sizeof(_int64),reg1,reg2);
         }
 
@@ -54 +56 @@
         if(idCalc==CALC_ADDITION){
             //add reg1,reg2
-            op_xor_reg(sizeof(long),reg1,reg2);
+            compiler.codeGenerator.op_xor_reg(sizeof(long),reg1,reg2);
         }
         else if(idCalc==CALC_OR){
             //or reg1,reg2
-            op_or_reg(sizeof(long),reg1,reg2);
+            compiler.codeGenerator.op_or_reg(sizeof(long),reg1,reg2);
         }
         else if(idCalc==CALC_AND){
             //and reg1,reg2
-            op_and_reg(sizeof(long),reg1,reg2);
+            compiler.codeGenerator.op_and_reg(sizeof(long),reg1,reg2);
         }
 
@@ -99 +101 @@
 
         //cmp reg,0
-        op_cmp_value(GetTypeSize(type[sp-1],-1),reg,0);
+        compiler.codeGenerator.op_cmp_value(GetTypeSize(type[sp-1],-1),reg,0);
 
         //setne al
-        op_setne( REG_RAX );
+        compiler.codeGenerator.op_setne( REG_RAX );
 
         //and rax,000000FFh
-        op_and64_value(REG_RAX,(int)0xFF);
+        compiler.codeGenerator.op_and64_value(REG_RAX,(int)0xFF);
 
         //neg
-        op_neg( REG_RAX );
+        compiler.codeGenerator.op_neg( REG_RAX );
 
         //sbb rax, rax
-        op_sbb_RR( sizeof(_int64), REG_RAX, REG_RAX );
+        compiler.codeGenerator.op_sbb_RR( sizeof(_int64), REG_RAX, REG_RAX );
 
         //add rax, 1
-        op_add_RV( REG_RAX, 1 );
+        compiler.codeGenerator.op_add_RV( REG_RAX, 1 );
 
         if( reg != REG_RAX ){
             //mov reg,rax
-            op_mov_RR( reg, REG_RAX );
+            compiler.codeGenerator.op_mov_RR( reg, REG_RAX );
 
             //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
@@ -133 +135 @@
 
         //not reg
-        op_not_reg(sizeof(_int64),reg);
+        compiler.codeGenerator.op_not_reg(sizeof(_int64),reg);
 
         if(reg==REG_R14){
@@ -144 +146 @@
 
         //not reg
-        op_not_reg(sizeof(long),reg);
+        compiler.codeGenerator.op_not_reg(sizeof(long),reg);
 
         if(reg==REG_R14){

trunk/abdev/BasicCompiler64/NumOpe_Relation.cpp

@@ -1 +1 @@
 #include "stdafx.h"
+
+#include <Compiler.h>
 
 #include "../BasicCompiler_Common/common.h"
@@ -24 +26 @@
         if(AnswerType==DEF_DOUBLE){
             //comisd xmm_reg1,xmm_reg2
-            op_comisd(xmm_reg1,xmm_reg2);
+            compiler.codeGenerator.op_comisd(xmm_reg1,xmm_reg2);
         }
         else if(AnswerType==DEF_SINGLE){
             //comiss xmm_reg1,xmm_reg2
-            op_comiss(xmm_reg1,xmm_reg2);
+            compiler.codeGenerator.op_comiss(xmm_reg1,xmm_reg2);
         }
 
@@ -46 +48 @@
 
         //cmp reg1,reg2
-        op_cmp_reg(sizeof(_int64),reg1,reg2);
+        compiler.codeGenerator.op_cmp_reg(sizeof(_int64),reg1,reg2);
     }
     else{
@@ -57 +59 @@
 
         //cmp reg1,reg2
-        op_cmp_reg(sizeof(long),reg1,reg2);
+        compiler.codeGenerator.op_cmp_reg(sizeof(long),reg1,reg2);
     }
 
@@ -137 +139 @@
 
     //xor reg1,reg1
-    op_zero_reg(reg1);
+    compiler.codeGenerator.op_zero_reg(reg1);
 
     //jmp 7（次のmovを飛び越す）
@@ -149 +151 @@
 
     //mov reg1,1
-    op_mov_RV(sizeof(_int64),reg1,1);
+    compiler.codeGenerator.op_mov_RV(sizeof(_int64),reg1,1);
 
 

trunk/abdev/BasicCompiler64/NumOpe_TypeOperation.cpp

@@ -11 +11 @@
     if(type==DEF_LONG){
         //movsxd reg64,reg32
-        op_movsxd(reg,reg);
+        compiler.codeGenerator.op_movsxd(reg,reg);
     }
     else if(type==DEF_DWORD){
@@ -18 +18 @@
     else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
         //movsx reg64,reg16
-        op_movsx64_FromReg16(reg,reg);
+        compiler.codeGenerator.op_movsx64_FromReg16(reg,reg);
     }
     else if(type==DEF_WORD){
         //and reg,000000000000FFFFh
-        op_and64_value(reg,(int)0xFFFF);
+        compiler.codeGenerator.op_and64_value(reg,(int)0xFFFF);
     }
     else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
         //movsx reg64,reg8
-        op_movsx64_FromReg8(reg,reg);
+        compiler.codeGenerator.op_movsx64_FromReg8(reg,reg);
     }
     else if(type==DEF_BYTE || type==DEF_BOOLEAN){
         //and reg,00000000000000FFh
-        op_and64_value(reg,(int)0x00FF);
+        compiler.codeGenerator.op_and64_value(reg,(int)0x00FF);
     }
 }
@@ -36 +36 @@
     if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
         //movsx reg32,reg16
-        op_movsx32_FromReg16(reg,reg);
+        compiler.codeGenerator.op_movsx32_FromReg16(reg,reg);
     }
     else if(type==DEF_WORD){
         //and reg,0000FFFFh
-        op_and32_value(reg,(int)0xFFFF);
+        compiler.codeGenerator.op_and32_value(reg,(int)0xFFFF);
     }
     else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
         //movsx reg32,reg8
-        op_movsx32_FromReg8(reg,reg);
+        compiler.codeGenerator.op_movsx32_FromReg8(reg,reg);
     }
     else if(type==DEF_BYTE || type==DEF_BOOLEAN){
         //and reg,000000FFh
-        op_and32_value(reg,(int)0xFF);
+        compiler.codeGenerator.op_and32_value(reg,(int)0xFF);
     }
 }
@@ -54 +54 @@
     if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
         //movsx reg16,reg8
-        op_movsx16_FromReg8(reg,reg);
+        compiler.codeGenerator.op_movsx16_FromReg8(reg,reg);
     }
     else if(type==DEF_BYTE){
         //and reg,000000FFh
-        op_and32_value(reg,(int)0xFF);
+        compiler.codeGenerator.op_and32_value(reg,(int)0xFF);
     }
 }
@@ -70 +70 @@
 
         //cvtss2sd
-        op_cvtss2sd(xmm_reg,xmm_reg);
+        compiler.codeGenerator.op_cvtss2sd(xmm_reg,xmm_reg);
     }
     else if(Is64Type(type)){
@@ -76 +76 @@
 
         //cvtsi2sd xmm_reg,reg
-        op_cvtsi2sd_reg(sizeof(_int64),xmm_reg,general_reg);
+        compiler.codeGenerator.op_cvtsi2sd_reg(sizeof(_int64),xmm_reg,general_reg);
 
         if(type==DEF_QWORD){
@@ -82 +82 @@
 
             //test reg,reg
-            op_test(general_reg,general_reg);
+            compiler.codeGenerator.op_test(general_reg,general_reg);
 
             //jge 9
@@ -109 +109 @@
 
         //cvtsi2sd xmm_reg,reg
-        op_cvtsi2sd_reg(sizeof(_int64),xmm_reg,general_reg);
+        compiler.codeGenerator.op_cvtsi2sd_reg(sizeof(_int64),xmm_reg,general_reg);
     }
     else{
@@ -118 +118 @@
 
         //cvtsi2sd xmm_reg,reg
-        op_cvtsi2sd_reg(sizeof(long),xmm_reg,general_reg);
+        compiler.codeGenerator.op_cvtsi2sd_reg(sizeof(long),xmm_reg,general_reg);
     }
 }
@@ -126 +126 @@
 
         //cvtsd2ss
-        op_cvtsd2ss(xmm_reg,xmm_reg);
+        compiler.codeGenerator.op_cvtsd2ss(xmm_reg,xmm_reg);
     }
     else if(type==DEF_SINGLE){
@@ -135 +135 @@
 
         //cvtsi2ss xmm_reg,reg
-        op_cvtsi2ss_reg(sizeof(_int64),xmm_reg,general_reg);
+        compiler.codeGenerator.op_cvtsi2ss_reg(sizeof(_int64),xmm_reg,general_reg);
 
         if(type==DEF_QWORD){
@@ -141 +141 @@
 
             //test reg,reg
-            op_test(general_reg,general_reg);
+            compiler.codeGenerator.op_test(general_reg,general_reg);
 
             //jge 9
@@ -168 +168 @@
 
         //cvtsi2ss xmm_reg,reg
-        op_cvtsi2ss_reg(sizeof(_int64),xmm_reg,general_reg);
+        compiler.codeGenerator.op_cvtsi2ss_reg(sizeof(_int64),xmm_reg,general_reg);
     }
     else{
@@ -177 +177 @@
 
         //cvtsi2ss xmm_reg,reg
-        op_cvtsi2ss_reg(sizeof(long),xmm_reg,general_reg);
+        compiler.codeGenerator.op_cvtsi2ss_reg(sizeof(long),xmm_reg,general_reg);
     }
 }
@@ -185 +185 @@
         if(Is64Type(NewType)){
             //cvttsd2si reg,xmm_reg
-            op_cvttsd2si_xmm(sizeof(_int64),reg,xmm_reg);
+            compiler.codeGenerator.op_cvttsd2si_xmm(sizeof(_int64),reg,xmm_reg);
         }
         else{
             //cvttsd2si reg,xmm_reg
-            op_cvttsd2si_xmm(sizeof(long),reg,xmm_reg);
+            compiler.codeGenerator.op_cvttsd2si_xmm(sizeof(long),reg,xmm_reg);
         }
     }
@@ -195 +195 @@
         if(Is64Type(NewType)){
             //cvttss2si reg,xmm_reg
-            op_cvttss2si_xmm(sizeof(_int64),reg,xmm_reg);
+            compiler.codeGenerator.op_cvttss2si_xmm(sizeof(_int64),reg,xmm_reg);
         }
         else{
             //cvttss2si reg,xmm_reg
-            op_cvttss2si_xmm(sizeof(long),reg,xmm_reg);
+            compiler.codeGenerator.op_cvttss2si_xmm(sizeof(long),reg,xmm_reg);
         }
     }

trunk/abdev/BasicCompiler64/Opcode.h

@@ -3 +3 @@
 #include <Type.h>
 #include <Procedure.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)
-
+#include "MachineFixed.h"
 
 
@@ -426 +378 @@
 
 
-
-////////////////////////////////
-// 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( const UserProc *pUserProc );
-void op_call( const DllProc *pDllProc );
-void op_ret();

trunk/abdev/BasicCompiler64/OperatorProc.cpp

@@ -2 +2 @@
 
 #include <jenga/include/smoothie/LexicalAnalysis.h>
+
+#include <Compiler.h>
 
 #include "../BasicCompiler_Common/common.h"
@@ -17 +19 @@
     if( method ){
         //mov rcx,reg
-        op_mov_RR(REG_RCX,reg);
+        compiler.codeGenerator.op_mov_RR(REG_RCX,reg);
 
         //call DestructorProcAddr
-        op_call( &method->GetUserProc() );
+        compiler.codeGenerator.op_call( &method->GetUserProc() );
     }
 
     //mov rcx,reg
-    op_mov_RR(REG_RCX,reg);
+    compiler.codeGenerator.op_mov_RR(REG_RCX,reg);
 
     //call free
     extern const UserProc *pSub_free;
-    op_call(pSub_free);
+    compiler.codeGenerator.op_call(pSub_free);
 }
 
@@ -119 +121 @@
 
             //mov rcx,object_size
-            op_mov_RV(sizeof(_int64),REG_RCX,object_size);
+            compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RCX,object_size);
 
             //call calloc
             extern const UserProc *pSub_calloc;
-            op_call(pSub_calloc);
+            compiler.codeGenerator.op_call(pSub_calloc);
 
             //mov r13,rax
-            op_mov_RR(REG_R13,REG_RAX);
+            compiler.codeGenerator.op_mov_RR(REG_R13,REG_RAX);
 
         /////////////////////////////////////////////
@@ -169 +171 @@
         if(reg1==REG_RDX||reg1==REG_R8){
             //mov r14,reg1
-            op_mov_RR(REG_R14,reg1);
+            compiler.codeGenerator.op_mov_RR(REG_R14,reg1);
             reg1=REG_R14;
         }
@@ -177 +179 @@
             if( pUserProc->ReturnType().IsStruct() ){
                 //mov r8,reg2
-                op_mov_RR(REG_R8,reg2);
+                compiler.codeGenerator.op_mov_RR(REG_R8,reg2);
             }
             else{
                 //mov rdx,reg2
-                op_mov_RR(REG_RDX,reg2);
+                compiler.codeGenerator.op_mov_RR(REG_RDX,reg2);
             }
         }
@@ -187 +189 @@
         if( pUserProc->ReturnType().IsStruct() ){
             //mov rdx,r13
-            op_mov_RR(REG_RDX,REG_R13);
+            compiler.codeGenerator.op_mov_RR(REG_RDX,REG_R13);
         }
 
         //mov rcx,reg1
-        op_mov_RR(REG_RCX,reg1);
+        compiler.codeGenerator.op_mov_RR(REG_RCX,reg1);
 
         //call operator_proc
-        op_call(pUserProc);
+        compiler.codeGenerator.op_call(pUserProc);
 
         if( !pUserProc->ReturnType().IsNull() ){
@@ -200 +202 @@
 
             //mov r13,rax
-            op_mov_RR(REG_R13,REG_RAX);
+            compiler.codeGenerator.op_mov_RR(REG_R13,REG_RAX);
         }
 
@@ -249 +251 @@
 
         //mov reg1,r13
-        op_mov_RR(reg1,REG_R13);
+        compiler.codeGenerator.op_mov_RR(reg1,REG_R13);
     }
 
@@ -338 +340 @@
 
         //mov reg,rax
-        op_mov_RR(reg,REG_RAX);
+        compiler.codeGenerator.op_mov_RR(reg,REG_RAX);
 
     /////////////////////////////////////////////

trunk/abdev/BasicCompiler64/amd64_main.cpp

@@ -20 +20 @@
     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<=REG_RDI){
-        /*  rax～rdi
-            0101 0xxx   */
-        OpBuffer[obp++]=(char)(0x50| REGISTER_OPERAND(reg) );
-    }
-    if(REG_R8<=reg&&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<=REG_RDI){
-        /*  rax～rdi
-            0101 1xxx   */
-        OpBuffer[obp++]=(char)(0x58| REGISTER_OPERAND(reg) );
-    }
-    if(REG_R8<=reg&&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&&reg1<=REG_RDI){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
-    }
-    if(REG_R8<=reg1&&reg1<=REG_R15){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
-        if(REG_R8<=reg2&&reg2<=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<=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<=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<=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<=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&&reg64<=REG_RDI){
-        if(REG_RAX<=reg32&&reg32<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg32&&reg32<=REG_R15) RexByte=(char)0x49;
-    }
-    if(REG_R8<=reg64&&reg64<=REG_R15){
-        if(REG_RAX<=reg32&&reg32<=REG_RDI) RexByte=(char)0x4C;
-        if(REG_R8<=reg32&&reg32<=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&&reg64<=REG_RDI){
-        if(REG_RAX<=reg16&&reg16<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg16&&reg16<=REG_R15) RexByte=(char)0x49;
-    }
-    if(REG_R8<=reg64&&reg64<=REG_R15){
-        if(REG_RAX<=reg16&&reg16<=REG_RDI) RexByte=(char)0x4C;
-        if(REG_R8<=reg16&&reg16<=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&&reg64<=REG_RDI){
-        if(REG_RAX<=reg8&&reg8<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg8&&reg8<=REG_R15) RexByte=(char)0x49;
-    }
-    if(REG_R8<=reg64&&reg64<=REG_R15){
-        if(REG_RAX<=reg8&&reg8<=REG_RDI) RexByte=(char)0x4C;
-        if(REG_R8<=reg8&&reg8<=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&&reg32<=REG_RDI){
-        if(REG_RAX<=reg16&&reg16<=REG_RDI) RexByte=0;
-        if(REG_R8<=reg16&&reg16<=REG_R15) RexByte=(char)0x41;
-    }
-    if(REG_R8<=reg32&&reg32<=REG_R15){
-        if(REG_RAX<=reg16&&reg16<=REG_RDI) RexByte=(char)0x44;
-        if(REG_R8<=reg16&&reg16<=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&&reg32<=REG_RDI){
-        if(REG_RAX<=reg8&&reg8<=REG_RBX) RexByte=0;
-        if(REG_RSP<=reg8&&reg8<=REG_RDI) RexByte=(char)0x40;
-        if(REG_R8<=reg8&&reg8<=REG_R15) RexByte=(char)0x41;
-    }
-    if(REG_R8<=reg32&&reg32<=REG_R15){
-        if(REG_RAX<=reg8&&reg8<=REG_RDI) RexByte=(char)0x44;
-        if(REG_R8<=reg8&&reg8<=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&&reg32<=REG_RDI){
-        if(REG_RAX<=reg8&&reg8<=REG_RBX) RexByte=0;
-        if(REG_RSP<=reg8&&reg8<=REG_RDI) RexByte=(char)0x40;
-        if(REG_R8<=reg8&&reg8<=REG_R15) RexByte=(char)0x41;
-    }
-    if(REG_R8<=reg32&&reg32<=REG_R15){
-        if(REG_RAX<=reg8&&reg8<=REG_RDI) RexByte=(char)0x44;
-        if(REG_R8<=reg8&&reg8<=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<=REG_RDI) RexByte=0x48;
-    if(REG_R8<=reg&&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&&reg1<=REG_RDI){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
-    }
-    if(REG_R8<=reg1&&reg1<=REG_R15){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
-        if(REG_R8<=reg2&&reg2<=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&&reg1<=REG_RDI){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=0;
-        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x41;
-    }
-    if(REG_R8<=reg1&&reg1<=REG_R15){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x44;
-        if(REG_R8<=reg2&&reg2<=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&&reg1<=REG_RDI){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
-    }
-    if(REG_R8<=reg1&&reg1<=REG_R15){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
-        if(REG_R8<=reg2&&reg2<=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&&reg1<=REG_RDI){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=0;
-        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x41;
-    }
-    if(REG_R8<=reg1&&reg1<=REG_R15){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x44;
-        if(REG_R8<=reg2&&reg2<=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&&reg1<=REG_RDI){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
-        }
-        if(REG_R8<=reg1&&reg1<=REG_R15){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x4D;
-        }
-    }
-    else{
-        if(REG_RAX<=reg1&&reg1<=REG_RDI){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=0;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x41;
-        }
-        if(REG_R8<=reg1&&reg1<=REG_R15){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x44;
-            if(REG_R8<=reg2&&reg2<=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<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x4D;
-    }
-    else{
-        if(REG_RAX<=reg&&reg<=REG_RDI) RexByte=0;
-        if(REG_R8<=reg&&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<=REG_RDI) RexByte=(char)0x48;
-    if(REG_R8<=reg&&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<=REG_RDI) RexByte=(char)0x48;
-    if(REG_R8<=reg&&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<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x49;
-    }
-    else if(op_size==sizeof(char)){
-        if(REG_RAX<=reg&&reg<=REG_RBX) RexByte=0;
-        if(REG_RSP<=reg&&reg<=REG_RDI) RexByte=(char)0x40;
-        if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x41;
-    }
-    else{
-        if(REG_RAX<=reg&&reg<=REG_RDI) RexByte=0;
-        if(REG_R8<=reg&&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<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x49;
-    }
-    else if(op_size==sizeof(char)){
-        if(REG_RAX<=reg&&reg<=REG_RBX) RexByte=0;
-        if(REG_RSP<=reg&&reg<=REG_RDI) RexByte=(char)0x40;
-        if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x41;
-    }
-    else{
-        if(REG_RAX<=reg&&reg<=REG_RDI) RexByte=0;
-        if(REG_R8<=reg&&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<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x49;
-    }
-    else if(op_size==sizeof(char)){
-        if(REG_RAX<=reg&&reg<=REG_RBX) RexByte=0;
-        if(REG_RSP<=reg&&reg<=REG_RDI) RexByte=(char)0x40;
-        if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x41;
-    }
-    else{
-        if(REG_RAX<=reg&&reg<=REG_RDI) RexByte=0;
-        if(REG_R8<=reg&&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&&reg1<=REG_RDI){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
-        }
-        if(REG_R8<=reg1&&reg1<=REG_R15){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x4D;
-        }
-    }
-    else{
-        if(REG_RAX<=reg1&&reg1<=REG_RDI){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=0;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x41;
-        }
-        if(REG_R8<=reg1&&reg1<=REG_R15){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x44;
-            if(REG_R8<=reg2&&reg2<=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<=REG_RDI) (char)RexByte=0x48;
-    if(REG_R8<=reg&&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<=REG_RDI) RexByte=0;
-    if(REG_R8<=reg&&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&&reg1<=REG_RDI){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
-        }
-        if(REG_R8<=reg1&&reg1<=REG_R15){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x4D;
-        }
-    }
-    else{
-        if(REG_RAX<=reg1&&reg1<=REG_RDI){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=0;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x41;
-        }
-        if(REG_R8<=reg1&&reg1<=REG_R15){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x44;
-            if(REG_R8<=reg2&&reg2<=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&&reg1<=REG_RDI){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
-        }
-        if(REG_R8<=reg1&&reg1<=REG_R15){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x4D;
-        }
-    }
-    else{
-        if(REG_RAX<=reg1&&reg1<=REG_RDI){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=0;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x41;
-        }
-        if(REG_R8<=reg1&&reg1<=REG_R15){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x44;
-            if(REG_R8<=reg2&&reg2<=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<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x49;
-    }
-    else{
-        if(REG_RAX<=reg&&reg<=REG_RDI) RexByte=0;
-        if(REG_R8<=reg&&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&&reg1<=REG_RDI){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
-    }
-    if(REG_R8<=reg1&&reg1<=REG_R15){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
-        if(REG_R8<=reg2&&reg2<=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&&reg1<=REG_RDI){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
-        }
-        if(REG_R8<=reg1&&reg1<=REG_R15){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x4D;
-        }
-    }
-    else{
-        if(REG_RAX<=reg1&&reg1<=REG_RDI){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=0;
-            if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x41;
-        }
-        if(REG_R8<=reg1&&reg1<=REG_R15){
-            if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x44;
-            if(REG_R8<=reg2&&reg2<=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==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<=REG_RDI) RexByte=(char)0x48;
-            if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x49;
-        }
-        if(REG_XMM8<=xmm_reg&&xmm_reg<=REG_XMM15){
-            if(REG_RAX<=reg&&reg<=REG_RDI) RexByte=(char)0x4C;
-            if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x4D;
-        }
-    }
-    else{
-        if(REG_XMM0<=xmm_reg&&xmm_reg<=REG_XMM7){
-            if(REG_RAX<=reg&&reg<=REG_RDI) RexByte=0;
-            if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x41;
-        }
-        if(REG_XMM8<=xmm_reg&&xmm_reg<=REG_XMM15){
-            if(REG_RAX<=reg&&reg<=REG_RDI) RexByte=(char)0x44;
-            if(REG_R8<=reg&&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<=REG_RDI) RexByte=(char)0x48;
-            if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x49;
-        }
-        if(REG_XMM8<=xmm_reg&&xmm_reg<=REG_XMM15){
-            if(REG_RAX<=reg&&reg<=REG_RDI) RexByte=(char)0x4C;
-            if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x4D;
-        }
-    }
-    else{
-        if(REG_XMM0<=xmm_reg&&xmm_reg<=REG_XMM7){
-            if(REG_RAX<=reg&&reg<=REG_RDI) RexByte=0;
-            if(REG_R8<=reg&&reg<=REG_R15) RexByte=(char)0x41;
-        }
-        if(REG_XMM8<=xmm_reg&&xmm_reg<=REG_XMM15){
-            if(REG_RAX<=reg&&reg<=REG_RDI) RexByte=(char)0x44;
-            if(REG_R8<=reg&&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<=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<=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( const UserProc *pUserProc ){
-    OpBuffer[obp++] = (char)0xE8;
-    pobj_SubAddrSchedule->add( pUserProc, 1 );
-    pUserProc->Using();
-    obp += sizeof(long);
-}
-void op_call( const 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;
-}

trunk/abdev/BasicCompiler64/increment.cpp

@@ -1 +1 @@
 #include "stdafx.h"
+
+#include <Compiler.h>
 
 #include "../BasicCompiler_Common/common.h"
@@ -47 +49 @@
             if(idCalc==CALC_ADDITION){
                 //インクリメント
-                op_inc(REG_RAX);
+                compiler.codeGenerator.op_inc(REG_RAX);
             }
             else if(idCalc==CALC_SUBTRACTION){
                 //デクリメント
-                op_dec(REG_RAX);
+                compiler.codeGenerator.op_dec(REG_RAX);
             }
     }

trunk/abdev/BasicCompiler64/stack_frame.cpp

@@ -1 +1 @@
 #include "stdafx.h"
+
+#include <Compiler.h>
 
 #include "../BasicCompiler_Common/common.h"
@@ -42 +44 @@
 void CStackFrame::mov_sp( int reg ){
     //mov reg,rsp
-    op_mov_RR( reg, REG_RSP );
+    compiler.codeGenerator.op_mov_RR( reg, REG_RSP );
 
     //add reg,now_sp
-    op_add_RV( reg, now_sp );
+    compiler.codeGenerator.op_add_RV( reg, now_sp );
 
     //スケジュールをセット
@@ -59 +61 @@
 
     //mov qword ptr[rsp+offset],reg
-    op_mov_MR(sizeof(_int64),reg,REG_RSP,now_sp,MOD_BASE_DISP32);
+    compiler.codeGenerator.op_mov_MR(sizeof(_int64),reg,REG_RSP,now_sp,MOD_BASE_DISP32);
 
     //スケジュールをセット
@@ -74 +76 @@
     if(varSize==sizeof(double)){
         //movlpd qword ptr[rsp+offset],xmm_reg
-        op_movlpd_MR(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32);
+        compiler.codeGenerator.op_movlpd_MR(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32);
     }
     if(varSize==sizeof(float)){
@@ -94 +96 @@
 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);
+    compiler.codeGenerator.op_mov_RM(sizeof(_int64),reg,REG_RSP,sp_offset,MOD_BASE_DISP32);
 
     //スケジュールをセット
@@ -107 +109 @@
     if(varSize==sizeof(double)){
         //movlpd xmm_reg,qword ptr[rsp+offset]
-        op_movlpd_RM(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32);
+        compiler.codeGenerator.op_movlpd_RM(xmm_reg,REG_RSP,now_sp,MOD_BASE_DISP32);
     }
     if(varSize==sizeof(float)){

trunk/abdev/BasicCompiler_Common/include/CodeGenerator.h

@@ -32 +32 @@
 
 #ifdef _AMD64_
+private:
+    void set_rex(int op_size,int reg,int index_reg,int base_reg);
+    void set_mod_rm_sib_disp(char mod,int reg,int scale,int index_reg,int base_reg,long disp);
+    void __op_format(int op_size,char op_prefix,char opcode1,char opcode2,int reg,int base_reg,long offset,char mod);
+public:
+    void op_mov_RV                  (int op_size,int reg,long i32data);
+    void op_mov_RV64                (int reg,_int64 i64data);
+    void op_mov_RM                  (int op_size,int reg,int base_reg,long offset,char mod);
+    void op_mov_RM_ex               (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset);
+    void op_mov_MR                  (int op_size,int reg,int base_reg,long offset,char mod);
+    void op_mov_MR_ex               (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset);
+    void op_mov_MV                  (int op_size,int base_reg,int offset,BOOL bUseOffset,long i32data);
+    void op_mov_RR                  (int reg1,int reg2);
+    void op_mov64_ToReg             (int reg,_int64 i64data);
+    void op_mov64_ToReg             (int reg,long 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,long 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,long 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,long 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,long offset);
+    void op_and32_value             (int reg,long 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(long num);
+    void op_sub_rsp(long num);
+    void op_add_esp(long num);
+    void op_sub_esp(long num);
+    void op_fld_ptr_esp(int type);
+    void op_zero_reg(int reg);
+    void op_call( const UserProc *pUserProc );
+    void op_call( const DllProc *pDllProc );
+    void op_ret();
+
 #else
 private:

trunk/abdev/BasicCompiler_Common/include/NativeCode.h

@@ -132 +132 @@
         extern char *OpBuffer;
         extern int obp;
-        memcpy( OpBuffer, codeBuffer, size );
+        memcpy( OpBuffer + obp, codeBuffer, size );
         obp += size;
     }
@@ -139 +139 @@
         Put( nativeCode.codeBuffer, nativeCode.size );
     }
-    void Put( char c )
+    void Put( _int64 i64data )
     {
-        codeBuffer[size++] = c;
-        Realloc();
-
-
-
-        // 未完成
-        extern char *OpBuffer;
-        extern int obp;
-        OpBuffer[obp++]=c;
+        Put( (const char *)(&i64data), sizeof(_int64) );
     }
     void Put( long l, Schedule::Type scheduleType = Schedule::None )
@@ -169 +161 @@
         obp+=sizeof(long);
     }
+    void Put( short s )
+    {
+        Put( (const char *)(&s), sizeof(short) );
+    }
+    void Put( char c )
+    {
+        codeBuffer[size++] = c;
+        Realloc();
+
+
+
+        // 未完成
+        extern char *OpBuffer;
+        extern int obp;
+        OpBuffer[obp++]=c;
+    }
 };

trunk/abdev/BasicCompiler_Common/src/LexicalScopingImpl.cpp

@@ -98 +98 @@
 
             //mov rcx,qword ptr[rsp+offset]
-            op_mov_RM(sizeof(_int64),REG_RCX,REG_RSP,
+            compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_RCX,REG_RSP,
                 -pVar->GetOffsetAddress(),
                 MOD_BASE_DISP32);