source: dev/trunk/ab5.0/abdev/compiler_x64/Opcode.h@ 828

#pragma once

#include <array>

#include "MachineFixed.h"


//変数の種類
#define NON_VAR             0
#define VAR_GLOBAL          1   // Global Variable
#define VAR_REFGLOBAL       2   // Global Refference Variable
#define VAR_LOCAL           3   // Local Variable
#define VAR_REFLOCAL        4   // Local Refference Variable
#define VAR_DIRECTMEM       5   // Direct memory


extern int cp;

#define breakpoint compiler.codeGenerator.PutOld( (char)0xCC );


//プロシージャ
struct PROCEDURE{
    char name[255];
    int address;
    int types[MAX_PARMS];
    _int8 ByVal[MAX_PARMS];
    BOOL ReturnType;
};

//With情報
struct WithInfo
{
    std::string name;
    int sourceCodePos;

    WithInfo( const std::string &name, int sourceCodePos )
        : name( name )
        , sourceCodePos( sourceCodePos )
    {
    }

    WithInfo(WithInfo&& y)
        : name(std::move(y.name))
        , sourceCodePos(std::move(y.sourceCodePos))
    {
    }

    WithInfo(WithInfo const& y)
        : name(y.name)
        , sourceCodePos(y.sourceCodePos)
    {
    }

    WithInfo& operator =(WithInfo&& y)
    {
        name = std::move(y.name);
        sourceCodePos = std::move(y.sourceCodePos);
        return *this;
    }

    WithInfo& operator =(WithInfo const& y)
    {
        return *this = std::move(WithInfo(y));
    }
};
typedef std::vector<WithInfo> WithInfos;


class StackFrame
{
    ///////////////////////////
    // スタックフレーム管理
    ///////////////////////////

    PertialSchedules pertialSchedules;

    int lowest_sp;          //スタックポインタの最下位位置
    int now_sp;             //スタックポインタ
    int max_parm_size;      //パラメータの最大サイズ

public:
    //コンストラクタ
    StackFrame();

    //デストラクタ
    ~StackFrame();

    int GetFrameSize( int localParamSize );
    int GetNowSp();
    void mov_sp( int reg );
    int push(int reg);
    void push(int xmm_reg,int varSize);
    void ref_offset_data( int reg, int sp_offset );
    void ref(int reg);
    void ref(int xmm_reg,int varSize);
    void pop(int reg = REG_NON);
    void pop(int xmm_reg,int varSize);
    void parameter_allocate(int size);
    void RunningSchedule( int stackFrameSize );

    void error_check(void);

private:
    StackFrame(StackFrame const&);
    StackFrame& operator =(StackFrame const&);
};
extern StackFrame *pobj_sf;


class CBlockReg{
    int array_BlockReg[256];
    int num;

public:
    CBlockReg();
    void lock(int reg);
    void unlock(int reg);
    BOOL check(int reg);
    void clear(void);

    //レジスタのバックアップと復旧
    void backup();
    void restore();

private:
    CBlockReg(CBlockReg const&);
    CBlockReg& operator =(CBlockReg const&);
};
extern CBlockReg *pobj_BlockReg;
class CRegister{
    ////////////////////
    // レジスタ管理
    ////////////////////

    //利用可能なレジスタを列挙する関数
    void EnumRegister(int const *pRegList,int nMaxList,int *array_reg,int *sp,int AnswerReg);

    std::array<int, 16> array_UseReg;
    int sp_UseReg;

    std::array<int, 16> array_XmmReg;
    int sp_XmmReg;

    int init_sp_reg,init_sp_xmm_reg;

public:
    CRegister(){};
    CRegister(int AnswerReg);
    
    CRegister(CRegister const& y)
        : array_UseReg(y.array_UseReg)
        , sp_UseReg(y.sp_UseReg)
        , array_XmmReg(y.array_XmmReg)
        , sp_XmmReg(y.sp_XmmReg)
        , init_sp_reg(y.init_sp_reg)
        , init_sp_xmm_reg(y.init_sp_xmm_reg)
    {
    }

