source: dev/trunk/abdev/BasicCompiler64/NumOpe_TypeOperation.cpp @ 308

#include "stdafx.h"

#include <jenga/include/smoothie/Smoothie.h>

#include <Compiler.h>

#include "../BasicCompiler_Common/common.h"
#include "Opcode.h"

void ExtendTypeTo64( const Type &oldType, int reg ){
    if( oldType.IsLong() )
    {
        //movsxd reg64,reg32
        compiler.codeGenerator.op_movsxd(reg,reg);
    }
    else if( oldType.IsDWord() )
    {
        //and reg,00000000FFFFFFFFh
    }
    else if( oldType.IsInteger() )
    {
        //movsx reg64,reg16
        compiler.codeGenerator.op_movsx64_FromReg16(reg,reg);
    }
    else if( oldType.IsWord() )
    {
        //and reg,000000000000FFFFh
        compiler.codeGenerator.op_and64_value(reg,(int)0xFFFF);
    }
    else if( oldType.IsSByte() )
    {
        //movsx reg64,reg8
        compiler.codeGenerator.op_movsx64_FromReg8(reg,reg);
    }
    else if( oldType.IsByte() || oldType.IsBoolean() )
    {
        //and reg,00000000000000FFh
        compiler.codeGenerator.op_and64_value(reg,(int)0x00FF);
    }
}
void ExtendTypeTo32( const Type &oldType, int reg ){
    if( oldType.IsInteger() )
    {
        //movsx reg32,reg16
        compiler.codeGenerator.op_movsx32_FromReg16(reg,reg);
    }
    else if( oldType.IsWord() )
    {
        //and reg,0000FFFFh
        compiler.codeGenerator.op_and32_value(reg,(int)0xFFFF);
    }
    else if( oldType.IsSByte() )
    {
        //movsx reg32,reg8
        compiler.codeGenerator.op_movsx32_FromReg8(reg,reg);
    }
    else if( oldType.IsByte() || oldType.IsBoolean() )
    {
        //and reg,000000FFh
        compiler.codeGenerator.op_and32_value(reg,(int)0xFF);
    }
}
void ExtendTypeTo16( const Type &oldType, int reg ){
    if( oldType.IsSByte() )
    {
        //movsx reg16,reg8
        compiler.codeGenerator.op_movsx16_FromReg8(reg,reg);
    }
    else if( oldType.IsByte() || oldType.IsBoolean() )
    {
        //and reg,000000FFh
        compiler.codeGenerator.op_and32_value(reg,(int)0xFF);
    }
}

void ChangeTypeToXmm_Double(int type,int xmm_reg,int general_reg){
    if(type==DEF_DOUBLE){
        //なにもしない
    }
    else if(type==DEF_SINGLE){
        //Single型

        //cvtss2sd
        compiler.codeGenerator.op_cvtss2sd(xmm_reg,xmm_reg);
    }
    else if(Is64Type(type)){
        //64ビット整数型

        //cvtsi2sd xmm_reg,reg
        compiler.codeGenerator.op_cvtsi2sd_reg(sizeof(_int64),xmm_reg,general_reg);

        if(type==DEF_QWORD){
            //符号なし

            //test reg,reg
            compiler.codeGenerator.op_test(general_reg,general_reg);

            //jge 9
            compiler.codeGenerator.op_jge( 9 );

            //addsd xmm_reg,qword ptr[offset]   ※offset value:43f0000000000000
            _int64 i64data=0x43f0000000000000;
            long temp=compiler.GetObjectModule().dataTable.Add( i64data );
            compiler.codeGenerator.PutOld(
                (char)0xF2,
                (char)0x0F,
                (char)0x58,
                (char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3),
                (char)0x25
            );
            compiler.codeGenerator.PutOld(
                temp,
                Schedule::DataTable
            );
        }
    }
    else if(type==DEF_DWORD){
        //符号なし32ビット値

        //64ビットにレジスタ値を拡張
        ExtendTypeTo64(type,general_reg);

        //cvtsi2sd xmm_reg,reg
        compiler.codeGenerator.op_cvtsi2sd_reg(sizeof(_int64),xmm_reg,general_reg);
    }
    else{
        //その他整数

        //32ビットにレジスタ値を拡張
        ExtendTypeTo32(type,general_reg);

        //cvtsi2sd xmm_reg,reg
        compiler.codeGenerator.op_cvtsi2sd_reg(sizeof(long),xmm_reg,general_reg);
    }
}
void ChangeTypeToXmm_Single(int type,int xmm_reg,int general_reg){
    if(type==DEF_DOUBLE){
        //Double型

        //cvtsd2ss
        compiler.codeGenerator.op_cvtsd2ss(xmm_reg,xmm_reg);
    }
    else if(type==DEF_SINGLE){
        //なにもしない
    }
    else if(Is64Type(type)){
        //64ビット整数型

        //cvtsi2ss xmm_reg,reg
        compiler.codeGenerator.op_cvtsi2ss_reg(sizeof(_int64),xmm_reg,general_reg);

        if(type==DEF_QWORD){
            //符号なし

            //test reg,reg
            compiler.codeGenerator.op_test(general_reg,general_reg);

            //jge 9
            compiler.codeGenerator.op_jge( 9 );

            //addss xmm_reg,dword ptr[offset]   ※offset value:5f800000
            long i32data=0x5f800000;
            long temp=compiler.GetObjectModule().dataTable.Add( i32data );
            compiler.codeGenerator.PutOld(
                (char)0xF3,
                (char)0x0F,
                (char)0x58,
                (char)(0x04 | REGISTER_OPERAND(xmm_reg)<<3),
                (char)0x25
            );
            compiler.codeGenerator.PutOld(
                temp,
                Schedule::DataTable
            );
        }
    }
    else if(type==DEF_DWORD){
        //符号なし32ビット値

        //64ビットにレジスタ値を拡張
        ExtendTypeTo64(type,general_reg);

        //cvtsi2ss xmm_reg,reg
        compiler.codeGenerator.op_cvtsi2ss_reg(sizeof(_int64),xmm_reg,general_reg);
    }
    else{
        //その他整数

        //32ビットにレジスタ値を拡張
        ExtendTypeTo32(type,general_reg);

        //cvtsi2ss xmm_reg,reg
        compiler.codeGenerator.op_cvtsi2ss_reg(sizeof(long),xmm_reg,general_reg);
    }
}

