Changeset 225 in dev for trunk


Ignore:
Timestamp:
Jul 21, 2007, 11:47:40 PM (17 years ago)
Author:
dai_9181
Message:

CodeGeneratorクラスのベースを実装

Location:
trunk/abdev
Files:
1 added
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler32/BasicCompiler.vcproj

    r215 r225  
    11171117                    >
    11181118                    <File
     1119                        RelativePath=".\CodeGenerator.cpp"
     1120                        >
     1121                        <FileConfiguration
     1122                            Name="Debug|Win32"
     1123                            >
     1124                            <Tool
     1125                                Name="VCCLCompilerTool"
     1126                                ObjectFile="$(IntDir)\$(InputName)1.obj"
     1127                                XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
     1128                            />
     1129                        </FileConfiguration>
     1130                        <FileConfiguration
     1131                            Name="Release|Win32"
     1132                            >
     1133                            <Tool
     1134                                Name="VCCLCompilerTool"
     1135                                ObjectFile="$(IntDir)\$(InputName)1.obj"
     1136                                XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
     1137                            />
     1138                        </FileConfiguration>
     1139                    </File>
     1140                    <File
    11191141                        RelativePath="op32_main.cpp"
    11201142                        >
    … …  
    13401362            </File>
    13411363            <File
     1364                RelativePath=".\MachineFixed.h"
     1365                >
     1366            </File>
     1367            <File
    13421368                RelativePath="Opcode.h"
    13431369                >
    … …  
    14201446                <File
    14211447                    RelativePath="..\BasicCompiler_Common\include\NamespaceSupporter.h"
     1448                    >
     1449                </File>
     1450                <File
     1451                    RelativePath="..\BasicCompiler_Common\include\NativeCode.h"
    14221452                    >
    14231453                </File>

  • trunk/abdev/BasicCompiler32/CParameter.cpp

    r206 r225  
    11#include "stdafx.h"
     2
     3#include <Compiler.h>
    24
    35#include "../BasicCompiler_Common/common.h"
    … …  
    7274
    7375                    //push esp
    74                     op_push( REG_ESP );
     76                    compiler.codeGenerator.op_push( REG_ESP );
    7577
    7678                    nCountOfTempObjects++;
    … …  
    111113                //call free
    112114                extern const UserProc *pSub_free;
    113                 op_call(pSub_free);
     115                compiler.codeGenerator.op_call(pSub_free);
    114116            }
    115117            else{
    … …  
    118120                    //pop ... 上位32ビット
    119121                    //pop ... 下位32ビット
    120                     op_add_esp( PTR_SIZE * 3 );
     122                    compiler.codeGenerator.op_add_esp( PTR_SIZE * 3 );
    121123                }
    122124                else{
    123125                    //pop ... 参照を消す
    124126                    //pop ... 値を消す
    125                     op_add_esp( PTR_SIZE * 2 );
     127                    compiler.codeGenerator.op_add_esp( PTR_SIZE * 2 );
    126128                }
    127129            }
    … …  
    134136
    135137    //push object_size
    136     op_push_V(object_size);
     138    compiler.codeGenerator.op_push_V(object_size);
    137139
    138140    //call calloc
    139141    extern const UserProc *pSub_calloc;
    140     op_call(pSub_calloc);
     142    compiler.codeGenerator.op_call(pSub_calloc);
    141143
    142144    //push eax（ここでプッシュされた値が実際にパラメータとして引き渡される）
    143     op_push(REG_EAX);
     145    compiler.codeGenerator.op_push(REG_EAX);
    144146
    145147    //push eax
    146     op_push(REG_EAX);
     148    compiler.codeGenerator.op_push(REG_EAX);
    147149
    148150    Type calcType;
    … …  
    332334
    333335                    //mov eax, dword ptr[esp+offset]
    334                     op_mov_RM(
     336                    compiler.codeGenerator.op_mov_RM(
    335337                        sizeof(long),
    336338                        REG_EAX,
    … …  
    340342
    341343                    //push eax
    342                     op_push(REG_EAX);
     344                    compiler.codeGenerator.op_push(REG_EAX);
    343345                }
    344346                else{
    … …  
    378380
    379381                            //push eax
    380                             op_push(REG_EAX);
     382                            compiler.codeGenerator.op_push(REG_EAX);
    381383                    }
    382384                }

  • trunk/abdev/BasicCompiler32/Compile_Calc.cpp

    r206 r225  
    1414    if(OldType==DEF_DOUBLE){
    1515        //fld qword ptr[esp]
    16         op_fld_ptr_esp(DEF_DOUBLE);
     16        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    1717
    1818        //add esp,8
    19         op_add_esp(8);
     19        compiler.codeGenerator.op_add_esp(8);
    2020    }
    2121    else if(OldType==DEF_SINGLE){
    2222        //fld dword ptr[esp]
    23         op_fld_ptr_esp(DEF_SINGLE);
     23        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    2424
    2525        //add esp,4
    26         op_add_esp(4);
     26        compiler.codeGenerator.op_add_esp(4);
    2727    }
    2828    else if(OldType==DEF_LONG){
    2929        //fild dword ptr[esp]
    30         op_fld_ptr_esp(DEF_LONG);
     30        compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    3131
    3232        //add esp,4
    33         op_add_esp(4);
     33        compiler.codeGenerator.op_add_esp(4);
    3434    }
    3535    else if(OldType==DEF_DWORD){
    3636        //pop eax
    37         op_pop(REG_EAX);
     37        compiler.codeGenerator.op_pop(REG_EAX);
    3838
    3939        //push 0
    40         op_push_V(0);
     40        compiler.codeGenerator.op_push_V(0);
    4141
    4242        //push eax
    43         op_push(REG_EAX);
     43        compiler.codeGenerator.op_push(REG_EAX);
    4444
    4545        //fild qword ptr[esp]
    46         OpBuffer[obp++]=(char)0xDF;
    47         OpBuffer[obp++]=(char)0x2C;
    48         OpBuffer[obp++]=(char)0x24;
     46        compiler.codeGenerator.PutOld(
     47            (char)0xDF,
     48            (char)0x2C,
     49            (char)0x24
     50        );
    4951
    5052        //add esp,8
    51         op_add_esp(8);
     53        compiler.codeGenerator.op_add_esp(8);
    5254    }
    5355}
    … …  
    5860    else if(OldType==DEF_SINGLE){
    5961        //fld dword ptr[esp]
    60         op_fld_ptr_esp(DEF_SINGLE);
     62        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    6163
    6264        //sub esp,4
    63         op_sub_esp(4);
     65        compiler.codeGenerator.op_sub_esp(4);
    6466
    6567        //fstp qword ptr[esp]
    66         OpBuffer[obp++]=(char)0xDD;
    67         OpBuffer[obp++]=(char)0x1C;
    68         OpBuffer[obp++]=(char)0x24;
     68        compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
    6969    }
    7070    else if(OldType==DEF_INT64||OldType==DEF_QWORD){
    … …  
    7272
    7373        //fild qword ptr[esp]
    74         op_fld_ptr_esp(DEF_INT64);
     74        compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    7575
    7676        //fstp qword ptr[esp]
    77         OpBuffer[obp++]=(char)0xDD;
    78         OpBuffer[obp++]=(char)0x1C;
    79         OpBuffer[obp++]=(char)0x24;
     77        compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
    8078    }
    8179    else if(IsWholeNumberType(OldType)){
    … …  
    8785            if(OldType==DEF_INTEGER || (Smoothie::IsUnicode()&&OldType==DEF_CHAR)){
    8886                //pop eax
    89                 op_pop(REG_EAX);
     87                compiler.codeGenerator.op_pop(REG_EAX);
    9088
    9189                //movsx eax,ax
    92                 OpBuffer[obp++]=(char)0x0F;
    93                 OpBuffer[obp++]=(char)0xBF;
    94                 OpBuffer[obp++]=(char)0xC0;
     90                compiler.codeGenerator.op_movsx_R32R16( REG_EAX );
    9591
    9692                //push eax
    97                 op_push(REG_EAX);
     93                compiler.codeGenerator.op_push(REG_EAX);
    9894            }
    9995            else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){
    10096                //pop eax
    101                 op_pop(REG_EAX);
     97                compiler.codeGenerator.op_pop(REG_EAX);
    10298
    10399                //movsx eax,al
    104                 OpBuffer[obp++]=(char)0x0F;
    105                 OpBuffer[obp++]=(char)0xBE;
    106                 OpBuffer[obp++]=(char)0xC0;
     100                compiler.codeGenerator.op_movsx_R32R8( REG_EAX );
    107101
    108102                //push eax
    109                 op_push(REG_EAX);
     103                compiler.codeGenerator.op_push(REG_EAX);
    110104            }
    111105
    112106            //fild dword ptr[esp]
    113             op_fld_ptr_esp(DEF_LONG);
     107            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    114108
    115109            //sub esp,4
    116             op_sub_esp(4);
     110            compiler.codeGenerator.op_sub_esp(4);
    117111        }
    118112        else{
    … …  
    120114
    121115            //pop eax
    122             op_pop(REG_EAX);
     116            compiler.codeGenerator.op_pop(REG_EAX);
    123117
    124118            //push 0
    125             op_push_V(0);
     119            compiler.codeGenerator.op_push_V(0);
    126120
    127121            //push eax
    128             op_push(REG_EAX);
     122            compiler.codeGenerator.op_push(REG_EAX);
    129123
    130124            //fild qword ptr[esp]
    131             OpBuffer[obp++]=(char)0xDF;
    132             OpBuffer[obp++]=(char)0x2C;
    133             OpBuffer[obp++]=(char)0x24;
     125            compiler.codeGenerator.PutOld(
     126                (char)0xDF,
     127                (char)0x2C,
     128                (char)0x24
     129            );
    134130        }
    135131
    136132        //fstp qword ptr[esp]
    137         OpBuffer[obp++]=(char)0xDD;
    138         OpBuffer[obp++]=(char)0x1C;
    139         OpBuffer[obp++]=(char)0x24;
     133        compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
    140134    }
    141135    else SetError(9,NULL,cp);
    … …  
    147141    else if(OldType==DEF_DOUBLE){
    148142        //fld qword ptr[esp]
    149         op_fld_ptr_esp(DEF_DOUBLE);
     143        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    150144
    151145        //add esp,4
    152         op_add_esp(4);
     146        compiler.codeGenerator.op_add_esp(4);
    153147
    154148        //fstp dword ptr[esp]
    155         OpBuffer[obp++]=(char)0xD9;
    156         OpBuffer[obp++]=(char)0x1C;
    157         OpBuffer[obp++]=(char)0x24;
     149        compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
    158150    }
    159151    else if(OldType==DEF_INT64||OldType==DEF_QWORD){
    … …  
    161153
    162154        //fild qword ptr[esp]
    163         op_fld_ptr_esp(DEF_INT64);
     155        compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    164156
    165157        //add esp,4
    166         op_add_esp(4);
     158        compiler.codeGenerator.op_add_esp(4);
    167159
    168160        //fstp dword ptr[esp]
    169         OpBuffer[obp++]=(char)0xD9;
    170         OpBuffer[obp++]=(char)0x1C;
    171         OpBuffer[obp++]=(char)0x24;
     161        compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
    172162    }
    173163    else if(IsWholeNumberType(OldType)){
    … …  
    179169            if(OldType==DEF_INTEGER || (Smoothie::IsUnicode()&&OldType==DEF_CHAR)){
    180170                //pop eax
    181                 op_pop(REG_EAX);
     171                compiler.codeGenerator.op_pop(REG_EAX);
    182172
    183173                //movsx eax,ax
    184                 OpBuffer[obp++]=(char)0x0F;
    185                 OpBuffer[obp++]=(char)0xBF;
    186                 OpBuffer[obp++]=(char)0xC0;
     174                compiler.codeGenerator.op_movsx_R32R16( REG_EAX );
    187175
    188176                //push eax
    189                 op_push(REG_EAX);
     177                compiler.codeGenerator.op_push(REG_EAX);
    190178            }
    191179            else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){
    192180                //pop eax
    193                 op_pop(REG_EAX);
     181                compiler.codeGenerator.op_pop(REG_EAX);
    194182
    195183                //movsx eax,al
    196                 OpBuffer[obp++]=(char)0x0F;
    197                 OpBuffer[obp++]=(char)0xBE;
    198                 OpBuffer[obp++]=(char)0xC0;
     184                compiler.codeGenerator.op_movsx_R32R8( REG_EAX );
    199185
    200186                //push eax
    201                 op_push(REG_EAX);
     187                compiler.codeGenerator.op_push(REG_EAX);
    202188            }
    203189
    204190            //fild dword ptr[esp]
    205             op_fld_ptr_esp(DEF_LONG);
     191            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    206192        }
    207193        else{
    … …  
    209195
    210196            //fild dword ptr[esp]
    211             op_fld_ptr_esp(DEF_LONG);
     197            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    212198        }
    213199
    214200        //fstp dword ptr[esp]
    215         OpBuffer[obp++]=(char)0xD9;
    216         OpBuffer[obp++]=(char)0x1C;
    217         OpBuffer[obp++]=(char)0x24;
     201        compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
    218202    }
    219203    else SetError(9,NULL,cp);
    … …  
    227211    else if(OldType==DEF_DOUBLE){
    228212        //fld qword ptr[esp]
    229         op_fld_ptr_esp(DEF_DOUBLE);
     213        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    230214
    231215        //fistp qword ptr[esp]
    232         op_fistp_ptr_esp( sizeof(_int64) );
     216        compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    233217    }
    234218    else if(OldType==DEF_SINGLE){
    235219        //fld dword ptr[esp]
    236         op_fld_ptr_esp(DEF_SINGLE);
     220        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    237221
    238222        //sub esp,4
    239         op_sub_esp(4);
     223        compiler.codeGenerator.op_sub_esp(4);
    240224
    241225        //fistp qword ptr[esp]
    242         op_fistp_ptr_esp( sizeof(_int64) );
     226        compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    243227    }
    244228    else if(IsWholeNumberType(OldType)){
    … …  
    249233
    250234            //pop eax
    251             op_pop(REG_EAX);
     235            compiler.codeGenerator.op_pop(REG_EAX);
    252236
    253237            //cdq
    254             op_cdq();
     238            compiler.codeGenerator.op_cdq();
    255239
    256240            //push edx
    257             op_push(REG_EDX);
     241            compiler.codeGenerator.op_push(REG_EDX);
    258242
    259243            //push eax
    260             op_push(REG_EAX);
     244            compiler.codeGenerator.op_push(REG_EAX);
    261245        }
    262246        else{
    … …  
    264248
    265249            //pop eax
    266             op_pop(REG_EAX);
     250            compiler.codeGenerator.op_pop(REG_EAX);
    267251
    268252            //push 0
    269             op_push_V(0);
     253            compiler.codeGenerator.op_push_V(0);
    270254
    271255            //push eax
    272             op_push(REG_EAX);
     256            compiler.codeGenerator.op_push(REG_EAX);
    273257        }
    274258    }
    … …  
    281265
    282266        //fld qword ptr[esp]
    283         op_fld_ptr_esp(DEF_DOUBLE);
     267        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    284268
    285269        //add esp,4
    286         op_add_esp(4);
     270        compiler.codeGenerator.op_add_esp(4);
    287271
    288272        //fistp dword ptr[esp]
    289         op_fistp_ptr_esp( sizeof(long) );
     273        compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    290274    }
    291275    else if(OldType==DEF_SINGLE){
    292276        //fld dword ptr[esp]
    293         op_fld_ptr_esp(DEF_SINGLE);
     277        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    294278
    295279        //fistp dword ptr[esp]
    296         op_fistp_ptr_esp( sizeof(long) );
     280        compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    297281    }
    298282    else if(OldType==DEF_INT64||OldType==DEF_QWORD){
    299283        //pop eax
    300         op_pop(REG_EAX);
     284        compiler.codeGenerator.op_pop(REG_EAX);
    301285
    302286        //add esp,4
    303         op_add_esp(4);
     287        compiler.codeGenerator.op_add_esp(4);
    304288
    305289        //push eax
    306         op_push(REG_EAX);
     290        compiler.codeGenerator.op_push(REG_EAX);
    307291    }
    308292}
    … …  
    314298    else if(OldType==DEF_SBYTE || (Smoothie::IsUnicode()==false&&OldType==DEF_CHAR)){
    315299        //pop eax
    316         op_pop(REG_EAX);
     300        compiler.codeGenerator.op_pop(REG_EAX);
    317301
    318302        //movsx eax,al
    319         OpBuffer[obp++]=(char)0x0F;
    320         OpBuffer[obp++]=(char)0xBE;
    321         OpBuffer[obp++]=(char)0xC0;
     303        compiler.codeGenerator.op_movsx_R32R8( REG_EAX );
    322304
    323305        //push eax
    324         op_push(REG_EAX);
     306        compiler.codeGenerator.op_push(REG_EAX);
    325307    }
    326308    else{
    … …  
    328310
    329311        //pop eax
    330         op_pop(REG_EAX);
     312        compiler.codeGenerator.op_pop(REG_EAX);
    331313
    332314        //and eax,0000FFFFh
    333         OpBuffer[obp++]=(char)0x25;
    334         *((long *)(OpBuffer+obp))=0x0000FFFF;
    335         obp+=sizeof(long);
     315        compiler.codeGenerator.op_and_RV( REG_EAX, 0x0000FFFF );
    336316
    337317        //push eax
    338         op_push(REG_EAX);
     318        compiler.codeGenerator.op_push(REG_EAX);
    339319    }
    340320}
    … …  
    346326
    347327    //pop eax
    348     op_pop(REG_EAX);
     328    compiler.codeGenerator.op_pop(REG_EAX);
    349329
    350330    //and eax,000000FFh
    351     OpBuffer[obp++]=(char)0x25;
    352     *((long *)(OpBuffer+obp))=0x000000FF;
    353     obp+=sizeof(long);
     331    compiler.codeGenerator.op_and_RV( REG_EAX, 0x000000FF );
    354332
    355333    //push eax
    356     op_push(REG_EAX);
     334    compiler.codeGenerator.op_push(REG_EAX);
    357335}
    358336
    … …  
    370348    if(type==DEF_DOUBLE){
    371349        //fld qword ptr[esp]
    372         op_fld_ptr_esp(DEF_DOUBLE);
     350        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    373351
    374352        //add esp,8
    375         op_add_esp(8);
     353        compiler.codeGenerator.op_add_esp(8);
    376354    }
    377355    else if(type==DEF_SINGLE){
    378356        //fld dword ptr[esp]
    379         op_fld_ptr_esp(DEF_SINGLE);
     357        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    380358
    381359        //add esp,4
    382         op_add_esp(4);
     360        compiler.codeGenerator.op_add_esp(4);
    383361    }
    384362    else if( Is64Type( type ) ){
    385363        //pop eax
    386         op_pop(REG_EAX);
     364        compiler.codeGenerator.op_pop(REG_EAX);
    387365
    388366        //pop edx
    389         op_pop(REG_EDX);
     367        compiler.codeGenerator.op_pop(REG_EDX);
    390368    }
    391369    else{
    392370        //pop eax
    393         op_pop(REG_EAX);
     371        compiler.codeGenerator.op_pop(REG_EAX);
    394372    }
    395373}
    … …  
    586564
    587565        //push eax
    588         op_push(REG_EAX);
     566        compiler.codeGenerator.op_push(REG_EAX);
    589567    }
    590568
    … …  
    639617
    640618        // call System.[TypeClass]._Create
    641         op_call( pUserProc );
     619        compiler.codeGenerator.op_call( pUserProc );
    642620
    643621        // push eax
    644         op_push( REG_EAX );
     622        compiler.codeGenerator.op_push( REG_EAX );
    645623
    646624        calcType = pUserProc->ReturnType();

  • trunk/abdev/BasicCompiler32/Compile_Calc_PushVar.cpp

    r206 r225  
    11#include "stdafx.h"
     2
     3#include <Compiler.h>
    24
    35#include "../BasicCompiler_Common/common.h"
    … …  
    810        if(pRelativeVar->bOffsetOffset){
    911            //fld ptr[ecx+offset]
    10             op_fld_base_offset(type,REG_ECX,(int)pRelativeVar->offset);
     12            compiler.codeGenerator.op_fld_base_offset(type,REG_ECX,(int)pRelativeVar->offset);
    1113            obp-=sizeof(long);
    1214            pobj_GlobalVarSchedule->add();
    … …  
    1517        else{
    1618            //mov ecx,offset
    17             op_mov_RV(REG_ECX,(int)pRelativeVar->offset);
     19            compiler.codeGenerator.op_mov_RV(REG_ECX,(int)pRelativeVar->offset);
    1820            obp-=sizeof(long);
    1921            pobj_GlobalVarSchedule->add();
    … …  
    2123
    2224            //fld ptr[ecx]
    23             op_fld_basereg(type,REG_ECX);
     25            compiler.codeGenerator.op_fld_basereg(type,REG_ECX);
    2426        }
    2527    }
    … …  
    3032        if(pRelativeVar->bOffsetOffset){
    3133            //fld ptr[ebp+ecx+offset]
    32             op_fld_base_offset_ex(type,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);
     34            compiler.codeGenerator.op_fld_base_offset_ex(type,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);
    3335            obp-=sizeof(long);
    3436            AddLocalVarAddrSchedule();
    … …  
    3739        else{
    3840            //fld ptr[ebp+offset]
    39             op_fld_base_offset(type,REG_EBP,(int)pRelativeVar->offset);
     41            compiler.codeGenerator.op_fld_base_offset(type,REG_EBP,(int)pRelativeVar->offset);
    4042            obp-=sizeof(long);
    4143            AddLocalVarAddrSchedule();
    … …  
    4648        if(pRelativeVar->bOffsetOffset){
    4749            //add ecx,qword ptr[ebp+offset]
    48             op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     50            compiler.codeGenerator.op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    4951            obp-=sizeof(long);
    5052            AddLocalVarAddrSchedule();
    … …  
    5355        else{
    5456            //mov ecx,qword ptr[ebp+offset]
    55             op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     57            compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    5658            obp-=sizeof(long);
    5759            AddLocalVarAddrSchedule();
    … …  
    6466directmem:
    6567        //fld ptr[ecx]
    66         op_fld_basereg(type,REG_ECX);
     68        compiler.codeGenerator.op_fld_basereg(type,REG_ECX);
    6769    }
    6870}
    … …  
    9698        if(pRelativeVar->bOffsetOffset){
    9799            //mov reg, ptr[ecx+offset]
    98             op_mov_RM(varSize,reg,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32);
     100            compiler.codeGenerator.op_mov_RM(varSize,reg,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32);
    99101        }
    100102        else{
    101103            //mov reg, ptr[offset]
    102             op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset + offsetOf64Head,MOD_DISP32);
     104            compiler.codeGenerator.op_mov_RM(varSize,reg,0,(int)pRelativeVar->offset + offsetOf64Head,MOD_DISP32);
    103105        }
    104106        obp-=sizeof(long);
    … …  
    109111        if(pRelativeVar->bOffsetOffset){
    110112            //add ecx,qword ptr[offset]
    111             op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
     113            compiler.codeGenerator.op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
    112114        }
    113115        else{
    114116            //mov ecx,qword ptr[offset]
    115             op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
     117            compiler.codeGenerator.op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
    116118        }
    117119        obp-=sizeof(long);
    … …  
    124126        if(pRelativeVar->bOffsetOffset){
    125127            //mov reg, ptr[ebp+ecx+offset]
    126             op_mov_RM_ex(varSize,reg,REG_EBP,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,USE_OFFSET);
     128            compiler.codeGenerator.op_mov_RM_ex(varSize,reg,REG_EBP,REG_ECX,(int)pRelativeVar->offset + offsetOf64Head,USE_OFFSET);
    127129        }
    128130        else{
    129131            //mov reg, ptr[ebp+offset]
    130             op_mov_RM(varSize,reg,REG_EBP,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32);
     132            compiler.codeGenerator.op_mov_RM(varSize,reg,REG_EBP,(int)pRelativeVar->offset + offsetOf64Head,MOD_BASE_DISP32);
    131133        }
    132134        obp-=sizeof(long);
    … …  
    137139        if(pRelativeVar->bOffsetOffset){
    138140            //add ecx,qword ptr[ebp+offset]
    139             op_add_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     141            compiler.codeGenerator.op_add_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    140142        }
    141143        else{
    142144            //mov ecx,qword ptr[ebp+offset]
    143             op_mov_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     145            compiler.codeGenerator.op_mov_RM(varSize,REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    144146        }
    145147        obp-=sizeof(long);
    … …  
    153155        if( is64Head ){
    154156            //mov reg, ptr[ecx]
    155             op_mov_RM(varSize,reg,REG_ECX,offsetOf64Head,MOD_BASE_DISP8);
     157            compiler.codeGenerator.op_mov_RM(varSize,reg,REG_ECX,offsetOf64Head,MOD_BASE_DISP8);
    156158        }
    157159        else{
    158160            //mov reg, ptr[ecx]
    159             op_mov_RM(varSize,reg,REG_ECX,0,MOD_BASE);
     161            compiler.codeGenerator.op_mov_RM(varSize,reg,REG_ECX,0,MOD_BASE);
    160162        }
    161163    }
    … …  
    164166
    165167
    166 
    167 
    168 void PushDoubleVariable(RELATIVE_VAR *pRelativeVar){
     168void PushLongVariable(RELATIVE_VAR *pRelativeVar){
    169169    if(pRelativeVar->dwKind==VAR_GLOBAL){
    170170        if(pRelativeVar->bOffsetOffset){
    171             //push dword ptr[ecx+offset+sizeof(long)]
    172             OpBuffer[obp++]=(char)0xFF;
    173             OpBuffer[obp++]=(char)0xB1;
    174             *((long *)(OpBuffer+obp))=pRelativeVar->offset+sizeof(long);
    175             pobj_GlobalVarSchedule->add();
    176             obp+=sizeof(long);
    177 
    178171            //push dword ptr[ecx+offset]
    179172            OpBuffer[obp++]=(char)0xFF;
    … …  
    184177        }
    185178        else{
    186             //push dword ptr[offset+sizeof(long)]
    187             OpBuffer[obp++]=(char)0xFF;
    188             OpBuffer[obp++]=(char)0x35;
    189             *((long *)(OpBuffer+obp))=pRelativeVar->offset+sizeof(long);
    190             pobj_GlobalVarSchedule->add();
    191             obp+=sizeof(long);
    192 
    193179            //push dword ptr[offset]
    194180            OpBuffer[obp++]=(char)0xFF;
    … …  
    200186    }
    201187    else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
    202         SetError(300,NULL,cp);
     188        //mov eax,dword ptr[offset]
     189        compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
     190        obp-=sizeof(long);
     191        pobj_GlobalVarSchedule->add();
     192        obp+=sizeof(long);
     193
     194        if(pRelativeVar->bOffsetOffset){
     195            //add eax,ecx
     196            compiler.codeGenerator.op_add_RR( REG_EAX, REG_ECX );
     197        }
     198
     199        //push dword ptr[eax]
     200        compiler.codeGenerator.op_push_M( REG_EAX );
    203201    }
    204202    else if(pRelativeVar->dwKind==VAR_LOCAL){
    205203        if(pRelativeVar->bOffsetOffset){
    206             //add ecx,offset+sizeof(long)
     204            //add ecx,offset
    207205            OpBuffer[obp++]=(char)0x81;
    208206            OpBuffer[obp++]=(char)0xC1;
    209             *((long *)(OpBuffer+obp))=pRelativeVar->offset+sizeof(long);
     207            *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    210208            AddLocalVarAddrSchedule();
    211209            obp+=sizeof(long);
    212210
    213211            //push dword ptr[ebp+ecx]
    214             OpBuffer[obp++]=(char)0xFF;
    215             OpBuffer[obp++]=(char)0x74;
    216             OpBuffer[obp++]=(char)0x0D;
    217             OpBuffer[obp++]=(char)0x00;
    218 
    219             //sub ecx,sizeof(long)
    220             OpBuffer[obp++]=(char)0x83;
    221             OpBuffer[obp++]=(char)0xE9;
    222             OpBuffer[obp++]=(char)0x04;
    223 
    224             //push dword ptr[ebp+ecx]
    225             OpBuffer[obp++]=(char)0xFF;
    226             OpBuffer[obp++]=(char)0x74;
    227             OpBuffer[obp++]=(char)0x0D;
    228             OpBuffer[obp++]=(char)0x00;
    229         }
    230         else{
    231             //push dword ptr[ebp+offset+sizeof(long)]
    232             OpBuffer[obp++]=(char)0xFF;
    233             OpBuffer[obp++]=(char)0xB5;
    234             *((long *)(OpBuffer+obp))=pRelativeVar->offset+sizeof(long);
    235             AddLocalVarAddrSchedule();
    236             obp+=sizeof(long);
    237 
     212            compiler.codeGenerator.PutOld(
     213                (char)0xFF,
     214                (char)0x74,
     215                (char)0x0D,
     216                (char)0x00
     217            );
     218        }
     219        else{
    238220            //push dword ptr[ebp+offset]
    239221            OpBuffer[obp++]=(char)0xFF;
    … …  
    254236        if(pRelativeVar->bOffsetOffset){
    255237            //add eax,ecx
    256             OpBuffer[obp++]=(char)0x03;
    257             OpBuffer[obp++]=(char)0xC1;
    258         }
    259 
    260         //push dword ptr[eax+sizeof(long)]
    261         OpBuffer[obp++]=(char)0xFF;
    262         OpBuffer[obp++]=(char)0x70;
    263         OpBuffer[obp++]=(char)0x04;
     238            compiler.codeGenerator.op_add_RR( REG_EAX, REG_ECX );
     239        }
    264240
    265241        //push dword ptr[eax]
    266         OpBuffer[obp++]=(char)0xFF;
    267         OpBuffer[obp++]=(char)0x30;
    268     }
    269     else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
    270         //push dword ptr[ecx+sizeof(long)]
    271         OpBuffer[obp++]=(char)0xFF;
    272         OpBuffer[obp++]=(char)0xB1;
    273         *((long *)(OpBuffer+obp))=sizeof(long);
    274         obp+=sizeof(long);
    275 
    276         //push dword ptr[ecx]
    277         OpBuffer[obp++]=(char)0xFF;
    278         OpBuffer[obp++]=(char)0x31;
    279     }
    280 }
    281 void PushLongVariable(RELATIVE_VAR *pRelativeVar){
    282     if(pRelativeVar->dwKind==VAR_GLOBAL){
    283         if(pRelativeVar->bOffsetOffset){
    284             //push dword ptr[ecx+offset]
    285             OpBuffer[obp++]=(char)0xFF;
    286             OpBuffer[obp++]=(char)0xB1;
    287             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    288             pobj_GlobalVarSchedule->add();
    289             obp+=sizeof(long);
    290         }
    291         else{
    292             //push dword ptr[offset]
    293             OpBuffer[obp++]=(char)0xFF;
    294             OpBuffer[obp++]=(char)0x35;
    295             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    296             pobj_GlobalVarSchedule->add();
    297             obp+=sizeof(long);
    298         }
    299     }
    300     else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
    301         //mov eax,dword ptr[offset]
    302         op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
    303         obp-=sizeof(long);
    304         pobj_GlobalVarSchedule->add();
    305         obp+=sizeof(long);
    306 
    307         if(pRelativeVar->bOffsetOffset){
    308             //add eax,ecx
    309             OpBuffer[obp++]=(char)0x03;
    310             OpBuffer[obp++]=(char)0xC1;
    311         }
    312 
    313         //push dword ptr[eax]
    314         OpBuffer[obp++]=(char)0xFF;
    315         OpBuffer[obp++]=(char)0x30;
    316     }
    317     else if(pRelativeVar->dwKind==VAR_LOCAL){
    318         if(pRelativeVar->bOffsetOffset){
    319             //add ecx,offset
    320             OpBuffer[obp++]=(char)0x81;
    321             OpBuffer[obp++]=(char)0xC1;
    322             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    323             AddLocalVarAddrSchedule();
    324             obp+=sizeof(long);
    325 
    326             //push dword ptr[ebp+ecx]
    327             OpBuffer[obp++]=(char)0xFF;
    328             OpBuffer[obp++]=(char)0x74;
    329             OpBuffer[obp++]=(char)0x0D;
    330             OpBuffer[obp++]=(char)0x00;
    331         }
    332         else{
    333             //push dword ptr[ebp+offset]
    334             OpBuffer[obp++]=(char)0xFF;
    335             OpBuffer[obp++]=(char)0xB5;
    336             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    337             AddLocalVarAddrSchedule();
    338             obp+=sizeof(long);
    339         }
    340     }
    341     else if(pRelativeVar->dwKind==VAR_REFLOCAL){
    342         //mov eax,dword ptr[ebp+offset]
    343         OpBuffer[obp++]=(char)0x8B;
    344         OpBuffer[obp++]=(char)0x85;
    345         *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    346         AddLocalVarAddrSchedule();
    347         obp+=sizeof(long);
    348 
    349         if(pRelativeVar->bOffsetOffset){
    350             //add eax,ecx
    351             OpBuffer[obp++]=(char)0x03;
    352             OpBuffer[obp++]=(char)0xC1;
    353         }
    354 
    355         //push dword ptr[eax]
    356         OpBuffer[obp++]=(char)0xFF;
    357         OpBuffer[obp++]=(char)0x30;
     242        compiler.codeGenerator.op_push_M( REG_EAX );
    358243    }
    359244    else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
    360245        //push dword ptr[ecx]
    361         OpBuffer[obp++]=(char)0xFF;
    362         OpBuffer[obp++]=(char)0x31;
     246        compiler.codeGenerator.op_push_M( REG_ECX );
    363247    }
    364248}
    365 void PushIntegerVariable(RELATIVE_VAR *pRelativeVar){
    366     if(pRelativeVar->dwKind==VAR_GLOBAL){
    367         if(pRelativeVar->bOffsetOffset){
    368             //movsx eax,word ptr[ecx+offset]
    369             OpBuffer[obp++]=(char)0x0F;
    370             OpBuffer[obp++]=(char)0xBF;
    371             OpBuffer[obp++]=(char)0x81;
    372             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    373             pobj_GlobalVarSchedule->add();
    374             obp+=sizeof(long);
    375         }
    376         else{
    377             //movsx eax,word ptr[offset]
    378             OpBuffer[obp++]=(char)0x0F;
    379             OpBuffer[obp++]=(char)0xBF;
    380             OpBuffer[obp++]=(char)0x05;
    381             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    382             pobj_GlobalVarSchedule->add();
    383             obp+=sizeof(long);
    384         }
    385     }
    386     else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
    387         //mov ebx,dword ptr[offset]
    388         op_mov_RM( sizeof(long), REG_EBX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
    389         obp-=sizeof(long);
    390         pobj_GlobalVarSchedule->add();
    391         obp+=sizeof(long);
    392 
    393         if(pRelativeVar->bOffsetOffset){
    394             //add ebx,ecx
    395             OpBuffer[obp++]=(char)0x03;
    396             OpBuffer[obp++]=(char)0xD9;
    397         }
    398 
    399         //movsx eax,word ptr[ebx]
    400         OpBuffer[obp++]=(char)0x0F;
    401         OpBuffer[obp++]=(char)0xBF;
    402         OpBuffer[obp++]=(char)0x03;
    403     }
    404     else if(pRelativeVar->dwKind==VAR_LOCAL){
    405         if(pRelativeVar->bOffsetOffset){
    406             //add ecx,offset
    407             OpBuffer[obp++]=(char)0x81;
    408             OpBuffer[obp++]=(char)0xC1;
    409             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    410             AddLocalVarAddrSchedule();
    411             obp+=sizeof(long);
    412 
    413             //movsx eax,word ptr[ebp+ecx]
    414             OpBuffer[obp++]=(char)0x0F;
    415             OpBuffer[obp++]=(char)0xBF;
    416             OpBuffer[obp++]=(char)0x44;
    417             OpBuffer[obp++]=(char)0x0D;
    418             OpBuffer[obp++]=(char)0x00;
    419         }
    420         else{
    421             //movsx eax,word ptr[ebp+offset]
    422             OpBuffer[obp++]=(char)0x0F;
    423             OpBuffer[obp++]=(char)0xBF;
    424             OpBuffer[obp++]=(char)0x85;
    425             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    426             AddLocalVarAddrSchedule();
    427             obp+=sizeof(long);
    428         }
    429     }
    430     else if(pRelativeVar->dwKind==VAR_REFLOCAL){
    431         //mov ebx,dword ptr[ebp+offset]
    432         OpBuffer[obp++]=(char)0x8B;
    433         OpBuffer[obp++]=(char)0x9D;
    434         *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    435         AddLocalVarAddrSchedule();
    436         obp+=sizeof(long);
    437 
    438         if(pRelativeVar->bOffsetOffset){
    439             //add ebx,ecx
    440             OpBuffer[obp++]=(char)0x03;
    441             OpBuffer[obp++]=(char)0xD9;
    442         }
    443 
    444         //movsx eax,word ptr[ebx]
    445         OpBuffer[obp++]=(char)0x0F;
    446         OpBuffer[obp++]=(char)0xBF;
    447         OpBuffer[obp++]=(char)0x03;
    448     }
    449     else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
    450         //movsx eax,word ptr[ecx]
    451         OpBuffer[obp++]=(char)0x0F;
    452         OpBuffer[obp++]=(char)0xBF;
    453         OpBuffer[obp++]=(char)0x01;
    454     }
    455 
    456     //push eax
    457     op_push(REG_EAX);
    458 }
    459 void PushWordVariable(RELATIVE_VAR *pRelativeVar){
    460     //xor eax,eax（eaxを0に初期化する）
    461     op_zero_reg(REG_EAX);
    462 
    463     if(pRelativeVar->dwKind==VAR_GLOBAL){
    464         if(pRelativeVar->bOffsetOffset){
    465             //mov ax,word ptr[ecx+offset]
    466             OpBuffer[obp++]=(char)0x66;
    467             OpBuffer[obp++]=(char)0x8B;
    468             OpBuffer[obp++]=(char)0x81;
    469             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    470             pobj_GlobalVarSchedule->add();
    471             obp+=sizeof(long);
    472         }
    473         else{
    474             //mov ax,word ptr[offset]
    475             OpBuffer[obp++]=(char)0x66;
    476             OpBuffer[obp++]=(char)0xA1;
    477             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    478             pobj_GlobalVarSchedule->add();
    479             obp+=sizeof(long);
    480         }
    481     }
    482     else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
    483         //mov ebx,dword ptr[offset]
    484         op_mov_RM( sizeof(long), REG_EBX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
    485         obp-=sizeof(long);
    486         pobj_GlobalVarSchedule->add();
    487         obp+=sizeof(long);
    488 
    489         if(pRelativeVar->bOffsetOffset){
    490             //add ebx,ecx
    491             OpBuffer[obp++]=(char)0x03;
    492             OpBuffer[obp++]=(char)0xD9;
    493         }
    494 
    495         //mov ax,word ptr[ebx]
    496         OpBuffer[obp++]=(char)0x66;
    497         OpBuffer[obp++]=(char)0x8B;
    498         OpBuffer[obp++]=(char)0x03;
    499     }
    500     else if(pRelativeVar->dwKind==VAR_LOCAL){
    501         if(pRelativeVar->bOffsetOffset){
    502             //add ecx,offset
    503             OpBuffer[obp++]=(char)0x81;
    504             OpBuffer[obp++]=(char)0xC1;
    505             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    506             AddLocalVarAddrSchedule();
    507             obp+=sizeof(long);
    508 
    509             //mov ax,word ptr[ebp+ecx]
    510             OpBuffer[obp++]=(char)0x66;
    511             OpBuffer[obp++]=(char)0x8B;
    512             OpBuffer[obp++]=(char)0x44;
    513             OpBuffer[obp++]=(char)0x0D;
    514             OpBuffer[obp++]=(char)0x00;
    515         }
    516         else{
    517             //mov ax,word ptr[ebp+offset]
    518             OpBuffer[obp++]=(char)0x66;
    519             OpBuffer[obp++]=(char)0x8B;
    520             OpBuffer[obp++]=(char)0x85;
    521             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    522             AddLocalVarAddrSchedule();
    523             obp+=sizeof(long);
    524         }
    525     }
    526     else if(pRelativeVar->dwKind==VAR_REFLOCAL){
    527         //mov ebx,dword ptr[ebp+offset]
    528         OpBuffer[obp++]=(char)0x8B;
    529         OpBuffer[obp++]=(char)0x9D;
    530         *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    531         AddLocalVarAddrSchedule();
    532         obp+=sizeof(long);
    533 
    534         if(pRelativeVar->bOffsetOffset){
    535             //add ebx,ecx
    536             OpBuffer[obp++]=(char)0x03;
    537             OpBuffer[obp++]=(char)0xD9;
    538         }
    539 
    540         //mov ax,word ptr[ebx]
    541         OpBuffer[obp++]=(char)0x66;
    542         OpBuffer[obp++]=(char)0x8B;
    543         OpBuffer[obp++]=(char)0x03;
    544     }
    545     else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
    546         //mov ax,word ptr[ecx]
    547         OpBuffer[obp++]=(char)0x66;
    548         OpBuffer[obp++]=(char)0x8B;
    549         OpBuffer[obp++]=(char)0x01;
    550     }
    551 
    552     //push eax
    553     op_push(REG_EAX);
    554 }
    555 void PushCharVariable(RELATIVE_VAR *pRelativeVar){
    556     if(pRelativeVar->dwKind==VAR_GLOBAL){
    557         if(pRelativeVar->bOffsetOffset){
    558             //movsx eax,byte ptr[ecx+offset]
    559             OpBuffer[obp++]=(char)0x0F;
    560             OpBuffer[obp++]=(char)0xBE;
    561             OpBuffer[obp++]=(char)0x81;
    562             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    563             pobj_GlobalVarSchedule->add();
    564             obp+=sizeof(long);
    565         }
    566         else{
    567             //movsx eax,byte ptr[offset]
    568             OpBuffer[obp++]=(char)0x0F;
    569             OpBuffer[obp++]=(char)0xBE;
    570             OpBuffer[obp++]=(char)0x05;
    571             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    572             pobj_GlobalVarSchedule->add();
    573             obp+=sizeof(long);
    574         }
    575     }
    576     else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
    577         //mov ebx,dword ptr[offset]
    578         op_mov_RM( sizeof(long), REG_EBX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
    579         obp-=sizeof(long);
    580         pobj_GlobalVarSchedule->add();
    581         obp+=sizeof(long);
    582 
    583         if(pRelativeVar->bOffsetOffset){
    584             //add ebx,ecx
    585             OpBuffer[obp++]=(char)0x03;
    586             OpBuffer[obp++]=(char)0xD9;
    587         }
    588 
    589         //movsx eax,byte ptr[ebx]
    590         OpBuffer[obp++]=(char)0x0F;
    591         OpBuffer[obp++]=(char)0xBE;
    592         OpBuffer[obp++]=(char)0x03;
    593     }
    594     else if(pRelativeVar->dwKind==VAR_LOCAL){
    595         if(pRelativeVar->bOffsetOffset){
    596             //add ecx,offset
    597             OpBuffer[obp++]=(char)0x81;
    598             OpBuffer[obp++]=(char)0xC1;
    599             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    600             AddLocalVarAddrSchedule();
    601             obp+=sizeof(long);
    602 
    603             //movsx eax,byte ptr[ebp+ecx]
    604             OpBuffer[obp++]=(char)0x0F;
    605             OpBuffer[obp++]=(char)0xBE;
    606             OpBuffer[obp++]=(char)0x44;
    607             OpBuffer[obp++]=(char)0x0D;
    608             OpBuffer[obp++]=(char)0x00;
    609         }
    610         else{
    611             //movsx eax,byte ptr[ebp+offset]
    612             OpBuffer[obp++]=(char)0x0F;
    613             OpBuffer[obp++]=(char)0xBE;
    614             OpBuffer[obp++]=(char)0x85;
    615             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    616             AddLocalVarAddrSchedule();
    617             obp+=sizeof(long);
    618         }
    619     }
    620     else if(pRelativeVar->dwKind==VAR_REFLOCAL){
    621         //mov ebx,dword ptr[ebp+offset]
    622         OpBuffer[obp++]=(char)0x8B;
    623         OpBuffer[obp++]=(char)0x9D;
    624         *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    625         AddLocalVarAddrSchedule();
    626         obp+=sizeof(long);
    627 
    628         if(pRelativeVar->bOffsetOffset){
    629             //add ebx,ecx
    630             OpBuffer[obp++]=(char)0x03;
    631             OpBuffer[obp++]=(char)0xD9;
    632         }
    633 
    634         //movsx eax,byte ptr[ebx]
    635         OpBuffer[obp++]=(char)0x0F;
    636         OpBuffer[obp++]=(char)0xBE;
    637         OpBuffer[obp++]=(char)0x03;
    638     }
    639     else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
    640         //movsx eax,byte ptr[ecx]
    641         OpBuffer[obp++]=(char)0x0F;
    642         OpBuffer[obp++]=(char)0xBE;
    643         OpBuffer[obp++]=(char)0x01;
    644     }
    645 
    646     //push eax
    647     op_push(REG_EAX);
    648 }
    649 void PushByteVariable(RELATIVE_VAR *pRelativeVar){
    650     //xor eax,eax（eaxを0に初期化する）
    651     op_zero_reg(REG_EAX);
    652 
    653     if(pRelativeVar->dwKind==VAR_GLOBAL){
    654         if(pRelativeVar->bOffsetOffset){
    655             //mov al,byte ptr[ecx+offset]
    656             OpBuffer[obp++]=(char)0x8A;
    657             OpBuffer[obp++]=(char)0x81;
    658             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    659             pobj_GlobalVarSchedule->add();
    660             obp+=sizeof(long);
    661         }
    662         else{
    663             //mov al,byte ptr[offset]
    664             OpBuffer[obp++]=(char)0xA0;
    665             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    666             pobj_GlobalVarSchedule->add();
    667             obp+=sizeof(long);
    668         }
    669     }
    670     else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
    671         //mov ebx,dword ptr[offset]
    672         op_mov_RM( sizeof(long), REG_EBX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
    673         obp-=sizeof(long);
    674         pobj_GlobalVarSchedule->add();
    675         obp+=sizeof(long);
    676 
    677         if(pRelativeVar->bOffsetOffset){
    678             //add ebx,ecx
    679             OpBuffer[obp++]=(char)0x03;
    680             OpBuffer[obp++]=(char)0xD9;
    681         }
    682 
    683         //mov al,byte ptr[ebx]
    684         OpBuffer[obp++]=(char)0x8A;
    685         OpBuffer[obp++]=(char)0x03;
    686     }
    687     else if(pRelativeVar->dwKind==VAR_LOCAL){
    688         if(pRelativeVar->bOffsetOffset){
    689             //add ecx,offset
    690             OpBuffer[obp++]=(char)0x81;
    691             OpBuffer[obp++]=(char)0xC1;
    692             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    693             AddLocalVarAddrSchedule();
    694             obp+=sizeof(long);
    695 
    696             //mov al,byte ptr[ebp+ecx]
    697             OpBuffer[obp++]=(char)0x8A;
    698             OpBuffer[obp++]=(char)0x44;
    699             OpBuffer[obp++]=(char)0x0D;
    700             OpBuffer[obp++]=(char)0x00;
    701         }
    702         else{
    703             //mov al,byte ptr[ebp+offset]
    704             OpBuffer[obp++]=(char)0x8A;
    705             OpBuffer[obp++]=(char)0x85;
    706             *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    707             AddLocalVarAddrSchedule();
    708             obp+=sizeof(long);
    709         }
    710     }
    711     else if(pRelativeVar->dwKind==VAR_REFLOCAL){
    712         //mov ebx,dword ptr[ebp+offset]
    713         OpBuffer[obp++]=(char)0x8B;
    714         OpBuffer[obp++]=(char)0x9D;
    715         *((long *)(OpBuffer+obp))=pRelativeVar->offset;
    716         AddLocalVarAddrSchedule();
    717         obp+=sizeof(long);
    718 
    719         if(pRelativeVar->bOffsetOffset){
    720             //add ebx,ecx
    721             OpBuffer[obp++]=(char)0x03;
    722             OpBuffer[obp++]=(char)0xD9;
    723         }
    724 
    725         //mov al,byte ptr[ebx]
    726         OpBuffer[obp++]=(char)0x8A;
    727         OpBuffer[obp++]=(char)0x03;
    728     }
    729     else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
    730         //mov al,byte ptr[ecx]
    731         OpBuffer[obp++]=(char)0x8A;
    732         OpBuffer[obp++]=(char)0x01;
    733     }
    734 
    735     //push eax
    736     op_push(REG_EAX);
    737 }

  • trunk/abdev/BasicCompiler32/Compile_CallProc.cpp

    r206 r225  
    1515    //call _System_GetEip
    1616    extern const UserProc *pSub_System_GetEip;
    17     op_call(pSub_System_GetEip);
     17    compiler.codeGenerator.op_call(pSub_System_GetEip);
    1818
    1919    //push eax
    20     op_push(REG_EAX);
     20    compiler.codeGenerator.op_push(REG_EAX);
    2121
    2222    //push ebp
    23     op_push(REG_EBP);
     23    compiler.codeGenerator.op_push(REG_EBP);
    2424
    2525    //call _DebugSys_SaveContext
    2626    extern const UserProc *pSub_DebugSys_SaveContext;
    27     op_call(pSub_DebugSys_SaveContext);
     27    compiler.codeGenerator.op_call(pSub_DebugSys_SaveContext);
    2828}
    2929
    … …  
    260260
    261261        //push object_size
    262         op_push_V(object_size);
     262        compiler.codeGenerator.op_push_V(object_size);
    263263
    264264        //call calloc
    265265        extern const UserProc *pSub_calloc;
    266         op_call(pSub_calloc);
     266        compiler.codeGenerator.op_call(pSub_calloc);
    267267
    268268        //push eax
    269         op_push(REG_EAX);
     269        compiler.codeGenerator.op_push(REG_EAX);
    270270    }
    271271
    … …  
    297297
    298298                // 参照を実体ポインタにする
    299                 op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
     299                compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
    300300            }
    301301        }
    … …  
    306306
    307307                //mov ecx,dword ptr[esp+ParmSize]
    308                 op_mov_RM( sizeof(long), REG_ECX, REG_ESP, ParmSize + tempSize, MOD_BASE_DISP32 );
     308                compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ESP, ParmSize + tempSize, MOD_BASE_DISP32 );
    309309            }
    310310            else{
    … …  
    315315
    316316        //push ecx
    317         op_push(REG_ECX);
     317        compiler.codeGenerator.op_push(REG_ECX);
    318318    }
    319319
    … …  
    347347
    348348        //call ProcAddr
    349         op_call(pUserProc);
     349        compiler.codeGenerator.op_call(pUserProc);
    350350    }
    351351
    352352    if(pUserProc->IsCdecl()){
    353353        //add esp,ParmSize
    354         op_add_esp(ParmSize);
     354        compiler.codeGenerator.op_add_esp(ParmSize);
    355355    }
    356356
    … …  
    408408    if(pDllProc->IsCdecl()){
    409409        //add esp,ParmSize
    410         op_add_esp(ParmSize);
     410        compiler.codeGenerator.op_add_esp(ParmSize);
    411411    }
    412412

  • trunk/abdev/BasicCompiler32/Compile_Func.cpp

    r206 r225  
    3333    if( resultType.IsDouble() ){
    3434        //fld qword ptr[esp]
    35         op_fld_ptr_esp(DEF_DOUBLE);
     35        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    3636
    3737        //fnstcw word ptr[esp]
    … …  
    7676
    7777        //add esp,4
    78         op_add_esp(4);
     78        compiler.codeGenerator.op_add_esp(4);
    7979    }
    8080    else if( resultType.IsSingle() ){
    8181        //fld dword ptr[esp]
    82         op_fld_ptr_esp(DEF_SINGLE);
     82        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    8383
    8484        //sub esp,4
    85         op_sub_esp(4);
     85        compiler.codeGenerator.op_sub_esp(4);
    8686
    8787        //fnstcw word ptr[esp]
    … …  
    126126
    127127        //add esp,4
    128         op_add_esp(4);
     128        compiler.codeGenerator.op_add_esp(4);
    129129    }
    130130    else if( resultType.Is64() ){
    131131        //pop eax
    132         op_pop(REG_EAX);
     132        compiler.codeGenerator.op_pop(REG_EAX);
    133133
    134134        //add esp,4
    135         op_add_esp(4);
     135        compiler.codeGenerator.op_add_esp(4);
    136136
    137137        //push eax
    138         op_push(REG_EAX);
     138        compiler.codeGenerator.op_push(REG_EAX);
    139139    }
    140140
    141141    //pop eax
    142     op_pop(REG_EAX);
     142    compiler.codeGenerator.op_pop(REG_EAX);
    143143}
    144144
    … …  
    151151
    152152    //pop eax
    153     op_pop(REG_EAX);
     153    compiler.codeGenerator.op_pop(REG_EAX);
    154154
    155155    //push 0
    … …  
    158158
    159159    //push eax
    160     op_push(REG_EAX);
     160    compiler.codeGenerator.op_push(REG_EAX);
    161161
    162162    //fild qword ptr[esp]
    … …  
    166166
    167167    //add esp,8
    168     op_add_esp(8);
     168    compiler.codeGenerator.op_add_esp(8);
    169169}
    170170void Opcode_Func_Len(const char *Parameter){
    … …  
    193193
    194194        //pop eax
    195         op_pop(REG_EAX);
     195        compiler.codeGenerator.op_pop(REG_EAX);
    196196
    197197        return;
    … …  
    270270
    271271                //mov ecx,eax
    272                 op_mov_RR(REG_ECX,REG_EAX);
     272                compiler.codeGenerator.op_mov_RR(REG_ECX,REG_EAX);
    273273
    274274                //参照タイプが整合しているかをチェック
    … …  
    277277                if(type.IsObjectPtr()){
    278278                    //mov ecx,dword ptr[ecx]
    279                     op_mov_RM(sizeof(long),REG_ECX,REG_ECX,0,MOD_BASE);
     279                    compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_ECX,0,MOD_BASE);
    280280                }
    281281            }
    … …  
    303303        //mov eax,dword ptr[edx+func_index]
    304304        if(i2*PTR_SIZE<=0x7F){
    305             op_mov_RM(sizeof(long),REG_EAX,REG_EDX,i2*PTR_SIZE,MOD_BASE_DISP8);
     305            compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,i2*PTR_SIZE,MOD_BASE_DISP8);
    306306        }
    307307        else{
    308             op_mov_RM(sizeof(long),REG_EAX,REG_EDX,i2*PTR_SIZE,MOD_BASE_DISP32);
     308            compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,i2*PTR_SIZE,MOD_BASE_DISP32);
    309309        }
    310310    }
    … …  
    331331
    332332    //mov eax,size
    333     op_mov_RV( REG_EAX, typeSize );
     333    compiler.codeGenerator.op_mov_RV( REG_EAX, typeSize );
    334334}
    335335void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn ){
    … …  
    362362
    363363        //mov eax,dword ptr[eax]
    364         op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
     364        compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
    365365
    366366        SetError(-120,NULL,cp);
    … …  
    397397
    398398        //mov eax,dword ptr[eax]
    399         op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
     399        compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
    400400    }
    401401    else{
    … …  
    416416    if(type==DEF_DOUBLE){
    417417        //pop eax
    418         op_pop(REG_EAX);
     418        compiler.codeGenerator.op_pop(REG_EAX);
    419419
    420420        //fld qword ptr[eax]
    … …  
    424424    else if(type==DEF_SINGLE||type==DEF_DWORD){
    425425        //pop eax
    426         op_pop(REG_EAX);
     426        compiler.codeGenerator.op_pop(REG_EAX);
    427427
    428428        //mov eax,dword ptr[eax]
    … …  
    432432    else if(type==DEF_QWORD){
    433433        //pop ecx
    434         op_pop(REG_ECX);
     434        compiler.codeGenerator.op_pop(REG_ECX);
    435435
    436436        //mov eax,dword ptr[ecx]
    437         op_mov_RM(sizeof(long),REG_EAX,REG_ECX,0,MOD_BASE);
     437        compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_ECX,0,MOD_BASE);
    438438
    439439        //mov edx,dword ptr[ecx+sizeof(long)]
    440         op_mov_RM(sizeof(long),REG_EDX,REG_ECX,sizeof(long),MOD_BASE_DISP8);
     440        compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EDX,REG_ECX,sizeof(long),MOD_BASE_DISP8);
    441441    }
    442442    else if(type==DEF_WORD){
    443443        //pop ebx
    444         op_pop(REG_EBX);
     444        compiler.codeGenerator.op_pop(REG_EBX);
    445445
    446446        //xor eax,eax
    … …  
    455455    else if(type==DEF_BYTE){
    456456        //pop ebx
    457         op_pop(REG_EBX);
     457        compiler.codeGenerator.op_pop(REG_EBX);
    458458
    459459        //xor eax,eax

  • trunk/abdev/BasicCompiler32/Compile_Object.cpp

    r206 r225  
    11#include "stdafx.h"
     2
     3#include <Compiler.h>
    24
    35#include "../BasicCompiler_Common/common.h"
    … …  
    2426
    2527        //push ebx
    26         op_push(REG_EBX);
     28        compiler.codeGenerator.op_push(REG_EBX);
    2729    }
    2830
    2931    // ※ここでプッシュされた値はコンストラクタのthisポインタとなる
    3032    //push eax
    31     op_push(REG_EAX);
     33    compiler.codeGenerator.op_push(REG_EAX);
    3234
    3335
    … …  
    7577
    7678    //pop eax
    77     op_pop(REG_EAX);
     79    compiler.codeGenerator.op_pop(REG_EAX);
    7880
    7981    if(bSomeObjects){
    8082        //pop ebx
    81         op_pop(REG_EBX);
     83        compiler.codeGenerator.op_pop(REG_EBX);
    8284
    8385        //add eax,TypeSize
    … …  
    8789
    8890        //sub ebx,1
    89         OpBuffer[obp++]=(char)0x83;
    90         OpBuffer[obp++]=(char)0xEB;
    91         OpBuffer[obp++]=(char)0x01;
     91        compiler.codeGenerator.op_sub_RV8(REG_EBX,1);
    9292
    9393        //jnz ↑
    … …  
    116116
    117117        //pop eax
    118         op_pop(REG_EAX);
     118        compiler.codeGenerator.op_pop(REG_EAX);
    119119
    120120        //※添え字上限値であることを考慮
    … …  
    142142
    143143        //push eax
    144         op_push(REG_EAX);
     144        compiler.codeGenerator.op_push(REG_EAX);
    145145    }
    146146    else{
    … …  
    164164        //call _System_GC_malloc_ForObject
    165165        extern const UserProc *pSub_System_GC_malloc_ForObject;
    166         op_call(pSub_System_GC_malloc_ForObject);
     166        compiler.codeGenerator.op_call(pSub_System_GC_malloc_ForObject);
    167167    }
    168168    else{
    … …  
    172172        //call _System_GC_malloc_ForObjectPtr
    173173        extern const UserProc *pSub_System_GC_malloc_ForObjectPtr;
    174         op_call(pSub_System_GC_malloc_ForObjectPtr);
     174        compiler.codeGenerator.op_call(pSub_System_GC_malloc_ForObjectPtr);
    175175    }
    176176
    … …  
    186186
    187187    //mov dword ptr[eax],ebx（オブジェクトの個数）
    188     OpBuffer[obp++]=(char)0x89;
    189     OpBuffer[obp++]=(char)0x18;
     188    compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE );
    190189
    191190    //add eax,sizeof(DWORD)
    … …  
    201200
    202201    //mov dword ptr[eax],ecx（オブジェクトのサイズ）
    203     OpBuffer[obp++]=(char)0x89;
    204     OpBuffer[obp++]=(char)0x08;
     202    compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
    205203
    206204    //add eax,sizeof(DWORD)
    … …  
    220218
    221219    //mov dword ptr[eax],ecx（デストラクタの関数ポインタ）
    222     OpBuffer[obp++]=(char)0x89;
    223     OpBuffer[obp++]=(char)0x08;
     220    compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
    224221
    225222    //add eax,sizeof(DWORD)
    … …  
    238235    // ※ここでプッシュされた値はNew演算子の戻り値となる
    239236    //push eax
    240     op_push(REG_EAX);
     237    compiler.codeGenerator.op_push(REG_EAX);
    241238
    242239
    … …  
    257254
    258255    //pop eax
    259     op_pop(REG_EAX);
     256    compiler.codeGenerator.op_pop(REG_EAX);
    260257
    261258    //sub eax,sizeof(DWORD)*3
    262     op_sub_RV8( REG_EAX, OBJECT_HEAD_SIZE );
     259    compiler.codeGenerator.op_sub_RV8( REG_EAX, OBJECT_HEAD_SIZE );
    263260
    264261    //push eax
    265     op_push(REG_EAX);
     262    compiler.codeGenerator.op_push(REG_EAX);
    266263
    267264
    … …  
    313310
    314311    //push ecx
    315     op_push(REG_ECX);
     312    compiler.codeGenerator.op_push(REG_ECX);
    316313
    317314    //push edx
    318     op_push(REG_EDX);
     315    compiler.codeGenerator.op_push(REG_EDX);
    319316
    320317    //push ecx（Thisポインタ   ※隠れた第一パラメータ）
    321     op_push(REG_ECX);
     318    compiler.codeGenerator.op_push(REG_ECX);
    322319
    323320    //call edx
    … …  
    326323
    327324    //pop edx
    328     op_pop(REG_EDX);
     325    compiler.codeGenerator.op_pop(REG_EDX);
    329326
    330327    //pop ecx
    331     op_pop(REG_ECX);
     328    compiler.codeGenerator.op_pop(REG_ECX);
    332329
    333330    //add ecx,esi
    334     OpBuffer[obp++]=(char)0x03;
    335     OpBuffer[obp++]=(char)0xCE;
     331    compiler.codeGenerator.op_add_RR( REG_ECX, REG_ESI );
    336332
    337333    //sub ebx,1
    338     OpBuffer[obp++]=(char)0x83;
    339     OpBuffer[obp++]=(char)0xEB;
    340     OpBuffer[obp++]=(char)0x01;
     334    compiler.codeGenerator.op_sub_RV8(REG_EBX,1);
    341335
    342336    //jnz ↑
    … …  
    354348        //call _System_GC_free_for_SweepingDelete
    355349        extern const UserProc *pSub_System_GC_free_for_SweepingDelete;
    356         op_call(pSub_System_GC_free_for_SweepingDelete);
     350        compiler.codeGenerator.op_call(pSub_System_GC_free_for_SweepingDelete);
    357351    }
    358352    else{
    359353        //call free
    360354        extern const UserProc *pSub_free;
    361         op_call(pSub_free);
     355        compiler.codeGenerator.op_call(pSub_free);
    362356    }
    363357}

  • trunk/abdev/BasicCompiler32/Compile_ProcOp.cpp

    r206 r225  
    2323
    2424        //ret
    25         op_ret();
     25        compiler.codeGenerator.op_ret();
    2626    }
    2727    else if( userProc.GetName() == "_System_InitDllGlobalVariables" ){
    … …  
    3333        if(!bDll){
    3434            //ret
    35             op_ret();
     35            compiler.codeGenerator.op_ret();
    3636
    3737            return;
    … …  
    5757        //_System_StartupProgramの呼び出し
    5858        extern const UserProc *pSub_System_StartupProgram;
    59         op_call(pSub_System_StartupProgram);
     59        compiler.codeGenerator.op_call(pSub_System_StartupProgram);
    6060
    6161        //クラスに属する静的メンバを定義
    … …  
    6868
    6969        //ret
    70         op_ret();
     70        compiler.codeGenerator.op_ret();
    7171    }
    7272    else if( userProc.GetName() == "_System_InitStaticLocalVariables" ){
    … …  
    9191
    9292        //ret
    93         op_ret();
     93        compiler.codeGenerator.op_ret();
    9494    }
    9595    else if( userProc.GetName() == "_System_Call_Destructor_of_GlobalObject" ){
    … …  
    105105
    106106        //ret
    107         op_ret();
     107        compiler.codeGenerator.op_ret();
    108108    }
    109109    else if( userProc.GetName() == "_System_GetSp" ){
    110110        //mov eax,esp
    111         op_mov_RR(REG_EAX,REG_ESP);
     111        compiler.codeGenerator.op_mov_RR(REG_EAX,REG_ESP);
    112112
    113113        //add eax,PTR_SIZE
    114         op_add_RV8(REG_EAX,PTR_SIZE);
     114        compiler.codeGenerator.op_add_RV8(REG_EAX,PTR_SIZE);
    115115
    116116        //ret
    117         op_ret();
     117        compiler.codeGenerator.op_ret();
    118118    }
    119119    else if( userProc.GetName() == "_allrem" ){
    … …  
    290290    compiler.GetNamespaceSupporter().SetImportedNamespaces( pUserProc->GetImportedNamespaces() );
    291291
     292    // コード生成対象を選択
     293    compiler.codeGenerator.Select( (const_cast<UserProc *>(pUserProc))->GetNativeCode() );
     294
    292295    if(pUserProc->IsSystem()){
    293296        ////////////////////
    … …  
    369372
    370373    //sub esp,AllLocalVarSize（スケジュール）
    371     op_sub_esp(0xFFFFFFFF);
     374    compiler.codeGenerator.op_sub_esp(0xFFFFFFFF);
    372375    LocalVarSchedule=obp-sizeof(long);
    373376
    374377    //push ebp
    375     op_push(REG_EBP);
     378    compiler.codeGenerator.op_push(REG_EBP);
    376379
    377380    //mov ebp,esp
    … …  
    380383
    381384    //push ebx
    382     op_push(REG_EBX);
     385    compiler.codeGenerator.op_push(REG_EBX);
    383386
    384387    //push esi
    … …  
    460463        //call _DebugSys_StartProc
    461464        extern const UserProc *pSub_DebugSys_StartProc;
    462         op_call(pSub_DebugSys_StartProc);
     465        compiler.codeGenerator.op_call(pSub_DebugSys_StartProc);
    463466    }
    464467
    … …  
    543546
    544547                    //mov dword ptr[ecx],eax
    545                     OpBuffer[obp++]=(char)0x89;
    546                     OpBuffer[obp++]=(char)0x01;
     548                    compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ECX, 0, MOD_BASE );
    547549            }
    548550        }
    … …  
    653655        //call _DebugSys_EndProc
    654656        extern const UserProc *pSub_DebugSys_EndProc;
    655         op_call(pSub_DebugSys_EndProc);
     657        compiler.codeGenerator.op_call(pSub_DebugSys_EndProc);
    656658    }
    657659
    … …  
    672674            if( i3==DEF_OBJECT ){
    673675                //mov eax,dword ptr[eax]
    674                 op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
     676                compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
    675677            }
    676678        }
    … …  
    717719        else if(i3==DEF_INTEGER||i3==DEF_WORD || (Smoothie::IsUnicode()&&i3==DEF_CHAR)){
    718720            //xor eax,eax（eaxを0に初期化する）
    719             op_zero_reg(REG_EAX);
     721            compiler.codeGenerator.op_zero_reg(REG_EAX);
    720722
    721723            //mov ax,word ptr[ebp+offset]
    … …  
    729731        else if(i3==DEF_SBYTE||i3==DEF_BYTE||i3==DEF_BOOLEAN || (Smoothie::IsUnicode()==false&&i3==DEF_CHAR)){
    730732            //xor eax,eax（eaxを0に初期化する）
    731             op_zero_reg(REG_EAX);
     733            compiler.codeGenerator.op_zero_reg(REG_EAX);
    732734
    733735            //mov al,byte ptr[ebp+offset]
    … …  
    763765
    764766    //pop ebx
    765     op_pop(REG_EBX);
     767    compiler.codeGenerator.op_pop(REG_EBX);
    766768
    767769    if(bDebugCompile){
    768770        //cmp esp,ebp
    769         op_cmp_RR( REG_ESP, REG_EBP );
     771        compiler.codeGenerator.op_cmp_RR( REG_ESP, REG_EBP );
    770772
    771773        //jz 6（次のcallとbreakpointを飛び越す）
    … …  
    775777        //call _esp_error
    776778        extern const UserProc *pSub_esp_error;
    777         op_call( pSub_esp_error );
     779        compiler.codeGenerator.op_call( pSub_esp_error );
    778780
    779781        breakpoint;
    … …  
    785787
    786788    //pop ebp
    787     op_pop(REG_EBP);
     789    compiler.codeGenerator.op_pop(REG_EBP);
    788790
    789791    //add esp AllLocalVarSize
    790     op_add_esp(AllLocalVarSize-BaseOffset);
     792    compiler.codeGenerator.op_add_esp(AllLocalVarSize-BaseOffset);
    791793
    792794    if( BaseOffset==0 || pUserProc->IsCdecl() ){
    793795        //ret
    794         op_ret();
     796        compiler.codeGenerator.op_ret();
    795797    }
    796798    else{

  • trunk/abdev/BasicCompiler32/Compile_Set_Var.cpp

    r206 r225  
    22
    33#include <jenga/include/smoothie/Smoothie.h>
     4
     5#include <Compiler.h>
    46
    57#include "../BasicCompiler_Common/common.h"
    … …  
    2123
    2224                //mov ecx,object_size
    23                 op_mov_RV(REG_ECX,object_size);
     25                compiler.codeGenerator.op_mov_RV(REG_ECX,object_size);
    2426
    2527                //pop esi
    26                 op_pop(REG_ESI);
     28                compiler.codeGenerator.op_pop(REG_ESI);
    2729
    2830                //pop edi
    29                 op_pop(REG_EDI);
     31                compiler.codeGenerator.op_pop(REG_EDI);
    3032
    3133                if(bUseHeap){
    3234                    //mov eax,esi
    33                     op_mov_RR(REG_EAX,REG_ESI);
     35                    compiler.codeGenerator.op_mov_RR(REG_EAX,REG_ESI);
    3436                }
    3537
    3638                //rep movs byte ptr[edi],byte ptr[esi]
    37                 op_rep_movs(sizeof(BYTE));
     39                compiler.codeGenerator.op_rep_movs(sizeof(BYTE));
    3840
    3941                if(bUseHeap){
    4042                    //push eax
    41                     op_push(REG_EAX);
     43                    compiler.codeGenerator.op_push(REG_EAX);
    4244
    4345                    //call free
    4446                    extern const UserProc *pSub_free;
    45                     op_call(pSub_free);
     47                    compiler.codeGenerator.op_call(pSub_free);
    4648                }
    4749
    … …  
    6466
    6567            //push edx
    66             op_push( REG_EDX );
     68            compiler.codeGenerator.op_push( REG_EDX );
    6769
    6870            //push eax
    69             op_push( REG_EAX );
     71            compiler.codeGenerator.op_push( REG_EAX );
    7072
    7173            //fild qword ptr[esp]
    72             op_fld_ptr_esp(DEF_INT64);
     74            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    7375
    7476            //pop
    75             op_pop( REG_NON );
     77            compiler.codeGenerator.op_pop( REG_NON );
    7678
    7779            //pop
    78             op_pop( REG_NON );
     80            compiler.codeGenerator.op_pop( REG_NON );
    7981        }
    8082        else{
    8183            //push eax
    82             op_push( REG_EAX );
     84            compiler.codeGenerator.op_push( REG_EAX );
    8385
    8486            //fild qword ptr[esp]
    85             op_fld_ptr_esp(DEF_LONG);
     87            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    8688
    8789            //pop
    88             op_pop( REG_NON );
     90            compiler.codeGenerator.op_pop( REG_NON );
    8991        }
    9092    }
    … …  
    9395        if(pRelativeVar->bOffsetOffset){
    9496            //fstp ptr[ecx+offset]
    95             op_fstp_base_offset(VarType,REG_ECX,(int)pRelativeVar->offset);
     97            compiler.codeGenerator.op_fstp_base_offset(VarType,REG_ECX,(int)pRelativeVar->offset);
    9698            obp-=sizeof(long);
    9799            pobj_GlobalVarSchedule->add();
    … …  
    100102        else{
    101103            //mov ecx,offset
    102             op_mov_RV(REG_ECX,(int)pRelativeVar->offset);
     104            compiler.codeGenerator.op_mov_RV(REG_ECX,(int)pRelativeVar->offset);
    103105            obp-=sizeof(long);
    104106            pobj_GlobalVarSchedule->add();
    … …  
    106108
    107109            //fstp ptr[ecx]
    108             op_fstp_basereg(VarType,REG_ECX);
     110            compiler.codeGenerator.op_fstp_basereg(VarType,REG_ECX);
    109111        }
    110112    }
    … …  
    112114        if(pRelativeVar->bOffsetOffset){
    113115            //add ecx,qword ptr[offset]
    114             op_add_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
     116            compiler.codeGenerator.op_add_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
    115117        }
    116118        else{
    117119            //mov ecx,qword ptr[offset]
    118             op_mov_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
     120            compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
    119121        }
    120122        obp-=sizeof(long);
    … …  
    127129        if(pRelativeVar->bOffsetOffset){
    128130            //fstp ptr[ebp+ecx+offset]
    129             op_fstp_base_offset_ex(VarType,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);
     131            compiler.codeGenerator.op_fstp_base_offset_ex(VarType,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);
    130132        }
    131133        else{
    132134            //fstp ptr[ebp+offset]
    133             op_fstp_base_offset(VarType,REG_EBP,(int)pRelativeVar->offset);
     135            compiler.codeGenerator.op_fstp_base_offset(VarType,REG_EBP,(int)pRelativeVar->offset);
    134136        }
    135137        obp-=sizeof(long);
    … …  
    140142        if(pRelativeVar->bOffsetOffset){
    141143            //add ecx,qword ptr[ebp+offset]
    142             op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     144            compiler.codeGenerator.op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    143145        }
    144146        else{
    145147            //mov ecx,qword ptr[ebp+offset]
    146             op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     148            compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    147149        }
    148150        obp-=sizeof(long);
    … …  
    155157directmem:
    156158        //fstp ptr[ecx]
    157         op_fstp_basereg(VarType,REG_ECX);
     159        compiler.codeGenerator.op_fstp_basereg(VarType,REG_ECX);
    158160    }
    159161}
    … …  
    170172    else if(type==DEF_INT64||type==DEF_QWORD){
    171173        //cmp eax,0
    172         op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
     174        compiler.codeGenerator.op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
    173175
    174176        //setne al
    175         op_setne( REG_EAX );
     177        compiler.codeGenerator.op_setne( REG_EAX );
    176178
    177179        //cmp edx,0
    178         op_cmp_value(GetTypeSize(type,-1),REG_EDX,0);
     180        compiler.codeGenerator.op_cmp_value(GetTypeSize(type,-1),REG_EDX,0);
    179181
    180182        //setne cl
    181         op_setne( REG_ECX );
     183        compiler.codeGenerator.op_setne( REG_ECX );
    182184
    183185        //or al,cl
    184         op_or_RR( sizeof( _int8 ), REG_EAX, REG_ECX );
     186        compiler.codeGenerator.op_or_RR( sizeof( _int8 ), REG_EAX, REG_ECX );
    185187    }
    186188    else{
    … …  
    193195
    194196    //cmp eax,0
    195     op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
     197    compiler.codeGenerator.op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
    196198
    197199    //setne al
    198     op_setne( REG_EAX );
     200    compiler.codeGenerator.op_setne( REG_EAX );
    199201
    200202    SetWholeVariable( sizeof(char), DEF_BYTE, pRelative );
    … …  
    209211    if(IsSignedType(type)){
    210212        //cdq
    211         op_cdq();
     213        compiler.codeGenerator.op_cdq();
    212214    }
    213215    else{
    214216        //xor edx,edx
    215         op_zero_reg(REG_EDX);
     217        compiler.codeGenerator.op_zero_reg(REG_EDX);
    216218    }
    217219}
    … …  
    219221    if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
    220222        //movsx reg32,reg16
    221         op_movsx_R32R16(reg,reg);
     223        compiler.codeGenerator.op_movsx_R32R16(reg,reg);
    222224    }
    223225    else if(type==DEF_WORD){
    224226        //and reg,0000FFFFh
    225         op_and_RV(reg,(int)0x0000FFFF);
     227        compiler.codeGenerator.op_and_RV(reg,(int)0x0000FFFF);
    226228    }
    227229    else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    228230        //movsx reg32,reg8
    229         op_movsx_R32R8(reg,reg);
     231        compiler.codeGenerator.op_movsx_R32R8(reg,reg);
    230232    }
    231233    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
    232234        //and reg,000000FFh
    233         op_and_RV(reg,(int)0xFF);
     235        compiler.codeGenerator.op_and_RV(reg,(int)0xFF);
    234236    }
    235237}
    … …  
    237239    if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    238240        //movsx reg16,reg8
    239         op_movsx_R16R8(reg,reg);
     241        compiler.codeGenerator.op_movsx_R16R8(reg,reg);
    240242    }
    241243    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
    242244        //and reg,000000FFh
    243         op_and_RV(reg,(int)0xFF);
     245        compiler.codeGenerator.op_and_RV(reg,(int)0xFF);
    244246    }
    245247}
    … …  
    256258            //push
    257259            //push
    258             op_sub_esp( PTR_SIZE * 2 );
     260            compiler.codeGenerator.op_sub_esp( PTR_SIZE * 2 );
    259261
    260262            //fistp qword ptr[esp]
    261             op_fistp_ptr_esp( sizeof(_int64) );
     263            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    262264
    263265            //pop eax
    264             op_pop( REG_EAX );
     266            compiler.codeGenerator.op_pop( REG_EAX );
    265267
    266268            //pop edx
    267             op_pop( REG_EDX );
     269            compiler.codeGenerator.op_pop( REG_EDX );
    268270        }
    269271        else{
    … …  
    272274
    273275            //push
    274             op_push( REG_NON );
     276            compiler.codeGenerator.op_push( REG_NON );
    275277
    276278            //fistp dword ptr[esp]
    277             op_fistp_ptr_esp( sizeof(long) );
     279            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    278280
    279281            //pop eax
    280             op_pop( REG_EAX );
     282            compiler.codeGenerator.op_pop( REG_EAX );
    281283        }
    282284    }
    … …  
    310312
    311313        //mov ecx,eax
    312         op_mov_RR( REG_ECX, REG_EAX );
     314        compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EAX );
    313315
    314316        //add ecx,sizeof(long)
    315         op_add_RV8( REG_ECX, sizeof(long) );
     317        compiler.codeGenerator.op_add_RV8( REG_ECX, sizeof(long) );
    316318
    317319        //mov eax,edx
    318         op_mov_RR( REG_EAX, REG_EDX );
     320        compiler.codeGenerator.op_mov_RR( REG_EAX, REG_EDX );
    319321
    320322        SetWholeVariable(sizeof(long),DEF_LONG,pRelative);
    … …  
    326328        if(pRelative->bOffsetOffset){
    327329            //mov ptr[ecx+offset],eax/ax/al
    328             op_mov_MR(varSize,REG_EAX,REG_ECX,(int)pRelative->offset,MOD_BASE_DISP32);
     330            compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,REG_ECX,(int)pRelative->offset,MOD_BASE_DISP32);
    329331        }
    330332        else{
    331333            //mov ptr[offset],eax/ax/al
    332             op_mov_MR(varSize,REG_EAX,0,(int)pRelative->offset,MOD_DISP32);
     334            compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,0,(int)pRelative->offset,MOD_DISP32);
    333335        }
    334336        obp-=sizeof(long);
    … …  
    342344        if(pRelative->bOffsetOffset){
    343345            //add ecx,qword ptr[offset]
    344             op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
     346            compiler.codeGenerator.op_add_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
    345347        }
    346348        else{
    347349            //mov ecx,qword ptr[offset]
    348             op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
     350            compiler.codeGenerator.op_mov_RM(varSize,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
    349351        }
    350352        obp-=sizeof(long);
    … …  
    357359        if(pRelative->bOffsetOffset){
    358360            //mov ptr[ebp+ecx+offset],eax/ax/al
    359             op_mov_MR_ex(varSize,REG_EAX,REG_EBP,REG_ECX,(int)pRelative->offset,USE_OFFSET);
     361            compiler.codeGenerator.op_mov_MR_ex(varSize,REG_EAX,REG_EBP,REG_ECX,(int)pRelative->offset,USE_OFFSET);
    360362        }
    361363        else{
    362364            //mov ptr[ebp+offset],eax/ax/al
    363             op_mov_MR(varSize,REG_EAX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
     365            compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
    364366        }
    365367        obp-=sizeof(long);
    … …  
    370372        if(pRelative->bOffsetOffset){
    371373            //add ecx,ptr[ebp+offset]
    372             op_add_RM(PTR_SIZE,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
     374            compiler.codeGenerator.op_add_RM(PTR_SIZE,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
    373375        }
    374376        else{
    375377            //mov ecx,ptr[ebp+offset]
    376             op_mov_RM(PTR_SIZE,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
     378            compiler.codeGenerator.op_mov_RM(PTR_SIZE,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
    377379        }
    378380        obp-=sizeof(long);
    … …  
    386388
    387389        //mov ptr[ecx],eax/ax/al
    388         op_mov_MR(varSize,REG_EAX,REG_ECX,0,MOD_BASE);
    389     }
    390 }
     390        compiler.codeGenerator.op_mov_MR(varSize,REG_EAX,REG_ECX,0,MOD_BASE);
     391    }
     392}

  • trunk/abdev/BasicCompiler32/Compile_Statement.cpp

    r206 r225  
    110110        else if( resultType.IsStruct() ){
    111111            //mov ebx,eax
    112             op_mov_RR(REG_EBX,REG_EAX);
     112            compiler.codeGenerator.op_mov_RR(REG_EBX,REG_EAX);
    113113
    114114            FreeTempObject(REG_EBX,&resultType.GetClass());
    … …  
    144144    else if( tempType.IsDouble() ){
    145145        //fld qword ptr[esp]
    146         op_fld_ptr_esp(DEF_DOUBLE);
     146        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    147147
    148148        //push 0
    149         op_push_V(0);
     149        compiler.codeGenerator.op_push_V(0);
    150150
    151151        //fild dword ptr[esp]
    152         op_fld_ptr_esp(DEF_LONG);
     152        compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    153153
    154154        //add esp,sizeof(double)+sizeof(long)
    155         op_add_esp(sizeof(double)+sizeof(long));
     155        compiler.codeGenerator.op_add_esp(sizeof(double)+sizeof(long));
    156156
    157157        //fcompp
    158         OpBuffer[obp++]=(char)0xDE;
    159         OpBuffer[obp++]=(char)0xD9;
     158        compiler.codeGenerator.op_fcompp();
    160159
    161160        //fnstsw ax
    162         OpBuffer[obp++]=(char)0xDF;
    163         OpBuffer[obp++]=(char)0xE0;
     161        compiler.codeGenerator.op_fnstsw_ax();
    164162
    165163        //test ah,40
    166         OpBuffer[obp++]=(char)0xF6;
    167         OpBuffer[obp++]=(char)0xC4;
    168         OpBuffer[obp++]=(char)0x40;
     164        compiler.codeGenerator.op_test_ah( (char)0x40 );
    169165
    170166        //jne (endif、または else まで)
    … …  
    178174    else if( tempType.IsSingle() ){
    179175        //fld dword ptr[esp]
    180         op_fld_ptr_esp(DEF_SINGLE);
     176        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    181177
    182178        //push 0
    183         op_push_V(0);
     179        compiler.codeGenerator.op_push_V(0);
    184180
    185181        //fild dword ptr[esp]
    186         op_fld_ptr_esp(DEF_LONG);
     182        compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    187183
    188184        //add esp,sizeof(float)+sizeof(long)
    189         op_add_esp(sizeof(float)+sizeof(long));
     185        compiler.codeGenerator.op_add_esp(sizeof(float)+sizeof(long));
    190186
    191187        //fcompp
    192         OpBuffer[obp++]=(char)0xDE;
    193         OpBuffer[obp++]=(char)0xD9;
     188        compiler.codeGenerator.op_fcompp();
    194189
    195190        //fnstsw ax
    196         OpBuffer[obp++]=(char)0xDF;
    197         OpBuffer[obp++]=(char)0xE0;
     191        compiler.codeGenerator.op_fnstsw_ax();
    198192
    199193        //test ah,40
    200         OpBuffer[obp++]=(char)0xF6;
    201         OpBuffer[obp++]=(char)0xC4;
    202         OpBuffer[obp++]=(char)0x40;
     194        compiler.codeGenerator.op_test_ah( (char)0x40 );
    203195
    204196        //jne (endif、または else まで)
    … …  
    214206
    215207        //pop eax
    216         op_pop(REG_EAX);
     208        compiler.codeGenerator.op_pop(REG_EAX);
    217209
    218210        //pop ebx
    219         op_pop(REG_EBX);
     211        compiler.codeGenerator.op_pop(REG_EBX);
    220212
    221213        //cmp eax,0
    … …  
    258250
    259251        //pop eax
    260         op_pop(REG_EAX);
     252        compiler.codeGenerator.op_pop(REG_EAX);
    261253
    262254        //cmp eax,0
    … …  
    401393    else if( tempType.IsDouble() ){
    402394        //fld qword ptr[esp]
    403         op_fld_ptr_esp(DEF_DOUBLE);
     395        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    404396
    405397        //push 0
    406         op_push_V(0);
     398        compiler.codeGenerator.op_push_V(0);
    407399
    408400        //fild dword ptr[esp]
    409         op_fld_ptr_esp(DEF_LONG);
     401        compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    410402
    411403        //add esp,sizeof(double)+sizeof(long)
    412         op_add_esp(sizeof(double)+sizeof(long));
     404        compiler.codeGenerator.op_add_esp(sizeof(double)+sizeof(long));
    413405
    414406        //fcompp
    415         OpBuffer[obp++]=(char)0xDE;
    416         OpBuffer[obp++]=(char)0xD9;
     407        compiler.codeGenerator.op_fcompp();
    417408
    418409        //fnstsw ax
    419         OpBuffer[obp++]=(char)0xDF;
    420         OpBuffer[obp++]=(char)0xE0;
     410        compiler.codeGenerator.op_fnstsw_ax();
    421411
    422412        //test ah,40
    423         OpBuffer[obp++]=(char)0xF6;
    424         OpBuffer[obp++]=(char)0xC4;
    425         OpBuffer[obp++]=(char)0x40;
     413        compiler.codeGenerator.op_test_ah( (char)0x40 );
    426414
    427415        //jne (Wend まで)
    … …  
    435423    else if( tempType.IsSingle() ){
    436424        //fld dword ptr[esp]
    437         op_fld_ptr_esp(DEF_SINGLE);
     425        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    438426
    439427        //push 0
    440         op_push_V(0);
     428        compiler.codeGenerator.op_push_V(0);
    441429
    442430        //fild dword ptr[esp]
    443         op_fld_ptr_esp(DEF_LONG);
     431        compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    444432
    445433        //add esp,sizeof(float)+sizeof(long)
    446         op_add_esp(sizeof(float)+sizeof(long));
     434        compiler.codeGenerator.op_add_esp(sizeof(float)+sizeof(long));
    447435
    448436        //fcompp
    449         OpBuffer[obp++]=(char)0xDE;
    450         OpBuffer[obp++]=(char)0xD9;
     437        compiler.codeGenerator.op_fcompp();
    451438
    452439        //fnstsw ax
    453         OpBuffer[obp++]=(char)0xDF;
    454         OpBuffer[obp++]=(char)0xE0;
     440        compiler.codeGenerator.op_fnstsw_ax();
    455441
    456442        //test ah,40
    457         OpBuffer[obp++]=(char)0xF6;
    458         OpBuffer[obp++]=(char)0xC4;
    459         OpBuffer[obp++]=(char)0x40;
     443        compiler.codeGenerator.op_test_ah( (char)0x40 );
    460444
    461445        //jne (Wend まで)
    … …  
    471455
    472456        //pop eax
    473         op_pop(REG_EAX);
     457        compiler.codeGenerator.op_pop(REG_EAX);
    474458
    475459        //pop ebx
    476         op_pop(REG_EBX);
     460        compiler.codeGenerator.op_pop(REG_EBX);
    477461
    478462        //cmp eax,0
    … …  
    514498
    515499        //pop eax
    516         op_pop(REG_EAX);
     500        compiler.codeGenerator.op_pop(REG_EAX);
    517501
    518502        //cmp eax,0
    … …  
    616600
    617601    //pop eax
    618     op_pop(REG_EAX);
     602    compiler.codeGenerator.op_pop(REG_EAX);
    619603
    620604    //cmp eax,0
    … …  
    634618
    635619    //pop eax
    636     op_pop(REG_EAX);
     620    compiler.codeGenerator.op_pop(REG_EAX);
    637621
    638622    //jmp [カウンタ減少の場合の判定を飛び越す]
    … …  
    648632
    649633    //pop eax
    650     op_pop(REG_EAX);
     634    compiler.codeGenerator.op_pop(REG_EAX);
    651635
    652636    *((long *)(OpBuffer+i3))=obp-(i3+sizeof(long)); //jmpジャンプ先のオフセット値
    … …  
    737721            if( tempType.IsDouble() ){
    738722                //fld qword ptr[esp]
    739                 op_fld_ptr_esp(DEF_DOUBLE);
     723                compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    740724
    741725                //push 0
    742                 op_push_V(0);
     726                compiler.codeGenerator.op_push_V(0);
    743727
    744728                //fild dword ptr[esp]
    745                 op_fld_ptr_esp(DEF_LONG);
     729                compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    746730
    747731                //add esp,sizeof(double)+sizeof(long)
    748                 op_add_esp(sizeof(double)+sizeof(long));
     732                compiler.codeGenerator.op_add_esp(sizeof(double)+sizeof(long));
    749733
    750734                //fcompp
    751                 OpBuffer[obp++]=(char)0xDE;
    752                 OpBuffer[obp++]=(char)0xD9;
     735                compiler.codeGenerator.op_fcompp();
    753736
    754737                //fnstsw ax
    755                 OpBuffer[obp++]=(char)0xDF;
    756                 OpBuffer[obp++]=(char)0xE0;
     738                compiler.codeGenerator.op_fnstsw_ax();
    757739
    758740                //test ah,40
    759                 OpBuffer[obp++]=(char)0xF6;
    760                 OpBuffer[obp++]=(char)0xC4;
    761                 OpBuffer[obp++]=(char)0x40;
     741                compiler.codeGenerator.op_test_ah( (char)0x40 );
    762742
    763743                if(basbuf[i3]=='0'){
    … …  
    778758            else if( tempType.IsSingle() ){
    779759                //fld dword ptr[esp]
    780                 op_fld_ptr_esp(DEF_SINGLE);
     760                compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    781761
    782762                //push 0
    783                 op_push_V(0);
     763                compiler.codeGenerator.op_push_V(0);
    784764
    785765                //fild dword ptr[esp]
    786                 op_fld_ptr_esp(DEF_LONG);
     766                compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    787767
    788768                //add esp,sizeof(float)+sizeof(long)
    789                 op_add_esp(sizeof(float)+sizeof(long));
     769                compiler.codeGenerator.op_add_esp(sizeof(float)+sizeof(long));
    790770
    791771                //fcompp
    792                 OpBuffer[obp++]=(char)0xDE;
    793                 OpBuffer[obp++]=(char)0xD9;
     772                compiler.codeGenerator.op_fcompp();
    794773
    795774                //fnstsw ax
    796                 OpBuffer[obp++]=(char)0xDF;
    797                 OpBuffer[obp++]=(char)0xE0;
     775                compiler.codeGenerator.op_fnstsw_ax();
    798776
    799777                //test ah,40
    800                 OpBuffer[obp++]=(char)0xF6;
    801                 OpBuffer[obp++]=(char)0xC4;
    802                 OpBuffer[obp++]=(char)0x40;
     778                compiler.codeGenerator.op_test_ah( (char)0x40 );
    803779
    804780                if(basbuf[i3]=='0'){
    … …  
    821797
    822798                //pop eax
    823                 op_pop(REG_EAX);
     799                compiler.codeGenerator.op_pop(REG_EAX);
    824800
    825801                //pop ebx
    826                 op_pop(REG_EBX);
     802                compiler.codeGenerator.op_pop(REG_EBX);
    827803
    828804                //cmp eax,0
    … …  
    877853            else{
    878854                //pop eax
    879                 op_pop(REG_EAX);
     855                compiler.codeGenerator.op_pop(REG_EAX);
    880856
    881857                //cmp eax,0
    … …  
    10271003            if(sw==0){
    10281004                //add esp,CaseTypeSize
    1029                 op_add_esp(CaseTypeSize);
     1005                compiler.codeGenerator.op_add_esp(CaseTypeSize);
    10301006            }
    10311007            break;
    … …  
    11011077
    11021078                    //pop edx
    1103                     op_pop(REG_EDX);
     1079                    compiler.codeGenerator.op_pop(REG_EDX);
    11041080
    11051081                    //mov ecx,dword ptr[esp]
    1106                     op_mov_RM(sizeof(long),REG_ECX,REG_ESP,0,MOD_BASE);
     1082                    compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_ESP,0,MOD_BASE);
    11071083
    11081084                    //push edx
    1109                     op_push(REG_EDX);
     1085                    compiler.codeGenerator.op_push(REG_EDX);
    11101086
    11111087                    //push ecx
    1112                     op_push(REG_ECX);
     1088                    compiler.codeGenerator.op_push(REG_ECX);
    11131089
    11141090                    //call operator_proc    ※ ==演算子
    1115                     op_call(pUserProc);
     1091                    compiler.codeGenerator.op_call(pUserProc);
    11161092
    11171093                    //test eax,eax
    1118                     op_test(REG_EAX,REG_EAX);
     1094                    compiler.codeGenerator.op_test(REG_EAX,REG_EAX);
    11191095
    11201096                    //jne ...
    … …  
    11281104
    11291105                    //fld qword ptr[esp]
    1130                     op_fld_ptr_esp(DEF_DOUBLE);
     1106                    compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    11311107
    11321108                    //add esp,CaseTypeSize
    1133                     op_add_esp(CaseTypeSize);
     1109                    compiler.codeGenerator.op_add_esp(CaseTypeSize);
    11341110
    11351111                    //fld qword ptr[esp]
    1136                     op_fld_ptr_esp(DEF_DOUBLE);
     1112                    compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    11371113
    11381114                    //fcompp
    1139                     OpBuffer[obp++]=(char)0xDE;
    1140                     OpBuffer[obp++]=(char)0xD9;
     1115                    compiler.codeGenerator.op_fcompp();
    11411116
    11421117                    //fnstsw ax
    1143                     OpBuffer[obp++]=(char)0xDF;
    1144                     OpBuffer[obp++]=(char)0xE0;
     1118                    compiler.codeGenerator.op_fnstsw_ax();
    11451119
    11461120                    //test ah,40
    1147                     OpBuffer[obp++]=(char)0xF6;
    1148                     OpBuffer[obp++]=(char)0xC4;
    1149                     OpBuffer[obp++]=(char)0x40;
     1121                    compiler.codeGenerator.op_test_ah( (char)0x40 );
    11501122
    11511123                    //jne ...
    … …  
    11591131
    11601132                    //fld dword ptr[esp]
    1161                     op_fld_ptr_esp(DEF_SINGLE);
     1133                    compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    11621134
    11631135                    //add esp,CaseTypeSize
    1164                     op_add_esp(CaseTypeSize);
     1136                    compiler.codeGenerator.op_add_esp(CaseTypeSize);
    11651137
    11661138                    //fld dword ptr[esp]
    1167                     op_fld_ptr_esp(DEF_SINGLE);
     1139                    compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    11681140
    11691141                    //fcompp
    1170                     OpBuffer[obp++]=(char)0xDE;
    1171                     OpBuffer[obp++]=(char)0xD9;
     1142                    compiler.codeGenerator.op_fcompp();
    11721143
    11731144                    //fnstsw ax
    1174                     OpBuffer[obp++]=(char)0xDF;
    1175                     OpBuffer[obp++]=(char)0xE0;
     1145                    compiler.codeGenerator.op_fnstsw_ax();
    11761146
    11771147                    //test ah,40
    1178                     OpBuffer[obp++]=(char)0xF6;
    1179                     OpBuffer[obp++]=(char)0xC4;
    1180                     OpBuffer[obp++]=(char)0x40;
     1148                    compiler.codeGenerator.op_test_ah( (char)0x40 );
    11811149
    11821150                    //jne ...
    … …  
    11901158
    11911159                    //pop ebx
    1192                     op_pop(REG_EBX);
     1160                    compiler.codeGenerator.op_pop(REG_EBX);
    11931161
    11941162                    //mov eax,dword ptr[esp]
    … …  
    12731241
    12741242    //add esp,CaseTypeSize
    1275     op_add_esp(CaseTypeSize);
     1243    compiler.codeGenerator.op_add_esp(CaseTypeSize);
    12761244}
    12771245
    … …  
    13211289
    13221290        //ret
    1323         op_ret();
     1291        compiler.codeGenerator.op_ret();
    13241292    }
    13251293    else{
    … …  
    13981366
    13991367        //pop eax
    1400         op_pop(REG_EAX);
     1368        compiler.codeGenerator.op_pop(REG_EAX);
    14011369
    14021370        //fstp qword ptr[eax]
    … …  
    14081376
    14091377        //pop ebx
    1410         op_pop(REG_EBX);
     1378        compiler.codeGenerator.op_pop(REG_EBX);
    14111379
    14121380        //pop eax
    1413         op_pop(REG_EAX);
     1381        compiler.codeGenerator.op_pop(REG_EAX);
    14141382
    14151383        //mov dword ptr[eax],ebx
    1416         OpBuffer[obp++]=(char)0x89;
    1417         OpBuffer[obp++]=(char)0x18;
     1384        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE );
    14181385    }
    14191386    else if(type==DEF_QWORD){
    … …  
    14211388
    14221389        //pop ecx
    1423         op_pop(REG_ECX);
     1390        compiler.codeGenerator.op_pop(REG_ECX);
    14241391
    14251392        //pop ebx
    1426         op_pop(REG_EBX);
     1393        compiler.codeGenerator.op_pop(REG_EBX);
    14271394
    14281395        //pop eax
    1429         op_pop(REG_EAX);
     1396        compiler.codeGenerator.op_pop(REG_EAX);
    14301397
    14311398        //mov dword ptr[eax],ecx
    1432         OpBuffer[obp++]=(char)0x89;
    1433         OpBuffer[obp++]=(char)0x08;
     1399        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
    14341400
    14351401        //mov dword ptr[eax+sizeof(long)],ebx
    1436         OpBuffer[obp++]=(char)0x89;
    1437         OpBuffer[obp++]=(char)0x58;
    1438         OpBuffer[obp++]=(char)0x04;
     1402        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0x04, MOD_BASE_DISP8 );
    14391403    }
    14401404    else if(type==DEF_DWORD){
    … …  
    14421406
    14431407        //pop ebx
    1444         op_pop(REG_EBX);
     1408        compiler.codeGenerator.op_pop(REG_EBX);
    14451409
    14461410        //pop eax
    1447         op_pop(REG_EAX);
     1411        compiler.codeGenerator.op_pop(REG_EAX);
    14481412
    14491413        //mov dword ptr[eax],ebx
    1450         OpBuffer[obp++]=(char)0x89;
    1451         OpBuffer[obp++]=(char)0x18;
     1414        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE );
    14521415    }
    14531416    else if(type==DEF_WORD){
    … …  
    14551418
    14561419        //pop ebx
    1457         op_pop(REG_EBX);
     1420        compiler.codeGenerator.op_pop(REG_EBX);
    14581421
    14591422        //pop eax
    1460         op_pop(REG_EAX);
     1423        compiler.codeGenerator.op_pop(REG_EAX);
    14611424
    14621425        //mov word ptr[eax],bx
    … …  
    14691432
    14701433        //pop ebx
    1471         op_pop(REG_EBX);
     1434        compiler.codeGenerator.op_pop(REG_EBX);
    14721435
    14731436        //pop eax
    1474         op_pop(REG_EAX);
     1437        compiler.codeGenerator.op_pop(REG_EAX);
    14751438
    14761439        //mov byte ptr[eax],bl

  • trunk/abdev/BasicCompiler32/Compile_Var.cpp

    r224 r225  
    2828
    2929    //pop ebx
    30     op_pop(REG_EBX);
     30    compiler.codeGenerator.op_pop(REG_EBX);
    3131
    3232    if( resultType.PtrLevel() ){
    … …  
    3636        if(typeSize>=2){
    3737            //imul ebx,i2
    38             op_imul_RV( REG_EBX, typeSize );
     38            compiler.codeGenerator.op_imul_RV( REG_EBX, typeSize );
    3939        }
    4040    }
    … …  
    4646
    4747    //pop ecx
    48     op_pop(REG_ECX);
     48    compiler.codeGenerator.op_pop(REG_ECX);
    4949
    5050    //add ecx,ebx
    51     OpBuffer[obp++]=(char)0x03;
    52     OpBuffer[obp++]=(char)0xCB;
     51    compiler.codeGenerator.op_add_RR( REG_ECX, REG_EBX );
    5352}
    5453void SetRelativeOffset( RELATIVE_VAR &relativeVar ){
    5554    if(relativeVar.dwKind==VAR_DIRECTMEM){
    5655        //mov ecx,dword ptr[ecx]
    57         op_mov_RM( sizeof(long), REG_ECX, REG_ECX, 0, MOD_BASE );
     56        compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ECX, 0, MOD_BASE );
    5857    }
    5958    else{
    … …  
    6362
    6463        //mov ecx,dword ptr[eax]
    65         op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
     64        compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
    6665    }
    6766}
    … …  
    114113
    115114    //push ecx
    116     op_push(REG_ECX);
     115    compiler.codeGenerator.op_push(REG_ECX);
    117116
    118117    //push 0
    119     op_push_V(0);
     118    compiler.codeGenerator.op_push_V(0);
    120119
    121120    for(i=i3-1;i>=0;i--){
    … …  
    133132
    134133        //pop eax
    135         op_pop(REG_EAX);
     134        compiler.codeGenerator.op_pop(REG_EAX);
    136135
    137136        for(i2=i+1,i4=1;i2<i3;i2++) i4*=subscripts[i2]+1;
    … …  
    152151
    153152    //pop eax
    154     op_pop(REG_EAX);
     153    compiler.codeGenerator.op_pop(REG_EAX);
    155154
    156155    //imul eax,TypeSize
    … …  
    161160
    162161    //pop ecx
    163     op_pop(REG_ECX);
     162    compiler.codeGenerator.op_pop(REG_ECX);
    164163
    165164    //add ecx,eax
    166     OpBuffer[obp++]=(char)0x03;
    167     OpBuffer[obp++]=(char)0xC8;
     165    compiler.codeGenerator.op_add_RR( REG_ECX, REG_EAX );
    168166
    169167    return 1;
    … …  
    628626        //xor ecx,ecx（ecxを0に初期化する）
    629627        //※ecxは変数ベースアドレスからの相対オフセットを示す
    630         op_zero_reg(REG_ECX);
     628        compiler.codeGenerator.op_zero_reg(REG_ECX);
    631629
    632630        pRelativeVar->bOffsetOffset=1;
    … …  
    11941192        else{
    11951193            //push 0
    1196             op_push_V(0);
     1194            compiler.codeGenerator.op_push_V(0);
    11971195
    11981196            //push VarSize
    1199             op_push_V( pVar->GetMemorySize() );
     1197            compiler.codeGenerator.op_push_V( pVar->GetMemorySize() );
    12001198
    12011199            //mov eax,ebp
    … …  
    12101208
    12111209            //push eax
    1212             op_push(REG_EAX);
     1210            compiler.codeGenerator.op_push(REG_EAX);
    12131211
    12141212            //call FillMemory
    … …  
    12371235
    12381236        //pop eax
    1239         op_pop( REG_EAX );
     1237        compiler.codeGenerator.op_pop( REG_EAX );
    12401238
    12411239        RELATIVE_VAR RelativeVar;
    … …  
    12731271
    12741272            //add eax,dword ptr[offset]
    1275             op_add_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
     1273            compiler.codeGenerator.op_add_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
    12761274        }
    12771275        else{
    12781276            //mov eax,dword ptr[offset]
    1279             op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
     1277            compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
    12801278        }
    12811279        obp-=sizeof(long);
    … …  
    13561354
    13571355            // 変数領域に要するLONG_PTR単位の個数を引き渡す
    1358             op_push_V( pVar->GetMemorySize()/PTR_SIZE );
     1356            compiler.codeGenerator.op_push_V( pVar->GetMemorySize()/PTR_SIZE );
    13591357
    13601358
    … …  
    13631361
    13641362            //mov eax,offset
    1365             op_mov_RV(REG_EAX,(int)pVar->GetOffsetAddress());
     1363            compiler.codeGenerator.op_mov_RV(REG_EAX,(int)pVar->GetOffsetAddress());
    13661364            obp-=sizeof(long);
    13671365            pobj_GlobalVarSchedule->add();
    … …  
    13691367
    13701368            //push eax
    1371             op_push( REG_EAX );
     1369            compiler.codeGenerator.op_push( REG_EAX );
    13721370
    13731371            //
    … …  
    13811379
    13821380            //push eax
    1383             op_push( REG_EAX );
     1381            compiler.codeGenerator.op_push( REG_EAX );
    13841382
    13851383            //
    … …  
    13881386
    13891387            // call AddGlobalRootPtr
    1390             op_call( pUserProc_AddGlobalRootPtr );
     1388            compiler.codeGenerator.op_call( pUserProc_AddGlobalRootPtr );
    13911389
    13921390            ReallocNativeCodeBuffer();

  • trunk/abdev/BasicCompiler32/MakePeHdr.cpp

    r224 r225  
    437437        dwContinueAddress=-1;
    438438
     439        // コード生成対象を選択
     440        compiler.codeGenerator.Select( compiler.globalNativeCode );
     441
    439442        trace_for_sourcecodestep( "★★★ グローバル領域のコンパイルを開始" );
    440443
    … …  
    443446        //OpBuffer[obp++]=(char)0xCC;
    444447
     448
    445449        //push ebp
    446         op_push(REG_EBP);
     450        compiler.codeGenerator.op_push(REG_EBP);
    447451
    448452        if(bDebugCompile){
    … …  
    455459
    456460        //_System_StartupProgramの呼び出し
    457         op_call(pSub_System_StartupProgram);
     461        compiler.codeGenerator.op_call(pSub_System_StartupProgram);
    458462
    459463        //クラスに属する静的メンバを定義
    … …  
    489493        //call _System_End
    490494        extern const UserProc *pSub_System_End;
    491         op_call(pSub_System_End);
     495        compiler.codeGenerator.op_call(pSub_System_End);
    492496
    493497
    494498        //xor eax,eax（eaxを0に初期化する）
    495         op_zero_reg(REG_EAX);
     499        compiler.codeGenerator.op_zero_reg(REG_EAX);
    496500
    497501        //pop ebp
    498         op_pop(REG_EBP);
     502        compiler.codeGenerator.op_pop(REG_EBP);
    499503
    500504        //ret
    501         op_ret();
     505        compiler.codeGenerator.op_ret();
    502506
    503507        //グローバル実行領域のコードサイズ

  • trunk/abdev/BasicCompiler32/NumOpe.cpp

    r224 r225  
    1515    if(type==DEF_OBJECT || type==DEF_STRUCT){
    1616        //push eax
    17         op_push(REG_EAX);
     17        compiler.codeGenerator.op_push(REG_EAX);
    1818    }
    1919    else if(type==DEF_DOUBLE){
    2020        //sub esp,8
    21         op_sub_esp(8);
     21        compiler.codeGenerator.op_sub_esp(8);
    2222
    2323        //fstp qword ptr[esp]
    24         OpBuffer[obp++]=(char)0xDD;
    25         OpBuffer[obp++]=(char)0x1C;
    26         OpBuffer[obp++]=(char)0x24;
     24        compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
    2725    }
    2826    else if(type==DEF_SINGLE){
    2927        //sub esp,4
    30         op_sub_esp(4);
     28        compiler.codeGenerator.op_sub_esp(4);
    3129
    3230        //fstp dword ptr[esp]
    33         OpBuffer[obp++]=(char)0xD9;
    34         OpBuffer[obp++]=(char)0x1C;
    35         OpBuffer[obp++]=(char)0x24;
     31        compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
    3632    }
    3733    else if(type==DEF_INT64||type==DEF_QWORD){
    3834        //push edx
    39         op_push(REG_EDX);
     35        compiler.codeGenerator.op_push(REG_EDX);
    4036
    4137        //push eax
    42         op_push(REG_EAX);
     38        compiler.codeGenerator.op_push(REG_EAX);
    4339    }
    4440    else if(type==DEF_LONG){
    4541        //push eax
    46         op_push(REG_EAX);
     42        compiler.codeGenerator.op_push(REG_EAX);
    4743    }
    4844    else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
    4945        //movsx ebx,ax
    50         OpBuffer[obp++]=(char)0x0F;
    51         OpBuffer[obp++]=(char)0xBF;
    52         OpBuffer[obp++]=(char)0xD8;
     46        compiler.codeGenerator.op_movsx_R32R16( REG_EBX, REG_EAX );
    5347
    5448        //push ebx
    55         op_push(REG_EBX);
     49        compiler.codeGenerator.op_push(REG_EBX);
    5650    }
    5751    else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    5852        //movsx ebx,al
    59         OpBuffer[obp++]=(char)0x0F;
    60         OpBuffer[obp++]=(char)0xBE;
    61         OpBuffer[obp++]=(char)0xD8;
     53        compiler.codeGenerator.op_movsx_R32R8( REG_EBX, REG_EAX );
    6254
    6355        //push ebx
    64         op_push(REG_EBX);
     56        compiler.codeGenerator.op_push(REG_EBX);
    6557    }
    6658    else if(type==DEF_DWORD||type==DEF_WORD||type==DEF_BYTE||type==DEF_BOOLEAN||
    6759        IsPtrType(type)){
    6860        //push eax
    69         op_push(REG_EAX);
     61        compiler.codeGenerator.op_push(REG_EAX);
    7062    }
    7163    else{
    … …  
    157149
    158150        //オブジェクトポインタをecxにコピー
    159         op_mov_RR( REG_ECX, useReg );
     151        compiler.codeGenerator.op_mov_RR( REG_ECX, useReg );
    160152
    161153        RELATIVE_VAR relativeVar;
    … …  
    200192                //オブジェクトポインタをスタックに入れておく
    201193                //push reg
    202                 op_push( useReg );
     194                compiler.codeGenerator.op_push( useReg );
    203195
    204196                if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){
    … …  
    207199                }
    208200
    209                 op_pop();
     201                compiler.codeGenerator.op_pop();
    210202
    211203                /////////////////////
    … …  
    521513    if( resultType.IsReal() ){
    522514        //fld ptr[esp]
    523         op_fld_ptr_esp( resultType.GetBasicType() );
     515        compiler.codeGenerator.op_fld_ptr_esp( resultType.GetBasicType() );
    524516
    525517        //add esp,size
    526         op_add_esp( resultType.GetBasicSize() );
     518        compiler.codeGenerator.op_add_esp( resultType.GetBasicSize() );
    527519    }
    528520    else{
    529521        //pop eax
    530         op_pop(REG_EAX);
     522        compiler.codeGenerator.op_pop(REG_EAX);
    531523
    532524        if( resultType.Is64() ){
    533525            //pop edx
    534             op_pop(REG_EDX);
     526            compiler.codeGenerator.op_pop(REG_EDX);
    535527        }
    536528    }
    … …  
    603595
    604596        //mov eax,i2
    605         op_mov_RV(REG_EAX,i2);
     597        compiler.codeGenerator.op_mov_RV(REG_EAX,i2);
    606598        obp-=sizeof(long);
    607599        pobj_DataTableSchedule->add();
    … …  
    613605
    614606        //push eax
    615         op_push( REG_EAX );
     607        compiler.codeGenerator.op_push( REG_EAX );
    616608
    617609        return true;
    … …  
    815807                                //sub esp,size
    816808                                //fstp ptr[esp]
    817                                 op_fstp_push( resultType );
     809                                compiler.codeGenerator.op_fstp_push( resultType );
    818810                            }
    819811                            else{
    820812                                if( resultType.Is64() ){
    821813                                    //push edx
    822                                     op_push( REG_EDX );
     814                                    compiler.codeGenerator.op_push( REG_EDX );
    823815                                }
    824816                                else{
    … …  
    827819
    828820                                //push eax
    829                                 op_push( REG_EAX );
     821                                compiler.codeGenerator.op_push( REG_EAX );
    830822                            }
    831823                        }
    … …  
    851843
    852844                        //push 0
    853                         op_push_V( 0 );
     845                        compiler.codeGenerator.op_push_V( 0 );
    854846
    855847                        sp++;
    … …  
    912904
    913905                        //push HILONG(dbl)
    914                         op_push_V((long)*(long *)(((char *)(&i64data))+4));
     906                        compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4));
    915907
    916908                        //push LOLONG(dbl)
    917                         op_push_V(*(long *)(&i64data));
     909                        compiler.codeGenerator.op_push_V(*(long *)(&i64data));
    918910                    }
    919911                    else if(type_stack[sp]==DEF_SINGLE){
    … …  
    926918
    927919                        //push term
    928                         op_push_V(i3);
     920                        compiler.codeGenerator.op_push_V(i3);
    929921                    }
    930922                    else{
    … …  
    932924
    933925                        //push term
    934                         op_push_V((long)i64data);
     926                        compiler.codeGenerator.op_push_V((long)i64data);
    935927
    936928                        if((long)i64data==0) index_stack[sp]=LITERAL_NULL;
    … …  
    10821074
    10831075            //push HILONG(i64data)
    1084             op_push_V((long)*(long *)(((char *)(&i64data))+4));
     1076            compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4));
    10851077
    10861078            //push LOLONG(i64data)
    1087             op_push_V(*(long *)(&i64data));
     1079            compiler.codeGenerator.op_push_V(*(long *)(&i64data));
    10881080        }
    10891081        else if( resultType.IsSingle() ){
    … …  
    10971089
    10981090            //push flt
    1099             op_push_V(i3);
     1091            compiler.codeGenerator.op_push_V(i3);
    11001092        }
    11011093        else{
    … …  
    11081100
    11091101            //push term
    1110             op_push_V(i3);
     1102            compiler.codeGenerator.op_push_V(i3);
    11111103        }
    11121104

  • trunk/abdev/BasicCompiler32/NumOpe_Arithmetic.cpp

    r206 r225  
    11#include "stdafx.h"
     2
     3#include <Compiler.h>
    24
    35#include "../BasicCompiler_Common/common.h"
    … …  
    1012    if(type[sp-1]==DEF_DOUBLE){
    1113        //fld qword ptr[esp]
    12         op_fld_ptr_esp(DEF_DOUBLE);
     14        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    1315
    1416        //fistp qword ptr[esp]
    15         op_fistp_ptr_esp( sizeof(_int64) );
     17        compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    1618
    1719        //pop ebx
    18         op_pop(REG_EBX);
     20        compiler.codeGenerator.op_pop(REG_EBX);
    1921
    2022        //pop ecx
    21         op_pop(REG_ECX);
     23        compiler.codeGenerator.op_pop(REG_ECX);
    2224    }
    2325    else if(type[sp-1]==DEF_SINGLE){
    2426        //fld dword ptr[esp]
    25         op_fld_ptr_esp(DEF_SINGLE);
     27        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    2628
    2729        //sub esp,4
    28         op_sub_esp(4);
     30        compiler.codeGenerator.op_sub_esp(4);
    2931
    3032        //fistp qword ptr[esp]
    31         op_fistp_ptr_esp( sizeof(_int64) );
     33        compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    3234
    3335        //pop ebx
    34         op_pop(REG_EBX);
     36        compiler.codeGenerator.op_pop(REG_EBX);
    3537
    3638        //pop ecx
    37         op_pop(REG_ECX);
     39        compiler.codeGenerator.op_pop(REG_ECX);
    3840    }
    3941    else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    4042        //pop ebx
    41         op_pop(REG_EBX);
     43        compiler.codeGenerator.op_pop(REG_EBX);
    4244
    4345        //pop ecx
    44         op_pop(REG_ECX);
     46        compiler.codeGenerator.op_pop(REG_ECX);
    4547    }
    4648    else{
    4749        //pop eax
    48         op_pop(REG_EAX);
     50        compiler.codeGenerator.op_pop(REG_EAX);
    4951
    5052        if(IsSignedType(type[sp-1])){
    … …  
    5355               
    5456            //cdq
    55             op_cdq();
     57            compiler.codeGenerator.op_cdq();
    5658        }
    5759        else{
    … …  
    6062
    6163            //xor edx,edx
    62             op_zero_reg(REG_EDX);
     64            compiler.codeGenerator.op_zero_reg(REG_EDX);
    6365        }
    6466
    6567        //mov ebx,eax
    66         OpBuffer[obp++]=(char)0x8B;
    67         OpBuffer[obp++]=(char)0xD8;
     68        compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
    6869
    6970        //mov ecx,edx
    70         OpBuffer[obp++]=(char)0x8B;
    71         OpBuffer[obp++]=(char)0xCA;
     71        compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
    7272    }
    7373
    … …  
    7575    if(type[sp-2]==DEF_DOUBLE){
    7676        //fld qword ptr[esp]
    77         op_fld_ptr_esp(DEF_DOUBLE);
     77        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    7878
    7979        //fistp qword ptr[esp]
    80         op_fistp_ptr_esp( sizeof(_int64) );
     80        compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    8181
    8282        //pop eax
    83         op_pop(REG_EAX);
     83        compiler.codeGenerator.op_pop(REG_EAX);
    8484
    8585        //pop edx
    86         op_pop(REG_EDX);
     86        compiler.codeGenerator.op_pop(REG_EDX);
    8787    }
    8888    else if(type[sp-2]==DEF_SINGLE){
    8989        //fld dword ptr[esp]
    90         op_fld_ptr_esp(DEF_SINGLE);
     90        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    9191
    9292        //sub esp,4
    93         op_sub_esp(4);
     93        compiler.codeGenerator.op_sub_esp(4);
    9494
    9595        //fistp qword ptr[esp]
    96         op_fistp_ptr_esp( sizeof(_int64) );
     96        compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    9797
    9898        //pop eax
    99         op_pop(REG_EAX);
     99        compiler.codeGenerator.op_pop(REG_EAX);
    100100
    101101        //pop edx
    102         op_pop(REG_EDX);
     102        compiler.codeGenerator.op_pop(REG_EDX);
    103103    }
    104104    else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
    105105        //pop eax
    106         op_pop(REG_EAX);
     106        compiler.codeGenerator.op_pop(REG_EAX);
    107107
    108108        //pop edx
    109         op_pop(REG_EDX);
     109        compiler.codeGenerator.op_pop(REG_EDX);
    110110    }
    111111    else{
    112112        //pop eax
    113         op_pop(REG_EAX);
     113        compiler.codeGenerator.op_pop(REG_EAX);
    114114
    115115        if(IsSignedType(type[sp-2])){
    … …  
    118118               
    119119            //cdq
    120             op_cdq();
     120            compiler.codeGenerator.op_cdq();
    121121        }
    122122        else{
    … …  
    125125
    126126            //xor edx,edx
    127             op_zero_reg(REG_EDX);
     127            compiler.codeGenerator.op_zero_reg(REG_EDX);
    128128        }
    129129    }
    … …  
    136136
    137137    //push ecx
    138     op_push(REG_ECX);
     138    compiler.codeGenerator.op_push(REG_ECX);
    139139
    140140    //push ebx
    141     op_push(REG_EBX);
     141    compiler.codeGenerator.op_push(REG_EBX);
    142142
    143143    //push edx
    144     op_push(REG_EDX);
     144    compiler.codeGenerator.op_push(REG_EDX);
    145145
    146146    //push eax
    147     op_push(REG_EAX);
     147    compiler.codeGenerator.op_push(REG_EAX);
    148148}
    149149
    … …  
    167167        if(type[sp-1]==DEF_DOUBLE){
    168168            //fld qword ptr[esp]
    169             op_fld_ptr_esp(DEF_DOUBLE);
     169            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    170170
    171171            //add esp,8
    172             op_add_esp(8);
     172            compiler.codeGenerator.op_add_esp(8);
    173173        }
    174174        else if(type[sp-1]==DEF_SINGLE){
    175175            //fld dword ptr[esp]
    176             op_fld_ptr_esp(DEF_SINGLE);
    177 
    178             //add esp,4
    179             op_add_esp(4);
     176            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     177
     178            //add esp,4
     179            compiler.codeGenerator.op_add_esp(4);
    180180        }
    181181        else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    … …  
    183183
    184184            //fild qword ptr[esp]
    185             op_fld_ptr_esp(DEF_INT64);
     185            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    186186
    187187            //add esp,8
    188             op_add_esp(8);
     188            compiler.codeGenerator.op_add_esp(8);
    189189        }
    190190        else{
    … …  
    192192
    193193            //fild dword ptr[esp]
    194             op_fld_ptr_esp(DEF_LONG);
    195 
    196             //add esp,4
    197             op_add_esp(4);
     194            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
     195
     196            //add esp,4
     197            compiler.codeGenerator.op_add_esp(4);
    198198        }
    199199
    200200        if(type[sp-2]==DEF_DOUBLE){
    201201            //fld qword ptr[esp]
    202             op_fld_ptr_esp(DEF_DOUBLE);
     202            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    203203        }
    204204        else if(type[sp-2]==DEF_SINGLE){
    205205            //fld dword ptr[esp]
    206             op_fld_ptr_esp(DEF_SINGLE);
     206            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    207207        }
    208208        else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
    209209            //64ビット整数値
    210             op_fld_ptr_esp(DEF_INT64);
     210            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    211211        }
    212212        else{
    … …  
    214214
    215215            //fild dword ptr[esp]
    216             op_fld_ptr_esp(DEF_LONG);
     216            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    217217        }
    218218
    … …  
    220220            if(AnswerType==DEF_SINGLE){
    221221                //add esp,4
    222                 op_add_esp(4);
     222                compiler.codeGenerator.op_add_esp(4);
    223223            }
    224224        }
    … …  
    226226            if(AnswerType==DEF_DOUBLE){
    227227                //sub esp,4
    228                 op_sub_esp(4);
     228                compiler.codeGenerator.op_sub_esp(4);
    229229            }
    230230        }
    … …  
    232232        if(idCalc==CALC_ADDITION){
    233233            //faddp st(1),st
    234             OpBuffer[obp++]=(char)0xDE;
    235             OpBuffer[obp++]=(char)0xC1;
     234            compiler.codeGenerator.PutOld(
     235                (char)0xDE,
     236                (char)0xC1
     237            );
    236238        }
    237239        else if(idCalc==CALC_SUBTRACTION){
    238240            //fsubrp st(1),st
    239             OpBuffer[obp++]=(char)0xDE;
    240             OpBuffer[obp++]=(char)0xE1;
     241            compiler.codeGenerator.PutOld(
     242                (char)0xDE,
     243                (char)0xE1
     244            );
    241245        }
    242246        else if(idCalc==CALC_PRODUCT){
    243247            //fmulp st(1),st
    244             OpBuffer[obp++]=(char)0xDE;
    245             OpBuffer[obp++]=(char)0xC9;
     248            compiler.codeGenerator.PutOld(
     249                (char)0xDE,
     250                (char)0xC9
     251            );
    246252        }
    247253
    248254        if(AnswerType==DEF_DOUBLE){
    249255            //fstp qword ptr[esp]
    250             OpBuffer[obp++]=(char)0xDD;
    251             OpBuffer[obp++]=(char)0x1C;
    252             OpBuffer[obp++]=(char)0x24;
     256            compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
    253257        }
    254258        else{
    255259            //fstp dword ptr[esp]
    256             OpBuffer[obp++]=(char)0xD9;
    257             OpBuffer[obp++]=(char)0x1C;
    258             OpBuffer[obp++]=(char)0x24;
     260            compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
    259261        }
    260262    }
    … …  
    273275            //call _allmul
    274276            extern const UserProc *pSub_allmul;
    275             op_call(pSub_allmul);
     277            compiler.codeGenerator.op_call(pSub_allmul);
    276278
    277279            //push edx
    278             op_push(REG_EDX);
     280            compiler.codeGenerator.op_push(REG_EDX);
    279281
    280282            //push eax
    281             op_push(REG_EAX);
     283            compiler.codeGenerator.op_push(REG_EAX);
    282284        }
    283285        else{
    … …  
    286288
    287289                //pop ebx
    288                 op_pop(REG_EBX);
     290                compiler.codeGenerator.op_pop(REG_EBX);
    289291
    290292                //pop ecx
    291                 op_pop(REG_ECX);
     293                compiler.codeGenerator.op_pop(REG_ECX);
    292294            }
    293295            else{
    … …  
    295297
    296298                //pop eax
    297                 op_pop(REG_EAX);
     299                compiler.codeGenerator.op_pop(REG_EAX);
    298300
    299301                if(IsSignedType(type[sp-1])){
    … …  
    302304                   
    303305                    //cdq
    304                     op_cdq();
     306                    compiler.codeGenerator.op_cdq();
    305307                }
    306308                else{
    … …  
    309311
    310312                    //xor edx,edx
    311                     op_zero_reg(REG_EDX);
     313                    compiler.codeGenerator.op_zero_reg(REG_EDX);
    312314                }
    313315
    314316                //mov ebx,eax
    315                 OpBuffer[obp++]=(char)0x8B;
    316                 OpBuffer[obp++]=(char)0xD8;
     317                compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
    317318
    318319                //mov ecx,edx
    319                 OpBuffer[obp++]=(char)0x8B;
    320                 OpBuffer[obp++]=(char)0xCA;
     320                compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
    321321            }
    322322
    … …  
    326326                if(idCalc==CALC_ADDITION){
    327327                    //add dword ptr[esp],ebx
    328                     OpBuffer[obp++]=(char)0x01;
    329                     OpBuffer[obp++]=(char)0x1C;
    330                     OpBuffer[obp++]=(char)0x24;
     328                    compiler.codeGenerator.PutOld(
     329                        (char)0x01,
     330                        (char)0x1C,
     331                        (char)0x24
     332                    );
    331333
    332334                    //adc dword ptr[esp+sizeof(long)],ecx
    333                     OpBuffer[obp++]=(char)0x11;
    334                     OpBuffer[obp++]=(char)0x4C;
    335                     OpBuffer[obp++]=(char)0x24;
    336                     OpBuffer[obp++]=(char)0x04;
     335                    compiler.codeGenerator.PutOld(
     336                        (char)0x11,
     337                        (char)0x4C,
     338                        (char)0x24,
     339                        (char)0x04
     340                    );
    337341                }
    338342                else if(idCalc==CALC_SUBTRACTION){
    339343                    //sub dword ptr[esp],ebx
    340                     OpBuffer[obp++]=(char)0x29;
    341                     OpBuffer[obp++]=(char)0x1C;
    342                     OpBuffer[obp++]=(char)0x24;
     344                    compiler.codeGenerator.PutOld(
     345                        (char)0x29,
     346                        (char)0x1C,
     347                        (char)0x24
     348                    );
    343349
    344350                    //sbb dword ptr[esp+sizeof(long)],ecx
    345                     OpBuffer[obp++]=(char)0x19;
    346                     OpBuffer[obp++]=(char)0x4C;
    347                     OpBuffer[obp++]=(char)0x24;
    348                     OpBuffer[obp++]=(char)0x04;
     351                    compiler.codeGenerator.PutOld(
     352                        (char)0x19,
     353                        (char)0x4C,
     354                        (char)0x24,
     355                        (char)0x04
     356                    );
    349357                }
    350358            }
    … …  
    353361
    354362                //pop eax
    355                 op_pop(REG_EAX);
     363                compiler.codeGenerator.op_pop(REG_EAX);
    356364
    357365                if(IsSignedType(type[sp-2])){
    … …  
    360368
    361369                    //cdq
    362                     op_cdq();
     370                    compiler.codeGenerator.op_cdq();
    363371                }
    364372                else{
    … …  
    367375
    368376                    //xor edx,edx
    369                     op_zero_reg(REG_EDX);
     377                    compiler.codeGenerator.op_zero_reg(REG_EDX);
    370378                }
    371379
    372380                if(idCalc==CALC_ADDITION){
    373381                    //add ebx,eax
    374                     OpBuffer[obp++]=(char)0x03;
    375                     OpBuffer[obp++]=(char)0xD8;
     382                    compiler.codeGenerator.op_add_RR( REG_EBX, REG_EAX );
    376383
    377384                    //adc ecx,edx
    378                     OpBuffer[obp++]=(char)0x13;
    379                     OpBuffer[obp++]=(char)0xCA;
     385                    compiler.codeGenerator.op_adc_RR( REG_ECX, REG_EDX );
    380386                }
    381387                else if(idCalc==CALC_SUBTRACTION){
    382388                    //sub ebx,eax
    383                     OpBuffer[obp++]=(char)0x2B;
    384                     OpBuffer[obp++]=(char)0xC3;
     389                    compiler.codeGenerator.op_sub_RR( REG_EBX, REG_EAX );
    385390
    386391                    //sbb ecx,edx
    387                     OpBuffer[obp++]=(char)0x1B;
    388                     OpBuffer[obp++]=(char)0xD1;
     392                    compiler.codeGenerator.op_sub_RR( REG_ECX, REG_EDX );
    389393                }
    390394
    391395                //push ecx
    392                 op_push(REG_ECX);
     396                compiler.codeGenerator.op_push(REG_ECX);
    393397
    394398                //push ebx
    395                 op_push(REG_EBX);
     399                compiler.codeGenerator.op_push(REG_EBX);
    396400            }
    397401        }
    … …  
    403407
    404408        //pop ebx
    405         op_pop(REG_EBX);
     409        compiler.codeGenerator.op_pop(REG_EBX);
    406410
    407411        //pop eax
    408         op_pop(REG_EAX);
     412        compiler.codeGenerator.op_pop(REG_EAX);
    409413
    410414        //sub esp,4
    411         op_sub_esp(4);
     415        compiler.codeGenerator.op_sub_esp(4);
    412416
    413417        if(idCalc==CALC_ADDITION){
    414418            //add eax,ebx
    415             OpBuffer[obp++]=(char)0x03;
    416             OpBuffer[obp++]=(char)0xC3;
     419            compiler.codeGenerator.op_add_RR( REG_EAX, REG_EBX );
    417420        }
    418421        else if(idCalc==CALC_SUBTRACTION){
    419422            //sub eax,ebx
    420             OpBuffer[obp++]=(char)0x2B;
    421             OpBuffer[obp++]=(char)0xC3;
     423            compiler.codeGenerator.op_sub_RR( REG_EAX, REG_EBX );
    422424        }
    423425        else if(idCalc==CALC_PRODUCT){
    424426            //imul eax,ebx（64ビット演算ではないので、符号を考慮しない）
    425             OpBuffer[obp++]=(char)0x0F;
    426             OpBuffer[obp++]=(char)0xAF;
    427             OpBuffer[obp++]=(char)0xC3;
     427            compiler.codeGenerator.op_imul_RR( REG_EAX, REG_EBX );
    428428        }
    429429
    430430        //mov dword ptr[esp],eax
    431         OpBuffer[obp++]=(char)0x89;
    432         OpBuffer[obp++]=(char)0x04;
    433         OpBuffer[obp++]=(char)0x24;
     431        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
    434432    }
    435433
    … …  
    463461            //call _aullrem
    464462            extern const UserProc *pSub_aullrem;
    465             op_call(pSub_aullrem);
     463            compiler.codeGenerator.op_call(pSub_aullrem);
    466464        }
    467465        else{
    … …  
    470468            //call _allrem
    471469            extern const UserProc *pSub_allrem;
    472             op_call(pSub_allrem);
     470            compiler.codeGenerator.op_call(pSub_allrem);
    473471        }
    474472
    475473        //push edx
    476         op_push(REG_EDX);
     474        compiler.codeGenerator.op_push(REG_EDX);
    477475
    478476        //push eax
    479         op_push(REG_EAX);
     477        compiler.codeGenerator.op_push(REG_EAX);
    480478
    481479        sp--;
    … …  
    490488        if(type[sp-1]==DEF_DOUBLE){
    491489            //fld qword ptr[esp]
    492             op_fld_ptr_esp(DEF_DOUBLE);
    493 
    494             //add esp,4
    495             op_add_esp(4);
    496 
    497             //fistp dword ptr[esp]
    498             op_fistp_ptr_esp( sizeof(long) );
     490            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     491
     492            //add esp,4
     493            compiler.codeGenerator.op_add_esp(4);
     494
     495            //fistp dword ptr[esp]
     496            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    499497        }
    500498        else if(type[sp-1]==DEF_SINGLE){
    501499            //fld dword ptr[esp]
    502             op_fld_ptr_esp(DEF_SINGLE);
    503 
    504             //fistp dword ptr[esp]
    505             op_fistp_ptr_esp( sizeof(long) );
     500            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     501
     502            //fistp dword ptr[esp]
     503            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    506504        }
    507505
    508506        //pop ebx
    509         op_pop(REG_EBX);
     507        compiler.codeGenerator.op_pop(REG_EBX);
    510508
    511509        if(type[sp-2]==DEF_DOUBLE){
    512510            //fld qword ptr[esp]
    513             op_fld_ptr_esp(DEF_DOUBLE);
    514 
    515             //add esp,4
    516             op_add_esp(4);
    517 
    518             //fistp dword ptr[esp]
    519             op_fistp_ptr_esp( sizeof(long) );
     511            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     512
     513            //add esp,4
     514            compiler.codeGenerator.op_add_esp(4);
     515
     516            //fistp dword ptr[esp]
     517            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    520518        }
    521519        else if(type[sp-2]==DEF_SINGLE){
    522520            //fld dword ptr[esp]
    523             op_fld_ptr_esp(DEF_SINGLE);
    524 
    525             //fistp dword ptr[esp]
    526             op_fistp_ptr_esp( sizeof(long) );
     521            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     522
     523            //fistp dword ptr[esp]
     524            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    527525        }
    528526
    529527        //pop eax
    530         op_pop(REG_EAX);
     528        compiler.codeGenerator.op_pop(REG_EAX);
    531529
    532530        //sub esp,4
    533         op_sub_esp(4);
     531        compiler.codeGenerator.op_sub_esp(4);
    534532
    535533        if(type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD){
    536534            //xor edx,edx
    537             op_zero_reg(REG_EDX);
     535            compiler.codeGenerator.op_zero_reg(REG_EDX);
    538536
    539537            //div ebx (eax=eax/ebx...edx)
    540             OpBuffer[obp++]=(char)0xF7;
    541             OpBuffer[obp++]=(char)0xF3;
     538            compiler.codeGenerator.op_div_R( REG_EBX );
    542539        }
    543540        else{
    544541            //cdq
    545             op_cdq();
     542            compiler.codeGenerator.op_cdq();
    546543
    547544            //idiv ebx (eax=eax/ebx...edx)
    548             OpBuffer[obp++]=(char)0xF7;
    549             OpBuffer[obp++]=(char)0xFB;
     545            compiler.codeGenerator.op_idiv_R( REG_EBX );
    550546        }
    551547
    552548        //mov dword ptr[esp],edx
    553         OpBuffer[obp++]=(char)0x89;
    554         OpBuffer[obp++]=(char)0x14;
    555         OpBuffer[obp++]=(char)0x24;
     549        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EDX, REG_ESP, 0, MOD_BASE );
    556550
    557551        sp--;
    … …  
    581575    if(type[sp-1]==DEF_DOUBLE){
    582576        //fld qword ptr[esp]
    583         op_fld_ptr_esp(DEF_DOUBLE);
     577        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    584578
    585579        //add esp,8
    586         op_add_esp(8);
     580        compiler.codeGenerator.op_add_esp(8);
    587581    }
    588582    else if(type[sp-1]==DEF_SINGLE){
    589583        //fld dword ptr[esp]
    590         op_fld_ptr_esp(DEF_SINGLE);
     584        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    591585
    592586        //add esp,4
    593         op_add_esp(4);
     587        compiler.codeGenerator.op_add_esp(4);
    594588    }
    595589    else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    … …  
    597591
    598592        //fild qword ptr[esp]
    599         op_fld_ptr_esp(DEF_INT64);
     593        compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    600594
    601595        //add esp,8
    602         op_add_esp(8);
     596        compiler.codeGenerator.op_add_esp(8);
    603597    }
    604598    else if(type[sp-1]==DEF_DWORD){
    605599        //pop eax
    606         op_pop(REG_EAX);
     600        compiler.codeGenerator.op_pop(REG_EAX);
    607601
    608602        //push 0
    609         op_push_V(0);
     603        compiler.codeGenerator.op_push_V(0);
    610604
    611605        //push eax
    612         op_push(REG_EAX);
     606        compiler.codeGenerator.op_push(REG_EAX);
    613607
    614608        //fild qword ptr[esp]
    615         OpBuffer[obp++]=(char)0xDF;
    616         OpBuffer[obp++]=(char)0x2C;
    617         OpBuffer[obp++]=(char)0x24;
     609        compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    618610
    619611        //add esp,8
    620         op_add_esp(8);
     612        compiler.codeGenerator.op_add_esp(8);
    621613    }
    622614    else{
    623615        //fild dword ptr[esp]
    624         op_fld_ptr_esp(DEF_LONG);
     616        compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    625617
    626618        //add esp,4
    627         op_add_esp(4);
     619        compiler.codeGenerator.op_add_esp(4);
    628620    }
    629621
    630622    if(type[sp-2]==DEF_DOUBLE){
    631623        //fld qword ptr[esp]
    632         op_fld_ptr_esp(DEF_DOUBLE);
     624        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    633625    }
    634626    else if(type[sp-2]==DEF_SINGLE){
    635627        //fld dword ptr[esp]
    636         op_fld_ptr_esp(DEF_SINGLE);
     628        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    637629    }
    638630    else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
    … …  
    640632
    641633        //fild qword ptr[esp]
    642         op_fld_ptr_esp(DEF_INT64);
     634        compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    643635    }
    644636    else if(type[sp-2]==DEF_DWORD){
    645637        //pop eax
    646         op_pop(REG_EAX);
     638        compiler.codeGenerator.op_pop(REG_EAX);
    647639
    648640        //push 0
    649         op_push_V(0);
     641        compiler.codeGenerator.op_push_V(0);
    650642
    651643        //push eax
    652         op_push(REG_EAX);
     644        compiler.codeGenerator.op_push(REG_EAX);
    653645
    654646        //fild qword ptr[esp]
    655         OpBuffer[obp++]=(char)0xDF;
    656         OpBuffer[obp++]=(char)0x2C;
    657         OpBuffer[obp++]=(char)0x24;
     647        compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    658648    }
    659649    else{   //Long
    660650        //fild dword ptr[esp]
    661         op_fld_ptr_esp(DEF_LONG);
     651        compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    662652    }
    663653                                                            //↓ここだけ例外DWord
    … …  
    665655        if(AnswerType==DEF_SINGLE){
    666656            //add esp,4
    667             op_add_esp(4);
     657            compiler.codeGenerator.op_add_esp(4);
    668658        }
    669659    }
    … …  
    671661        if(AnswerType==DEF_DOUBLE){
    672662            //sub esp,4
    673             op_sub_esp(4);
     663            compiler.codeGenerator.op_sub_esp(4);
    674664        }
    675665    }
    676666
    677667    //fdivrp st(1),st
    678     OpBuffer[obp++]=(char)0xDE;
    679     OpBuffer[obp++]=(char)0xF1;
     668    compiler.codeGenerator.PutOld(
     669        (char)0xDE,
     670        (char)0xF1
     671    );
    680672
    681673    sp--;
    682674    if(AnswerType==DEF_DOUBLE){
    683675        //fstp qword ptr[esp]
    684         OpBuffer[obp++]=(char)0xDD;
    685         OpBuffer[obp++]=(char)0x1C;
    686         OpBuffer[obp++]=(char)0x24;
     676        compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
    687677
    688678        type[sp-1]=DEF_DOUBLE;
    … …  
    690680    else{
    691681        //fstp dword ptr[esp]
    692         OpBuffer[obp++]=(char)0xD9;
    693         OpBuffer[obp++]=(char)0x1C;
    694         OpBuffer[obp++]=(char)0x24;
     682        compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
    695683
    696684        type[sp-1]=DEF_SINGLE;
    … …  
    723711            //call _aulldiv
    724712            extern const UserProc *pSub_aulldiv;
    725             op_call(pSub_aulldiv);
     713            compiler.codeGenerator.op_call(pSub_aulldiv);
    726714        }
    727715        else{
    … …  
    730718            //call _alldiv
    731719            extern const UserProc *pSub_alldiv;
    732             op_call(pSub_alldiv);
     720            compiler.codeGenerator.op_call(pSub_alldiv);
    733721        }
    734722
    735723        //push edx
    736         op_push(REG_EDX);
     724        compiler.codeGenerator.op_push(REG_EDX);
    737725
    738726        //push eax
    739         op_push(REG_EAX);
     727        compiler.codeGenerator.op_push(REG_EAX);
    740728
    741729        sp--;
    … …  
    750738        if(type[sp-1]==DEF_DOUBLE){
    751739            //fld qword ptr[esp]
    752             op_fld_ptr_esp(DEF_DOUBLE);
    753 
    754             //add esp,4
    755             op_add_esp(4);
    756 
    757             //fistp dword ptr[esp]
    758             op_fistp_ptr_esp( sizeof(long) );
     740            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     741
     742            //add esp,4
     743            compiler.codeGenerator.op_add_esp(4);
     744
     745            //fistp dword ptr[esp]
     746            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    759747        }
    760748        else if(type[sp-1]==DEF_SINGLE){
    761749            //fld dword ptr[esp]
    762             op_fld_ptr_esp(DEF_SINGLE);
    763 
    764             //fistp dword ptr[esp]
    765             op_fistp_ptr_esp( sizeof(long) );
     750            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     751
     752            //fistp dword ptr[esp]
     753            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    766754        }
    767755
    768756        //pop ebx
    769         op_pop(REG_EBX);
     757        compiler.codeGenerator.op_pop(REG_EBX);
    770758
    771759        if(type[sp-2]==DEF_DOUBLE){
    772760            //fld qword ptr[esp]
    773             op_fld_ptr_esp(DEF_DOUBLE);
    774 
    775             //add esp,4
    776             op_add_esp(4);
    777 
    778             //fistp dword ptr[esp]
    779             op_fistp_ptr_esp( sizeof(long) );
     761            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     762
     763            //add esp,4
     764            compiler.codeGenerator.op_add_esp(4);
     765
     766            //fistp dword ptr[esp]
     767            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    780768        }
    781769        else if(type[sp-2]==DEF_SINGLE){
    782770            //fld dword ptr[esp]
    783             op_fld_ptr_esp(DEF_SINGLE);
    784 
    785             //fistp dword ptr[esp]
    786             op_fistp_ptr_esp( sizeof(long) );
     771            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     772
     773            //fistp dword ptr[esp]
     774            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    787775        }
    788776
    789777        //pop eax
    790         op_pop(REG_EAX);
     778        compiler.codeGenerator.op_pop(REG_EAX);
    791779
    792780        //sub esp,4
    793         op_sub_esp(4);
     781        compiler.codeGenerator.op_sub_esp(4);
    794782
    795783        if((type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD)||
    … …  
    797785            (type[sp-2]==DEF_DWORD&&IS_POSITIVE_LITERAL(index_stack[sp-1]))){
    798786            //xor edx,edx
    799             op_zero_reg(REG_EDX);
     787            compiler.codeGenerator.op_zero_reg(REG_EDX);
    800788
    801789            //div ebx (eax=eax/ebx...edx)
    802             OpBuffer[obp++]=(char)0xF7;
    803             OpBuffer[obp++]=(char)0xF3;
     790            compiler.codeGenerator.op_div_R( REG_EBX );
    804791        }
    805792        else{
    806793            //cdq
    807             op_cdq();
     794            compiler.codeGenerator.op_cdq();
    808795
    809796            //idiv ebx (eax=eax/ebx...edx)
    810             OpBuffer[obp++]=(char)0xF7;
    811             OpBuffer[obp++]=(char)0xFB;
     797            compiler.codeGenerator.op_idiv_R( REG_EBX );
    812798        }
    813799
    814800        //mov dword ptr[esp],eax
    815         OpBuffer[obp++]=(char)0x89;
    816         OpBuffer[obp++]=(char)0x04;
    817         OpBuffer[obp++]=(char)0x24;
     801        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
    818802
    819803        sp--;
    … …  
    833817    if(type[sp-1]==DEF_DOUBLE){
    834818        //fld qword ptr[esp]
    835         op_fld_ptr_esp(DEF_DOUBLE);
     819        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    836820
    837821        //push -1
    838         op_push_V(-1);
     822        compiler.codeGenerator.op_push_V(-1);
    839823
    840824        //fild dword ptr[esp]
    841         op_fld_ptr_esp(DEF_LONG);
     825        compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    842826
    843827        //add esp,4
    844         op_add_esp(4);
     828        compiler.codeGenerator.op_add_esp(4);
    845829
    846830        //fmulp st(1),st
    847         OpBuffer[obp++]=(char)0xDE;
    848         OpBuffer[obp++]=(char)0xC9;
     831        compiler.codeGenerator.PutOld(
     832            (char)0xDE,
     833            (char)0xC9
     834        );
    849835
    850836        //fstp qword ptr[esp]
    851         OpBuffer[obp++]=(char)0xDD;
    852         OpBuffer[obp++]=(char)0x1C;
    853         OpBuffer[obp++]=(char)0x24;
     837        compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
    854838    }
    855839    else if(type[sp-1]==DEF_SINGLE){
    856840        //fld dword ptr[esp]
    857         op_fld_ptr_esp(DEF_SINGLE);
     841        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    858842
    859843        //push -1
    860         op_push_V(-1);
     844        compiler.codeGenerator.op_push_V(-1);
    861845
    862846        //fild dword ptr[esp]
    863         op_fld_ptr_esp(DEF_LONG);
     847        compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    864848
    865849        //add esp,4
    866         op_add_esp(4);
     850        compiler.codeGenerator.op_add_esp(4);
    867851
    868852        //fmulp st(1),st
    869         OpBuffer[obp++]=(char)0xDE;
    870         OpBuffer[obp++]=(char)0xC9;
     853        compiler.codeGenerator.PutOld(
     854            (char)0xDE,
     855            (char)0xC9
     856        );
    871857
    872858        //fstp dword ptr[esp]
    873         OpBuffer[obp++]=(char)0xD9;
    874         OpBuffer[obp++]=(char)0x1C;
    875         OpBuffer[obp++]=(char)0x24;
     859        compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
    876860    }
    877861    else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    878862        //pop eax
    879         op_pop(REG_EAX);
     863        compiler.codeGenerator.op_pop(REG_EAX);
    880864
    881865        //neg eax
    882         OpBuffer[obp++]=(char)0xF7;
    883         OpBuffer[obp++]=(char)0xD8;
     866        compiler.codeGenerator.op_neg( REG_EAX );
    884867
    885868        //pop edx
    886         op_pop(REG_EDX);
     869        compiler.codeGenerator.op_pop(REG_EDX);
    887870
    888871        //adc edx,0
    889         OpBuffer[obp++]=(char)0x83;
    890         OpBuffer[obp++]=(char)0xD2;
    891         OpBuffer[obp++]=(char)0x00;
     872        compiler.codeGenerator.op_adc_RV8(REG_EDX,0);
    892873
    893874        //neg edx
    894         OpBuffer[obp++]=(char)0xF7;
    895         OpBuffer[obp++]=(char)0xDA;
     875        compiler.codeGenerator.op_neg( REG_EDX );
    896876
    897877        //push edx
    898         op_push(REG_EDX);
     878        compiler.codeGenerator.op_push(REG_EDX);
    899879
    900880        //push eax
    901         op_push(REG_EAX);
     881        compiler.codeGenerator.op_push(REG_EAX);
    902882
    903883        type[sp-1]=DEF_INT64;   //QWordはInt64へ
    … …  
    905885    else if(IsWholeNumberType(type[sp-1])){
    906886        //pop eax
    907         op_pop(REG_EAX);
     887        compiler.codeGenerator.op_pop(REG_EAX);
    908888
    909889        //imul eax,-1
    910         OpBuffer[obp++]=(char)0x6B;
    911         OpBuffer[obp++]=(char)0xC0;
    912         OpBuffer[obp++]=(char)0xFF;
     890        compiler.codeGenerator.op_imul_RV8( REG_EAX, -1 );
    913891
    914892        //push eax
    915         op_push(REG_EAX);
     893        compiler.codeGenerator.op_push(REG_EAX);
    916894
    917895        type[sp-1]=GetSignedType(type[sp-1]);
    … …  
    929907    if(type[sp-1]==DEF_DOUBLE){
    930908        //fld qword ptr[esp]
    931         op_fld_ptr_esp(DEF_DOUBLE);
     909        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    932910
    933911        //add esp,8
    934         op_add_esp(8);
     912        compiler.codeGenerator.op_add_esp(8);
    935913    }
    936914    else if(type[sp-1]==DEF_SINGLE){
    937915        //fld dword ptr[esp]
    938         op_fld_ptr_esp(DEF_SINGLE);
     916        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    939917
    940918        //add esp,4
    941         op_add_esp(4);
     919        compiler.codeGenerator.op_add_esp(4);
    942920    }
    943921    else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    … …  
    945923
    946924        //fild qword ptr[esp]
    947         op_fld_ptr_esp(DEF_INT64);
     925        compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    948926
    949927        //add esp,8
    950         op_add_esp(8);
     928        compiler.codeGenerator.op_add_esp(8);
    951929    }
    952930    else{
    … …  
    954932
    955933        //fild dword ptr[esp]
    956         op_fld_ptr_esp(DEF_LONG);
     934        compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    957935
    958936        //add esp,4
    959         op_add_esp(4);
     937        compiler.codeGenerator.op_add_esp(4);
    960938    }
    961939
    962940    if(type[sp-2]==DEF_DOUBLE){
    963941        //fld qword ptr[esp]
    964         op_fld_ptr_esp(DEF_DOUBLE);
     942        compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    965943    }
    966944    else if(type[sp-2]==DEF_SINGLE){
    967945        //fld dword ptr[esp]
    968         op_fld_ptr_esp(DEF_SINGLE);
     946        compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    969947
    970948        //sub esp,4
    971         op_sub_esp(4);
     949        compiler.codeGenerator.op_sub_esp(4);
    972950    }
    973951    else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
    … …  
    975953
    976954        //fild qword ptr[esp]
    977         op_fld_ptr_esp(DEF_INT64);
     955        compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    978956    }
    979957    else{
    … …  
    981959
    982960        //fild dword ptr[esp]
    983         op_fld_ptr_esp(DEF_LONG);
     961        compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    984962
    985963        //sub esp,4
    986         op_sub_esp(4);
     964        compiler.codeGenerator.op_sub_esp(4);
    987965    }
    988966
    989967    //sub esp,8
    990     op_sub_esp(8);
     968    compiler.codeGenerator.op_sub_esp(8);
    991969
    992970    //fstp qword ptr[esp]
    993     OpBuffer[obp++]=(char)0xDD;
    994     OpBuffer[obp++]=(char)0x1C;
    995     OpBuffer[obp++]=(char)0x24;
     971    compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
    996972
    997973    //fstp qword ptr[esp+8]
    998     OpBuffer[obp++]=(char)0xDD;
    999     OpBuffer[obp++]=(char)0x5C;
    1000     OpBuffer[obp++]=(char)0x24;
    1001     OpBuffer[obp++]=(char)0x08;
     974    compiler.codeGenerator.op_fstp_base_offset(DEF_DOUBLE,REG_ESP,8);
    1002975
    1003976    //call pow
    1004977    extern const UserProc *pSub_pow;
    1005     op_call(pSub_pow);
     978    compiler.codeGenerator.op_call(pSub_pow);
    1006979
    1007980    //sub esp,8
    1008     op_sub_esp(8);
     981    compiler.codeGenerator.op_sub_esp(8);
    1009982
    1010983    //fstp qword ptr[esp]
    1011     OpBuffer[obp++]=(char)0xDD;
    1012     OpBuffer[obp++]=(char)0x1C;
    1013     OpBuffer[obp++]=(char)0x24;
     984    compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
    1014985
    1015986    sp--;
    … …  
    10671038        if(type[sp-1]==DEF_DOUBLE){
    10681039            //fld qword ptr[esp]
    1069             op_fld_ptr_esp(DEF_DOUBLE);
    1070 
    1071             //add esp,4
    1072             op_add_esp(4);
    1073 
    1074             //fistp dword ptr[esp]
    1075             op_fistp_ptr_esp( sizeof(long) );
    1076 
    1077             //pop ecx
    1078             op_pop(REG_ECX);
     1040            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     1041
     1042            //add esp,4
     1043            compiler.codeGenerator.op_add_esp(4);
     1044
     1045            //fistp dword ptr[esp]
     1046            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
     1047
     1048            //pop ecx
     1049            compiler.codeGenerator.op_pop(REG_ECX);
    10791050        }
    10801051        else if(type[sp-1]==DEF_SINGLE){
    10811052            //fld dword ptr[esp]
    1082             op_fld_ptr_esp(DEF_SINGLE);
    1083 
    1084             //fistp dword ptr[esp]
    1085             op_fistp_ptr_esp( sizeof(long) );
    1086 
    1087             //pop ecx
    1088             op_pop(REG_ECX);
     1053            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     1054
     1055            //fistp dword ptr[esp]
     1056            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
     1057
     1058            //pop ecx
     1059            compiler.codeGenerator.op_pop(REG_ECX);
    10891060        }
    10901061        else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    10911062            //pop ecx
    1092             op_pop(REG_ECX);
    1093 
    1094             //add esp,4
    1095             op_add_esp(4);
    1096         }
    1097         else{
    1098             //pop ecx
    1099             op_pop(REG_ECX);
     1063            compiler.codeGenerator.op_pop(REG_ECX);
     1064
     1065            //add esp,4
     1066            compiler.codeGenerator.op_add_esp(4);
     1067        }
     1068        else{
     1069            //pop ecx
     1070            compiler.codeGenerator.op_pop(REG_ECX);
    11001071        }
    11011072
    … …  
    11031074        if(type[sp-2]==DEF_DOUBLE){
    11041075            //fld qword ptr[esp]
    1105             op_fld_ptr_esp(DEF_DOUBLE);
     1076            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    11061077
    11071078            //fistp qword ptr[esp]
    1108             op_fistp_ptr_esp( sizeof(_int64) );
     1079            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    11091080
    11101081            //pop eax
    1111             op_pop(REG_EAX);
     1082            compiler.codeGenerator.op_pop(REG_EAX);
    11121083
    11131084            //pop edx
    1114             op_pop(REG_EDX);
     1085            compiler.codeGenerator.op_pop(REG_EDX);
    11151086        }
    11161087        else if(type[sp-2]==DEF_SINGLE){
    11171088            //fld dword ptr[esp]
    1118             op_fld_ptr_esp(DEF_SINGLE);
     1089            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    11191090
    11201091            //sub esp,4
    1121             op_sub_esp(4);
     1092            compiler.codeGenerator.op_sub_esp(4);
    11221093
    11231094            //fistp qword ptr[esp]
    1124             op_fistp_ptr_esp( sizeof(_int64) );
     1095            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    11251096
    11261097            //pop eax
    1127             op_pop(REG_EAX);
     1098            compiler.codeGenerator.op_pop(REG_EAX);
    11281099
    11291100            //pop edx
    1130             op_pop(REG_EDX);
     1101            compiler.codeGenerator.op_pop(REG_EDX);
    11311102        }
    11321103        else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
    11331104            //pop eax
    1134             op_pop(REG_EAX);
     1105            compiler.codeGenerator.op_pop(REG_EAX);
    11351106
    11361107            //pop edx
    1137             op_pop(REG_EDX);
     1108            compiler.codeGenerator.op_pop(REG_EDX);
    11381109        }
    11391110        else{
    11401111            //pop eax
    1141             op_pop(REG_EAX);
     1112            compiler.codeGenerator.op_pop(REG_EAX);
    11421113
    11431114            if(IsSignedType(type[sp-2])){
    … …  
    11461117                   
    11471118                //cdq
    1148                 op_cdq();
     1119                compiler.codeGenerator.op_cdq();
    11491120            }
    11501121            else{
    … …  
    11531124
    11541125                //xor edx,edx
    1155                 op_zero_reg(REG_EDX);
     1126                compiler.codeGenerator.op_zero_reg(REG_EDX);
    11561127            }
    11571128        }
    … …  
    11591130        //call _allshl
    11601131        extern const UserProc *pSub_allshl;
    1161         op_call(pSub_allshl);
     1132        compiler.codeGenerator.op_call(pSub_allshl);
    11621133
    11631134        //push edx
    1164         op_push(REG_EDX);
     1135        compiler.codeGenerator.op_push(REG_EDX);
    11651136
    11661137        //push eax
    1167         op_push(REG_EAX);
     1138        compiler.codeGenerator.op_push(REG_EAX);
    11681139
    11691140        sp--;
    … …  
    11771148        if(type[sp-1]==DEF_DOUBLE){
    11781149            //fld qword ptr[esp]
    1179             op_fld_ptr_esp(DEF_DOUBLE);
    1180 
    1181             //add esp,4
    1182             op_add_esp(4);
    1183 
    1184             //fistp dword ptr[esp]
    1185             op_fistp_ptr_esp( sizeof(long) );
    1186 
    1187             //pop ecx
    1188             op_pop(REG_ECX);
     1150            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     1151
     1152            //add esp,4
     1153            compiler.codeGenerator.op_add_esp(4);
     1154
     1155            //fistp dword ptr[esp]
     1156            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
     1157
     1158            //pop ecx
     1159            compiler.codeGenerator.op_pop(REG_ECX);
    11891160        }
    11901161        else if(type[sp-1]==DEF_SINGLE){
    11911162            //fld dword ptr[esp]
    1192             op_fld_ptr_esp(DEF_SINGLE);
    1193 
    1194             //fistp dword ptr[esp]
    1195             op_fistp_ptr_esp( sizeof(long) );
    1196 
    1197             //pop ecx
    1198             op_pop(REG_ECX);
     1163            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     1164
     1165            //fistp dword ptr[esp]
     1166            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
     1167
     1168            //pop ecx
     1169            compiler.codeGenerator.op_pop(REG_ECX);
    11991170        }
    12001171        else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    12011172            //pop ecx
    1202             op_pop(REG_ECX);
    1203 
    1204             //add esp,4
    1205             op_add_esp(4);
    1206         }
    1207         else{
    1208             //pop ecx
    1209             op_pop(REG_ECX);
     1173            compiler.codeGenerator.op_pop(REG_ECX);
     1174
     1175            //add esp,4
     1176            compiler.codeGenerator.op_add_esp(4);
     1177        }
     1178        else{
     1179            //pop ecx
     1180            compiler.codeGenerator.op_pop(REG_ECX);
    12101181        }
    12111182
    12121183        if(type[sp-2]==DEF_DOUBLE){
    12131184            //fld qword ptr[esp]
    1214             op_fld_ptr_esp(DEF_DOUBLE);
    1215 
    1216             //add esp,4
    1217             op_add_esp(4);
    1218 
    1219             //fistp dword ptr[esp]
    1220             op_fistp_ptr_esp( sizeof(long) );
     1185            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     1186
     1187            //add esp,4
     1188            compiler.codeGenerator.op_add_esp(4);
     1189
     1190            //fistp dword ptr[esp]
     1191            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    12211192        }
    12221193        else if(type[sp-2]==DEF_SINGLE){
    12231194            //fld dword ptr[esp]
    1224             op_fld_ptr_esp(DEF_SINGLE);
    1225 
    1226             //fistp dword ptr[esp]
    1227             op_fistp_ptr_esp( sizeof(long) );
     1195            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     1196
     1197            //fistp dword ptr[esp]
     1198            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    12281199        }
    12291200
    12301201        //pop eax
    1231         op_pop(REG_EAX);
     1202        compiler.codeGenerator.op_pop(REG_EAX);
    12321203
    12331204        //sub esp,4
    1234         op_sub_esp(4);
     1205        compiler.codeGenerator.op_sub_esp(4);
    12351206
    12361207        //shl eax,cl
    1237         OpBuffer[obp++]=(char)0xD3;
    1238         OpBuffer[obp++]=(char)0xE0;
     1208        compiler.codeGenerator.PutOld(
     1209            (char)0xD3,
     1210            (char)0xE0
     1211        );
    12391212
    12401213        //mov dword ptr[esp],eax
    1241         OpBuffer[obp++]=(char)0x89;
    1242         OpBuffer[obp++]=(char)0x04;
    1243         OpBuffer[obp++]=(char)0x24;
     1214        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
    12441215
    12451216        sp--;
    … …  
    12691240        if(type[sp-1]==DEF_DOUBLE){
    12701241            //fld qword ptr[esp]
    1271             op_fld_ptr_esp(DEF_DOUBLE);
    1272 
    1273             //add esp,4
    1274             op_add_esp(4);
    1275 
    1276             //fistp dword ptr[esp]
    1277             op_fistp_ptr_esp( sizeof(long) );
    1278 
    1279             //pop ecx
    1280             op_pop(REG_ECX);
     1242            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     1243
     1244            //add esp,4
     1245            compiler.codeGenerator.op_add_esp(4);
     1246
     1247            //fistp dword ptr[esp]
     1248            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
     1249
     1250            //pop ecx
     1251            compiler.codeGenerator.op_pop(REG_ECX);
    12811252        }
    12821253        else if(type[sp-1]==DEF_SINGLE){
    12831254            //fld dword ptr[esp]
    1284             op_fld_ptr_esp(DEF_SINGLE);
    1285 
    1286             //fistp dword ptr[esp]
    1287             op_fistp_ptr_esp( sizeof(long) );
    1288 
    1289             //pop ecx
    1290             op_pop(REG_ECX);
     1255            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     1256
     1257            //fistp dword ptr[esp]
     1258            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
     1259
     1260            //pop ecx
     1261            compiler.codeGenerator.op_pop(REG_ECX);
    12911262        }
    12921263        else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    12931264            //pop ecx
    1294             op_pop(REG_ECX);
    1295 
    1296             //add esp,4
    1297             op_add_esp(4);
    1298         }
    1299         else{
    1300             //pop ecx
    1301             op_pop(REG_ECX);
     1265            compiler.codeGenerator.op_pop(REG_ECX);
     1266
     1267            //add esp,4
     1268            compiler.codeGenerator.op_add_esp(4);
     1269        }
     1270        else{
     1271            //pop ecx
     1272            compiler.codeGenerator.op_pop(REG_ECX);
    13021273        }
    13031274
    … …  
    13051276        if(type[sp-2]==DEF_DOUBLE){
    13061277            //fld qword ptr[esp]
    1307             op_fld_ptr_esp(DEF_DOUBLE);
     1278            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    13081279
    13091280            //fistp qword ptr[esp]
    1310             op_fistp_ptr_esp( sizeof(_int64) );
     1281            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    13111282
    13121283            //pop eax
    1313             op_pop(REG_EAX);
     1284            compiler.codeGenerator.op_pop(REG_EAX);
    13141285
    13151286            //pop edx
    1316             op_pop(REG_EDX);
     1287            compiler.codeGenerator.op_pop(REG_EDX);
    13171288        }
    13181289        else if(type[sp-2]==DEF_SINGLE){
    13191290            //fld dword ptr[esp]
    1320             op_fld_ptr_esp(DEF_SINGLE);
     1291            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    13211292
    13221293            //sub esp,4
    1323             op_sub_esp(4);
     1294            compiler.codeGenerator.op_sub_esp(4);
    13241295
    13251296            //fistp qword ptr[esp]
    1326             op_fistp_ptr_esp( sizeof(_int64) );
     1297            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    13271298
    13281299            //pop eax
    1329             op_pop(REG_EAX);
     1300            compiler.codeGenerator.op_pop(REG_EAX);
    13301301
    13311302            //pop edx
    1332             op_pop(REG_EDX);
     1303            compiler.codeGenerator.op_pop(REG_EDX);
    13331304        }
    13341305        else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
    13351306            //pop eax
    1336             op_pop(REG_EAX);
     1307            compiler.codeGenerator.op_pop(REG_EAX);
    13371308
    13381309            //pop edx
    1339             op_pop(REG_EDX);
     1310            compiler.codeGenerator.op_pop(REG_EDX);
    13401311        }
    13411312        else{
    13421313            //pop eax
    1343             op_pop(REG_EAX);
     1314            compiler.codeGenerator.op_pop(REG_EAX);
    13441315
    13451316            if(IsSignedType(type[sp-2])){
    … …  
    13481319
    13491320                //cdq
    1350                 op_cdq();
     1321                compiler.codeGenerator.op_cdq();
    13511322            }
    13521323            else{
    … …  
    13551326
    13561327                //xor edx,edx
    1357                 op_zero_reg(REG_EDX);
     1328                compiler.codeGenerator.op_zero_reg(REG_EDX);
    13581329            }
    13591330        }
    … …  
    13641335            //call _aullshr
    13651336            extern const UserProc *pSub_aullshr;
    1366             op_call(pSub_aullshr);
     1337            compiler.codeGenerator.op_call(pSub_aullshr);
    13671338        }
    13681339        else{
    … …  
    13711342            //call _allshr
    13721343            extern const UserProc *pSub_allshr;
    1373             op_call(pSub_allshr);
     1344            compiler.codeGenerator.op_call(pSub_allshr);
    13741345        }
    13751346
    13761347        //push edx
    1377         op_push(REG_EDX);
     1348        compiler.codeGenerator.op_push(REG_EDX);
    13781349
    13791350        //push eax
    1380         op_push(REG_EAX);
     1351        compiler.codeGenerator.op_push(REG_EAX);
    13811352
    13821353        sp--;
    … …  
    13901361        if(type[sp-1]==DEF_DOUBLE){
    13911362            //fld qword ptr[esp]
    1392             op_fld_ptr_esp(DEF_DOUBLE);
    1393 
    1394             //add esp,4
    1395             op_add_esp(4);
    1396 
    1397             //fistp dword ptr[esp]
    1398             op_fistp_ptr_esp( sizeof(long) );
    1399 
    1400             //pop ecx
    1401             op_pop(REG_ECX);
     1363            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     1364
     1365            //add esp,4
     1366            compiler.codeGenerator.op_add_esp(4);
     1367
     1368            //fistp dword ptr[esp]
     1369            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
     1370
     1371            //pop ecx
     1372            compiler.codeGenerator.op_pop(REG_ECX);
    14021373        }
    14031374        else if(type[sp-1]==DEF_SINGLE){
    14041375            //fld dword ptr[esp]
    1405             op_fld_ptr_esp(DEF_SINGLE);
    1406 
    1407             //fistp dword ptr[esp]
    1408             op_fistp_ptr_esp( sizeof(long) );
    1409 
    1410             //pop ecx
    1411             op_pop(REG_ECX);
     1376            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     1377
     1378            //fistp dword ptr[esp]
     1379            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
     1380
     1381            //pop ecx
     1382            compiler.codeGenerator.op_pop(REG_ECX);
    14121383        }
    14131384        else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    14141385            //pop ecx
    1415             op_pop(REG_ECX);
    1416 
    1417             //add esp,4
    1418             op_add_esp(4);
    1419         }
    1420         else{
    1421             //pop ecx
    1422             op_pop(REG_ECX);
     1386            compiler.codeGenerator.op_pop(REG_ECX);
     1387
     1388            //add esp,4
     1389            compiler.codeGenerator.op_add_esp(4);
     1390        }
     1391        else{
     1392            //pop ecx
     1393            compiler.codeGenerator.op_pop(REG_ECX);
    14231394        }
    14241395
    14251396        if(type[sp-2]==DEF_DOUBLE){
    14261397            //fld qword ptr[esp]
    1427             op_fld_ptr_esp(DEF_DOUBLE);
    1428 
    1429             //add esp,4
    1430             op_add_esp(4);
    1431 
    1432             //fistp dword ptr[esp]
    1433             op_fistp_ptr_esp( sizeof(long) );
     1398            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     1399
     1400            //add esp,4
     1401            compiler.codeGenerator.op_add_esp(4);
     1402
     1403            //fistp dword ptr[esp]
     1404            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    14341405        }
    14351406        else if(type[sp-2]==DEF_SINGLE){
    14361407            //fld dword ptr[esp]
    1437             op_fld_ptr_esp(DEF_SINGLE);
    1438 
    1439             //fistp dword ptr[esp]
    1440             op_fistp_ptr_esp( sizeof(long) );
     1408            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     1409
     1410            //fistp dword ptr[esp]
     1411            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    14411412        }
    14421413
    14431414        //pop eax
    1444         op_pop(REG_EAX);
     1415        compiler.codeGenerator.op_pop(REG_EAX);
    14451416
    14461417        //sub esp,4
    1447         op_sub_esp(4);
     1418        compiler.codeGenerator.op_sub_esp(4);
    14481419
    14491420        if(type[sp-2]==DEF_DWORD){
    14501421            //shr eax,cl
    1451             OpBuffer[obp++]=(char)0xD3;
    1452             OpBuffer[obp++]=(char)0xE8;
     1422            compiler.codeGenerator.PutOld(
     1423                (char)0xD3,
     1424                (char)0xE8
     1425            );
    14531426        }
    14541427        else{
    14551428            //sar eax,cl
    1456             OpBuffer[obp++]=(char)0xD3;
    1457             OpBuffer[obp++]=(char)0xF8;
     1429            compiler.codeGenerator.PutOld(
     1430                (char)0xD3,
     1431                (char)0xF8
     1432            );
    14581433        }
    14591434
    14601435        //mov dword ptr[esp],eax
    1461         OpBuffer[obp++]=(char)0x89;
    1462         OpBuffer[obp++]=(char)0x04;
    1463         OpBuffer[obp++]=(char)0x24;
     1436        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
    14641437
    14651438        sp--;

  • trunk/abdev/BasicCompiler32/NumOpe_Logical.cpp

    r206 r225  
    11#include "stdafx.h"
     2
     3#include <Compiler.h>
    24
    35#include "../BasicCompiler_Common/common.h"
    … …  
    2830
    2931            //pop ebx
    30             op_pop(REG_EBX);
     32            compiler.codeGenerator.op_pop(REG_EBX);
    3133
    3234            //pop ecx
    33             op_pop(REG_ECX);
     35            compiler.codeGenerator.op_pop(REG_ECX);
    3436        }
    3537        else{
    … …  
    3739
    3840            //pop eax
    39             op_pop(REG_EAX);
     41            compiler.codeGenerator.op_pop(REG_EAX);
    4042
    4143            if(IsSignedType(type[sp-1])){
    … …  
    4446               
    4547                //cdq
    46                 op_cdq();
     48                compiler.codeGenerator.op_cdq();
    4749            }
    4850            else{
    … …  
    5153
    5254                //xor edx,edx
    53                 op_zero_reg(REG_EDX);
     55                compiler.codeGenerator.op_zero_reg(REG_EDX);
    5456            }
    5557
    5658            //mov ebx,eax
    57             OpBuffer[obp++]=(char)0x8B;
    58             OpBuffer[obp++]=(char)0xD8;
     59            compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
    5960
    6061            //mov ecx,edx
    61             OpBuffer[obp++]=(char)0x8B;
    62             OpBuffer[obp++]=(char)0xCA;
     62            compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
    6363        }
    6464
    … …  
    6767
    6868            //xor dword ptr[esp],ebx
    69             OpBuffer[obp++]=(char)0x31;
    70             OpBuffer[obp++]=(char)0x1C;
    71             OpBuffer[obp++]=(char)0x24;
     69            compiler.codeGenerator.PutOld(
     70                (char)0x31,
     71                (char)0x1C,
     72                (char)0x24
     73            );
    7274
    7375            //xor dword ptr[esp+sizeof(long)],ecx
    74             OpBuffer[obp++]=(char)0x31;
    75             OpBuffer[obp++]=(char)0x4C;
    76             OpBuffer[obp++]=(char)0x24;
    77             OpBuffer[obp++]=(char)0x04;
     76            compiler.codeGenerator.PutOld(
     77                (char)0x31,
     78                (char)0x4C,
     79                (char)0x24,
     80                (char)0x04
     81            );
    7882        }
    7983        else{
    … …  
    8185            if(IsSignedType(type[sp-2])){
    8286                //pop eax
    83                 op_pop(REG_EAX);
     87                compiler.codeGenerator.op_pop(REG_EAX);
    8488
    8589                //符号拡張
    … …  
    8791
    8892                //cdq
    89                 op_cdq();
     93                compiler.codeGenerator.op_cdq();
    9094            }
    9195            else{
    9296                //pop eax
    93                 op_pop(REG_EAX);
     97                compiler.codeGenerator.op_pop(REG_EAX);
    9498
    9599                //ビット拡張
    … …  
    97101
    98102                //xor edx,edx
    99                 op_zero_reg(REG_EDX);
     103                compiler.codeGenerator.op_zero_reg(REG_EDX);
    100104            }
    101105
    102106            //xor ebx,eax
    103             OpBuffer[obp++]=(char)0x33;
    104             OpBuffer[obp++]=(char)0xD8;
     107            compiler.codeGenerator.op_xor_RR( REG_EBX, REG_EAX );
    105108
    106109            //xor ecx,edx
    107             OpBuffer[obp++]=(char)0x33;
    108             OpBuffer[obp++]=(char)0xCA;
     110            compiler.codeGenerator.op_xor_RR( REG_ECX, REG_EDX );
    109111
    110112            //push ecx
    111             op_push(REG_ECX);
     113            compiler.codeGenerator.op_push(REG_ECX);
    112114
    113115            //push ebx
    114             op_push(REG_EBX);
     116            compiler.codeGenerator.op_push(REG_EBX);
    115117        }
    116118
    … …  
    125127
    126128        //pop ebx
    127         op_pop(REG_EBX);
     129        compiler.codeGenerator.op_pop(REG_EBX);
    128130
    129131        //pop eax
    130         op_pop(REG_EAX);
     132        compiler.codeGenerator.op_pop(REG_EAX);
    131133
    132134        //sub esp,4
    133         op_sub_esp(4);
     135        compiler.codeGenerator.op_sub_esp(4);
    134136
    135137        //xor eax,ebx
    136         OpBuffer[obp++]=(char)0x33;
    137         OpBuffer[obp++]=(char)0xC3;
     138        compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
    138139
    139140        //mov dword ptr[esp],eax
    140         OpBuffer[obp++]=(char)0x89;
    141         OpBuffer[obp++]=(char)0x04;
    142         OpBuffer[obp++]=(char)0x24;
     141        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
    143142
    144143        sp--;
    … …  
    174173
    175174            //pop ebx
    176             op_pop(REG_EBX);
     175            compiler.codeGenerator.op_pop(REG_EBX);
    177176
    178177            //pop ecx
    179             op_pop(REG_ECX);
     178            compiler.codeGenerator.op_pop(REG_ECX);
    180179        }
    181180        else{
    … …  
    183182
    184183            //pop eax
    185             op_pop(REG_EAX);
     184            compiler.codeGenerator.op_pop(REG_EAX);
    186185
    187186            if(IsSignedType(type[sp-1])){
    … …  
    190189               
    191190                //cdq
    192                 op_cdq();
     191                compiler.codeGenerator.op_cdq();
    193192            }
    194193            else{
    … …  
    197196
    198197                //xor edx,edx
    199                 op_zero_reg(REG_EDX);
     198                compiler.codeGenerator.op_zero_reg(REG_EDX);
    200199            }
    201200
    202201            //mov ebx,eax
    203             OpBuffer[obp++]=(char)0x8B;
    204             OpBuffer[obp++]=(char)0xD8;
     202            compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
    205203
    206204            //mov ecx,edx
    207             OpBuffer[obp++]=(char)0x8B;
    208             OpBuffer[obp++]=(char)0xCA;
     205            compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
    209206        }
    210207
    … …  
    213210
    214211            //or dword ptr[esp],ebx
    215             OpBuffer[obp++]=(char)0x09;
    216             OpBuffer[obp++]=(char)0x1C;
    217             OpBuffer[obp++]=(char)0x24;
     212            compiler.codeGenerator.PutOld(
     213                (char)0x09,
     214                (char)0x1C,
     215                (char)0x24
     216            );
    218217
    219218            //or dword ptr[esp+sizeof(long)],ecx
    220             OpBuffer[obp++]=(char)0x09;
    221             OpBuffer[obp++]=(char)0x4C;
    222             OpBuffer[obp++]=(char)0x24;
    223             OpBuffer[obp++]=(char)0x04;
     219            compiler.codeGenerator.PutOld(
     220                (char)0x09,
     221                (char)0x4C,
     222                (char)0x24,
     223                (char)0x04
     224            );
    224225        }
    225226        else{
    … …  
    227228            if(IsSignedType(type[sp-2])){
    228229                //pop eax
    229                 op_pop(REG_EAX);
     230                compiler.codeGenerator.op_pop(REG_EAX);
    230231
    231232                //符号拡張
    … …  
    233234
    234235                //cdq
    235                 op_cdq();
     236                compiler.codeGenerator.op_cdq();
    236237            }
    237238            else{
    238239                //pop eax
    239                 op_pop(REG_EAX);
     240                compiler.codeGenerator.op_pop(REG_EAX);
    240241
    241242                //ビット拡張
    … …  
    243244
    244245                //xor edx,edx
    245                 op_zero_reg(REG_EDX);
     246                compiler.codeGenerator.op_zero_reg(REG_EDX);
    246247            }
    247248
    248249            //or ebx,eax
    249             OpBuffer[obp++]=(char)0x0B;
    250             OpBuffer[obp++]=(char)0xD8;
     250            compiler.codeGenerator.op_or_RR( sizeof(long), REG_EBX, REG_EAX );
    251251
    252252            //or ecx,edx
    253             OpBuffer[obp++]=(char)0x0B;
    254             OpBuffer[obp++]=(char)0xCA;
     253            compiler.codeGenerator.op_or_RR( sizeof(long), REG_ECX, REG_EDX );
    255254
    256255            //push ecx
    257             op_push(REG_ECX);
     256            compiler.codeGenerator.op_push(REG_ECX);
    258257
    259258            //push ebx
    260             op_push(REG_EBX);
     259            compiler.codeGenerator.op_push(REG_EBX);
    261260        }
    262261
    … …  
    271270
    272271        //pop ebx
    273         op_pop(REG_EBX);
     272        compiler.codeGenerator.op_pop(REG_EBX);
    274273
    275274        //pop eax
    276         op_pop(REG_EAX);
     275        compiler.codeGenerator.op_pop(REG_EAX);
    277276
    278277        //sub esp,4
    279         op_sub_esp(4);
     278        compiler.codeGenerator.op_sub_esp(4);
    280279
    281280        //or eax,ebx
    282         OpBuffer[obp++]=(char)0x0B;
    283         OpBuffer[obp++]=(char)0xC3;
     281        compiler.codeGenerator.op_or_RR( sizeof(long), REG_EAX, REG_EBX );
    284282
    285283        //mov dword ptr[esp],eax
    286         OpBuffer[obp++]=(char)0x89;
    287         OpBuffer[obp++]=(char)0x04;
    288         OpBuffer[obp++]=(char)0x24;
     284        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
    289285
    290286        sp--;
    … …  
    320316
    321317            //pop ebx
    322             op_pop(REG_EBX);
     318            compiler.codeGenerator.op_pop(REG_EBX);
    323319
    324320            //pop ecx
    325             op_pop(REG_ECX);
     321            compiler.codeGenerator.op_pop(REG_ECX);
    326322        }
    327323        else{
    … …  
    329325
    330326            //pop eax
    331             op_pop(REG_EAX);
     327            compiler.codeGenerator.op_pop(REG_EAX);
    332328
    333329            if(IsSignedType(type[sp-1])){
    … …  
    336332               
    337333                //cdq
    338                 op_cdq();
     334                compiler.codeGenerator.op_cdq();
    339335            }
    340336            else{
    … …  
    343339
    344340                //xor edx,edx
    345                 op_zero_reg(REG_EDX);
     341                compiler.codeGenerator.op_zero_reg(REG_EDX);
    346342            }
    347343
    348344            //mov ebx,eax
    349             OpBuffer[obp++]=(char)0x8B;
    350             OpBuffer[obp++]=(char)0xD8;
     345            compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
    351346
    352347            //mov ecx,edx
    353             OpBuffer[obp++]=(char)0x8B;
    354             OpBuffer[obp++]=(char)0xCA;
     348            compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
    355349        }
    356350
    … …  
    359353
    360354            //and dword ptr[esp],ebx
    361             OpBuffer[obp++]=(char)0x21;
    362             OpBuffer[obp++]=(char)0x1C;
    363             OpBuffer[obp++]=(char)0x24;
     355            compiler.codeGenerator.PutOld(
     356                (char)0x21,
     357                (char)0x1C,
     358                (char)0x24
     359            );
    364360
    365361            //and dword ptr[esp+sizeof(long)],ecx
    366             OpBuffer[obp++]=(char)0x21;
    367             OpBuffer[obp++]=(char)0x4C;
    368             OpBuffer[obp++]=(char)0x24;
    369             OpBuffer[obp++]=(char)0x04;
     362            compiler.codeGenerator.PutOld(
     363                (char)0x21,
     364                (char)0x4C,
     365                (char)0x24,
     366                (char)0x04
     367            );
    370368        }
    371369        else{
    … …  
    373371            if(IsSignedType(type[sp-2])){
    374372                //pop eax
    375                 op_pop(REG_EAX);
     373                compiler.codeGenerator.op_pop(REG_EAX);
    376374
    377375                //符号拡張
    … …  
    379377
    380378                //cdq
    381                 op_cdq();
     379                compiler.codeGenerator.op_cdq();
    382380            }
    383381            else{
    384382                //pop eax
    385                 op_pop(REG_EAX);
     383                compiler.codeGenerator.op_pop(REG_EAX);
    386384
    387385                //ビット拡張
    … …  
    389387
    390388                //xor edx,edx
    391                 op_zero_reg(REG_EDX);
     389                compiler.codeGenerator.op_zero_reg(REG_EDX);
    392390            }
    393391
    394392            //and ebx,eax
    395             OpBuffer[obp++]=(char)0x23;
    396             OpBuffer[obp++]=(char)0xD8;
     393            compiler.codeGenerator.op_and_RR( REG_EBX, REG_EAX );
    397394
    398395            //and ecx,edx
    399             OpBuffer[obp++]=(char)0x23;
    400             OpBuffer[obp++]=(char)0xCA;
     396            compiler.codeGenerator.op_and_RR( REG_ECX, REG_EDX );
    401397
    402398            //push ecx
    403             op_push(REG_ECX);
     399            compiler.codeGenerator.op_push(REG_ECX);
    404400
    405401            //push ebx
    406             op_push(REG_EBX);
     402            compiler.codeGenerator.op_push(REG_EBX);
    407403        }
    408404
    … …  
    417413
    418414        //pop ebx
    419         op_pop(REG_EBX);
     415        compiler.codeGenerator.op_pop(REG_EBX);
    420416
    421417        //pop eax
    422         op_pop(REG_EAX);
     418        compiler.codeGenerator.op_pop(REG_EAX);
    423419
    424420        //sub esp,4
    425         op_sub_esp(4);
     421        compiler.codeGenerator.op_sub_esp(4);
    426422
    427423        //and eax,ebx
    428         OpBuffer[obp++]=(char)0x23;
    429         OpBuffer[obp++]=(char)0xC3;
     424        compiler.codeGenerator.op_and_RR( REG_EAX, REG_EBX );
    430425
    431426        //mov dword ptr[esp],eax
    432         OpBuffer[obp++]=(char)0x89;
    433         OpBuffer[obp++]=(char)0x04;
    434         OpBuffer[obp++]=(char)0x24;
     427        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
    435428
    436429        sp--;
    … …  
    454447    if( type[sp - 1] == DEF_BOOLEAN ){
    455448        //pop eax
    456         op_pop( REG_EAX );
     449        compiler.codeGenerator.op_pop( REG_EAX );
    457450
    458451        //cmp eax,0
    459         op_cmp_value(GetTypeSize(type[sp-1],-1),REG_EAX,0);
     452        compiler.codeGenerator.op_cmp_value(GetTypeSize(type[sp-1],-1),REG_EAX,0);
    460453
    461454        //setne al
    462         op_setne( REG_EAX );
     455        compiler.codeGenerator.op_setne( REG_EAX );
    463456
    464457        //and eax,000000FFh
    465         op_and_RV(REG_EAX,(int)0xFF);
     458        compiler.codeGenerator.op_and_RV(REG_EAX,(int)0xFF);
    466459
    467460        //neg
    468         op_neg( REG_EAX );
     461        compiler.codeGenerator.op_neg( REG_EAX );
    469462
    470463        //sbb eax, eax
    471         op_sbb_RR( REG_EAX, REG_EAX );
     464        compiler.codeGenerator.op_sbb_RR( REG_EAX, REG_EAX );
    472465
    473466        //add eax, 1
    474         op_add_RV8( REG_EAX, 1 );
     467        compiler.codeGenerator.op_add_RV8( REG_EAX, 1 );
    475468
    476469        //push eax
    477         op_push( REG_EAX );
     470        compiler.codeGenerator.op_push( REG_EAX );
    478471    }
    479472    else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    … …  
    483476
    484477        //not dword ptr[esp]
    485         OpBuffer[obp++]=(char)0xF7;
    486         OpBuffer[obp++]=(char)0x14;
    487         OpBuffer[obp++]=(char)0x24;
     478        compiler.codeGenerator.PutOld(
     479            (char)0xF7,
     480            (char)0x14,
     481            (char)0x24
     482        );
    488483
    489484        //not dword ptr[esp+4]
    490         OpBuffer[obp++]=(char)0xF7;
    491         OpBuffer[obp++]=(char)0x54;
    492         OpBuffer[obp++]=(char)0x24;
    493         OpBuffer[obp++]=(char)0x04;
     485        compiler.codeGenerator.PutOld(
     486            (char)0xF7,
     487            (char)0x54,
     488            (char)0x24,
     489            (char)0x04
     490        );
    494491    }
    495492    else{
    … …  
    499496
    500497        //not dword ptr[esp]
    501         OpBuffer[obp++]=(char)0xF7;
    502         OpBuffer[obp++]=(char)0x14;
    503         OpBuffer[obp++]=(char)0x24;
     498        compiler.codeGenerator.PutOld(
     499            (char)0xF7,
     500            (char)0x14,
     501            (char)0x24
     502        );
    504503    }
    505504

  • trunk/abdev/BasicCompiler32/NumOpe_Relation.cpp

    r206 r225  
    11#include "stdafx.h"
     2
     3#include <Compiler.h>
    24
    35#include "../BasicCompiler_Common/common.h"
    … …  
    4446        if(type_stack[sp-1]==DEF_DOUBLE){
    4547            //fld qword ptr[esp]
    46             op_fld_ptr_esp(DEF_DOUBLE);
     48            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    4749
    4850            //add esp,8
    49             op_add_esp(8);
     51            compiler.codeGenerator.op_add_esp(8);
    5052        }
    5153        else if(type_stack[sp-1]==DEF_SINGLE){
    5254            //fld dword ptr[esp]
    53             op_fld_ptr_esp(DEF_SINGLE);
    54 
    55             //add esp,4
    56             op_add_esp(4);
     55            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     56
     57            //add esp,4
     58            compiler.codeGenerator.op_add_esp(4);
    5759        }
    5860        else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
    … …  
    6062
    6163            //fild qword ptr[esp]
    62             op_fld_ptr_esp(DEF_INT64);
     64            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    6365
    6466            //add esp,8
    65             op_add_esp(8);
     67            compiler.codeGenerator.op_add_esp(8);
    6668        }
    6769        else{
    … …  
    6971
    7072            //fild dword ptr[esp]
    71             op_fld_ptr_esp(DEF_LONG);
    72 
    73             //add esp,4
    74             op_add_esp(4);
     73            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
     74
     75            //add esp,4
     76            compiler.codeGenerator.op_add_esp(4);
    7577        }
    7678
    7779        if(type_stack[sp-2]==DEF_DOUBLE){
    7880            //fld qword ptr[esp]
    79             op_fld_ptr_esp(DEF_DOUBLE);
    80 
    81             //add esp,4
    82             op_add_esp(4);
     81            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     82
     83            //add esp,4
     84            compiler.codeGenerator.op_add_esp(4);
    8385        }
    8486        else if(type_stack[sp-2]==DEF_SINGLE){
    8587            //fld dword ptr[esp]
    86             op_fld_ptr_esp(DEF_SINGLE);
     88            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    8789        }
    8890        else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
    … …  
    9092
    9193            //fild qword ptr[esp]
    92             op_fld_ptr_esp(DEF_INT64);
    93 
    94             //add esp,4
    95             op_add_esp(4);
     94            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
     95
     96            //add esp,4
     97            compiler.codeGenerator.op_add_esp(4);
    9698        }
    9799        else{
    … …  
    99101
    100102            //fild dword ptr[esp]
    101             op_fld_ptr_esp(DEF_LONG);
     103            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    102104        }
    103105
    104106        //fcompp
    105         OpBuffer[obp++]=(char)0xDE;
    106         OpBuffer[obp++]=(char)0xD9;
     107        compiler.codeGenerator.op_fcompp();
    107108
    108109        //fnstsw ax
    109         OpBuffer[obp++]=(char)0xDF;
    110         OpBuffer[obp++]=(char)0xE0;
     110        compiler.codeGenerator.op_fnstsw_ax();
    111111
    112112        //mov ecx,1
    113         OpBuffer[obp++]=(char)0xB9;
    114         *((long *)(OpBuffer+obp))=1;
    115         obp+=sizeof(long);
     113        compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
    116114
    117115        //test ah,41h
    118         OpBuffer[obp++]=(char)0xF6;
    119         OpBuffer[obp++]=(char)0xC4;
    120         OpBuffer[obp++]=(char)0x41;
     116        compiler.codeGenerator.op_test_ah( (char)0x41 );
    121117
    122118        //jne 5
    123         OpBuffer[obp++]=(char)0x75;
    124         OpBuffer[obp++]=(char)0x02;
     119        compiler.codeGenerator.PutOld(
     120            (char)0x75,
     121            (char)0x02
     122        );
    125123
    126124        //xor ecx,ecx（ecxを0にする）
    127         op_zero_reg(REG_ECX);
     125        compiler.codeGenerator.op_zero_reg(REG_ECX);
    128126
    129127        //mov dword ptr[esp],ecx
    130         OpBuffer[obp++]=(char)0x89;
    131         OpBuffer[obp++]=(char)0x0C;
    132         OpBuffer[obp++]=(char)0x24;
     128        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
    133129    }
    134130    else if(Is64Type(AnswerType)){
    … …  
    147143
    148144        //cmp edx,ecx
    149         OpBuffer[obp++]=(char)0x3B;
    150         OpBuffer[obp++]=(char)0xD1;
     145        compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
    151146
    152147        if(IsSignedType(type_stack[sp-2])==0&&IsSignedType(type_stack[sp-1])==0){
    … …  
    206201
    207202        //xor eax,eax（eaxを0にする）
    208         op_zero_reg(REG_EAX);
     203        compiler.codeGenerator.op_zero_reg(REG_EAX);
    209204
    210205        //push eax
    211         op_push(REG_EAX);
     206        compiler.codeGenerator.op_push(REG_EAX);
    212207    }
    213208    else{
    … …  
    217212
    218213        //pop ebx
    219         op_pop(REG_EBX);
     214        compiler.codeGenerator.op_pop(REG_EBX);
    220215
    221216        //pop eax
    222         op_pop(REG_EAX);
     217        compiler.codeGenerator.op_pop(REG_EAX);
    223218
    224219        // どちらかのサイズが足りない場合は自動拡張する
    … …  
    226221
    227222        //sub esp,4
    228         op_sub_esp(4);
     223        compiler.codeGenerator.op_sub_esp(4);
    229224
    230225        //mov ecx,1
    … …  
    258253
    259254        //mov dword ptr[esp],ecx
    260         OpBuffer[obp++]=(char)0x89;
    261         OpBuffer[obp++]=(char)0x0C;
    262         OpBuffer[obp++]=(char)0x24;
     255        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
    263256    }
    264257
    … …  
    283276        if(type_stack[sp-1]==DEF_DOUBLE){
    284277            //fld qword ptr[esp]
    285             op_fld_ptr_esp(DEF_DOUBLE);
     278            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    286279
    287280            //add esp,8
    288             op_add_esp(8);
     281            compiler.codeGenerator.op_add_esp(8);
    289282        }
    290283        else if(type_stack[sp-1]==DEF_SINGLE){
    291284            //fld dword ptr[esp]
    292             op_fld_ptr_esp(DEF_SINGLE);
    293 
    294             //add esp,4
    295             op_add_esp(4);
     285            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     286
     287            //add esp,4
     288            compiler.codeGenerator.op_add_esp(4);
    296289        }
    297290        else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
    … …  
    299292
    300293            //fild qword ptr[esp]
    301             op_fld_ptr_esp(DEF_INT64);
     294            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    302295
    303296            //add esp,8
    304             op_add_esp(8);
     297            compiler.codeGenerator.op_add_esp(8);
    305298        }
    306299        else{
    … …  
    308301
    309302            //fild dword ptr[esp]
    310             op_fld_ptr_esp(DEF_LONG);
    311 
    312             //add esp,4
    313             op_add_esp(4);
     303            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
     304
     305            //add esp,4
     306            compiler.codeGenerator.op_add_esp(4);
    314307        }
    315308
    316309        if(type_stack[sp-2]==DEF_DOUBLE){
    317310            //fld qword ptr[esp]
    318             op_fld_ptr_esp(DEF_DOUBLE);
    319 
    320             //add esp,4
    321             op_add_esp(4);
     311            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     312
     313            //add esp,4
     314            compiler.codeGenerator.op_add_esp(4);
    322315        }
    323316        else if(type_stack[sp-2]==DEF_SINGLE){
    324317            //fld dword ptr[esp]
    325             op_fld_ptr_esp(DEF_SINGLE);
     318            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    326319        }
    327320        else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
    … …  
    329322
    330323            //fild qword ptr[esp]
    331             op_fld_ptr_esp(DEF_INT64);
    332 
    333             //add esp,4
    334             op_add_esp(4);
     324            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
     325
     326            //add esp,4
     327            compiler.codeGenerator.op_add_esp(4);
    335328        }
    336329        else{
    … …  
    338331
    339332            //fild dword ptr[esp]
    340             op_fld_ptr_esp(DEF_LONG);
     333            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    341334        }
    342335
    … …  
    346339
    347340        //fnstsw ax
    348         OpBuffer[obp++]=(char)0xDF;
    349         OpBuffer[obp++]=(char)0xE0;
     341        compiler.codeGenerator.op_fnstsw_ax();
    350342
    351343        //mov ecx,1
    … …  
    355347
    356348        //test ah,1
    357         OpBuffer[obp++]=(char)0xF6;
    358         OpBuffer[obp++]=(char)0xC4;
    359         OpBuffer[obp++]=(char)0x01;
     349        compiler.codeGenerator.op_test_ah( (char)0x01 );
    360350
    361351        //je 5
    … …  
    369359
    370360        //mov dword ptr[esp],ecx
    371         OpBuffer[obp++]=(char)0x89;
    372         OpBuffer[obp++]=(char)0x0C;
    373         OpBuffer[obp++]=(char)0x24;
     361        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
    374362    }
    375363    else if(Is64Type(AnswerType)){
    … …  
    447435
    448436        //xor eax,eax（eaxを0にする）
    449         op_zero_reg(REG_EAX);
     437        compiler.codeGenerator.op_zero_reg(REG_EAX);
    450438
    451439        //push eax
    452         op_push(REG_EAX);
     440        compiler.codeGenerator.op_push(REG_EAX);
    453441    }
    454442    else{
    … …  
    458446
    459447        //pop ebx
    460         op_pop(REG_EBX);
     448        compiler.codeGenerator.op_pop(REG_EBX);
    461449
    462450        //pop eax
    463         op_pop(REG_EAX);
     451        compiler.codeGenerator.op_pop(REG_EAX);
    464452
    465453        // どちらかのサイズが足りない場合は自動拡張する
    … …  
    467455
    468456        //sub esp,4
    469         op_sub_esp(4);
     457        compiler.codeGenerator.op_sub_esp(4);
    470458
    471459        //mov ecx,1
    … …  
    499487
    500488        //mov dword ptr[esp],ecx
    501         OpBuffer[obp++]=(char)0x89;
    502         OpBuffer[obp++]=(char)0x0C;
    503         OpBuffer[obp++]=(char)0x24;
     489        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
    504490    }
    505491
    … …  
    527513        if(type_stack[sp-1]==DEF_DOUBLE){
    528514            //fld qword ptr[esp]
    529             op_fld_ptr_esp(DEF_DOUBLE);
     515            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    530516
    531517            //add esp,8
    532             op_add_esp(8);
     518            compiler.codeGenerator.op_add_esp(8);
    533519        }
    534520        else if(type_stack[sp-1]==DEF_SINGLE){
    535521            //fld dword ptr[esp]
    536             op_fld_ptr_esp(DEF_SINGLE);
    537 
    538             //add esp,4
    539             op_add_esp(4);
     522            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     523
     524            //add esp,4
     525            compiler.codeGenerator.op_add_esp(4);
    540526        }
    541527        else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
    … …  
    543529
    544530            //fild qword ptr[esp]
    545             op_fld_ptr_esp(DEF_INT64);
     531            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    546532
    547533            //add esp,8
    548             op_add_esp(8);
     534            compiler.codeGenerator.op_add_esp(8);
    549535        }
    550536        else{
    … …  
    552538
    553539            //fild dword ptr[esp]
    554             op_fld_ptr_esp(DEF_LONG);
    555 
    556             //add esp,4
    557             op_add_esp(4);
     540            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
     541
     542            //add esp,4
     543            compiler.codeGenerator.op_add_esp(4);
    558544        }
    559545
    560546        if(type_stack[sp-2]==DEF_DOUBLE){
    561547            //fld qword ptr[esp]
    562             op_fld_ptr_esp(DEF_DOUBLE);
    563 
    564             //add esp,4
    565             op_add_esp(4);
     548            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     549
     550            //add esp,4
     551            compiler.codeGenerator.op_add_esp(4);
    566552        }
    567553        else if(type_stack[sp-2]==DEF_SINGLE){
    568554            //fld dword ptr[esp]
    569             op_fld_ptr_esp(DEF_SINGLE);
     555            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    570556        }
    571557        else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
    … …  
    573559
    574560            //fild qword ptr[esp]
    575             op_fld_ptr_esp(DEF_INT64);
    576 
    577             //add esp,4
    578             op_add_esp(4);
     561            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
     562
     563            //add esp,4
     564            compiler.codeGenerator.op_add_esp(4);
    579565        }
    580566        else{
    … …  
    582568
    583569            //fild dword ptr[esp]
    584             op_fld_ptr_esp(DEF_LONG);
     570            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    585571        }
    586572
    587573        //fcompp
    588         OpBuffer[obp++]=(char)0xDE;
    589         OpBuffer[obp++]=(char)0xD9;
     574        compiler.codeGenerator.op_fcompp();
    590575
    591576        //fnstsw ax
    592         OpBuffer[obp++]=(char)0xDF;
    593         OpBuffer[obp++]=(char)0xE0;
     577        compiler.codeGenerator.op_fnstsw_ax();
    594578
    595579        //mov ecx,1
    … …  
    599583
    600584        //test ah,01h
    601         OpBuffer[obp++]=(char)0xF6;
    602         OpBuffer[obp++]=(char)0xC4;
    603         OpBuffer[obp++]=(char)0x01;
     585        compiler.codeGenerator.op_test_ah( (char)0x41 );
    604586
    605587        //jne 5
    … …  
    613595
    614596        //mov dword ptr[esp],ecx
    615         OpBuffer[obp++]=(char)0x89;
    616         OpBuffer[obp++]=(char)0x0C;
    617         OpBuffer[obp++]=(char)0x24;
     597        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
    618598    }
    619599    else if(Is64Type(AnswerType)){
    … …  
    678658
    679659        //xor eax,eax（eaxを0にする）
    680         op_zero_reg(REG_EAX);
     660        compiler.codeGenerator.op_zero_reg(REG_EAX);
    681661
    682662        //jmp 5（演算終了位置へジャンプ）
    … …  
    694674
    695675        //push eax
    696         op_push(REG_EAX);
     676        compiler.codeGenerator.op_push(REG_EAX);
    697677    }
    698678    else{
    … …  
    702682
    703683        //pop ebx
    704         op_pop(REG_EBX);
     684        compiler.codeGenerator.op_pop(REG_EBX);
    705685
    706686        //pop eax
    707         op_pop(REG_EAX);
     687        compiler.codeGenerator.op_pop(REG_EAX);
    708688
    709689        // どちらかのサイズが足りない場合は自動拡張する
    … …  
    711691
    712692        //sub esp,4
    713         op_sub_esp(4);
     693        compiler.codeGenerator.op_sub_esp(4);
    714694
    715695        //mov ecx,1
    … …  
    743723
    744724        //mov dword ptr[esp],ecx
    745         OpBuffer[obp++]=(char)0x89;
    746         OpBuffer[obp++]=(char)0x0C;
    747         OpBuffer[obp++]=(char)0x24;
     725        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
    748726    }
    749727
    … …  
    771749        if(type_stack[sp-1]==DEF_DOUBLE){
    772750            //fld qword ptr[esp]
    773             op_fld_ptr_esp(DEF_DOUBLE);
     751            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    774752
    775753            //add esp,8
    776             op_add_esp(8);
     754            compiler.codeGenerator.op_add_esp(8);
    777755        }
    778756        else if(type_stack[sp-1]==DEF_SINGLE){
    779757            //fld dword ptr[esp]
    780             op_fld_ptr_esp(DEF_SINGLE);
    781 
    782             //add esp,4
    783             op_add_esp(4);
     758            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     759
     760            //add esp,4
     761            compiler.codeGenerator.op_add_esp(4);
    784762        }
    785763        else if(type_stack[sp-1]==DEF_INT64||type_stack[sp-1]==DEF_QWORD){
    … …  
    787765
    788766            //fild qword ptr[esp]
    789             op_fld_ptr_esp(DEF_INT64);
     767            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    790768
    791769            //add esp,8
    792             op_add_esp(8);
     770            compiler.codeGenerator.op_add_esp(8);
    793771        }
    794772        else{   //Long、DWord
    795773            //fild dword ptr[esp]
    796             op_fld_ptr_esp(DEF_LONG);
    797 
    798             //add esp,4
    799             op_add_esp(4);
     774            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
     775
     776            //add esp,4
     777            compiler.codeGenerator.op_add_esp(4);
    800778        }
    801779
    802780        if(type_stack[sp-2]==DEF_DOUBLE){
    803781            //fld qword ptr[esp]
    804             op_fld_ptr_esp(DEF_DOUBLE);
    805 
    806             //add esp,4
    807             op_add_esp(4);
     782            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     783
     784            //add esp,4
     785            compiler.codeGenerator.op_add_esp(4);
    808786        }
    809787        else if(type_stack[sp-2]==DEF_SINGLE){
    810788            //fld dword ptr[esp]
    811             op_fld_ptr_esp(DEF_SINGLE);
     789            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    812790        }
    813791        else if(type_stack[sp-2]==DEF_INT64||type_stack[sp-2]==DEF_QWORD){
    … …  
    815793
    816794            //fild qword ptr[esp]
    817             op_fld_ptr_esp(DEF_INT64);
    818 
    819             //add esp,4
    820             op_add_esp(4);
     795            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
     796
     797            //add esp,4
     798            compiler.codeGenerator.op_add_esp(4);
    821799        }
    822800        else{   //Long、DWord
    823801            //fild dword ptr[esp]
    824             op_fld_ptr_esp(DEF_LONG);
     802            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    825803        }
    826804
    827805        //fcompp
    828         OpBuffer[obp++]=(char)0xDE;
    829         OpBuffer[obp++]=(char)0xD9;
     806        compiler.codeGenerator.op_fcompp();
    830807
    831808        //fnstsw ax
    832         OpBuffer[obp++]=(char)0xDF;
    833         OpBuffer[obp++]=(char)0xE0;
     809        compiler.codeGenerator.op_fnstsw_ax();
    834810
    835811        //mov ecx,1
    … …  
    839815
    840816        //test ah,41
    841         OpBuffer[obp++]=(char)0xF6;
    842         OpBuffer[obp++]=(char)0xC4;
    843         OpBuffer[obp++]=(char)0x41;
     817        compiler.codeGenerator.op_test_ah( (char)0x41 );
    844818
    845819        //je 5
    … …  
    853827
    854828        //mov dword ptr[esp],ecx
    855         OpBuffer[obp++]=(char)0x89;
    856         OpBuffer[obp++]=(char)0x0C;
    857         OpBuffer[obp++]=(char)0x24;
     829        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
    858830    }
    859831    else if(Is64Type(AnswerType)){
    … …  
    918890
    919891        //xor eax,eax（eaxを0にする）
    920         op_zero_reg(REG_EAX);
     892        compiler.codeGenerator.op_zero_reg(REG_EAX);
    921893
    922894        //jmp 5（演算終了位置へジャンプ）
    … …  
    934906
    935907        //push eax
    936         op_push(REG_EAX);
     908        compiler.codeGenerator.op_push(REG_EAX);
    937909    }
    938910    else{
    … …  
    942914
    943915        //pop ebx
    944         op_pop(REG_EBX);
     916        compiler.codeGenerator.op_pop(REG_EBX);
    945917
    946918        //pop eax
    947         op_pop(REG_EAX);
     919        compiler.codeGenerator.op_pop(REG_EAX);
    948920
    949921        // どちらかのサイズが足りない場合は自動拡張する
    … …  
    951923
    952924        //sub esp,4
    953         op_sub_esp(4);
     925        compiler.codeGenerator.op_sub_esp(4);
    954926
    955927        //mov ecx,1
    … …  
    979951
    980952        //mov dword ptr[esp],ecx
    981         OpBuffer[obp++]=(char)0x89;
    982         OpBuffer[obp++]=(char)0x0C;
    983         OpBuffer[obp++]=(char)0x24;
     953        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
    984954    }
    985955
    … …  
    1005975        if(type[sp-1]==DEF_DOUBLE){
    1006976            //fld qword ptr[esp]
    1007             op_fld_ptr_esp(DEF_DOUBLE);
     977            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    1008978
    1009979            //add esp,8
    1010             op_add_esp(8);
     980            compiler.codeGenerator.op_add_esp(8);
    1011981        }
    1012982        else if(type[sp-1]==DEF_SINGLE){
    1013983            //fld dword ptr[esp]
    1014             op_fld_ptr_esp(DEF_SINGLE);
    1015 
    1016             //add esp,4
    1017             op_add_esp(4);
     984            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     985
     986            //add esp,4
     987            compiler.codeGenerator.op_add_esp(4);
    1018988        }
    1019989        else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    … …  
    1021991
    1022992            //fild qword ptr[esp]
    1023             op_fld_ptr_esp(DEF_INT64);
     993            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    1024994
    1025995            //add esp,8
    1026             op_add_esp(8);
     996            compiler.codeGenerator.op_add_esp(8);
    1027997        }
    1028998        else{   //Long、DWord
    1029999            //fild dword ptr[esp]
    1030             op_fld_ptr_esp(DEF_LONG);
    1031 
    1032             //add esp,4
    1033             op_add_esp(4);
     1000            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
     1001
     1002            //add esp,4
     1003            compiler.codeGenerator.op_add_esp(4);
    10341004        }
    10351005
    10361006        if(type[sp-2]==DEF_DOUBLE){
    10371007            //fld qword ptr[esp]
    1038             op_fld_ptr_esp(DEF_DOUBLE);
    1039 
    1040             //add esp,4
    1041             op_add_esp(4);
     1008            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     1009
     1010            //add esp,4
     1011            compiler.codeGenerator.op_add_esp(4);
    10421012        }
    10431013        else if(type[sp-2]==DEF_SINGLE){
    10441014            //fld dword ptr[esp]
    1045             op_fld_ptr_esp(DEF_SINGLE);
     1015            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    10461016        }
    10471017        else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
    … …  
    10491019
    10501020            //fild qword ptr[esp]
    1051             op_fld_ptr_esp(DEF_INT64);
    1052 
    1053             //add esp,4
    1054             op_add_esp(4);
     1021            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
     1022
     1023            //add esp,4
     1024            compiler.codeGenerator.op_add_esp(4);
    10551025        }
    10561026        else{   //Long、DWord
    10571027            //fild dword ptr[esp]
    1058             op_fld_ptr_esp(DEF_LONG);
     1028            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    10591029        }
    10601030
    10611031        //fcompp
    1062         OpBuffer[obp++]=(char)0xDE;
    1063         OpBuffer[obp++]=(char)0xD9;
     1032        compiler.codeGenerator.op_fcompp();
    10641033
    10651034        //fnstsw ax
    1066         OpBuffer[obp++]=(char)0xDF;
    1067         OpBuffer[obp++]=(char)0xE0;
     1035        compiler.codeGenerator.op_fnstsw_ax();
    10681036
    10691037        //mov ecx,1
    … …  
    10731041
    10741042        //test ah,40
    1075         OpBuffer[obp++]=(char)0xF6;
    1076         OpBuffer[obp++]=(char)0xC4;
    1077         OpBuffer[obp++]=(char)0x40;
     1043        compiler.codeGenerator.op_test_ah( (char)0x40 );
    10781044
    10791045        //je 5
    … …  
    10871053
    10881054        //mov dword ptr[esp],ecx
    1089         OpBuffer[obp++]=(char)0x89;
    1090         OpBuffer[obp++]=(char)0x0C;
    1091         OpBuffer[obp++]=(char)0x24;
     1055        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
    10921056    }
    10931057    else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
    … …  
    11241088
    11251089        //xor eax,eax（eaxを0にする）
    1126         op_zero_reg(REG_EAX);
     1090        compiler.codeGenerator.op_zero_reg(REG_EAX);
    11271091
    11281092        //jmp 5（演算終了位置へジャンプ）
    … …  
    11401104
    11411105        //push eax
    1142         op_push(REG_EAX);
     1106        compiler.codeGenerator.op_push(REG_EAX);
    11431107    }
    11441108    else{
    … …  
    11481112
    11491113        //pop eax
    1150         op_pop(REG_EAX);
     1114        compiler.codeGenerator.op_pop(REG_EAX);
    11511115
    11521116        //pop ebx
    1153         op_pop(REG_EBX);
     1117        compiler.codeGenerator.op_pop(REG_EBX);
    11541118
    11551119        // どちらかのサイズが足りない場合は自動拡張する
    … …  
    11571121
    11581122        //sub esp,4
    1159         op_sub_esp(4);
     1123        compiler.codeGenerator.op_sub_esp(4);
    11601124
    11611125        //xor eax,ebx
    … …  
    11731137
    11741138        //mov dword ptr[esp],eax
    1175         OpBuffer[obp++]=(char)0x89;
    1176         OpBuffer[obp++]=(char)0x04;
    1177         OpBuffer[obp++]=(char)0x24;
     1139        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
    11781140    }
    11791141
    … …  
    11991161        if(type[sp-1]==DEF_DOUBLE){
    12001162            //fld qword ptr[esp]
    1201             op_fld_ptr_esp(DEF_DOUBLE);
     1163            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    12021164
    12031165            //add esp,8
    1204             op_add_esp(8);
     1166            compiler.codeGenerator.op_add_esp(8);
    12051167        }
    12061168        else if(type[sp-1]==DEF_SINGLE){
    12071169            //fld dword ptr[esp]
    1208             op_fld_ptr_esp(DEF_SINGLE);
    1209 
    1210             //add esp,4
    1211             op_add_esp(4);
     1170            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
     1171
     1172            //add esp,4
     1173            compiler.codeGenerator.op_add_esp(4);
    12121174        }
    12131175        else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
    … …  
    12151177
    12161178            //fild qword ptr[esp]
    1217             op_fld_ptr_esp(DEF_INT64);
     1179            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
    12181180
    12191181            //add esp,8
    1220             op_add_esp(8);
     1182            compiler.codeGenerator.op_add_esp(8);
    12211183        }
    12221184        else{   //Long、DWord
    12231185            //fild dword ptr[esp]
    1224             op_fld_ptr_esp(DEF_LONG);
    1225 
    1226             //add esp,4
    1227             op_add_esp(4);
     1186            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
     1187
     1188            //add esp,4
     1189            compiler.codeGenerator.op_add_esp(4);
    12281190        }
    12291191
    12301192        if(type[sp-2]==DEF_DOUBLE){
    12311193            //fld qword ptr[esp]
    1232             op_fld_ptr_esp(DEF_DOUBLE);
    1233 
    1234             //add esp,4
    1235             op_add_esp(4);
     1194            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
     1195
     1196            //add esp,4
     1197            compiler.codeGenerator.op_add_esp(4);
    12361198        }
    12371199        else if(type[sp-2]==DEF_SINGLE){
    12381200            //fld dword ptr[esp]
    1239             op_fld_ptr_esp(DEF_SINGLE);
     1201            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    12401202        }
    12411203        else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
    … …  
    12431205
    12441206            //fild qword ptr[esp]
    1245             op_fld_ptr_esp(DEF_INT64);
    1246 
    1247             //add esp,4
    1248             op_add_esp(4);
     1207            compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
     1208
     1209            //add esp,4
     1210            compiler.codeGenerator.op_add_esp(4);
    12491211        }
    12501212        else{   //Long、DWord
    12511213            //fild dword ptr[esp]
    1252             op_fld_ptr_esp(DEF_LONG);
     1214            compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
    12531215        }
    12541216
    12551217        //fcompp
    1256         OpBuffer[obp++]=(char)0xDE;
    1257         OpBuffer[obp++]=(char)0xD9;
     1218        compiler.codeGenerator.op_fcompp();
    12581219
    12591220        //fnstsw ax
    1260         OpBuffer[obp++]=(char)0xDF;
    1261         OpBuffer[obp++]=(char)0xE0;
     1221        compiler.codeGenerator.op_fnstsw_ax();
    12621222
    12631223        //mov ecx,1
    … …  
    12671227
    12681228        //test ah,40
    1269         OpBuffer[obp++]=(char)0xF6;
    1270         OpBuffer[obp++]=(char)0xC4;
    1271         OpBuffer[obp++]=(char)0x40;
     1229        compiler.codeGenerator.op_test_ah( (char)0x40 );
    12721230
    12731231        //jne 5
    … …  
    12811239
    12821240        //mov dword ptr[esp],ecx
    1283         OpBuffer[obp++]=(char)0x89;
    1284         OpBuffer[obp++]=(char)0x0C;
    1285         OpBuffer[obp++]=(char)0x24;
     1241        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
    12861242    }
    12871243    else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
    … …  
    13311287
    13321288        //xor eax,eax（eaxを0にする）
    1333         op_zero_reg(REG_EAX);
     1289        compiler.codeGenerator.op_zero_reg(REG_EAX);
    13341290
    13351291        //push eax
    1336         op_push(REG_EAX);
     1292        compiler.codeGenerator.op_push(REG_EAX);
    13371293    }
    13381294    else{
    … …  
    13421298
    13431299        //pop eax
    1344         op_pop(REG_EAX);
     1300        compiler.codeGenerator.op_pop(REG_EAX);
    13451301
    13461302        //pop ebx
    1347         op_pop(REG_EBX);
     1303        compiler.codeGenerator.op_pop(REG_EBX);
    13481304
    13491305        // どちらかのサイズが足りない場合は自動拡張する
    … …  
    13511307
    13521308        //sub esp,4
    1353         op_sub_esp(4);
     1309        compiler.codeGenerator.op_sub_esp(4);
    13541310
    13551311        //xor eax,ebx
    … …  
    13751331
    13761332        //mov dword ptr[esp],eax
    1377         OpBuffer[obp++]=(char)0x89;
    1378         OpBuffer[obp++]=(char)0x04;
    1379         OpBuffer[obp++]=(char)0x24;
     1333        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
    13801334    }
    13811335

  • trunk/abdev/BasicCompiler32/NumOpe_TypeOperation.cpp

    r206 r225  
    2020
    2121        //pop eax
    22         op_pop(REG_EAX);
     22        compiler.codeGenerator.op_pop(REG_EAX);
    2323
    2424        //cdq
    25         op_cdq();
     25        compiler.codeGenerator.op_cdq();
    2626
    2727        //push edx
    28         op_push(REG_EDX);
     28        compiler.codeGenerator.op_push(REG_EDX);
    2929
    3030        //push eax
    31         op_push(REG_EAX);
     31        compiler.codeGenerator.op_push(REG_EAX);
    3232    }
    3333    else{
    … …  
    3535
    3636        //pop eax
    37         op_pop(REG_EAX);
     37        compiler.codeGenerator.op_pop(REG_EAX);
    3838
    3939        //push 0
    40         op_push_V(0);
     40        compiler.codeGenerator.op_push_V(0);
    4141
    4242        //push eax
    43         op_push(REG_EAX);
     43        compiler.codeGenerator.op_push(REG_EAX);
    4444    }
    4545}
    … …  
    4949    if(Is64Type(type)){
    5050        //pop eax
    51         op_pop(REG_EAX);
     51        compiler.codeGenerator.op_pop(REG_EAX);
    5252
    5353        //pop edx
    54         op_pop(REG_EDX);
     54        compiler.codeGenerator.op_pop(REG_EDX);
    5555
    5656        //push eax
    57         op_push(REG_EAX);
     57        compiler.codeGenerator.op_push(REG_EAX);
    5858    }
    5959    else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
    6060        //pop eax
    61         op_pop(REG_EAX);
     61        compiler.codeGenerator.op_pop(REG_EAX);
    6262
    6363        //movsx eax,ax
    64         OpBuffer[obp++]=(char)0x0F;
    65         OpBuffer[obp++]=(char)0xBF;
    66         OpBuffer[obp++]=(char)0xC0;
     64        compiler.codeGenerator.op_movsx_R32R16( REG_EAX );
    6765
    6866        //push eax
    69         op_push(REG_EAX);
     67        compiler.codeGenerator.op_push(REG_EAX);
    7068    }
    7169    else if(type==DEF_WORD){
    7270        //pop eax
    73         op_pop(REG_EAX);
     71        compiler.codeGenerator.op_pop(REG_EAX);
    7472
    7573        //and eax,0000FFFFh
    … …  
    7977
    8078        //push eax
    81         op_push(REG_EAX);
     79        compiler.codeGenerator.op_push(REG_EAX);
    8280    }
    8381    else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    8482        //pop eax
    85         op_pop(REG_EAX);
     83        compiler.codeGenerator.op_pop(REG_EAX);
    8684
    8785        //movsx eax,al
    88         OpBuffer[obp++]=(char)0x0F;
    89         OpBuffer[obp++]=(char)0xBE;
    90         OpBuffer[obp++]=(char)0xC0;
     86        compiler.codeGenerator.op_movsx_R32R8( REG_EAX );
    9187
    9288        //push eax
    93         op_push(REG_EAX);
     89        compiler.codeGenerator.op_push(REG_EAX);
    9490    }
    9591    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
    9692        //pop eax
    97         op_pop(REG_EAX);
     93        compiler.codeGenerator.op_pop(REG_EAX);
    9894
    9995        //and eax,000000FFh
    … …  
    10399
    104100        //push eax
    105         op_push(REG_EAX);
     101        compiler.codeGenerator.op_push(REG_EAX);
    106102    }
    107103}
    … …  
    109105    if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
    110106        //pop eax
    111         op_pop(REG_EAX);
     107        compiler.codeGenerator.op_pop(REG_EAX);
    112108
    113109        //movsx eax,al
    114         OpBuffer[obp++]=(char)0x0F;
    115         OpBuffer[obp++]=(char)0xBE;
    116         OpBuffer[obp++]=(char)0xC0;
     110        compiler.codeGenerator.op_movsx_R32R8( REG_EAX );
    117111
    118112        //push eax
    119         op_push(REG_EAX);
     113        compiler.codeGenerator.op_push(REG_EAX);
    120114    }
    121115    else if(type==DEF_BYTE){
    122116        //pop eax
    123         op_pop(REG_EAX);
     117        compiler.codeGenerator.op_pop(REG_EAX);
    124118
    125119        //and eax,000000FFh
    … …  
    129123
    130124        //push eax
    131         op_push(REG_EAX);
     125        compiler.codeGenerator.op_push(REG_EAX);
    132126    }
    133127}
    … …  
    135129    if(Is64Type(type)){
    136130        //pop eax
    137         op_pop(REG_EAX);
     131        compiler.codeGenerator.op_pop(REG_EAX);
    138132
    139133        //pop edx
    140         op_pop(REG_EDX);
     134        compiler.codeGenerator.op_pop(REG_EDX);
    141135
    142136        //push eax
    143         op_push(REG_EAX);
     137        compiler.codeGenerator.op_push(REG_EAX);
    144138    }
    145139}
    … …  
    150144        if(Is64Type(NewType)){
    151145            //fld qword ptr[esp]
    152             op_fld_ptr_esp(DEF_DOUBLE);
     146            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    153147
    154148            //fistp qword ptr[esp]
    155             op_fistp_ptr_esp( sizeof(_int64) );
     149            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    156150        }
    157151        else{
    158152            //fld qword ptr[esp]
    159             op_fld_ptr_esp(DEF_DOUBLE);
     153            compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
    160154
    161155            //add esp,4
    162             op_add_esp(4);
     156            compiler.codeGenerator.op_add_esp(4);
    163157
    164158            //fistp dword ptr[esp]
    165             op_fistp_ptr_esp( sizeof(long) );
     159            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    166160        }
    167161    }
    … …  
    169163        if(Is64Type(NewType)){
    170164            //fld dword ptr[esp]
    171             op_fld_ptr_esp(DEF_SINGLE);
     165            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    172166
    173167            //sub esp,4
    174             op_sub_esp(4);
     168            compiler.codeGenerator.op_sub_esp(4);
    175169
    176170            //fistp qword ptr[esp]
    177             op_fistp_ptr_esp( sizeof(_int64) );
     171            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
    178172        }
    179173        else{
    180174            //fld dword ptr[esp]
    181             op_fld_ptr_esp(DEF_SINGLE);
     175            compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
    182176
    183177            //fistp dword ptr[esp]
    184             op_fistp_ptr_esp( sizeof(long) );
     178            compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
    185179        }
    186180    }

  • trunk/abdev/BasicCompiler32/Opcode.h

    r206 r225  
    33#include <Type.h>
    44#include <Procedure.h>
    5 
    6 
    7 //未定義の定数情報
    8 #define IMAGE_FILE_MACHINE_AMD64 0x8664
    9 
    10 
    11 //レジスタを示す定数
    12 #define REG_NON -1
    13 #define REG_EAX 0x00    //reg:000
    14 #define REG_ECX 0x01    //reg:001
    15 #define REG_EDX 0x02    //reg:010
    16 #define REG_EBX 0x03    //reg:011
    17 #define REG_ESP 0x04    //reg:100
    18 #define REG_EBP 0x05    //reg:101
    19 #define REG_ESI 0x06    //reg:110
    20 #define REG_EDI 0x07    //reg:111
    21 
    22 #define REG_RAX REG_EAX
    23 #define REG_RCX REG_ECX
    24 #define REG_RDX REG_EDX
    25 #define REG_RBX REG_EBX
    26 #define REG_RSP REG_ESP
    27 #define REG_RBP REG_EBP
    28 #define REG_RSI REG_ESI
    29 #define REG_RDI REG_EDI
    30 
    31 #define REGISTER_OPERAND(reg) (reg&0x07)
     5#include "MachineFixed.h"
     6
    327
    338//変数の種類
    … …  
    190165void SetReg_RealVariable(int type,RELATIVE_VAR *pRelativeVar);
    191166void SetReg_WholeVariable(int type,RELATIVE_VAR *pRelativeVar,int reg, bool is64Head = false);
    192 void PushDoubleVariable(RELATIVE_VAR *pRelativeVar);
    193167void PushLongVariable(RELATIVE_VAR *pRelativeVar);
    194 void PushIntegerVariable(RELATIVE_VAR *pRelativeVar);
    195 void PushWordVariable(RELATIVE_VAR *pRelativeVar);
    196 void PushCharVariable(RELATIVE_VAR *pRelativeVar);
    197 void PushByteVariable(RELATIVE_VAR *pRelativeVar);
    198168
    199169//Compile_Object.cpp
    … …  
    294264////////////////////////////////
    295265
    296 //Mod（モード）
    297 #define MOD_BASE        (char)0x00
    298 #define MOD_DISP32      (char)0xFF
    299 #define MOD_BASE_DISP8  (char)0x40
    300 #define MOD_BASE_DISP32 (char)0x80
    301 #define MOD_REG             (char)0xC0
    302 
    303 #define USE_OFFSET 1
    304 #define NON_OFFSET 0
    305 
    306266//op32_main.cpp
    307267BOOL IsSafeReg(int reg);
     268/*
    308269void op_mov_RV          (int reg,int offset);
    309270void op_mov_RV          (int op_size,int reg,int offset);
    … …  
    357318void op_call(const UserProc *pUserProc);
    358319void op_ret();
     320*/

  • trunk/abdev/BasicCompiler32/OperatorProc.cpp

    r206 r225  
    22
    33#include <jenga/include/smoothie/LexicalAnalysis.h>
     4
     5#include <Compiler.h>
    46
    57#include "../BasicCompiler_Common/common.h"
    … …  
    1214    if( method ){
    1315        //push reg
    14         op_push(reg);
     16        compiler.codeGenerator.op_push(reg);
    1517
    1618        //call DestructorProcAddr
    17         op_call( &method->GetUserProc() );
     19        compiler.codeGenerator.op_call( &method->GetUserProc() );
    1820    }
    1921
    2022    //push reg
    21     op_push(reg);
     23    compiler.codeGenerator.op_push(reg);
    2224
    2325    //call free
    2426    extern const UserProc *pSub_free;
    25     op_call(pSub_free);
     27    compiler.codeGenerator.op_call(pSub_free);
    2628}
    2729
    … …  
    108110
    109111        //push object_size
    110         op_push_V(object_size);
     112        compiler.codeGenerator.op_push_V(object_size);
    111113
    112114        //call calloc
    113115        extern const UserProc *pSub_calloc;
    114         op_call(pSub_calloc);
     116        compiler.codeGenerator.op_call(pSub_calloc);
    115117
    116118        //mov ebx,eax
    117         op_mov_RR(REG_EBX,REG_EAX);
     119        compiler.codeGenerator.op_mov_RR(REG_EBX,REG_EAX);
    118120    }
    119121
    … …  
    123125        if(right_side_size==sizeof(_int64)){
    124126            //pop eax
    125             op_pop(REG_EAX);
     127            compiler.codeGenerator.op_pop(REG_EAX);
    126128
    127129            //pop edx
    128             op_pop(REG_EDX);
     130            compiler.codeGenerator.op_pop(REG_EDX);
    129131        }
    130132        else{
    131133            //pop eax
    132             op_pop(REG_EAX);
     134            compiler.codeGenerator.op_pop(REG_EAX);
    133135        }
    134136    }
    135137
    136138    //pop ecx
    137     op_pop(REG_ECX);
     139    compiler.codeGenerator.op_pop(REG_ECX);
    138140
    139141
    … …  
    141143    if(bUseHeap[sp-1]){
    142144        //mov esi,eax
    143         op_mov_RR(REG_ESI,REG_EAX);
     145        compiler.codeGenerator.op_mov_RR(REG_ESI,REG_EAX);
    144146    }
    145147    if(bUseHeap[sp-2]){
    146148        //mov edi,ecx
    147         op_mov_RR(REG_EDI,REG_ECX);
     149        compiler.codeGenerator.op_mov_RR(REG_EDI,REG_ECX);
    148150    }
    149151
    … …  
    153155        if(right_side_size==sizeof(_int64)){
    154156            //push edx
    155             op_push(REG_EDX);
     157            compiler.codeGenerator.op_push(REG_EDX);
    156158
    157159            //push eax
    158             op_push(REG_EAX);
     160            compiler.codeGenerator.op_push(REG_EAX);
    159161        }
    160162        else{
    161163            //push eax
    162             op_push(REG_EAX);
     164            compiler.codeGenerator.op_push(REG_EAX);
    163165        }
    164166
    … …  
    167169
    168170            //mov eax,esp
    169             op_mov_RR( REG_EAX, REG_ESP );
     171            compiler.codeGenerator.op_mov_RR( REG_EAX, REG_ESP );
    170172
    171173            //push eax
    172             op_push( REG_EAX );
     174            compiler.codeGenerator.op_push( REG_EAX );
    173175        }
    174176    }
    … …  
    176178    if( pUserProc->ReturnType().IsStruct() ){
    177179        //push ebx
    178         op_push(REG_EBX);
     180        compiler.codeGenerator.op_push(REG_EBX);
    179181    }
    180182
    181183    //push ecx
    182     op_push(REG_ECX);
     184    compiler.codeGenerator.op_push(REG_ECX);
    183185
    184186    //call operator_proc
    185     op_call(pUserProc);
     187    compiler.codeGenerator.op_call(pUserProc);
    186188
    187189    if(bTwoTerm){
    188190        if( pUserProc->RealParams()[1]->IsRef() ){
    189191            //一時参照を破棄
    190             op_pop( REG_NON );
     192            compiler.codeGenerator.op_pop( REG_NON );
    191193        }
    192194    }

  • trunk/abdev/BasicCompiler32/increment.cpp

    r206 r225  
    11#include "stdafx.h"
     2
     3#include <Compiler.h>
    24
    35#include "../BasicCompiler_Common/common.h"
    … …  
    1921    if(IsUse_ecx(&VarRelativeVar)){
    2022        //push ecx
    21         op_push(REG_ECX);
     23        compiler.codeGenerator.op_push(REG_ECX);
    2224    }
    2325
    … …  
    4850
    4951                //add eax,1
    50                 op_add_RV8(REG_EAX,1);
     52                compiler.codeGenerator.op_add_RV8(REG_EAX,1);
    5153
    5254                //adc edx,0
    53                 op_adc_RV8(REG_EDX,0);
     55                compiler.codeGenerator.op_adc_RV8(REG_EDX,0);
    5456            }
    5557            else if(idCalc==CALC_SUBTRACTION){
    … …  
    5759
    5860                //sub eax,1
    59                 op_sub_RV8(REG_EAX,1);
     61                compiler.codeGenerator.op_sub_RV8(REG_EAX,1);
    6062
    6163                //sbb edx,0
    62                 op_sbb_RV8(REG_EDX,0);
     64                compiler.codeGenerator.op_sbb_RV8(REG_EDX,0);
    6365            }
    6466        }
    … …  
    6668            if(idCalc==CALC_ADDITION){
    6769                //インクリメント
    68                 op_inc(REG_EAX);
     70                compiler.codeGenerator.op_inc(REG_EAX);
    6971            }
    7072            else if(idCalc==CALC_SUBTRACTION){
    7173                //デクリメント
    72                 op_dec(REG_EAX);
     74                compiler.codeGenerator.op_dec(REG_EAX);
    7375            }
    7476        }
    … …  
    7779        //変数オフセットを一時退避
    7880        //push ecx
    79         op_push(REG_ECX);
     81        compiler.codeGenerator.op_push(REG_ECX);
    8082
    8183        if( varType.IsDouble() ){
    8284            //sub esp,8
    83             op_sub_esp(8);
     85            compiler.codeGenerator.op_sub_esp(8);
    8486
    8587            //fstp qword ptr[esp]
    86             op_fstp_basereg(varType.GetBasicType(),REG_ESP);
     88            compiler.codeGenerator.op_fstp_basereg(varType.GetBasicType(),REG_ESP);
    8789        }
    8890        else if( varType.IsSingle() ){
    8991            //sub esp,4
    90             op_sub_esp(4);
     92            compiler.codeGenerator.op_sub_esp(4);
    9193
    9294            //fstp dword ptr[esp]
    93             op_fstp_basereg(varType.GetBasicType(),REG_ESP);
     95            compiler.codeGenerator.op_fstp_basereg(varType.GetBasicType(),REG_ESP);
    9496        }
    9597        else if( varType.Is64() ){
    9698            //push edx
    97             op_push(REG_EDX);
     99            compiler.codeGenerator.op_push(REG_EDX);
    98100
    99101            //push eax
    100             op_push(REG_EAX);
     102            compiler.codeGenerator.op_push(REG_EAX);
    101103        }
    102104        else{
    103105            //push eax
    104             op_push(REG_EAX);
     106            compiler.codeGenerator.op_push(REG_EAX);
    105107        }
    106108
    … …  
    160162        if( varType.IsDouble() ){
    161163            //fld qword ptr[esp]
    162             op_fld_basereg(varType.GetBasicType(),REG_ESP);
     164            compiler.codeGenerator.op_fld_basereg(varType.GetBasicType(),REG_ESP);
    163165
    164166            //add esp,8
    165             op_add_esp(8);
     167            compiler.codeGenerator.op_add_esp(8);
    166168        }
    167169        else if( varType.IsSingle() ){
    168170            //fld dword ptr[esp]
    169             op_fld_basereg(varType.GetBasicType(),REG_ESP);
     171            compiler.codeGenerator.op_fld_basereg(varType.GetBasicType(),REG_ESP);
    170172
    171173            //add esp,4
    172             op_add_esp(4);
     174            compiler.codeGenerator.op_add_esp(4);
    173175        }
    174176        else if( varType.Is64() ){
    175177            //pop eax
    176             op_pop(REG_EAX);
     178            compiler.codeGenerator.op_pop(REG_EAX);
    177179
    178180            //pop edx
    179             op_pop(REG_EDX);
     181            compiler.codeGenerator.op_pop(REG_EDX);
    180182        }
    181183        else{
    182184            //pop eax
    183             op_pop(REG_EAX);
     185            compiler.codeGenerator.op_pop(REG_EAX);
    184186        }
    185187
    … …  
    187189        //変数オフセットを復元
    188190        //pop ecx
    189         op_pop(REG_ECX);
     191        compiler.codeGenerator.op_pop(REG_ECX);
    190192    }
    191193
    … …  
    197199    if(IsUse_ecx(&VarRelativeVar)){
    198200        //pop ecx
    199         op_pop(REG_ECX);
     201        compiler.codeGenerator.op_pop(REG_ECX);
    200202    }
    201203

  • trunk/abdev/BasicCompiler32/op32_main.cpp

    r206 r225  
    1010    return 0;
    1111}
    12 
    13 
    14 
    15 /////////////////////////////////////////////////
    16 // ModR/Mバイト、SIBバイト、ディスプレースメント
    17 /////////////////////////////////////////////////
    18 
    19 //スケール
    20 #define SCALE_NON   (char)0x00
    21 #define SCALE_2     (char)0x40
    22 #define SCALE_4     (char)0x80
    23 #define SCALE_8     (char)0xC0
    24 
    25 //インデックスなし
    26 #define INDEX_NON   0x04
    27 
    28 void set_mod_rm_sib_disp(char mod,int reg,int scale,int index_reg,int base_reg,int disp){
    29     if(mod==MOD_DISP32){
    30         //ModR/Mバイト
    31         OpBuffer[obp++]=(char)(      REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(0x04));
    32 
    33         base_reg=0x05;
    34         index_reg=INDEX_NON;
    35     }
    36     else{
    37         //ModR/Mバイト
    38         OpBuffer[obp++]=(char)(mod | REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(base_reg));
    39     }
    40 
    41 
    42     //レジスタモードの場合は、ここで終了
    43     if(mod==MOD_REG) return;
    44 
    45 
    46     if(REGISTER_OPERAND(base_reg)==0x04||mod==MOD_DISP32){
    47         //////////////////////
    48         // SIBバイトを使う
    49         //////////////////////
    50 
    51         OpBuffer[obp++]=(char)(scale| REGISTER_OPERAND(index_reg)<<3 | REGISTER_OPERAND(base_reg));
    52     }
    53 
    54     //ディスプレースメントを必要としない場合は、ここで終了
    55     if(mod==MOD_BASE) return;
    56 
    57 
    58     //////////////////////////
    59     // ディスプレースメント
    60     //////////////////////////
    61 
    62     if(mod==MOD_BASE_DISP8) OpBuffer[obp++]=(char)disp;
    63     else{
    64         *((long *)(OpBuffer+obp))=disp;
    65         obp+=sizeof(long);
    66     }
    67 }
    68 
    69 
    70 
    71 void __op_format(char op_prefix,char opcode,int reg){
    72     //命令プリフィックス
    73     if(op_prefix) OpBuffer[obp++]=op_prefix;
    74 
    75     //オペコード、レジスタ
    76     OpBuffer[obp++]=(char)(opcode|REGISTER_OPERAND(reg));
    77 }
    78 void __op_format(char op_prefix,char opcode1,char opcode2,int reg,int base_reg,int offset,char mod){
    79     //命令プリフィックス
    80     if(op_prefix) OpBuffer[obp++]=op_prefix;
    81 
    82     //オペコード
    83     OpBuffer[obp++]=opcode1;
    84     if(opcode2) OpBuffer[obp++]=opcode2;
    85 
    86     //ModR/M, SIB, disp
    87     set_mod_rm_sib_disp(mod,reg,SCALE_NON,INDEX_NON,base_reg,offset);
    88 }
    89 
    90 
    91 
    92 ///////////////////
    93 // mov関連
    94 ///////////////////
    95 
    96 void op_mov_RV(int reg,int offset){
    97     //mov reg,value
    98 
    99     //オペコード、レジスタ
    100     OpBuffer[obp++]=(char)(0xB8|REGISTER_OPERAND(reg));
    101 
    102     //DISP32
    103     *((long *)(OpBuffer+obp))=offset;
    104     obp+=sizeof(long);
    105 }
    106 void op_mov_RV(int op_size,int reg,int offset){
    107     if(op_size==PTR_SIZE) op_mov_RV(reg,offset);
    108     else SetError(300,NULL,cp);
    109 }
    110 void op_mov_RR(int reg1,int reg2){
    111     //mov reg1,reg2
    112 
    113     if(reg1==reg2) return;
    114 
    115     //1000 1011 11xx xbbb
    116     OpBuffer[obp++]=(char)0x8B;
    117     OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
    118 }
    119 void op_mov_RM(int op_size,int reg,int base_reg,int offset,char mod){
    120     //mov reg32,dword ptr[base_reg+offset]
    121     //mov reg16,word ptr[base_reg+offset]
    122     //mov reg8,byte ptr[base_reg+offset]
    123 
    124     //16ビット演算の命令プリフィックス
    125     char op_prefix=0;
    126     if(op_size==sizeof(short)) op_prefix=(char)0x66;
    127 
    128     //オペコード
    129     char opcode;
    130     if(op_size==sizeof(char)) opcode=(char)0x8A;
    131     else opcode=(char)0x8B;
    132 
    133     __op_format(op_prefix,opcode,0,reg,base_reg,offset,mod);
    134 }
    135 void op_mov_RM_ex(int op_size,int reg,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){
    136     //mov reg32,dword ptr[base_reg1+base_reg2+offset]
    137     //mov reg16,word ptr[base_reg1+base_reg2+offset]
    138     //mov reg8,byte ptr[base_reg1+base_reg2+offset]
    139 
    140     if(base_reg1==REG_ESP){
    141         //SIBバイトのindex部にespは指定できない
    142         base_reg1=base_reg2;
    143         base_reg2=REG_ESP;
    144     }
    145 
    146     //16ビット演算のプリフィックス
    147     if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;
    148 
    149     //オペコード
    150     if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x8A;
    151     else OpBuffer[obp++]=(char)0x8B;
    152 
    153     if(bUseOffset){
    154         ///////////////////////////
    155         // オフセット値を使う
    156         ///////////////////////////
    157 
    158         //レジスタ
    159         OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(reg)<<3);
    160 
    161         //ベースレジスタ
    162         OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
    163 
    164         //オフセット値
    165         *((long *)(OpBuffer+obp))=offset;
    166         obp+=sizeof(long);
    167     }
    168     else{
    169         ///////////////////////////
    170         // オフセット値を使わない
    171         ///////////////////////////
    172 
    173         //レジスタ
    174         OpBuffer[obp++]=(char)(0x04| REGISTER_OPERAND(reg)<<3);
    175 
    176         //ベースレジスタ
    177         OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
    178     }
    179 }
    180 void op_mov_MR(int op_size,int reg,int base_reg,int offset,char mod){
    181     //mov dword ptr[base_reg+offset],reg32
    182     //mov word ptr[base_reg+offset],reg16
    183     //mov byte ptr[base_reg+offset],reg8
    184 
    185     //16ビット演算の命令プリフィックス
    186     char op_prefix=0;
    187     if(op_size==sizeof(short)) op_prefix=(char)0x66;
    188 
    189     //オペコード
    190     char opcode;
    191     if(op_size==sizeof(char)) opcode=(char)0x88;
    192     else opcode=(char)0x89;
    193 
    194     __op_format(op_prefix,opcode,0,reg,base_reg,offset,mod);
    195 }
    196 void op_mov_MR_ex(int op_size,int reg,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){
    197     //mov dword ptr[base_reg1+base_reg2+offset],reg32
    198     //mov word ptr[base_reg1+base_reg2+offset],reg16
    199     //mov byte ptr[base_reg1+base_reg2+offset],reg8
    200 
    201     if(base_reg1==REG_ESP){
    202         //SIBバイトのindex部にrspは指定できない
    203         base_reg1=base_reg2;
    204         base_reg2=REG_ESP;
    205     }
    206 
    207     //16ビット演算のプリフィックス
    208     if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;
    209 
    210     //オペコード
    211     if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x88;
    212     else OpBuffer[obp++]=(char)0x89;
    213 
    214     if(bUseOffset==USE_OFFSET){
    215         //////////////////////////
    216         //オフセット値を使う
    217         //////////////////////////
    218 
    219         //レジスタ
    220         OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(reg)<<3);
    221 
    222         //ベースレジスタ
    223         OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
    224 
    225         //オフセット値
    226         *((long *)(OpBuffer+obp))=offset;
    227         obp+=sizeof(long);
    228     }
    229     else{
    230         //////////////////////////
    231         //オフセット値を使わない
    232         //////////////////////////
    233 
    234         //レジスタ
    235         OpBuffer[obp++]=(char)(0x04| REGISTER_OPERAND(reg)<<3);
    236 
    237         //ベースレジスタ
    238         OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
    239     }
    240 }
    241 
    242 
    243 
    244 
    245 ////////////////////////////////
    246 // movsx関連
    247 ////////////////////////////////
    248 
    249 void op_movsx_R32R16(int reg32,int reg16){
    250     //movsx reg32,reg16
    251 
    252     //16ビット演算の命令プリフィックス
    253     char op_prefix=0;
    254 
    255     //オペコード
    256     char opcode=(char)0x0F;
    257     char opcode2=(char)0xBF;
    258 
    259     __op_format(op_prefix,opcode,opcode2,reg32,reg16,0,MOD_REG);
    260 }
    261 void op_movsx_R32R8(int reg32,int reg8){
    262     //movsx reg32,reg8
    263 
    264     //16ビット演算の命令プリフィックス
    265     char op_prefix=0;
    266 
    267     //オペコード
    268     char opcode=(char)0x0F;
    269     char opcode2=(char)0xBE;
    270 
    271     __op_format(op_prefix,opcode,opcode2,reg32,reg8,0,MOD_REG);
    272 }
    273 void op_movsx_R16R8(int reg16,int reg8){
    274     //movsx reg16,reg8
    275 
    276     //16ビット演算の命令プリフィックス
    277     char op_prefix=(char)0x66;
    278 
    279     //オペコード
    280     char opcode=(char)0x0F;
    281     char opcode2=(char)0xBE;
    282 
    283     __op_format(op_prefix,opcode,opcode2,reg16,reg8,0,MOD_REG);
    284 }
    285 
    286 
    287 
    288 //////////////////////////////////
    289 // インクリメント・デクリメント
    290 //////////////////////////////////
    291 
    292 void op_inc(int reg){
    293     //inc reg
    294 
    295     //16ビット演算の命令プリフィックス
    296     char op_prefix=0;
    297 
    298     //オペコード
    299     char opcode=(char)0xFF;
    300 
    301     __op_format(op_prefix,opcode,0,0,reg,0,MOD_REG);
    302 }
    303 void op_dec(int reg){
    304     op_inc(reg);
    305     OpBuffer[obp-1]=OpBuffer[obp-1]|0x08;
    306 }
    307 
    308 
    309 
    310 /////////////////////
    311 // add関連
    312 /////////////////////
    313 
    314 void op_add_RV8(int reg,char cValue){
    315     //add reg,value8
    316 
    317     OpBuffer[obp++]=(char)0x83;
    318     OpBuffer[obp++]=(char)(0xC0|REGISTER_OPERAND(reg));
    319     OpBuffer[obp++]=cValue;
    320 }
    321 void op_add_RM(int op_size,int reg,int base_reg,int offset,char mod){
    322     //add reg32,dword ptr[base_reg+offset]
    323     //add reg16,word ptr[base_reg+offset]
    324     //add reg8,byte ptr[base_reg+offset]
    325 
    326     //16ビット演算の命令プリフィックス
    327     char op_prefix=0;
    328     if(op_size==sizeof(short)) op_prefix=(char)0x66;
    329 
    330     //オペコード
    331     char opcode;
    332     if(op_size==sizeof(char)) opcode=(char)0x02;
    333     else opcode=(char)0x03;
    334 
    335     __op_format(op_prefix,opcode,0,reg,base_reg,offset,mod);
    336 }
    337 void op_adc_RV8(int reg,char cValue){
    338     //adc reg,value8
    339 
    340     OpBuffer[obp++]=(char)0x83;
    341     OpBuffer[obp++]=(char)(0xD0|REGISTER_OPERAND(reg));
    342     OpBuffer[obp++]=cValue;
    343 }
    344 
    345 
    346 /////////////////////
    347 // sub関連
    348 /////////////////////
    349 
    350 void op_sub_RV8(int reg,char cValue){
    351     //sub reg,value8
    352 
    353     OpBuffer[obp++]=(char)0x83;
    354     OpBuffer[obp++]=(char)(0xE8|REGISTER_OPERAND(reg));
    355     OpBuffer[obp++]=cValue;
    356 }
    357 void op_sbb_RV8(int reg,char cValue){
    358     //sbb reg,value8
    359 
    360     OpBuffer[obp++]=(char)0x83;
    361     OpBuffer[obp++]=(char)(0xD8|REGISTER_OPERAND(reg));
    362     OpBuffer[obp++]=cValue;
    363 }
    364 void op_sbb_RR( int reg1, int reg2 ){
    365     //sbb reg1,reg2
    366 
    367     //オペコード
    368     OpBuffer[obp++]=(char)0x1B;
    369 
    370     //レジスタ
    371     OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
    372 }
    373 
    374 
    375 
    376 ////////////////////////
    377 // imul関連
    378 ////////////////////////
    379 
    380 void op_imul_RR(int reg1,int reg2){
    381     //imul reg1,reg2
    382 
    383     //オペコード
    384     OpBuffer[obp++]=(char)0x0F;
    385     OpBuffer[obp++]=(char)0xAF;
    386 
    387     //レジスタ
    388     OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
    389 }
    390 
    391 void op_imul_RV(int reg,int i32data){
    392     //imul reg,i32data
    393 
    394     if(-128<=i32data&&i32data<=127){
    395         //オペコード
    396         OpBuffer[obp++]=(char)0x6B;
    397 
    398         //レジスタ
    399         OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg));
    400 
    401         //値
    402         OpBuffer[obp++]=(char)i32data;
    403     }
    404     else{
    405         //オペコード
    406         OpBuffer[obp++]=(char)0x69;
    407 
    408         //レジスタ
    409         OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg));
    410 
    411         //値
    412         *((long *)(OpBuffer+obp))=i32data;
    413         obp+=sizeof(long);
    414     }
    415 }
    416 
    417 
    418 
    419 //////////////////////
    420 // and関連
    421 //////////////////////
    422 
    423 void op_and_RV(int reg,int value){
    424     //and reg,value
    425 
    426     if(reg==REG_RAX){
    427         //eaxのみ特殊
    428 
    429         // [8bit rex] 0010 0101 [32bit offset]
    430         OpBuffer[obp++]=(char)0x25;
    431         *((long *)(OpBuffer+obp))=value;
    432         obp+=sizeof(long);
    433     }
    434     else{
    435         //16ビット演算の命令プリフィックス
    436         char op_prefix=0;
    437 
    438         //オペコード
    439         char opcode=(char)0x81;
    440 
    441         __op_format(op_prefix,opcode,0,0,reg,value,MOD_REG);
    442     }
    443 }
    444 
    445 void op_or_RR( int op_size, int reg1, int reg2 ){
    446     //16ビット演算のプリフィックス
    447     if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;
    448 
    449     //オペコード
    450     if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x0A;
    451     else OpBuffer[obp++]=(char)0x0B;
    452 
    453     //レジスタ
    454     OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
    455 }
    456 
    457 
    458 
    459 void op_neg( int reg ){
    460     //neg reg
    461 
    462     //オペコード
    463     OpBuffer[obp++]=(char)0xF7;
    464 
    465     //レジスタ
    466     OpBuffer[obp++]=(char)(0xD8| REGISTER_OPERAND(reg));
    467 }
    468 
    469 
    470 
    471 ///////////////////////
    472 // 64ビット関連
    473 ///////////////////////
    474 
    475 void op_cdq(){
    476     //cdq
    477     OpBuffer[obp++]=(char)0x99;
    478 }
    479 
    480 
    481 
    482 /////////////////////
    483 // ストリング関係
    484 /////////////////////
    485 
    486 void op_rep_movs(int op_size){
    487     if(op_size==sizeof(BYTE)){
    488         //rep movs byte ptr[edi],byte ptr[esi]
    489         OpBuffer[obp++]=(char)0xF3;
    490         OpBuffer[obp++]=(char)0xA4;
    491     }
    492     else if(op_size==sizeof(short)){
    493         //rep movs word ptr[edi],word ptr[esi]
    494         OpBuffer[obp++]=(char)0xF3;
    495         OpBuffer[obp++]=(char)0x66;
    496         OpBuffer[obp++]=(char)0xA5;
    497     }
    498     else if(op_size==sizeof(long)){
    499         //rep movs dword ptr[edi],dword ptr[esi]
    500         OpBuffer[obp++]=(char)0xF3;
    501         OpBuffer[obp++]=(char)0xA5;
    502     }
    503 }
    504 
    505 
    506 
    507 
    508 //////////////////////////
    509 // スタック関連
    510 //////////////////////////
    511 
    512 void op_push(int reg){
    513     //push reg
    514 
    515     if( reg == REG_NON ){
    516         op_sub_esp( PTR_SIZE );
    517         return;
    518     }
    519 
    520     //オペコード、レジスタ
    521     __op_format(0,(char)0x50,reg);
    522 }
    523 void op_push_V(long data){
    524     //スタックにリテラル値をプッシュ
    525     if(-128<=data&&data<=127){
    526         //push 8ビット値
    527         OpBuffer[obp++]=(char)0x6A;
    528         OpBuffer[obp++]=(char)data;
    529     }
    530     else{
    531         //push 32ビット値
    532         OpBuffer[obp++]=(char)0x68;
    533         *((long *)(OpBuffer+obp))=data;
    534         obp+=sizeof(long);
    535     }
    536 }
    537 void op_pop(int reg){
    538     //pop reg
    539 
    540     if( reg == REG_NON ){
    541         op_add_esp( PTR_SIZE );
    542         return;
    543     }
    544 
    545     //オペコード、レジスタ
    546     __op_format(0,(char)0x58,reg);
    547 }
    548 void op_add_esp(int num){
    549     //スタックポインタの加算（pop方向）
    550 
    551     //add esp,num
    552     if(0xFFFFFF80&num){
    553         OpBuffer[obp++]=(char)0x81;
    554         OpBuffer[obp++]=(char)0xC4;
    555         *((long *)(OpBuffer+obp))=num;
    556         obp+=sizeof(long);
    557     }
    558     else{
    559         //「128 > num > -127」の場合
    560         OpBuffer[obp++]=(char)0x83;
    561         OpBuffer[obp++]=(char)0xC4;
    562         OpBuffer[obp++]=(char)num;
    563     }
    564 }
    565 void op_sub_esp(int num){
    566     //スタックポインタの減算（push方向）
    567 
    568     //sub esp,num
    569     if(0xFFFFFF80&num){
    570         OpBuffer[obp++]=(char)0x81;
    571         OpBuffer[obp++]=(char)0xEC;
    572         *((long *)(OpBuffer+obp))=num;
    573         obp+=sizeof(long);
    574     }
    575     else{
    576         //「128 > num > -127」の場合
    577         OpBuffer[obp++]=(char)0x83;
    578         OpBuffer[obp++]=(char)0xEC;
    579         OpBuffer[obp++]=(char)num;
    580     }
    581 }
    582 
    583 
    584 
    585 /////////////////////
    586 // cmp関連
    587 /////////////////////
    588 void op_cmp_RR( int reg1, int reg2 ){
    589     //オペコード
    590     OpBuffer[obp++]=(char)0x3B;
    591 
    592     //レジスタ
    593     OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
    594 }
    595 void op_cmp_value(int op_size,int reg,char byte_data){
    596     //cmp reg,byte_data
    597 
    598     if(op_size==sizeof(char)&&reg==REG_EAX){
    599         //alレジスタの場合は特殊
    600         OpBuffer[obp++]=(char)0x3C;
    601 
    602         //8ビット値
    603         OpBuffer[obp++]=byte_data;
    604 
    605         return;
    606     }
    607 
    608     //16ビット演算のプリフィックス
    609     if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;
    610 
    611     //オペコード
    612     if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x80;
    613     else OpBuffer[obp++]=(char)0x83;
    614 
    615     //レジスタ
    616     OpBuffer[obp++]=(char)(0xF8| REGISTER_OPERAND(reg));
    617 
    618     //8ビット値
    619     OpBuffer[obp++]=byte_data;
    620 }
    621 void op_setne( int reg ){
    622     //オペコード
    623     OpBuffer[obp++]=(char)0x0F;
    624     OpBuffer[obp++]=(char)0x95;
    625 
    626     //レジスタ
    627     OpBuffer[obp++]=(char)( 0xC0 | REGISTER_OPERAND(reg) );
    628 }
    629 
    630 
    631 
    632 ////////////////////
    633 // test関連
    634 ////////////////////
    635 
    636 void op_test(int reg1,int reg2){
    637     //test reg1,reg2
    638 
    639     //1000 0101 11rr rbbb
    640     OpBuffer[obp++]=(char)0x85;
    641     OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
    642 }
    643 
    644 
    645 
    646 //////////////////////////////
    647 // 浮動小数点関連
    648 //////////////////////////////
    649 
    650 void op_fld_ptr_esp(int type){
    651     //スタックポインタが示すバッファのデータを浮動小数点レジスタへロード
    652 
    653     if(type==DEF_DOUBLE){
    654         //fld qword ptr[esp]
    655         OpBuffer[obp++]=(char)0xDD;
    656         OpBuffer[obp++]=(char)0x04;
    657         OpBuffer[obp++]=(char)0x24;
    658     }
    659     else if(type==DEF_SINGLE){
    660         //fld dword ptr[esp]
    661         OpBuffer[obp++]=(char)0xD9;
    662         OpBuffer[obp++]=(char)0x04;
    663         OpBuffer[obp++]=(char)0x24;
    664     }
    665     else if(type==DEF_INT64){
    666         //fild qword ptr[esp]
    667         OpBuffer[obp++]=(char)0xDF;
    668         OpBuffer[obp++]=(char)0x2C;
    669         OpBuffer[obp++]=(char)0x24;
    670     }
    671     else if(type==DEF_LONG){
    672         //fild dword ptr[esp]
    673         OpBuffer[obp++]=(char)0xDB;
    674         OpBuffer[obp++]=(char)0x04;
    675         OpBuffer[obp++]=(char)0x24;
    676     }
    677 }
    678 void op_fld_basereg(int type,int base_reg){
    679     //fld ptr[reg]
    680 
    681     //オペコード
    682     if(type==DEF_DOUBLE)        OpBuffer[obp++]=(char)0xDD;
    683     else if(type==DEF_SINGLE)   OpBuffer[obp++]=(char)0xD9;
    684     else SetError(300,NULL,cp);
    685 
    686     if(base_reg==REG_ESP){
    687         OpBuffer[obp++]=(char)0x04;
    688         OpBuffer[obp++]=(char)0x24;
    689     }
    690     else if(base_reg==REG_EBP){
    691         OpBuffer[obp++]=(char)0x45;
    692         OpBuffer[obp++]=(char)0x00;
    693     }
    694     else{
    695         OpBuffer[obp++]=(char)REGISTER_OPERAND(base_reg);
    696     }
    697 }
    698 void op_fld_base_offset(int type,int base_reg,int offset){
    699     //fld ptr[reg+offset]
    700 
    701     //オペコード
    702     if(type==DEF_DOUBLE)        OpBuffer[obp++]=(char)0xDD;
    703     else if(type==DEF_SINGLE)   OpBuffer[obp++]=(char)0xD9;
    704     else SetError(300,NULL,cp);
    705 
    706     //オペコード、レジスタ
    707     if(base_reg==REG_ESP){
    708         OpBuffer[obp++]=(char)0x84;
    709         OpBuffer[obp++]=(char)0x24;
    710     }
    711     else{
    712         OpBuffer[obp++]=(char)(0x80|REGISTER_OPERAND(base_reg));
    713     }
    714 
    715     //オフセット値
    716     *((long *)(OpBuffer+obp))=offset;
    717     obp+=sizeof(long);
    718 }
    719 void op_fld_base_offset_ex(int type,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){
    720     //fld ptr[base_reg1+base_reg2+offset]
    721 
    722     if(base_reg1==REG_ESP){
    723         //SIBバイトのindex部にespは指定できない
    724         base_reg1=base_reg2;
    725         base_reg2=REG_ESP;
    726     }
    727 
    728     //オペコード
    729     if(type==DEF_DOUBLE)        OpBuffer[obp++]=(char)0xDD;
    730     else if(type==DEF_SINGLE)   OpBuffer[obp++]=(char)0xD9;
    731     else SetError(300,NULL,cp);
    732 
    733     int reg=0;
    734     if(bUseOffset){
    735         ///////////////////////////
    736         // オフセット値を使う
    737         ///////////////////////////
    738 
    739         //レジスタ
    740         OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(reg)<<3);
    741 
    742         //ベースレジスタ
    743         OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
    744 
    745         //オフセット値
    746         *((long *)(OpBuffer+obp))=offset;
    747         obp+=sizeof(long);
    748     }
    749     else{
    750         ///////////////////////////
    751         // オフセット値を使わない
    752         ///////////////////////////
    753 
    754         //レジスタ
    755         OpBuffer[obp++]=(char)(0x04| REGISTER_OPERAND(reg)<<3);
    756 
    757         //ベースレジスタ
    758         OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
    759     }
    760 }
    761 void op_fstp_basereg(int type,int base_reg){
    762     //fstp ptr[reg]
    763 
    764     //オペコード
    765     if(type==DEF_DOUBLE)        OpBuffer[obp++]=(char)0xDD;
    766     else if(type==DEF_SINGLE)   OpBuffer[obp++]=(char)0xD9;
    767     else SetError(300,NULL,cp);
    768 
    769     if(base_reg==REG_ESP){
    770         OpBuffer[obp++]=(char)0x1C;
    771         OpBuffer[obp++]=(char)0x24;
    772     }
    773     else if(base_reg==REG_EBP){
    774         OpBuffer[obp++]=(char)0x5D;
    775         OpBuffer[obp++]=(char)0x00;
    776     }
    777     else{
    778         OpBuffer[obp++]=(char)(0x18|REGISTER_OPERAND(base_reg));
    779     }
    780 }
    781 void op_fstp_base_offset(int type,int base_reg,int offset){
    782     //fstp ptr[reg+offset]
    783 
    784     //オペコード
    785     if(type==DEF_DOUBLE)        OpBuffer[obp++]=(char)0xDD;
    786     else if(type==DEF_SINGLE)   OpBuffer[obp++]=(char)0xD9;
    787     else SetError(300,NULL,cp);
    788 
    789     //オペコード、レジスタ
    790     if(base_reg==REG_ESP){
    791         OpBuffer[obp++]=(char)0x9C;
    792         OpBuffer[obp++]=(char)0x24;
    793     }
    794     else{
    795         OpBuffer[obp++]=(char)(0x98|REGISTER_OPERAND(base_reg));
    796     }
    797 
    798     //オフセット値
    799     *((long *)(OpBuffer+obp))=offset;
    800     obp+=sizeof(long);
    801 }
    802 void op_fstp_base_offset_ex(int type,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){
    803     //fstp ptr[base_reg1+base_reg2+offset]
    804 
    805     if(base_reg1==REG_ESP){
    806         //SIBバイトのindex部にespは指定できない
    807         base_reg1=base_reg2;
    808         base_reg2=REG_ESP;
    809     }
    810 
    811     //オペコード
    812     if(type==DEF_DOUBLE)        OpBuffer[obp++]=(char)0xDD;
    813     else if(type==DEF_SINGLE)   OpBuffer[obp++]=(char)0xD9;
    814     else SetError(300,NULL,cp);
    815 
    816     int reg=0;
    817     if(bUseOffset){
    818         ///////////////////////////
    819         // オフセット値を使う
    820         ///////////////////////////
    821 
    822         //レジスタ
    823         OpBuffer[obp++]=(char)(0x9C| REGISTER_OPERAND(reg)<<3);
    824 
    825         //ベースレジスタ
    826         OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
    827 
    828         //オフセット値
    829         *((long *)(OpBuffer+obp))=offset;
    830         obp+=sizeof(long);
    831     }
    832     else{
    833         ///////////////////////////
    834         // オフセット値を使わない
    835         ///////////////////////////
    836 
    837         //レジスタ
    838         OpBuffer[obp++]=(char)(0x1C| REGISTER_OPERAND(reg)<<3);
    839 
    840         //ベースレジスタ
    841         OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
    842     }
    843 }
    844 void op_fistp_ptr_esp( int typeSize ){
    845     if( typeSize == sizeof(_int64) ){
    846         //64bit
    847 
    848         //fistp qword ptr[esp]
    849         fpu_cast();
    850         OpBuffer[obp++]=(char)0xDF;
    851         OpBuffer[obp++]=(char)0x3C;
    852         OpBuffer[obp++]=(char)0x24;
    853         fpu_cast_end();
    854     }
    855     else if( typeSize == sizeof(long) ){
    856         //32bit
    857 
    858         //fistp dword ptr[esp]
    859         fpu_cast();
    860         OpBuffer[obp++]=(char)0xDB;
    861         OpBuffer[obp++]=(char)0x1C;
    862         OpBuffer[obp++]=(char)0x24;
    863         fpu_cast_end();
    864     }
    865     else{
    866         SetError();
    867     }
    868 }
    869 void op_fstp_push( Type &type ){
    870     //sub esp,size
    871     op_sub_esp( type.GetBasicSize() );
    872 
    873     op_fstp_basereg( type.GetBasicType(), REG_ESP );
    874 }
    875 
    876 
    877 
    878 //////////////////////////////
    879 // レジスタ関連
    880 //////////////////////////////
    881 
    882 void op_zero_reg(int reg){
    883     //レジスタに0をセット
    884 
    885     switch(reg){
    886         case REG_EAX:
    887             //xor eax,eax
    888             OpBuffer[obp++]=(char)0x33;
    889             OpBuffer[obp++]=(char)0xC0;
    890             break;
    891         case REG_EBX:
    892             //xor ebx,ebx
    893             OpBuffer[obp++]=(char)0x33;
    894             OpBuffer[obp++]=(char)0xDB;
    895             break;
    896         case REG_ECX:
    897             //xor ecx,ecx
    898             OpBuffer[obp++]=(char)0x33;
    899             OpBuffer[obp++]=(char)0xC9;
    900             break;
    901         case REG_EDX:
    902             //xor edx,edx
    903             OpBuffer[obp++]=(char)0x33;
    904             OpBuffer[obp++]=(char)0xD2;
    905             break;
    906         case REG_EBP:
    907             //xor ebp,ebp
    908             OpBuffer[obp++]=(char)0x33;
    909             OpBuffer[obp++]=(char)0xED;
    910             break;
    911     }
    912 }
    913 
    914 void fpu_cast(){
    915     ///////////////////////
    916     // FPUの切り捨て設定
    917     ///////////////////////
    918 
    919     //sub esp,16
    920     op_sub_esp(16);
    921 
    922     //mov dword ptr[esp+4],eax
    923     OpBuffer[obp++]=(char)0x89;
    924     OpBuffer[obp++]=(char)0x44;
    925     OpBuffer[obp++]=(char)0x24;
    926     OpBuffer[obp++]=(char)0x04;
    927 
    928     //fnstcw word ptr[esp]
    929     OpBuffer[obp++]=(char)0xD9;
    930     OpBuffer[obp++]=(char)0x3C;
    931     OpBuffer[obp++]=(char)0x24;
    932 
    933     //mov ax,word ptr[esp]
    934     OpBuffer[obp++]=(char)0x66;
    935     OpBuffer[obp++]=(char)0x8B;
    936     OpBuffer[obp++]=(char)0x04;
    937     OpBuffer[obp++]=(char)0x24;
    938 
    939     //or ah,0Ch
    940     OpBuffer[obp++]=(char)0x80;
    941     OpBuffer[obp++]=(char)0xCC;
    942     OpBuffer[obp++]=(char)0x0C;
    943 
    944     //mov word ptr[esp+2],ax
    945     OpBuffer[obp++]=(char)0x66;
    946     OpBuffer[obp++]=(char)0x89;
    947     OpBuffer[obp++]=(char)0x44;
    948     OpBuffer[obp++]=(char)0x24;
    949     OpBuffer[obp++]=(char)0x02;
    950 
    951     //fldcw word ptr[esp+2]
    952     OpBuffer[obp++]=(char)0xD9;
    953     OpBuffer[obp++]=(char)0x6C;
    954     OpBuffer[obp++]=(char)0x24;
    955     OpBuffer[obp++]=(char)0x02;
    956 
    957     //mov eax,dword ptr[esp+4]
    958     OpBuffer[obp++]=(char)0x8B;
    959     OpBuffer[obp++]=(char)0x44;
    960     OpBuffer[obp++]=(char)0x24;
    961     OpBuffer[obp++]=(char)0x04;
    962 
    963     //add esp,16
    964     op_add_esp(16);
    965 }
    966 void fpu_cast_end(){
    967     //sub esp,16
    968     op_sub_esp(16);
    969 
    970     //fldcw word ptr[esp]
    971     OpBuffer[obp++]=(char)0xD9;
    972     OpBuffer[obp++]=(char)0x2C;
    973     OpBuffer[obp++]=(char)0x24;
    974 
    975     //add esp,16
    976     op_add_esp(16);
    977 }
    978 
    979 
    980 /////////////////////////////
    981 // 関数呼び出し
    982 /////////////////////////////
    983 
    984 void op_call(const UserProc *pUserProc){
    985     OpBuffer[obp++]=(char)0xE8;
    986     pobj_SubAddrSchedule->add(pUserProc,1);
    987     pUserProc->Using();
    988     obp+=sizeof(long);
    989 }
    990 void op_ret(){
    991     OpBuffer[obp++]=(char)0xC3;
    992 }

  • trunk/abdev/BasicCompiler_Common/gc.cpp

    r223 r225  
    11#include "stdafx.h"
    22
    3 #include "common.h"
     3#include <Compiler.h>
    44
    55#ifdef _AMD64_
    … …  
    2525
    2626    //mov rax,rsp
    27     op_mov_RR(REG_RAX,REG_RSP);
     27    compiler.codeGenerator.op_mov_RR(REG_RAX,REG_RSP);
    2828
    2929    //mov ptr[offset],rax/eax
    30     op_mov_MR(PTR_SIZE,REG_RAX,0,(int)RelativeVar.offset,MOD_DISP32);
     30    compiler.codeGenerator.op_mov_MR(PTR_SIZE,REG_RAX,0,(int)RelativeVar.offset,MOD_DISP32);
    3131    obp-=sizeof(long);
    3232    pobj_GlobalVarSchedule->add();

  • trunk/abdev/BasicCompiler_Common/include/CodeGenerator.h

    r224 r225  
    11#pragma once
    22
     3#include <NativeCode.h>
     4
     5#ifdef _AMD64_
     6#include "../../BasicCompiler64/MachineFixed.h"
     7#else
     8#include "../../BasicCompiler32/MachineFixed.h"
     9#endif
     10
     11
    312void ReallocNativeCodeBuffer();
     13
     14class CodeGenerator
     15{
     16    NativeCode *pNativeCode;
     17
     18    // XMLシリアライズ用
     19private:
     20    friend class boost::serialization::access;
     21    template<class Archive> void serialize(Archive& ar, const unsigned int version)
     22    {
     23        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( NativeCode );
     24    }
     25
     26public:
     27
     28    void Select( NativeCode &nativeCode )
     29    {
     30        pNativeCode = &nativeCode;
     31    }
     32
     33#ifdef _AMD64_
     34#else
     35private:
     36    void set_mod_rm_sib_disp(char mod,int reg,int scale,int index_reg,int base_reg,long disp);
     37    void __op_format(char op_prefix,char opcode,int reg);
     38    void __op_format(char op_prefix,char opcode1,char opcode2,int reg,int base_reg,int offset,char mod);
     39public:
     40    void op_mov_RV          (int reg,long offset);
     41    void op_mov_RV          (int op_size,int reg,int offset);
     42    void op_mov_RR          (int reg1,int reg2);
     43    void op_mov_RM          (int op_size,int reg,int base_reg,int offset,char mod);
     44    void op_mov_RM_ex       (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset);
     45    void op_mov_MR          (int op_size,int reg,int base_reg,int offset,char mod);
     46    void op_mov_MR_ex       (int op_size,int reg,int base_reg1,int base_reg2,long offset,BOOL bUseOffset);
     47    void op_movsx_R32R16    (int reg32,int reg16 = REG_NON);
     48    void op_movsx_R32R8     (int reg32,int reg8 = REG_NON);
     49    void op_movsx_R16R8     (int reg16,int reg8 = REG_NON);
     50    void op_inc             (int reg);
     51    void op_dec             (int reg);
     52    void op_add_RV8         (int reg,char cValue);
     53    void op_add_RR          ( int reg1, int reg2 );
     54    void op_add_RM          (int op_size,int reg,int base_reg,int offset,char mod);
     55    void op_adc_RV8         (int reg,char cValue);
     56    void op_adc_RR          ( int reg1, int reg2 );
     57    void op_sub_RV8         (int reg,char cValue);
     58    void op_sub_RR          ( int reg1, int reg2 );
     59    void op_sbb_RV8         (int reg,char cValue);
     60    void op_sbb_RR          ( int reg1, int reg2 );
     61    void op_imul_RR         (int reg1,int reg2);
     62    void op_imul_RV         (int reg,long i32data);
     63    void op_imul_RV8        (int reg,char cValue);
     64    void op_div_R           ( int reg );
     65    void op_idiv_R          ( int reg );
     66    void op_and_RV          (int reg,long value);
     67    void op_and_RR          ( int reg1, int reg2 );
     68    void op_or_RR           ( int op_size, int reg1, int reg2 );
     69    void op_xor_RR          ( int reg1, int reg2 = REG_NON );
     70    void op_neg             ( int reg );
     71    void op_cdq             ();
     72
     73    void op_rep_movs        (int op_size);
     74
     75    void op_push(int reg);
     76    void op_push_V(long data);
     77    void op_push_M( int base_reg );
     78    void op_pop(int reg = REG_NON);
     79    void op_add_esp(long num);
     80    void op_sub_esp(long num);
     81    void op_cmp_RR( int reg1, int reg2 );
     82    void op_cmp_value(int op_size,int reg,char byte_data);
     83    void op_setne( int reg );
     84    void op_test(int reg1,int reg2);
     85    void op_test_ah( char cValue );
     86    void op_fld_ptr_esp(int type);
     87    void op_fld_basereg         (int type,int base_reg);
     88    void op_fld_base_offset     (int type,int base_reg,long offset);
     89    void op_fld_base_offset_ex  (int type,int base_reg1,int base_reg2,long offset,BOOL bUseOffset);
     90    void op_fstp_basereg        (int type,int base_reg);
     91    void op_fstp_base_offset    (int type,int base_reg,long offset);
     92    void op_fstp_base_offset_ex (int type,int base_reg1,int base_reg2,long offset,BOOL bUseOffset);
     93    void op_fistp_ptr_esp       ( int typeSize );
     94    void op_fstp_push           ( Type &type );
     95    void op_fcompp();
     96    void op_fnstsw_ax();
     97    void op_zero_reg(int reg);
     98    void fpu_cast();
     99    void fpu_cast_end();
     100
     101    void op_call(const UserProc *pUserProc);
     102    void op_ret();
     103#endif
     104
     105
     106
     107
     108    void PutOld( char c1, char c2 )
     109    {
     110        pNativeCode->Put( c1 );
     111        pNativeCode->Put( c2 );
     112    }
     113    void PutOld( char c1, char c2, char c3 )
     114    {
     115        pNativeCode->Put( c1 );
     116        pNativeCode->Put( c2 );
     117        pNativeCode->Put( c3 );
     118    }
     119    void PutOld( char c1, char c2, char c3, char c4 )
     120    {
     121        pNativeCode->Put( c1 );
     122        pNativeCode->Put( c2 );
     123        pNativeCode->Put( c3 );
     124        pNativeCode->Put( c4 );
     125    }
     126    void PutOld( char c1, char c2, char c3, char c4, char c5 )
     127    {
     128        pNativeCode->Put( c1 );
     129        pNativeCode->Put( c2 );
     130        pNativeCode->Put( c3 );
     131        pNativeCode->Put( c4 );
     132        pNativeCode->Put( c5 );
     133    }
     134    void PutOld( char c1, char c2, char c3, char c4, char c5, char c6 )
     135    {
     136        pNativeCode->Put( c1 );
     137        pNativeCode->Put( c2 );
     138        pNativeCode->Put( c3 );
     139        pNativeCode->Put( c4 );
     140        pNativeCode->Put( c5 );
     141        pNativeCode->Put( c6 );
     142    }
     143};

  • trunk/abdev/BasicCompiler_Common/include/Compiler.h

    r224 r225  
    55#include <MetaImpl.h>
    66#include <DataTable.h>
     7#include <CodeGenerator.h>
    78
    89class Compiler
    … …  
    3435    }
    3536
     37    // グローバル領域のネイティブコード
     38    NativeCode globalNativeCode;
     39
     40    // コード生成機構
     41    CodeGenerator codeGenerator;
     42
    3643    static bool StringToType( const std::string &typeName, Type &type );
    3744    static const std::string TypeToString( const Type &type );

  • trunk/abdev/BasicCompiler_Common/include/NativeCode.h

    r224 r225  
    22
    33#include <vector>
     4
     5#include <BoostSerializationSupport.h>
    46
    57class Schedule
    … …  
    911    {
    1012        None,
     13        GlobalVar,      // グローバル変数スケジュール
     14        LocalVar,       // ローカル変数スケジュール
     15        Relocation,     // リロケーション情報スケジュール
    1116    };
    1217
    … …  
    123128        memcpy( this->codeBuffer + this->size, codeBuffer, size );
    124129        this->size += size;
     130
     131        // 未完成
     132        extern char *OpBuffer;
     133        extern int obp;
     134        memcpy( OpBuffer, codeBuffer, size );
     135        obp += size;
    125136    }
    126137    void Put( const NativeCode &nativeCode )
    … …  
    132143        codeBuffer[size++] = c;
    133144        Realloc();
     145
     146
     147
     148        // 未完成
     149        extern char *OpBuffer;
     150        extern int obp;
     151        OpBuffer[obp++]=c;
    134152    }
    135153    void Put( long l, Schedule::Type scheduleType = Schedule::None )
    … …  
    142160        *((long *)(codeBuffer+size))=l;
    143161        size += sizeof(long);
     162
     163
     164
     165        // 未完成
     166        extern char *OpBuffer;
     167        extern int obp;
     168        *((long *)(OpBuffer+obp))=l;
     169        obp+=sizeof(long);
    144170    }
    145171};

  • trunk/abdev/BasicCompiler_Common/include/Procedure.h

    r224 r225  
    1111#include <Parameter.h>
    1212#include <Variable.h>
    13 #include <NativeCode.h>
     13#include <CodeGenerator.h>
    1414
    1515class CClass;
    … …  
    314314    }
    315315
     316    NativeCode &GetNativeCode()
     317    {
     318        return nativeCode;
     319    }
     320
    316321    std::string GetFullName() const;
    317322

  • trunk/abdev/BasicCompiler_Common/src/LexicalScopingImpl.cpp

    r206 r225  
    108108
    109109            //mov ecx,dword ptr[ebp+offset]
    110             op_mov_RM(sizeof(long),REG_ECX,REG_EBP,-pVar->GetOffsetAddress(),MOD_BASE_DISP32);
     110            compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_EBP,-pVar->GetOffsetAddress(),MOD_BASE_DISP32);
    111111            obp-=sizeof(long);
    112112            AddLocalVarAddrSchedule();
    … …  
    114114
    115115            //push ecx
    116             op_push(REG_ECX);
     116            compiler.codeGenerator.op_push(REG_ECX);
    117117#endif
    118118
    119119            //call free
    120120            extern const UserProc *pSub_free;
    121             op_call(pSub_free);
     121            compiler.codeGenerator.op_call(pSub_free);
    122122
    123123
Note: See TracChangeset for help on using the changeset viewer.