Пример #1
0
extern  void    DumpConflicts() {
/*******************************/

    conflict_node       *conf;

    DumpLiteral( "Conflict graph" );
    DumpNL();
    for( conf = ConfList; conf != NULL; conf = conf->next_conflict ) {
        DumpPtr( conf );
        DumpChar( ' ' );
        DumpAConf( conf );
    }
    DumpNL();
}
Пример #2
0
extern  void    DumpConflicts() {
/*******************************/

    conflict_node       *conf;

    DumpLiteral( "Conflict graph" );
    DumpNL();
    conf = ConfList;
    while( conf != NULL ) {
        DumpPtr( conf );
        DumpLiteral( " " );
        DumpAConf( conf );
        conf = conf->next_conflict;
    }
    DumpNL();
}
Пример #3
0
static  void    DoOffset( unsigned_32 o ) {
/*****************************************/

    DumpChar( '\t' );
    Dump8h( o );
    DumpNL();
}
Пример #4
0
static  void    DumpInv( name *name ) {
/***************************************/

    for( ; name != NULL; name = name->n.next_name ) {
        if( _ChkLoopUsage( name, VU_INVARIANT ) ) {
            DumpOperand( name );
            DumpChar( ' ' );
        }
    }
    DumpNL();
}
Пример #5
0
extern  void    DumpInOut( instruction *ins ) {
/*********************************************/

    DumpLiteral( "     " );
    DumpGBit( &ins->head.live.out_of_block );
    DumpChar( ' ' );
    DumpLBit( &ins->head.live.within_block );
    if( !HW_CEqual( ins->head.live.regs, HW_EMPTY ) && !HW_COvlap( ins->head.live.regs, HW_UNUSED ) ) {
        DumpLiteral( "  " );
        DumpRegName( ins->head.live.regs );
    }
    DumpNL();
}
Пример #6
0
extern  void    DumpCurrLoop() {
/******************************/

    block               *blk;
    block               *header;
    interval_depth      depth;

    DumpLiteral( "The Loop Is:" );
    DumpNL();
    DumpLiteral( "============" );
    DumpNL();
    depth = MAX_INTERVAL_DEPTH;
    header = NULL;
    for( blk = HeadBlock; blk != NULL; blk = blk->next_block ) {
        if( blk->class & BLK_IN_LOOP ) {
            if( blk->depth < depth ) {
                header = blk;
                depth = header->depth;
            }
        }
    }
    for( blk = HeadBlock; blk != NULL; blk = blk->next_block ) {
        DumpBlkId( blk );
        if( blk->class & BLK_IN_LOOP ) {
            if( blk == header ) {
                DumpLiteral( " - Header" );
            } else {
                DumpLiteral( " - In for(;;) {" );
            }
            if( blk->class & BLK_LOOP_EXIT ) {
                DumpLiteral( " Exits" );
            }
        }
        DumpNL();
    }
}
Пример #7
0
static  void    DoDump( reg_tree *tree, int indent ) {
/****************************************************/

    DumpIndent( indent );
    DumpRegs( tree->regs );
    DumpNL();
    DumpIndent( indent );
    DumpLiteral( "offset " );
    DumpInt( tree->offset );
    DumpLiteral( " size " );
    DumpInt( tree->size );
    DumpNL();
    if( tree->temp != NULL ) {
        DumpIndent( indent );
        DumpLiteral( "name " );
        DumpPtr( tree->temp );
        DumpChar( ' ' );
        DumpSym( tree->temp );
        DumpNL();
    }
    if( tree->alt != NULL ) {
        DumpIndent( indent );
        DumpLiteral( "alt  " );
        DumpPtr( tree->alt  );
        DumpChar( ' ' );
        DumpSym( tree->alt );
        DumpNL();
    }
    if( tree->hi != NULL ) {
        DumpIndent( indent );
        DumpLiteral( "high " );
        DumpNL();
        DoDump( tree->hi, indent + 4 );
    }
    if( tree->lo != NULL ) {
        DumpIndent( indent );
        DumpLiteral( "low  " );
        DumpNL();
        DoDump( tree->lo, indent + 4 );
    }
}
Пример #8
0
extern  void    DumpAConf( conflict_node *conf ) {
/************************************************/

    DumpOperand( conf->name );
    DumpLiteral( " id " );
    DumpGBit( &conf->id.out_of_block );
    DumpChar( ' ' );
    DumpLBit( &conf->id.within_block );
    DumpPossible( conf->possible );
    DumpNL();
    DumpLiteral( "    " );
    DumpInsRange( conf );
    DumpLiteral( " Start block " );
    DumpPtr( conf->start_block );
    DumpNL();
    DumpLiteral( "    Conflicts with " );
    DumpGBit( &conf->with.out_of_block );
    DumpChar( ' ' );
    DumpLBit( &conf->with.within_block );
    DumpChar( ' ' );
    DumpRegName( conf->with.regs );
    DumpNL();
    DumpLiteral( "    Constrained " );
    DumpInt( conf->num_constrained );
    DumpLiteral( " vs " );
    DumpInt( conf->available );
    DumpNL();
    if( _Is( conf, CST_SAVINGS_CALCULATED ) ) {
        DumpLiteral( "    Savings " );
        DumpLong( conf->savings );
        DumpNL();
    }
    if( _Is( conf, CST_CONFLICT_ON_HOLD ) ) {
        DumpLiteral( "    On hold" );
        DumpNL();
    }
    if( _Is( conf, CST_CHANGES_OTHERS ) ) {
        DumpLiteral( "    Changes Others" );
        DumpNL();
    }
    if( _Is( conf, CST_NEEDS_SEGMENT ) ) {
        DumpLiteral( "    Needs segment" );
        DumpNL();
    }
    if( _Is( conf, CST_NEEDS_SEGMENT_SPLIT ) ) {
        DumpLiteral( "    Needs segment split" );
        DumpNL();
    }
    if( _Is( conf, CST_SEGMENT_SPLIT ) ) {
        DumpLiteral( "    Is segment split" );
        DumpNL();
    }
    if( _Is( conf, CST_NEEDS_INDEX ) ) {
        DumpLiteral( "    Needs index" );
        DumpNL();
    }
    if( _Is( conf, CST_NEEDS_INDEX_SPLIT ) ) {
        DumpLiteral( "    Needs index split" );
        DumpNL();
    }
    if( _Is( conf, CST_INDEX_SPLIT ) ) {
        DumpLiteral( "    Is index split" );
        DumpNL();
    }
}
Пример #9
0
extern  void    DumpRegSet( hw_reg_set reg ) {
/********************************************/

    DumpRegName( reg );
    DumpNL();
}
Пример #10
0
extern  void    DumpIV( induction *var ) {
/****************************************/

    induction   *alias;
    invariant   *invar;

    DumpPtr( var );
    DumpLiteral( "  " );
    DumpOperand( var->name );
    DumpLiteral( " = ( " );
    if( _IsV( var, IV_BASIC ) ) {
        DumpLiteral( "**basic**" );
    } else {
        if( var->ivtimes != NULL ) {
            DumpOperand( var->ivtimes );
            DumpLiteral( " * " );
        }
        if( var->times != 1 ) {
            DumpLong( var->times );
            DumpLiteral( " * " );
        }
        DumpOperand( var->basic->name );
    }
    DumpLiteral( " )" );
    if( var->plus != 0 ) {
        DumpLiteral( " + ( " );
        DumpLong( var->plus );
        DumpLiteral( " )" );
    }
    if( var->ivtimes != NULL && var->plus2 != 0 ) {
        DumpLiteral( " + ( " );
        DumpOperand( var->ivtimes );
        DumpLiteral( " * " );
        DumpLong( var->plus2 );
        DumpLiteral( " )" );
    }
    for( invar = var->invar; invar != NULL; invar = invar->next ) {
        DumpLiteral( " + ( " );
        if( var->lasttimes >= invar->id ) {
            DumpOperand( var->ivtimes );
            DumpLiteral( " * " );
        }
        if( invar->times != 1 ) {
            DumpLong( invar->times );
            DumpLiteral( " * " );
        }
        DumpOperand( invar->name );
        DumpLiteral( " )" );
    }
    DumpNL();
    DumpLiteral( "        ins=" );
    DumpPtr( var->ins );
    DumpLiteral( " prev=" );
    DumpPtr( var->prev );
    DumpLiteral( " basic=" );
    DumpOperand( var->basic->name );
    if( _IsV( var, IV_ALIAS ) ) {
        DumpLiteral( " alias=" );
        for( alias = var->alias; _IsV( alias, IV_ALIAS ); ) {
            alias = alias->alias;
        }
        DumpPtr( alias );
    }
    DumpNL();
    DumpLiteral( "        Uses: " );
    DumpInt( var->use_count );
    DumpChar( ' ' );
    if( _IsV( var, IV_BASIC ) ) {
        DumpLiteral( " Basic" );
    }
    if( _IsV( var, IV_DEAD ) ) {
        DumpLiteral( " Dead" );
    }
    if( _IsV( var, IV_SURVIVED ) ) {
        DumpLiteral( " Survived" );
    }
    if( _IsV( var, IV_TOP ) ) {
        DumpLiteral( " Top" );
    }
    if( _IsV( var, IV_INTRODUCED ) ) {
        DumpLiteral( " Introduced" );
    }
    if( _IsV( var, IV_ALIAS ) ) {
        DumpLiteral( " Alias" );
    }
    if( _IsV( var, IV_INDEXED ) ) {
        DumpLiteral( " Indexed" );
    }
    if( _IsV( var, IV_USED ) ) {
        DumpLiteral( " Used" );
    }
    DumpNL();
}