namelist.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 784 行 · 第 1/2 页

    }
    return( &( new_m->m ) );
}


extern  name    *AllocMemory( pointer symbol, type_length offset,
                              cg_class class, type_class_def type_class ) {
/*************************************************************************/

    return( (name *) SAllocMemory( symbol, offset, class, type_class, 0 ) );
}


extern  name    *STempOffset( name *temp, type_length offset,
                              type_class_def class, type_length size ) {
/**********************************************************************/


    name        *new_t;
    name        *xx;

    class = OneClass[  class  ];
    offset += temp->v.offset;
    new_t = temp->t.alias;
    xx = NULL;
    for( ;; ) {
        if( new_t->t.v.id == temp->t.v.id && new_t->v.offset == offset ) {
            if( class == XX && size == 0 ) return( new_t ); /* 89-07-07 */
            if( new_t->n.name_class == class && class != XX ) {
                return( new_t ); /* exact match */
            }
            if( new_t->n.name_class == XX && new_t->n.size == size ) {
                xx = new_t; /* an XX with the right size */
            }
        }
        if( new_t == temp ) break;
        new_t = new_t->t.alias;
    }
    if( xx != NULL ) {
        ZapXX( xx, class, size );
        return( xx );
    }
    new_t = AllocName( N_TEMP, class, size );
    new_t->t.v.id = temp->t.v.id;
    new_t->v.symbol = temp->v.symbol;
    new_t->v.offset = offset;
    new_t->v.usage = temp->v.usage;
    new_t->v.block_usage = EMPTY;
    new_t->v.conflict = temp->v.conflict;
    new_t->t.u.block_id = temp->t.u.block_id;
    new_t->t.alias = temp->t.alias;
    temp->t.alias = new_t;
    new_t->t.temp_flags = ALIAS;
    new_t->t.temp_flags |= temp->t.temp_flags & PERM_TEMP_FLAGS;
    new_t->t.possible = RL_NUMBER_OF_SETS;
    if( temp->t.location == NO_LOCATION ) {
        new_t->t.location = NO_LOCATION;
    } else {
        new_t->t.location = temp->t.location + offset;
    }
    return( new_t );
}


extern  name    *SAllocTemp( type_class_def class, type_length size ) {
/*********************************************************************/

    name        *new_t;

    class = OneClass[  class  ];
    new_t = AllocName( N_TEMP, class, size );
    new_t->t.v.id = ++ TempId;
    new_t->v.symbol = NULL;
    new_t->v.offset = 0;
    new_t->v.usage  = EMPTY;
    new_t->v.block_usage = EMPTY;
    new_t->v.conflict = NULL;
    new_t->t.u.block_id = NO_BLOCK_ID;
    new_t->t.location = NO_LOCATION;
    new_t->t.alias = new_t;
    new_t->t.temp_flags = 0;
    new_t->t.possible = RL_NUMBER_OF_SETS;
    return( new_t );
}


extern  name    *AllocTemp( type_class_def class ) {
/**************************************************/

    return( SAllocTemp( class, 0 ) );
}


extern  name    *TempOffset( name *temp, type_length offset,
                             type_class_def class ) {
/***************************************************************************/

    return( STempOffset( temp, offset, class, 0 ) );
}


extern  name    *SAllocUserTemp( pointer symbol,
                                 type_class_def class, type_length size ) {
/*************************************************************************/

    name        *new_t;

    class = OneClass[  class  ];
    new_t = LkAddBack( symbol, NULL );
    if( new_t == NULL ) {
        new_t = AllocTemp( class );
        new_t->v.symbol = symbol;
        if( size != 0 ) {
            new_t->n.size = size;
        }
        LkAddBack( symbol, new_t );
        return( new_t );
    } else {
        if( new_t->n.name_class == class && class != XX ) return( new_t );
        return( STempOffset( new_t, 0, class, size ) );
    }
}


extern  name    *AllocUserTemp( pointer symbol, type_class_def class ) {
/**********************************************************************/

    return( SAllocUserTemp( symbol, class, 0 ) );
}


extern  name    *DeAlias( name *temp ) {
/**************************************/

    while( temp->t.temp_flags & ALIAS ) {
        temp = temp->t.alias;
    }
    return( temp );
}



extern  name    *AllocRegName( hw_reg_set regs ) {
/************************************************/

    name        *new_r;

    if( HW_CEqual( regs, HW_EMPTY ) ) { /* here for speed. we grab this a lot! */
        if( NullReg == NULL ) {
            new_r = AllocName( N_REGISTER, RegClass( regs ), 0 );
            HW_CAsgn( new_r->r.reg, HW_EMPTY );
            new_r->r.reg_index = -1;
            NullReg = new_r;
        }
        return( NullReg );
    }
    new_r = Names[  N_REGISTER  ];
    while( new_r != NULL ) {
        if( HW_Equal( new_r->r.reg, regs ) ) return( new_r );
        new_r = new_r->n.next_name;
    }
    new_r = AllocName( N_REGISTER, RegClass( regs ), 0 );
    new_r->r.reg = regs;
    new_r->r.reg_index = -1;
#if _TARGET & _TARG_RISC
    new_r->r.arch_index = RegTrans( regs );
#endif
    return( new_r );
}