void ChangeTypeToWhole( const Type &oldType, const Type &newType, int reg, int xmm_reg )
{
    if( oldType.IsDouble() )
    {
        if( newType.Is64() )
        {
            //cvttsd2si reg,xmm_reg
            compiler.codeGenerator.op_cvttsd2si_xmm(sizeof(_int64),reg,xmm_reg);
        }
        else
        {
            //cvttsd2si reg,xmm_reg
            compiler.codeGenerator.op_cvttsd2si_xmm(sizeof(long),reg,xmm_reg);
        }
    }
    if( oldType.IsSingle() )
    {
        if( newType.Is64() )
        {
            //cvttss2si reg,xmm_reg
            compiler.codeGenerator.op_cvttss2si_xmm(sizeof(_int64),reg,xmm_reg);
        }
        else
        {
            //cvttss2si reg,xmm_reg
            compiler.codeGenerator.op_cvttss2si_xmm(sizeof(long),reg,xmm_reg);
        }
    }
    else{
        //整数から整数へ変換

        if( newType.Is64() )
        {
            ExtendTypeTo64(oldType,reg);
        }
        if( newType.GetSize() == sizeof(long) )
        {
            ExtendTypeTo32(oldType,reg);
        }
        if( newType.GetSize() == sizeof(short) )
        {
            ExtendTypeTo16(oldType,reg);
        }
    }
}



/////////////////////////////////////////
// 1つの項を適切なレジスタへセット
/////////////////////////////////////////

void SetOneTermToReg_RealCalc(int TermType,int *pXmmReg){
    int xmm_reg;

    if(IsRealNumberType(TermType)){
        //実数型
        xmm_reg=pobj_reg->GetLockingXmmReg();

        if(xmm_reg==REG_XMM4){
            if(TermType==DEF_DOUBLE){
                //movlpd xmm4,qword ptr[rsp+offset]     ※スタックフレームを利用
                pobj_sf->pop(xmm_reg,sizeof(double));
            }
            if(TermType==DEF_SINGLE){
                //movss xmm4,dword ptr[rsp+offset]      ※スタックフレームを利用
                pobj_sf->pop(xmm_reg,sizeof(float));
            }
        }
    }
    else{
        SetError(300,NULL,cp);
    }

    *pXmmReg=xmm_reg;
}
void SetOneTermToReg_Whole64Calc(int TermType,int *pReg){
    //1つの項を適切なレジスタへセット（64ビット整数演算用）
    int reg;

    reg=pobj_reg->GetLockingReg();

    if(reg==REG_R14){
        //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(REG_R14);
    }

    //レジスタ値を64ビットに拡張
    ExtendTypeTo64(TermType,reg);

    *pReg=reg;
}
void SetOneTermToReg_Whole32Calc(int TermType,int *pReg){
    //1つの項を適切なレジスタへセット（32ビット整数演算用）
    int reg;

    reg=pobj_reg->GetLockingReg();

    if(reg==REG_R14){
        //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(REG_R14);
    }

    //レジスタ値を32ビットに拡張
    ExtendTypeTo32(TermType,reg);

    *pReg=reg;
}



/////////////////////////////////////////
// 2つの項を適切なレジスタへセット
/////////////////////////////////////////

void SetTowTermToReg_RealCalc(int AnswerType,int *type,int sp,int *pXmmReg1,int *pXmmReg2){
    //2つの項を適切なレジスタへセット（Double演算用）
    int xmm_reg1,xmm_reg2,temp_reg;


    ///////////////////
    // 第2項
    ///////////////////

    if(IsRealNumberType(type[sp-1])){
        //実数型
        xmm_reg2=pobj_reg->UnlockXmmReg();

        if(xmm_reg2==REG_XMM4){
            xmm_reg2=REG_XMM5;

            if(type[sp-1]==DEF_DOUBLE){
                //movlpd xmm5,qword ptr[rsp+offset]     ※スタックフレームを利用
                pobj_sf->pop(xmm_reg2,sizeof(double));
            }
            if(type[sp-1]==DEF_SINGLE){
                //movss xmm5,dword ptr[rsp+offset]      ※スタックフレームを利用
                pobj_sf->pop(xmm_reg2,sizeof(float));
            }
        }
        else{
            if(!IsRealNumberType(type[sp-2])){
                if(type[sp-1]==DEF_DOUBLE){
                    //movsd xmm5,xmm_reg
                    compiler.codeGenerator.op_movsd_RR( REG_XMM5, xmm_reg2 );
                }
                if(type[sp-1]==DEF_SINGLE){
                    //movss xmm5,xmm_reg
                    compiler.codeGenerator.op_movss_RR( REG_XMM5, xmm_reg2 );
                }

                xmm_reg2=REG_XMM5;
            }
        }
    }
    else{
        //整数値

        temp_reg=pobj_reg->UnlockReg();

        if(temp_reg==REG_R14){
            //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
            pobj_sf->pop(REG_R14);
        }

        xmm_reg2=REG_XMM5;
    }

    //汎用レジスタ（temp_reg）をXMMレジスタ（xmm_reg2）にコピー
    if(AnswerType==DEF_DOUBLE)
        ChangeTypeToXmm_Double(type[sp-1],xmm_reg2,temp_reg);
    if(AnswerType==DEF_SINGLE)
        ChangeTypeToXmm_Single(type[sp-1],xmm_reg2,temp_reg);


    ///////////////////
    // 第1項
    ///////////////////

    if(IsRealNumberType(type[sp-2])){
        //実数
        xmm_reg1=pobj_reg->GetLockingXmmReg();

        if(xmm_reg1==REG_XMM4){
            if(type[sp-2]==DEF_DOUBLE){
                //movlpd xmm4,qword ptr[rsp+offset]     ※スタックフレームを利用
                pobj_sf->pop(xmm_reg1,sizeof(double));
            }
            if(type[sp-2]==DEF_SINGLE){
                //movss xmm4,dword ptr[rsp+offset]      ※スタックフレームを利用
                pobj_sf->pop(xmm_reg1,sizeof(float));
            }
        }
    }
    else{
        //整数

        temp_reg=pobj_reg->UnlockReg();

        if(temp_reg==REG_R14){
            //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
            pobj_sf->pop(REG_R14);
        }

        xmm_reg1=pobj_reg->LockXmmReg();
    }

    //汎用レジスタ（temp_reg）をXMMレジスタ（xmm_reg1）にコピー
    if(AnswerType==DEF_DOUBLE)
        ChangeTypeToXmm_Double(type[sp-2],xmm_reg1,temp_reg);
    if(AnswerType==DEF_SINGLE)
        ChangeTypeToXmm_Single(type[sp-2],xmm_reg1,temp_reg);


    *pXmmReg1=xmm_reg1;
    *pXmmReg2=xmm_reg2;
}
void SetTowTermToReg_Whole64Calc(int *type,int sp,int *pReg1,int *pReg2){
    //2つの項を適切なレジスタへセット（64ビット整数演算用）
    int reg1,reg2;

    //////////////////
    // 第2項
    //////////////////
    reg2=pobj_reg->UnlockReg();

    if(reg2==REG_R14){
        //mov r15,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(REG_R15);

        reg2=REG_R15;
    }

    //レジスタ値を64ビットに拡張
    ExtendTypeTo64(type[sp-1],reg2);


    //////////////////
    // 第1項
    //////////////////
    reg1=pobj_reg->GetLockingReg();

    if(reg1==REG_R14){
        //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(REG_R14);
    }

    //レジスタ値を64ビットに拡張
    ExtendTypeTo64(type[sp-2],reg1);


    *pReg1=reg1;
    *pReg2=reg2;
}
void SetTowTermToReg_Whole32Calc(int *type,int sp,int *pReg1,int *pReg2){
    //2つの項を適切なレジスタへセット（32ビット整数演算用）
    int reg1,reg2;

    //////////////////
    // 第2項
    //////////////////
    reg2=pobj_reg->UnlockReg();

    if(reg2==REG_R14){
        //mov r15,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(REG_R15);

        reg2=REG_R15;
    }

    //レジスタ値を32ビットに拡張
    ExtendTypeTo32(type[sp-1],reg2);


    //////////////////
    // 第1項
    //////////////////
    reg1=pobj_reg->GetLockingReg();

    if(reg1==REG_R14){
        //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(REG_R14);
    }

    //レジスタ値を32ビットに拡張
    ExtendTypeTo32(type[sp-2],reg1);


    *pReg1=reg1;
    *pReg2=reg2;
}



