| /**CFile**************************************************************** |
| |
| FileName [bac.h] |
| |
| SystemName [ABC: Logic synthesis and verification system.] |
| |
| PackageName [Hierarchical word-level netlist.] |
| |
| Synopsis [External declarations.] |
| |
| Author [Alan Mishchenko] |
| |
| Affiliation [UC Berkeley] |
| |
| Date [Ver. 1.0. Started - November 29, 2014.] |
| |
| Revision [$Id: bac.h,v 1.00 2014/11/29 00:00:00 alanmi Exp $] |
| |
| ***********************************************************************/ |
| |
| #ifndef ABC__base__bac__bac_h |
| #define ABC__base__bac__bac_h |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// INCLUDES /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| #include "aig/gia/gia.h" |
| #include "misc/extra/extra.h" |
| #include "misc/util/utilNam.h" |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// PARAMETERS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| ABC_NAMESPACE_HEADER_START |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// BASIC TYPES /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| // network objects |
| typedef enum { |
| BAC_OBJ_NONE = 0, // 0: unused |
| BAC_OBJ_PI, // 1: input |
| BAC_OBJ_PO, // 2: output |
| BAC_OBJ_BI, // 3: box input |
| BAC_OBJ_BO, // 4: box output |
| BAC_OBJ_BOX, // 5: box |
| |
| BAC_BOX_CF, |
| BAC_BOX_CT, |
| BAC_BOX_CX, |
| BAC_BOX_CZ, |
| BAC_BOX_BUF, |
| BAC_BOX_INV, |
| BAC_BOX_AND, |
| BAC_BOX_NAND, |
| BAC_BOX_OR, |
| BAC_BOX_NOR, |
| BAC_BOX_XOR, |
| BAC_BOX_XNOR, |
| BAC_BOX_SHARP, |
| BAC_BOX_SHARPL, |
| BAC_BOX_MUX, |
| BAC_BOX_MAJ, |
| |
| BAC_BOX_RAND, |
| BAC_BOX_RNAND, |
| BAC_BOX_ROR, |
| BAC_BOX_RNOR, |
| BAC_BOX_RXOR, |
| BAC_BOX_RXNOR, |
| |
| BAC_BOX_LAND, |
| BAC_BOX_LNAND, |
| BAC_BOX_LOR, |
| BAC_BOX_LNOR, |
| BAC_BOX_LXOR, |
| BAC_BOX_LXNOR, |
| |
| BAC_BOX_NMUX, |
| BAC_BOX_SEL, |
| BAC_BOX_PSEL, |
| BAC_BOX_ENC, |
| BAC_BOX_PENC, |
| BAC_BOX_DEC, |
| BAC_BOX_EDEC, |
| |
| BAC_BOX_ADD, |
| BAC_BOX_SUB, |
| BAC_BOX_MUL, |
| BAC_BOX_DIV, |
| BAC_BOX_MOD, |
| BAC_BOX_REM, |
| BAC_BOX_POW, |
| BAC_BOX_MIN, |
| BAC_BOX_ABS, |
| |
| BAC_BOX_LTHAN, |
| BAC_BOX_LETHAN, |
| BAC_BOX_METHAN, |
| BAC_BOX_MTHAN, |
| BAC_BOX_EQU, |
| BAC_BOX_NEQU, |
| |
| BAC_BOX_SHIL, |
| BAC_BOX_SHIR, |
| BAC_BOX_ROTL, |
| BAC_BOX_ROTR, |
| |
| BAC_BOX_GATE, |
| BAC_BOX_LUT, |
| BAC_BOX_ASSIGN, |
| |
| BAC_BOX_TRI, |
| BAC_BOX_RAM, |
| BAC_BOX_RAMR, |
| BAC_BOX_RAMW, |
| BAC_BOX_RAMWC, |
| BAC_BOX_RAMBOX, |
| |
| BAC_BOX_LATCH, |
| BAC_BOX_LATCHRS, |
| BAC_BOX_DFF, |
| BAC_BOX_DFFRS, |
| |
| BAC_BOX_UNKNOWN // 67 |
| } Bac_ObjType_t; |
| |
| |
| // name types |
| typedef enum { |
| BAC_NAME_BIN = 0, // 0: binary variable |
| BAC_NAME_WORD, // 1: first bit of word-level variable |
| BAC_NAME_INFO, // 2: first bit of special variable |
| BAC_NAME_INDEX, // 3: index of word-level variable |
| } Bac_NameType_t; |
| |
| |
| typedef struct Bac_Ntk_t_ Bac_Ntk_t; |
| typedef struct Bac_Man_t_ Bac_Man_t; |
| |
| // network |
| struct Bac_Ntk_t_ |
| { |
| Bac_Man_t * pDesign; // design |
| int NameId; // name ID |
| int iCopy; // copy module |
| int iBoxNtk; // instance network ID |
| int iBoxObj; // instance object ID |
| int Count; // object counter |
| int Mark; // visit mark |
| // interface |
| Vec_Int_t vInputs; // inputs |
| Vec_Int_t vOutputs; // outputs |
| Vec_Int_t vInfo; // input/output/wire info |
| // object attributes |
| Vec_Str_t vType; // types |
| Vec_Int_t vFanin; // fanin |
| Vec_Int_t vIndex; // index |
| Vec_Int_t vName; // original NameId or InstId |
| Vec_Int_t vFanout; // fanout |
| Vec_Int_t vCopy; // copy |
| // other |
| Vec_Int_t vArray; |
| Vec_Int_t vArray2; |
| }; |
| |
| // design |
| struct Bac_Man_t_ |
| { |
| // design names |
| char * pName; // design name |
| char * pSpec; // spec file name |
| Abc_Nam_t * pStrs; // string manager |
| Abc_Nam_t * pMods; // module name manager |
| // internal data |
| int iRoot; // root network |
| int nNtks; // number of current networks |
| Bac_Ntk_t * pNtks; // networks |
| // user data |
| Vec_Str_t * vOut; |
| Vec_Str_t * vOut2; |
| Vec_Int_t vBuf2RootNtk; |
| Vec_Int_t vBuf2RootObj; |
| Vec_Int_t vBuf2LeafNtk; |
| Vec_Int_t vBuf2LeafObj; |
| void * pMioLib; |
| void ** ppGraphs; |
| int ElemGates[4]; |
| char * pPrimNames[BAC_BOX_UNKNOWN]; |
| char * pPrimSymbs[BAC_BOX_UNKNOWN]; |
| }; |
| |
| static inline char * Bac_ManName( Bac_Man_t * p ) { return p->pName; } |
| static inline char * Bac_ManSpec( Bac_Man_t * p ) { return p->pSpec; } |
| static inline int Bac_ManNtkNum( Bac_Man_t * p ) { return p->nNtks; } |
| static inline int Bac_ManPrimNum( Bac_Man_t * p ) { return Abc_NamObjNumMax(p->pMods) - Bac_ManNtkNum(p); } |
| static inline int Bac_ManNtkIsOk( Bac_Man_t * p, int i ) { return i > 0 && i <= Bac_ManNtkNum(p); } |
| static inline Bac_Ntk_t * Bac_ManNtk( Bac_Man_t * p, int i ) { return Bac_ManNtkIsOk(p, i) ? p->pNtks + i : NULL; } |
| static inline int Bac_ManNtkFindId( Bac_Man_t * p, char * pName ) { return Abc_NamStrFind(p->pMods, pName); } |
| static inline Bac_Ntk_t * Bac_ManNtkFind( Bac_Man_t * p, char * pName ) { return Bac_ManNtk( p, Bac_ManNtkFindId(p, pName) ); } |
| static inline Bac_Ntk_t * Bac_ManRoot( Bac_Man_t * p ) { return Bac_ManNtk(p, p->iRoot); } |
| static inline char * Bac_ManStr( Bac_Man_t * p, int i ) { return Abc_NamStr(p->pStrs, i); } |
| static inline int Bac_ManStrId( Bac_Man_t * p, char * pStr ) { return Abc_NamStrFind(p->pStrs, pStr); } |
| static inline char * Bac_ManPrimName( Bac_Man_t * p, Bac_ObjType_t Type ) { return p->pPrimNames[Type]; } |
| static inline char * Bac_ManPrimSymb( Bac_Man_t * p, Bac_ObjType_t Type ) { return p->pPrimSymbs[Type]; } |
| |
| static inline int Bac_NtkId( Bac_Ntk_t * p ) { int i = p - p->pDesign->pNtks; assert(Bac_ManNtkIsOk(p->pDesign, i)); return i; } |
| static inline Bac_Man_t * Bac_NtkMan( Bac_Ntk_t * p ) { return p->pDesign; } |
| static inline int Bac_NtkNameId( Bac_Ntk_t * p ) { return p->NameId; } |
| static inline char * Bac_NtkName( Bac_Ntk_t * p ) { return Bac_ManStr(p->pDesign, Bac_NtkNameId(p)); } |
| static inline int Bac_NtkCopy( Bac_Ntk_t * p ) { return p->iCopy; } |
| static inline Bac_Ntk_t * Bac_NtkCopyNtk(Bac_Man_t * pNew, Bac_Ntk_t * p) { return Bac_ManNtk(pNew, Bac_NtkCopy(p)); } |
| static inline void Bac_NtkSetCopy( Bac_Ntk_t * p, int i ) { assert(p->iCopy == -1); p->iCopy = i; } |
| |
| static inline int Bac_NtkObjNum( Bac_Ntk_t * p ) { return Vec_StrSize(&p->vType); } |
| static inline int Bac_NtkObjNumAlloc( Bac_Ntk_t * p ) { return Vec_StrCap(&p->vType); } |
| static inline int Bac_NtkPiNum( Bac_Ntk_t * p ) { return Vec_IntSize(&p->vInputs); } |
| static inline int Bac_NtkPoNum( Bac_Ntk_t * p ) { return Vec_IntSize(&p->vOutputs); } |
| static inline int Bac_NtkPioNum( Bac_Ntk_t * p ) { return Bac_NtkPiNum(p) + Bac_NtkPoNum(p); } |
| static inline int Bac_NtkPiNumAlloc( Bac_Ntk_t * p ) { return Vec_IntCap(&p->vInputs); } |
| static inline int Bac_NtkPoNumAlloc( Bac_Ntk_t * p ) { return Vec_IntCap(&p->vOutputs); } |
| static inline int Bac_NtkBiNum( Bac_Ntk_t * p ) { return Vec_StrCountEntryLit(&p->vType, (char)BAC_OBJ_BI); } |
| static inline int Bac_NtkBoNum( Bac_Ntk_t * p ) { return Vec_StrCountEntryLit(&p->vType, (char)BAC_OBJ_BO); } |
| static inline int Bac_NtkCiNum( Bac_Ntk_t * p ) { return Bac_NtkPiNum(p) + Bac_NtkBoNum(p); } |
| static inline int Bac_NtkCoNum( Bac_Ntk_t * p ) { return Bac_NtkPoNum(p) + Bac_NtkBiNum(p); } |
| static inline int Bac_NtkBoxNum( Bac_Ntk_t * p ) { return Bac_NtkObjNum(p) - Vec_StrCountSmallerLit(&p->vType, (char)BAC_OBJ_BOX); } |
| static inline int Bac_NtkPrimNum( Bac_Ntk_t * p ) { return Vec_StrCountLargerLit(&p->vType, (char)BAC_OBJ_BOX); } |
| static inline int Bac_NtkUserNum( Bac_Ntk_t * p ) { return Vec_StrCountEntryLit(&p->vType, (char)BAC_OBJ_BOX); } |
| |
| static inline int Bac_NtkPi( Bac_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInputs, i); } |
| static inline int Bac_NtkPo( Bac_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vOutputs, i); } |
| static inline char * Bac_NtkStr( Bac_Ntk_t * p, int i ) { return Bac_ManStr(p->pDesign, i); } |
| static inline Bac_Ntk_t * Bac_NtkHostNtk( Bac_Ntk_t * p ) { return p->iBoxNtk > 0 ? Bac_ManNtk(p->pDesign, p->iBoxNtk) : NULL; } |
| static inline int Bac_NtkHostObj( Bac_Ntk_t * p ) { return p->iBoxObj; } |
| static inline void Bac_NtkSetHost( Bac_Ntk_t * p, int n, int i ) { assert(p->iBoxNtk == -1); p->iBoxNtk = n; p->iBoxObj = i; } |
| |
| static inline int Bac_InfoRange( int Beg, int End ) { return End > Beg ? End - Beg + 1 : Beg - End + 1; } |
| static inline int Bac_NtkInfoNum( Bac_Ntk_t * p ) { return Vec_IntSize(&p->vInfo)/3; } |
| static inline int Bac_NtkInfoNumAlloc( Bac_Ntk_t * p ) { return Vec_IntCap(&p->vInfo)/3; } |
| static inline int Bac_NtkInfoType( Bac_Ntk_t * p, int i ) { return Abc_Lit2Att2(Vec_IntEntry(&p->vInfo, 3*i)); } |
| static inline int Bac_NtkInfoName( Bac_Ntk_t * p, int i ) { return Abc_Lit2Var2(Vec_IntEntry(&p->vInfo, 3*i)); } |
| static inline int Bac_NtkInfoBeg( Bac_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInfo, 3*i+1); } |
| static inline int Bac_NtkInfoEnd( Bac_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInfo, 3*i+2); } |
| static inline int Bac_NtkInfoRange( Bac_Ntk_t * p, int i ) { int* a = Vec_IntEntryP(&p->vInfo, 3*i); return a[1]>=0 ? Bac_InfoRange( a[1], a[2] ) : 1; } |
| static inline int Bac_NtkInfoIndex( Bac_Ntk_t * p, int i, int j ) { int* a = Vec_IntEntryP(&p->vInfo, 3*i); assert(a[1]>=0); return a[1]<a[2] ? a[1]+j : a[1]-j;} |
| static inline void Bac_NtkAddInfo( Bac_Ntk_t * p,int i,int b,int e){ Vec_IntPush(&p->vInfo, i); Vec_IntPushTwo(&p->vInfo, b, e); } |
| static inline void Bac_NtkSetInfoName( Bac_Ntk_t * p, int i, int n){ Vec_IntWriteEntry( &p->vInfo, 3*i, n ); } |
| |
| static inline void Bac_NtkStartNames( Bac_Ntk_t * p ) { assert(Bac_NtkObjNumAlloc(p)); Vec_IntFill(&p->vName, Bac_NtkObjNumAlloc(p), 0); } |
| static inline void Bac_NtkStartFanouts( Bac_Ntk_t * p ) { assert(Bac_NtkObjNumAlloc(p)); Vec_IntFill(&p->vFanout, Bac_NtkObjNumAlloc(p), 0); } |
| static inline void Bac_NtkStartCopies( Bac_Ntk_t * p ) { assert(Bac_NtkObjNumAlloc(p)); Vec_IntFill(&p->vCopy, Bac_NtkObjNumAlloc(p), -1); } |
| static inline void Bac_NtkFreeNames( Bac_Ntk_t * p ) { Vec_IntErase(&p->vName); } |
| static inline void Bac_NtkFreeFanouts( Bac_Ntk_t * p ) { Vec_IntErase(&p->vFanout); } |
| static inline void Bac_NtkFreeCopies( Bac_Ntk_t * p ) { Vec_IntErase(&p->vCopy); } |
| static inline int Bac_NtkHasNames( Bac_Ntk_t * p ) { return p->vName.pArray != NULL; } |
| static inline int Bac_NtkHasFanouts( Bac_Ntk_t * p ) { return p->vFanout.pArray != NULL; } |
| static inline int Bac_NtkHasCopies( Bac_Ntk_t * p ) { return p->vCopy.pArray != NULL; } |
| |
| static inline int Bac_TypeIsBox( Bac_ObjType_t Type ) { return Type >= BAC_OBJ_BOX && Type < BAC_BOX_UNKNOWN; } |
| static inline Bac_NameType_t Bac_NameType( int n ) { assert( n ); return (Bac_NameType_t)Abc_Lit2Att2( n ); } |
| static inline int Bac_CharIsDigit( char c ) { return c >= '0' && c <= '9'; } |
| |
| static inline Bac_ObjType_t Bac_ObjType( Bac_Ntk_t * p, int i ) { return (Bac_ObjType_t)Abc_Lit2Var((int)(unsigned char)Vec_StrEntry(&p->vType, i)); } |
| static inline int Bac_ObjIsPi( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_OBJ_PI; } |
| static inline int Bac_ObjIsPo( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_OBJ_PO; } |
| static inline int Bac_ObjIsPio( Bac_Ntk_t * p, int i ) { return Bac_ObjIsPi(p, i) || Bac_ObjIsPo(p, i); } |
| static inline int Bac_ObjIsBi( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_OBJ_BI; } |
| static inline int Bac_ObjIsBo( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_OBJ_BO; } |
| static inline int Bac_ObjIsBio( Bac_Ntk_t * p, int i ) { return Bac_ObjIsBi(p, i) || Bac_ObjIsBo(p, i); } |
| static inline int Bac_ObjIsBox( Bac_Ntk_t * p, int i ) { return Bac_TypeIsBox(Bac_ObjType(p, i)); } |
| static inline int Bac_ObjIsBoxUser( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_OBJ_BOX; } |
| static inline int Bac_ObjIsBoxPrim( Bac_Ntk_t * p, int i ) { return Bac_ObjIsBox(p, i) && !Bac_ObjIsBoxUser(p, i); } |
| static inline int Bac_ObjIsGate( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_BOX_GATE; } |
| static inline int Bac_ObjIsCi( Bac_Ntk_t * p, int i ) { return Bac_ObjIsPi(p, i) || Bac_ObjIsBo(p, i); } |
| static inline int Bac_ObjIsCo( Bac_Ntk_t * p, int i ) { return Bac_ObjIsPo(p, i) || Bac_ObjIsBi(p, i); } |
| static inline int Bac_ObjIsCio( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) < BAC_OBJ_BOX; } |
| static inline int Bac_ObjIsConst( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) >= BAC_BOX_CF && Bac_ObjType(p, i) <= BAC_BOX_CZ; } |
| static inline int Bac_ObjIsConstBin( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_BOX_CF || Bac_ObjType(p, i) == BAC_BOX_CT; } |
| |
| static inline int Bac_ObjBit( Bac_Ntk_t * p, int i ) { assert(!Bac_ObjIsBox(p, i)); return Abc_LitIsCompl((int)Vec_StrEntry(&p->vType, i)); } |
| static inline void Bac_ObjSetBit( Bac_Ntk_t * p, int i ) { char *q = Vec_StrArray(&p->vType); assert(!Bac_ObjIsBox(p, i)); q[i] = (char)Abc_LitNot((int)q[i]); } |
| static inline int Bac_ObjFanin( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsCo(p, i)); return Vec_IntEntry(&p->vFanin, i); } |
| static inline int Bac_ObjIndex( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsCio(p, i)); return Vec_IntEntry(&p->vIndex, i); } |
| static inline int Bac_ObjNameInt( Bac_Ntk_t * p, int i ) { assert(!Bac_ObjIsCo(p, i)); return Vec_IntEntry(&p->vName, i); } |
| static inline int Bac_ObjName( Bac_Ntk_t * p, int i ) { return Bac_ObjIsCo(p, i) ? Bac_ObjNameInt(p, Bac_ObjFanin(p,i)) : Bac_ObjNameInt(p, i); } |
| static inline Bac_NameType_t Bac_ObjNameType( Bac_Ntk_t * p, int i ) { return Bac_NameType( Bac_ObjName(p, i) ); } |
| static inline int Bac_ObjNameId( Bac_Ntk_t * p, int i ) { return Abc_Lit2Var2( Bac_ObjName(p, i) ); } |
| static inline char * Bac_ObjNameStr( Bac_Ntk_t * p, int i ) { assert(Bac_ObjNameType(p, i) <= BAC_NAME_WORD); return Bac_NtkStr(p, Bac_ObjNameId(p, i)); } |
| static inline int Bac_ObjCopy( Bac_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vCopy, i); } |
| static inline int Bac_ObjFanout( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsCi(p, i)); return Vec_IntEntry(&p->vFanout, i); } |
| static inline int Bac_ObjNextFanout( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsCo(p, i)); return Vec_IntEntry(&p->vFanout, i); } |
| static inline void Bac_ObjSetFanout( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjIsCi(p, i)); Vec_IntSetEntry(&p->vFanout, i, x); } |
| static inline void Bac_ObjSetNextFanout( Bac_Ntk_t * p,int i,int x){ assert(Bac_ObjIsCo(p, i)); Vec_IntSetEntry(&p->vFanout, i, x); } |
| static inline void Bac_ObjCleanFanin( Bac_Ntk_t * p, int i ) { assert(Bac_ObjFanin(p, i) >= 0 && Bac_ObjIsCo(p, i)); Vec_IntSetEntry( &p->vFanin, i, -1); } |
| static inline void Bac_ObjSetFanin( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjFanin(p, i) == -1 && Bac_ObjIsCo(p, i)); Vec_IntSetEntry( &p->vFanin, i, x); } |
| static inline void Bac_ObjSetIndex( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjIndex(p, i) == -1); Vec_IntSetEntry( &p->vIndex, i, x ); } |
| static inline void Bac_ObjSetName( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjName(p, i) == 0 && !Bac_ObjIsCo(p, i)); Vec_IntSetEntry( &p->vName, i, x ); } |
| static inline void Bac_ObjSetCopy( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjCopy(p, i) == -1); Vec_IntSetEntry( &p->vCopy, i, x ); } |
| static inline int Bac_ObjGetConst( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsCi(p, i)); return Bac_ObjIsBo(p, i) && Bac_ObjIsConst(p, i-1) ? Bac_ObjType(p, i-1) : 0; } |
| |
| static inline int Bac_BoxBiNum( Bac_Ntk_t * p, int i ) { int s = i-1; assert(Bac_ObjIsBox(p, i)); while (--i >= 0 && Bac_ObjIsBi(p, i)) {} return s - i; } |
| static inline int Bac_BoxBoNum( Bac_Ntk_t * p, int i ) { int s = i+1; assert(Bac_ObjIsBox(p, i)); while (++i < Bac_NtkObjNum(p) && Bac_ObjIsBo(p, i)) {} return i - s; } |
| static inline int Bac_BoxSize( Bac_Ntk_t * p, int i ) { return 1 + Bac_BoxBiNum(p, i) + Bac_BoxBoNum(p, i); } |
| static inline int Bac_BoxBi( Bac_Ntk_t * p, int b, int i ) { assert(Bac_ObjIsBox(p, b)); return b - 1 - i; } |
| static inline int Bac_BoxBo( Bac_Ntk_t * p, int b, int i ) { assert(Bac_ObjIsBox(p, b)); return b + 1 + i; } |
| //static inline int Bac_BoxBiBox( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsBi(p, i)); return i + 1 + Bac_ObjIndex(p, i); } |
| static inline int Bac_BoxBoBox( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsBo(p, i)); return i - 1 - Bac_ObjIndex(p, i); } |
| static inline int Bac_BoxFanin( Bac_Ntk_t * p, int b, int i ) { return Bac_ObjFanin(p, Bac_BoxBi(p, b, i)); } |
| static inline int Bac_BoxFaninBox( Bac_Ntk_t * p, int b, int i ) { return Bac_BoxBoBox(p, Bac_BoxFanin(p, b, i)); } |
| static inline int Bac_BoxBiRange( Bac_Ntk_t * p, int i ) { int s = i; assert(Bac_ObjIsBi(p, i) && !Bac_ObjBit(p, i)); while (--i >= 0 && Bac_ObjIsBi(p, i) && Bac_ObjBit(p, i)) {} return s - i; } |
| static inline int Bac_BoxBoRange( Bac_Ntk_t * p, int i ) { int s = i; assert(Bac_ObjIsBo(p, i) && !Bac_ObjBit(p, i)); while (++i < Bac_NtkObjNum(p) && Bac_ObjIsBo(p, i) && Bac_ObjBit(p, i)) {} return i - s; } |
| static inline int Bac_ObjPiRange( Bac_Ntk_t * p, int i ) { int s = i; assert(Bac_ObjIsPi(p, i) && !Bac_ObjBit(p, i)); while (++i < Bac_NtkObjNum(p) && Bac_ObjIsPi(p, i) && Bac_ObjBit(p, i)) {} return i - s; } |
| |
| static inline int Bac_BoxNtkId( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsBox(p, i)); return Vec_IntEntry(&p->vFanin, i); } |
| static inline void Bac_BoxSetNtkId( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjIsBox(p, i)&&Bac_ManNtkIsOk(p->pDesign, x));Vec_IntSetEntry(&p->vFanin, i, x);} |
| //static inline int Bac_BoxBiNtkId( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsBi(p, i)); return Bac_BoxNtkId(p, Bac_BoxBiBox(p, i)); } |
| static inline int Bac_BoxBoNtkId( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsBo(p, i)); return Bac_BoxNtkId(p, Bac_BoxBoBox(p, i)); } |
| static inline Bac_Ntk_t * Bac_BoxNtk( Bac_Ntk_t * p, int i ) { return Bac_ManNtk( p->pDesign, Bac_BoxNtkId(p, i) ); } |
| //static inline Bac_Ntk_t * Bac_BoxBiNtk( Bac_Ntk_t * p, int i ) { return Bac_ManNtk( p->pDesign, Bac_BoxBiNtkId(p, i) ); } |
| static inline Bac_Ntk_t * Bac_BoxBoNtk( Bac_Ntk_t * p, int i ) { return Bac_ManNtk( p->pDesign, Bac_BoxBoNtkId(p, i) ); } |
| static inline char * Bac_BoxNtkName( Bac_Ntk_t * p, int i ) { return Abc_NamStr( p->pDesign->pMods, Bac_BoxNtkId(p, i) ); } |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// MACRO DEFINITIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// ITERATORS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| #define Bac_ManForEachNtk( p, pNtk, i ) \ |
| for ( i = 1; (i <= Bac_ManNtkNum(p)) && (((pNtk) = Bac_ManNtk(p, i)), 1); i++ ) |
| |
| #define Bac_NtkForEachPi( p, iObj, i ) \ |
| for ( i = 0; (i < Bac_NtkPiNum(p)) && (((iObj) = Bac_NtkPi(p, i)), 1); i++ ) |
| #define Bac_NtkForEachPo( p, iObj, i ) \ |
| for ( i = 0; (i < Bac_NtkPoNum(p)) && (((iObj) = Bac_NtkPo(p, i)), 1); i++ ) |
| #define Bac_NtkForEachPoDriver( p, iObj, i ) \ |
| for ( i = 0; (i < Bac_NtkPoNum(p)) && (((iObj) = Bac_ObjFanin(p, Bac_NtkPo(p, i))), 1); i++ ) |
| |
| #define Bac_NtkForEachPiMain( p, iObj, i ) \ |
| for ( i = 0; (i < Bac_NtkPiNum(p)) && (((iObj) = Bac_NtkPi(p, i)), 1); i++ ) if ( Bac_ObjBit(p, iObj) ) {} else |
| #define Bac_NtkForEachPoMain( p, iObj, i ) \ |
| for ( i = 0; (i < Bac_NtkPoNum(p)) && (((iObj) = Bac_NtkPo(p, i)), 1); i++ ) if ( Bac_ObjBit(p, iObj) ) {} else |
| |
| #define Bac_NtkForEachObj( p, i ) if ( !Bac_ObjType(p, i) ) {} else \ |
| for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) |
| #define Bac_NtkForEachObjType( p, Type, i ) \ |
| for ( i = 0; (i < Bac_NtkObjNum(p)) && (((Type) = Bac_ObjType(p, i)), 1); i++ ) if ( !Type ) {} else |
| |
| #define Bac_NtkForEachBox( p, i ) \ |
| for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBox(p, i) ) {} else |
| #define Bac_NtkForEachBoxUser( p, i ) \ |
| for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBoxUser(p, i) ) {} else |
| #define Bac_NtkForEachBoxPrim( p, i ) \ |
| for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBoxPrim(p, i) ) {} else |
| |
| #define Bac_NtkForEachCi( p, i ) \ |
| for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsCi(p, i) ) {} else |
| #define Bac_NtkForEachCo( p, i ) \ |
| for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsCo(p, i) ) {} else |
| #define Bac_NtkForEachCio( p, i ) \ |
| for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsCio(p, i) ){} else |
| |
| #define Bac_NtkForEachBi( p, i ) \ |
| for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBi(p, i) ){} else |
| #define Bac_NtkForEachBo( p, i ) \ |
| for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBo(p, i) ){} else |
| #define Bac_NtkForEachBio( p, i ) \ |
| for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBio(p, i) ){} else |
| |
| #define Bac_BoxForEachBi( p, iBox, iTerm, i ) \ |
| for ( iTerm = iBox - 1, i = 0; iTerm >= 0 && Bac_ObjIsBi(p, iTerm); iTerm--, i++ ) |
| #define Bac_BoxForEachBo( p, iBox, iTerm, i ) \ |
| for ( iTerm = iBox + 1, i = 0; iTerm < Bac_NtkObjNum(p) && Bac_ObjIsBo(p, iTerm); iTerm++, i++ ) |
| #define Bac_BoxForEachBiReverse( p, iBox, iTerm, i ) \ |
| for ( i = Bac_BoxBiNum(p, iBox), iTerm = iBox - i--; Bac_ObjIsBi(p, iTerm); iTerm++, i-- ) |
| |
| #define Bac_BoxForEachBiMain( p, iBox, iTerm, i ) \ |
| for ( iTerm = iBox - 1, i = 0; iTerm >= 0 && Bac_ObjIsBi(p, iTerm); iTerm--, i++ ) if ( Bac_ObjBit(p, iTerm) ) {} else |
| #define Bac_BoxForEachBoMain( p, iBox, iTerm, i ) \ |
| for ( iTerm = iBox + 1, i = 0; iTerm < Bac_NtkObjNum(p) && Bac_ObjIsBo(p, iTerm); iTerm++, i++ ) if ( Bac_ObjBit(p, iTerm) ) {} else |
| |
| #define Bac_BoxForEachFanin( p, iBox, iFanin, i ) \ |
| for ( i = 0; iBox - 1 - i >= 0 && Bac_ObjIsBi(p, iBox - 1 - i) && (((iFanin) = Bac_BoxFanin(p, iBox, i)), 1); i++ ) |
| #define Bac_BoxForEachFaninBox( p, iBox, iFanin, i ) \ |
| for ( i = 0; iBox - 1 - i >= 0 && Bac_ObjIsBi(p, iBox - 1 - i) && (((iFanin) = Bac_BoxFaninBox(p, iBox, i)), 1); i++ ) |
| |
| #define Bac_ObjForEachFanout( p, iCi, iCo ) \ |
| for ( iCo = Bac_ObjFanout(p, iCi); iCo; iCo = Bac_ObjNextFanout(p, iCo) ) |
| #define Bac_BoxForEachFanoutBox( p, iBox, iCo, iFanBox ) \ |
| for ( assert(Bac_BoxBoNum(p, iBox) == 1), iCo = Bac_ObjFanout(p, Bac_BoxBo(p, iBox, 0)); iCo && ((iFanBox = Bac_BoxBiBox(p, iCo)), 1); iCo = Bac_ObjNextFanout(p, iCo) ) |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// FUNCTION DECLARATIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| /**Function************************************************************* |
| |
| Synopsis [Object APIs.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static inline int Bac_ObjAlloc( Bac_Ntk_t * p, Bac_ObjType_t Type, int Fanin ) |
| { |
| int iObj = Bac_NtkObjNum(p); |
| assert( iObj == Vec_IntSize(&p->vFanin) ); |
| if ( Type == BAC_OBJ_PI ) |
| Vec_IntPush( &p->vInputs, iObj ); |
| else if ( Type == BAC_OBJ_PO ) |
| Vec_IntPush( &p->vOutputs, iObj ); |
| Vec_StrPush( &p->vType, (char)Abc_Var2Lit(Type, 0) ); |
| Vec_IntPush( &p->vFanin, Fanin ); |
| return iObj; |
| } |
| static inline int Bac_ObjDup( Bac_Ntk_t * pNew, Bac_Ntk_t * p, int i ) |
| { |
| int iObj = Bac_ObjAlloc( pNew, Bac_ObjType(p, i), Bac_ObjIsBox(p, i) ? Bac_BoxNtkId(p, i) : -1 ); |
| if ( Bac_NtkHasNames(p) && Bac_NtkHasNames(pNew) && !Bac_ObjIsCo(p, i) ) |
| Bac_ObjSetName( pNew, iObj, Bac_ObjName(p, i) ); |
| Bac_ObjSetCopy( p, i, iObj ); |
| return iObj; |
| } |
| static inline int Bac_BoxAlloc( Bac_Ntk_t * p, Bac_ObjType_t Type, int nIns, int nOuts, int iNtk ) |
| { |
| int i, iObj; |
| for ( i = nIns - 1; i >= 0; i-- ) |
| Bac_ObjAlloc( p, BAC_OBJ_BI, -1 ); |
| iObj = Bac_ObjAlloc( p, Type, iNtk ); |
| for ( i = 0; i < nOuts; i++ ) |
| Bac_ObjAlloc( p, BAC_OBJ_BO, -1 ); |
| return iObj; |
| } |
| static inline int Bac_BoxDup( Bac_Ntk_t * pNew, Bac_Ntk_t * p, int iBox ) |
| { |
| int i, iTerm, iBoxNew; |
| Bac_BoxForEachBiReverse( p, iBox, iTerm, i ) |
| Bac_ObjDup( pNew, p, iTerm ); |
| iBoxNew = Bac_ObjDup( pNew, p, iBox ); |
| if ( Bac_NtkHasNames(p) && Bac_NtkHasNames(pNew) && Bac_ObjName(p, iBox) ) |
| Bac_ObjSetName( pNew, iBoxNew, Bac_ObjName(p, iBox) ); |
| if ( Bac_BoxNtk(p, iBox) ) |
| Bac_BoxSetNtkId( pNew, iBoxNew, Bac_NtkCopy(Bac_BoxNtk(p, iBox)) ); |
| Bac_BoxForEachBo( p, iBox, iTerm, i ) |
| Bac_ObjDup( pNew, p, iTerm ); |
| return iBoxNew; |
| } |
| static inline void Bac_BoxDelete( Bac_Ntk_t * p, int iBox ) |
| { |
| int iStart = iBox - Bac_BoxBiNum(p, iBox); |
| int i, iStop = iBox + Bac_BoxBoNum(p, iBox); |
| for ( i = iStart; i <= iStop; i++ ) |
| { |
| Vec_StrWriteEntry( &p->vType, i, (char)0 ); |
| Vec_IntWriteEntry( &p->vFanin, i, -1 ); |
| if ( Bac_NtkHasNames(p) ) |
| Vec_IntWriteEntry( &p->vName, i, 0 ); |
| if ( Bac_NtkHasFanouts(p) ) |
| Vec_IntWriteEntry( &p->vFanout, i, 0 ); |
| } |
| } |
| static inline void Bac_BoxReplace( Bac_Ntk_t * p, int iBox, int * pArray, int nSize ) |
| { |
| extern void Bac_NtkUpdateFanout( Bac_Ntk_t * p, int iOld, int iNew ); |
| int i, Limit = Bac_BoxBoNum(p, iBox); |
| assert( Limit == nSize ); |
| for ( i = 0; i < Limit; i++ ) |
| Bac_NtkUpdateFanout( p, Bac_BoxBo(p, iBox, i), pArray[i] ); |
| } |
| |
| |
| static inline Vec_Int_t * Bac_BoxCollectRanges( Bac_Ntk_t * p, int iBox ) |
| { |
| static Vec_Int_t Bits, * vBits = &Bits; |
| static int pArray[10]; int i, iTerm; |
| assert( !Bac_ObjIsBoxUser(p, iBox) ); |
| // initialize array |
| vBits->pArray = pArray; |
| vBits->nSize = 0; |
| vBits->nCap = 10; |
| // iterate through inputs |
| Bac_BoxForEachBiMain( p, iBox, iTerm, i ) |
| Vec_IntPush( vBits, Bac_BoxBiRange(p, iTerm) ); |
| // iterate through outputs |
| Bac_BoxForEachBoMain( p, iBox, iTerm, i ) |
| Vec_IntPush( vBits, Bac_BoxBoRange(p, iTerm) ); |
| assert( Vec_IntSize(vBits) < 10 ); |
| //Vec_IntPrint( vBits ); |
| return vBits; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Prints vector.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static inline void Vec_StrPrint( Vec_Str_t * p, int fInt ) |
| { |
| int i; |
| for ( i = 0; i < p->nSize; i++ ) |
| if ( fInt ) |
| printf( "%d ", (int)p->pArray[i] ); |
| else |
| printf( "%c ", p->pArray[i] ); |
| printf( "\n" ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Network APIs.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static inline void Bac_NtkAlloc( Bac_Ntk_t * pNew, int NameId, int nIns, int nOuts, int nObjs ) |
| { |
| int NtkId, fFound; |
| assert( pNew->pDesign != NULL ); |
| assert( Bac_NtkPiNum(pNew) == 0 ); |
| assert( Bac_NtkPoNum(pNew) == 0 ); |
| pNew->NameId = NameId; |
| pNew->iCopy = -1; |
| pNew->iBoxNtk = -1; |
| pNew->iBoxObj = -1; |
| Vec_IntGrow( &pNew->vInputs, nIns ); |
| Vec_IntGrow( &pNew->vOutputs, nOuts ); |
| Vec_StrGrow( &pNew->vType, nObjs ); |
| Vec_IntGrow( &pNew->vFanin, nObjs ); |
| // check if the network is unique |
| NtkId = Abc_NamStrFindOrAdd( pNew->pDesign->pMods, Bac_NtkStr(pNew, NameId), &fFound ); |
| if ( fFound ) |
| printf( "Network with name %s already exists.\n", Bac_NtkStr(pNew, NameId) ); |
| else |
| assert( NtkId == Bac_NtkId(pNew) ); |
| } |
| static inline void Bac_NtkDup( Bac_Ntk_t * pNew, Bac_Ntk_t * p ) |
| { |
| int i, iObj; |
| assert( pNew != p ); |
| Bac_NtkAlloc( pNew, Bac_NtkNameId(p), Bac_NtkPiNum(p), Bac_NtkPoNum(p), Bac_NtkObjNum(p) ); |
| if ( Vec_IntSize(&p->vInfo) ) |
| Vec_IntAppend( &pNew->vInfo, &p->vInfo ); |
| Bac_NtkStartCopies( p ); |
| if ( Bac_NtkHasNames(p) ) |
| Bac_NtkStartNames( pNew ); |
| Bac_NtkForEachPi( p, iObj, i ) |
| Bac_ObjDup( pNew, p, iObj ); |
| Bac_NtkForEachBox( p, iObj ) |
| Bac_BoxDup( pNew, p, iObj ); |
| Bac_NtkForEachPo( p, iObj, i ) |
| Bac_ObjDup( pNew, p, iObj ); |
| Bac_NtkForEachCo( p, iObj ) |
| Bac_ObjSetFanin( pNew, Bac_ObjCopy(p, iObj), Bac_ObjCopy(p, Bac_ObjFanin(p, iObj)) ); |
| //Bac_NtkFreeCopies( p ); // needed for name transfer and host ntk |
| assert( Bac_NtkObjNum(pNew) == Bac_NtkObjNumAlloc(pNew) ); |
| } |
| static inline void Bac_NtkDupUserBoxes( Bac_Ntk_t * pNew, Bac_Ntk_t * p ) |
| { |
| int i, iObj; |
| assert( pNew != p ); |
| Bac_NtkAlloc( pNew, Bac_NtkNameId(p), Bac_NtkPiNum(p), Bac_NtkPoNum(p), Bac_NtkObjNum(p) + 3*Bac_NtkCoNum(p) ); |
| if ( Vec_IntSize(&p->vInfo) ) |
| Vec_IntAppend( &pNew->vInfo, &p->vInfo ); |
| Bac_NtkStartCopies( p ); |
| Bac_NtkForEachPi( p, iObj, i ) |
| Bac_ObjDup( pNew, p, iObj ); |
| Bac_NtkForEachPo( p, iObj, i ) |
| Bac_ObjDup( pNew, p, iObj ); |
| Bac_NtkForEachBoxUser( p, iObj ) |
| Bac_BoxDup( pNew, p, iObj ); |
| // connect feed-throughs |
| Bac_NtkForEachCo( p, iObj ) |
| if ( Bac_ObjCopy(p, iObj) >= 0 && Bac_ObjCopy(p, Bac_ObjFanin(p, iObj)) >= 0 ) |
| Bac_ObjSetFanin( pNew, Bac_ObjCopy(p, iObj), Bac_ObjCopy(p, Bac_ObjFanin(p, iObj)) ); |
| } |
| static inline void Bac_NtkMoveNames( Bac_Ntk_t * pNew, Bac_Ntk_t * p ) |
| { |
| int i, iBox, iObj; |
| assert( Bac_NtkHasNames(p) ); |
| assert( !Bac_NtkHasNames(pNew) ); |
| Bac_NtkStartNames( pNew ); |
| Bac_NtkForEachPi( p, iObj, i ) |
| Bac_ObjSetName( pNew, Bac_ObjCopy(p, iObj), Bac_ObjName(p, iObj) ); |
| Bac_NtkForEachBoxUser( p, iBox ) |
| { |
| Bac_ObjSetName( pNew, Bac_ObjCopy(p, iBox), Bac_ObjName(p, iBox) ); |
| Bac_BoxForEachBo( p, iBox, iObj, i ) |
| Bac_ObjSetName( pNew, Bac_ObjCopy(p, iObj), Bac_ObjName(p, iObj) ); |
| } |
| Bac_NtkForEachBoxUser( p, iBox ) |
| Bac_BoxForEachBi( p, iBox, iObj, i ) |
| if ( !Bac_ObjName(pNew, Bac_ObjFanin(pNew, Bac_ObjCopy(p, iObj))) ) |
| Bac_ObjSetName( pNew, Bac_ObjFanin(pNew, Bac_ObjCopy(p, iObj)), Bac_ObjName(p, iObj) ); |
| Bac_NtkForEachPo( p, iObj, i ) |
| if ( !Bac_ObjName(pNew, Bac_ObjFanin(pNew, Bac_ObjCopy(p, iObj))) ) |
| Bac_ObjSetName( pNew, Bac_ObjFanin(pNew, Bac_ObjCopy(p, iObj)), Bac_ObjName(p, iObj) ); |
| } |
| |
| static inline void Bac_NtkFree( Bac_Ntk_t * p ) |
| { |
| Vec_IntErase( &p->vInputs ); |
| Vec_IntErase( &p->vOutputs ); |
| Vec_IntErase( &p->vInfo ); |
| Vec_StrErase( &p->vType ); |
| Vec_IntErase( &p->vFanin ); |
| Vec_IntErase( &p->vIndex ); |
| Vec_IntErase( &p->vName ); |
| Vec_IntErase( &p->vFanout ); |
| Vec_IntErase( &p->vCopy ); |
| Vec_IntErase( &p->vArray ); |
| Vec_IntErase( &p->vArray2 ); |
| } |
| static inline int Bac_NtkMemory( Bac_Ntk_t * p ) |
| { |
| int nMem = sizeof(Bac_Ntk_t); |
| nMem += (int)Vec_IntMemory(&p->vInputs); |
| nMem += (int)Vec_IntMemory(&p->vOutputs); |
| nMem += (int)Vec_IntMemory(&p->vInfo); |
| nMem += (int)Vec_StrMemory(&p->vType); |
| nMem += (int)Vec_IntMemory(&p->vFanin); |
| nMem += (int)Vec_IntMemory(&p->vIndex); |
| nMem += (int)Vec_IntMemory(&p->vName); |
| nMem += (int)Vec_IntMemory(&p->vFanout); |
| nMem += (int)Vec_IntMemory(&p->vCopy); |
| return nMem; |
| } |
| static inline void Bac_NtkPrintStats( Bac_Ntk_t * p ) |
| { |
| printf( "pi =%5d ", Bac_NtkPiNum(p) ); |
| printf( "pi =%5d ", Bac_NtkPoNum(p) ); |
| printf( "box =%6d ", Bac_NtkBoxNum(p) ); |
| printf( "clp =%7d ", p->Count ); |
| printf( "obj =%7d ", Bac_NtkObjNum(p) ); |
| printf( "%s ", Bac_NtkName(p) ); |
| if ( Bac_NtkHostNtk(p) ) |
| printf( "-> %s", Bac_NtkName(Bac_NtkHostNtk(p)) ); |
| printf( "\n" ); |
| } |
| static inline void Bac_NtkDeriveIndex( Bac_Ntk_t * p ) |
| { |
| int i, iObj, iTerm; |
| Vec_IntFill( &p->vIndex, Bac_NtkObjNum(p), -1 ); |
| Bac_NtkForEachPi( p, iObj, i ) |
| Bac_ObjSetIndex( p, iObj, i ); |
| Bac_NtkForEachPo( p, iObj, i ) |
| Bac_ObjSetIndex( p, iObj, i ); |
| Bac_NtkForEachBox( p, iObj ) |
| { |
| Bac_BoxForEachBi( p, iObj, iTerm, i ) |
| Bac_ObjSetIndex( p, iTerm, i ); |
| Bac_BoxForEachBo( p, iObj, iTerm, i ) |
| Bac_ObjSetIndex( p, iTerm, i ); |
| } |
| } |
| static inline void Bac_NtkPrint( Bac_Ntk_t * p ) |
| { |
| int i, Type, Value, Beg, End; |
| printf( "Interface (%d):\n", Bac_NtkInfoNum(p) ); |
| Vec_IntForEachEntryTriple( &p->vInfo, Value, Beg, End, i ) |
| { |
| printf( "%6d : ", i ); |
| printf( "Type =%3d ", Bac_NtkInfoType(p, i/3) ); |
| if ( Beg >= 0 ) |
| printf( "[%d:%d] ", End, Beg ); |
| else |
| printf( " " ); |
| printf( "Name =%3d ", Bac_NtkInfoName(p, i/3) ); |
| if ( Bac_NtkInfoName(p, i/3) ) |
| printf( "%s", Bac_NtkStr( p, Bac_NtkInfoName(p, i/3) ) ); |
| printf( "\n" ); |
| } |
| printf( "Objects (%d):\n", Bac_NtkObjNum(p) ); |
| Bac_NtkForEachObjType( p, Type, i ) |
| { |
| printf( "%6d : ", i ); |
| printf( "Type =%3d ", Type ); |
| if ( Bac_ObjIsCo(p, i) ) |
| printf( "Fanin =%6d ", Bac_ObjFanin(p, i) ); |
| else if ( Bac_NtkHasNames(p) && Bac_ObjName(p, i) ) |
| { |
| printf( "Name =%6d(%d) ", Bac_ObjNameId(p, i), Bac_ObjNameType(p, i) ); |
| if ( Bac_ObjNameType(p, i) <= BAC_NAME_WORD ) |
| printf( "%s", Bac_ObjNameStr(p, i) ); |
| } |
| printf( "\n" ); |
| } |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [Manager APIs.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static inline Bac_Man_t * Bac_ManAlloc( char * pFileName, int nNtks ) |
| { |
| extern void Bac_ManSetupTypes( char ** pNames, char ** pSymbs ); |
| Bac_Ntk_t * pNtk; int i; |
| Bac_Man_t * pNew = ABC_CALLOC( Bac_Man_t, 1 ); |
| pNew->pName = Extra_FileDesignName( pFileName ); |
| pNew->pSpec = Abc_UtilStrsav( pFileName ); |
| pNew->pStrs = Abc_NamStart( 1000, 24 ); |
| pNew->pMods = Abc_NamStart( 1000, 24 ); |
| pNew->iRoot = 1; |
| pNew->nNtks = nNtks; |
| pNew->pNtks = ABC_CALLOC( Bac_Ntk_t, pNew->nNtks + 1 ); |
| Bac_ManForEachNtk( pNew, pNtk, i ) |
| pNtk->pDesign = pNew; |
| Bac_ManSetupTypes( pNew->pPrimNames, pNew->pPrimSymbs ); |
| return pNew; |
| } |
| static inline Bac_Man_t * Bac_ManStart( Bac_Man_t * p, int nNtks ) |
| { |
| Bac_Ntk_t * pNtk; int i; |
| Bac_Man_t * pNew = ABC_CALLOC( Bac_Man_t, 1 ); |
| pNew->pName = Abc_UtilStrsav( Bac_ManName(p) ); |
| pNew->pSpec = Abc_UtilStrsav( Bac_ManSpec(p) ); |
| pNew->pStrs = Abc_NamRef( p->pStrs ); |
| pNew->pMods = Abc_NamStart( 1000, 24 ); |
| pNew->iRoot = 1; |
| pNew->nNtks = nNtks; |
| pNew->pNtks = ABC_CALLOC( Bac_Ntk_t, nNtks + 1 ); |
| Bac_ManForEachNtk( pNew, pNtk, i ) |
| pNtk->pDesign = pNew; |
| return pNew; |
| } |
| static inline Bac_Man_t * Bac_ManDup( Bac_Man_t * p ) |
| { |
| Bac_Ntk_t * pNtk, * pHost; int i; |
| Bac_Man_t * pNew = Bac_ManStart( p, Bac_ManNtkNum(p) ); |
| Bac_ManForEachNtk( p, pNtk, i ) |
| Bac_NtkSetCopy( pNtk, i ); |
| Bac_ManForEachNtk( p, pNtk, i ) |
| Bac_NtkDup( Bac_NtkCopyNtk(pNew, pNtk), pNtk ); |
| Bac_ManForEachNtk( p, pNtk, i ) |
| if ( (pHost = Bac_NtkHostNtk(pNtk)) ) |
| Bac_NtkSetHost( Bac_NtkCopyNtk(pNew, pNtk), Bac_NtkCopy(pHost), Bac_ObjCopy(pHost, Bac_NtkHostObj(pNtk)) ); |
| return pNew; |
| } |
| static inline Bac_Man_t * Bac_ManDupUserBoxes( Bac_Man_t * p ) |
| { |
| Bac_Ntk_t * pNtk, * pHost; int i; |
| Bac_Man_t * pNew = Bac_ManStart( p, Bac_ManNtkNum(p) ); |
| Bac_ManForEachNtk( p, pNtk, i ) |
| Bac_NtkSetCopy( pNtk, i ); |
| Bac_ManForEachNtk( p, pNtk, i ) |
| Bac_NtkDupUserBoxes( Bac_NtkCopyNtk(pNew, pNtk), pNtk ); |
| Bac_ManForEachNtk( p, pNtk, i ) |
| if ( (pHost = Bac_NtkHostNtk(pNtk)) ) |
| Bac_NtkSetHost( Bac_NtkCopyNtk(pNew, pNtk), Bac_NtkCopy(pHost), Bac_ObjCopy(pHost, Bac_NtkHostObj(pNtk)) ); |
| return pNew; |
| } |
| static inline void Bac_ManMoveNames( Bac_Man_t * pNew, Bac_Man_t * p ) |
| { |
| Bac_Ntk_t * pNtk; int i; |
| Bac_ManForEachNtk( p, pNtk, i ) |
| Bac_NtkMoveNames( Bac_NtkCopyNtk(pNew, pNtk), pNtk ); |
| } |
| |
| |
| static inline void Bac_ManFree( Bac_Man_t * p ) |
| { |
| Bac_Ntk_t * pNtk; int i; |
| Bac_ManForEachNtk( p, pNtk, i ) |
| Bac_NtkFree( pNtk ); |
| Vec_IntErase( &p->vBuf2LeafNtk ); |
| Vec_IntErase( &p->vBuf2LeafObj ); |
| Vec_IntErase( &p->vBuf2RootNtk ); |
| Vec_IntErase( &p->vBuf2RootObj ); |
| Abc_NamDeref( p->pStrs ); |
| Abc_NamDeref( p->pMods ); |
| ABC_FREE( p->pName ); |
| ABC_FREE( p->pSpec ); |
| ABC_FREE( p->pNtks ); |
| ABC_FREE( p ); |
| } |
| static inline int Bac_ManMemory( Bac_Man_t * p ) |
| { |
| Bac_Ntk_t * pNtk; int i; |
| int nMem = sizeof(Bac_Man_t); |
| if ( p->pName ) |
| nMem += (int)strlen(p->pName); |
| if ( p->pSpec ) |
| nMem += (int)strlen(p->pSpec); |
| nMem += Abc_NamMemUsed(p->pStrs); |
| nMem += Abc_NamMemUsed(p->pMods); |
| Bac_ManForEachNtk( p, pNtk, i ) |
| nMem += Bac_NtkMemory( pNtk ); |
| return nMem; |
| } |
| static inline int Bac_ManObjNum( Bac_Man_t * p ) |
| { |
| Bac_Ntk_t * pNtk; int i, Count = 0; |
| Bac_ManForEachNtk( p, pNtk, i ) |
| Count += Bac_NtkObjNum(pNtk); |
| return Count; |
| } |
| static inline int Bac_ManNodeNum( Bac_Man_t * p ) |
| { |
| Bac_Ntk_t * pNtk; int i, Count = 0; |
| Bac_ManForEachNtk( p, pNtk, i ) |
| Count += Bac_NtkBoxNum( pNtk ); |
| return Count; |
| } |
| static inline int Bac_ManBoxNum_rec( Bac_Ntk_t * p ) |
| { |
| int iObj, Counter = 0; |
| if ( p->Count >= 0 ) |
| return p->Count; |
| Bac_NtkForEachBox( p, iObj ) |
| Counter += Bac_ObjIsBoxUser(p, iObj) ? Bac_ManBoxNum_rec( Bac_BoxNtk(p, iObj) ) : 1; |
| return (p->Count = Counter); |
| } |
| static inline int Bac_ManBoxNum( Bac_Man_t * p ) |
| { |
| Bac_Ntk_t * pNtk; int i; |
| Bac_ManForEachNtk( p, pNtk, i ) |
| pNtk->Count = -1; |
| return Bac_ManBoxNum_rec( Bac_ManRoot(p) ); |
| } |
| static inline void Bac_ManPrintStats( Bac_Man_t * p, int nModules, int fVerbose ) |
| { |
| Bac_Ntk_t * pNtk; int i; |
| Bac_Ntk_t * pRoot = Bac_ManRoot( p ); |
| printf( "%-12s : ", Bac_ManName(p) ); |
| printf( "pi =%5d ", Bac_NtkPiNum(pRoot) ); |
| printf( "po =%5d ", Bac_NtkPoNum(pRoot) ); |
| printf( "pri =%4d ", Bac_ManPrimNum(p) ); |
| printf( "mod =%6d ", Bac_ManNtkNum(p) ); |
| printf( "box =%7d ", Bac_ManNodeNum(p) ); |
| printf( "obj =%7d ", Bac_ManObjNum(p) ); |
| printf( "mem =%6.3f MB", 1.0*Bac_ManMemory(p)/(1<<20) ); |
| printf( "\n" ); |
| Bac_ManBoxNum( p ); |
| Bac_ManForEachNtk( p, pNtk, i ) |
| { |
| if ( i == nModules+1 ) |
| break; |
| printf( "Module %5d : ", i ); |
| Bac_NtkPrintStats( pNtk ); |
| } |
| } |
| |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [Other APIs.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static inline Bac_ObjType_t Ptr_SopToType( char * pSop ) |
| { |
| if ( !strcmp(pSop, " 0\n") ) return BAC_BOX_CF; |
| if ( !strcmp(pSop, " 1\n") ) return BAC_BOX_CT; |
| if ( !strcmp(pSop, "1 1\n") ) return BAC_BOX_BUF; |
| if ( !strcmp(pSop, "0 1\n") ) return BAC_BOX_INV; |
| if ( !strcmp(pSop, "11 1\n") ) return BAC_BOX_AND; |
| if ( !strcmp(pSop, "00 1\n") ) return BAC_BOX_NOR; |
| if ( !strcmp(pSop, "00 0\n") ) return BAC_BOX_OR; |
| if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return BAC_BOX_OR; |
| if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return BAC_BOX_OR; |
| if ( !strcmp(pSop, "01 1\n10 1\n") ) return BAC_BOX_XOR; |
| if ( !strcmp(pSop, "10 1\n01 1\n") ) return BAC_BOX_XOR; |
| if ( !strcmp(pSop, "11 1\n00 1\n") ) return BAC_BOX_XNOR; |
| if ( !strcmp(pSop, "00 1\n11 1\n") ) return BAC_BOX_XNOR; |
| if ( !strcmp(pSop, "10 1\n") ) return BAC_BOX_SHARP; |
| if ( !strcmp(pSop, "01 1\n") ) return BAC_BOX_SHARPL; |
| assert( 0 ); |
| return BAC_OBJ_NONE; |
| } |
| static inline char * Ptr_SopToTypeName( char * pSop ) |
| { |
| if ( !strcmp(pSop, " 0\n") ) return "BAC_BOX_C0"; |
| if ( !strcmp(pSop, " 1\n") ) return "BAC_BOX_C1"; |
| if ( !strcmp(pSop, "1 1\n") ) return "BAC_BOX_BUF"; |
| if ( !strcmp(pSop, "0 1\n") ) return "BAC_BOX_INV"; |
| if ( !strcmp(pSop, "11 1\n") ) return "BAC_BOX_AND"; |
| if ( !strcmp(pSop, "00 1\n") ) return "BAC_BOX_NOR"; |
| if ( !strcmp(pSop, "00 0\n") ) return "BAC_BOX_OR"; |
| if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return "BAC_BOX_OR"; |
| if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return "BAC_BOX_OR"; |
| if ( !strcmp(pSop, "01 1\n10 1\n") ) return "BAC_BOX_XOR"; |
| if ( !strcmp(pSop, "10 1\n01 1\n") ) return "BAC_BOX_XOR"; |
| if ( !strcmp(pSop, "11 1\n00 1\n") ) return "BAC_BOX_XNOR"; |
| if ( !strcmp(pSop, "00 1\n11 1\n") ) return "BAC_BOX_XNOR"; |
| if ( !strcmp(pSop, "10 1\n") ) return "BAC_BOX_SHARP"; |
| if ( !strcmp(pSop, "01 1\n") ) return "BAC_BOX_SHARPL"; |
| assert( 0 ); |
| return NULL; |
| } |
| static inline char * Ptr_TypeToName( Bac_ObjType_t Type ) |
| { |
| if ( Type == BAC_BOX_CF ) return "const0"; |
| if ( Type == BAC_BOX_CT ) return "const1"; |
| if ( Type == BAC_BOX_CX ) return "constX"; |
| if ( Type == BAC_BOX_CZ ) return "constZ"; |
| if ( Type == BAC_BOX_BUF ) return "buf"; |
| if ( Type == BAC_BOX_INV ) return "not"; |
| if ( Type == BAC_BOX_AND ) return "and"; |
| if ( Type == BAC_BOX_NAND ) return "nand"; |
| if ( Type == BAC_BOX_OR ) return "or"; |
| if ( Type == BAC_BOX_NOR ) return "nor"; |
| if ( Type == BAC_BOX_XOR ) return "xor"; |
| if ( Type == BAC_BOX_XNOR ) return "xnor"; |
| if ( Type == BAC_BOX_MUX ) return "mux"; |
| if ( Type == BAC_BOX_MAJ ) return "maj"; |
| if ( Type == BAC_BOX_SHARP ) return "sharp"; |
| if ( Type == BAC_BOX_SHARPL) return "sharpl"; |
| assert( 0 ); |
| return "???"; |
| } |
| static inline char * Ptr_TypeToSop( Bac_ObjType_t Type ) |
| { |
| if ( Type == BAC_BOX_CF ) return " 0\n"; |
| if ( Type == BAC_BOX_CT ) return " 1\n"; |
| if ( Type == BAC_BOX_CX ) return " 0\n"; |
| if ( Type == BAC_BOX_CZ ) return " 0\n"; |
| if ( Type == BAC_BOX_BUF ) return "1 1\n"; |
| if ( Type == BAC_BOX_INV ) return "0 1\n"; |
| if ( Type == BAC_BOX_AND ) return "11 1\n"; |
| if ( Type == BAC_BOX_NAND ) return "11 0\n"; |
| if ( Type == BAC_BOX_OR ) return "00 0\n"; |
| if ( Type == BAC_BOX_NOR ) return "00 1\n"; |
| if ( Type == BAC_BOX_XOR ) return "01 1\n10 1\n"; |
| if ( Type == BAC_BOX_XNOR ) return "00 1\n11 1\n"; |
| if ( Type == BAC_BOX_SHARP ) return "10 1\n"; |
| if ( Type == BAC_BOX_SHARPL) return "01 1\n"; |
| if ( Type == BAC_BOX_MUX ) return "11- 1\n0-1 1\n"; |
| if ( Type == BAC_BOX_MAJ ) return "11- 1\n1-1 1\n-11 1\n"; |
| assert( 0 ); |
| return "???"; |
| } |
| |
| /*=== bacCom.c ===============================================================*/ |
| extern void Abc_FrameImportPtr( Vec_Ptr_t * vPtr ); |
| extern Vec_Ptr_t * Abc_FrameExportPtr(); |
| |
| /*=== bacBlast.c =============================================================*/ |
| extern int Bac_NtkBuildLibrary( Bac_Man_t * p ); |
| extern Gia_Man_t * Bac_ManExtract( Bac_Man_t * p, int fBuffers, int fVerbose ); |
| extern Bac_Man_t * Bac_ManInsertGia( Bac_Man_t * p, Gia_Man_t * pGia ); |
| extern void * Bac_ManInsertAbc( Bac_Man_t * p, void * pAbc ); |
| /*=== bacCba.c ===============================================================*/ |
| extern Bac_Man_t * Bac_ManReadBac( char * pFileName ); |
| extern void Bac_ManWriteBac( char * pFileName, Bac_Man_t * p ); |
| /*=== bacNtk.c ===============================================================*/ |
| extern char * Bac_NtkGenerateName( Bac_Ntk_t * p, Bac_ObjType_t Type, Vec_Int_t * vBits ); |
| extern Bac_ObjType_t Bac_NameToType( char * pName ); |
| extern Vec_Int_t * Bac_NameToRanges( char * pName ); |
| extern void Bac_NtkUpdateFanout( Bac_Ntk_t * p, int iOld, int iNew ); |
| extern void Bac_ManDeriveFanout( Bac_Man_t * p ); |
| //extern void Bac_ManAssignInternNames( Bac_Man_t * p ); |
| extern void Bac_ManAssignInternWordNames( Bac_Man_t * p ); |
| extern Bac_Man_t * Bac_ManCollapse( Bac_Man_t * p ); |
| extern void Bac_ManSetupTypes( char ** pNames, char ** pSymbs ); |
| /*=== bacPtr.c ===============================================================*/ |
| extern void Bac_PtrFree( Vec_Ptr_t * vDes ); |
| extern int Bac_PtrMemory( Vec_Ptr_t * vDes ); |
| extern void Bac_PtrDumpBlif( char * pFileName, Vec_Ptr_t * vDes ); |
| extern void Bac_PtrDumpVerilog( char * pFileName, Vec_Ptr_t * vDes ); |
| extern Vec_Ptr_t * Bac_PtrTransformTest( Vec_Ptr_t * vDes ); |
| /*=== bacPtrAbc.c ============================================================*/ |
| extern Bac_Man_t * Bac_PtrTransformToCba( Vec_Ptr_t * vDes ); |
| extern Vec_Ptr_t * Bac_PtrDeriveFromCba( Bac_Man_t * p ); |
| /*=== bacPrsBuild.c ==========================================================*/ |
| extern Bac_Man_t * Psr_ManBuildCba( char * pFileName, Vec_Ptr_t * vDes ); |
| /*=== bacReadBlif.c ==========================================================*/ |
| extern Vec_Ptr_t * Psr_ManReadBlif( char * pFileName ); |
| /*=== bacReadSmt.c ===========================================================*/ |
| extern Vec_Ptr_t * Psr_ManReadSmt( char * pFileName ); |
| /*=== bacReadVer.c ===========================================================*/ |
| extern Vec_Ptr_t * Psr_ManReadVerilog( char * pFileName ); |
| /*=== bacWriteBlif.c =========================================================*/ |
| extern void Psr_ManWriteBlif( char * pFileName, Vec_Ptr_t * p ); |
| extern void Bac_ManWriteBlif( char * pFileName, Bac_Man_t * p ); |
| /*=== bacWriteVer.c ==========================================================*/ |
| extern void Psr_ManWriteVerilog( char * pFileName, Vec_Ptr_t * p ); |
| extern void Bac_ManWriteVerilog( char * pFileName, Bac_Man_t * p, int fUseAssign ); |
| |
| ABC_NAMESPACE_HEADER_END |
| |
| #endif |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// END OF FILE /// |
| //////////////////////////////////////////////////////////////////////// |
| |