extern  name    *ScaleIndex( name *index, name *base, type_length offset,
                             type_class_def class,
                             type_length size, int scale, i_flags flags ) {
/*************************************************************************/

    name        *new_x;

    class = OneClass[  class  ];
    new_x = Names[  N_INDEXED  ];
    while( new_x != NULL ) {
        if( new_x->i.base == base
         && new_x->i.index == index
         && new_x->i.constant == offset
         && new_x->i.scale == scale
         && new_x->i.index_flags == flags
         && ( ( new_x->n.name_class == class
              && new_x->n.name_class != XX )
            || ( new_x->n.name_class == XX
              && new_x->n.size == size ) ) ) {
            if( class != XX ) {
                new_x->n.name_class = class;
                new_x->n.size = TypeClassSize[  class  ];
            }
            if( index->n.class == N_TEMP ) {
                index->t.temp_flags |= INDEXED;
            }
            return( new_x );
        }
        new_x = new_x->n.next_name;
    }
    new_x = AllocName( N_INDEXED, class, size );
    new_x->i.index = index;
    new_x->i.base = base;
    new_x->i.constant = offset;
    new_x->i.index_flags = flags;
    new_x->i.scale = scale;
    if( index->n.class == N_TEMP ) {
        index->t.temp_flags |= INDEXED;
    }
    return( new_x );
}


extern  name    *SAllocIndex( name *index, name *base, type_length offset,
                              type_class_def class, type_length size ) {
/**********************************************************************/

    return( ScaleIndex( index, base, offset, class, size, 0, EMPTY ) );
}


extern  name    *AllocIndex( name *index, name *base,
                             type_length offset, type_class_def class ) {
/***************************************************************/

    return( SAllocIndex( index, base, offset, class, 0 ) );
}


extern  void    InitNames() {
/***************************/

    int                 class;

    class = N_CONSTANT;
    for(;;) {
        InitFrl( &FrlHead[  class  ] );
        if( ++ class > N_INDEXED ) break;
    }
    InitFrl( &ConstDefnFrl );
    for( class = U1; class <= XX; ++class ) {
        TypeClassSize[ class ] = ClassType( class )->length;
    }
    ReInitNames();
}


extern  void    ReInitNames() {
/*****************************/

    int class;

    TempId = 0;
    NullReg = NULL;
    ConstOne = NULL;
    ConstZero = NULL;
    LastTemp = NULL;
    DummyIndex = NULL;
    class = N_CONSTANT;
    for(;;) {
        Names[ class ] = NULL;
        if( ++ class > N_INDEXED ) break;
    }
}


extern  void    FreeNames() {
/***************************/

    int         class;
    name        *temp;
    name        *junk;

    class = N_CONSTANT;
    for(;;) {
        temp = Names[ class ];
        Names[ class ] = NULL;
        while( temp != NULL ) {
            junk = temp;
            temp = temp->n.next_name;
            FreeAName( junk );
        }
        if( ++ class > N_INDEXED ) break;
    }
}


extern  void    FreeAName( name *op ) {
/***************************************/

    constant_defn       *defn;
    constant_defn       *junk;

    if( op->n.class == N_CONSTANT ) {
        if( op == ConstZero ) {
            ConstZero = NULL;
        }
        if( op == ConstOne ) {
            ConstOne = NULL;
        }
        if( op->c.const_type == CONS_ABSOLUTE ) {
            CFFree( op->c.value );
            defn = op->c.static_defn;
            while( defn != NULL ) {
                junk = defn;
                defn = defn->next_defn;
                FrlFreeSize( &ConstDefnFrl,
                             (pointer *)junk, sizeof( constant_defn ) );
            }
        }
    } else if( op->n.class == N_MEMORY ) {
        if( op->m.memory_type == CG_TBL ) {
            FreeTable( op->v.symbol );
        }
    } else if( op->n.class == N_REGISTER ) {
        if( op == NullReg ) {
            NullReg = NULL;
        }
    } else if( op->n.class == N_TEMP ) {
        if( op == LastTemp ) LastTemp = op->n.next_name;
        if( op == DummyIndex ) DummyIndex = NULL;
    }
    FrlFreeSize( &FrlHead[  op->n.class  ],
                 (pointer *)op, Size[  op->n.class  ] );
}


extern  bool    NameFrlFree() {
/*****************************/

    bool        freed;
    int         class;

    class = N_CONSTANT;
    freed = FALSE;
    for(;;) {
        freed |= FrlFreeAll( &FrlHead[  class  ], Size[  class  ] );
        if( ++class > N_INDEXED ) break;
    }
    freed |= FrlFreeAll( &ConstDefnFrl, sizeof( constant_defn ) );
    return( freed );
}

extern  i_flags AlignmentToFlags( type_length alignment ) {
/*********************************************************/

    i_flags             flags;

    flags = 0;
    switch( alignment ) {
    case 0:
        break;
    case 1:
        flags |= X_ALIGNED_1;
        break;
    case 2:
        flags |= X_ALIGNED_2;
        break;
    case 4:
        flags |= X_ALIGNED_4;
        break;
    case 8:
        flags |= X_ALIGNED_8;
        break;
    default:
        _Zoiks( ZOIKS_098 );
    }
    return( flags );
}

extern  type_length     FlagsToAlignment( i_flags flags ) {
/*********************************************************/

    type_length         alignment;

    alignment = 0;
    if( flags & X_ALIGNED_1 ) {
        alignment = 1;
    }
    if( flags & X_ALIGNED_2 ) {
        alignment = 2;
    }
    if( flags & X_ALIGNED_4 ) {
        alignment = 4;
    }
    if( flags & X_ALIGNED_8 ) {
        alignment = 8;
    }
    return( alignment );
}