    CRegister& operator =(CRegister const& y)
    {
        array_UseReg = y.array_UseReg;
        sp_UseReg = y.sp_UseReg;
        array_XmmReg = y.array_XmmReg;
        sp_XmmReg = y.sp_XmmReg;
        init_sp_reg = y.init_sp_reg;
        init_sp_xmm_reg = y.init_sp_xmm_reg;
        return *this;
    }

    ~CRegister(){};

    //コンパイラにバグがないかをチェックする機構
    void bug_check();

    //汎用レジスタ
    int GetNextReg();
    int GetLockingReg();
    int LockReg();
    int UnlockReg();

    //XMMレジスタ
    int GetNextXmmReg();
    int GetLockingXmmReg();
    int LockXmmReg();
    int UnlockXmmReg();

    //レジスタが利用中かどうかを調べる
    bool IsUsing( int reg );

    //レジスタのバックアップと復旧
    void backup();
    void restore();
};
extern CRegister *pobj_reg;


#define BACKUP_REGISTER_RESOURCE                                \
    /* レジスタをスタックフレームにバックアップ */              \
    pobj_BlockReg->backup();                                    \
    if(pobj_reg) pobj_reg->backup();                            \
                                                                \
    /* レジスタブロッキングオブジェクトを退避して再生成 */      \
    CBlockReg *pobj_BlockReg_back;                              \
    pobj_BlockReg_back=pobj_BlockReg;                           \
    pobj_BlockReg=new CBlockReg;                                \
                                                                \
    /* レジスタ管理オブジェクトポインタを退避して0をセット */    \
    CRegister *pobj_reg_back;                                   \
    pobj_reg_back=pobj_reg;                                     \
    pobj_reg=0;

#define RESTORE_REGISTER_RESOURCE                               \
    /* レジスタブロッキングオブジェクトポインタを復元 */       \
    delete pobj_BlockReg;                                       \
    pobj_BlockReg=pobj_BlockReg_back;                           \
                                                                \
    /* レジスタ管理オブジェクトポインタを復元 */               \
    delete pobj_reg;                                            \
    pobj_reg=pobj_reg_back;                                     \
                                                                \
    /* レジスタをスタックフレームから復元 */                 \
    if(pobj_reg) pobj_reg->restore();                           \
    pobj_BlockReg->restore();



//RSrcSection.cpp
char *GetRSrcSectionBuffer(int *pLen);

//Compile.cpp
void Compile( const char *source );
void ChangeOpcode(char *Command);
void GetGlobalDataForDll(void);
DWORD CompileBuffer(char Return_Sequence,WORD Return_Command);

//Register.cpp
BOOL IsGeneralReg(int reg);
BOOL IsXmmReg(int reg);
BOOL IsVolatileReg(int reg);
void IfR14Push( int reg );

//Compile_Calc.cpp
void SetVariableFromRax( const Type &varType, int CalcType,RELATIVE_VAR *pRelativeVar);
void OpcodeCalc(const char *Command);

//NumOpe.cpp
bool TermOpeOnlyVariable( const char *term, Type &resultType, RELATIVE_VAR &relativeVar, bool isWriteAccess );
bool TermOpe(
             const char *term,
             const Type &baseType,
             Type &resultType,
             bool &isLiteral,
             bool &isNeedHeapFreeStructure,
             bool *pIsClassName = NULL,
             bool isProcedureCallOnly = false,
             bool isWriteAccess = false );
bool NumOpe( int *pReg,
           const char *Command,
           const Type &baseType,
           Type &resultType,
           bool *pbIsNeedHeapFreeStructure = NULL );

//NumOpe_Arithmetic.cpp
BOOL CalcTwoTerm_Arithmetic(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer);
BOOL Calc_Mod(int *type,LONG_PTR *index_stack,int *pStackPointer);
BOOL Calc_Divide(int *type,int *pStackPointer,int BaseType);
BOOL Calc_IntDivide(int *type,LONG_PTR *index_stack,int *pStackPointer);
BOOL Calc_MinusMark(int *type,int sp);
BOOL Calc_Power(int *type,int *pStackPointer);
BOOL Calc_Shift(int idCalc,int *type,int *pStackPointer);

