예제 #1
0
extern  void    CloneCode( label_handle lbl )
/*****************************************
    consider:

        JMP L1
            ....
  L1:   POP   AX
        RET

    we want to clone the code at L1 at the point of the jump,
    since it will be faster (and smaller since POP AX/RET is only 2 bytes
    while the JMP might be 3/5).
*/
{
    ins_entry   *next;
    ins_entry   *lbl_ins;
    ins_entry   *hoist;
    ins_entry   *jmp;
    unsigned    size;
    unsigned    max_size;

    lbl_ins = lbl->ins;
    if( lbl_ins == NULL )
        return;
    size = 0;
    hoist = NextIns( lbl_ins );
    for( next = hoist; ; next = NextIns( next ) ) {
        if( next == NULL )
            return;
        if( _Class( next ) == OC_CODE && CodeHasAbsPatch( &next->oc.oc_entry ) )
            return;
        if( _Class( next ) != OC_LABEL ) {
            size += _ObjLen( next );
            if( size > MAX_CLONE_SIZE )
                return;
            if( _TransferClass( _Class( next ) ) ) {
                break;
            }
        }
    }
    if( _Class( next ) == OC_JMP && _Label( next ) == lbl )
        return;
    for( jmp = lbl->refs; jmp != NULL; jmp = _LblRef( jmp ) ) {
        if( next == jmp )
            continue;
        if( !_TransferClass( _Class( jmp ) ) )
            continue;
        max_size = _ObjLen( jmp );
        if( size > max_size && FindShort( jmp, NULL ) )
            continue;
        if( OptForSize < 50 ) {
            max_size *= (100-OptForSize) / 25;
        }
        if( size > max_size )
            continue;
        DoCloneCode( jmp, hoist );
        DelInstr( jmp );
    }
}
예제 #2
0
파일: 1125.c 프로젝트: UsuallyGO/POJ
int main()
{
	int vertex;
	int index;
	int first, second;
	int tmp;

	do
	{
		scanf("%d", &vertex);
		if(!vertex)
			break;

		memset(Matrix, 0, sizeof(int)*MAX_VERTEX*MAX_VERTEX);
		for(index=1; index<=vertex; index++)
		{
			scanf("%d", &first);
			for(second=0; second<first; second++)
			{
				scanf("%d", &tmp);
				scanf("%d", &Matrix[index][tmp]);
			}
		}

		for(first=1; first<=vertex; first++)
			for(second=1; second<=vertex; second++)
			{
				if(first!=second && !Matrix[first][second])
						Matrix[first][second] = MAX_INT;
			}

#if DEBUG
		Show(Matrix, vertex);
#endif
		Floyid(vertex);
#if DEBUG
		Show(Dist, vertex);
#endif
		if(FindShort(vertex, &first, &second)<0)
			printf("disjoint\n");
		else
			printf("%d %d\n", first, second);
	}while(1);
	
	return 0;
}
예제 #3
0
static  void    TransformJumps( ins_entry *ins, ins_entry *first )
/****************************************************************/
{
    ins_entry           *add;
    ins_entry           *next;
    ins_entry           *lbl;
    oc_class            cl;

  optbegin
    if( _Class( ins ) == OC_RET )
        optreturnvoid;
    lbl = _Label( ins )->ins;
    if( lbl == NULL )
        optreturnvoid;
    add = lbl;
    for( ;; ) {
        if( add == NULL )
            optreturnvoid;
        cl = _Class( add );
        if( _TransferClass( cl ) )
            break;
        if( cl == OC_LABEL ) {
            if( _Attr( add ) & ATTR_SHORT )
                optreturnvoid;
            _ClrStatus( _Label( add ), SHORTREACH );
        }
        add = NextIns( add );
    }
    if( add == first || add == ins )
        optreturnvoid;
    if( FindShort( first, lbl ) )
        optreturnvoid;
    for( ;; ) {
        next = PrevIns( add );
        DeleteQueue( add );
        InsertQueue( add, first );
        if( add == lbl )
            break;
        add = next;
    }
    DeleteQueue( first );
    InsertQueue( first, next );
    Untangle( NextIns( first ) );
  optend
}
예제 #4
0
void Dijkstra(ALGraph * G,int v0){
	// 邻接表存储的图最短路径算法(时间复杂度为O(|E|log|V|) 
	int P[G->n],D[G->n],Arrived[G->n];				//P[]存放最短路径邻接于哪个顶点,D[]存放各定点到V0的最短路径值 
	int i,shortest;
	EdgeNode * edge;
	
	// Initialization
	for(i=0; i<G->n; i++){
		Arrived[i] = FALSE;
		P[i] = -1;
		D[i] = INFINITY;
	}
	
	// Update the shortest path of each vertex 
	D[v0] = 0;
	Arrived[v0] = 0;
	edge = G->Adjlist[v0].FirstEdge;
	while( edge ){
		D[edge->AdjV] = edge->Value;
		P[edge->AdjV] = v0;
		edge = edge->Next;
	}
	
	for(i=1; i<G->n; i++){							//这里i只是控制次数,无实际意义 
		shortest = FindShort(G,D,Arrived);
		if( D[shortest] == INFINITY ) break;		//若是非连通图,结束 
		Arrived[shortest] = TRUE;
		edge = G->Adjlist[shortest].FirstEdge;
		while( edge ){								//Update the shortest path
			if( edge->Value + D[shortest] < D[edge->AdjV] ){
				D[edge->AdjV] = edge->Value + D[shortest];
				P[edge->AdjV] = shortest;
			}
			edge = edge->Next;						//不要忘记改变循环变量 
		}
	}
	
	for(i=0; i<G->n; i++){
		if( i==v0 ) continue;
		printf("P[%d] = %d, D[%d] =%d \n",i,P[i],i,D[i]);
	}
	
	PrintSP(P,9);
	return ;
}
예제 #5
0
extern  bool    StraightenCode( ins_entry *jump )
/***********************************************/
{
    ins_entry   *next;
    ins_entry   *insert;
    ins_entry   *hoist;
    ins_entry   *end_hoist;
    oc_class    cl;
    obj_length  align;

    optbegin
    hoist = _Label( jump )->ins;
    if( hoist == NULL )
        optreturn( false );
    if( hoist == LastIns )
        optreturn( false );
    cl = PrevClass( hoist );
    if( !_TransferClass( cl ) )
        optreturn( false );

    end_hoist = NULL;
    for( next = hoist; ; next = NextIns( next ) ) {
        if( next == jump ) { // pushing code down to jump
            if( end_hoist == NULL )
                optreturn( false );
            if( FindShort( hoist, end_hoist ) )
                optreturn( false );
            break;
        }
        if( next == NULL ) { // hauling code up to jump
            if( FindShort( jump, hoist ) )
                optreturn( false );
            break;
        }
        cl = _Class( next );
        if( end_hoist == NULL && _TransferClass( cl ) ) {
            end_hoist = next;
        }
    }

    align = _ObjLen( hoist );
    insert = jump;
    for( ;; ) {
        if( hoist == NULL ) {
            ChgLblRef( jump, AddNewLabel( LastIns, align ) );
            next = LastIns;
            break;
        }
        next = NextIns( hoist );
        DeleteQueue( hoist );
        InsertQueue( hoist, insert );
        if( hoist == jump )
            optreturn( false );
        insert = hoist;
        cl = _Class( hoist );
        if( _TransferClass( cl ) ) {
            IsolatedCode( insert );
            break;
        }
        hoist = next;
    }
    InsDelete = true;
    Untangle( next );
    if( _Class( jump ) != OC_DEAD ) {
        Untangle( _Label( jump )->ins );
    }
    optreturn( true );
}