示例#1
0
void    MemChanged( score *p, bool statics_too )
/**********************************************/
{
    int         i;
    score_list  **owner;
    score_list  *curr;
    bool        changed;

    for( i = ScoreCount; i > 0; --i ) {
        if( p->list != NULL ) {
            for( owner = p->list; (curr = *owner) != NULL; ) {
                changed = false;
                switch( curr->info.class ) {
                case SC_N_CONSTANT:
                    changed = true;
                    break;
                case SC_N_TEMP:
                    if( (curr->info.symbol.v->usage & USE_ADDRESS) == 0 ) {
                        changed = true;
                    }
                    break;
                case SC_N_MEMORY:
                    if( !statics_too ) {
                        changed = true;
                    }
                    break;
                case SC_N_INDEXED:
                    if( curr->info.base != NULL ) {
                        if( curr->info.base->n.class == N_MEMORY ) {
                            if( !statics_too ) {
                                changed = true;
                            }
                        }
                    } else {
                        if( !statics_too ) {
                            changed = true;
                        }
                    }
                    break;
                }
                if( changed ) {
                    owner = &curr->next;
                } else {
                    *owner = curr->next;
                    FreeScListEntry( curr );
                }
            }
        }
        ++p;
    }
示例#2
0
void    ScoreFreeList( score *p )
/*******************************/
{
    score_list  *curr;
    score_list  *next;

    if( p->list != NULL ) {
        for( curr = *p->list; curr != NULL; curr = next ) {
            next = curr->next;
            FreeScListEntry( curr );
        }
        *p->list = NULL;
    }
}
示例#3
0
extern  void    RegKill( score *scoreboard, hw_reg_set regs ) {
    /*************************************************************/

    score_reg   *entry;
    score_list  *curr_list;
    score_list  **owner;
    int         i;
    list_head   **free_heads;

    if( !HW_CEqual( regs, HW_EMPTY ) ) {
        entry = *ScoreList;
        free_heads = (list_head **)&scoreboard[ ScoreCount ];
        for( i = ScoreCount; i > 0; --i ) {
            if( HW_Ovlap( entry->reg, regs ) ) {
                if( scoreboard->list != NULL ) {
                    if( scoreboard->next_reg == scoreboard ) {
                        ScoreFreeList( scoreboard );
                    } else {
                        scoreboard->list = *free_heads;
                        *free_heads = (list_head *)**free_heads;
                        *scoreboard->list = NULL;
                    }
                }
                scoreboard->prev_reg->next_reg = scoreboard->next_reg;
                scoreboard->next_reg->prev_reg = scoreboard->prev_reg;
                scoreboard->next_reg = scoreboard;
                scoreboard->prev_reg = scoreboard;
                scoreboard->generation = 0;
            } else {
                owner = scoreboard->list;
                for( ; ; ) {
                    curr_list = *owner;
                    if( curr_list == NULL ) break;
                    if( curr_list->info.index_reg != NO_INDEX
                            && HW_Ovlap( ScoreList[ curr_list->info.index_reg ]->reg, regs ) ) {
                        *owner = curr_list->next;
                        FreeScListEntry( curr_list );
                    } else {
                        owner = &curr_list->next;
                    }
                }
            }
            ++entry;
            ++scoreboard;
        }
    }
}