//NumOpe_Logical.cpp
BOOL CalcTwoTerm_Logical(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer);
BOOL Calc_Not(int *type,int sp);

//NumOpe_Relation.cpp
BOOL CalcTwoTerm_Relational(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer);

//NumOpe_TypeOperation.cpp
void ExtendTypeTo64( const Type &oldType, int reg );
void ExtendTypeTo32( const Type &oldType, int reg );
void ExtendTypeTo16( const Type &oldType, int reg );
void ChangeTypeToXmm_Double(int type,int xmm_reg,int general_reg);
void ChangeTypeToXmm_Single(int type,int xmm_reg,int general_reg);
void ChangeTypeToWhole( const Type &oldType, const Type &newType, int reg, int xmm_reg );
void SetOneTermToReg_RealCalc(int TermType,int *pXmmReg);
void SetOneTermToReg_Whole64Calc(int TermType,int *pReg);
void SetOneTermToReg_Whole32Calc(int TermType,int *pReg);
void SetTowTermToReg_RealCalc(int AnswerType,int *type,int sp,int *pXmmReg1,int *pXmmReg2);
void SetTowTermToReg_Whole64Calc(int *type,int sp,int *pReg1,int *pReg2);
void SetTowTermToReg_Whole32Calc(int *type,int sp,int *pReg1,int *pReg2);
BOOL Calc_Cast(int *type,LONG_PTR *index_stack,int *pStackPointer);

//Compile_Set_Var.cpp
BOOL IsUse_r11(RELATIVE_VAR *pRelativeVar);
void SetStructVariableFromRax( const Type &varType, const Type &calcType, RELATIVE_VAR *pRelativeVar,BOOL bUseHeap);
void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar);
void SetBooleanVariable(int type,RELATIVE_VAR *pRelative);
void SetWholeVariable(int varSize,int type,RELATIVE_VAR *pRelative);

//increment.cpp
void IncDec(int idCalc, const char *lpszLeft, const char *lpszRight);

//Compile_Calc_PushVar.cpp
void SetXmmReg_DoubleVariable(RELATIVE_VAR *pRelativeVar,int xmm_reg);
void SetXmmReg_SingleVariable(RELATIVE_VAR *pRelativeVar,int xmm_reg);
void SetReg_WholeVariable( const Type &type, RELATIVE_VAR *pRelativeVar,int reg);

//Compile_Object.cpp
void Operator_New( const CClass &classObj, const char *objectSizeStr, const char *parameter,const Type &baseTypeInfo );
void OpcodeDelete(const char *Parameter, bool isSweeping);

//Compile_Var.cpp
bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const Type &classType, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess);
void SetThisPtrToReg(int reg);
bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts = NULL );
bool SetInitGlobalData(int offset,const Type &type,const Subscripts &subscripts,const char *InitBuf);
#define DIMFLAG_INITDEBUGVAR            0x01
#define DIMFLAG_NONCALL_CONSTRACTOR     0x02
#define DIMFLAG_STATIC                  0x04
#define DIMFLAG_CONST                   0x08
void dim( char *VarName, const Subscripts &subscripts, const Type &type, const char *InitBuf,const char *ConstractParameter,DWORD dwFlags);
void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar);
bool Compile_AddGlobalRootsForGc();

//ParamImpl.cpp
class ParamImpl{
    char *Parms[255];
    std::vector<Type> types;
    int ParmsNum;

    Type leftType;
    Type returnType;

    //一時オブジェクト管理用
    bool useTempObject;
    bool useTempParameters[255];
    bool isNeedFreeStructures[255];
    int StackOffsetOfTempObject[255];

public:
    ParamImpl(const char *buffer);
    ParamImpl(const Parameters &params);
    ~ParamImpl();
    void SetLeftType( const Type &type )
    {
        this->leftType = type;
    }
    void SetReturnType( const Type &returnType );

private:
    bool EvaluateOverloadScore( int level, const Parameters &targetParms, const Type &targetResultType, const Type &leftType, const UserProc &userProc, bool &isErrored );

public:
    const UserProc *_OverloadSolution( const char *name, std::vector<const UserProc *> &subs, const Type &leftType, bool isEnabledReturnType );
    const UserProc *OverloadSolution( const char *name, std::vector<const UserProc *> &subs, const Type &leftType, bool isEnabledReturnType = false );

    void ApplyDefaultParameters( const Parameters &params );
    bool ErrorCheck( const std::string &procName, const Parameters &params, int SecondParmNum = -1 );
    void MacroParameterSupport( const Parameters &params );
    void SetStructParameter( int reg, const Type &baseType, const char *expression );
    void SetParameter( const std::string &procName, const Parameters &params, int SecondParmNum = -1, const UserProc *pUserProc = NULL );

    //一時オブジェクトパラメータの生成と破棄
    int NewTempParameters( const std::string &procName, const Parameters &params, int SecondParmNum = -1 );
    void DeleteTempParameters();

    void BackupParameter(int pi_num);
    void RestoreParameter(int pi_num);

private:
    ParamImpl(ParamImpl const&);
    ParamImpl& operator =(ParamImpl const&);
};

//CLockParameter.cpp
#define MAX_LOCKPARMS 255
class CDBLockParms{
public:
    int array_LevelCount[MAX_LOCKPARMS];
    CDBLockParms();
    ~CDBLockParms();

    void lock(int level);
    void unlock(int level);

private:
    CDBLockParms(CDBLockParms const&);
    CDBLockParms& operator =(CDBLockParms const&);
};

//Compile_CallProc.cpp
#define PROCFLAG_NEW                1
#define PROCFLAG_PERMIT_CONSTRUCTOR 2
#define PROCFLAG_PERMIT_DESTRUCTOR  4
bool Opcode_CallProcPtr(const char *variable, const char *lpszParms,ProcPointer *pProcPointer);
bool Opcode_CallProc(const char *Parameter,const UserProc *pUserProc,DWORD dwFlags,const char *ObjectName);
bool Opcode_CallDllProc( const char *lpszParms,DllProc *pDllProc);
void Opcode_CallDelegate( const Delegate &dg, const char *methodPtrValueStr, const char *objPtrValueStr, const char *params );

//Compile_ProcOp.cpp
void _compile_proc(const UserProc *pUserProc);

//Compile_Func.cpp
int GetFunctionFromName(char *FuncName);
bool Opcode_CallFunc( const char *Parameter, const int FuncNum, const Type &baseType, Type &resultType, bool isCallOn = true );

//OperatorProc.cpp
void FreeTempObject(int reg,const CClass *pobj_c);
int CallOperatorProc(BYTE idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,bool isNeedHeapFreeStructureStack[],int &sp);
void CallCastOperatorProc(int reg,Type &calcType,BOOL bCalcUseHeap,const Type &toType);
void CallIndexerGetterProc(int reg, const Type &classType, const char *ObjectName,char *Parameter,Type &resultType, DWORD dwProcFlags = 0 );

//Compile_Statement.cpp
void OpcodeOthers(const char *Command);
void OpcodeIf(char *Parameter);
void OpcodeGoto(char *Parameter);
void OpcodeWhile(char *Parameter);
void OpcodeFor(char *Parameter);
void OpcodeForeach(const char *Parameter);
void OpcodeDo(char *Parameter);
void OpcodeContinue(void);
void OpcodeExitSub(void);
void OpcodeSelect( const char *Parameter );
void OpcodeCase(char *Parameter);
void OpcodeGosub(char *Parameter);
void OpcodeReturn(char *Parameter);
void OpcodeSetPtrData(char *Parameter,int type);


//InsertOpcode.cpp
void InsertDimStatement_ToProcHead(char *lpszCommand);


BOOL IsSafeReg(int reg);