mirror of https://github.com/YosysHQ/abc.git
Renaming Cba into Bac.
This commit is contained in:
Alan Mishchenko
parent
ddda9320ac
commit
477ecc172f
204
abclib.dsp
204
abclib.dsp
|
|
@ -782,82 +782,6 @@ SOURCE=.\src\base\wlc\wlcStdin.c
|
|||
SOURCE=.\src\base\wlc\wlcWriteVer.c
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "cba"
|
||||
|
||||
# PROP Default_Filter ""
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cba.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaBlast.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaCba.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaCom.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaLib.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaNtk.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaOper.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaPrs.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaPrsBuild.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaPrsTrans.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaPtr.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaPtrAbc.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaReadBlif.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaReadSmt.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaReadVer.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaWriteBlif.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaWriteSmt.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaWriteVer.c
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "pla"
|
||||
|
||||
# PROP Default_Filter ""
|
||||
|
|
@ -898,6 +822,134 @@ SOURCE=.\src\base\pla\plaSimple.c
|
|||
SOURCE=.\src\base\pla\plaWrite.c
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "bac"
|
||||
|
||||
# PROP Default_Filter ""
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bac.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bac.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacBac.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacBlast.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacCom.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacLib.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacNtk.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacOper.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacPrs.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacPrsBuild.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacPrsTrans.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacPrtAbc.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacPtr.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacReadBlif.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacReadSmt.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacReadVec.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacWriteBlif.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacWriteSmt.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\bac\bacWriteVer.c
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "cba"
|
||||
|
||||
# PROP Default_Filter ""
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cba.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cba.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaBlast.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaCba.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaCom.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaNtk.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaPrs.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaReadBlif.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaReadVer.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaWriteBlif.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\src\base\cba\cbaWriteVer.c
|
||||
# End Source File
|
||||
# End Group
|
||||
# End Group
|
||||
# Begin Group "bdd"
|
||||
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
|
||||
Affiliation [UC Berkeley]
|
||||
|
||||
Date [Ver. 1.0. Started - November 29, 2014.]
|
||||
Date [Ver. 1.0. Started - July 21, 2015.]
|
||||
|
||||
Revision [$Id: cba.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
|
||||
|
||||
|
|
|
|||
1215
src/base/cba/cba.h
1215
src/base/cba/cba.h
File diff suppressed because it is too large
Load Diff
|
|
@ -1,28 +1,24 @@
|
|||
/**CFile****************************************************************
|
||||
|
||||
FileName [cbaBlast.c]
|
||||
FileName [cba.c]
|
||||
|
||||
SystemName [ABC: Logic synthesis and verification system.]
|
||||
|
||||
PackageName [Hierarchical word-level netlist.]
|
||||
PackageName [Verilog parser.]
|
||||
|
||||
Synopsis [Bit-blasting of the netlist.]
|
||||
Synopsis [Parses several flavors of word-level Verilog.]
|
||||
|
||||
Author [Alan Mishchenko]
|
||||
|
||||
Affiliation [UC Berkeley]
|
||||
|
||||
Date [Ver. 1.0. Started - November 29, 2014.]
|
||||
Date [Ver. 1.0. Started - July 21, 2015.]
|
||||
|
||||
Revision [$Id: cbaBlast.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
|
||||
Revision [$Id: cba.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
|
||||
|
||||
***********************************************************************/
|
||||
|
||||
#include "cba.h"
|
||||
#include "base/abc/abc.h"
|
||||
#include "map/mio/mio.h"
|
||||
#include "bool/dec/dec.h"
|
||||
#include "base/main/mainInt.h"
|
||||
|
||||
ABC_NAMESPACE_IMPL_START
|
||||
|
||||
|
|
@ -45,539 +41,8 @@ ABC_NAMESPACE_IMPL_START
|
|||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Cba_ManPrepareGates( Cba_Man_t * p )
|
||||
{
|
||||
Dec_Graph_t ** ppGraphs; int i;
|
||||
if ( p->pMioLib == NULL )
|
||||
return;
|
||||
ppGraphs = ABC_CALLOC( Dec_Graph_t *, Abc_NamObjNumMax(p->pMods) );
|
||||
for ( i = 1; i < Abc_NamObjNumMax(p->pMods); i++ )
|
||||
{
|
||||
char * pGateName = Abc_NamStr( p->pMods, i );
|
||||
Mio_Gate_t * pGate = Mio_LibraryReadGateByName( (Mio_Library_t *)p->pMioLib, pGateName, NULL );
|
||||
if ( pGate != NULL )
|
||||
ppGraphs[i] = Dec_Factor( Mio_GateReadSop(pGate) );
|
||||
}
|
||||
assert( p->ppGraphs == NULL );
|
||||
p->ppGraphs = (void **)ppGraphs;
|
||||
}
|
||||
void Cba_ManUndoGates( Cba_Man_t * p )
|
||||
{
|
||||
int i;
|
||||
if ( p->pMioLib == NULL )
|
||||
return;
|
||||
for ( i = 1; i < Abc_NamObjNumMax(p->pMods); i++ )
|
||||
if ( p->ppGraphs[i] )
|
||||
Dec_GraphFree( (Dec_Graph_t *)p->ppGraphs[i] );
|
||||
ABC_FREE( p->ppGraphs );
|
||||
}
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
int Cba_ManAddBarbuf( Gia_Man_t * pNew, int iRes, Cba_Man_t * p, int iLNtk, int iLObj, int iRNtk, int iRObj, Vec_Int_t * vMap )
|
||||
{
|
||||
int iBufLit, iIdLit;
|
||||
if ( iRes == 0 || iRes == 1 )
|
||||
return iRes;
|
||||
assert( iRes > 0 );
|
||||
if ( vMap && Abc_Lit2Var(iRes) < Vec_IntSize(vMap) && (iIdLit = Vec_IntEntry(vMap, Abc_Lit2Var(iRes))) >= 0 &&
|
||||
Vec_IntEntry(&p->vBuf2LeafNtk, Abc_Lit2Var(iIdLit)) == iLNtk && Vec_IntEntry(&p->vBuf2RootNtk, Abc_Lit2Var(iIdLit)) == iRNtk )
|
||||
return Abc_LitNotCond( Vec_IntEntry(pNew->vBarBufs, Abc_Lit2Var(iIdLit)), Abc_LitIsCompl(iRes) ^ Abc_LitIsCompl(iIdLit) );
|
||||
assert( Cba_ManNtkIsOk(p, iLNtk) && Cba_ManNtkIsOk(p, iRNtk) );
|
||||
Vec_IntPush( &p->vBuf2LeafNtk, iLNtk );
|
||||
Vec_IntPush( &p->vBuf2LeafObj, iLObj );
|
||||
Vec_IntPush( &p->vBuf2RootNtk, iRNtk );
|
||||
Vec_IntPush( &p->vBuf2RootObj, iRObj );
|
||||
iBufLit = Gia_ManAppendBuf( pNew, iRes );
|
||||
if ( vMap )
|
||||
{
|
||||
Vec_IntSetEntryFull( vMap, Abc_Lit2Var(iRes), Abc_Var2Lit(Vec_IntSize(pNew->vBarBufs), Abc_LitIsCompl(iRes)) );
|
||||
Vec_IntPush( pNew->vBarBufs, iBufLit );
|
||||
}
|
||||
return iBufLit;
|
||||
}
|
||||
int Cba_ManExtract_rec( Gia_Man_t * pNew, Cba_Ntk_t * p, int i, int fBuffers, Vec_Int_t * vMap )
|
||||
{
|
||||
int iRes = Cba_ObjCopy( p, i );
|
||||
if ( iRes >= 0 )
|
||||
return iRes;
|
||||
if ( Cba_ObjIsCo(p, i) )
|
||||
iRes = Cba_ManExtract_rec( pNew, p, Cba_ObjFanin(p, i), fBuffers, vMap );
|
||||
else if ( Cba_ObjIsPi(p, i) )
|
||||
{
|
||||
Cba_Ntk_t * pHost = Cba_NtkHostNtk( p );
|
||||
int iObj = Cba_BoxBi( pHost, Cba_NtkHostObj(p), Cba_ObjIndex(p, i) );
|
||||
iRes = Cba_ManExtract_rec( pNew, pHost, iObj, fBuffers, vMap );
|
||||
if ( fBuffers )
|
||||
iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pHost), iObj, vMap );
|
||||
}
|
||||
else if ( Cba_ObjIsBo(p, i) )
|
||||
{
|
||||
int iBox = Cba_BoxBoBox(p, i);
|
||||
if ( Cba_ObjIsBoxUser(p, iBox) ) // user box
|
||||
{
|
||||
Cba_Ntk_t * pBox = Cba_BoxBoNtk( p, i );
|
||||
int iObj = Cba_NtkPo( pBox, Cba_ObjIndex(p, i) );
|
||||
iRes = Cba_ManExtract_rec( pNew, pBox, iObj, fBuffers, vMap );
|
||||
if ( fBuffers )
|
||||
iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pBox), iObj, vMap );
|
||||
}
|
||||
else // primitive
|
||||
{
|
||||
int iFanin, nLits, pLits[16];
|
||||
assert( Cba_ObjIsBoxPrim(p, iBox) );
|
||||
Cba_BoxForEachFanin( p, iBox, iFanin, nLits )
|
||||
pLits[nLits] = Cba_ManExtract_rec( pNew, p, iFanin, fBuffers, vMap );
|
||||
assert( nLits <= 16 );
|
||||
if ( p->pDesign->ppGraphs ) // mapped gate
|
||||
{
|
||||
extern int Gia_ManFactorGraph( Gia_Man_t * p, Dec_Graph_t * pFForm, Vec_Int_t * vLeaves );
|
||||
Dec_Graph_t * pGraph = (Dec_Graph_t *)p->pDesign->ppGraphs[Cba_BoxNtkId(p, iBox)];
|
||||
Vec_Int_t Leaves = { nLits, nLits, pLits };
|
||||
assert( pGraph != NULL );
|
||||
return Gia_ManFactorGraph( pNew, pGraph, &Leaves );
|
||||
}
|
||||
else
|
||||
{
|
||||
Cba_ObjType_t Type = Cba_ObjType(p, iBox);
|
||||
if ( nLits == 0 )
|
||||
{
|
||||
if ( Type == CBA_BOX_CF )
|
||||
iRes = 0;
|
||||
else if ( Type == CBA_BOX_CT )
|
||||
iRes = 1;
|
||||
else assert( 0 );
|
||||
}
|
||||
else if ( nLits == 1 )
|
||||
{
|
||||
if ( Type == CBA_BOX_BUF )
|
||||
iRes = pLits[0];
|
||||
else if ( Type == CBA_BOX_INV )
|
||||
iRes = Abc_LitNot( pLits[0] );
|
||||
else assert( 0 );
|
||||
}
|
||||
else if ( nLits == 2 )
|
||||
{
|
||||
if ( Type == CBA_BOX_AND )
|
||||
iRes = Gia_ManHashAnd( pNew, pLits[0], pLits[1] );
|
||||
else if ( Type == CBA_BOX_NAND )
|
||||
iRes = Abc_LitNot( Gia_ManHashAnd( pNew, pLits[0], pLits[1] ) );
|
||||
else if ( Type == CBA_BOX_OR )
|
||||
iRes = Gia_ManHashOr( pNew, pLits[0], pLits[1] );
|
||||
else if ( Type == CBA_BOX_NOR )
|
||||
iRes = Abc_LitNot( Gia_ManHashOr( pNew, pLits[0], pLits[1] ) );
|
||||
else if ( Type == CBA_BOX_XOR )
|
||||
iRes = Gia_ManHashXor( pNew, pLits[0], pLits[1] );
|
||||
else if ( Type == CBA_BOX_XNOR )
|
||||
iRes = Abc_LitNot( Gia_ManHashXor( pNew, pLits[0], pLits[1] ) );
|
||||
else if ( Type == CBA_BOX_SHARP )
|
||||
iRes = Gia_ManHashAnd( pNew, pLits[0], Abc_LitNot(pLits[1]) );
|
||||
else if ( Type == CBA_BOX_SHARPL )
|
||||
iRes = Gia_ManHashAnd( pNew, Abc_LitNot(pLits[0]), pLits[1] );
|
||||
else assert( 0 );
|
||||
}
|
||||
else if ( nLits == 3 )
|
||||
{
|
||||
if ( Type == CBA_BOX_MUX )
|
||||
iRes = Gia_ManHashMux( pNew, pLits[0], pLits[1], pLits[2] );
|
||||
else if ( Type == CBA_BOX_MAJ )
|
||||
iRes = Gia_ManHashMaj( pNew, pLits[0], pLits[1], pLits[2] );
|
||||
else if ( Type == CBA_BOX_ADD )
|
||||
{
|
||||
int iRes0 = Gia_ManHashAnd( pNew, pLits[1], pLits[2] );
|
||||
int iRes1 = Gia_ManHashOr( pNew, pLits[1], pLits[2] );
|
||||
assert( Cba_BoxBoNum(p, iBox) == 2 );
|
||||
if ( Cba_BoxBo(p, iBox, 0) == i ) // sum
|
||||
iRes = Gia_ManHashXor( pNew, pLits[0], Gia_ManHashAnd(pNew, Abc_LitNot(iRes0), iRes1) );
|
||||
else if ( Cba_BoxBo(p, iBox, 1) == i ) // cout
|
||||
iRes = Gia_ManHashOr( pNew, iRes0, Gia_ManHashAnd(pNew, pLits[0], iRes1) );
|
||||
else assert( 0 );
|
||||
}
|
||||
else assert( 0 );
|
||||
}
|
||||
else assert( 0 );
|
||||
}
|
||||
}
|
||||
}
|
||||
else assert( 0 );
|
||||
Cba_ObjSetCopy( p, i, iRes );
|
||||
return iRes;
|
||||
}
|
||||
Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose )
|
||||
{
|
||||
Cba_Ntk_t * pNtk, * pRoot = Cba_ManRoot(p);
|
||||
Gia_Man_t * pNew, * pTemp;
|
||||
Vec_Int_t * vMap = NULL;
|
||||
int i, iObj;
|
||||
|
||||
Vec_IntClear( &p->vBuf2LeafNtk );
|
||||
Vec_IntClear( &p->vBuf2LeafObj );
|
||||
Vec_IntClear( &p->vBuf2RootNtk );
|
||||
Vec_IntClear( &p->vBuf2RootObj );
|
||||
|
||||
Cba_ManForEachNtk( p, pNtk, i )
|
||||
{
|
||||
Cba_NtkDeriveIndex( pNtk );
|
||||
Cba_NtkStartCopies( pNtk );
|
||||
}
|
||||
|
||||
// start the manager
|
||||
pNew = Gia_ManStart( Cba_ManNodeNum(p) );
|
||||
pNew->pName = Abc_UtilStrsav(p->pName);
|
||||
pNew->pSpec = Abc_UtilStrsav(p->pSpec);
|
||||
|
||||
// primary inputs
|
||||
Cba_NtkForEachPi( pRoot, iObj, i )
|
||||
Cba_ObjSetCopy( pRoot, iObj, Gia_ManAppendCi(pNew) );
|
||||
|
||||
// internal nodes
|
||||
Gia_ManHashAlloc( pNew );
|
||||
pNew->vBarBufs = Vec_IntAlloc( 10000 );
|
||||
vMap = Vec_IntStartFull( 10000 );
|
||||
Cba_ManPrepareGates( p );
|
||||
Cba_NtkForEachPo( pRoot, iObj, i )
|
||||
Cba_ManExtract_rec( pNew, pRoot, iObj, fBuffers, vMap );
|
||||
Cba_ManUndoGates( p );
|
||||
Vec_IntFreeP( &vMap );
|
||||
Gia_ManHashStop( pNew );
|
||||
|
||||
// primary outputs
|
||||
Cba_NtkForEachPo( pRoot, iObj, i )
|
||||
Gia_ManAppendCo( pNew, Cba_ObjCopy(pRoot, iObj) );
|
||||
assert( Vec_IntSize(&p->vBuf2LeafNtk) == pNew->nBufs );
|
||||
|
||||
// cleanup
|
||||
pNew = Gia_ManCleanup( pTemp = pNew );
|
||||
Gia_ManStop( pTemp );
|
||||
//Gia_ManPrintStats( pNew, NULL );
|
||||
return pNew;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Mark each GIA node with the network it belongs to.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Cba_ManMarkNodesGia( Cba_Man_t * p, Gia_Man_t * pGia )
|
||||
{
|
||||
Gia_Obj_t * pObj; int i, Count = 0;
|
||||
assert( Vec_IntSize(&p->vBuf2LeafNtk) == Gia_ManBufNum(pGia) );
|
||||
Gia_ManConst0(pGia)->Value = 1;
|
||||
Gia_ManForEachPi( pGia, pObj, i )
|
||||
pObj->Value = 1;
|
||||
Gia_ManForEachAnd( pGia, pObj, i )
|
||||
{
|
||||
if ( Gia_ObjIsBuf(pObj) )
|
||||
pObj->Value = Vec_IntEntry( &p->vBuf2LeafNtk, Count++ );
|
||||
else
|
||||
{
|
||||
pObj->Value = Gia_ObjFanin0(pObj)->Value;
|
||||
assert( pObj->Value == Gia_ObjFanin1(pObj)->Value );
|
||||
}
|
||||
}
|
||||
assert( Count == Gia_ManBufNum(pGia) );
|
||||
Gia_ManForEachPo( pGia, pObj, i )
|
||||
{
|
||||
assert( Gia_ObjFanin0(pObj)->Value == 1 );
|
||||
pObj->Value = 1;
|
||||
}
|
||||
}
|
||||
void Cba_ManRemapBarbufs( Cba_Man_t * pNew, Cba_Man_t * p )
|
||||
{
|
||||
Cba_Ntk_t * pNtk; int Entry, i;
|
||||
//assert( Vec_IntSize(&p->vBuf2RootNtk) );
|
||||
assert( !Vec_IntSize(&pNew->vBuf2RootNtk) );
|
||||
Vec_IntAppend( &pNew->vBuf2RootNtk, &p->vBuf2RootNtk );
|
||||
Vec_IntAppend( &pNew->vBuf2RootObj, &p->vBuf2RootObj );
|
||||
Vec_IntAppend( &pNew->vBuf2LeafNtk, &p->vBuf2LeafNtk );
|
||||
Vec_IntAppend( &pNew->vBuf2LeafObj, &p->vBuf2LeafObj );
|
||||
Vec_IntForEachEntry( &p->vBuf2LeafObj, Entry, i )
|
||||
{
|
||||
pNtk = Cba_ManNtk( p, Vec_IntEntry(&p->vBuf2LeafNtk, i) );
|
||||
Vec_IntWriteEntry( &pNew->vBuf2LeafObj, i, Cba_ObjCopy(pNtk, Entry) );
|
||||
}
|
||||
Vec_IntForEachEntry( &p->vBuf2RootObj, Entry, i )
|
||||
{
|
||||
pNtk = Cba_ManNtk( p, Vec_IntEntry(&p->vBuf2RootNtk, i) );
|
||||
Vec_IntWriteEntry( &pNew->vBuf2RootObj, i, Cba_ObjCopy(pNtk, Entry) );
|
||||
}
|
||||
}
|
||||
void Cba_NtkCreateAndConnectBuffer( Gia_Man_t * pGia, Gia_Obj_t * pObj, Cba_Ntk_t * p, int iTerm )
|
||||
{
|
||||
int iObj;
|
||||
if ( pGia && Gia_ObjFaninId0p(pGia, pObj) > 0 )
|
||||
{
|
||||
iObj = Cba_ObjAlloc( p, CBA_OBJ_BI, Gia_ObjFanin0(pObj)->Value );
|
||||
Cba_ObjAlloc( p, Gia_ObjFaninC0(pObj) ? CBA_BOX_INV : CBA_BOX_BUF, -1 );
|
||||
}
|
||||
else
|
||||
{
|
||||
Cba_ObjAlloc( p, pGia && Gia_ObjFaninC0(pObj) ? CBA_BOX_CT : CBA_BOX_CF, -1 );
|
||||
}
|
||||
iObj = Cba_ObjAlloc( p, CBA_OBJ_BO, -1 );
|
||||
Cba_ObjSetFanin( p, iTerm, iObj );
|
||||
}
|
||||
void Cba_NtkInsertGia( Cba_Man_t * p, Gia_Man_t * pGia )
|
||||
{
|
||||
Cba_Ntk_t * pNtk, * pRoot = Cba_ManRoot( p );
|
||||
int i, j, k, iBox, iTerm, Count = 0;
|
||||
Gia_Obj_t * pObj;
|
||||
|
||||
Gia_ManConst0(pGia)->Value = ~0;
|
||||
Gia_ManForEachPi( pGia, pObj, i )
|
||||
pObj->Value = Cba_NtkPi( pRoot, i );
|
||||
Gia_ManForEachAnd( pGia, pObj, i )
|
||||
{
|
||||
if ( Gia_ObjIsBuf(pObj) )
|
||||
{
|
||||
pNtk = Cba_ManNtk( p, Vec_IntEntry(&p->vBuf2RootNtk, Count) );
|
||||
iTerm = Vec_IntEntry( &p->vBuf2RootObj, Count );
|
||||
assert( Cba_ObjIsCo(pNtk, iTerm) );
|
||||
if ( Cba_ObjFanin(pNtk, iTerm) == -1 ) // not a feedthrough
|
||||
Cba_NtkCreateAndConnectBuffer( pGia, pObj, pNtk, iTerm );
|
||||
// prepare leaf
|
||||
pObj->Value = Vec_IntEntry( &p->vBuf2LeafObj, Count++ );
|
||||
}
|
||||
else
|
||||
{
|
||||
int iLit0 = Gia_ObjFanin0(pObj)->Value;
|
||||
int iLit1 = Gia_ObjFanin1(pObj)->Value;
|
||||
Cba_ObjType_t Type;
|
||||
pNtk = Cba_ManNtk( p, pObj->Value );
|
||||
if ( Gia_ObjFaninC0(pObj) && Gia_ObjFaninC1(pObj) )
|
||||
Type = CBA_BOX_NOR;
|
||||
else if ( Gia_ObjFaninC1(pObj) )
|
||||
Type = CBA_BOX_SHARP;
|
||||
else if ( Gia_ObjFaninC0(pObj) )
|
||||
{
|
||||
Type = CBA_BOX_SHARP;
|
||||
ABC_SWAP( int, iLit0, iLit1 );
|
||||
}
|
||||
else
|
||||
Type = CBA_BOX_AND;
|
||||
// create box
|
||||
iTerm = Cba_ObjAlloc( pNtk, CBA_OBJ_BI, iLit1 );
|
||||
iTerm = Cba_ObjAlloc( pNtk, CBA_OBJ_BI, iLit0 );
|
||||
Cba_ObjAlloc( pNtk, Type, -1 );
|
||||
pObj->Value = Cba_ObjAlloc( pNtk, CBA_OBJ_BO, -1 );
|
||||
}
|
||||
}
|
||||
assert( Count == Gia_ManBufNum(pGia) );
|
||||
|
||||
// create constant 0 drivers for COs without barbufs
|
||||
Cba_ManForEachNtk( p, pNtk, i )
|
||||
{
|
||||
Cba_NtkForEachBox( pNtk, iBox )
|
||||
Cba_BoxForEachBi( pNtk, iBox, iTerm, j )
|
||||
if ( Cba_ObjFanin(pNtk, iTerm) == -1 )
|
||||
Cba_NtkCreateAndConnectBuffer( NULL, NULL, pNtk, iTerm );
|
||||
Cba_NtkForEachPo( pNtk, iTerm, k )
|
||||
if ( pNtk != pRoot && Cba_ObjFanin(pNtk, iTerm) == -1 )
|
||||
Cba_NtkCreateAndConnectBuffer( NULL, NULL, pNtk, iTerm );
|
||||
}
|
||||
// create node and connect POs
|
||||
Gia_ManForEachPo( pGia, pObj, i )
|
||||
if ( Cba_ObjFanin(pRoot, Cba_NtkPo(pRoot, i)) == -1 ) // not a feedthrough
|
||||
Cba_NtkCreateAndConnectBuffer( pGia, pObj, pRoot, Cba_NtkPo(pRoot, i) );
|
||||
}
|
||||
Cba_Man_t * Cba_ManInsertGia( Cba_Man_t * p, Gia_Man_t * pGia )
|
||||
{
|
||||
Cba_Man_t * pNew = Cba_ManDupUserBoxes( p );
|
||||
Cba_ManMarkNodesGia( p, pGia );
|
||||
Cba_ManRemapBarbufs( pNew, p );
|
||||
Cba_NtkInsertGia( pNew, pGia );
|
||||
Cba_ManMoveNames( pNew, p );
|
||||
return pNew;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
Cba_Man_t * Cba_ManBlastTest( Cba_Man_t * p )
|
||||
{
|
||||
Gia_Man_t * pGia = Cba_ManExtract( p, 1, 0 );
|
||||
Cba_Man_t * pNew = Cba_ManInsertGia( p, pGia );
|
||||
Gia_ManStop( pGia );
|
||||
return pNew;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Mark each GIA node with the network it belongs to.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
static inline int Abc_NodeIsSeriousGate( Abc_Obj_t * p )
|
||||
{
|
||||
return Abc_ObjIsNode(p) && Abc_ObjFaninNum(p) > 0 && !Abc_ObjIsBarBuf(p);
|
||||
}
|
||||
void Cba_ManMarkNodesAbc( Cba_Man_t * p, Abc_Ntk_t * pNtk )
|
||||
{
|
||||
Abc_Obj_t * pObj, * pFanin; int i, k, Count = 0;
|
||||
assert( Vec_IntSize(&p->vBuf2LeafNtk) == pNtk->nBarBufs2 );
|
||||
Abc_NtkForEachPi( pNtk, pObj, i )
|
||||
pObj->iTemp = 1;
|
||||
Abc_NtkForEachNode( pNtk, pObj, i )
|
||||
{
|
||||
if ( Abc_ObjIsBarBuf(pObj) )
|
||||
pObj->iTemp = Vec_IntEntry( &p->vBuf2LeafNtk, Count++ );
|
||||
else if ( Abc_NodeIsSeriousGate(pObj) )
|
||||
{
|
||||
pObj->iTemp = Abc_ObjFanin0(pObj)->iTemp;
|
||||
Abc_ObjForEachFanin( pObj, pFanin, k )
|
||||
assert( pObj->iTemp == pFanin->iTemp );
|
||||
}
|
||||
}
|
||||
Abc_NtkForEachPo( pNtk, pObj, i )
|
||||
{
|
||||
if ( !Abc_NodeIsSeriousGate(Abc_ObjFanin0(pObj)) )
|
||||
continue;
|
||||
assert( Abc_ObjFanin0(pObj)->iTemp == 1 );
|
||||
pObj->iTemp = Abc_ObjFanin0(pObj)->iTemp;
|
||||
}
|
||||
assert( Count == pNtk->nBarBufs2 );
|
||||
}
|
||||
void Cba_NtkCreateOrConnectFanin( Abc_Obj_t * pFanin, Cba_Ntk_t * p, int iTerm )
|
||||
{
|
||||
int iObj;
|
||||
if ( pFanin && Abc_NodeIsSeriousGate(pFanin) )//&& Cba_ObjName(p, pFanin->iTemp) == -1 ) // gate without name
|
||||
{
|
||||
iObj = pFanin->iTemp;
|
||||
}
|
||||
else if ( pFanin && (Abc_ObjIsPi(pFanin) || Abc_ObjIsBarBuf(pFanin) || Abc_NodeIsSeriousGate(pFanin)) ) // PI/BO or gate with name
|
||||
{
|
||||
iObj = Cba_ObjAlloc( p, CBA_OBJ_BI, pFanin->iTemp );
|
||||
Cba_ObjAlloc( p, CBA_BOX_GATE, p->pDesign->ElemGates[2] ); // buffer
|
||||
iObj = Cba_ObjAlloc( p, CBA_OBJ_BO, -1 );
|
||||
}
|
||||
else
|
||||
{
|
||||
assert( !pFanin || Abc_NodeIsConst0(pFanin) || Abc_NodeIsConst1(pFanin) );
|
||||
Cba_ObjAlloc( p, CBA_BOX_GATE, p->pDesign->ElemGates[(pFanin && Abc_NodeIsConst1(pFanin))] ); // const 0/1
|
||||
iObj = Cba_ObjAlloc( p, CBA_OBJ_BO, -1 );
|
||||
}
|
||||
Cba_ObjSetFanin( p, iTerm, iObj );
|
||||
}
|
||||
void Cba_NtkPrepareLibrary( Cba_Man_t * p, Mio_Library_t * pLib )
|
||||
{
|
||||
Mio_Gate_t * pGate;
|
||||
Mio_Gate_t * pGate0 = Mio_LibraryReadConst0( pLib );
|
||||
Mio_Gate_t * pGate1 = Mio_LibraryReadConst1( pLib );
|
||||
Mio_Gate_t * pGate2 = Mio_LibraryReadBuf( pLib );
|
||||
if ( !pGate0 || !pGate1 || !pGate2 )
|
||||
{
|
||||
printf( "The library does not have one of the elementary gates.\n" );
|
||||
return;
|
||||
}
|
||||
p->ElemGates[0] = Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate0), NULL );
|
||||
p->ElemGates[1] = Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate1), NULL );
|
||||
p->ElemGates[2] = Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate2), NULL );
|
||||
Mio_LibraryForEachGate( pLib, pGate )
|
||||
if ( pGate != pGate0 && pGate != pGate1 && pGate != pGate2 )
|
||||
Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate), NULL );
|
||||
assert( Abc_NamObjNumMax(p->pMods) > 1 );
|
||||
}
|
||||
int Cba_NtkBuildLibrary( Cba_Man_t * p )
|
||||
{
|
||||
int RetValue = 1;
|
||||
Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen();
|
||||
if ( pLib == NULL )
|
||||
printf( "The standard cell library is not available.\n" ), RetValue = 0;
|
||||
else
|
||||
Cba_NtkPrepareLibrary( p, pLib );
|
||||
p->pMioLib = pLib;
|
||||
return RetValue;
|
||||
}
|
||||
void Cba_NtkInsertNtk( Cba_Man_t * p, Abc_Ntk_t * pNtk )
|
||||
{
|
||||
Cba_Ntk_t * pCbaNtk, * pRoot = Cba_ManRoot( p );
|
||||
int i, j, k, iBox, iTerm, Count = 0;
|
||||
Abc_Obj_t * pObj;
|
||||
assert( Abc_NtkHasMapping(pNtk) );
|
||||
Cba_NtkPrepareLibrary( p, (Mio_Library_t *)pNtk->pManFunc );
|
||||
p->pMioLib = pNtk->pManFunc;
|
||||
|
||||
Abc_NtkForEachPi( pNtk, pObj, i )
|
||||
pObj->iTemp = Cba_NtkPi( pRoot, i );
|
||||
Abc_NtkForEachNode( pNtk, pObj, i )
|
||||
{
|
||||
if ( Abc_ObjIsBarBuf(pObj) )
|
||||
{
|
||||
pCbaNtk = Cba_ManNtk( p, Vec_IntEntry(&p->vBuf2RootNtk, Count) );
|
||||
iTerm = Vec_IntEntry( &p->vBuf2RootObj, Count );
|
||||
assert( Cba_ObjIsCo(pCbaNtk, iTerm) );
|
||||
if ( Cba_ObjFanin(pCbaNtk, iTerm) == -1 ) // not a feedthrough
|
||||
Cba_NtkCreateOrConnectFanin( Abc_ObjFanin0(pObj), pCbaNtk, iTerm );
|
||||
// prepare leaf
|
||||
pObj->iTemp = Vec_IntEntry( &p->vBuf2LeafObj, Count++ );
|
||||
}
|
||||
else if ( Abc_NodeIsSeriousGate(pObj) )
|
||||
{
|
||||
pCbaNtk = Cba_ManNtk( p, pObj->iTemp );
|
||||
for ( k = Abc_ObjFaninNum(pObj)-1; k >= 0; k-- )
|
||||
iTerm = Cba_ObjAlloc( pCbaNtk, CBA_OBJ_BI, Abc_ObjFanin(pObj, k)->iTemp );
|
||||
Cba_ObjAlloc( pCbaNtk, CBA_BOX_GATE, Abc_NamStrFind(p->pMods, Mio_GateReadName((Mio_Gate_t *)pObj->pData)) );
|
||||
pObj->iTemp = Cba_ObjAlloc( pCbaNtk, CBA_OBJ_BO, -1 );
|
||||
}
|
||||
}
|
||||
assert( Count == pNtk->nBarBufs2 );
|
||||
|
||||
// create constant 0 drivers for COs without barbufs
|
||||
Cba_ManForEachNtk( p, pCbaNtk, i )
|
||||
{
|
||||
Cba_NtkForEachBox( pCbaNtk, iBox )
|
||||
Cba_BoxForEachBi( pCbaNtk, iBox, iTerm, j )
|
||||
if ( Cba_ObjFanin(pCbaNtk, iTerm) == -1 )
|
||||
Cba_NtkCreateOrConnectFanin( NULL, pCbaNtk, iTerm );
|
||||
Cba_NtkForEachPo( pCbaNtk, iTerm, k )
|
||||
if ( pCbaNtk != pRoot && Cba_ObjFanin(pCbaNtk, iTerm) == -1 )
|
||||
Cba_NtkCreateOrConnectFanin( NULL, pCbaNtk, iTerm );
|
||||
}
|
||||
// create node and connect POs
|
||||
Abc_NtkForEachPo( pNtk, pObj, i )
|
||||
if ( Cba_ObjFanin(pRoot, Cba_NtkPo(pRoot, i)) == -1 ) // not a feedthrough
|
||||
Cba_NtkCreateOrConnectFanin( Abc_ObjFanin0(pObj), pRoot, Cba_NtkPo(pRoot, i) );
|
||||
}
|
||||
void * Cba_ManInsertAbc( Cba_Man_t * p, void * pAbc )
|
||||
{
|
||||
Abc_Ntk_t * pNtk = (Abc_Ntk_t *)pAbc;
|
||||
Cba_Man_t * pNew = Cba_ManDupUserBoxes( p );
|
||||
Cba_ManMarkNodesAbc( p, pNtk );
|
||||
Cba_ManRemapBarbufs( pNew, p );
|
||||
Cba_NtkInsertNtk( pNew, pNtk );
|
||||
Cba_ManMoveNames( pNew, p );
|
||||
return pNew;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -1,20 +1,20 @@
|
|||
/**CFile****************************************************************
|
||||
|
||||
FileName [cbaCba.c]
|
||||
FileName [cba.c]
|
||||
|
||||
SystemName [ABC: Logic synthesis and verification system.]
|
||||
|
||||
PackageName [Hierarchical word-level netlist.]
|
||||
PackageName [Verilog parser.]
|
||||
|
||||
Synopsis [Verilog parser.]
|
||||
Synopsis [Parses several flavors of word-level Verilog.]
|
||||
|
||||
Author [Alan Mishchenko]
|
||||
|
||||
Affiliation [UC Berkeley]
|
||||
|
||||
Date [Ver. 1.0. Started - November 29, 2014.]
|
||||
Date [Ver. 1.0. Started - July 21, 2015.]
|
||||
|
||||
Revision [$Id: cbaCba.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
|
||||
Revision [$Id: cba.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
|
||||
|
||||
***********************************************************************/
|
||||
|
||||
|
|
@ -30,10 +30,9 @@ ABC_NAMESPACE_IMPL_START
|
|||
/// FUNCTION DEFINITIONS ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Read CBA.]
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
|
|
@ -42,252 +41,7 @@ ABC_NAMESPACE_IMPL_START
|
|||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
int CbaManReadCbaLine( Vec_Str_t * vOut, int * pPos, char * pBuffer, char * pLimit )
|
||||
{
|
||||
char c;
|
||||
while ( (c = Vec_StrEntry(vOut, (*pPos)++)) != '\n' && pBuffer < pLimit )
|
||||
*pBuffer++ = c;
|
||||
*pBuffer = 0;
|
||||
return pBuffer < pLimit;
|
||||
}
|
||||
int CbaManReadCbaNameAndNums( char * pBuffer, int * Num1, int * Num2, int * Num3, int * Num4 )
|
||||
{
|
||||
*Num1 = *Num2 = *Num3 = *Num4 = -1;
|
||||
// read name
|
||||
while ( *pBuffer && *pBuffer != ' ' )
|
||||
pBuffer++;
|
||||
if ( !*pBuffer )
|
||||
return 0;
|
||||
assert( *pBuffer == ' ' );
|
||||
*pBuffer = 0;
|
||||
// read Num1
|
||||
*Num1 = atoi(++pBuffer);
|
||||
while ( *pBuffer && *pBuffer != ' ' )
|
||||
pBuffer++;
|
||||
if ( !*pBuffer )
|
||||
return 0;
|
||||
// read Num2
|
||||
assert( *pBuffer == ' ' );
|
||||
*Num2 = atoi(++pBuffer);
|
||||
while ( *pBuffer && *pBuffer != ' ' )
|
||||
pBuffer++;
|
||||
if ( !*pBuffer )
|
||||
return 1;
|
||||
// read Num3
|
||||
assert( *pBuffer == ' ' );
|
||||
*Num3 = atoi(++pBuffer);
|
||||
while ( *pBuffer && *pBuffer != ' ' )
|
||||
pBuffer++;
|
||||
if ( !*pBuffer )
|
||||
return 1;
|
||||
// read Num4
|
||||
assert( *pBuffer == ' ' );
|
||||
*Num4 = atoi(++pBuffer);
|
||||
return 1;
|
||||
}
|
||||
void Cba_ManReadCbaVecStr( Vec_Str_t * vOut, int * pPos, Vec_Str_t * p, int nSize )
|
||||
{
|
||||
memcpy( Vec_StrArray(p), Vec_StrArray(vOut) + *pPos, nSize );
|
||||
*pPos += nSize;
|
||||
p->nSize = nSize;
|
||||
assert( Vec_StrSize(p) == Vec_StrCap(p) );
|
||||
}
|
||||
void Cba_ManReadCbaVecInt( Vec_Str_t * vOut, int * pPos, Vec_Int_t * p, int nSize )
|
||||
{
|
||||
memcpy( Vec_IntArray(p), Vec_StrArray(vOut) + *pPos, nSize );
|
||||
*pPos += nSize;
|
||||
p->nSize = nSize / 4;
|
||||
assert( Vec_IntSize(p) == Vec_IntCap(p) );
|
||||
}
|
||||
void Cba_ManReadCbaNtk( Vec_Str_t * vOut, int * pPos, Cba_Ntk_t * pNtk )
|
||||
{
|
||||
int i, Type;
|
||||
//char * pName; int iObj, NameId;
|
||||
Cba_ManReadCbaVecStr( vOut, pPos, &pNtk->vType, Cba_NtkObjNumAlloc(pNtk) );
|
||||
Cba_ManReadCbaVecInt( vOut, pPos, &pNtk->vFanin, 4 * Cba_NtkObjNumAlloc(pNtk) );
|
||||
Cba_ManReadCbaVecInt( vOut, pPos, &pNtk->vInfo, 12 * Cba_NtkInfoNumAlloc(pNtk) );
|
||||
Cba_NtkForEachObjType( pNtk, Type, i )
|
||||
{
|
||||
if ( Type == CBA_OBJ_PI )
|
||||
Vec_IntPush( &pNtk->vInputs, i );
|
||||
if ( Type == CBA_OBJ_PO )
|
||||
Vec_IntPush( &pNtk->vOutputs, i );
|
||||
}
|
||||
assert( Cba_NtkPiNum(pNtk) == Cba_NtkPiNumAlloc(pNtk) );
|
||||
assert( Cba_NtkPoNum(pNtk) == Cba_NtkPoNumAlloc(pNtk) );
|
||||
assert( Cba_NtkObjNum(pNtk) == Cba_NtkObjNumAlloc(pNtk) );
|
||||
assert( Cba_NtkInfoNum(pNtk) == Cba_NtkInfoNumAlloc(pNtk) );
|
||||
/*
|
||||
// read input/output/box names
|
||||
Cba_NtkForEachPiMain( pNtk, iObj, i )
|
||||
{
|
||||
pName = Vec_StrEntryP( vOut, Pos );
|
||||
NameId = Abc_NamStrFindOrAdd( p->pStrs, pName, NULL );
|
||||
Pos += strlen(pName) + 1;
|
||||
}
|
||||
Cba_NtkForEachPoMain( pNtk, iObj, i )
|
||||
{
|
||||
pName = Vec_StrEntryP( vOut, Pos );
|
||||
NameId = Abc_NamStrFindOrAdd( p->pStrs, pName, NULL );
|
||||
Pos += strlen(pName) + 1;
|
||||
}
|
||||
Cba_NtkForEachBox( pNtk, iObj )
|
||||
{
|
||||
pName = Vec_StrEntryP( vOut, Pos );
|
||||
NameId = Abc_NamStrFindOrAdd( p->pStrs, pName, NULL );
|
||||
Pos += strlen(pName) + 1;
|
||||
}
|
||||
*/
|
||||
}
|
||||
Cba_Man_t * Cba_ManReadCbaInt( Vec_Str_t * vOut )
|
||||
{
|
||||
Cba_Man_t * p;
|
||||
Cba_Ntk_t * pNtk;
|
||||
char Buffer[1000] = "#";
|
||||
int i, NameId, Pos = 0, nNtks, Num1, Num2, Num3, Num4;
|
||||
while ( Buffer[0] == '#' )
|
||||
if ( !CbaManReadCbaLine(vOut, &Pos, Buffer, Buffer+1000) )
|
||||
return NULL;
|
||||
if ( !CbaManReadCbaNameAndNums(Buffer, &nNtks, &Num2, &Num3, &Num4) )
|
||||
return NULL;
|
||||
// start manager
|
||||
assert( nNtks > 0 );
|
||||
p = Cba_ManAlloc( Buffer, nNtks );
|
||||
// start networks
|
||||
Cba_ManForEachNtk( p, pNtk, i )
|
||||
{
|
||||
if ( !CbaManReadCbaLine(vOut, &Pos, Buffer, Buffer+1000) )
|
||||
{
|
||||
Cba_ManFree( p );
|
||||
return NULL;
|
||||
}
|
||||
if ( !CbaManReadCbaNameAndNums(Buffer, &Num1, &Num2, &Num3, &Num4) )
|
||||
{
|
||||
Cba_ManFree( p );
|
||||
return NULL;
|
||||
}
|
||||
assert( Num1 >= 0 && Num2 >= 0 && Num3 >= 0 );
|
||||
NameId = Abc_NamStrFindOrAdd( p->pStrs, Buffer, NULL );
|
||||
Cba_NtkAlloc( pNtk, NameId, Num1, Num2, Num3 );
|
||||
Vec_IntFill( &pNtk->vInfo, 3 * Num4, -1 );
|
||||
}
|
||||
// read networks
|
||||
Cba_ManForEachNtk( p, pNtk, i )
|
||||
Cba_ManReadCbaNtk( vOut, &Pos, pNtk );
|
||||
assert( Cba_ManNtkNum(p) == nNtks );
|
||||
assert( Pos == Vec_StrSize(vOut) );
|
||||
return p;
|
||||
}
|
||||
Cba_Man_t * Cba_ManReadCba( char * pFileName )
|
||||
{
|
||||
Cba_Man_t * p;
|
||||
FILE * pFile;
|
||||
Vec_Str_t * vOut;
|
||||
int nFileSize;
|
||||
pFile = fopen( pFileName, "rb" );
|
||||
if ( pFile == NULL )
|
||||
{
|
||||
printf( "Cannot open file \"%s\" for reading.\n", pFileName );
|
||||
return NULL;
|
||||
}
|
||||
// get the file size, in bytes
|
||||
fseek( pFile, 0, SEEK_END );
|
||||
nFileSize = ftell( pFile );
|
||||
rewind( pFile );
|
||||
// load the contents
|
||||
vOut = Vec_StrAlloc( nFileSize );
|
||||
vOut->nSize = vOut->nCap;
|
||||
assert( nFileSize == Vec_StrSize(vOut) );
|
||||
nFileSize = fread( Vec_StrArray(vOut), 1, Vec_StrSize(vOut), pFile );
|
||||
assert( nFileSize == Vec_StrSize(vOut) );
|
||||
fclose( pFile );
|
||||
// read the networks
|
||||
p = Cba_ManReadCbaInt( vOut );
|
||||
if ( p != NULL )
|
||||
{
|
||||
ABC_FREE( p->pSpec );
|
||||
p->pSpec = Abc_UtilStrsav( pFileName );
|
||||
}
|
||||
Vec_StrFree( vOut );
|
||||
return p;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Write CBA.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Cba_ManWriteCbaNtk( Vec_Str_t * vOut, Cba_Ntk_t * pNtk )
|
||||
{
|
||||
//char * pName; int iObj, NameId;
|
||||
Vec_StrPushBuffer( vOut, (char *)Vec_StrArray(&pNtk->vType), Cba_NtkObjNum(pNtk) );
|
||||
Vec_StrPushBuffer( vOut, (char *)Vec_IntArray(&pNtk->vFanin), 4 * Cba_NtkObjNum(pNtk) );
|
||||
Vec_StrPushBuffer( vOut, (char *)Vec_IntArray(&pNtk->vInfo), 12 * Cba_NtkInfoNum(pNtk) );
|
||||
/*
|
||||
// write input/output/box names
|
||||
Cba_NtkForEachPiMain( pNtk, iObj, i )
|
||||
{
|
||||
pName = Cba_ObjNameStr( pNtk, iObj );
|
||||
Vec_StrPrintStr( vOut, pName );
|
||||
Vec_StrPush( vOut, '\0' );
|
||||
}
|
||||
Cba_NtkForEachPoMain( pNtk, iObj, i )
|
||||
{
|
||||
pName = Cba_ObjNameStr( pNtk, iObj );
|
||||
Vec_StrPrintStr( vOut, pName );
|
||||
Vec_StrPush( vOut, '\0' );
|
||||
}
|
||||
Cba_NtkForEachBox( pNtk, iObj )
|
||||
{
|
||||
pName = Cba_ObjNameStr( pNtk, iObj );
|
||||
Vec_StrPrintStr( vOut, pName );
|
||||
Vec_StrPush( vOut, '\0' );
|
||||
}
|
||||
*/
|
||||
}
|
||||
void Cba_ManWriteCbaInt( Vec_Str_t * vOut, Cba_Man_t * p )
|
||||
{
|
||||
char Buffer[1000];
|
||||
Cba_Ntk_t * pNtk; int i;
|
||||
sprintf( Buffer, "# Design \"%s\" written by ABC on %s\n", Cba_ManName(p), Extra_TimeStamp() );
|
||||
Vec_StrPrintStr( vOut, Buffer );
|
||||
// write short info
|
||||
sprintf( Buffer, "%s %d \n", Cba_ManName(p), Cba_ManNtkNum(p) );
|
||||
Vec_StrPrintStr( vOut, Buffer );
|
||||
Cba_ManForEachNtk( p, pNtk, i )
|
||||
{
|
||||
sprintf( Buffer, "%s %d %d %d %d \n", Cba_NtkName(pNtk),
|
||||
Cba_NtkPiNum(pNtk), Cba_NtkPoNum(pNtk), Cba_NtkObjNum(pNtk), Cba_NtkInfoNum(pNtk) );
|
||||
Vec_StrPrintStr( vOut, Buffer );
|
||||
}
|
||||
Cba_ManForEachNtk( p, pNtk, i )
|
||||
Cba_ManWriteCbaNtk( vOut, pNtk );
|
||||
}
|
||||
void Cba_ManWriteCba( char * pFileName, Cba_Man_t * p )
|
||||
{
|
||||
Vec_Str_t * vOut;
|
||||
assert( p->pMioLib == NULL );
|
||||
vOut = Vec_StrAlloc( 10000 );
|
||||
Cba_ManWriteCbaInt( vOut, p );
|
||||
if ( Vec_StrSize(vOut) > 0 )
|
||||
{
|
||||
FILE * pFile = fopen( pFileName, "wb" );
|
||||
if ( pFile == NULL )
|
||||
printf( "Cannot open file \"%s\" for writing.\n", pFileName );
|
||||
else
|
||||
{
|
||||
fwrite( Vec_StrArray(vOut), 1, Vec_StrSize(vOut), pFile );
|
||||
fclose( pFile );
|
||||
}
|
||||
}
|
||||
Vec_StrFree( vOut );
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
|
|
|
|||
|
|
@ -45,48 +45,6 @@ static inline void Cba_AbcUpdateMan( Abc_Frame_t * pAbc, Cba_Man_t * p )
|
|||
/// FUNCTION DEFINITIONS ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**Function********************************************************************
|
||||
|
||||
Synopsis [Accessing current Cba_Ntk_t.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
******************************************************************************/
|
||||
void Abc_FrameImportPtr( Vec_Ptr_t * vPtr )
|
||||
{
|
||||
Cba_Man_t * p;
|
||||
if ( Abc_FrameGetGlobalFrame() == NULL )
|
||||
{
|
||||
printf( "ABC framework is not started.\n" );
|
||||
return;
|
||||
}
|
||||
p = Cba_PtrTransformToCba( vPtr );
|
||||
if ( p == NULL )
|
||||
printf( "Converting from Ptr failed.\n" );
|
||||
Cba_AbcUpdateMan( Abc_FrameGetGlobalFrame(), p );
|
||||
}
|
||||
Vec_Ptr_t * Abc_FrameExportPtr()
|
||||
{
|
||||
Vec_Ptr_t * vPtr;
|
||||
Cba_Man_t * p;
|
||||
if ( Abc_FrameGetGlobalFrame() == NULL )
|
||||
{
|
||||
printf( "ABC framework is not started.\n" );
|
||||
return NULL;
|
||||
}
|
||||
p = Cba_AbcGetMan( Abc_FrameGetGlobalFrame() );
|
||||
if ( p == NULL )
|
||||
printf( "There is no CBA design present.\n" );
|
||||
vPtr = Cba_PtrDeriveFromCba( p );
|
||||
if ( vPtr == NULL )
|
||||
printf( "Converting to Ptr has failed.\n" );
|
||||
return vPtr;
|
||||
}
|
||||
|
||||
/**Function********************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
|
@ -181,6 +139,8 @@ int Cba_CommandRead( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
return 0;
|
||||
}
|
||||
fclose( pFile );
|
||||
|
||||
#if 0
|
||||
// perform reading
|
||||
if ( fUseAbc || fUsePtr )
|
||||
{
|
||||
|
|
@ -230,6 +190,8 @@ int Cba_CommandRead( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
return 0;
|
||||
}
|
||||
Cba_AbcUpdateMan( pAbc, p );
|
||||
|
||||
#endif
|
||||
return 0;
|
||||
usage:
|
||||
Abc_Print( -2, "usage: @read [-apvh] <file_name>\n" );
|
||||
|
|
@ -284,6 +246,8 @@ int Cba_CommandWrite( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
Abc_Print( 1, "Cba_CommandWrite(): There is no current design.\n" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
if ( argc == globalUtilOptind + 1 )
|
||||
pFileName = argv[globalUtilOptind];
|
||||
else if ( argc == globalUtilOptind && p )
|
||||
|
|
@ -319,6 +283,8 @@ int Cba_CommandWrite( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
printf( "Unrecognized output file extension.\n" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
return 0;
|
||||
usage:
|
||||
Abc_Print( -2, "usage: @write [-apvh]\n" );
|
||||
|
|
@ -376,7 +342,11 @@ int Cba_CommandPs( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
Abc_Print( 1, "Cba_CommandPs(): There is no current design.\n" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
Cba_ManPrintStats( p, nModules, fVerbose );
|
||||
|
||||
#endif
|
||||
return 0;
|
||||
usage:
|
||||
Abc_Print( -2, "usage: @ps [-M num] [-vh]\n" );
|
||||
|
|
@ -425,6 +395,8 @@ int Cba_CommandPut( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
Abc_Print( 1, "Cba_CommandPut(): There is no current design.\n" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
pGia = Cba_ManExtract( p, fBarBufs, fVerbose );
|
||||
if ( pGia == NULL )
|
||||
{
|
||||
|
|
@ -432,6 +404,8 @@ int Cba_CommandPut( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
return 0;
|
||||
}
|
||||
Abc_FrameUpdateGia( pAbc, pGia );
|
||||
|
||||
#endif
|
||||
return 0;
|
||||
usage:
|
||||
Abc_Print( -2, "usage: @put [-bvh]\n" );
|
||||
|
|
@ -479,6 +453,8 @@ int Cba_CommandGet( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
Abc_Print( 1, "Cba_CommandGet(): There is no current design.\n" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
if ( fMapped )
|
||||
{
|
||||
if ( pAbc->pNtkCur == NULL )
|
||||
|
|
@ -498,10 +474,12 @@ int Cba_CommandGet( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
pNew = Cba_ManInsertGia( p, pAbc->pGia );
|
||||
}
|
||||
Cba_AbcUpdateMan( pAbc, pNew );
|
||||
|
||||
#endif
|
||||
return 0;
|
||||
usage:
|
||||
Abc_Print( -2, "usage: @get [-mvh]\n" );
|
||||
Abc_Print( -2, "\t inserts AIG or mapped network into the hierarchical design\n" );
|
||||
Abc_Print( -2, "\t extracts AIG or mapped network into the hierarchical design\n" );
|
||||
Abc_Print( -2, "\t-m : toggle using mapped network from main-space [default = %s]\n", fMapped? "yes": "no" );
|
||||
Abc_Print( -2, "\t-v : toggle printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
|
||||
Abc_Print( -2, "\t-h : print the command usage\n");
|
||||
|
|
@ -542,8 +520,12 @@ int Cba_CommandClp( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
Abc_Print( 1, "Cba_CommandGet(): There is no current design.\n" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
pNew = Cba_ManCollapse( p );
|
||||
Cba_AbcUpdateMan( pAbc, pNew );
|
||||
|
||||
#endif
|
||||
return 0;
|
||||
usage:
|
||||
Abc_Print( -2, "usage: @clp [-vh]\n" );
|
||||
|
|
@ -593,6 +575,8 @@ int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
Abc_Print( 1, "Cba_CommandCec(): There is no current design.\n" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
pArgvNew = argv + globalUtilOptind;
|
||||
nArgcNew = argc - globalUtilOptind;
|
||||
if ( nArgcNew != 1 )
|
||||
|
|
@ -658,6 +642,8 @@ int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
}
|
||||
Gia_ManStop( pFirst );
|
||||
Gia_ManStop( pSecond );
|
||||
|
||||
#endif
|
||||
return 0;
|
||||
usage:
|
||||
Abc_Print( -2, "usage: @cec [-vh]\n" );
|
||||
|
|
@ -680,10 +666,7 @@ usage:
|
|||
******************************************************************************/
|
||||
int Cba_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
|
||||
{
|
||||
extern void Prs_ManReadBlifTest();
|
||||
extern void Prs_ManReadVerilogTest();
|
||||
extern void Prs_SmtReadSmtTest();
|
||||
//Cba_Man_t * p = Cba_AbcGetMan(pAbc);
|
||||
Cba_Man_t * p = Cba_AbcGetMan(pAbc);
|
||||
int c, fVerbose = 0;
|
||||
Extra_UtilGetoptReset();
|
||||
while ( ( c = Extra_UtilGetopt( argc, argv, "vh" ) ) != EOF )
|
||||
|
|
@ -699,16 +682,11 @@ int Cba_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
goto usage;
|
||||
}
|
||||
}
|
||||
/*
|
||||
if ( p == NULL )
|
||||
{
|
||||
Abc_Print( 1, "Cba_CommandTest(): There is no current design.\n" );
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
//Cba_PtrTransformTestTest();
|
||||
//Prs_ManReadVerilogTest();
|
||||
//Prs_SmtReadSmtTest();
|
||||
return 0;
|
||||
usage:
|
||||
Abc_Print( -2, "usage: @test [-vh]\n" );
|
||||
|
|
|
|||
|
|
@ -1,20 +1,20 @@
|
|||
/**CFile****************************************************************
|
||||
|
||||
FileName [cbaNtk.c]
|
||||
FileName [cba.c]
|
||||
|
||||
SystemName [ABC: Logic synthesis and verification system.]
|
||||
|
||||
PackageName [Hierarchical word-level netlist.]
|
||||
PackageName [Verilog parser.]
|
||||
|
||||
Synopsis [Netlist manipulation.]
|
||||
Synopsis [Parses several flavors of word-level Verilog.]
|
||||
|
||||
Author [Alan Mishchenko]
|
||||
|
||||
Affiliation [UC Berkeley]
|
||||
|
||||
Date [Ver. 1.0. Started - November 29, 2014.]
|
||||
Date [Ver. 1.0. Started - July 21, 2015.]
|
||||
|
||||
Revision [$Id: cbaNtk.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
|
||||
Revision [$Id: cba.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
|
||||
|
||||
***********************************************************************/
|
||||
|
||||
|
|
@ -26,489 +26,10 @@ ABC_NAMESPACE_IMPL_START
|
|||
/// DECLARATIONS ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
typedef struct Cba_Pair_t_ Cba_Pair_t;
|
||||
struct Cba_Pair_t_
|
||||
{
|
||||
Cba_ObjType_t Type;
|
||||
char * pName;
|
||||
char * pSymb;
|
||||
};
|
||||
static const char * s_Pref = "ABC_";
|
||||
static Cba_Pair_t s_Types[CBA_BOX_UNKNOWN] =
|
||||
{
|
||||
{ CBA_OBJ_NONE, "NONE", NULL },
|
||||
{ CBA_OBJ_PI, "PI", NULL },
|
||||
{ CBA_OBJ_PO, "PO", NULL },
|
||||
{ CBA_OBJ_BI, "BI", NULL },
|
||||
{ CBA_OBJ_BO, "BO", NULL },
|
||||
{ CBA_OBJ_BOX, "BOX", NULL },
|
||||
|
||||
{ CBA_BOX_CF, "CF", "o" },
|
||||
{ CBA_BOX_CT, "CT", "o" },
|
||||
{ CBA_BOX_CX, "CX", "o" },
|
||||
{ CBA_BOX_CZ, "CZ", "o" },
|
||||
{ CBA_BOX_BUF, "BUF", "ao" },
|
||||
{ CBA_BOX_INV, "INV", "ao" },
|
||||
{ CBA_BOX_AND, "AND", "abo" },
|
||||
{ CBA_BOX_NAND, "NAND", "abo" },
|
||||
{ CBA_BOX_OR, "OR", "abo" },
|
||||
{ CBA_BOX_NOR, "NOR", "abo" },
|
||||
{ CBA_BOX_XOR, "XOR", "abo" },
|
||||
{ CBA_BOX_XNOR, "XNOR", "abo" },
|
||||
{ CBA_BOX_SHARP, "SHARP", "abo" },
|
||||
{ CBA_BOX_SHARPL, "SHARPL", "abo" },
|
||||
{ CBA_BOX_MUX, "MUX", "cabo" },
|
||||
{ CBA_BOX_MAJ, "MAJ", "abco" },
|
||||
|
||||
{ CBA_BOX_RAND, "RAND", "ao" },
|
||||
{ CBA_BOX_RNAND, "RNAND", "ao" },
|
||||
{ CBA_BOX_ROR, "ROR", "ao" },
|
||||
{ CBA_BOX_RNOR, "RNOR", "ao" },
|
||||
{ CBA_BOX_RXOR, "RXOR", "ao" },
|
||||
{ CBA_BOX_RXNOR, "RXNOR", "ao" },
|
||||
|
||||
{ CBA_BOX_LAND, "LAND", "abo" },
|
||||
{ CBA_BOX_LNAND, "LNAND", "abo" },
|
||||
{ CBA_BOX_LOR, "LOR", "abo" },
|
||||
{ CBA_BOX_LNOR, "LNOR", "abo" },
|
||||
{ CBA_BOX_LXOR, "LXOR", "abo" },
|
||||
{ CBA_BOX_LXNOR, "LXNOR", "abo" },
|
||||
|
||||
{ CBA_BOX_NMUX, "NMUX", "abo" },
|
||||
{ CBA_BOX_SEL, "SEL", "abo" },
|
||||
{ CBA_BOX_PSEL, "PSEL", "iabo" },
|
||||
{ CBA_BOX_ENC, "ENC", "ao" },
|
||||
{ CBA_BOX_PENC, "PENC", "ao" },
|
||||
{ CBA_BOX_DEC, "DEC", "ao" },
|
||||
{ CBA_BOX_EDEC, "EDEC", "abo" },
|
||||
|
||||
{ CBA_BOX_ADD, "ADD", "iabso" },
|
||||
{ CBA_BOX_SUB, "SUB", "abo" },
|
||||
{ CBA_BOX_MUL, "MUL", "abo" },
|
||||
{ CBA_BOX_DIV, "DIV", "abo" },
|
||||
{ CBA_BOX_MOD, "MOD", "abo" },
|
||||
{ CBA_BOX_REM, "REM", "abo" },
|
||||
{ CBA_BOX_POW, "POW", "abo" },
|
||||
{ CBA_BOX_MIN, "MIN", "ao" },
|
||||
{ CBA_BOX_ABS, "ABS", "ao" },
|
||||
|
||||
{ CBA_BOX_LTHAN, "LTHAN", "iabo" },
|
||||
{ CBA_BOX_LETHAN, "LETHAN", "abo" },
|
||||
{ CBA_BOX_METHAN, "METHAN", "abo" },
|
||||
{ CBA_BOX_MTHAN, "MTHAN", "abo" },
|
||||
{ CBA_BOX_EQU, "EQU", "abo" },
|
||||
{ CBA_BOX_NEQU, "NEQU", "abo" },
|
||||
|
||||
{ CBA_BOX_SHIL, "SHIL", "abo" },
|
||||
{ CBA_BOX_SHIR, "SHIR", "abo" },
|
||||
{ CBA_BOX_ROTL, "ROTL", "abo" },
|
||||
{ CBA_BOX_ROTR, "ROTR", "abo" },
|
||||
|
||||
{ CBA_BOX_GATE, "GATE", "io" },
|
||||
{ CBA_BOX_LUT, "LUT", "io" },
|
||||
{ CBA_BOX_ASSIGN, "ASSIGN", "abo" },
|
||||
|
||||
{ CBA_BOX_TRI, "TRI", "abo" },
|
||||
{ CBA_BOX_RAM, "RAM", "eadro" },
|
||||
{ CBA_BOX_RAMR, "RAMR", "eamo" },
|
||||
{ CBA_BOX_RAMW, "RAMW", "eado" },
|
||||
{ CBA_BOX_RAMWC, "RAMWC", "ceado" },
|
||||
{ CBA_BOX_RAMBOX, "RAMBOX", "io" },
|
||||
|
||||
{ CBA_BOX_LATCH, "LATCH", "dvsgq" },
|
||||
{ CBA_BOX_LATCHRS, "LATCHRS", "dsrgq" },
|
||||
{ CBA_BOX_DFF, "DFF", "dvscq" },
|
||||
{ CBA_BOX_DFFRS, "DFFRS", "dsrcq" }
|
||||
};
|
||||
static inline int Cba_GetTypeId( Cba_ObjType_t Type )
|
||||
{
|
||||
int i;
|
||||
for ( i = 1; i < CBA_BOX_UNKNOWN; i++ )
|
||||
if ( s_Types[i].Type == Type )
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
void Cba_ManSetupTypes( char ** pNames, char ** pSymbs )
|
||||
{
|
||||
Cba_ObjType_t Type;
|
||||
for ( Type = 1; Type < CBA_BOX_UNKNOWN; Type++ )
|
||||
{
|
||||
int Id = Cba_GetTypeId( Type );
|
||||
pNames[Type] = s_Types[Id].pName;
|
||||
pSymbs[Type] = s_Types[Id].pSymb;
|
||||
}
|
||||
}
|
||||
|
||||
char * Cba_NtkGenerateName( Cba_Ntk_t * p, Cba_ObjType_t Type, Vec_Int_t * vBits )
|
||||
{
|
||||
static char Buffer[100];
|
||||
char * pTemp; int i, Bits;
|
||||
char * pName = Cba_ManPrimName( p->pDesign, Type );
|
||||
char * pSymb = Cba_ManPrimSymb( p->pDesign, Type );
|
||||
assert( Vec_IntSize(vBits) == (int)strlen(pSymb) );
|
||||
sprintf( Buffer, "%s%s_", s_Pref, pName );
|
||||
pTemp = Buffer + strlen(Buffer);
|
||||
Vec_IntForEachEntry( vBits, Bits, i )
|
||||
{
|
||||
sprintf( pTemp, "%c%d", pSymb[i], Bits );
|
||||
pTemp += strlen(pTemp);
|
||||
}
|
||||
//Vec_IntPrint( vBits );
|
||||
//printf( "%s\n", Buffer );
|
||||
return Buffer;
|
||||
}
|
||||
|
||||
Cba_ObjType_t Cba_NameToType( char * pName )
|
||||
{
|
||||
Cba_ObjType_t i;
|
||||
if ( strncmp(pName, s_Pref, strlen(s_Pref)) )
|
||||
return 0;
|
||||
pName += strlen(s_Pref);
|
||||
for ( i = 1; i < CBA_BOX_UNKNOWN; i++ )
|
||||
if ( !strncmp(pName, s_Types[i].pName, strlen(s_Types[i].pName)) )
|
||||
return s_Types[i].Type;
|
||||
return 0;
|
||||
}
|
||||
Vec_Int_t * Cba_NameToRanges( char * pName )
|
||||
{
|
||||
static Vec_Int_t Bits, * vBits = &Bits;
|
||||
static int pArray[10];
|
||||
char * pTemp;
|
||||
int Num = 0, Count = 0;
|
||||
// initialize array
|
||||
vBits->pArray = pArray;
|
||||
vBits->nSize = 0;
|
||||
vBits->nCap = 10;
|
||||
// check the name
|
||||
assert( !strncmp(pName, s_Pref, strlen(s_Pref)) );
|
||||
for ( pTemp = pName; *pTemp && !Cba_CharIsDigit(*pTemp); pTemp++ );
|
||||
assert( Cba_CharIsDigit(*pTemp) );
|
||||
for ( ; *pTemp; pTemp++ )
|
||||
{
|
||||
if ( Cba_CharIsDigit(*pTemp) )
|
||||
Num = 10 * Num + *pTemp - '0';
|
||||
else
|
||||
Vec_IntPush( vBits, Num ), Count += Num, Num = 0;
|
||||
}
|
||||
assert( Num > 0 );
|
||||
Vec_IntPush( vBits, Num ); Count += Num;
|
||||
assert( Vec_IntSize(vBits) <= 10 );
|
||||
return vBits;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// FUNCTION DEFINITIONS ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Replaces fanin iOld by iNew in all fanouts.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Cba_NtkUpdateFanout( Cba_Ntk_t * p, int iOld, int iNew )
|
||||
{
|
||||
int iCo;
|
||||
assert( Cba_ObjIsCi(p, iOld) );
|
||||
assert( Cba_ObjIsCi(p, iNew) );
|
||||
Cba_ObjForEachFanout( p, iOld, iCo )
|
||||
{
|
||||
assert( Cba_ObjFanin(p, iCo) == iOld );
|
||||
Cba_ObjCleanFanin( p, iCo );
|
||||
Cba_ObjSetFanin( p, iCo, iNew );
|
||||
}
|
||||
Cba_ObjSetFanout( p, iNew, Cba_ObjFanout(p, iOld) );
|
||||
Cba_ObjSetFanout( p, iOld, 0 );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Derives fanout.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Cba_NtkDeriveFanout( Cba_Ntk_t * p )
|
||||
{
|
||||
int iCi, iCo;
|
||||
assert( !Cba_NtkHasFanouts(p) );
|
||||
Cba_NtkStartFanouts( p );
|
||||
Cba_NtkForEachCo( p, iCo )
|
||||
{
|
||||
assert( !Cba_ObjNextFanout(p, iCo) );
|
||||
iCi = Cba_ObjFanin(p, iCo);
|
||||
if ( Cba_ObjFanout(p, iCi) )
|
||||
Cba_ObjSetNextFanout( p, Cba_ObjFanout(p, iCi), iCo );
|
||||
Cba_ObjSetFanout( p, iCi, iCo );
|
||||
}
|
||||
Cba_NtkForEachCo( p, iCo )
|
||||
if ( !Cba_ObjNextFanout(p, iCo) )
|
||||
Cba_ObjSetFanout( p, Cba_ObjFanin(p, iCo), iCo );
|
||||
}
|
||||
void Cba_ManDeriveFanout( Cba_Man_t * p )
|
||||
{
|
||||
Cba_Ntk_t * pNtk; int i;
|
||||
Cba_ManForEachNtk( p, pNtk, i )
|
||||
Cba_NtkDeriveFanout( pNtk );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Assigns word-level names.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
int Cba_ManAssignInternTwo( Cba_Ntk_t * p, int iNum, int nDigits, char * pPref, Vec_Int_t * vMap )
|
||||
{
|
||||
char Buffer[16]; int i, NameId = 0;
|
||||
for ( i = 0; !NameId || Vec_IntEntry(vMap, NameId); i++ )
|
||||
{
|
||||
if ( i == 0 )
|
||||
sprintf( Buffer, "%s%0*d", pPref, nDigits, iNum );
|
||||
else
|
||||
sprintf( Buffer, "%s%0*d_%d", pPref, nDigits, iNum, i );
|
||||
NameId = Abc_NamStrFindOrAdd( p->pDesign->pStrs, Buffer, NULL );
|
||||
}
|
||||
Vec_IntWriteEntry( vMap, NameId, 1 );
|
||||
return NameId;
|
||||
}
|
||||
int Cba_ManAssignCountNames( Cba_Ntk_t * p )
|
||||
{
|
||||
int i, iObj, iBox, Count = 0;
|
||||
Cba_NtkForEachPiMain( p, iObj, i )
|
||||
if ( !Cba_ObjNameInt(p, iObj) )
|
||||
Count++;
|
||||
Cba_NtkForEachBox( p, iBox )
|
||||
Cba_BoxForEachBoMain( p, iBox, iObj, i )
|
||||
if ( !Cba_ObjNameInt(p, iObj) )
|
||||
Count++;
|
||||
return Count;
|
||||
}
|
||||
void Cba_ManAssignInternWordNamesNtk( Cba_Ntk_t * p, Vec_Int_t * vMap )
|
||||
{
|
||||
int k, iObj, iTerm, iName = -1, iBit = -1;
|
||||
int nDigits, nPis = 0, nPos = 0, nNames = 1;
|
||||
// start names
|
||||
if ( !Cba_NtkHasNames(p) )
|
||||
Cba_NtkStartNames(p);
|
||||
nDigits = Abc_Base10Log( Cba_ManAssignCountNames(p) );
|
||||
// populate map with the currently used names
|
||||
Cba_NtkForEachCi( p, iObj )
|
||||
if ( Cba_ObjNameInt(p, iObj) )
|
||||
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 1 );
|
||||
Cba_NtkForEachBox( p, iObj )
|
||||
if ( Cba_ObjNameInt(p, iObj) )
|
||||
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 1 );
|
||||
// assign CI names
|
||||
Cba_NtkForEachCi( p, iObj )
|
||||
{
|
||||
if ( Cba_ObjNameInt(p, iObj) )
|
||||
{
|
||||
iName = -1;
|
||||
iBit = -1;
|
||||
continue;
|
||||
}
|
||||
if ( Cba_ObjBit(p, iObj) )
|
||||
{
|
||||
assert( iBit > 0 );
|
||||
Cba_ObjSetName( p, iObj, Abc_Var2Lit2(iBit++, CBA_NAME_INDEX) );
|
||||
}
|
||||
else
|
||||
{
|
||||
//int Type = Cba_ObjType(p, iObj);
|
||||
int Range = Cba_ObjIsPi(p, iObj) ? Cba_ObjPiRange(p, iObj) : Cba_BoxBoRange(p, iObj);
|
||||
iName = Cba_ManAssignInternTwo( p, nNames++, nDigits, (char*)(Cba_ObjIsPi(p, iObj) ? "i":"n"), vMap );
|
||||
if ( Range == 1 )
|
||||
Cba_ObjSetName( p, iObj, Abc_Var2Lit2(iName, CBA_NAME_BIN) );
|
||||
else
|
||||
Cba_ObjSetName( p, iObj, Abc_Var2Lit2(iName, CBA_NAME_WORD) );
|
||||
iBit = 1;
|
||||
}
|
||||
}
|
||||
// transfer names to the interface
|
||||
if ( Cba_NtkInfoNum(p) )
|
||||
{
|
||||
for ( k = 0; k < Cba_NtkInfoNum(p); k++ )
|
||||
{
|
||||
//char * pName = Cba_NtkName(p);
|
||||
if ( Cba_NtkInfoType(p, k) == 1 ) // PI
|
||||
{
|
||||
iObj = Cba_NtkPi(p, nPis);
|
||||
assert( !Cba_ObjBit(p, iObj) );
|
||||
assert( Cba_ObjNameType(p, iObj) <= CBA_NAME_WORD );
|
||||
Cba_NtkSetInfoName( p, k, Abc_Var2Lit2(Cba_ObjNameId(p, iObj), 1) );
|
||||
nPis += Cba_NtkInfoRange(p, k);
|
||||
}
|
||||
else if ( Cba_NtkInfoType(p, k) == 2 ) // PO
|
||||
{
|
||||
iObj = Cba_NtkPo(p, nPos);
|
||||
assert( !Cba_ObjBit(p, iObj) );
|
||||
iObj = Cba_ObjFanin(p, iObj);
|
||||
assert( Cba_ObjNameType(p, iObj) <= CBA_NAME_WORD );
|
||||
Cba_NtkSetInfoName( p, k, Abc_Var2Lit2(Cba_ObjNameId(p, iObj), 2) );
|
||||
nPos += Cba_NtkInfoRange(p, k);
|
||||
}
|
||||
else assert( 0 );
|
||||
}
|
||||
assert( nPis == Cba_NtkPiNum(p) );
|
||||
assert( nPos == Cba_NtkPoNum(p) );
|
||||
}
|
||||
// assign instance names
|
||||
nDigits = Abc_Base10Log( Cba_NtkObjNum(p) );
|
||||
Cba_NtkForEachBox( p, iObj )
|
||||
if ( !Cba_ObjNameInt(p, iObj) )
|
||||
{
|
||||
iName = Cba_ManAssignInternTwo( p, iObj, nDigits, "g", vMap );
|
||||
Cba_ObjSetName( p, iObj, Abc_Var2Lit2(iName, CBA_NAME_BIN) );
|
||||
}
|
||||
// unmark all names
|
||||
Cba_NtkForEachPi( p, iObj, k )
|
||||
if ( Cba_ObjNameType(p, iObj) <= CBA_NAME_WORD )
|
||||
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 0 );
|
||||
Cba_NtkForEachBox( p, iObj )
|
||||
{
|
||||
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 0 );
|
||||
Cba_BoxForEachBo( p, iObj, iTerm, k )
|
||||
if ( Cba_ObjNameType(p, iTerm) <= CBA_NAME_WORD )
|
||||
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iTerm), 0 );
|
||||
}
|
||||
// printf( "Generated %d word-level names.\n", nNames-1 );
|
||||
}
|
||||
void Cba_ManAssignInternWordNames( Cba_Man_t * p )
|
||||
{
|
||||
Vec_Int_t * vMap = Vec_IntStart( 2*Cba_ManObjNum(p) );
|
||||
Cba_Ntk_t * pNtk; int i;
|
||||
Cba_ManForEachNtk( p, pNtk, i )
|
||||
Cba_ManAssignInternWordNamesNtk( pNtk, vMap );
|
||||
assert( Vec_IntCountEntry(vMap, 0) == Vec_IntSize(vMap) );
|
||||
Vec_IntFree( vMap );
|
||||
}
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Count number of objects after collapsing.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
int Cba_ManClpObjNum_rec( Cba_Ntk_t * p )
|
||||
{
|
||||
int i, Counter = 0;
|
||||
if ( p->Count >= 0 )
|
||||
return p->Count;
|
||||
Cba_NtkForEachBox( p, i )
|
||||
Counter += Cba_ObjIsBoxUser(p, i) ? Cba_ManClpObjNum_rec( Cba_BoxNtk(p, i) ) + 3*Cba_BoxBoNum(p, i) : Cba_BoxSize(p, i);
|
||||
return (p->Count = Counter);
|
||||
}
|
||||
int Cba_ManClpObjNum( Cba_Man_t * p )
|
||||
{
|
||||
Cba_Ntk_t * pNtk; int i;
|
||||
Cba_ManForEachNtk( p, pNtk, i )
|
||||
pNtk->Count = -1;
|
||||
return Cba_NtkPioNum( Cba_ManRoot(p) ) + Cba_ManClpObjNum_rec( Cba_ManRoot(p) );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Collects boxes in the DFS order.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Cba_NtkDfs_rec( Cba_Ntk_t * p, int iObj, Vec_Int_t * vBoxes )
|
||||
{
|
||||
int k, iFanin;
|
||||
if ( Cba_ObjIsBo(p, iObj) == 1 )
|
||||
{
|
||||
Cba_NtkDfs_rec( p, Cba_ObjFanin(p, iObj), vBoxes );
|
||||
return;
|
||||
}
|
||||
assert( Cba_ObjIsPi(p, iObj) || Cba_ObjIsBox(p, iObj) );
|
||||
if ( Cba_ObjCopy(p, iObj) > 0 ) // visited
|
||||
return;
|
||||
Cba_ObjSetCopy( p, iObj, 1 );
|
||||
Cba_BoxForEachFanin( p, iObj, iFanin, k )
|
||||
Cba_NtkDfs_rec( p, iFanin, vBoxes );
|
||||
Vec_IntPush( vBoxes, iObj );
|
||||
}
|
||||
Vec_Int_t * Cba_NtkDfs( Cba_Ntk_t * p )
|
||||
{
|
||||
int i, iObj;
|
||||
Vec_Int_t * vBoxes = Vec_IntAlloc( Cba_NtkBoxNum(p) );
|
||||
Cba_NtkStartCopies( p ); // -1 = not visited; 1 = finished
|
||||
Cba_NtkForEachPi( p, iObj, i )
|
||||
Cba_ObjSetCopy( p, iObj, 1 );
|
||||
Cba_NtkForEachPo( p, iObj, i )
|
||||
Cba_NtkDfs_rec( p, Cba_ObjFanin(p, iObj), vBoxes );
|
||||
return vBoxes;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Collects user boxes in the DFS order.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
int Cba_NtkDfsUserBoxes_rec( Cba_Ntk_t * p, int iObj, Vec_Int_t * vBoxes )
|
||||
{
|
||||
int k, iFanin;
|
||||
assert( Cba_ObjIsBoxUser(p, iObj) );
|
||||
if ( Cba_ObjCopy(p, iObj) == 1 ) // visited
|
||||
return 1;
|
||||
if ( Cba_ObjCopy(p, iObj) == 0 ) // loop
|
||||
return 0;
|
||||
Cba_ObjSetCopy( p, iObj, 0 );
|
||||
Cba_BoxForEachFanin( p, iObj, iFanin, k )
|
||||
if ( Cba_ObjIsBo(p, iFanin) && Cba_ObjIsBoxUser(p, Cba_ObjFanin(p, iFanin)) )
|
||||
if ( !Cba_NtkDfsUserBoxes_rec( p, Cba_ObjFanin(p, iFanin), vBoxes ) )
|
||||
return 0;
|
||||
Vec_IntPush( vBoxes, iObj );
|
||||
Cba_ObjSetCopy( p, iObj, 1 );
|
||||
return 1;
|
||||
}
|
||||
int Cba_NtkDfsUserBoxes( Cba_Ntk_t * p )
|
||||
{
|
||||
int iObj;
|
||||
Cba_NtkStartCopies( p ); // -1 = not visited; 0 = on the path; 1 = finished
|
||||
Vec_IntClear( &p->vArray );
|
||||
Cba_NtkForEachBoxUser( p, iObj )
|
||||
if ( !Cba_NtkDfsUserBoxes_rec( p, iObj, &p->vArray ) )
|
||||
{
|
||||
printf( "Cyclic dependency of user boxes is detected.\n" );
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
|
@ -520,80 +41,6 @@ int Cba_NtkDfsUserBoxes( Cba_Ntk_t * p )
|
|||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Cba_NtkCollapse_rec( Cba_Ntk_t * pNew, Cba_Ntk_t * p, Vec_Int_t * vSigs )
|
||||
{
|
||||
int i, iObj, iObjNew, iTerm;
|
||||
Cba_NtkStartCopies( p );
|
||||
// set PI copies
|
||||
assert( Vec_IntSize(vSigs) == Cba_NtkPiNum(p) );
|
||||
Cba_NtkForEachPi( p, iObj, i )
|
||||
Cba_ObjSetCopy( p, iObj, Vec_IntEntry(vSigs, i) );
|
||||
// duplicate internal objects and create buffers for hierarchy instances
|
||||
Cba_NtkForEachBox( p, iObj )
|
||||
if ( Cba_ObjIsBoxPrim( p, iObj ) )
|
||||
Cba_BoxDup( pNew, p, iObj );
|
||||
else
|
||||
{
|
||||
Cba_BoxForEachBo( p, iObj, iTerm, i )
|
||||
{
|
||||
iObjNew = Cba_ObjAlloc( pNew, CBA_OBJ_BI, -1 );
|
||||
iObjNew = Cba_ObjAlloc( pNew, CBA_BOX_BUF, -1 ); // buffer
|
||||
iObjNew = Cba_ObjAlloc( pNew, CBA_OBJ_BO, -1 );
|
||||
Cba_ObjSetCopy( p, iTerm, iObjNew );
|
||||
}
|
||||
}
|
||||
// duplicate user modules and connect objects
|
||||
Cba_NtkForEachBox( p, iObj )
|
||||
if ( Cba_ObjIsBoxPrim( p, iObj ) )
|
||||
{
|
||||
Cba_BoxForEachBi( p, iObj, iTerm, i )
|
||||
Cba_ObjSetFanin( pNew, Cba_ObjCopy(p, iTerm), Cba_ObjCopy(p, Cba_ObjFanin(p, iTerm)) );
|
||||
}
|
||||
else
|
||||
{
|
||||
Vec_IntClear( vSigs );
|
||||
Cba_BoxForEachBi( p, iObj, iTerm, i )
|
||||
Vec_IntPush( vSigs, Cba_ObjCopy(p, Cba_ObjFanin(p, iTerm)) );
|
||||
Cba_NtkCollapse_rec( pNew, Cba_BoxNtk(p, iObj), vSigs );
|
||||
assert( Vec_IntSize(vSigs) == Cba_BoxBoNum(p, iObj) );
|
||||
Cba_BoxForEachBo( p, iObj, iTerm, i )
|
||||
Cba_ObjSetFanin( pNew, Cba_ObjCopy(p, iTerm)-2, Vec_IntEntry(vSigs, i) );
|
||||
}
|
||||
// collect POs
|
||||
Vec_IntClear( vSigs );
|
||||
Cba_NtkForEachPo( p, iObj, i )
|
||||
Vec_IntPush( vSigs, Cba_ObjCopy(p, Cba_ObjFanin(p, iObj)) );
|
||||
}
|
||||
Cba_Man_t * Cba_ManCollapse( Cba_Man_t * p )
|
||||
{
|
||||
int i, iObj;
|
||||
Vec_Int_t * vSigs = Vec_IntAlloc( 1000 );
|
||||
Cba_Man_t * pNew = Cba_ManStart( p, 1 );
|
||||
Cba_Ntk_t * pRoot = Cba_ManRoot( p );
|
||||
Cba_Ntk_t * pRootNew = Cba_ManRoot( pNew );
|
||||
Cba_NtkAlloc( pRootNew, Cba_NtkNameId(pRoot), Cba_NtkPiNum(pRoot), Cba_NtkPoNum(pRoot), Cba_ManClpObjNum(p) );
|
||||
if ( Vec_IntSize(&pRoot->vInfo) )
|
||||
Vec_IntAppend( &pRootNew->vInfo, &pRoot->vInfo );
|
||||
Cba_NtkForEachPi( pRoot, iObj, i )
|
||||
Vec_IntPush( vSigs, Cba_ObjAlloc(pRootNew, CBA_OBJ_PI, -1) );
|
||||
Cba_NtkCollapse_rec( pRootNew, pRoot, vSigs );
|
||||
assert( Vec_IntSize(vSigs) == Cba_NtkPoNum(pRoot) );
|
||||
Cba_NtkForEachPo( pRoot, iObj, i )
|
||||
Cba_ObjAlloc( pRootNew, CBA_OBJ_PO, Vec_IntEntry(vSigs, i) );
|
||||
assert( Cba_NtkObjNum(pRootNew) == Cba_NtkObjNumAlloc(pRootNew) );
|
||||
Vec_IntFree( vSigs );
|
||||
// transfer PI/PO names
|
||||
if ( Cba_NtkHasNames(pRoot) )
|
||||
{
|
||||
Cba_NtkStartNames( pRootNew );
|
||||
Cba_NtkForEachPi( pRoot, iObj, i )
|
||||
Cba_ObjSetName( pRootNew, Cba_NtkPi(pRootNew, i), Cba_ObjName(pRoot, iObj) );
|
||||
Cba_NtkForEachPoDriver( pRoot, iObj, i )
|
||||
if ( !Cba_ObjIsPi(pRoot, iObj) )
|
||||
Cba_ObjSetName( pRootNew, Cba_ObjCopy(pRoot, iObj), Cba_ObjName(pRoot, iObj) );
|
||||
}
|
||||
return pNew;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
|
|
|
|||
|
|
@ -288,6 +288,14 @@ static inline void Prs_NtkFree( Prs_Ntk_t * p )
|
|||
ABC_FREE( p );
|
||||
}
|
||||
|
||||
static inline void Prs_ManVecFree( Vec_Ptr_t * vPrs )
|
||||
{
|
||||
Prs_Ntk_t * pNtk; int i;
|
||||
Vec_PtrForEachEntry( Prs_Ntk_t *, vPrs, pNtk, i )
|
||||
Prs_NtkFree( pNtk );
|
||||
Vec_PtrFree( vPrs );
|
||||
}
|
||||
|
||||
static inline void Prs_ManFree( Prs_Man_t * p )
|
||||
{
|
||||
if ( p->pStrs )
|
||||
|
|
@ -333,6 +341,100 @@ static inline int Prs_ManMemory( Vec_Ptr_t * vPrs )
|
|||
}
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Other APIs.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
static inline Cba_ObjType_t Ptr_SopToType( char * pSop )
|
||||
{
|
||||
if ( !strcmp(pSop, " 0\n") ) return CBA_BOX_CF;
|
||||
if ( !strcmp(pSop, " 1\n") ) return CBA_BOX_CT;
|
||||
if ( !strcmp(pSop, "1 1\n") ) return CBA_BOX_BUF;
|
||||
if ( !strcmp(pSop, "0 1\n") ) return CBA_BOX_INV;
|
||||
if ( !strcmp(pSop, "11 1\n") ) return CBA_BOX_AND;
|
||||
if ( !strcmp(pSop, "00 1\n") ) return CBA_BOX_NOR;
|
||||
if ( !strcmp(pSop, "00 0\n") ) return CBA_BOX_OR;
|
||||
if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return CBA_BOX_OR;
|
||||
if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return CBA_BOX_OR;
|
||||
if ( !strcmp(pSop, "01 1\n10 1\n") ) return CBA_BOX_XOR;
|
||||
if ( !strcmp(pSop, "10 1\n01 1\n") ) return CBA_BOX_XOR;
|
||||
if ( !strcmp(pSop, "11 1\n00 1\n") ) return CBA_BOX_XNOR;
|
||||
if ( !strcmp(pSop, "00 1\n11 1\n") ) return CBA_BOX_XNOR;
|
||||
if ( !strcmp(pSop, "10 1\n") ) return CBA_BOX_SHARP;
|
||||
if ( !strcmp(pSop, "01 1\n") ) return CBA_BOX_SHARPL;
|
||||
assert( 0 );
|
||||
return CBA_OBJ_NONE;
|
||||
}
|
||||
static inline char * Ptr_SopToTypeName( char * pSop )
|
||||
{
|
||||
if ( !strcmp(pSop, " 0\n") ) return "CBA_BOX_C0";
|
||||
if ( !strcmp(pSop, " 1\n") ) return "CBA_BOX_C1";
|
||||
if ( !strcmp(pSop, "1 1\n") ) return "CBA_BOX_BUF";
|
||||
if ( !strcmp(pSop, "0 1\n") ) return "CBA_BOX_INV";
|
||||
if ( !strcmp(pSop, "11 1\n") ) return "CBA_BOX_AND";
|
||||
if ( !strcmp(pSop, "00 1\n") ) return "CBA_BOX_NOR";
|
||||
if ( !strcmp(pSop, "00 0\n") ) return "CBA_BOX_OR";
|
||||
if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return "CBA_BOX_OR";
|
||||
if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return "CBA_BOX_OR";
|
||||
if ( !strcmp(pSop, "01 1\n10 1\n") ) return "CBA_BOX_XOR";
|
||||
if ( !strcmp(pSop, "10 1\n01 1\n") ) return "CBA_BOX_XOR";
|
||||
if ( !strcmp(pSop, "11 1\n00 1\n") ) return "CBA_BOX_XNOR";
|
||||
if ( !strcmp(pSop, "00 1\n11 1\n") ) return "CBA_BOX_XNOR";
|
||||
if ( !strcmp(pSop, "10 1\n") ) return "CBA_BOX_SHARP";
|
||||
if ( !strcmp(pSop, "01 1\n") ) return "CBA_BOX_SHARPL";
|
||||
assert( 0 );
|
||||
return NULL;
|
||||
}
|
||||
static inline char * Ptr_TypeToName( Cba_ObjType_t Type )
|
||||
{
|
||||
if ( Type == CBA_BOX_CF ) return "const0";
|
||||
if ( Type == CBA_BOX_CT ) return "const1";
|
||||
if ( Type == CBA_BOX_CX ) return "constX";
|
||||
if ( Type == CBA_BOX_CZ ) return "constZ";
|
||||
if ( Type == CBA_BOX_BUF ) return "buf";
|
||||
if ( Type == CBA_BOX_INV ) return "not";
|
||||
if ( Type == CBA_BOX_AND ) return "and";
|
||||
if ( Type == CBA_BOX_NAND ) return "nand";
|
||||
if ( Type == CBA_BOX_OR ) return "or";
|
||||
if ( Type == CBA_BOX_NOR ) return "nor";
|
||||
if ( Type == CBA_BOX_XOR ) return "xor";
|
||||
if ( Type == CBA_BOX_XNOR ) return "xnor";
|
||||
if ( Type == CBA_BOX_MUX ) return "mux";
|
||||
if ( Type == CBA_BOX_MAJ ) return "maj";
|
||||
if ( Type == CBA_BOX_SHARP ) return "sharp";
|
||||
if ( Type == CBA_BOX_SHARPL) return "sharpl";
|
||||
assert( 0 );
|
||||
return "???";
|
||||
}
|
||||
static inline char * Ptr_TypeToSop( Cba_ObjType_t Type )
|
||||
{
|
||||
if ( Type == CBA_BOX_CF ) return " 0\n";
|
||||
if ( Type == CBA_BOX_CT ) return " 1\n";
|
||||
if ( Type == CBA_BOX_CX ) return " 0\n";
|
||||
if ( Type == CBA_BOX_CZ ) return " 0\n";
|
||||
if ( Type == CBA_BOX_BUF ) return "1 1\n";
|
||||
if ( Type == CBA_BOX_INV ) return "0 1\n";
|
||||
if ( Type == CBA_BOX_AND ) return "11 1\n";
|
||||
if ( Type == CBA_BOX_NAND ) return "11 0\n";
|
||||
if ( Type == CBA_BOX_OR ) return "00 0\n";
|
||||
if ( Type == CBA_BOX_NOR ) return "00 1\n";
|
||||
if ( Type == CBA_BOX_XOR ) return "01 1\n10 1\n";
|
||||
if ( Type == CBA_BOX_XNOR ) return "00 1\n11 1\n";
|
||||
if ( Type == CBA_BOX_SHARP ) return "10 1\n";
|
||||
if ( Type == CBA_BOX_SHARPL) return "01 1\n";
|
||||
if ( Type == CBA_BOX_MUX ) return "11- 1\n0-1 1\n";
|
||||
if ( Type == CBA_BOX_MAJ ) return "11- 1\n1-1 1\n-11 1\n";
|
||||
assert( 0 );
|
||||
return "???";
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// ITERATORS ///
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ typedef enum {
|
|||
PRS_BLIF_UNKNOWN // 11: unknown
|
||||
} Cba_BlifType_t;
|
||||
|
||||
const char * s_BlifTypes[PRS_BLIF_UNKNOWN+1] = {
|
||||
static const char * s_BlifTypes[PRS_BLIF_UNKNOWN+1] = {
|
||||
NULL, // 0: unused
|
||||
".model", // 1: .model
|
||||
".inouts", // 2: .inputs
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ typedef enum {
|
|||
PRS_VER_UNKNOWN // 13: unknown
|
||||
} Cba_VerType_t;
|
||||
|
||||
const char * s_VerTypes[PRS_VER_UNKNOWN+1] = {
|
||||
static const char * s_VerTypes[PRS_VER_UNKNOWN+1] = {
|
||||
NULL, // 0: unused
|
||||
"input", // 1: input
|
||||
"output", // 2: output
|
||||
|
|
@ -101,7 +101,7 @@ static inline int Prs_ManIsDigit( Prs_Man_t * p ) { return Prs_CharIsD
|
|||
***********************************************************************/
|
||||
|
||||
// collect predefined modules names
|
||||
const char * s_VerilogModules[100] =
|
||||
static const char * s_VerilogModules[100] =
|
||||
{
|
||||
"const0", // CBA_BOX_CF,
|
||||
"const1", // CBA_BOX_CT,
|
||||
|
|
@ -120,7 +120,7 @@ const char * s_VerilogModules[100] =
|
|||
"maj", // CBA_BOX_MAJ,
|
||||
NULL
|
||||
};
|
||||
const char * s_KnownModules[100] =
|
||||
static const char * s_KnownModules[100] =
|
||||
{
|
||||
"VERIFIC_",
|
||||
"add_",
|
||||
|
|
@ -447,7 +447,7 @@ static inline int Prs_ManReadSignal( Prs_Man_t * p )
|
|||
return Abc_Var2Lit2( Item, CBA_PRS_NAME );
|
||||
}
|
||||
}
|
||||
int Prs_ManReadSignalList( Prs_Man_t * p, Vec_Int_t * vTemp, char LastSymb, int fAddForm )
|
||||
static int Prs_ManReadSignalList( Prs_Man_t * p, Vec_Int_t * vTemp, char LastSymb, int fAddForm )
|
||||
{
|
||||
Vec_IntClear( vTemp );
|
||||
while ( 1 )
|
||||
|
|
|
|||
|
|
@ -44,14 +44,14 @@ ABC_NAMESPACE_IMPL_START
|
|||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Prs_ManWriteBlifArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vFanins )
|
||||
static void Prs_ManWriteBlifArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vFanins )
|
||||
{
|
||||
int i, NameId;
|
||||
Vec_IntForEachEntry( vFanins, NameId, i )
|
||||
fprintf( pFile, " %s", Prs_NtkStr(p, NameId) );
|
||||
fprintf( pFile, "\n" );
|
||||
}
|
||||
void Prs_ManWriteBlifLines( FILE * pFile, Prs_Ntk_t * p )
|
||||
static void Prs_ManWriteBlifLines( FILE * pFile, Prs_Ntk_t * p )
|
||||
{
|
||||
Vec_Int_t * vBox;
|
||||
int i, k, FormId, ActId;
|
||||
|
|
@ -84,7 +84,7 @@ void Prs_ManWriteBlifLines( FILE * pFile, Prs_Ntk_t * p )
|
|||
}
|
||||
}
|
||||
}
|
||||
void Prs_ManWriteBlifNtk( FILE * pFile, Prs_Ntk_t * p )
|
||||
static void Prs_ManWriteBlifNtk( FILE * pFile, Prs_Ntk_t * p )
|
||||
{
|
||||
// write header
|
||||
fprintf( pFile, ".model %s\n", Prs_NtkStr(p, p->iModuleName) );
|
||||
|
|
@ -116,6 +116,7 @@ void Prs_ManWriteBlif( char * pFileName, Vec_Ptr_t * vPrs )
|
|||
}
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
|
|
@ -226,6 +227,7 @@ void Cba_ManWriteBlif( char * pFileName, Cba_Man_t * p )
|
|||
fclose( pFile );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ ABC_NAMESPACE_IMPL_START
|
|||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Prs_ManWriteVerilogConcat( FILE * pFile, Prs_Ntk_t * p, int Con )
|
||||
static void Prs_ManWriteVerilogConcat( FILE * pFile, Prs_Ntk_t * p, int Con )
|
||||
{
|
||||
extern void Prs_ManWriteVerilogArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs, int Start, int Stop, int fOdd );
|
||||
Vec_Int_t * vSigs = Prs_CatSignals(p, Con);
|
||||
|
|
@ -52,7 +52,7 @@ void Prs_ManWriteVerilogConcat( FILE * pFile, Prs_Ntk_t * p, int Con )
|
|||
Prs_ManWriteVerilogArray( pFile, p, vSigs, 0, Vec_IntSize(vSigs), 0 );
|
||||
fprintf( pFile, "}" );
|
||||
}
|
||||
void Prs_ManWriteVerilogSignal( FILE * pFile, Prs_Ntk_t * p, int Sig )
|
||||
static void Prs_ManWriteVerilogSignal( FILE * pFile, Prs_Ntk_t * p, int Sig )
|
||||
{
|
||||
int Value = Abc_Lit2Var2( Sig );
|
||||
Prs_ManType_t Type = (Prs_ManType_t)Abc_Lit2Att2( Sig );
|
||||
|
|
@ -64,7 +64,7 @@ void Prs_ManWriteVerilogSignal( FILE * pFile, Prs_Ntk_t * p, int Sig )
|
|||
Prs_ManWriteVerilogConcat( pFile, p, Value );
|
||||
else assert( 0 );
|
||||
}
|
||||
void Prs_ManWriteVerilogArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs, int Start, int Stop, int fOdd )
|
||||
static void Prs_ManWriteVerilogArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs, int Start, int Stop, int fOdd )
|
||||
{
|
||||
int i, Sig;
|
||||
assert( Vec_IntSize(vSigs) > 0 );
|
||||
|
|
@ -76,7 +76,7 @@ void Prs_ManWriteVerilogArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs, i
|
|||
fprintf( pFile, "%s", i == Stop - 1 ? "" : ", " );
|
||||
}
|
||||
}
|
||||
void Prs_ManWriteVerilogArray2( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
|
||||
static void Prs_ManWriteVerilogArray2( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
|
||||
{
|
||||
int i, FormId, ActSig;
|
||||
assert( Vec_IntSize(vSigs) % 2 == 0 );
|
||||
|
|
@ -89,7 +89,7 @@ void Prs_ManWriteVerilogArray2( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
|
|||
fprintf( pFile, ")%s", (i == Vec_IntSize(vSigs) - 2) ? "" : ", " );
|
||||
}
|
||||
}
|
||||
void Prs_ManWriteVerilogMux( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
|
||||
static void Prs_ManWriteVerilogMux( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
|
||||
{
|
||||
int i, FormId, ActSig;
|
||||
char * pStrs[4] = { " = ", " ? ", " : ", ";\n" };
|
||||
|
|
@ -105,7 +105,7 @@ void Prs_ManWriteVerilogMux( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
|
|||
break;
|
||||
}
|
||||
}
|
||||
void Prs_ManWriteVerilogBoxes( FILE * pFile, Prs_Ntk_t * p )
|
||||
static void Prs_ManWriteVerilogBoxes( FILE * pFile, Prs_Ntk_t * p )
|
||||
{
|
||||
Vec_Int_t * vBox; int i;
|
||||
Prs_NtkForEachBox( p, vBox, i )
|
||||
|
|
@ -131,7 +131,7 @@ void Prs_ManWriteVerilogBoxes( FILE * pFile, Prs_Ntk_t * p )
|
|||
}
|
||||
}
|
||||
}
|
||||
void Prs_ManWriteVerilogIos( FILE * pFile, Prs_Ntk_t * p, int SigType )
|
||||
static void Prs_ManWriteVerilogIos( FILE * pFile, Prs_Ntk_t * p, int SigType )
|
||||
{
|
||||
int NameId, RangeId, i;
|
||||
char * pSigNames[4] = { "inout", "input", "output", "wire" };
|
||||
|
|
@ -142,13 +142,13 @@ void Prs_ManWriteVerilogIos( FILE * pFile, Prs_Ntk_t * p, int SigType )
|
|||
Vec_IntForEachEntryTwo( vSigs[SigType], vSigsR[SigType], NameId, RangeId, i )
|
||||
fprintf( pFile, " %s %s%s;\n", pSigNames[SigType], RangeId ? Prs_NtkStr(p, RangeId) : "", Prs_NtkStr(p, NameId) );
|
||||
}
|
||||
void Prs_ManWriteVerilogIoOrder( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vOrder )
|
||||
static void Prs_ManWriteVerilogIoOrder( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vOrder )
|
||||
{
|
||||
int i, NameId;
|
||||
Vec_IntForEachEntry( vOrder, NameId, i )
|
||||
fprintf( pFile, "%s%s", Prs_NtkStr(p, NameId), i == Vec_IntSize(vOrder) - 1 ? "" : ", " );
|
||||
}
|
||||
void Prs_ManWriteVerilogNtk( FILE * pFile, Prs_Ntk_t * p )
|
||||
static void Prs_ManWriteVerilogNtk( FILE * pFile, Prs_Ntk_t * p )
|
||||
{
|
||||
int s;
|
||||
// write header
|
||||
|
|
@ -179,6 +179,7 @@ void Prs_ManWriteVerilog( char * pFileName, Vec_Ptr_t * vPrs )
|
|||
}
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
|
|
@ -693,6 +694,7 @@ void Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p, int fUseAssign )
|
|||
Vec_StrFreeP( &p->vOut2 );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
|
|
|
|||
|
|
@ -1,15 +1,8 @@
|
|||
SRC += src/base/cba/cbaBlast.c \
|
||||
src/base/cba/cbaCba.c \
|
||||
src/base/cba/cbaCom.c \
|
||||
src/base/cba/cbaLib.c \
|
||||
src/base/cba/cbaNtk.c \
|
||||
src/base/cba/cbaPrsBuild.c \
|
||||
src/base/cba/cbaPrsTrans.c \
|
||||
src/base/cba/cbaPtr.c \
|
||||
src/base/cba/cbaPtrAbc.c \
|
||||
src/base/cba/cbaReadBlif.c \
|
||||
src/base/cba/cbaReadSmt.c \
|
||||
src/base/cba/cbaReadVer.c \
|
||||
src/base/cba/cbaWriteBlif.c \
|
||||
src/base/cba/cbaWriteSmt.c \
|
||||
src/base/cba/cbaWriteVer.c
|
||||
|
|
|
|||
|
|
@ -49,6 +49,8 @@ extern void Scl_Init( Abc_Frame_t * pAbc );
|
|||
extern void Scl_End( Abc_Frame_t * pAbc );
|
||||
extern void Wlc_Init( Abc_Frame_t * pAbc );
|
||||
extern void Wlc_End( Abc_Frame_t * pAbc );
|
||||
extern void Bac_Init( Abc_Frame_t * pAbc );
|
||||
extern void Bac_End( Abc_Frame_t * pAbc );
|
||||
extern void Cba_Init( Abc_Frame_t * pAbc );
|
||||
extern void Cba_End( Abc_Frame_t * pAbc );
|
||||
extern void Pla_Init( Abc_Frame_t * pAbc );
|
||||
|
|
@ -108,6 +110,7 @@ void Abc_FrameInit( Abc_Frame_t * pAbc )
|
|||
Load_Init( pAbc );
|
||||
Scl_Init( pAbc );
|
||||
Wlc_Init( pAbc );
|
||||
Bac_Init( pAbc );
|
||||
Cba_Init( pAbc );
|
||||
Pla_Init( pAbc );
|
||||
Test_Init( pAbc );
|
||||
|
|
@ -145,6 +148,7 @@ void Abc_FrameEnd( Abc_Frame_t * pAbc )
|
|||
Load_End( pAbc );
|
||||
Scl_End( pAbc );
|
||||
Wlc_End( pAbc );
|
||||
Bac_End( pAbc );
|
||||
Cba_End( pAbc );
|
||||
Pla_End( pAbc );
|
||||
Test_End( pAbc );
|
||||
|
|
|
|||
|
|
@ -1939,6 +1939,27 @@ static inline void Vec_IntAppendSkip( Vec_Int_t * vVec1, Vec_Int_t * vVec2, int
|
|||
Vec_IntPush( vVec1, Entry );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Remapping attributes after objects were duplicated.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
static inline void Vec_IntRemapArray( Vec_Int_t * vOld2New, Vec_Int_t * vOld, Vec_Int_t * vNew, int nNew )
|
||||
{
|
||||
int iOld, iNew;
|
||||
if ( Vec_IntSize(vOld) == 0 )
|
||||
return;
|
||||
Vec_IntFill( vNew, nNew, 0 );
|
||||
Vec_IntForEachEntry( vOld2New, iNew, iOld )
|
||||
if ( iNew > 0 && iNew < nNew && Vec_IntEntry(vOld, iOld) != 0 )
|
||||
Vec_IntWriteEntry( vNew, iNew, Vec_IntEntry(vOld, iOld) );
|
||||
}
|
||||
|
||||
ABC_NAMESPACE_HEADER_END
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue