Changeset 436 in dev for trunk/abdev/BasicCompiler64


Ignore:
Timestamp:
Mar 15, 2008, 3:33:36 PM (17 years ago)
Author:
dai_9181
Message:

関数の戻り値の構造体など、一時メモリに保持された構造体のメンバに直接アクセスした場合、その一時メモリの解放が正常に行われないバグを修正（64bit版も修正した）。

Location:
trunk/abdev/BasicCompiler64
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler64/CParameter.cpp

    r331 r436  
    6565                int reg = REG_RAX;
    6666                Type calcType;
    67                 NumOpe( &reg, Parms[i2], dummyType, calcType );
     67                bool isNeedHeapFreeStructure;
     68                NumOpe( &reg, Parms[i2], dummyType, calcType, &isNeedHeapFreeStructure );
    6869
    6970                if( !calcType.IsStruct() ){
    … …  
    8687                    i2);
    8788
    88                 if( result ){
     89                if( result )
     90                {
    8991                    useTempParameters[i2] = true;
     92                    isNeedFreeStructures[i2] = isNeedHeapFreeStructure;
    9093                    useTempObject = true;
    9194
    … …  
    109112                // 構造体の一時メモリ
    110113
    111                 //メモリを解放する
    112 
    113                 pobj_sf->pop( REG_RCX );
    114 
    115                 //call free
    116                 extern const UserProc *pSub_free;
    117                 compiler.codeGenerator.op_call(pSub_free);
    118             }
    119             else{
     114                if( isNeedFreeStructures[i2] )
     115                {
     116                    //メモリを解放する
     117
     118                    pobj_sf->pop( REG_RCX );
     119
     120                    //call free
     121                    extern const UserProc *pSub_free;
     122                    compiler.codeGenerator.op_call(pSub_free);
     123                }
     124                else
     125                {
     126                    pobj_sf->pop();
     127                }
     128            }
     129            else
     130            {
    120131                pobj_sf->pop();
    121132                pobj_sf->pop();
    … …  
    148159
    149160        Type calcType;
    150         BOOL bUseHeap;
     161        bool isNeedHeapFreeStructure;
    151162        int temp_reg=REG_RAX;
    152163        NumOpe( &temp_reg,
    … …  
    154165            baseType,
    155166            calcType,
    156             &bUseHeap );
     167            &isNeedHeapFreeStructure );
    157168
    158169
    … …  
    169180            baseType,
    170181            calcType,
    171             &RelativeVar,bUseHeap);
     182            &RelativeVar,isNeedHeapFreeStructure);
    172183
    173184
    … …  
    282293            temp_reg=reg;
    283294
    284             BOOL bCalcUseHeap;
    285295            Type calcType;
    286             if( !NumOpe( &temp_reg, Parms[i2], dummyType, calcType, &bCalcUseHeap ) ){
     296            bool isNeedHeapFreeStructure;
     297            if( !NumOpe( &temp_reg, Parms[i2], dummyType, calcType, &isNeedHeapFreeStructure ) ){
    287298                break;
    288299            }
    … …  
    294305                    !dummyType.GetClass().IsEqualsOrSubClass( &calcType.GetClass() ) ){
    295306                        //キャスト演算子のオーバーロードに対応する
    296                         CallCastOperatorProc( reg, calcType, bCalcUseHeap,dummyType );
     307                        CallCastOperatorProc( reg, calcType, isNeedHeapFreeStructure,dummyType );
    297308                }
    298309            }

  • trunk/abdev/BasicCompiler64/Compile_Calc.cpp

    r417 r436  
    190190    //NumOpe...（rax、またはxmm0に答えが格納される）
    191191    int reg=REG_RAX;
    192     BOOL bCalcUseHeap;
    193192    Type calcType;
    194     if( !NumOpe(&reg,Command+i+1,varType,calcType,&bCalcUseHeap) ){
     193    bool isNeedHeapFreeStructure;
     194    if( !NumOpe(&reg,Command+i+1,varType,calcType,&isNeedHeapFreeStructure) ){
    195195        return;
    196196    }
    … …  
    222222    if( varType.IsStruct() ){
    223223        //構造体インスタンスへの代入
    224         SetStructVariableFromRax(varType,calcType,&VarRelativeVar,bCalcUseHeap);
     224        SetStructVariableFromRax(varType,calcType,&VarRelativeVar,isNeedHeapFreeStructure);
    225225        return;
    226226    }
    … …  
    235235        if( !isUpCast ){
    236236            //キャスト演算子のオーバーロードに対応する
    237             CallCastOperatorProc(REG_RAX,calcType,bCalcUseHeap,varType);
     237            CallCastOperatorProc(REG_RAX,calcType,isNeedHeapFreeStructure,varType);
    238238        }
    239239    }
    … …  
    269269    /////////////////////////////////////////////////
    270270    SetVariableFromRax(varType,calcType.GetBasicType(),&VarRelativeVar);
     271
     272
     273    // コード生成過程で発生した構造体の一時メモリを破棄する
     274    compiler.codeGenerator.op_FreeTempStructure();
    271275}

  • trunk/abdev/BasicCompiler64/Compile_CallProc.cpp

    r420 r436  
    322322            if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
    323323            else{
    324                 bool isLiteral;
     324                bool isLiteral, isNeedHeapFreeStructure = false;
    325325                Type baseType( DEF_OBJECT, *pUserProc->GetParentClassPtr() ) , resultType;
    326                 if( !TermOpe( ObjectName, baseType, resultType, isLiteral, NULL, NULL, false, !pMethod->IsConst() ) )
     326                if( !TermOpe( ObjectName, baseType, resultType, isLiteral, isNeedHeapFreeStructure, NULL, false, !pMethod->IsConst() ) )
    327327                {
    328328                    return false;
     329                }
     330                if( !resultType.IsObject() )
     331                {
     332                    SetError();
    329333                }
    330334

  • trunk/abdev/BasicCompiler64/Compile_Statement.cpp

    r425 r436  
    9595
    9696    Type resultType;
    97     bool isLiteral;
    98     BOOL bUseHeap;
    99     bool result = TermOpe( leftTerm, Type(), resultType, isLiteral, &bUseHeap, NULL, true );
     97    bool isLiteral, isNeedHeapFreeStructure = false;
     98    bool result = TermOpe( leftTerm, Type(), resultType, isLiteral, isNeedHeapFreeStructure, NULL, true );
    10099
    101100    delete pobj_reg;

  • trunk/abdev/BasicCompiler64/Compile_Var.cpp

    r425 r436  
    142142        int reg=REG_NON;
    143143        Type type;
    144         BOOL bUseHeap;
    145         NumOpe( &reg, pParm[i], Type( DEF_LONG ), type, &bUseHeap );
    146         if( type.IsObject() ){
     144        bool isNeedHeapFreeStructure;
     145        NumOpe( &reg, pParm[i], Type( DEF_LONG ), type, &isNeedHeapFreeStructure );
     146        if( type.IsObject() )
     147        {
    147148            //キャスト演算子のオーバーロードに対応する
    148149            CallCastOperatorProc(reg,
    149150                type,
    150                 bUseHeap, Type(DEF_LONG) );
     151                isNeedHeapFreeStructure, Type(DEF_LONG) );
    151152            type.SetBasicType( DEF_LONG );
    152153        }
    153154
    154         if( !type.IsWhole() ){
     155        if( !type.IsWhole() )
     156        {
    155157            SetError(46,NULL,cp);
    156158        }

  • trunk/abdev/BasicCompiler64/MakePeHdr.cpp

    r423 r436  
    3333    *pSub_System_GC_malloc_ForObjectPtr,
    3434    *pSub_System_GC_free_for_SweepingDelete,
     35    *pSub_System_AddNeedFreeTempStructure,
     36    *pSub_System_FreeTempStructure,
    3537    *pSubStaticMethod_System_TypeBase_InitializeUserTypes,
    3638    *pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType;
    … …  
    266268    if( pSub_System_GC_free_for_SweepingDelete = GetSubHash( "_System_GC_free_for_SweepingDelete",1 ) )
    267269        pSub_System_GC_free_for_SweepingDelete->Using();
     270
     271    if( pSub_System_AddNeedFreeTempStructure = GetSubHash( "_System_AddNeedFreeTempStructure",1 ) )
     272    {
     273        pSub_System_AddNeedFreeTempStructure->Using();
     274    }
     275    if( pSub_System_FreeTempStructure = GetSubHash( "_System_FreeTempStructure",1 ) )
     276    {
     277        pSub_System_FreeTempStructure->Using();
     278    }
    268279
    269280    if( pSubStaticMethod_System_TypeBase_InitializeUserTypes = GetSubHash( "ActiveBasic.Core._System_TypeBase.InitializeUserTypes",1 ) ){

  • trunk/abdev/BasicCompiler64/NumOpe.cpp

    r430 r436  
    130130    return true;
    131131}
    132 bool TermMemberOpe( const Type &leftType, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member, bool &isVariable, RELATIVE_VAR &relativeVar )
     132bool TermMemberOpe( const Type &leftType, bool &isNeedHeapFreeStructure, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member, bool &isVariable, RELATIVE_VAR &relativeVar )
    133133{
    134134    const CClass &objClass = leftType.GetClass();
    … …  
    218218        // メンバが見つかったとき
    219219
     220        if( isNeedHeapFreeStructure )
     221        {
     222            if( !leftType.IsStruct() )
     223            {
     224                SetError();
     225            }
     226
     227            pobj_reg->LockReg();
     228
     229            // 親となる構造体が一時メモリに存在していた場合、後ほど解放する必要がある
     230            compiler.codeGenerator.op_AddNeedFreeTempStructure( useReg );
     231            isNeedHeapFreeStructure = false;
     232
     233            pobj_reg->UnlockReg();
     234        }
     235
    220236        //オブジェクトポインタをr11にコピー
    221237        compiler.codeGenerator.op_mov_RR( REG_R11, useReg );
    … …  
    267283                bool dummyIsVariable;
    268284                RELATIVE_VAR dummyRelativeVar;
    269                 TermMemberOpe( leftType, baseType, resultType, termFull, termLeft, methodName, dummyIsVariable, dummyRelativeVar );
     285                TermMemberOpe( leftType, isNeedHeapFreeStructure, baseType, resultType, termFull, termLeft, methodName, dummyIsVariable, dummyRelativeVar );
    270286
    271287                // 戻り値のオブジェクトインスタンスのインデクサを呼び出す
    … …  
    274290                sprintf( temp2, "%s.%s", termLeft, methodName );
    275291                Type classType = resultType;
    276                 return TermMemberOpe( classType, baseType, resultType, termFull, temp2, temporary, isVariable, relativeVar );
     292                return TermMemberOpe( classType, isNeedHeapFreeStructure, baseType, resultType, termFull, temp2, temporary, isVariable, relativeVar );
    277293            }
    278294
    … …  
    344360    return false;
    345361}
    346 bool _TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool *pIsClassName, bool isProcedureCallOnly, bool &isVariable, RELATIVE_VAR &relativeVar, bool isWriteAccess )
     362bool _TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, bool &isNeedHeapFreeStructure, bool *pIsClassName, bool isProcedureCallOnly, bool &isVariable, RELATIVE_VAR &relativeVar, bool isWriteAccess )
    347363{
    348364    char parameter[VN_SIZE];
    … …  
    385401        }
    386402
    387         if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, &isClassName ) ){
     403        if( !TermOpe( termLeft, baseType, leftType, isLiteral, isNeedHeapFreeStructure, &isClassName ) ){
    388404            goto globalArea;
    389405        }
    … …  
    403419        }
    404420
    405         return TermMemberOpe( leftType, baseType, resultType, termFull, termLeft, member, isVariable, relativeVar );
     421        return TermMemberOpe( leftType, isNeedHeapFreeStructure, baseType, resultType, termFull, termLeft, member, isVariable, relativeVar );
    406422    }
    407423globalArea:
    … …  
    500516            }////////////////////////////////////////////
    501517
    502             if(resultType.IsStruct()){
     518            if(resultType.IsStruct())
     519            {
    503520                //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    504521                //※後にfreeする必要あり
    505522                // TODO: 解放はGCに任せる
    506                 *pbUseHeap = 1;
     523                isNeedHeapFreeStructure = true;
    507524            }
    508525
    … …  
    628645        }////////////////////////////////////////////
    629646
    630         if(resultType.IsStruct()){
     647        if(resultType.IsStruct())
     648        {
    631649            //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    632650            //※後にfreeする必要あり
    633651            // TODO: 解放はGCに任せる
    634             *pbUseHeap = 1;
     652            isNeedHeapFreeStructure = true;
    635653        }
    636654
    … …  
    648666}
    649667
    650 bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool *pIsClassName, bool isProcedureCallOnly, bool isWriteAccess )
     668bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, bool &isNeedHeapFreeStructure, bool *pIsClassName, bool isProcedureCallOnly, bool isWriteAccess )
    651669{
    652670    bool isInitRegSwitch = false;
    … …  
    665683    RELATIVE_VAR relativeVar;
    666684    bool isVariable = false;
    667     bool result = _TermOpe( term, baseType, resultType, isLiteral, pbUseHeap, pIsClassName, isProcedureCallOnly, isVariable, relativeVar, isWriteAccess );
     685    bool result = _TermOpe( term, baseType, resultType, isLiteral, isNeedHeapFreeStructure, pIsClassName, isProcedureCallOnly, isVariable, relativeVar, isWriteAccess );
    668686
    669687    if( isVariable )
    … …  
    705723    pobj_reg = new CRegister( REG_NON );
    706724
    707     bool isLiteral, isVariable = false;
    708     bool result = _TermOpe( term, Type(), resultType, isLiteral, NULL, NULL, false, isVariable, relativeVar, isWriteAccess );
     725    bool isLiteral, isVariable = false, isNeedHeapFreeStructure = false;
     726    bool result = _TermOpe( term, Type(), resultType, isLiteral, isNeedHeapFreeStructure, NULL, false, isVariable, relativeVar, isWriteAccess );
    709727
    710728    if( !isVariable )
    … …  
    731749            const Type &baseType,
    732750            Type &resultType,
    733             BOOL *pbUseHeap )
     751            bool *pbIsNeedHeapFreeStructure )
    734752{
    735753    int i,i2,i3;
    … …  
    892910    LONG_PTR index_stack[255];
    893911    bool isNothing_stack[255];
    894     BOOL bUseHeap[255];
     912    bool isNeedHeapFreeStructureStack[255];
    895913    _int64 i64data;
    896914    int UseReg,XmmReg;
    … …  
    916934                else{
    917935                    //オーバーロードされたオペレータを呼び出す
    918                     i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,bUseHeap,sp);
     936                    i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,isNeedHeapFreeStructureStack,sp);
    919937                    if(i2==0){
    920938                        if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
    … …  
    938956                index_stack[sp]=-1;
    939957                isNothing_stack[sp] = false;
    940                 bUseHeap[sp]=0;
     958                isNeedHeapFreeStructureStack[sp] = false;
    941959
    942960                UseReg=pobj_reg->GetNextReg();
    … …  
    10411059
    10421060                    bool isLiteral;
    1043                     if( TermOpe( term, baseType, resultType, isLiteral, &bUseHeap[sp] ) ){
     1061                    if( TermOpe( term, baseType, resultType, isLiteral, isNeedHeapFreeStructureStack[sp] ) ){
    10441062                        if(resultType.IsNull()){
    10451063                            //戻り値が存在しないとき
    … …  
    13461364    }
    13471365
    1348     if(pbUseHeap) *pbUseHeap=bUseHeap[0];
     1366    if( pbIsNeedHeapFreeStructure )
     1367    {
     1368        *pbIsNeedHeapFreeStructure = isNeedHeapFreeStructureStack[0];
     1369    }
    13491370
    13501371    if(IsRealNumberType(type_stack[0]))
    … …  
    13861407            const Type &baseType,
    13871408            Type &resultType,
    1388             BOOL *pbUseHeap )
     1409            bool *pbIsNeedHeapFreeStructure )
    13891410{
    13901411    bool isInitRegSwitch = false;
    … …  
    14031424
    14041425
    1405     bool result = _numope( pReg, expression, baseType, resultType, pbUseHeap );
     1426    bool result = _numope( pReg, expression, baseType, resultType, pbIsNeedHeapFreeStructure );
    14061427
    14071428

  • trunk/abdev/BasicCompiler64/Opcode.h

    r425 r436  
    191191             Type &resultType,
    192192             bool &isLiteral,
    193              BOOL *pbUseHeap,
     193             bool &isNeedHeapFreeStructure,
    194194             bool *pIsClassName = NULL,
    195195             bool isProcedureCallOnly = false,
    … …  
    199199           const Type &baseType,
    200200           Type &resultType,
    201            BOOL *pbUseHeap = NULL );
     201           bool *pbIsNeedHeapFreeStructure = NULL );
    202202
    203203//NumOpe_Arithmetic.cpp
    … …  
    276276    bool useTempObject;
    277277    bool useTempParameters[255];
     278    bool isNeedFreeStructures[255];
    278279    int StackOffsetOfTempObject[255];
    279280
    … …  
    337338//OperatorProc.cpp
    338339void FreeTempObject(int reg,const CClass *pobj_c);
    339 int CallOperatorProc(BYTE idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp);
     340int CallOperatorProc(BYTE idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,bool isNeedHeapFreeStructureStack[],int &sp);
    340341void CallCastOperatorProc(int reg,Type &calcType,BOOL bCalcUseHeap,const Type &toType);
    341342void CallIndexerGetterProc(int reg, const Type &classType, const char *ObjectName,char *Parameter,Type &resultType, DWORD dwProcFlags = 0 );

  • trunk/abdev/BasicCompiler64/OperatorProc.cpp

    r425 r436  
    3131}
    3232
    33 int CallOperatorProc(BYTE idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp)
     33int CallOperatorProc(BYTE idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,bool isNeedHeapFreeStructureStack[],int &sp)
    3434{
    3535    Type leftType( type_stack[sp-2], index_stack[sp-2] );
    … …  
    101101        if( pUserProc->RealParams()[1]->IsStruct() &&pUserProc->RealParams()[1]->IsRef() == false ){
    102102            //一時オブジェクトはメソッド内で破棄される
    103             bUseHeap[sp-1]=0;
     103            isNeedHeapFreeStructureStack[sp-1] = false;
    104104        }
    105105    }
    … …  
    153153
    154154    //ヒープ解放用に退避
    155     if(bUseHeap[sp-1]){
     155    if(isNeedHeapFreeStructureStack[sp-1]){
    156156        //mov qword ptr[rsp+offset],reg2     ※スタックフレームを利用
    157157        pobj_sf->push(reg2);
    158158    }
    159     if(bUseHeap[sp-2]){
     159    if(isNeedHeapFreeStructureStack[sp-2]){
    160160        //mov qword ptr[rsp+offset],reg1     ※スタックフレームを利用
    161161        pobj_sf->push(reg1);
    … …  
    213213
    214214
    215     if(bUseHeap[sp-2]||bUseHeap[sp-1]){
    216 
     215    if( isNeedHeapFreeStructureStack[sp-2] || isNeedHeapFreeStructureStack[sp-1] )
     216    {
    217217        //////////////////////////////////////////////////////
    218218        /////    レジスタ資源のバックアップ
    … …  
    220220        //////////////////////////////////////////////////////
    221221
    222             if(bUseHeap[sp-2]){
     222            if( isNeedHeapFreeStructureStack[sp-2] )
     223            {
    223224                //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
    224225                pobj_sf->pop(REG_R14);
    … …  
    226227                FreeTempObject(REG_R14,(CClass *)index_stack[sp-2]);
    227228            }
    228             if(bUseHeap[sp-1]){
     229            if( isNeedHeapFreeStructureStack[sp-1] )
     230            {
    229231                //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
    230232                pobj_sf->pop(REG_R14);
    … …  
    258260    index_stack[sp-1]=pUserProc->ReturnType().GetIndex();
    259261
    260     if( pUserProc->ReturnType().IsStruct() ){
     262    if( pUserProc->ReturnType().IsStruct() )
     263    {
    261264        //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    262265        //※後にfreeする必要あり
    263         bUseHeap[sp-1]=1;
    264     }
    265     else bUseHeap[sp-1]=0;
     266        isNeedHeapFreeStructureStack[sp-1] = true;
     267    }
     268    else
     269    {
     270        isNeedHeapFreeStructureStack[sp-1] = false;
     271    }
    266272
    267273    return 1;
    … …  
    271277    int type_stack[10];
    272278    LONG_PTR index_stack[10];
    273     BOOL array_bUseHeap[10];
     279    bool array_bUseHeap[10];
    274280    int sp=2;
    275281    int iRet;
Note: See TracChangeset for help on using the changeset viewer.