////////////////////////////
// As 演算子によるキャスト
////////////////////////////

BOOL Calc_Cast(int *type,LONG_PTR *index_stack,int *pStackPointer){
    //キャスト

    int sp;
    sp=*pStackPointer;

    int castBasicType = type[sp-1];
    if((castBasicType&FLAG_CAST)==0){
        SetError(47,NULL,cp);
        return 0;
    }
    castBasicType = castBasicType&(~FLAG_CAST);

    Type oldType( type[sp-2], index_stack[sp-2] );
    Type castType( castBasicType, index_stack[sp-1] );

    int xmm_reg,reg;
    if( castType.IsReal() )
    {
        //実数型へキャスト

        if( oldType.IsReal() )
        {
            SetOneTermToReg_RealCalc(oldType.GetBasicType(),&xmm_reg);
        }
        else
        {
            if( oldType.Is64() )
            {
                SetOneTermToReg_Whole64Calc(oldType.GetBasicType(),&reg);
            }
            else if( oldType.IsWhole() )
            {
                SetOneTermToReg_Whole32Calc(oldType.GetBasicType(),&reg);
            }

            pobj_reg->UnlockReg();

            xmm_reg=pobj_reg->LockXmmReg();
        }

        if( castType.IsDouble() )
        {
            //Double型にデータ変換
            ChangeTypeToXmm_Double(oldType.GetBasicType(),xmm_reg,reg);
        }
        else if( castType.IsSingle() )
        {
            //Single型にデータ変換
            ChangeTypeToXmm_Single(oldType.GetBasicType(),xmm_reg,reg);
        }

        if(xmm_reg==REG_XMM4){
            //movsd qword ptr[rsp+offset],xmm4      ※スタックフレームを利用
            pobj_sf->push(REG_XMM4,sizeof(double));
        }
    }
    else{
        //その他整数型へ変換

        if( oldType.IsReal() )
        {
            SetOneTermToReg_RealCalc(oldType.GetBasicType(),&xmm_reg);

            pobj_reg->UnlockXmmReg();

            reg=pobj_reg->LockReg();

            //整数型へデータ変換
            ChangeTypeToWhole(oldType,castType,reg,xmm_reg);

            if(reg==REG_R14){
                //mov qword ptr[rsp+offset],r14     ※スタックフレームを利用
                pobj_sf->push(REG_R14);
            }
        }
        else{
            reg=pobj_reg->GetLockingReg();

            if(reg==REG_R14){
                //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
                pobj_sf->pop(REG_R14);
            }

            //整数型へデータ変換
            ChangeTypeToWhole(oldType,castType,reg,0);

            if(reg==REG_R14){
                //mov qword ptr[rsp+offset],r14     ※スタックフレームを利用
                pobj_sf->push(REG_R14);
            }
        }
    }

    type[sp-2] = castType.GetBasicType();
    index_stack[sp-2] = castType.GetIndex();

    sp--;

    *pStackPointer=sp;
    return 1;
}