luke
/
abc
mirror of https://github.com/YosysHQ/abc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

C++ compiler errors.

This commit is contained in:
Alan Mishchenko 2013-05-04 20:41:40 -07:00
parent 79f782c0e8
commit cd4043ba7f
1 changed files with 48 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
src/aig/gia/giaTim.c
View File

@ -101,11 +101,11 @@ int Gia_ManOrderWithBoxes_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vNod
} }
Vec_Int_t * Gia_ManOrderWithBoxes( Gia_Man_t * p ) Vec_Int_t * Gia_ManOrderWithBoxes( Gia_Man_t * p )
{ {
Tim_Man_t * pTime = (Tim_Man_t *)p->pManTime; Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime;
Vec_Int_t * vNodes; Vec_Int_t * vNodes;
Gia_Obj_t * pObj; Gia_Obj_t * pObj;
int i, k, curCi, curCo; int i, k, curCi, curCo;
assert( p->pManTime != NULL ); assert( pManTime != NULL );
assert( Gia_ManIsNormalized( p ) ); assert( Gia_ManIsNormalized( p ) );
// start trav IDs // start trav IDs
Gia_ManIncrementTravId( p ); Gia_ManIncrementTravId( p );
@ -115,7 +115,7 @@ Vec_Int_t * Gia_ManOrderWithBoxes( Gia_Man_t * p )
Vec_IntPush( vNodes, 0 ); Vec_IntPush( vNodes, 0 );
Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) ); Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
// include primary inputs // include primary inputs
for ( i = 0; i < Tim_ManPiNum(pTime); i++ ) for ( i = 0; i < Tim_ManPiNum(pManTime); i++ )
{ {
pObj = Gia_ManPi( p, i ); pObj = Gia_ManPi( p, i );
Vec_IntPush( vNodes, Gia_ObjId(p, pObj) ); Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
@ -123,25 +123,25 @@ Vec_Int_t * Gia_ManOrderWithBoxes( Gia_Man_t * p )
assert( Gia_ObjId(p, pObj) == i+1 ); assert( Gia_ObjId(p, pObj) == i+1 );
} }
// for each box, include box nodes // for each box, include box nodes
curCi = Tim_ManPiNum(pTime); curCi = Tim_ManPiNum(pManTime);
curCo = 0; curCo = 0;
for ( i = 0; i < Tim_ManBoxNum(pTime); i++ ) for ( i = 0; i < Tim_ManBoxNum(pManTime); i++ )
{ {
// add internal nodes // add internal nodes
for ( k = 0; k < Tim_ManBoxInputNum(pTime, i); k++ ) for ( k = 0; k < Tim_ManBoxInputNum(pManTime, i); k++ )
{ {
pObj = Gia_ManPo( p, curCo + k ); pObj = Gia_ManPo( p, curCo + k );
if ( Gia_ManOrderWithBoxes_rec( p, Gia_ObjFanin0(pObj), vNodes ) ) if ( Gia_ManOrderWithBoxes_rec( p, Gia_ObjFanin0(pObj), vNodes ) )
{ {
int iCiNum = p->iData2; int iCiNum = p->iData2;
int iBoxNum = Tim_ManBoxFindFromCiNum( p->pManTime, iCiNum ); int iBoxNum = Tim_ManBoxFindFromCiNum( pManTime, iCiNum );
printf( "Boxes are not in a topological order. The command has to terminate.\n" ); printf( "Boxes are not in a topological order. The command has to terminate.\n" );
printf( "The following information may help debugging (numbers are 0-based):\n" ); printf( "The following information may help debugging (numbers are 0-based):\n" );
printf( "Input %d of BoxA %d (1stCI = %d; 1stCO = %d) has TFI with CI %d,\n", printf( "Input %d of BoxA %d (1stCI = %d; 1stCO = %d) has TFI with CI %d,\n",
k, i, Tim_ManBoxOutputFirst(p->pManTime, i), Tim_ManBoxInputFirst(p->pManTime, i), iCiNum ); k, i, Tim_ManBoxOutputFirst(pManTime, i), Tim_ManBoxInputFirst(pManTime, i), iCiNum );
printf( "which corresponds to output %d of BoxB %d (1stCI = %d; 1stCO = %d).\n", printf( "which corresponds to output %d of BoxB %d (1stCI = %d; 1stCO = %d).\n",
iCiNum - Tim_ManBoxOutputFirst(p->pManTime, iBoxNum), iBoxNum, iCiNum - Tim_ManBoxOutputFirst(pManTime, iBoxNum), iBoxNum,
Tim_ManBoxOutputFirst(p->pManTime, iBoxNum), Tim_ManBoxInputFirst(p->pManTime, iBoxNum) ); Tim_ManBoxOutputFirst(pManTime, iBoxNum), Tim_ManBoxInputFirst(pManTime, iBoxNum) );
printf( "In a correct topological order, BoxB should preceed BoxA.\n" ); printf( "In a correct topological order, BoxB should preceed BoxA.\n" );
Vec_IntFree( vNodes ); Vec_IntFree( vNodes );
p->iData2 = 0; p->iData2 = 0;
@ -149,34 +149,34 @@ Vec_Int_t * Gia_ManOrderWithBoxes( Gia_Man_t * p )
} }
} }
// add POs corresponding to box inputs // add POs corresponding to box inputs
for ( k = 0; k < Tim_ManBoxInputNum(pTime, i); k++ ) for ( k = 0; k < Tim_ManBoxInputNum(pManTime, i); k++ )
{ {
pObj = Gia_ManPo( p, curCo + k ); pObj = Gia_ManPo( p, curCo + k );
Vec_IntPush( vNodes, Gia_ObjId(p, pObj) ); Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
} }
curCo += Tim_ManBoxInputNum(pTime, i); curCo += Tim_ManBoxInputNum(pManTime, i);
// add PIs corresponding to box outputs // add PIs corresponding to box outputs
for ( k = 0; k < Tim_ManBoxOutputNum(pTime, i); k++ ) for ( k = 0; k < Tim_ManBoxOutputNum(pManTime, i); k++ )
{ {
pObj = Gia_ManPi( p, curCi + k ); pObj = Gia_ManPi( p, curCi + k );
Vec_IntPush( vNodes, Gia_ObjId(p, pObj) ); Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
Gia_ObjSetTravIdCurrent( p, pObj ); Gia_ObjSetTravIdCurrent( p, pObj );
} }
curCi += Tim_ManBoxOutputNum(pTime, i); curCi += Tim_ManBoxOutputNum(pManTime, i);
} }
// add remaining nodes // add remaining nodes
for ( i = Tim_ManCoNum(pTime) - Tim_ManPoNum(pTime); i < Tim_ManCoNum(pTime); i++ ) for ( i = Tim_ManCoNum(pManTime) - Tim_ManPoNum(pManTime); i < Tim_ManCoNum(pManTime); i++ )
{ {
pObj = Gia_ManPo( p, i ); pObj = Gia_ManPo( p, i );
Gia_ManOrderWithBoxes_rec( p, Gia_ObjFanin0(pObj), vNodes ); Gia_ManOrderWithBoxes_rec( p, Gia_ObjFanin0(pObj), vNodes );
} }
// add POs // add POs
for ( i = Tim_ManCoNum(pTime) - Tim_ManPoNum(pTime); i < Tim_ManCoNum(pTime); i++ ) for ( i = Tim_ManCoNum(pManTime) - Tim_ManPoNum(pManTime); i < Tim_ManCoNum(pManTime); i++ )
{ {
pObj = Gia_ManPo( p, i ); pObj = Gia_ManPo( p, i );
Vec_IntPush( vNodes, Gia_ObjId(p, pObj) ); Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
} }
curCo += Tim_ManPoNum(pTime); curCo += Tim_ManPoNum(pManTime);
// verify counts // verify counts
assert( curCi == Gia_ManPiNum(p) ); assert( curCi == Gia_ManPiNum(p) );
assert( curCo == Gia_ManPoNum(p) ); assert( curCo == Gia_ManPoNum(p) );
@ -288,12 +288,12 @@ void Gia_ManDupCollapse_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Gia_Man_t * pNew )
} }
Gia_Man_t * Gia_ManDupCollapse( Gia_Man_t * p, Gia_Man_t * pBoxes, Vec_Int_t * vBoxPres ) Gia_Man_t * Gia_ManDupCollapse( Gia_Man_t * p, Gia_Man_t * pBoxes, Vec_Int_t * vBoxPres )
{ {
Tim_Man_t * pTime = (Tim_Man_t *)p->pManTime; Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime;
Gia_Man_t * pNew, * pTemp; Gia_Man_t * pNew, * pTemp;
Gia_Obj_t * pObj, * pObjBox; Gia_Obj_t * pObj, * pObjBox;
int i, k, curCi, curCo; int i, k, curCi, curCo;
assert( Gia_ManRegNum(p) == 0 ); assert( Gia_ManRegNum(p) == 0 );
assert( Gia_ManPiNum(p) == Tim_ManPiNum(pTime) + Gia_ManPoNum(pBoxes) ); assert( Gia_ManPiNum(p) == Tim_ManPiNum(pManTime) + Gia_ManPoNum(pBoxes) );
pNew = Gia_ManStart( Gia_ManObjNum(p) ); pNew = Gia_ManStart( Gia_ManObjNum(p) );
pNew->pName = Abc_UtilStrsav( p->pName ); pNew->pName = Abc_UtilStrsav( p->pName );
pNew->pSpec = Abc_UtilStrsav( p->pSpec ); pNew->pSpec = Abc_UtilStrsav( p->pSpec );
@ -305,32 +305,32 @@ Gia_Man_t * Gia_ManDupCollapse( Gia_Man_t * p, Gia_Man_t * pBoxes, Vec_Int_t * v
Gia_ManConst0(p)->Value = 0; Gia_ManConst0(p)->Value = 0;
Gia_ManIncrementTravId( p ); Gia_ManIncrementTravId( p );
Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) ); Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
for ( i = 0; i < Tim_ManPiNum(pTime); i++ ) for ( i = 0; i < Tim_ManPiNum(pManTime); i++ )
{ {
pObj = Gia_ManPi( p, i ); pObj = Gia_ManPi( p, i );
pObj->Value = Gia_ManAppendCi(pNew); pObj->Value = Gia_ManAppendCi(pNew);
Gia_ObjSetTravIdCurrent( p, pObj ); Gia_ObjSetTravIdCurrent( p, pObj );
} }
// create logic for each box // create logic for each box
curCi = Tim_ManPiNum(pTime); curCi = Tim_ManPiNum(pManTime);
curCo = 0; curCo = 0;
for ( i = 0; i < Tim_ManBoxNum(pTime); i++ ) for ( i = 0; i < Tim_ManBoxNum(pManTime); i++ )
{ {
// clean boxes // clean boxes
Gia_ManIncrementTravId( pBoxes ); Gia_ManIncrementTravId( pBoxes );
Gia_ObjSetTravIdCurrent( pBoxes, Gia_ManConst0(pBoxes) ); Gia_ObjSetTravIdCurrent( pBoxes, Gia_ManConst0(pBoxes) );
Gia_ManConst0(pBoxes)->Value = 0; Gia_ManConst0(pBoxes)->Value = 0;
// add internal nodes // add internal nodes
if ( Tim_ManBoxIsBlack(pTime, i) ) if ( Tim_ManBoxIsBlack(pManTime, i) )
{ {
int fSkip = (vBoxPres != NULL && !Vec_IntEntry(vBoxPres, i)); int fSkip = (vBoxPres != NULL && !Vec_IntEntry(vBoxPres, i));
for ( k = 0; k < Tim_ManBoxInputNum(pTime, i); k++ ) for ( k = 0; k < Tim_ManBoxInputNum(pManTime, i); k++ )
{ {
pObj = Gia_ManPo( p, curCo + k ); pObj = Gia_ManPo( p, curCo + k );
Gia_ManDupCollapse_rec( p, Gia_ObjFanin0(pObj), pNew ); Gia_ManDupCollapse_rec( p, Gia_ObjFanin0(pObj), pNew );
pObj->Value = fSkip ? -1 : Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ); pObj->Value = fSkip ? -1 : Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
} }
for ( k = 0; k < Tim_ManBoxOutputNum(pTime, i); k++ ) for ( k = 0; k < Tim_ManBoxOutputNum(pManTime, i); k++ )
{ {
pObj = Gia_ManPi( p, curCi + k ); pObj = Gia_ManPi( p, curCi + k );
pObj->Value = fSkip ? 0 : Gia_ManAppendCi(pNew); pObj->Value = fSkip ? 0 : Gia_ManAppendCi(pNew);
@ -339,7 +339,7 @@ Gia_Man_t * Gia_ManDupCollapse( Gia_Man_t * p, Gia_Man_t * pBoxes, Vec_Int_t * v
} }
else else
{ {
for ( k = 0; k < Tim_ManBoxInputNum(pTime, i); k++ ) for ( k = 0; k < Tim_ManBoxInputNum(pManTime, i); k++ )
{ {
// build logic // build logic
pObj = Gia_ManPo( p, curCo + k ); pObj = Gia_ManPo( p, curCo + k );
@ -349,10 +349,10 @@ Gia_Man_t * Gia_ManDupCollapse( Gia_Man_t * p, Gia_Man_t * pBoxes, Vec_Int_t * v
pObjBox->Value = Gia_ObjFanin0Copy(pObj); pObjBox->Value = Gia_ObjFanin0Copy(pObj);
Gia_ObjSetTravIdCurrent( pBoxes, pObjBox ); Gia_ObjSetTravIdCurrent( pBoxes, pObjBox );
} }
for ( k = 0; k < Tim_ManBoxOutputNum(pTime, i); k++ ) for ( k = 0; k < Tim_ManBoxOutputNum(pManTime, i); k++ )
{ {
// build logic // build logic
pObjBox = Gia_ManPo( pBoxes, curCi - Tim_ManPiNum(pTime) + k ); pObjBox = Gia_ManPo( pBoxes, curCi - Tim_ManPiNum(pManTime) + k );
Gia_ManDupCollapse_rec( pBoxes, Gia_ObjFanin0(pObjBox), pNew ); Gia_ManDupCollapse_rec( pBoxes, Gia_ObjFanin0(pObjBox), pNew );
// transfer to the PI // transfer to the PI
pObj = Gia_ManPi( p, curCi + k ); pObj = Gia_ManPi( p, curCi + k );
@ -360,17 +360,17 @@ Gia_Man_t * Gia_ManDupCollapse( Gia_Man_t * p, Gia_Man_t * pBoxes, Vec_Int_t * v
Gia_ObjSetTravIdCurrent( p, pObj ); Gia_ObjSetTravIdCurrent( p, pObj );
} }
} }
curCo += Tim_ManBoxInputNum(pTime, i); curCo += Tim_ManBoxInputNum(pManTime, i);
curCi += Tim_ManBoxOutputNum(pTime, i); curCi += Tim_ManBoxOutputNum(pManTime, i);
} }
// add remaining nodes // add remaining nodes
for ( i = Tim_ManCoNum(pTime) - Tim_ManPoNum(pTime); i < Tim_ManCoNum(pTime); i++ ) for ( i = Tim_ManCoNum(pManTime) - Tim_ManPoNum(pManTime); i < Tim_ManCoNum(pManTime); i++ )
{ {
pObj = Gia_ManPo( p, i ); pObj = Gia_ManPo( p, i );
Gia_ManDupCollapse_rec( p, Gia_ObjFanin0(pObj), pNew ); Gia_ManDupCollapse_rec( p, Gia_ObjFanin0(pObj), pNew );
pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ); pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
} }
curCo += Tim_ManPoNum(pTime); curCo += Tim_ManPoNum(pManTime);
// verify counts // verify counts
assert( curCi == Gia_ManPiNum(p) ); assert( curCi == Gia_ManPiNum(p) );
assert( curCo == Gia_ManPoNum(p) ); assert( curCo == Gia_ManPoNum(p) );
@ -379,8 +379,8 @@ Gia_Man_t * Gia_ManDupCollapse( Gia_Man_t * p, Gia_Man_t * pBoxes, Vec_Int_t * v
pNew = Gia_ManCleanup( pTemp = pNew ); pNew = Gia_ManCleanup( pTemp = pNew );
Gia_ManCleanupRemap( p, pTemp ); Gia_ManCleanupRemap( p, pTemp );
Gia_ManStop( pTemp ); Gia_ManStop( pTemp );
assert( Tim_ManPoNum(pTime) == Gia_ManPoNum(pNew) ); assert( Tim_ManPoNum(pManTime) == Gia_ManPoNum(pNew) );
assert( Tim_ManPiNum(pTime) == Gia_ManPiNum(pNew) ); assert( Tim_ManPiNum(pManTime) == Gia_ManPiNum(pNew) );
return pNew; return pNew;
} }
@ -415,7 +415,7 @@ int Gia_ManLevelWithBoxes_rec( Gia_Man_t * p, Gia_Obj_t * pObj )
int Gia_ManLevelWithBoxes( Gia_Man_t * p ) int Gia_ManLevelWithBoxes( Gia_Man_t * p )
{ {
int nAnd2Delay = p->nAnd2Delay ? p->nAnd2Delay : 1; int nAnd2Delay = p->nAnd2Delay ? p->nAnd2Delay : 1;
Tim_Man_t * pTime = (Tim_Man_t *)p->pManTime; Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime;
Gia_Obj_t * pObj, * pObjIn; Gia_Obj_t * pObj, * pObjIn;
int i, k, j, curCi, curCo, LevelMax; int i, k, j, curCi, curCo, LevelMax;
assert( Gia_ManRegNum(p) == 0 ); assert( Gia_ManRegNum(p) == 0 );
@ -424,20 +424,20 @@ int Gia_ManLevelWithBoxes( Gia_Man_t * p )
Gia_ObjSetLevel( p, Gia_ManConst0(p), 0 ); Gia_ObjSetLevel( p, Gia_ManConst0(p), 0 );
Gia_ManIncrementTravId( p ); Gia_ManIncrementTravId( p );
Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) ); Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
for ( i = 0; i < Tim_ManPiNum(pTime); i++ ) for ( i = 0; i < Tim_ManPiNum(pManTime); i++ )
{ {
pObj = Gia_ManPi( p, i ); pObj = Gia_ManPi( p, i );
Gia_ObjSetLevel( p, pObj, Tim_ManGetCiArrival(pTime, i) / nAnd2Delay ); Gia_ObjSetLevel( p, pObj, Tim_ManGetCiArrival(pManTime, i) / nAnd2Delay );
Gia_ObjSetTravIdCurrent( p, pObj ); Gia_ObjSetTravIdCurrent( p, pObj );
} }
// create logic for each box // create logic for each box
curCi = Tim_ManPiNum(pTime); curCi = Tim_ManPiNum(pManTime);
curCo = 0; curCo = 0;
for ( i = 0; i < Tim_ManBoxNum(pTime); i++ ) for ( i = 0; i < Tim_ManBoxNum(pManTime); i++ )
{ {
int nBoxInputs = Tim_ManBoxInputNum( pTime, i ); int nBoxInputs = Tim_ManBoxInputNum( pManTime, i );
int nBoxOutputs = Tim_ManBoxOutputNum( pTime, i ); int nBoxOutputs = Tim_ManBoxOutputNum( pManTime, i );
float * pDelayTable = Tim_ManBoxDelayTable( pTime, i ); float * pDelayTable = Tim_ManBoxDelayTable( pManTime, i );
// compute level for TFI of box inputs // compute level for TFI of box inputs
for ( k = 0; k < nBoxInputs; k++ ) for ( k = 0; k < nBoxInputs; k++ )
{ {
@ -469,14 +469,14 @@ int Gia_ManLevelWithBoxes( Gia_Man_t * p )
} }
// add remaining nodes // add remaining nodes
p->nLevels = 0; p->nLevels = 0;
for ( i = Tim_ManCoNum(pTime) - Tim_ManPoNum(pTime); i < Tim_ManCoNum(pTime); i++ ) for ( i = Tim_ManCoNum(pManTime) - Tim_ManPoNum(pManTime); i < Tim_ManCoNum(pManTime); i++ )
{ {
pObj = Gia_ManPo( p, i ); pObj = Gia_ManPo( p, i );
Gia_ManLevelWithBoxes_rec( p, Gia_ObjFanin0(pObj) ); Gia_ManLevelWithBoxes_rec( p, Gia_ObjFanin0(pObj) );
Gia_ObjSetCoLevel( p, pObj ); Gia_ObjSetCoLevel( p, pObj );
p->nLevels = Abc_MaxInt( p->nLevels, Gia_ObjLevel(p, pObj) ); p->nLevels = Abc_MaxInt( p->nLevels, Gia_ObjLevel(p, pObj) );
} }
curCo += Tim_ManPoNum(pTime); curCo += Tim_ManPoNum(pManTime);
// verify counts // verify counts
assert( curCi == Gia_ManPiNum(p) ); assert( curCi == Gia_ManPiNum(p) );
assert( curCo == Gia_ManPoNum(p) ); assert( curCo == Gia_ManPoNum(p) );
@ -586,9 +586,10 @@ int Gia_ManVerifyWithBoxes( Gia_Man_t * pGia, void * pParsInit )
***********************************************************************/ ***********************************************************************/
void * Gia_ManUpdateTimMan( Gia_Man_t * p, Vec_Int_t * vBoxPres ) void * Gia_ManUpdateTimMan( Gia_Man_t * p, Vec_Int_t * vBoxPres )
{ {
assert( p->pManTime != NULL ); Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime;
assert( Tim_ManBoxNum(p->pManTime) == Vec_IntSize(vBoxPres) ); assert( pManTime != NULL );
return Tim_ManTrim( p->pManTime, vBoxPres ); assert( Tim_ManBoxNum(pManTime) == Vec_IntSize(vBoxPres) );
return Tim_ManTrim( pManTime, vBoxPres );
} }
/**Function************************************************************* /**Function*************************************************************