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 );
}
}
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;
}
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
}
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 ;
}
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 );
}
