#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "misc/vec/vec.h"
#include "aig/hop/hop.h"
#include "aig/gia/gia.h"
#include "misc/st/st.h"
#include "misc/st/stmm.h"
#include "misc/nm/nm.h"
#include "misc/mem/mem.h"
#include "misc/util/utilCex.h"
#include "misc/extra/extra.h"

Include dependency graph for abc.h:

Classes
struct	Abc_Time_t_

struct	Abc_Obj_t_

struct	Abc_Ntk_t_

struct	Abc_Des_t_

Macros
#define	Abc_NtkForEachObj(pNtk, pObj, i)
	ITERATORS ///.

#define	Abc_NtkForEachObjReverse(pNtk, pNode, i)

#define	Abc_NtkForEachObjVec(vIds, pNtk, pObj, i)

#define	Abc_NtkForEachObjVecStart(vIds, pNtk, pObj, i, Start)

#define	Abc_NtkForEachNet(pNtk, pNet, i)

#define	Abc_NtkForEachNode(pNtk, pNode, i)

#define	Abc_NtkForEachNodeNotBarBuf(pNtk, pNode, i)

#define	Abc_NtkForEachNode1(pNtk, pNode, i)

#define	Abc_NtkForEachNodeNotBarBuf1(pNtk, pNode, i)

#define	Abc_NtkForEachNodeReverse(pNtk, pNode, i)

#define	Abc_NtkForEachNodeReverse1(pNtk, pNode, i)

#define	Abc_NtkForEachBarBuf(pNtk, pNode, i)

#define	Abc_NtkForEachGate(pNtk, pNode, i)

#define	Abc_AigForEachAnd(pNtk, pNode, i)

#define	Abc_NtkForEachNodeCi(pNtk, pNode, i)

#define	Abc_NtkForEachNodeCo(pNtk, pNode, i)

#define	Abc_NtkForEachBox(pNtk, pObj, i)

#define	Abc_NtkForEachLatch(pNtk, pObj, i)

#define	Abc_NtkForEachLatchInput(pNtk, pObj, i)

#define	Abc_NtkForEachLatchOutput(pNtk, pObj, i)

#define	Abc_NtkForEachWhitebox(pNtk, pObj, i)

#define	Abc_NtkForEachBlackbox(pNtk, pObj, i)

#define	Abc_NtkForEachPi(pNtk, pPi, i)

#define	Abc_NtkForEachCi(pNtk, pCi, i)

#define	Abc_NtkForEachPo(pNtk, pPo, i)

#define	Abc_NtkForEachCo(pNtk, pCo, i)

#define	Abc_NtkForEachLiPo(pNtk, pCo, i)

#define	Abc_ObjForEachFanin(pObj, pFanin, i)

#define	Abc_ObjForEachFanout(pObj, pFanout, i)

#define	Abc_ObjForEachFaninId(pObj, iFanin, i)

#define	Abc_ObjForEachFanoutId(pObj, iFanout, i)

#define	Abc_CubeForEachVar(pCube, Value, i)

#define	Abc_SopForEachCube(pSop, nFanins, pCube)

#define	Abc_SopForEachCubePair(pSop, nFanins, pCube, pCube2)

Typedefs
typedef struct Abc_Des_t_	Abc_Des_t
	BASIC TYPES ///.

typedef struct Abc_Ntk_t_	Abc_Ntk_t

typedef struct Abc_Obj_t_	Abc_Obj_t

typedef struct Abc_Aig_t_	Abc_Aig_t

typedef struct Abc_ManTime_t_	Abc_ManTime_t

typedef struct Abc_ManCut_t_	Abc_ManCut_t

typedef struct Abc_Time_t_	Abc_Time_t

typedef struct Odc_Man_t_	Odc_Man_t

Enumerations
enum	Abc_NtkType_t { ABC_NTK_NONE = 0 , ABC_NTK_NETLIST , ABC_NTK_LOGIC , ABC_NTK_STRASH , ABC_NTK_OTHER }
	INCLUDES ///. More...

enum	Abc_NtkFunc_t { ABC_FUNC_NONE = 0 , ABC_FUNC_SOP , ABC_FUNC_BDD , ABC_FUNC_AIG , ABC_FUNC_MAP , ABC_FUNC_BLIFMV , ABC_FUNC_BLACKBOX , ABC_FUNC_OTHER }

enum	Abc_ObjType_t { ABC_OBJ_NONE = 0 , ABC_OBJ_CONST1 , ABC_OBJ_PI , ABC_OBJ_PO , ABC_OBJ_BI , ABC_OBJ_BO , ABC_OBJ_NET , ABC_OBJ_NODE , ABC_OBJ_LATCH , ABC_OBJ_WHITEBOX , ABC_OBJ_BLACKBOX , ABC_OBJ_NUMBER }

enum	Abc_InitType_t { ABC_INIT_NONE = 0 , ABC_INIT_ZERO , ABC_INIT_ONE , ABC_INIT_DC , ABC_INIT_OTHER }

Functions
ABC_DLL Abc_Obj_t *	Abc_NtkCreateObj (Abc_Ntk_t *pNtk, Abc_ObjType_t Type)

ABC_DLL Abc_Aig_t *	Abc_AigAlloc (Abc_Ntk_t *pNtk)
	FUNCTION DECLARATIONS ///.

ABC_DLL void	Abc_AigFree (Abc_Aig_t *pMan)

ABC_DLL int	Abc_AigCleanup (Abc_Aig_t *pMan)

ABC_DLL int	Abc_AigCheck (Abc_Aig_t *pMan)

ABC_DLL int	Abc_AigLevel (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Obj_t *	Abc_AigConst1 (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Obj_t *	Abc_AigAnd (Abc_Aig_t pMan, Abc_Obj_t p0, Abc_Obj_t *p1)

ABC_DLL Abc_Obj_t *	Abc_AigAndLookup (Abc_Aig_t pMan, Abc_Obj_t p0, Abc_Obj_t *p1)

ABC_DLL Abc_Obj_t *	Abc_AigXorLookup (Abc_Aig_t pMan, Abc_Obj_t p0, Abc_Obj_t p1, int pType)

ABC_DLL Abc_Obj_t *	Abc_AigMuxLookup (Abc_Aig_t pMan, Abc_Obj_t pC, Abc_Obj_t pT, Abc_Obj_t pE, int *pType)

ABC_DLL Abc_Obj_t *	Abc_AigOr (Abc_Aig_t pMan, Abc_Obj_t p0, Abc_Obj_t *p1)

ABC_DLL Abc_Obj_t *	Abc_AigXor (Abc_Aig_t pMan, Abc_Obj_t p0, Abc_Obj_t *p1)

ABC_DLL Abc_Obj_t *	Abc_AigMux (Abc_Aig_t pMan, Abc_Obj_t pC, Abc_Obj_t p1, Abc_Obj_t p0)

ABC_DLL Abc_Obj_t *	Abc_AigMiter (Abc_Aig_t pMan, Vec_Ptr_t vPairs, int fImplic)

ABC_DLL int	Abc_AigReplace (Abc_Aig_t pMan, Abc_Obj_t pOld, Abc_Obj_t *pNew, int fUpdateLevel)

ABC_DLL void	Abc_AigDeleteNode (Abc_Aig_t pMan, Abc_Obj_t pOld)

ABC_DLL void	Abc_AigRehash (Abc_Aig_t *pMan)

ABC_DLL int	Abc_AigNodeHasComplFanoutEdge (Abc_Obj_t *pNode)

ABC_DLL int	Abc_AigNodeHasComplFanoutEdgeTrav (Abc_Obj_t *pNode)

ABC_DLL void	Abc_AigPrintNode (Abc_Obj_t *pNode)

ABC_DLL int	Abc_AigNodeIsAcyclic (Abc_Obj_t pNode, Abc_Obj_t pRoot)

ABC_DLL void	Abc_AigCheckFaninOrder (Abc_Aig_t *pMan)

ABC_DLL void	Abc_AigSetNodePhases (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_AigUpdateStart (Abc_Aig_t pMan, Vec_Ptr_t *pvUpdatedNets)

ABC_DLL void	Abc_AigUpdateStop (Abc_Aig_t *pMan)

ABC_DLL void	Abc_AigUpdateReset (Abc_Aig_t *pMan)

ABC_DLL int	Abc_NtkAttach (Abc_Ntk_t *pNtk)
	FUNCTION DEFINITIONS ///.

ABC_DLL Abc_Ntk_t *	Abc_NtkToBarBufs (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkFromBarBufs (Abc_Ntk_t pNtkBase, Abc_Ntk_t pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkBarBufsToBuffers (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkBarBufsFromBuffers (Abc_Ntk_t pNtkBase, Abc_Ntk_t pNtk)

ABC_DLL void	Abc_NtkStartMvVars (Abc_Ntk_t *pNtk)
	DECLARATIONS ///.

ABC_DLL void	Abc_NtkFreeMvVars (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkSetMvVarValues (Abc_Obj_t *pObj, int nValues)

ABC_DLL Abc_Ntk_t *	Abc_NtkStrashBlifMv (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkInsertBlifMv (Abc_Ntk_t pNtkBase, Abc_Ntk_t pNtkLogic)

ABC_DLL int	Abc_NtkConvertToBlifMv (Abc_Ntk_t *pNtk)

ABC_DLL char *	Abc_NodeConvertSopToMvSop (int nVars, Vec_Int_t vSop0, Vec_Int_t vSop1)

ABC_DLL int	Abc_NodeEvalMvCost (int nVars, Vec_Int_t vSop0, Vec_Int_t vSop1)

ABC_DLL Abc_Ntk_t *	Abc_NtkBalance (Abc_Ntk_t *pNtk, int fDuplicate, int fSelective, int fUpdateLevel)
	FUNCTION DEFINITIONS ///.

ABC_DLL int	Abc_NtkCheck (Abc_Ntk_t *pNtk)
	FUNCTION DEFINITIONS ///.

ABC_DLL int	Abc_NtkCheckRead (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkDoCheck (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkCheckObj (Abc_Ntk_t pNtk, Abc_Obj_t pObj)

ABC_DLL int	Abc_NtkCompareSignals (Abc_Ntk_t pNtk1, Abc_Ntk_t pNtk2, int fOnlyPis, int fComb)

ABC_DLL int	Abc_NtkIsAcyclicHierarchy (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkCheckUniqueCiNames (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkCheckUniqueCoNames (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkCheckUniqueCioNames (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkCollapse (Abc_Ntk_t *pNtk, int fBddSizeMax, int fDualRail, int fReorder, int fReverse, int fDumpOrder, int fVerbose)
	DECLARATIONS ///.

ABC_DLL Abc_Ntk_t *	Abc_NtkCollapseSat (Abc_Ntk_t *pNtk, int nCubeLim, int nBTLimit, int nCostMax, int fCanon, int fReverse, int fCnfShared, int fVerbose)

ABC_DLL Gia_Man_t *	Abc_NtkClpGia (Abc_Ntk_t *pNtk)

ABC_DLL void *	Abc_NodeGetCutsRecursive (void p, Abc_Obj_t pObj, int fDag, int fTree)

ABC_DLL void *	Abc_NodeGetCuts (void p, Abc_Obj_t pObj, int fDag, int fTree)

ABC_DLL void	Abc_NodeGetCutsSeq (void p, Abc_Obj_t pObj, int fFirst)

ABC_DLL void *	Abc_NodeReadCuts (void p, Abc_Obj_t pObj)

ABC_DLL void	Abc_NodeFreeCuts (void p, Abc_Obj_t pObj)

ABC_DLL int	Abc_NtkPhaseFrameNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkDarPrintCone (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkBalanceExor (Abc_Ntk_t *pNtk, int fUpdateLevel, int fVerbose)

ABC_DLL Abc_Ntk_t *	Abc_NtkDarLatchSweep (Abc_Ntk_t *pNtk, int fLatchConst, int fLatchEqual, int fSaveNames, int fUseMvSweep, int nFramesSymb, int nFramesSatur, int fVerbose, int fVeryVerbose)

ABC_DLL float	Abc_NtkDelayTraceLut (Abc_Ntk_t *pNtk, int fUseLutLib)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfs (Abc_Ntk_t *pNtk, int fCollectAll)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfs2 (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfsNodes (Abc_Ntk_t pNtk, Abc_Obj_t *ppNodes, int nNodes)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfsReverse (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfsReverseNodes (Abc_Ntk_t pNtk, Abc_Obj_t *ppNodes, int nNodes)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfsReverseNodesContained (Abc_Ntk_t pNtk, Abc_Obj_t *ppNodes, int nNodes)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfsSeq (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfsSeqReverse (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfsIter (Abc_Ntk_t *pNtk, int fCollectAll)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfsIterNodes (Abc_Ntk_t pNtk, Vec_Ptr_t vRoots)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfsHie (Abc_Ntk_t *pNtk, int fCollectAll)

ABC_DLL int	Abc_NtkIsDfsOrdered (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_NtkDfsWithBoxes (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_NtkSupport (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_NtkNodeSupport (Abc_Ntk_t pNtk, Abc_Obj_t *ppNodes, int nNodes)

ABC_DLL Vec_Int_t *	Abc_NtkNodeSupportInt (Abc_Ntk_t *pNtk, int iCo)

ABC_DLL int	Abc_NtkFunctionalIso (Abc_Ntk_t *pNtk, int iCo1, int iCo2, int fCommon)

ABC_DLL Vec_Ptr_t *	Abc_AigDfs (Abc_Ntk_t *pNtk, int fCollectAll, int fCollectCos)

ABC_DLL Vec_Ptr_t *	Abc_AigDfsMap (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Vec_t *	Abc_DfsLevelized (Abc_Obj_t *pNode, int fTfi)

ABC_DLL Vec_Vec_t *	Abc_NtkLevelize (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkLevel (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkLevelR (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkLevelReverse (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkIsAcyclic (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkIsAcyclicWithBoxes (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_AigGetLevelizedOrder (Abc_Ntk_t *pNtk, int fCollectCis)

ABC_DLL int	Abc_ExactInputNum ()

ABC_DLL int	Abc_ExactIsRunning ()

ABC_DLL Abc_Obj_t *	Abc_ExactBuildNode (word pTruth, int nVars, int pArrTimeProfile, Abc_Obj_t *pFanins, Abc_Ntk_t pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkFindExact (word pTruth, int nVars, int nFunc, int nMaxDepth, int pArrivalTimes, int nBTLimit, int nStartGates, int fVerbose)

ABC_DLL void	Abc_ObjAddFanin (Abc_Obj_t pObj, Abc_Obj_t pFanin)

ABC_DLL void	Abc_ObjDeleteFanin (Abc_Obj_t pObj, Abc_Obj_t pFanin)

ABC_DLL void	Abc_ObjRemoveFanins (Abc_Obj_t *pObj)

ABC_DLL void	Abc_ObjPatchFanin (Abc_Obj_t pObj, Abc_Obj_t pFaninOld, Abc_Obj_t *pFaninNew)

ABC_DLL void	Abc_ObjPatchFanoutFanin (Abc_Obj_t *pObj, int iObjNew)

ABC_DLL Abc_Obj_t *	Abc_ObjInsertBetween (Abc_Obj_t pNodeIn, Abc_Obj_t pNodeOut, Abc_ObjType_t Type)

ABC_DLL void	Abc_ObjTransferFanout (Abc_Obj_t pObjOld, Abc_Obj_t pObjNew)

ABC_DLL void	Abc_ObjReplace (Abc_Obj_t pObjOld, Abc_Obj_t pObjNew)

ABC_DLL void	Abc_ObjReplaceByConstant (Abc_Obj_t *pNode, int fConst1)

ABC_DLL int	Abc_ObjFanoutFaninNum (Abc_Obj_t pFanout, Abc_Obj_t pFanin)

ABC_DLL int	Abc_NtkMakeLegit (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkSortSops (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkFraig (Abc_Ntk_t pNtk, void pParams, int fAllNodes, int fExdc)
	FUNCTION DEFINITIONS ///.

ABC_DLL void *	Abc_NtkToFraig (Abc_Ntk_t pNtk, void pParams, int fAllNodes, int fExdc)

ABC_DLL Abc_Ntk_t *	Abc_NtkFraigTrust (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkFraigStore (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkFraigRestore (int nPatsRand, int nPatsDyna, int nBTLimit)

ABC_DLL void	Abc_NtkFraigStoreClean ()

ABC_DLL int	Abc_NtkSopToBdd (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkBddToSop (Abc_Ntk_t *pNtk, int fMode, int nCubeLimit, int fCubeSort)

ABC_DLL void	Abc_NodeBddToCnf (Abc_Obj_t pNode, Mem_Flex_t pMmMan, Vec_Str_t vCube, int fAllPrimes, char ppSop0, char *ppSop1)

ABC_DLL void	Abc_NtkLogicMakeDirectSops (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkSopToAig (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkAigToBdd (Abc_Ntk_t *pNtk)

ABC_DLL Gia_Man_t *	Abc_NtkAigToGia (Abc_Ntk_t *p, int fGiaSimple)

ABC_DLL int	Abc_NtkMapToSopUsingLibrary (Abc_Ntk_t pNtk, void library)

ABC_DLL int	Abc_NtkMapToSop (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkToSop (Abc_Ntk_t *pNtk, int fMode, int nCubeLimit)

ABC_DLL int	Abc_NtkToBdd (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkToAig (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkHaigStart (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkHaigStop (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkHaigUse (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkFlattenLogicHierarchy (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkConvertBlackboxes (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkInsertNewLogic (Abc_Ntk_t pNtkH, Abc_Ntk_t pNtkL)

ABC_DLL void	Abc_NtkPrintBoxInfo (Abc_Ntk_t *pNtk)

ABC_DLL Gia_Man_t *	Abc_NtkFlattenHierarchyGia (Abc_Ntk_t pNtk, Vec_Ptr_t *pvBuffers, int fVerbose)

ABC_DLL void	Abc_NtkInsertHierarchyGia (Abc_Ntk_t pNtk, Abc_Ntk_t pNew, int fVerbose)

ABC_DLL int	Abc_NtkLatchIsSelfFeed (Abc_Obj_t *pLatch)

ABC_DLL int	Abc_NtkCountSelfFeedLatches (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkRemoveSelfFeedLatches (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Int_t *	Abc_NtkCollectLatchValues (Abc_Ntk_t *pNtk)

ABC_DLL char *	Abc_NtkCollectLatchValuesStr (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkInsertLatchValues (Abc_Ntk_t pNtk, Vec_Int_t vValues)

ABC_DLL Abc_Obj_t *	Abc_NtkAddLatch (Abc_Ntk_t pNtk, Abc_Obj_t pDriver, Abc_InitType_t Init)

ABC_DLL void	Abc_NtkConvertDcLatches (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_NtkConverLatchNamesIntoNumbers (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Des_t *	Abc_DesCreate (char *pName)
	DECLARATIONS ///.

ABC_DLL void	Abc_DesCleanManPointer (Abc_Des_t p, void pMan)

ABC_DLL void	Abc_DesFree (Abc_Des_t p, Abc_Ntk_t pNtk)

ABC_DLL Abc_Des_t *	Abc_DesDup (Abc_Des_t *p)

ABC_DLL void	Abc_DesPrint (Abc_Des_t *p)

ABC_DLL int	Abc_DesAddModel (Abc_Des_t p, Abc_Ntk_t pNtk)

ABC_DLL Abc_Ntk_t *	Abc_DesFindModelByName (Abc_Des_t p, char pName)

ABC_DLL int	Abc_DesFindTopLevelModels (Abc_Des_t *p)

ABC_DLL Abc_Ntk_t *	Abc_DesDeriveRoot (Abc_Des_t *p)

ABC_DLL void	Abc_NtkWriteLogFile (char pFileName, Abc_Cex_t pSeqCex, int Status, int nFrames, char *pCommand)
	DECLARATIONS ///.

ABC_DLL Abc_Obj_t *	Abc_NtkFetchTwinNode (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NtkMinimumBase (Abc_Ntk_t *pNtk)
	DECLARATIONS ///.

ABC_DLL int	Abc_NodeMinimumBase (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NtkRemoveDupFanins (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NodeRemoveDupFanins (Abc_Obj_t *pNode)

ABC_DLL Abc_Ntk_t *	Abc_NtkMiter (Abc_Ntk_t pNtk1, Abc_Ntk_t pNtk2, int fComb, int nPartSize, int fImplic, int fMulti)
	FUNCTION DEFINITIONS ///.

ABC_DLL void	Abc_NtkMiterAddCone (Abc_Ntk_t pNtk, Abc_Ntk_t pNtkMiter, Abc_Obj_t *pNode)

ABC_DLL Abc_Ntk_t *	Abc_NtkMiterAnd (Abc_Ntk_t pNtk1, Abc_Ntk_t pNtk2, int fOr, int fCompl2)

ABC_DLL Abc_Ntk_t *	Abc_NtkMiterCofactor (Abc_Ntk_t pNtk, Vec_Int_t vPiValues)

ABC_DLL Abc_Ntk_t *	Abc_NtkMiterForCofactors (Abc_Ntk_t *pNtk, int Out, int In1, int In2)

ABC_DLL Abc_Ntk_t *	Abc_NtkMiterQuantify (Abc_Ntk_t *pNtk, int In, int fExist)

ABC_DLL Abc_Ntk_t *	Abc_NtkMiterQuantifyPis (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkMiterIsConstant (Abc_Ntk_t *pMiter)

ABC_DLL void	Abc_NtkMiterReport (Abc_Ntk_t *pMiter)

ABC_DLL Abc_Ntk_t *	Abc_NtkFrames (Abc_Ntk_t *pNtk, int nFrames, int fInitial, int fVerbose)

ABC_DLL int	Abc_NtkCombinePos (Abc_Ntk_t *pNtk, int fAnd, int fXor)

ABC_DLL char *	Abc_ObjName (Abc_Obj_t *pNode)
	DECLARATIONS ///.

ABC_DLL char *	Abc_ObjAssignName (Abc_Obj_t pObj, char pName, char *pSuffix)

ABC_DLL char *	Abc_ObjNamePrefix (Abc_Obj_t pObj, char pPrefix)

ABC_DLL char *	Abc_ObjNameSuffix (Abc_Obj_t pObj, char pSuffix)

ABC_DLL char *	Abc_ObjNameDummy (char *pPrefix, int Num, int nDigits)

ABC_DLL void	Abc_NtkTrasferNames (Abc_Ntk_t pNtk, Abc_Ntk_t pNtkNew)

ABC_DLL void	Abc_NtkTrasferNamesNoLatches (Abc_Ntk_t pNtk, Abc_Ntk_t pNtkNew)

ABC_DLL Vec_Ptr_t *	Abc_NodeGetFaninNames (Abc_Obj_t *pNode)

ABC_DLL Vec_Ptr_t *	Abc_NodeGetFakeNames (int nNames)

ABC_DLL void	Abc_NodeFreeNames (Vec_Ptr_t *vNames)

ABC_DLL char **	Abc_NtkCollectCioNames (Abc_Ntk_t *pNtk, int fCollectCos)

ABC_DLL int	Abc_NodeCompareNames (Abc_Obj_t pp1, Abc_Obj_t pp2)

ABC_DLL void	Abc_NtkOrderObjsByName (Abc_Ntk_t *pNtk, int fComb)

ABC_DLL void	Abc_NtkAddDummyPiNames (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkAddDummyPoNames (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkAddDummyBoxNames (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkShortNames (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkCharNames (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkCleanNames (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkStartNameIds (Abc_Ntk_t *p)

ABC_DLL void	Abc_NtkTransferNameIds (Abc_Ntk_t p, Abc_Ntk_t pNew)

ABC_DLL void	Abc_NtkUpdateNameIds (Abc_Ntk_t *p)

ABC_DLL Abc_Ntk_t *	Abc_NtkToLogic (Abc_Ntk_t *pNtk)
	FUNCTION DEFINITIONS ///.

ABC_DLL Abc_Ntk_t *	Abc_NtkToNetlist (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkToNetlistBench (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkDeriveFromBdd (void dd, void bFunc, char pNamePo, Vec_Ptr_t vNamesPi)

ABC_DLL Abc_Ntk_t *	Abc_NtkBddToMuxes (Abc_Ntk_t *pNtk, int fGlobal, int Limit, int fUseAdd)

ABC_DLL void *	Abc_NtkBuildGlobalBdds (Abc_Ntk_t *pNtk, int fBddSizeMax, int fDropInternal, int fReorder, int fReverse, int fVerbose)

ABC_DLL void *	Abc_NtkFreeGlobalBdds (Abc_Ntk_t *pNtk, int fFreeMan)

ABC_DLL int	Abc_NtkSizeOfGlobalBdds (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkAlloc (Abc_NtkType_t Type, Abc_NtkFunc_t Func, int fUseMemMan)
	DECLARATIONS ///.

ABC_DLL Abc_Ntk_t *	Abc_NtkStartFrom (Abc_Ntk_t *pNtk, Abc_NtkType_t Type, Abc_NtkFunc_t Func)

ABC_DLL Abc_Ntk_t *	Abc_NtkStartFromNoLatches (Abc_Ntk_t *pNtk, Abc_NtkType_t Type, Abc_NtkFunc_t Func)

ABC_DLL void	Abc_NtkFinalize (Abc_Ntk_t pNtk, Abc_Ntk_t pNtkNew)

ABC_DLL Abc_Ntk_t *	Abc_NtkStartRead (char *pName)

ABC_DLL void	Abc_NtkFinalizeRead (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkDup (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkDupDfs (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkDupDfsNoBarBufs (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkDupTransformMiter (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkCreateCone (Abc_Ntk_t pNtk, Abc_Obj_t pNode, char *pNodeName, int fUseAllCis)

ABC_DLL Abc_Ntk_t *	Abc_NtkCreateConeArray (Abc_Ntk_t pNtk, Vec_Ptr_t vRoots, int fUseAllCis)

ABC_DLL void	Abc_NtkAppendToCone (Abc_Ntk_t pNtkNew, Abc_Ntk_t pNtk, Vec_Ptr_t *vRoots)

ABC_DLL Abc_Ntk_t *	Abc_NtkCreateMffc (Abc_Ntk_t pNtk, Abc_Obj_t pNode, char *pNodeName)

ABC_DLL Abc_Ntk_t *	Abc_NtkCreateTarget (Abc_Ntk_t pNtk, Vec_Ptr_t vRoots, Vec_Int_t *vValues)

ABC_DLL Abc_Ntk_t *	Abc_NtkCreateFromNode (Abc_Ntk_t pNtk, Abc_Obj_t pNode)

ABC_DLL Abc_Ntk_t *	Abc_NtkCreateFromRange (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkCreateWithNode (char *pSop)

ABC_DLL Abc_Ntk_t *	Abc_NtkCreateWithNodes (Vec_Ptr_t *vSops)

ABC_DLL void	Abc_NtkDelete (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkFixNonDrivenNets (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkMakeComb (Abc_Ntk_t *pNtk, int fRemoveLatches)

ABC_DLL void	Abc_NtkPermute (Abc_Ntk_t pNtk, int fInputs, int fOutputs, int fFlops, char pInPermFile, char pOutPermFile, char pFlopPermFile)

ABC_DLL void	Abc_NtkUnpermute (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Ntk_t *	Abc_NtkCreateFromSops (char pName, Vec_Ptr_t vSops)

ABC_DLL Abc_Ntk_t *	Abc_NtkCreateFromGias (char pName, Vec_Ptr_t vGias, Gia_Man_t *pMulti)

ABC_DLL Abc_Obj_t *	Abc_ObjAlloc (Abc_Ntk_t *pNtk, Abc_ObjType_t Type)
	DECLARATIONS ///.

ABC_DLL void	Abc_ObjRecycle (Abc_Obj_t *pObj)

ABC_DLL void	Abc_NtkDeleteObj (Abc_Obj_t *pObj)

ABC_DLL void	Abc_NtkDeleteObjPo (Abc_Obj_t *pObj)

ABC_DLL void	Abc_NtkDeleteObj_rec (Abc_Obj_t *pObj, int fOnlyNodes)

ABC_DLL void	Abc_NtkDeleteAll_rec (Abc_Obj_t *pObj)

ABC_DLL Abc_Obj_t *	Abc_NtkDupObj (Abc_Ntk_t pNtkNew, Abc_Obj_t pObj, int fCopyName)

ABC_DLL Abc_Obj_t *	Abc_NtkDupBox (Abc_Ntk_t pNtkNew, Abc_Obj_t pBox, int fCopyName)

ABC_DLL Abc_Obj_t *	Abc_NtkCloneObj (Abc_Obj_t *pNode)

ABC_DLL Abc_Obj_t *	Abc_NtkFindNode (Abc_Ntk_t pNtk, char pName)

ABC_DLL Abc_Obj_t *	Abc_NtkFindNet (Abc_Ntk_t pNtk, char pName)

ABC_DLL Abc_Obj_t *	Abc_NtkFindCi (Abc_Ntk_t pNtk, char pName)

ABC_DLL Abc_Obj_t *	Abc_NtkFindCo (Abc_Ntk_t pNtk, char pName)

ABC_DLL Abc_Obj_t *	Abc_NtkFindOrCreateNet (Abc_Ntk_t pNtk, char pName)

ABC_DLL Abc_Obj_t *	Abc_NtkCreateNodeConst0 (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Obj_t *	Abc_NtkCreateNodeConst1 (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Obj_t *	Abc_NtkCreateNodeInv (Abc_Ntk_t pNtk, Abc_Obj_t pFanin)

ABC_DLL Abc_Obj_t *	Abc_NtkCreateNodeBuf (Abc_Ntk_t pNtk, Abc_Obj_t pFanin)

ABC_DLL Abc_Obj_t *	Abc_NtkCreateNodeAnd (Abc_Ntk_t pNtk, Vec_Ptr_t vFanins)

ABC_DLL Abc_Obj_t *	Abc_NtkCreateNodeOr (Abc_Ntk_t pNtk, Vec_Ptr_t vFanins)

ABC_DLL Abc_Obj_t *	Abc_NtkCreateNodeExor (Abc_Ntk_t pNtk, Vec_Ptr_t vFanins)

ABC_DLL Abc_Obj_t *	Abc_NtkCreateNodeMux (Abc_Ntk_t pNtk, Abc_Obj_t pNodeC, Abc_Obj_t pNode1, Abc_Obj_t pNode0)

ABC_DLL int	Abc_NodeIsConst (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NodeIsConst0 (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NodeIsConst1 (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NodeIsBuf (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NodeIsInv (Abc_Obj_t *pNode)

ABC_DLL void	Abc_NodeComplement (Abc_Obj_t *pNode)

ABC_DLL void	Abc_NodeComplementInput (Abc_Obj_t pNode, Abc_Obj_t pFanin)

ABC_DLL Odc_Man_t *	Abc_NtkDontCareAlloc (int nVarsMax, int nLevels, int fVerbose, int fVeryVerbose)
	FUNCTION DEFINITIONS ///.

ABC_DLL void	Abc_NtkDontCareClear (Odc_Man_t *p)

ABC_DLL void	Abc_NtkDontCareFree (Odc_Man_t *p)

ABC_DLL int	Abc_NtkDontCareCompute (Odc_Man_t p, Abc_Obj_t pNode, Vec_Ptr_t vLeaves, unsigned puTruth)

ABC_DLL float	Abc_NtkMfsTotalSwitching (Abc_Ntk_t *pNtk)

ABC_DLL float	Abc_NtkMfsTotalGlitching (Abc_Ntk_t *pNtk, int nPats, int Prob, int fVerbose)

ABC_DLL void	Abc_NtkPrintStats (Abc_Ntk_t *pNtk, int fFactored, int fSaveBest, int fDumpResult, int fUseLutLib, int fPrintMuxes, int fPower, int fGlitch, int fSkipBuf, int fSkipSmall, int fPrintMem)

ABC_DLL void	Abc_NtkPrintIo (FILE pFile, Abc_Ntk_t pNtk, int fPrintFlops)

ABC_DLL void	Abc_NtkPrintLatch (FILE pFile, Abc_Ntk_t pNtk)

ABC_DLL void	Abc_NtkPrintFanio (FILE pFile, Abc_Ntk_t pNtk, int fUseFanio, int fUsePio, int fUseSupp, int fUseCone)

ABC_DLL void	Abc_NtkPrintFanioNew (FILE pFile, Abc_Ntk_t pNtk, int fMffc)

ABC_DLL void	Abc_NodePrintFanio (FILE pFile, Abc_Obj_t pNode)

ABC_DLL void	Abc_NtkPrintFactor (FILE pFile, Abc_Ntk_t pNtk, int fUseRealNames)

ABC_DLL void	Abc_NodePrintFactor (FILE pFile, Abc_Obj_t pNode, int fUseRealNames)

ABC_DLL void	Abc_NtkPrintLevel (FILE pFile, Abc_Ntk_t pNtk, int fProfile, int fListNodes, int fOutputs, int fVerbose)

ABC_DLL void	Abc_NodePrintLevel (FILE pFile, Abc_Obj_t pNode)

ABC_DLL void	Abc_NtkPrintSkews (FILE pFile, Abc_Ntk_t pNtk, int fPrintAll)

ABC_DLL void	Abc_ObjPrint (FILE pFile, Abc_Obj_t pObj)

ABC_DLL void	Abc_NtkShow6VarFunc (char pF0, char pF1)

ABC_DLL int	Abc_NtkMiterProve (Abc_Ntk_t *ppNtk, void pParams)
	FUNCTION DEFINITIONS ///.

ABC_DLL int	Abc_NtkIvyProve (Abc_Ntk_t *ppNtk, void pPars)

ABC_DLL void	Abc_NtkRecStart3 (Gia_Man_t *p, int nVars, int nCuts, int fFuncOnly, int fVerbose)

ABC_DLL void	Abc_NtkRecStop3 ()

ABC_DLL void	Abc_NtkRecAdd3 (Abc_Ntk_t *pNtk, int fUseSOPB)

ABC_DLL void	Abc_NtkRecPs3 (int fPrintLib)

ABC_DLL Gia_Man_t *	Abc_NtkRecGetGia3 ()

ABC_DLL int	Abc_NtkRecIsRunning3 ()

ABC_DLL void	Abc_NtkRecLibMerge3 (Gia_Man_t *pGia)

ABC_DLL int	Abc_NtkRecInputNum3 ()

ABC_DLL Abc_ManCut_t *	Abc_NtkManCutStart (int nNodeSizeMax, int nConeSizeMax, int nNodeFanStop, int nConeFanStop)

ABC_DLL void	Abc_NtkManCutStop (Abc_ManCut_t *p)

ABC_DLL Vec_Ptr_t *	Abc_NtkManCutReadCutLarge (Abc_ManCut_t *p)

ABC_DLL Vec_Ptr_t *	Abc_NtkManCutReadCutSmall (Abc_ManCut_t *p)

ABC_DLL Vec_Ptr_t *	Abc_NtkManCutReadVisited (Abc_ManCut_t *p)

ABC_DLL Vec_Ptr_t *	Abc_NodeFindCut (Abc_ManCut_t p, Abc_Obj_t pRoot, int fContain)

ABC_DLL void	Abc_NodeConeCollect (Abc_Obj_t *ppRoots, int nRoots, Vec_Ptr_t vFanins, Vec_Ptr_t *vVisited, int fIncludeFanins)

ABC_DLL Vec_Ptr_t *	Abc_NodeCollectTfoCands (Abc_ManCut_t p, Abc_Obj_t pRoot, Vec_Ptr_t *vFanins, int LevelMax)

ABC_DLL int	Abc_NodeMffcSize (Abc_Obj_t *pNode)
	FUNCTION DEFINITIONS ///.

ABC_DLL int	Abc_NodeMffcSizeSupp (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NodeMffcSizeStop (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NodeMffcLabelAig (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NodeMffcLabel (Abc_Obj_t pNode, Vec_Ptr_t vNodes)

ABC_DLL void	Abc_NodeMffcConeSupp (Abc_Obj_t pNode, Vec_Ptr_t vCone, Vec_Ptr_t *vSupp)

ABC_DLL int	Abc_NodeDeref_rec (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NodeRef_rec (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NtkRefactor (Abc_Ntk_t *pNtk, int nNodeSizeMax, int nMinSaved, int nConeSizeMax, int fUpdateLevel, int fUseZeros, int fUseDcs, int fVerbose)

ABC_DLL int	Abc_NtkRewrite (Abc_Ntk_t *pNtk, int fUpdateLevel, int fUseZeros, int fVerbose, int fVeryVerbose, int fPlaceEnable)
	FUNCTION DEFINITIONS ///.

ABC_DLL int	Abc_NtkMiterSat (Abc_Ntk_t pNtk, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, int fVerbose, ABC_INT64_T pNumConfs, ABC_INT64_T *pNumInspects)
	FUNCTION DEFINITIONS ///.

ABC_DLL void *	Abc_NtkMiterSatCreate (Abc_Ntk_t *pNtk, int fAllPrimes)

ABC_DLL char *	Abc_SopRegister (Mem_Flex_t pMan, const char pName)
	DECLARATIONS ///.

ABC_DLL char *	Abc_SopStart (Mem_Flex_t *pMan, int nCubes, int nVars)

ABC_DLL char *	Abc_SopCreateConst0 (Mem_Flex_t *pMan)

ABC_DLL char *	Abc_SopCreateConst1 (Mem_Flex_t *pMan)

ABC_DLL char *	Abc_SopCreateAnd2 (Mem_Flex_t *pMan, int fCompl0, int fCompl1)

ABC_DLL char *	Abc_SopCreateAnd (Mem_Flex_t pMan, int nVars, int pfCompl)

ABC_DLL char *	Abc_SopCreateNand (Mem_Flex_t *pMan, int nVars)

ABC_DLL char *	Abc_SopCreateOr (Mem_Flex_t pMan, int nVars, int pfCompl)

ABC_DLL char *	Abc_SopCreateOrMultiCube (Mem_Flex_t pMan, int nVars, int pfCompl)

ABC_DLL char *	Abc_SopCreateNor (Mem_Flex_t *pMan, int nVars)

ABC_DLL char *	Abc_SopCreateXor (Mem_Flex_t *pMan, int nVars)

ABC_DLL char *	Abc_SopCreateXorSpecial (Mem_Flex_t *pMan, int nVars)

ABC_DLL char *	Abc_SopCreateNxor (Mem_Flex_t *pMan, int nVars)

ABC_DLL char *	Abc_SopCreateMux (Mem_Flex_t *pMan)

ABC_DLL char *	Abc_SopCreateInv (Mem_Flex_t *pMan)

ABC_DLL char *	Abc_SopCreateBuf (Mem_Flex_t *pMan)

ABC_DLL char *	Abc_SopCreateFromTruth (Mem_Flex_t pMan, int nVars, unsigned pTruth)

ABC_DLL char *	Abc_SopCreateFromIsop (Mem_Flex_t pMan, int nVars, Vec_Int_t vCover)

ABC_DLL char *	Abc_SopCreateFromTruthIsop (Mem_Flex_t pMan, int nVars, word pTruth, Vec_Int_t *vCover)

ABC_DLL int	Abc_SopGetCubeNum (char *pSop)

ABC_DLL int	Abc_SopGetLitNum (char *pSop)

ABC_DLL int	Abc_SopGetVarNum (char *pSop)

ABC_DLL int	Abc_SopGetPhase (char *pSop)

ABC_DLL int	Abc_SopGetIthCareLit (char *pSop, int i)

ABC_DLL void	Abc_SopComplement (char *pSop)

ABC_DLL void	Abc_SopComplementVar (char *pSop, int iVar)

ABC_DLL int	Abc_SopIsComplement (char *pSop)

ABC_DLL int	Abc_SopIsConst0 (char *pSop)

ABC_DLL int	Abc_SopIsConst1 (char *pSop)

ABC_DLL int	Abc_SopIsBuf (char *pSop)

ABC_DLL int	Abc_SopIsInv (char *pSop)

ABC_DLL int	Abc_SopIsAndType (char *pSop)

ABC_DLL int	Abc_SopIsOrType (char *pSop)

ABC_DLL int	Abc_SopIsExorType (char *pSop)

ABC_DLL int	Abc_SopCheck (char *pSop, int nFanins)

ABC_DLL char *	Abc_SopFromTruthBin (char *pTruth)

ABC_DLL char *	Abc_SopFromTruthHex (char *pTruth)

ABC_DLL Vec_Ptr_t *	Abc_SopFromTruthsBin (char *pTruth)

ABC_DLL Vec_Ptr_t *	Abc_SopFromTruthsHex (char *pTruth)

ABC_DLL char *	Abc_SopEncoderPos (Mem_Flex_t *pMan, int iValue, int nValues)

ABC_DLL char *	Abc_SopEncoderLog (Mem_Flex_t *pMan, int iBit, int nValues)

ABC_DLL char *	Abc_SopDecoderPos (Mem_Flex_t *pMan, int nValues)

ABC_DLL char *	Abc_SopDecoderLog (Mem_Flex_t *pMan, int nValues)

ABC_DLL word	Abc_SopToTruth (char *pSop, int nInputs)

ABC_DLL void	Abc_SopToTruth7 (char *pSop, int nInputs, word r[2])

ABC_DLL void	Abc_SopToTruthBig (char pSop, int nInputs, word pVars, word pCube, word *pRes)

ABC_DLL Abc_Ntk_t *	Abc_NtkRestrash (Abc_Ntk_t *pNtk, int fCleanup)
	FUNCTION DEFINITIONS ///.

ABC_DLL Abc_Ntk_t *	Abc_NtkRestrashZero (Abc_Ntk_t *pNtk, int fCleanup)

ABC_DLL Abc_Ntk_t *	Abc_NtkStrash (Abc_Ntk_t *pNtk, int fAllNodes, int fCleanup, int fRecord)

ABC_DLL Abc_Obj_t *	Abc_NodeStrash (Abc_Ntk_t pNtkNew, Abc_Obj_t pNode, int fRecord)

ABC_DLL int	Abc_NtkAppend (Abc_Ntk_t pNtk1, Abc_Ntk_t pNtk2, int fAddPos)

ABC_DLL Abc_Ntk_t *	Abc_NtkTopmost (Abc_Ntk_t *pNtk, int nLevels)

ABC_DLL int	Abc_NtkSweep (Abc_Ntk_t *pNtk, int fVerbose)

ABC_DLL int	Abc_NtkCleanup (Abc_Ntk_t *pNtk, int fVerbose)

ABC_DLL int	Abc_NtkCleanupNodes (Abc_Ntk_t pNtk, Vec_Ptr_t vNodes, int fVerbose)

ABC_DLL int	Abc_NtkCleanupSeq (Abc_Ntk_t *pNtk, int fLatchSweep, int fAutoSweep, int fVerbose)

ABC_DLL int	Abc_NtkSweepBufsInvs (Abc_Ntk_t *pNtk, int fVerbose)

ABC_DLL Abc_Time_t *	Abc_NtkReadDefaultArrival (Abc_Ntk_t *pNtk)
	FUNCTION DEFINITIONS ///.

ABC_DLL Abc_Time_t *	Abc_NtkReadDefaultRequired (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Time_t *	Abc_NodeReadArrival (Abc_Obj_t *pNode)

ABC_DLL Abc_Time_t *	Abc_NodeReadRequired (Abc_Obj_t *pNode)

ABC_DLL float	Abc_NtkReadDefaultArrivalWorst (Abc_Ntk_t *pNtk)

ABC_DLL float	Abc_NtkReadDefaultRequiredWorst (Abc_Ntk_t *pNtk)

ABC_DLL float	Abc_NodeReadArrivalAve (Abc_Obj_t *pNode)

ABC_DLL float	Abc_NodeReadRequiredAve (Abc_Obj_t *pNode)

ABC_DLL float	Abc_NodeReadArrivalWorst (Abc_Obj_t *pNode)

ABC_DLL float	Abc_NodeReadRequiredWorst (Abc_Obj_t *pNode)

ABC_DLL Abc_Time_t *	Abc_NtkReadDefaultInputDrive (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Time_t *	Abc_NtkReadDefaultOutputLoad (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Time_t *	Abc_NodeReadInputDrive (Abc_Ntk_t *pNtk, int iPi)

ABC_DLL Abc_Time_t *	Abc_NodeReadOutputLoad (Abc_Ntk_t *pNtk, int iPo)

ABC_DLL float	Abc_NodeReadInputDriveWorst (Abc_Ntk_t *pNtk, int iPi)

ABC_DLL float	Abc_NodeReadOutputLoadWorst (Abc_Ntk_t *pNtk, int iPo)

ABC_DLL void	Abc_NtkTimeSetDefaultArrival (Abc_Ntk_t *pNtk, float Rise, float Fall)

ABC_DLL void	Abc_NtkTimeSetDefaultRequired (Abc_Ntk_t *pNtk, float Rise, float Fall)

ABC_DLL void	Abc_NtkTimeSetArrival (Abc_Ntk_t *pNtk, int ObjId, float Rise, float Fall)

ABC_DLL void	Abc_NtkTimeSetRequired (Abc_Ntk_t *pNtk, int ObjId, float Rise, float Fall)

ABC_DLL void	Abc_NtkTimeSetDefaultInputDrive (Abc_Ntk_t *pNtk, float Rise, float Fall)

ABC_DLL void	Abc_NtkTimeSetDefaultOutputLoad (Abc_Ntk_t *pNtk, float Rise, float Fall)

ABC_DLL void	Abc_NtkTimeSetInputDrive (Abc_Ntk_t *pNtk, int PiNum, float Rise, float Fall)

ABC_DLL void	Abc_NtkTimeSetOutputLoad (Abc_Ntk_t *pNtk, int PoNum, float Rise, float Fall)

ABC_DLL void	Abc_NtkTimeInitialize (Abc_Ntk_t pNtk, Abc_Ntk_t pNtkOld)

ABC_DLL void	Abc_ManTimeStop (Abc_ManTime_t *p)

ABC_DLL void	Abc_ManTimeDup (Abc_Ntk_t pNtkOld, Abc_Ntk_t pNtkNew)

ABC_DLL void	Abc_NtkSetNodeLevelsArrival (Abc_Ntk_t *pNtk)

ABC_DLL float *	Abc_NtkGetCiArrivalFloats (Abc_Ntk_t *pNtk)

ABC_DLL float *	Abc_NtkGetCoRequiredFloats (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Time_t *	Abc_NtkGetCiArrivalTimes (Abc_Ntk_t *pNtk)

ABC_DLL Abc_Time_t *	Abc_NtkGetCoRequiredTimes (Abc_Ntk_t *pNtk)

ABC_DLL float	Abc_NtkDelayTrace (Abc_Ntk_t pNtk, Abc_Obj_t pOut, Abc_Obj_t *pIn, int fPrint)

ABC_DLL int	Abc_ObjLevelNew (Abc_Obj_t *pObj)

ABC_DLL int	Abc_ObjReverseLevelNew (Abc_Obj_t *pObj)

ABC_DLL int	Abc_ObjRequiredLevel (Abc_Obj_t *pObj)

ABC_DLL int	Abc_ObjReverseLevel (Abc_Obj_t *pObj)

ABC_DLL void	Abc_ObjSetReverseLevel (Abc_Obj_t *pObj, int LevelR)

ABC_DLL void	Abc_NtkStartReverseLevels (Abc_Ntk_t *pNtk, int nMaxLevelIncrease)

ABC_DLL void	Abc_NtkStopReverseLevels (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkUpdateLevel (Abc_Obj_t pObjNew, Vec_Vec_t vLevels)

ABC_DLL void	Abc_NtkUpdateReverseLevel (Abc_Obj_t pObjNew, Vec_Vec_t vLevels)

ABC_DLL void	Abc_NtkUpdate (Abc_Obj_t pObj, Abc_Obj_t pObjNew, Vec_Vec_t *vLevels)

ABC_DLL void *	Abc_NtkAttrFree (Abc_Ntk_t *pNtk, int Attr, int fFreeMan)
	DECLARATIONS ///.

ABC_DLL void	Abc_NtkOrderCisCos (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetCubeNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetCubePairNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetLitNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetLitFactNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetBddNodeNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetAigNodeNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetClauseNum (Abc_Ntk_t *pNtk)

ABC_DLL double	Abc_NtkGetMappedArea (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetExorNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetMuxNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetBufNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetLargeNodeNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetChoiceNum (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetFaninMax (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetFanoutMax (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkGetTotalFanins (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkCleanCopy (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkCleanCopy_rec (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkCleanData (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkFillTemp (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkCountCopy (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_NtkSaveCopy (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkLoadCopy (Abc_Ntk_t pNtk, Vec_Ptr_t vCopies)

ABC_DLL void	Abc_NtkCleanNext (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkCleanNext_rec (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkCleanMarkA (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkCleanMarkB (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkCleanMarkC (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkCleanMarkAB (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkCleanMarkABC (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NodeFindFanin (Abc_Obj_t pNode, Abc_Obj_t pFanin)

ABC_DLL Abc_Obj_t *	Abc_NodeFindCoFanout (Abc_Obj_t *pNode)

ABC_DLL Abc_Obj_t *	Abc_NodeFindNonCoFanout (Abc_Obj_t *pNode)

ABC_DLL Abc_Obj_t *	Abc_NodeHasUniqueCoFanout (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NtkLogicHasSimpleCos (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkLogicMakeSimpleCos (Abc_Ntk_t *pNtk, int fDuplicate)

ABC_DLL void	Abc_VecObjPushUniqueOrderByLevel (Vec_Ptr_t p, Abc_Obj_t pNode)

ABC_DLL int	Abc_NodeIsExorType (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NodeIsMuxType (Abc_Obj_t *pNode)

ABC_DLL int	Abc_NodeIsMuxControlType (Abc_Obj_t *pNode)

ABC_DLL Abc_Obj_t *	Abc_NodeRecognizeMux (Abc_Obj_t pNode, Abc_Obj_t ppNodeT, Abc_Obj_t *ppNodeE)

ABC_DLL int	Abc_NtkPrepareTwoNtks (FILE pErr, Abc_Ntk_t pNtk, char argv, int argc, Abc_Ntk_t ppNtk1, Abc_Ntk_t *ppNtk2, int pfDelete1, int *pfDelete2, int fCheck)

ABC_DLL void	Abc_NodeCollectFanins (Abc_Obj_t pNode, Vec_Ptr_t vNodes)

ABC_DLL void	Abc_NodeCollectFanouts (Abc_Obj_t pNode, Vec_Ptr_t vNodes)

ABC_DLL Vec_Ptr_t *	Abc_NtkCollectLatches (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NodeCompareLevelsIncrease (Abc_Obj_t pp1, Abc_Obj_t pp2)

ABC_DLL int	Abc_NodeCompareLevelsDecrease (Abc_Obj_t pp1, Abc_Obj_t pp2)

ABC_DLL Vec_Int_t *	Abc_NtkFanoutCounts (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Ptr_t *	Abc_NtkCollectObjects (Abc_Ntk_t *pNtk)

ABC_DLL Vec_Int_t *	Abc_NtkGetCiIds (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkReassignIds (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_ObjPointerCompare (void pp1, void pp2)

ABC_DLL void	Abc_NtkTransferCopy (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkInvertConstraints (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkPrintCiLevels (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkReverseTopoOrder (Abc_Ntk_t *pNtk)

ABC_DLL int	Abc_NtkIsTopo (Abc_Ntk_t *pNtk)

ABC_DLL void	Abc_NtkTransferPhases (Abc_Ntk_t pNtkNew, Abc_Ntk_t pNtk)

ABC_DLL Gia_Man_t *	Abc_SopSynthesizeOne (char *pSop, int fClp)

ABC_DLL int *	Abc_NtkVerifyGetCleanModel (Abc_Ntk_t *pNtk, int nFrames)

ABC_DLL int *	Abc_NtkVerifySimulatePattern (Abc_Ntk_t pNtk, int pModel)

ABC_DLL int	Abc_NtkIsTrueCex (Abc_Ntk_t pNtk, Abc_Cex_t pCex)

ABC_DLL int	Abc_NtkIsValidCex (Abc_Ntk_t pNtk, Abc_Cex_t pCex)

Macro Definition Documentation

◆ Abc_AigForEachAnd

#define Abc_AigForEachAnd	(	pNtk,
		pNode,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ ) \

if ( (pNode) == NULL || !Abc_AigNodeIsAnd(pNode) ) {} else

Definition at line 488 of file abc.h.

#define Abc_AigForEachAnd( pNtk, pNode, i )                                                        \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ )   \
        if ( (pNode) == NULL || !Abc_AigNodeIsAnd(pNode) ) {} else

◆ Abc_CubeForEachVar

#define Abc_CubeForEachVar	(	pCube,
		Value,
		i )

Value:

for ( i = 0; (pCube[i] != ' ') && (Value = pCube[i]); i++ )

Definition at line 536 of file abc.h.

536#define Abc_CubeForEachVar( pCube, Value, i ) \

537 for ( i = 0; (pCube[i] != ' ') && (Value = pCube[i]); i++ )

◆ Abc_NtkForEachBarBuf

#define Abc_NtkForEachBarBuf	(	pNtk,
		pNode,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ ) \

if ( (pNode) == NULL || !Abc_ObjIsBarBuf(pNode) ) {} else

Definition at line 482 of file abc.h.

#define Abc_NtkForEachBarBuf( pNtk, pNode, i )                                                     \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ )   \
        if ( (pNode) == NULL || !Abc_ObjIsBarBuf(pNode) ) {} else

◆ Abc_NtkForEachBlackbox

#define Abc_NtkForEachBlackbox	(	pNtk,
		pObj,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)) && (((pObj) = Abc_NtkBox(pNtk, i)), 1); i++ ) \

if ( !Abc_ObjIsBlackbox(pObj) ) {} else

Definition at line 512 of file abc.h.

#define Abc_NtkForEachBlackbox( pNtk, pObj, i )                                                    \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)) && (((pObj) = Abc_NtkBox(pNtk, i)), 1); i++ )   \
        if ( !Abc_ObjIsBlackbox(pObj) ) {} else

◆ Abc_NtkForEachBox

#define Abc_NtkForEachBox	(	pNtk,
		pObj,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)) && (((pObj) = Abc_NtkBox(pNtk, i)), 1); i++ )

Definition at line 498 of file abc.h.

498#define Abc_NtkForEachBox( pNtk, pObj, i ) \

499 for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)) && (((pObj) = Abc_NtkBox(pNtk, i)), 1); i++ )

◆ Abc_NtkForEachCi

#define Abc_NtkForEachCi	(	pNtk,
		pCi,
		i )

Value:

for ( i = 0; (i < Abc_NtkCiNum(pNtk)) && (((pCi) = Abc_NtkCi(pNtk, i)), 1); i++ )

Definition at line 518 of file abc.h.

518#define Abc_NtkForEachCi( pNtk, pCi, i ) \

519 for ( i = 0; (i < Abc_NtkCiNum(pNtk)) && (((pCi) = Abc_NtkCi(pNtk, i)), 1); i++ )

◆ Abc_NtkForEachCo

#define Abc_NtkForEachCo	(	pNtk,
		pCo,
		i )

Value:

for ( i = 0; (i < Abc_NtkCoNum(pNtk)) && (((pCo) = Abc_NtkCo(pNtk, i)), 1); i++ )

Definition at line 522 of file abc.h.

522#define Abc_NtkForEachCo( pNtk, pCo, i ) \

523 for ( i = 0; (i < Abc_NtkCoNum(pNtk)) && (((pCo) = Abc_NtkCo(pNtk, i)), 1); i++ )

◆ Abc_NtkForEachGate

#define Abc_NtkForEachGate	(	pNtk,
		pNode,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ ) \

if ( (pNode) == NULL || !Abc_ObjIsGate(pNode) ) {} else

Definition at line 485 of file abc.h.

#define Abc_NtkForEachGate( pNtk, pNode, i )                                                       \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ )   \
        if ( (pNode) == NULL || !Abc_ObjIsGate(pNode) ) {} else

◆ Abc_NtkForEachLatch

#define Abc_NtkForEachLatch	(	pNtk,
		pObj,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)) && (((pObj) = Abc_NtkBox(pNtk, i)), 1); i++ ) \

if ( !Abc_ObjIsLatch(pObj) ) {} else

Definition at line 500 of file abc.h.

#define Abc_NtkForEachLatch( pNtk, pObj, i )                                                       \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)) && (((pObj) = Abc_NtkBox(pNtk, i)), 1); i++ )   \
        if ( !Abc_ObjIsLatch(pObj) ) {} else

◆ Abc_NtkForEachLatchInput

#define Abc_NtkForEachLatchInput	(	pNtk,
		pObj,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)); i++ ) \

if ( !(Abc_ObjIsLatch(Abc_NtkBox(pNtk, i)) && (((pObj) = Abc_ObjFanin0(Abc_NtkBox(pNtk, i))), 1)) ) {} else

Definition at line 503 of file abc.h.

#define Abc_NtkForEachLatchInput( pNtk, pObj, i )                                                  \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)); i++ )                                          \
        if ( !(Abc_ObjIsLatch(Abc_NtkBox(pNtk, i)) && (((pObj) = Abc_ObjFanin0(Abc_NtkBox(pNtk, i))), 1)) ) {} else

◆ Abc_NtkForEachLatchOutput

#define Abc_NtkForEachLatchOutput	(	pNtk,
		pObj,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)); i++ ) \

if ( !(Abc_ObjIsLatch(Abc_NtkBox(pNtk, i)) && (((pObj) = Abc_ObjFanout0(Abc_NtkBox(pNtk, i))), 1)) ) {} else

Definition at line 506 of file abc.h.

#define Abc_NtkForEachLatchOutput( pNtk, pObj, i )                                                 \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)); i++ )                                          \
        if ( !(Abc_ObjIsLatch(Abc_NtkBox(pNtk, i)) && (((pObj) = Abc_ObjFanout0(Abc_NtkBox(pNtk, i))), 1)) ) {} else

◆ Abc_NtkForEachLiPo

#define Abc_NtkForEachLiPo	(	pNtk,
		pCo,
		i )

Value:

for ( i = 0; (i < Abc_NtkCoNum(pNtk)) && (((pCo) = Abc_NtkCo(pNtk, i < pNtk->nBarBufs ? Abc_NtkCoNum(pNtk) - pNtk->nBarBufs + i : i - pNtk->nBarBufs)), 1); i++ )

Definition at line 524 of file abc.h.

524#define Abc_NtkForEachLiPo( pNtk, pCo, i ) \

525 for ( i = 0; (i < Abc_NtkCoNum(pNtk)) && (((pCo) = Abc_NtkCo(pNtk, i < pNtk->nBarBufs ? Abc_NtkCoNum(pNtk) - pNtk->nBarBufs + i : i - pNtk->nBarBufs)), 1); i++ )

◆ Abc_NtkForEachNet

#define Abc_NtkForEachNet	(	pNtk,
		pNet,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNet) = Abc_NtkObj(pNtk, i)), 1); i++ ) \

if ( (pNet) == NULL || !Abc_ObjIsNet(pNet) ) {} else

Definition at line 461 of file abc.h.

#define Abc_NtkForEachNet( pNtk, pNet, i )                                                         \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNet) = Abc_NtkObj(pNtk, i)), 1); i++ )    \
        if ( (pNet) == NULL || !Abc_ObjIsNet(pNet) ) {} else

◆ Abc_NtkForEachNode

#define Abc_NtkForEachNode	(	pNtk,
		pNode,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ ) \

if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) ) {} else

Definition at line 464 of file abc.h.

#define Abc_NtkForEachNode( pNtk, pNode, i )                                                       \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ )   \
        if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) ) {} else

◆ Abc_NtkForEachNode1

#define Abc_NtkForEachNode1	(	pNtk,
		pNode,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ ) \

if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) || !Abc_ObjFaninNum(pNode) ) {} else

Definition at line 470 of file abc.h.

#define Abc_NtkForEachNode1( pNtk, pNode, i )                                                      \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ )   \
        if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) || !Abc_ObjFaninNum(pNode) ) {} else

◆ Abc_NtkForEachNodeCi

#define Abc_NtkForEachNodeCi	(	pNtk,
		pNode,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ ) \

if ( (pNode) == NULL || (!Abc_ObjIsNode(pNode) && !Abc_ObjIsCi(pNode)) ) {} else

Definition at line 491 of file abc.h.

#define Abc_NtkForEachNodeCi( pNtk, pNode, i )                                                       \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ )   \
        if ( (pNode) == NULL || (!Abc_ObjIsNode(pNode) && !Abc_ObjIsCi(pNode)) ) {} else

◆ Abc_NtkForEachNodeCo

#define Abc_NtkForEachNodeCo	(	pNtk,
		pNode,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ ) \

if ( (pNode) == NULL || (!Abc_ObjIsNode(pNode) && !Abc_ObjIsCo(pNode)) ) {} else

Definition at line 494 of file abc.h.

#define Abc_NtkForEachNodeCo( pNtk, pNode, i )                                                       \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ )   \
        if ( (pNode) == NULL || (!Abc_ObjIsNode(pNode) && !Abc_ObjIsCo(pNode)) ) {} else

◆ Abc_NtkForEachNodeNotBarBuf

#define Abc_NtkForEachNodeNotBarBuf	(	pNtk,
		pNode,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ ) \

if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) || Abc_ObjIsBarBuf(pNode) ) {} else

Definition at line 467 of file abc.h.

#define Abc_NtkForEachNodeNotBarBuf( pNtk, pNode, i )                                              \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ )   \
        if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) || Abc_ObjIsBarBuf(pNode) ) {} else

◆ Abc_NtkForEachNodeNotBarBuf1

#define Abc_NtkForEachNodeNotBarBuf1	(	pNtk,
		pNode,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ ) \

if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) || !Abc_ObjFaninNum(pNode) || Abc_ObjIsBarBuf(pNode) ) {} else

Definition at line 473 of file abc.h.

#define Abc_NtkForEachNodeNotBarBuf1( pNtk, pNode, i )                                             \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i++ )   \
        if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) || !Abc_ObjFaninNum(pNode) || Abc_ObjIsBarBuf(pNode) ) {} else

◆ Abc_NtkForEachNodeReverse

#define Abc_NtkForEachNodeReverse	(	pNtk,
		pNode,
		i )

Value:

for ( i = Vec_PtrSize((pNtk)->vObjs) - 1; (i >= 0) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i-- ) \

if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) ) {} else

Definition at line 476 of file abc.h.

#define Abc_NtkForEachNodeReverse( pNtk, pNode, i )                                                \
    for ( i = Vec_PtrSize((pNtk)->vObjs) - 1; (i >= 0) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i-- ) \
        if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) ) {} else

◆ Abc_NtkForEachNodeReverse1

#define Abc_NtkForEachNodeReverse1	(	pNtk,
		pNode,
		i )

Value:

for ( i = Vec_PtrSize((pNtk)->vObjs) - 1; (i >= 0) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i-- ) \

if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) || !Abc_ObjFaninNum(pNode) ) {} else

Definition at line 479 of file abc.h.

#define Abc_NtkForEachNodeReverse1( pNtk, pNode, i )                                               \
    for ( i = Vec_PtrSize((pNtk)->vObjs) - 1; (i >= 0) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i-- ) \
        if ( (pNode) == NULL || !Abc_ObjIsNode(pNode) || !Abc_ObjFaninNum(pNode) ) {} else

◆ Abc_NtkForEachObj

#define Abc_NtkForEachObj	(	pNtk,
		pObj,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pObj) = Abc_NtkObj(pNtk, i)), 1); i++ ) \

if ( (pObj) == NULL ) {} else

ITERATORS ///.

Definition at line 449 of file abc.h.

#define Abc_NtkForEachObj( pNtk, pObj, i )                                                         \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pObj) = Abc_NtkObj(pNtk, i)), 1); i++ )    \
        if ( (pObj) == NULL ) {} else

◆ Abc_NtkForEachObjReverse

#define Abc_NtkForEachObjReverse	(	pNtk,
		pNode,
		i )

Value:

for ( i = Vec_PtrSize((pNtk)->vObjs) - 1; (i >= 0) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i-- ) \

if ( (pNode) == NULL ) {} else

Definition at line 452 of file abc.h.

#define Abc_NtkForEachObjReverse( pNtk, pNode, i )                                                 \
    for ( i = Vec_PtrSize((pNtk)->vObjs) - 1; (i >= 0) && (((pNode) = Abc_NtkObj(pNtk, i)), 1); i-- ) \
        if ( (pNode) == NULL ) {} else

◆ Abc_NtkForEachObjVec

#define Abc_NtkForEachObjVec	(	vIds,
		pNtk,
		pObj,
		i )

Value:

for ( i = 0; i < Vec_IntSize(vIds) && (((pObj) = Abc_NtkObj(pNtk, Vec_IntEntry(vIds,i))), 1); i++ ) \

if ( (pObj) == NULL ) {} else

Definition at line 455 of file abc.h.

#define Abc_NtkForEachObjVec( vIds, pNtk, pObj, i )                                                \
    for ( i = 0; i < Vec_IntSize(vIds) && (((pObj) = Abc_NtkObj(pNtk, Vec_IntEntry(vIds,i))), 1); i++ ) \
        if ( (pObj) == NULL ) {} else

◆ Abc_NtkForEachObjVecStart

#define Abc_NtkForEachObjVecStart	(	vIds,
		pNtk,
		pObj,
		i,
		Start )

Value:

for ( i = Start; i < Vec_IntSize(vIds) && (((pObj) = Abc_NtkObj(pNtk, Vec_IntEntry(vIds,i))), 1); i++ ) \

if ( (pObj) == NULL ) {} else

Definition at line 458 of file abc.h.

#define Abc_NtkForEachObjVecStart( vIds, pNtk, pObj, i, Start )                                    \
    for ( i = Start; i < Vec_IntSize(vIds) && (((pObj) = Abc_NtkObj(pNtk, Vec_IntEntry(vIds,i))), 1); i++ ) \
        if ( (pObj) == NULL ) {} else

◆ Abc_NtkForEachPi

#define Abc_NtkForEachPi	(	pNtk,
		pPi,
		i )

Value:

for ( i = 0; (i < Abc_NtkPiNum(pNtk)) && (((pPi) = Abc_NtkPi(pNtk, i)), 1); i++ )

Definition at line 516 of file abc.h.

516#define Abc_NtkForEachPi( pNtk, pPi, i ) \

517 for ( i = 0; (i < Abc_NtkPiNum(pNtk)) && (((pPi) = Abc_NtkPi(pNtk, i)), 1); i++ )

◆ Abc_NtkForEachPo

#define Abc_NtkForEachPo	(	pNtk,
		pPo,
		i )

Value:

for ( i = 0; (i < Abc_NtkPoNum(pNtk)) && (((pPo) = Abc_NtkPo(pNtk, i)), 1); i++ )

Definition at line 520 of file abc.h.

520#define Abc_NtkForEachPo( pNtk, pPo, i ) \

521 for ( i = 0; (i < Abc_NtkPoNum(pNtk)) && (((pPo) = Abc_NtkPo(pNtk, i)), 1); i++ )

◆ Abc_NtkForEachWhitebox

#define Abc_NtkForEachWhitebox	(	pNtk,
		pObj,
		i )

Value:

for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)) && (((pObj) = Abc_NtkBox(pNtk, i)), 1); i++ ) \

if ( !Abc_ObjIsWhitebox(pObj) ) {} else

Definition at line 509 of file abc.h.

#define Abc_NtkForEachWhitebox( pNtk, pObj, i )                                                    \
    for ( i = 0; (i < Vec_PtrSize((pNtk)->vBoxes)) && (((pObj) = Abc_NtkBox(pNtk, i)), 1); i++ )   \
        if ( !Abc_ObjIsWhitebox(pObj) ) {} else

◆ Abc_ObjForEachFanin

#define Abc_ObjForEachFanin	(	pObj,
		pFanin,
		i )

Value:

for ( i = 0; (i < Abc_ObjFaninNum(pObj)) && (((pFanin) = Abc_ObjFanin(pObj, i)), 1); i++ )

Definition at line 527 of file abc.h.

527#define Abc_ObjForEachFanin( pObj, pFanin, i ) \

528 for ( i = 0; (i < Abc_ObjFaninNum(pObj)) && (((pFanin) = Abc_ObjFanin(pObj, i)), 1); i++ )

◆ Abc_ObjForEachFaninId

#define Abc_ObjForEachFaninId	(	pObj,
		iFanin,
		i )

Value:

for ( i = 0; (i < Abc_ObjFaninNum(pObj)) && (((iFanin) = Abc_ObjFaninId(pObj, i)), 1); i++ )

Definition at line 531 of file abc.h.

531#define Abc_ObjForEachFaninId( pObj, iFanin, i ) \

532 for ( i = 0; (i < Abc_ObjFaninNum(pObj)) && (((iFanin) = Abc_ObjFaninId(pObj, i)), 1); i++ )

◆ Abc_ObjForEachFanout

#define Abc_ObjForEachFanout	(	pObj,
		pFanout,
		i )

Value:

for ( i = 0; (i < Abc_ObjFanoutNum(pObj)) && (((pFanout) = Abc_ObjFanout(pObj, i)), 1); i++ )

Definition at line 529 of file abc.h.

529#define Abc_ObjForEachFanout( pObj, pFanout, i ) \

530 for ( i = 0; (i < Abc_ObjFanoutNum(pObj)) && (((pFanout) = Abc_ObjFanout(pObj, i)), 1); i++ )

◆ Abc_ObjForEachFanoutId

#define Abc_ObjForEachFanoutId	(	pObj,
		iFanout,
		i )

Value:

for ( i = 0; (i < Abc_ObjFanoutNum(pObj)) && (((iFanout) = Abc_ObjFanoutId(pObj, i)), 1); i++ )

Definition at line 533 of file abc.h.

533#define Abc_ObjForEachFanoutId( pObj, iFanout, i ) \

534 for ( i = 0; (i < Abc_ObjFanoutNum(pObj)) && (((iFanout) = Abc_ObjFanoutId(pObj, i)), 1); i++ )

◆ Abc_SopForEachCube

#define Abc_SopForEachCube	(	pSop,
		nFanins,
		pCube )

Value:

for ( pCube = (pSop); *pCube; pCube += (nFanins) + 3 )

Definition at line 538 of file abc.h.

538#define Abc_SopForEachCube( pSop, nFanins, pCube ) \

539 for ( pCube = (pSop); *pCube; pCube += (nFanins) + 3 )

◆ Abc_SopForEachCubePair

#define Abc_SopForEachCubePair	(	pSop,
		nFanins,
		pCube,
		pCube2 )

Value:

Abc_SopForEachCube( pSop, nFanins, pCube ) \

Abc_SopForEachCube( pCube + (nFanins) + 3, nFanins, pCube2 )

Abc_SopForEachCube

#define Abc_SopForEachCube(pSop, nFanins, pCube)

Definition abc.h:538

Definition at line 540 of file abc.h.

#define Abc_SopForEachCubePair( pSop, nFanins, pCube, pCube2 )                                     \
    Abc_SopForEachCube( pSop, nFanins, pCube )                                                     \
    Abc_SopForEachCube( pCube + (nFanins) + 3, nFanins, pCube2 )

Typedef Documentation

◆ Abc_Aig_t

typedef struct Abc_Aig_t_ Abc_Aig_t

Definition at line 117 of file abc.h.

◆ Abc_Des_t

typedef struct Abc_Des_t_ Abc_Des_t

BASIC TYPES ///.

Definition at line 114 of file abc.h.

◆ Abc_ManCut_t

typedef struct Abc_ManCut_t_ Abc_ManCut_t

Definition at line 119 of file abc.h.

◆ Abc_ManTime_t

typedef struct Abc_ManTime_t_ Abc_ManTime_t

Definition at line 118 of file abc.h.

◆ Abc_Ntk_t

typedef struct Abc_Ntk_t_ Abc_Ntk_t

Definition at line 115 of file abc.h.

◆ Abc_Obj_t

typedef struct Abc_Obj_t_ Abc_Obj_t

Definition at line 116 of file abc.h.

◆ Abc_Time_t

typedef struct Abc_Time_t_ Abc_Time_t

Definition at line 120 of file abc.h.

◆ Odc_Man_t

typedef struct Odc_Man_t_ Odc_Man_t

Definition at line 832 of file abc.h.

Enumeration Type Documentation

◆ Abc_InitType_t

enum Abc_InitType_t

Enumerator
ABC_INIT_NONE
ABC_INIT_ZERO
ABC_INIT_ONE
ABC_INIT_DC
ABC_INIT_OTHER

Definition at line 102 of file abc.h.

             { 
    ABC_INIT_NONE = 0,  // 0:  unknown
    ABC_INIT_ZERO,      // 1:  zero
    ABC_INIT_ONE,       // 2:  one
    ABC_INIT_DC,        // 3:  don't-care
    ABC_INIT_OTHER      // 4:  unused
} Abc_InitType_t;

◆ Abc_NtkFunc_t

enum Abc_NtkFunc_t

Enumerator
ABC_FUNC_NONE
ABC_FUNC_SOP
ABC_FUNC_BDD
ABC_FUNC_AIG
ABC_FUNC_MAP
ABC_FUNC_BLIFMV
ABC_FUNC_BLACKBOX
ABC_FUNC_OTHER

Definition at line 63 of file abc.h.

             { 
    ABC_FUNC_NONE = 0,  // 0:  unknown
    ABC_FUNC_SOP,       // 1:  sum-of-products
    ABC_FUNC_BDD,       // 2:  binary decision diagrams
    ABC_FUNC_AIG,       // 3:  and-inverter graphs
    ABC_FUNC_MAP,       // 4:  standard cell library
    ABC_FUNC_BLIFMV,    // 5:  BLIF-MV node functions
    ABC_FUNC_BLACKBOX,  // 6:  black box about which nothing is known
    ABC_FUNC_OTHER      // 7:  unused
} Abc_NtkFunc_t;

◆ Abc_NtkType_t

enum Abc_NtkType_t

INCLUDES ///.

CFile****************************************************************

FileName [abc.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: abc.h,v 1.1 2008/05/14 22:13:11 wudenni Exp

] PARAMETERS ///

Enumerator
ABC_NTK_NONE
ABC_NTK_NETLIST
ABC_NTK_LOGIC
ABC_NTK_STRASH
ABC_NTK_OTHER

Definition at line 54 of file abc.h.

             { 
    ABC_NTK_NONE = 0,   // 0:  unknown
    ABC_NTK_NETLIST,    // 1:  network with PIs/POs, latches, nodes, and nets
    ABC_NTK_LOGIC,      // 2:  network with PIs/POs, latches, and nodes
    ABC_NTK_STRASH,     // 3:  structurally hashed AIG (two input AND gates with c-attributes on edges)
    ABC_NTK_OTHER       // 4:  unused
} Abc_NtkType_t;

◆ Abc_ObjType_t

enum Abc_ObjType_t

Enumerator
ABC_OBJ_NONE
ABC_OBJ_CONST1
ABC_OBJ_PI
ABC_OBJ_PO
ABC_OBJ_BI
ABC_OBJ_BO
ABC_OBJ_NET
ABC_OBJ_NODE
ABC_OBJ_LATCH
ABC_OBJ_WHITEBOX
ABC_OBJ_BLACKBOX
ABC_OBJ_NUMBER

Definition at line 86 of file abc.h.

             { 
    ABC_OBJ_NONE = 0,   //  0:  unknown
    ABC_OBJ_CONST1,     //  1:  constant 1 node (AIG only)
    ABC_OBJ_PI,         //  2:  primary input terminal
    ABC_OBJ_PO,         //  3:  primary output terminal
    ABC_OBJ_BI,         //  4:  box input terminal
    ABC_OBJ_BO,         //  5:  box output terminal
    ABC_OBJ_NET,        //  6:  net
    ABC_OBJ_NODE,       //  7:  node
    ABC_OBJ_LATCH,      //  8:  latch
    ABC_OBJ_WHITEBOX,   //  9:  box with known contents
    ABC_OBJ_BLACKBOX,   // 10:  box with unknown contents
    ABC_OBJ_NUMBER      // 11:  unused
} Abc_ObjType_t;

Function Documentation

◆ Abc_AigAlloc()

ABC_DLL Abc_Aig_t * Abc_AigAlloc ( Abc_Ntk_t * pNtkAig )

extern

FUNCTION DECLARATIONS ///.

Function*************************************************************

Synopsis [Allocates the local AIG manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 128 of file abcAig.c.

{
    Abc_Aig_t * pMan;
    // start the manager
    pMan = ABC_ALLOC( Abc_Aig_t, 1 );
    memset( pMan, 0, sizeof(Abc_Aig_t) );
    // allocate the table
    pMan->nBins    = Abc_PrimeCudd( 10000 );
    pMan->pBins    = ABC_ALLOC( Abc_Obj_t *, pMan->nBins );
    memset( pMan->pBins, 0, sizeof(Abc_Obj_t *) * pMan->nBins );
    pMan->vNodes   = Vec_PtrAlloc( 100 );
    pMan->vLevels  = Vec_VecAlloc( 100 );
    pMan->vLevelsR = Vec_VecAlloc( 100 );
    pMan->vStackReplaceOld = Vec_PtrAlloc( 100 );
    pMan->vStackReplaceNew = Vec_PtrAlloc( 100 );
    // create the constant node
    assert( pNtkAig->vObjs->nSize == 0 );
    pMan->pConst1 = Abc_NtkCreateObj( pNtkAig, ABC_OBJ_NODE );
    pMan->pConst1->Type = ABC_OBJ_CONST1;
    pMan->pConst1->fPhase = 1;
    pNtkAig->nObjCounts[ABC_OBJ_NODE]--;
    // save the current network
    pMan->pNtkAig = pNtkAig;
    return pMan;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigAnd()

ABC_DLL Abc_Obj_t * Abc_AigAnd	(	Abc_Aig_t *	pMan,
		Abc_Obj_t *	p0,
		Abc_Obj_t *	p1 )

extern

Function*************************************************************

Synopsis [Performs canonicization step.]

Description [The argument nodes can be complemented.]

SideEffects []

SeeAlso []

Definition at line 700 of file abcAig.c.

{
    Abc_Obj_t * pAnd;
    if ( (pAnd = Abc_AigAndLookup( pMan, p0, p1 )) )
        return pAnd;
    return Abc_AigAndCreate( pMan, p0, p1 );
}

Here is the call graph for this function:

◆ Abc_AigAndLookup()

ABC_DLL Abc_Obj_t * Abc_AigAndLookup	(	Abc_Aig_t *	pMan,
		Abc_Obj_t *	p0,
		Abc_Obj_t *	p1 )

extern

Function*************************************************************

Synopsis [Performs canonicization step.]

Description [The argument nodes can be complemented.]

SideEffects []

SeeAlso []

Definition at line 403 of file abcAig.c.

{
    Abc_Obj_t * pAnd, * pConst1;
    unsigned Key;
    assert( Abc_ObjRegular(p0)->pNtk->pManFunc == pMan );
    assert( Abc_ObjRegular(p1)->pNtk->pManFunc == pMan );
    // check for trivial cases
    pConst1 = Abc_AigConst1(pMan->pNtkAig);
    if ( p0 == p1 )
        return p0;
    if ( p0 == Abc_ObjNot(p1) )
        return Abc_ObjNot(pConst1);
    if ( Abc_ObjRegular(p0) == pConst1 )
    {
        if ( p0 == pConst1 )
            return p1;
        return Abc_ObjNot(pConst1);
    }
    if ( Abc_ObjRegular(p1) == pConst1 )
    {
        if ( p1 == pConst1 )
            return p0;
        return Abc_ObjNot(pConst1);
    }
/*
    {
        int nFans0 = Abc_ObjFanoutNum( Abc_ObjRegular(p0) );
        int nFans1 = Abc_ObjFanoutNum( Abc_ObjRegular(p1) );
        if ( nFans0 == 0 || nFans1 == 0 )
            pMan->nStrash0++;
        else if ( nFans0 == 1 || nFans1 == 1 )
            pMan->nStrash1++;
        else if ( nFans0 <= 100 && nFans1 <= 100 )
            pMan->nStrash5++;
        else
            pMan->nStrash2++;
    }
*/
    {
        int nFans0 = Abc_ObjFanoutNum( Abc_ObjRegular(p0) );
        int nFans1 = Abc_ObjFanoutNum( Abc_ObjRegular(p1) );
        if ( nFans0 == 0 || nFans1 == 0 )
            return NULL;
    }
 
    // order the arguments
    if ( Abc_ObjRegular(p0)->Id > Abc_ObjRegular(p1)->Id )
        pAnd = p0, p0 = p1, p1 = pAnd;
    // get the hash key for these two nodes
    Key = Abc_HashKey2( p0, p1, pMan->nBins );
    // find the matching node in the table
    Abc_AigBinForEachEntry( pMan->pBins[Key], pAnd )
        if ( p0 == Abc_ObjChild0(pAnd) && p1 == Abc_ObjChild1(pAnd) )
        {
//            assert( Abc_ObjFanoutNum(Abc_ObjRegular(p0)) && Abc_ObjFanoutNum(p1) );
             return pAnd;
        }
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigCheck()

ABC_DLL int Abc_AigCheck ( Abc_Aig_t * pMan )

extern

Function*************************************************************

Synopsis [Makes sure that every node in the table is in the network and vice versa.]

Description []

SideEffects []

SeeAlso []

Definition at line 226 of file abcAig.c.

{
    Abc_Obj_t * pObj, * pAnd;
    int i, nFanins, Counter;
    Abc_NtkForEachNode( pMan->pNtkAig, pObj, i )
    {
        nFanins = Abc_ObjFaninNum(pObj);
        if ( nFanins == 0 )
        {
            if ( !Abc_AigNodeIsConst(pObj) )
            {
                printf( "Abc_AigCheck: The AIG has non-standard constant nodes.\n" );
                return 0;
            }
            continue;
        }
        if ( nFanins == 1 )
        {
            printf( "Abc_AigCheck: The AIG has single input nodes.\n" );
            return 0;
        }
        if ( nFanins > 2 )
        {
            printf( "Abc_AigCheck: The AIG has non-standard nodes.\n" );
            return 0;
        }
        if ( pObj->Level != 1 + (unsigned)Abc_MaxInt( Abc_ObjFanin0(pObj)->Level, Abc_ObjFanin1(pObj)->Level ) )
            printf( "Abc_AigCheck: Node \"%s\" has level that does not agree with the fanin levels.\n", Abc_ObjName(pObj) );
        pAnd = Abc_AigAndLookup( pMan, Abc_ObjChild0(pObj), Abc_ObjChild1(pObj) );
        if ( pAnd != pObj )
            printf( "Abc_AigCheck: Node \"%s\" is not in the structural hashing table.\n", Abc_ObjName(pObj) );
    }
    // count the number of nodes in the table
    Counter = 0;
    for ( i = 0; i < pMan->nBins; i++ )
        Abc_AigBinForEachEntry( pMan->pBins[i], pAnd )
            Counter++;
    if ( Counter != Abc_NtkNodeNum(pMan->pNtkAig) )
    {
        printf( "Abc_AigCheck: The number of nodes in the structural hashing table is wrong.\n" );
        return 0;
    }
    // if the node is a choice node, nodes in its class should not have fanouts
    Abc_NtkForEachNode( pMan->pNtkAig, pObj, i )
        if ( Abc_AigNodeIsChoice(pObj) )
            for ( pAnd = (Abc_Obj_t *)pObj->pData; pAnd; pAnd = (Abc_Obj_t *)pAnd->pData )
                if ( Abc_ObjFanoutNum(pAnd) > 0 )
                {
                    printf( "Abc_AigCheck: Representative %s", Abc_ObjName(pAnd) );
                    printf( " of choice node %s has %d fanouts.\n", Abc_ObjName(pObj), Abc_ObjFanoutNum(pAnd) );
                    return 0;
                }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigCheckFaninOrder()

ABC_DLL void Abc_AigCheckFaninOrder ( Abc_Aig_t * pMan )

extern

Function*************************************************************

Synopsis [Resizes the hash table of AIG nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1379 of file abcAig.c.

{
    Abc_Obj_t * pEnt;
    int i;
    for ( i = 0; i < pMan->nBins; i++ )
        Abc_AigBinForEachEntry( pMan->pBins[i], pEnt )
        {
            if ( Abc_ObjRegular(Abc_ObjChild0(pEnt))->Id > Abc_ObjRegular(Abc_ObjChild1(pEnt))->Id )
            {
//                int i0 = Abc_ObjRegular(Abc_ObjChild0(pEnt))->Id;
//                int i1 = Abc_ObjRegular(Abc_ObjChild1(pEnt))->Id;
                printf( "Node %d has incorrect ordering of fanins.\n", pEnt->Id );
            }
        }
}

◆ Abc_AigCleanup()

ABC_DLL int Abc_AigCleanup ( Abc_Aig_t * pMan )

extern

Function*************************************************************

Synopsis [Returns the number of dangling nodes removed.]

Description []

SideEffects []

SeeAlso []

Definition at line 194 of file abcAig.c.

{
    Vec_Ptr_t * vDangles;
    Abc_Obj_t * pAnd;
    int i, nNodesOld;
//    printf( "Strash0 = %d.  Strash1 = %d.  Strash100 = %d.  StrashM = %d.\n", 
//        pMan->nStrash0, pMan->nStrash1, pMan->nStrash5, pMan->nStrash2 );
    nNodesOld = pMan->nEntries;
    // collect the AND nodes that do not fanout
    vDangles = Vec_PtrAlloc( 100 );
    for ( i = 0; i < pMan->nBins; i++ )
        Abc_AigBinForEachEntry( pMan->pBins[i], pAnd )
            if ( Abc_ObjFanoutNum(pAnd) == 0 )
                Vec_PtrPush( vDangles, pAnd );
    // process the dangling nodes and their MFFCs
    Vec_PtrForEachEntry( Abc_Obj_t *, vDangles, pAnd, i )
        Abc_AigDeleteNode( pMan, pAnd );
    Vec_PtrFree( vDangles );
    return nNodesOld - pMan->nEntries;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigConst1()

ABC_DLL Abc_Obj_t * Abc_AigConst1 ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Performs canonicization step.]

Description [The argument nodes can be complemented.]

SideEffects []

SeeAlso []

Definition at line 683 of file abcAig.c.

{
    assert( Abc_NtkIsStrash(pNtk) );
    return ((Abc_Aig_t *)pNtk->pManFunc)->pConst1;
}

◆ Abc_AigDeleteNode()

ABC_DLL void Abc_AigDeleteNode	(	Abc_Aig_t *	pMan,
		Abc_Obj_t *	pNode )

extern

Function*************************************************************

Synopsis [Performs internal deletion step.]

Description []

SideEffects []

SeeAlso []

Definition at line 989 of file abcAig.c.

{
    Abc_Obj_t * pNode0, * pNode1, * pTemp;
    int i, k;
 
    // make sure the node is regular and dangling
    assert( !Abc_ObjIsComplement(pNode) );
    assert( Abc_ObjIsNode(pNode) );
    assert( Abc_ObjFaninNum(pNode) == 2 );
    assert( Abc_ObjFanoutNum(pNode) == 0 );
 
    // when deleting an old node that is scheduled for replacement, remove it from the replacement queue
    Vec_PtrForEachEntry( Abc_Obj_t *, pMan->vStackReplaceOld, pTemp, i )
        if ( pNode == pTemp )
        {
            // remove the entry from the replacement array
            for ( k = i; k < pMan->vStackReplaceOld->nSize - 1; k++ )
            {
                pMan->vStackReplaceOld->pArray[k] = pMan->vStackReplaceOld->pArray[k+1];
                pMan->vStackReplaceNew->pArray[k] = pMan->vStackReplaceNew->pArray[k+1];
            }
            pMan->vStackReplaceOld->nSize--;
            pMan->vStackReplaceNew->nSize--;
        }
 
    // when deleting a new node that should replace another node, do not delete
    Vec_PtrForEachEntry( Abc_Obj_t *, pMan->vStackReplaceNew, pTemp, i )
        if ( pNode == Abc_ObjRegular(pTemp) )
            return;
 
    // remember the node's fanins
    pNode0 = Abc_ObjFanin0( pNode );
    pNode1 = Abc_ObjFanin1( pNode );
 
    // add the node to the list of updated nodes
    if ( pMan->vUpdatedNets )
    {
        Vec_PtrPushUnique( pMan->vUpdatedNets, pNode0 );
        Vec_PtrPushUnique( pMan->vUpdatedNets, pNode1 );
    }
 
    // remove the node from the table
    Abc_AigAndDelete( pMan, pNode );
    // if the node is in the level structure, remove it
    if ( pNode->fMarkA )
        Abc_AigRemoveFromLevelStructure( pMan->vLevels, pNode );
    if ( pNode->fMarkB )
        Abc_AigRemoveFromLevelStructureR( pMan->vLevelsR, pNode );
    // remove the node from the network
    Abc_NtkDeleteObj( pNode );
 
    // call recursively for the fanins
    if ( Abc_ObjIsNode(pNode0) && pNode0->vFanouts.nSize == 0 )
        Abc_AigDeleteNode( pMan, pNode0 );
    if ( Abc_ObjIsNode(pNode1) && pNode1->vFanouts.nSize == 0 )
        Abc_AigDeleteNode( pMan, pNode1 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigDfs()

ABC_DLL Vec_Ptr_t * Abc_AigDfs	(	Abc_Ntk_t *	pNtk,
		int	fCollectAll,
		int	fCollectCos )

extern

Function*************************************************************

Synopsis [Returns the DFS ordered array of logic nodes.]

Description [Collects only the internal nodes, leaving out CIs/COs. However it marks both CIs and COs with the current TravId.]

SideEffects []

SeeAlso []

Definition at line 1198 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pNode;
    int i;
    assert( Abc_NtkIsStrash(pNtk) );
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    // go through the PO nodes and call for each of them
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        Abc_AigDfs_rec( Abc_ObjFanin0(pNode), vNodes );
        Abc_NodeSetTravIdCurrent( pNode );
        if ( fCollectCos )
            Vec_PtrPush( vNodes, pNode );
    }
    // collect dangling nodes if asked to
    if ( fCollectAll )
    {
        Abc_NtkForEachNode( pNtk, pNode, i )
            if ( !Abc_NodeIsTravIdCurrent(pNode) )
                Abc_AigDfs_rec( pNode, vNodes );
    }
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigDfsMap()

ABC_DLL Vec_Ptr_t * Abc_AigDfsMap ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns the DFS ordered array of logic nodes.]

Description [Collects only the internal nodes, leaving out CIs/COs. However it marks both CIs and COs with the current TravId.]

SideEffects []

SeeAlso []

Definition at line 1238 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pNode;
    int i;
    assert( Abc_NtkIsStrash(pNtk) );
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    // collect cones of barbufs
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        if ( i < Abc_NtkCoNum(pNtk) - pNtk->nBarBufs )
            continue;
        Abc_AigDfs_rec( Abc_ObjFanin0(pNode), vNodes );
        Abc_NodeSetTravIdCurrent( pNode );
        // collect latch as a placeholder
        assert( Abc_ObjIsLatch(Abc_ObjFanout0(pNode)) );
        Vec_PtrPush( vNodes, Abc_ObjFanout0(pNode) );
    }
    // collect nodes of real POs
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        if ( i >= Abc_NtkCoNum(pNtk) - pNtk->nBarBufs )
            break;
        Abc_AigDfs_rec( Abc_ObjFanin0(pNode), vNodes );
        assert( Abc_ObjIsCo(pNode) );
        Abc_NodeSetTravIdCurrent( pNode );
    }
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigFree()

ABC_DLL void Abc_AigFree ( Abc_Aig_t * pMan )

extern

Function*************************************************************

Synopsis [Deallocates the local AIG manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 165 of file abcAig.c.

{
    assert( Vec_PtrSize( pMan->vStackReplaceOld ) == 0 );
    assert( Vec_PtrSize( pMan->vStackReplaceNew ) == 0 );
    // free the table
    if ( pMan->vAddedCells )
        Vec_PtrFree( pMan->vAddedCells );
    if ( pMan->vUpdatedNets )
        Vec_PtrFree( pMan->vUpdatedNets );
    Vec_VecFree( pMan->vLevels );
    Vec_VecFree( pMan->vLevelsR );
    Vec_PtrFree( pMan->vStackReplaceOld );
    Vec_PtrFree( pMan->vStackReplaceNew );
    Vec_PtrFree( pMan->vNodes );
    ABC_FREE( pMan->pBins );
    ABC_FREE( pMan );
}

Here is the caller graph for this function:

◆ Abc_AigGetLevelizedOrder()

ABC_DLL Vec_Ptr_t * Abc_AigGetLevelizedOrder	(	Abc_Ntk_t *	pNtk,
		int	fCollectCis )

extern

Function*************************************************************

Synopsis [Returns nodes by level from the smallest to the largest.]

Description [Correctly handles the case of choice nodes, by first spreading them out across several levels and then collecting.]

SideEffects [What happens with dangling nodes???]

SeeAlso []

Definition at line 1841 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes, * vLevels;
    Abc_Obj_t * pNode, ** ppHead;
    int LevelMax, i;
    assert( Abc_NtkIsStrash(pNtk) );
    // set the correct levels
    Abc_NtkCleanCopy( pNtk );
    LevelMax = Abc_AigSetChoiceLevels( pNtk );
    // relink nodes by level
    vLevels = Vec_PtrStart( LevelMax + 1 );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        ppHead = ((Abc_Obj_t **)vLevels->pArray) + (int)(ABC_PTRINT_T)pNode->pCopy;
        pNode->pCopy = *ppHead;
        *ppHead = pNode;
    }
    // recollect nodes
    vNodes = Vec_PtrStart( Abc_NtkNodeNum(pNtk) );
    Vec_PtrForEachEntryStart( Abc_Obj_t *, vLevels, pNode, i, !fCollectCis )
        for ( ; pNode; pNode = pNode->pCopy )
            Vec_PtrPush( vNodes, pNode );
    Vec_PtrFree( vLevels );
    return vNodes;
}

Here is the call graph for this function:

◆ Abc_AigLevel()

ABC_DLL int Abc_AigLevel ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Computes the number of logic levels not counting PIs/POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 292 of file abcAig.c.

{
    Abc_Obj_t * pNode;
    int i, LevelsMax;
    assert( Abc_NtkIsStrash(pNtk) );
    if ( pNtk->nBarBufs )
        return Abc_NtkLevel( pNtk );
    // perform the traversal
    LevelsMax = 0;
    Abc_NtkForEachCo( pNtk, pNode, i )
        if ( LevelsMax < (int)Abc_ObjFanin0(pNode)->Level )
            LevelsMax = (int)Abc_ObjFanin0(pNode)->Level;
    return LevelsMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigMiter()

ABC_DLL Abc_Obj_t * Abc_AigMiter	(	Abc_Aig_t *	pMan,
		Vec_Ptr_t *	vPairs,
		int	fImplic )

extern

Function*************************************************************

Synopsis [Implements the miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 789 of file abcAig.c.

{
    int i;
    if ( vPairs->nSize == 0 )
        return Abc_ObjNot( Abc_AigConst1(pMan->pNtkAig) );
    assert( vPairs->nSize % 2 == 0 );
    // go through the cubes of the node's SOP
    if ( fImplic )
    {
        for ( i = 0; i < vPairs->nSize; i += 2 )
            vPairs->pArray[i/2] = Abc_AigAnd( pMan, (Abc_Obj_t *)vPairs->pArray[i], Abc_ObjNot((Abc_Obj_t *)vPairs->pArray[i+1]) );
    }
    else
    {
        for ( i = 0; i < vPairs->nSize; i += 2 )
            vPairs->pArray[i/2] = Abc_AigXor( pMan, (Abc_Obj_t *)vPairs->pArray[i], (Abc_Obj_t *)vPairs->pArray[i+1] );
    }
    vPairs->nSize = vPairs->nSize/2;
    return Abc_AigMiter_rec( pMan, (Abc_Obj_t **)vPairs->pArray, vPairs->nSize );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigMux()

ABC_DLL Abc_Obj_t * Abc_AigMux	(	Abc_Aig_t *	pMan,
		Abc_Obj_t *	pC,
		Abc_Obj_t *	p1,
		Abc_Obj_t *	p0 )

extern

Function*************************************************************

Synopsis [Implements Boolean XOR.]

Description []

SideEffects []

SeeAlso []

Definition at line 752 of file abcAig.c.

{
    return Abc_AigOr( pMan, Abc_AigAnd(pMan, pC, p1), Abc_AigAnd(pMan, Abc_ObjNot(pC), p0) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigMuxLookup()

ABC_DLL Abc_Obj_t * Abc_AigMuxLookup	(	Abc_Aig_t *	pMan,
		Abc_Obj_t *	pC,
		Abc_Obj_t *	pT,
		Abc_Obj_t *	pE,
		int *	pType )

extern

Function*************************************************************

Synopsis [Returns the gate implementing EXOR of the two arguments if it exists.]

Description [The argument nodes can be complemented.]

SideEffects []

SeeAlso []

Definition at line 508 of file abcAig.c.

{
    Abc_Obj_t * pNode1, * pNode2, * pNode;
    // set the flag to zero
    if ( pType ) *pType = 0;
    // check the case of MUX(c,t,e) = OR(ct', c'e')'
    if ( (pNode1 = Abc_AigAndLookup(pMan, pC, Abc_ObjNot(pT))) &&
         (pNode2 = Abc_AigAndLookup(pMan, Abc_ObjNot(pC), Abc_ObjNot(pE))) ) 
    {
        pNode = Abc_AigAndLookup( pMan, Abc_ObjNot(pNode1), Abc_ObjNot(pNode2) );
        if ( pNode && pType ) *pType = 1;
        return pNode;
    }
    // check the case of MUX(c,t,e) = OR(ct, c'e)
    if ( (pNode1 = Abc_AigAndLookup(pMan, pC, pT)) &&
         (pNode2 = Abc_AigAndLookup(pMan, Abc_ObjNot(pC), pE)) ) 
    {
        pNode = Abc_AigAndLookup( pMan, Abc_ObjNot(pNode1), Abc_ObjNot(pNode2) );
        return pNode? Abc_ObjNot(pNode) : NULL;
    }
    return NULL;
}

Here is the call graph for this function:

◆ Abc_AigNodeHasComplFanoutEdge()

ABC_DLL int Abc_AigNodeHasComplFanoutEdge ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns 1 if the node has at least one complemented fanout.]

Description [A fanout is complemented if the fanout's fanin edge pointing to the given node is complemented.]

SideEffects []

SeeAlso []

Definition at line 1241 of file abcAig.c.

{
    Abc_Obj_t * pFanout;
    int i, iFanin;
    Abc_ObjForEachFanout( pNode, pFanout, i )
    {
        iFanin = Vec_IntFind( &pFanout->vFanins, pNode->Id );
        assert( iFanin >= 0 );
        if ( Abc_ObjFaninC( pFanout, iFanin ) )
            return 1;
    }
    return 0;
}

◆ Abc_AigNodeHasComplFanoutEdgeTrav()

ABC_DLL int Abc_AigNodeHasComplFanoutEdgeTrav ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns 1 if the node has at least one complemented fanout.]

Description [A fanout is complemented if the fanout's fanin edge pointing to the given node is complemented. Only the fanouts with current TravId are counted.]

SideEffects []

SeeAlso []

Definition at line 1268 of file abcAig.c.

{
    Abc_Obj_t * pFanout;
    int i, iFanin;
    Abc_ObjForEachFanout( pNode, pFanout, i )
    {
        if ( !Abc_NodeIsTravIdCurrent(pFanout) )
            continue;
        iFanin = Vec_IntFind( &pFanout->vFanins, pNode->Id );
        assert( iFanin >= 0 );
        if ( Abc_ObjFaninC( pFanout, iFanin ) )
            return 1;
    }
    return 0;
}

Here is the caller graph for this function:

◆ Abc_AigNodeIsAcyclic()

ABC_DLL int Abc_AigNodeIsAcyclic	(	Abc_Obj_t *	pNode,
		Abc_Obj_t *	pRoot )

extern

Function*************************************************************

Synopsis [Check if the node has a combination loop of depth 1 or 2.]

Description []

SideEffects []

SeeAlso []

Definition at line 1330 of file abcAig.c.

{
    Abc_Obj_t * pFanin0, * pFanin1;
    Abc_Obj_t * pChild00, * pChild01;
    Abc_Obj_t * pChild10, * pChild11;
    if ( !Abc_AigNodeIsAnd(pNode) )
        return 1;
    pFanin0 = Abc_ObjFanin0(pNode);
    pFanin1 = Abc_ObjFanin1(pNode);
    if ( pRoot == pFanin0 || pRoot == pFanin1 )
        return 0;
    if ( Abc_ObjIsCi(pFanin0) )
    {
        pChild00 = NULL;
        pChild01 = NULL;
    }
    else
    {
        pChild00 = Abc_ObjFanin0(pFanin0);
        pChild01 = Abc_ObjFanin1(pFanin0);
        if ( pRoot == pChild00 || pRoot == pChild01 )
            return 0;
    }
    if ( Abc_ObjIsCi(pFanin1) )
    {
        pChild10 = NULL;
        pChild11 = NULL;
    }
    else
    {
        pChild10 = Abc_ObjFanin0(pFanin1);
        pChild11 = Abc_ObjFanin1(pFanin1);
        if ( pRoot == pChild10 || pRoot == pChild11 )
            return 0;
    }
    return 1;
}

◆ Abc_AigOr()

ABC_DLL Abc_Obj_t * Abc_AigOr	(	Abc_Aig_t *	pMan,
		Abc_Obj_t *	p0,
		Abc_Obj_t *	p1 )

extern

Function*************************************************************

Synopsis [Implements Boolean OR.]

Description []

SideEffects []

SeeAlso []

Definition at line 719 of file abcAig.c.

{
    return Abc_ObjNot( Abc_AigAnd( pMan, Abc_ObjNot(p0), Abc_ObjNot(p1) ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigPrintNode()

ABC_DLL void Abc_AigPrintNode ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Prints the AIG node for debugging purposes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1296 of file abcAig.c.

{
    Abc_Obj_t * pNodeR = Abc_ObjRegular(pNode);
    if ( Abc_ObjIsCi(pNodeR) )
    {
        printf( "CI %4s%s.\n", Abc_ObjName(pNodeR), Abc_ObjIsComplement(pNode)? "\'" : "" );
        return;
    }
    if ( Abc_AigNodeIsConst(pNodeR) )
    {
        printf( "Constant 1 %s.\n", Abc_ObjIsComplement(pNode)? "(complemented)" : ""  );
        return;
    }
    // print the node's function
    printf( "%7s%s", Abc_ObjName(pNodeR),                Abc_ObjIsComplement(pNode)? "\'" : "" );
    printf( " = " );
    printf( "%7s%s", Abc_ObjName(Abc_ObjFanin0(pNodeR)), Abc_ObjFaninC0(pNodeR)?     "\'" : "" );
    printf( " * " );
    printf( "%7s%s", Abc_ObjName(Abc_ObjFanin1(pNodeR)), Abc_ObjFaninC1(pNodeR)?     "\'" : "" );
    printf( "\n" );
}

Here is the call graph for this function:

◆ Abc_AigRehash()

ABC_DLL void Abc_AigRehash ( Abc_Aig_t * pMan )

extern

Function*************************************************************

Synopsis [Resizes the hash table of AIG nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 628 of file abcAig.c.

{
    Abc_Obj_t ** pBinsNew;
    Abc_Obj_t * pEnt, * pEnt2;
    int * pArray;
    unsigned Key;
    int Counter, Temp, i;
 
    // allocate a new array
    pBinsNew = ABC_ALLOC( Abc_Obj_t *, pMan->nBins );
    memset( pBinsNew, 0, sizeof(Abc_Obj_t *) * pMan->nBins );
    // rehash the entries from the old table
    Counter = 0;
    for ( i = 0; i < pMan->nBins; i++ )
        Abc_AigBinForEachEntrySafe( pMan->pBins[i], pEnt, pEnt2 )
        {
            // swap the fanins if needed
            pArray = pEnt->vFanins.pArray;
            if ( pArray[0] > pArray[1] )
            {
                Temp = pArray[0];
                pArray[0] = pArray[1];
                pArray[1] = Temp;
                Temp = pEnt->fCompl0;
                pEnt->fCompl0 = pEnt->fCompl1;
                pEnt->fCompl1 = Temp;
            }
            // rehash the node
            Key = Abc_HashKey2( Abc_ObjChild0(pEnt), Abc_ObjChild1(pEnt), pMan->nBins );
            pEnt->pNext   = pBinsNew[Key];
            pBinsNew[Key] = pEnt;
            Counter++;
        }
    assert( Counter == pMan->nEntries );
    // replace the table and the parameters
    ABC_FREE( pMan->pBins );
    pMan->pBins = pBinsNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigReplace()

ABC_DLL int Abc_AigReplace	(	Abc_Aig_t *	pMan,
		Abc_Obj_t *	pOld,
		Abc_Obj_t *	pNew,
		int	fUpdateLevel )

extern

Function*************************************************************

Synopsis [Replaces one AIG node by the other.]

Description []

SideEffects []

SeeAlso []

Definition at line 850 of file abcAig.c.

{
    assert( Vec_PtrSize(pMan->vStackReplaceOld) == 0 );
    assert( Vec_PtrSize(pMan->vStackReplaceNew) == 0 );
    Vec_PtrPush( pMan->vStackReplaceOld, pOld );
    Vec_PtrPush( pMan->vStackReplaceNew, pNew );
    assert( !Abc_ObjIsComplement(pOld) );
    // process the replacements
    while ( Vec_PtrSize(pMan->vStackReplaceOld) )
    {
        pOld = (Abc_Obj_t *)Vec_PtrPop( pMan->vStackReplaceOld );
        pNew = (Abc_Obj_t *)Vec_PtrPop( pMan->vStackReplaceNew );
        if ( Abc_ObjFanoutNum(pOld) == 0 )
            //return 0;
            continue;
        Abc_AigReplace_int( pMan, pOld, pNew, fUpdateLevel );
    }
    if ( fUpdateLevel )
    {
        Abc_AigUpdateLevel_int( pMan );
        if ( pMan->pNtkAig->vLevelsR ) 
            Abc_AigUpdateLevelR_int( pMan );
    }
    return 1;
}

Here is the caller graph for this function:

◆ Abc_AigSetNodePhases()

ABC_DLL void Abc_AigSetNodePhases ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Sets the correct phase of the nodes.]

Description [The AIG nodes should be in the DFS order.]

SideEffects []

SeeAlso []

Definition at line 1406 of file abcAig.c.

{
    Abc_Obj_t * pObj;
    int i;
    assert( Abc_NtkIsDfsOrdered(pNtk) );
    Abc_AigConst1(pNtk)->fPhase = 1;
    Abc_NtkForEachPi( pNtk, pObj, i )
        pObj->fPhase = 0;
    Abc_NtkForEachLatchOutput( pNtk, pObj, i )
        pObj->fPhase = Abc_LatchIsInit1(pObj);
    Abc_AigForEachAnd( pNtk, pObj, i )
        pObj->fPhase = (Abc_ObjFanin0(pObj)->fPhase ^ Abc_ObjFaninC0(pObj)) & (Abc_ObjFanin1(pObj)->fPhase ^ Abc_ObjFaninC1(pObj));
    Abc_NtkForEachPo( pNtk, pObj, i )
        pObj->fPhase = (Abc_ObjFanin0(pObj)->fPhase ^ Abc_ObjFaninC0(pObj));
    Abc_NtkForEachLatchInput( pNtk, pObj, i )
        pObj->fPhase = (Abc_ObjFanin0(pObj)->fPhase ^ Abc_ObjFaninC0(pObj));
}

Here is the call graph for this function:

◆ Abc_AigUpdateReset()

ABC_DLL void Abc_AigUpdateReset ( Abc_Aig_t * pMan )

extern

Function*************************************************************

Synopsis [Start the update list.]

Description []

SideEffects []

SeeAlso []

Definition at line 1477 of file abcAig.c.

{
    assert( pMan->vAddedCells != NULL );
    Vec_PtrClear( pMan->vAddedCells );
    Vec_PtrClear( pMan->vUpdatedNets );
}

Here is the caller graph for this function:

◆ Abc_AigUpdateStart()

ABC_DLL Vec_Ptr_t * Abc_AigUpdateStart	(	Abc_Aig_t *	pMan,
		Vec_Ptr_t **	pvUpdatedNets )

extern

Function*************************************************************

Synopsis [Start the update list.]

Description []

SideEffects []

SeeAlso []

Definition at line 1437 of file abcAig.c.

{
    assert( pMan->vAddedCells == NULL );
    pMan->vAddedCells  = Vec_PtrAlloc( 1000 );
    pMan->vUpdatedNets = Vec_PtrAlloc( 1000 );
    *pvUpdatedNets = pMan->vUpdatedNets;
    return pMan->vAddedCells;
}

◆ Abc_AigUpdateStop()

ABC_DLL void Abc_AigUpdateStop ( Abc_Aig_t * pMan )

extern

Function*************************************************************

Synopsis [Start the update list.]

Description []

SideEffects []

SeeAlso []

Definition at line 1457 of file abcAig.c.

{
    assert( pMan->vAddedCells != NULL );
    Vec_PtrFree( pMan->vAddedCells );
    Vec_PtrFree( pMan->vUpdatedNets );
    pMan->vAddedCells = NULL;
    pMan->vUpdatedNets = NULL;
}

◆ Abc_AigXor()

ABC_DLL Abc_Obj_t * Abc_AigXor	(	Abc_Aig_t *	pMan,
		Abc_Obj_t *	p0,
		Abc_Obj_t *	p1 )

extern

Function*************************************************************

Synopsis [Implements Boolean XOR.]

Description []

SideEffects []

SeeAlso []

Definition at line 735 of file abcAig.c.

{
    return Abc_AigOr( pMan, Abc_AigAnd(pMan, p0, Abc_ObjNot(p1)), 
                            Abc_AigAnd(pMan, p1, Abc_ObjNot(p0)) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_AigXorLookup()

ABC_DLL Abc_Obj_t * Abc_AigXorLookup	(	Abc_Aig_t *	pMan,
		Abc_Obj_t *	p0,
		Abc_Obj_t *	p1,
		int *	pType )

extern

Function*************************************************************

Synopsis [Returns the gate implementing EXOR of the two arguments if it exists.]

Description [The argument nodes can be complemented.]

SideEffects []

SeeAlso []

Definition at line 474 of file abcAig.c.

{
    Abc_Obj_t * pNode1, * pNode2, * pNode;
    // set the flag to zero
    if ( pType ) *pType = 0;
    // check the case of XOR(a,b) = OR(ab, a'b')'
    if ( (pNode1 = Abc_AigAndLookup(pMan, Abc_ObjNot(p0), Abc_ObjNot(p1))) &&
         (pNode2 = Abc_AigAndLookup(pMan, p0, p1)) ) 
    {
        pNode = Abc_AigAndLookup( pMan, Abc_ObjNot(pNode1), Abc_ObjNot(pNode2) );
        if ( pNode && pType ) *pType = 1;
        return pNode;
    }
    // check the case of XOR(a,b) = OR(a'b, ab')
    if ( (pNode1 = Abc_AigAndLookup(pMan, p0, Abc_ObjNot(p1))) &&
         (pNode2 = Abc_AigAndLookup(pMan, Abc_ObjNot(p0), p1)) ) 
    {
        pNode = Abc_AigAndLookup( pMan, Abc_ObjNot(pNode1), Abc_ObjNot(pNode2) );
        return pNode? Abc_ObjNot(pNode) : NULL;
    }
    return NULL;
}

Here is the call graph for this function:

◆ Abc_DesAddModel()

ABC_DLL int Abc_DesAddModel	(	Abc_Des_t *	p,
		Abc_Ntk_t *	pNtk )

extern

Function*************************************************************

Synopsis [Create the library.]

Description []

SideEffects []

SeeAlso []

Definition at line 226 of file abcLib.c.

{
    if ( st__is_member( p->tModules, (char *)pNtk->pName ) )
        return 0;
    st__insert( p->tModules, (char *)pNtk->pName, (char *)pNtk );
    assert( pNtk->Id == 0 );
    pNtk->Id = Vec_PtrSize(p->vModules);
    Vec_PtrPush( p->vModules, pNtk );
    pNtk->pDesign = p;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_DesCleanManPointer()

ABC_DLL void Abc_DesCleanManPointer	(	Abc_Des_t *	p,
		void *	pMan )

extern

Function*************************************************************

Synopsis [Removes all pointers to the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 70 of file abcLib.c.

{
    Abc_Ntk_t * pTemp;
    int i;
    if ( p == NULL )
        return;
    if ( p->pManFunc == pMan )
        p->pManFunc = NULL;
    Vec_PtrForEachEntry( Abc_Ntk_t *, p->vModules, pTemp, i )
        if ( pTemp->pManFunc == pMan )
            pTemp->pManFunc = NULL;
}

◆ Abc_DesCreate()

ABC_DLL Abc_Des_t * Abc_DesCreate ( char * pName )

extern

DECLARATIONS ///.

CFile****************************************************************

FileName [abcLib.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Functions to manipulate verilog libraries.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: abcLib.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Create the library.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file abcLib.c.

{
    Abc_Des_t * p;
    p = ABC_ALLOC( Abc_Des_t, 1 );
    memset( p, 0, sizeof(Abc_Des_t) );
    p->pName    = Abc_UtilStrsav( pName );
    p->tModules = st__init_table( strcmp, st__strhash );
    p->vTops    = Vec_PtrAlloc( 100 );
    p->vModules = Vec_PtrAlloc( 100 );
    p->pManFunc = Hop_ManStart();
    p->pLibrary = NULL;
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_DesDeriveRoot()

ABC_DLL Abc_Ntk_t * Abc_DesDeriveRoot ( Abc_Des_t * p )

extern

Function*************************************************************

Synopsis [Frees the library.]

Description []

SideEffects []

SeeAlso []

Definition at line 269 of file abcLib.c.

{
    Abc_Ntk_t * pNtk;
    if ( Vec_PtrSize(p->vModules) > 1 )
    {
        printf( "The design includes more than one module and is currently not used.\n" );
        return NULL;
    }
    pNtk = (Abc_Ntk_t *)Vec_PtrEntry( p->vModules, 0 );  Vec_PtrClear( p->vModules );
    pNtk->pManFunc = p->pManFunc;           p->pManFunc = NULL;
    return pNtk;
}

◆ Abc_DesDup()

ABC_DLL Abc_Des_t * Abc_DesDup ( Abc_Des_t * p )

extern

Function*************************************************************

Synopsis [Duplicated the library.]

Description []

SideEffects []

SeeAlso []

Definition at line 133 of file abcLib.c.

{
    Abc_Des_t * pNew;
    Abc_Ntk_t * pTemp;
    Abc_Obj_t * pObj;
    int i, k;
    pNew = Abc_DesCreate( p->pName );
    Vec_PtrForEachEntry( Abc_Ntk_t *, p->vModules, pTemp, i )
        Abc_DesAddModel( pNew, Abc_NtkDup(pTemp) );
    Vec_PtrForEachEntry( Abc_Ntk_t *, p->vTops, pTemp, i )
        Vec_PtrPush( pNew->vTops, pTemp->pCopy );
    Vec_PtrForEachEntry( Abc_Ntk_t *, p->vModules, pTemp, i )
        pTemp->pCopy->pAltView = pTemp->pAltView ? pTemp->pAltView->pCopy : NULL;
    // update box models
    Vec_PtrForEachEntry( Abc_Ntk_t *, p->vModules, pTemp, i )
        Abc_NtkForEachBox( pTemp, pObj, k )
            if ( Abc_ObjIsWhitebox(pObj) || Abc_ObjIsBlackbox(pObj) )
                pObj->pCopy->pData = Abc_ObjModel(pObj)->pCopy;
    return pNew;
}

Here is the call graph for this function:

◆ Abc_DesFindModelByName()

ABC_DLL Abc_Ntk_t * Abc_DesFindModelByName	(	Abc_Des_t *	p,
		char *	pName )

extern

Function*************************************************************

Synopsis [Create the library.]

Description []

SideEffects []

SeeAlso []

Definition at line 249 of file abcLib.c.

{
    Abc_Ntk_t * pNtk;
    if ( ! st__is_member( p->tModules, (char *)pName ) )
        return NULL;
    st__lookup( p->tModules, (char *)pName, (char **)&pNtk );
    return pNtk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_DesFindTopLevelModels()

ABC_DLL int Abc_DesFindTopLevelModels ( Abc_Des_t * p )

extern

Function*************************************************************

Synopsis [Detects the top-level models.]

Description []

SideEffects []

SeeAlso []

Definition at line 293 of file abcLib.c.

{
    Abc_Ntk_t * pNtk, * pNtkBox;
    Abc_Obj_t * pObj;
    int i, k;
    assert( Vec_PtrSize( p->vModules ) > 0 );
    // clear the models
    Vec_PtrForEachEntry( Abc_Ntk_t *, p->vModules, pNtk, i )
        pNtk->fHieVisited = 0;
    // mark all the models reachable from other models
    Vec_PtrForEachEntry( Abc_Ntk_t *, p->vModules, pNtk, i )
    {
        Abc_NtkForEachBox( pNtk, pObj, k )
        {
            if ( Abc_ObjIsLatch(pObj) )
                continue;
            if ( pObj->pData == NULL )
                continue;
            pNtkBox = (Abc_Ntk_t *)pObj->pData;
            pNtkBox->fHieVisited = 1;
        }
    }
    // collect the models that are not marked
    Vec_PtrClear( p->vTops );
    Vec_PtrForEachEntry( Abc_Ntk_t *, p->vModules, pNtk, i )
    {
        if ( pNtk->fHieVisited == 0 )
            Vec_PtrPush( p->vTops, pNtk );
        else
            pNtk->fHieVisited = 0;
    }
    return Vec_PtrSize( p->vTops );
}

Here is the caller graph for this function:

◆ Abc_DesFree()

ABC_DLL void Abc_DesFree	(	Abc_Des_t *	p,
		Abc_Ntk_t *	pNtkSave )

extern

Function*************************************************************

Synopsis [Frees the library.]

Description []

SideEffects []

SeeAlso []

Definition at line 94 of file abcLib.c.

{
    Abc_Ntk_t * pNtk;
    int i;
    if ( p->pName )
        ABC_FREE( p->pName );
    if ( p->pManFunc )
        Hop_ManStop( (Hop_Man_t *)p->pManFunc );
    if ( p->tModules )
        st__free_table( p->tModules );
    if ( p->vModules )
    {
        Vec_PtrForEachEntry( Abc_Ntk_t *, p->vModules, pNtk, i )
        {
            if ( pNtk == pNtkSave )
                continue;
            pNtk->pDesign = NULL;
            if ( (pNtkSave && pNtk->pManFunc == pNtkSave->pManFunc) || (pNtk->pManFunc == p->pManFunc) )
                pNtk->pManFunc = NULL;
            Abc_NtkDelete( pNtk );
        }
        Vec_PtrFree( p->vModules );
    }
    if ( p->vTops )
        Vec_PtrFree( p->vTops );
    ABC_FREE( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_DesPrint()

ABC_DLL void Abc_DesPrint ( Abc_Des_t * p )

extern

Function*************************************************************

Synopsis [Prints the library.]

Description []

SideEffects []

SeeAlso []

Definition at line 194 of file abcLib.c.

{
    Abc_Ntk_t * pNtk;
    Abc_Obj_t * pObj;
    int i, k;
    printf( "Models of design %s:\n", p->pName );
    Vec_PtrForEachEntry( Abc_Ntk_t *, p->vModules, pNtk, i )
    {
        printf( "%2d : %20s   ", i+1, pNtk->pName );
        printf( "nd = %6d   lat = %6d   whitebox = %3d   blackbox = %3d\n", 
            Abc_NtkNodeNum(pNtk), Abc_NtkLatchNum(pNtk), 
            Abc_NtkWhiteboxNum(pNtk), Abc_NtkBlackboxNum(pNtk) );
        if ( Abc_NtkBlackboxNum(pNtk) == 0 )
            continue;
        Abc_NtkForEachWhitebox( pNtk, pObj, k )
            printf( "     %20s (whitebox)\n", Abc_NtkName((Abc_Ntk_t *)pObj->pData) );
        Abc_NtkForEachBlackbox( pNtk, pObj, k )
            printf( "     %20s (blackbox)\n", Abc_NtkName((Abc_Ntk_t *)pObj->pData) );
    }
}

◆ Abc_DfsLevelized()

ABC_DLL Vec_Vec_t * Abc_DfsLevelized	(	Abc_Obj_t *	pNode,
		int	fTfi )

extern

Function*************************************************************

Synopsis [Collects nodes in the DFS manner by level.]

Description [The number of levels should be set!!!]

SideEffects []

SeeAlso []

Definition at line 1313 of file abcDfs.c.

{
    Vec_Vec_t * vLevels;
    Abc_Obj_t * pFanout;
    int i;
    assert( fTfi == 0 );
    assert( !Abc_NtkIsNetlist(pNode->pNtk) );
    // set the traversal ID
    Abc_NtkIncrementTravId( pNode->pNtk );
    vLevels = Vec_VecAlloc( 100 );
    if ( Abc_ObjIsNode(pNode) )
        Abc_DfsLevelizedTfo_rec( pNode, vLevels );
    else
    {
        assert( Abc_ObjIsCi(pNode) );
        Abc_NodeSetTravIdCurrent( pNode );
        Abc_ObjForEachFanout( pNode, pFanout, i )
            Abc_DfsLevelizedTfo_rec( pFanout, vLevels );
    }
    return vLevels;
}

Here is the call graph for this function:

◆ Abc_ExactBuildNode()

ABC_DLL Abc_Obj_t * Abc_ExactBuildNode	(	word *	pTruth,
		int	nVars,
		int *	pArrTimeProfile,
		Abc_Obj_t **	pFanins,
		Abc_Ntk_t *	pNtk )

extern

Definition at line 2894 of file abcExact.c.

{
    char * pSol = NULL;
    int i, j, nMaxArrival;
    int pNormalArrTime[8];
    char const * p;
    Abc_Obj_t * pObj;
    Vec_Ptr_t * pGates;
    char pGateTruth[5];
    char * pSopCover;
    abctime timeStart = Abc_Clock();
 
    if ( nVars == 0 )
    {
        s_pSesStore->timeTotal += ( Abc_Clock() - timeStart );
        return (pTruth[0] & 1) ? Abc_NtkCreateNodeConst1(pNtk) : Abc_NtkCreateNodeConst0(pNtk);
    }
    if ( nVars == 1 )
    {
        s_pSesStore->timeTotal += ( Abc_Clock() - timeStart );
        return (pTruth[0] & 1) ? Abc_NtkCreateNodeInv(pNtk, pFanins[0]) : Abc_NtkCreateNodeBuf(pNtk, pFanins[0]);
    }
 
    for ( i = 0; i < nVars; ++i )
        pNormalArrTime[i] = pArrTimeProfile[i];
    Abc_NormalizeArrivalTimes( pNormalArrTime, nVars, &nMaxArrival );
    assert( Ses_StoreGetEntry( s_pSesStore, pTruth, nVars, pNormalArrTime, &pSol ) );
    if ( !pSol )
    {
        s_pSesStore->timeTotal += ( Abc_Clock() - timeStart );
        return NULL;
    }
 
    assert( pSol[ABC_EXACT_SOL_NVARS] == nVars );
    assert( pSol[ABC_EXACT_SOL_NFUNC] == 1 );
 
    pGates = Vec_PtrAlloc( nVars + pSol[ABC_EXACT_SOL_NGATES] );
    pGateTruth[3] = '0';
    pGateTruth[4] = '\0';
 
    /* primary inputs */
    for ( i = 0; i < nVars; ++i )
    {
        assert( pFanins[i] );
        Vec_PtrPush( pGates, pFanins[i] );
    }
 
    /* gates */
    p = pSol + 3;
    for ( i = 0; i < pSol[ABC_EXACT_SOL_NGATES]; ++i )
    {
        pGateTruth[2] = '0' + ( *p & 1 );
        pGateTruth[1] = '0' + ( ( *p >> 1 ) & 1 );
        pGateTruth[0] = '0' + ( ( *p >> 2 ) & 1 );
        ++p;
 
        assert( *p == 2 ); /* binary gate */
        ++p;
 
        /* invert truth table if we are last gate and inverted */
        if ( i + 1 == pSol[ABC_EXACT_SOL_NGATES] && Abc_LitIsCompl( *( p + 2 ) ) )
            for ( j = 0; j < 4; ++j )
                pGateTruth[j] = ( pGateTruth[j] == '0' ) ? '1' : '0';
 
        pSopCover = Abc_SopFromTruthBin( pGateTruth );
        pObj = Abc_NtkCreateNode( pNtk );
        assert( pObj );
        pObj->pData = Abc_SopRegister( (Mem_Flex_t*)pNtk->pManFunc, pSopCover );
        Vec_PtrPush( pGates, pObj );
        ABC_FREE( pSopCover );
 
        Abc_ObjAddFanin( pObj, (Abc_Obj_t *)Vec_PtrEntry( pGates, *p++ ) );
        Abc_ObjAddFanin( pObj, (Abc_Obj_t *)Vec_PtrEntry( pGates, *p++ ) );
    }
 
    /* output */
    pObj = (Abc_Obj_t *)Vec_PtrEntry( pGates, nVars + Abc_Lit2Var( *p ) );
 
    Vec_PtrFree( pGates );
 
    s_pSesStore->timeTotal += ( Abc_Clock() - timeStart );
    return pObj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ExactInputNum()

ABC_DLL int Abc_ExactInputNum ( )

extern

Definition at line 2611 of file abcExact.c.

{
    return 8;
}

◆ Abc_ExactIsRunning()

ABC_DLL int Abc_ExactIsRunning ( )

extern

Function*************************************************************

Synopsis [APIs for integraging with the mapper.]

Definition at line 2605 of file abcExact.c.

{
    return s_pSesStore != NULL;
}

◆ Abc_ManTimeDup()

ABC_DLL void Abc_ManTimeDup	(	Abc_Ntk_t *	pNtkOld,
		Abc_Ntk_t *	pNtkNew )

extern

Function*************************************************************

Synopsis [Duplicates the timing manager with the PI/PO timing info.]

Description [The PIs/POs of the new network should be allocated.]

SideEffects []

SeeAlso []

Definition at line 573 of file abcTiming.c.

{
    extern void Abc_NtkTimePrint( Abc_Ntk_t * pNtk );
 
    Abc_Obj_t * pObj;
    Abc_Time_t ** ppTimesOld, ** ppTimesNew;
    int i;
    if ( pNtkOld->pManTime == NULL )
        return;
    assert( Abc_NtkCiNum(pNtkOld) == Abc_NtkCiNum(pNtkNew) );
    assert( Abc_NtkCoNum(pNtkOld) == Abc_NtkCoNum(pNtkNew) );
    assert( Abc_NtkLatchNum(pNtkOld) == Abc_NtkLatchNum(pNtkNew) );
    // create the new timing manager
    pNtkNew->pManTime = Abc_ManTimeStart(pNtkNew);
    Abc_ManTimeExpand( pNtkNew->pManTime, Abc_NtkObjNumMax(pNtkNew), 0 );
    // set the default timing
    pNtkNew->pManTime->tArrDef = pNtkOld->pManTime->tArrDef;
    pNtkNew->pManTime->tReqDef = pNtkOld->pManTime->tReqDef;
    // set the CI timing
    ppTimesOld = (Abc_Time_t **)pNtkOld->pManTime->vArrs->pArray;
    ppTimesNew = (Abc_Time_t **)pNtkNew->pManTime->vArrs->pArray;
    Abc_NtkForEachCi( pNtkOld, pObj, i )
        *ppTimesNew[ Abc_NtkCi(pNtkNew,i)->Id ] = *ppTimesOld[ pObj->Id ];
    // set the CO timing
    ppTimesOld = (Abc_Time_t **)pNtkOld->pManTime->vReqs->pArray;
    ppTimesNew = (Abc_Time_t **)pNtkNew->pManTime->vReqs->pArray;
    Abc_NtkForEachCo( pNtkOld, pObj, i )
        *ppTimesNew[ Abc_NtkCo(pNtkNew,i)->Id ] = *ppTimesOld[ pObj->Id ];
    // duplicate input drive
    pNtkNew->pManTime->tInDriveDef = pNtkOld->pManTime->tInDriveDef; 
    pNtkNew->pManTime->tOutLoadDef = pNtkOld->pManTime->tOutLoadDef; 
    if ( pNtkOld->pManTime->tInDrive )
    {
        pNtkNew->pManTime->tInDrive = ABC_ALLOC( Abc_Time_t, Abc_NtkCiNum(pNtkOld) );
        memcpy( pNtkNew->pManTime->tInDrive, pNtkOld->pManTime->tInDrive, sizeof(Abc_Time_t) * Abc_NtkCiNum(pNtkOld) );
    }
    if ( pNtkOld->pManTime->tOutLoad )
    {
        pNtkNew->pManTime->tOutLoad = ABC_ALLOC( Abc_Time_t, Abc_NtkCoNum(pNtkOld) );
        memcpy( pNtkNew->pManTime->tOutLoad, pNtkOld->pManTime->tOutLoad, sizeof(Abc_Time_t) * Abc_NtkCoNum(pNtkOld) );
    }
 
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ManTimeStop()

ABC_DLL void Abc_ManTimeStop ( Abc_ManTime_t * p )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 547 of file abcTiming.c.

{
    if ( p->tInDrive )
        ABC_FREE( p->tInDrive );
    if ( p->tOutLoad )
        ABC_FREE( p->tOutLoad );
    if ( Vec_PtrSize(p->vArrs) > 0 )
        ABC_FREE( p->vArrs->pArray[0] );
    Vec_PtrFree( p->vArrs );
    if ( Vec_PtrSize(p->vReqs) > 0 )
        ABC_FREE( p->vReqs->pArray[0] );
    Vec_PtrFree( p->vReqs );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Abc_NodeBddToCnf()

ABC_DLL void Abc_NodeBddToCnf	(	Abc_Obj_t *	pNode,
		Mem_Flex_t *	pMmMan,
		Vec_Str_t *	vCube,
		int	fAllPrimes,
		char **	ppSop0,
		char **	ppSop1 )

extern

Definition at line 867 of file abcFunc.c.

867{}

Here is the caller graph for this function:

◆ Abc_NodeCollectFanins()

ABC_DLL void Abc_NodeCollectFanins	(	Abc_Obj_t *	pNode,
		Vec_Ptr_t *	vNodes )

extern

Function*************************************************************

Synopsis [Returns 1 if it is an AIG with choice nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1627 of file abcUtil.c.

{
    Abc_Obj_t * pFanin;
    int i;
    Vec_PtrClear(vNodes);
    Abc_ObjForEachFanin( pNode, pFanin, i )
        Vec_PtrPush( vNodes, pFanin );
}

Here is the caller graph for this function:

◆ Abc_NodeCollectFanouts()

ABC_DLL void Abc_NodeCollectFanouts	(	Abc_Obj_t *	pNode,
		Vec_Ptr_t *	vNodes )

extern

Function*************************************************************

Synopsis [Returns 1 if it is an AIG with choice nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1647 of file abcUtil.c.

{
    Abc_Obj_t * pFanout;
    int i;
    Vec_PtrClear(vNodes);
    Abc_ObjForEachFanout( pNode, pFanout, i )
        Vec_PtrPush( vNodes, pFanout );
}

Here is the caller graph for this function:

◆ Abc_NodeCollectTfoCands()

ABC_DLL Vec_Ptr_t * Abc_NodeCollectTfoCands	(	Abc_ManCut_t *	p,
		Abc_Obj_t *	pRoot,
		Vec_Ptr_t *	vLeaves,
		int	LevelMax )

extern

Function*************************************************************

Synopsis [Collects the TFO of the cut in the topological order.]

Description [TFO of the cut is defined as a set of nodes, for which the cut is a cut, that is, every path from the collected nodes to the CIs goes through a node in the cut. The nodes are collected if their level does not exceed the given number (LevelMax). The nodes are returned in the topological order. If the root node is given, its MFFC is marked, so that the collected nodes do not contain any nodes in the MFFC.]

SideEffects []

SeeAlso []

Definition at line 699 of file abcReconv.c.

{
    Abc_Ntk_t * pNtk = pRoot->pNtk;
    Vec_Ptr_t * vVec;
    Abc_Obj_t * pNode, * pFanout;
    int i, k, v, LevelMin;
    assert( Abc_NtkIsStrash(pNtk) );
 
    // assuming that the structure is clean
    Vec_VecForEachLevel( p->vLevels, vVec, i )
        assert( vVec->nSize == 0 );
 
    // put fanins into the structure while labeling them
    Abc_NtkIncrementTravId( pNtk );
    LevelMin = -1;
    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pNode, i )
    {
        if ( pNode->Level > (unsigned)LevelMax )
            continue;
        Abc_NodeSetTravIdCurrent( pNode );
        Vec_VecPush( p->vLevels, pNode->Level, pNode );
        if ( LevelMin < (int)pNode->Level )
            LevelMin = pNode->Level;
    }
    assert( LevelMin >= 0 );
 
    // mark MFFC 
    if ( pRoot )
        Abc_NodeMffcLabelAig( pRoot );
 
    // go through the levels up
    Vec_PtrClear( p->vNodesTfo );
    Vec_VecForEachEntryStart( Abc_Obj_t *, p->vLevels, pNode, i, k, LevelMin )
    {
        if ( i > LevelMax )
            break;
        // if the node is not marked, it is not a fanin
        if ( !Abc_NodeIsTravIdCurrent(pNode) )
        {
            // check if it belongs to the TFO
            if ( !Abc_NodeIsTravIdCurrent(Abc_ObjFanin0(pNode)) || 
                 !Abc_NodeIsTravIdCurrent(Abc_ObjFanin1(pNode)) )
                 continue;
            // save the node in the TFO and label it
            Vec_PtrPush( p->vNodesTfo, pNode );
            Abc_NodeSetTravIdCurrent( pNode );
        }
        // go through the fanouts and add them to the structure if they meet the conditions
        Abc_ObjForEachFanout( pNode, pFanout, v )
        {
            // skip if fanout is a CO or its level exceeds
            if ( Abc_ObjIsCo(pFanout) || pFanout->Level > (unsigned)LevelMax )
                continue;
            // skip if it is already added or if it is in MFFC
            if ( Abc_NodeIsTravIdCurrent(pFanout) )
                continue;
            // add it to the structure but do not mark it (until tested later)
            Vec_VecPushUnique( p->vLevels, pFanout->Level, pFanout );
        }
    }
 
    // clear the levelized structure
    Vec_VecForEachLevelStart( p->vLevels, vVec, i, LevelMin )
    {
        if ( i > LevelMax )
            break;
        Vec_PtrClear( vVec );
    }
    return p->vNodesTfo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeCompareLevelsDecrease()

ABC_DLL int Abc_NodeCompareLevelsDecrease	(	Abc_Obj_t **	pp1,
		Abc_Obj_t **	pp2 )

extern

Function*************************************************************

Synopsis [Procedure used for sorting the nodes in decreasing order of levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 1715 of file abcUtil.c.

{
    int Diff = Abc_ObjRegular(*pp1)->Level - Abc_ObjRegular(*pp2)->Level;
    if ( Diff > 0 )
        return -1;
    if ( Diff < 0 ) 
        return 1;
    Diff = Abc_ObjRegular(*pp1)->Id - Abc_ObjRegular(*pp2)->Id;
    if ( Diff > 0 )
        return -1;
    if ( Diff < 0 ) 
        return 1;
    return 0; 
}

◆ Abc_NodeCompareLevelsIncrease()

ABC_DLL int Abc_NodeCompareLevelsIncrease	(	Abc_Obj_t **	pp1,
		Abc_Obj_t **	pp2 )

extern

Function*************************************************************

Synopsis [Procedure used for sorting the nodes in increasing order of levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 1689 of file abcUtil.c.

{
    int Diff = Abc_ObjRegular(*pp1)->Level - Abc_ObjRegular(*pp2)->Level;
    if ( Diff < 0 )
        return -1;
    if ( Diff > 0 ) 
        return 1;
    Diff = Abc_ObjRegular(*pp1)->Id - Abc_ObjRegular(*pp2)->Id;
    if ( Diff < 0 )
        return -1;
    if ( Diff > 0 ) 
        return 1;
    return 0; 
}

Here is the caller graph for this function:

◆ Abc_NodeCompareNames()

ABC_DLL int Abc_NodeCompareNames	(	Abc_Obj_t **	pp1,
		Abc_Obj_t **	pp2 )

extern

Function*************************************************************

Synopsis [Orders PIs/POs/latches alphabetically.]

Description []

SideEffects []

SeeAlso []

Definition at line 316 of file abcNames.c.

{
    int Diff = strcmp( (char *)(*pp1)->pCopy, (char *)(*pp2)->pCopy );
    if ( Diff < 0 )
        return -1;
    if ( Diff > 0 ) 
        return 1;
    Diff = (*pp1)->Id - (*pp2)->Id;
    if ( Diff < 0 )
        return -1;
    if ( Diff > 0 ) 
        return 1;
    return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeComplement()

ABC_DLL void Abc_NodeComplement ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Complements the local functions of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1012 of file abcObj.c.

{
    assert( Abc_NtkIsLogic(pNode->pNtk) || Abc_NtkIsNetlist(pNode->pNtk) );
    assert( Abc_ObjIsNode(pNode) ); 
    if ( Abc_NtkHasSop(pNode->pNtk) )
        Abc_SopComplement( (char *)pNode->pData );
    else if ( Abc_NtkHasAig(pNode->pNtk) )
        pNode->pData = Hop_Not( (Hop_Obj_t *)pNode->pData );
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNode->pNtk) )
        pNode->pData = Cudd_Not( pNode->pData );
#endif
    else
        assert( 0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeComplementInput()

ABC_DLL void Abc_NodeComplementInput	(	Abc_Obj_t *	pNode,
		Abc_Obj_t *	pFanin )

extern

Function*************************************************************

Synopsis [Changes the polarity of one fanin.]

Description []

SideEffects []

SeeAlso []

Definition at line 1039 of file abcObj.c.

{
    int iFanin;
    if ( (iFanin = Vec_IntFind( &pNode->vFanins, pFanin->Id )) == -1 )
    {
        printf( "Node %s should be among", Abc_ObjName(pFanin) );
        printf( " the fanins of node %s...\n", Abc_ObjName(pNode) );
        return;
    }
    if ( Abc_NtkHasSop(pNode->pNtk) )
        Abc_SopComplementVar( (char *)pNode->pData, iFanin );
    else if ( Abc_NtkHasAig(pNode->pNtk) )
        pNode->pData = Hop_Complement( (Hop_Man_t *)pNode->pNtk->pManFunc, (Hop_Obj_t *)pNode->pData, iFanin );
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNode->pNtk) )
    {
        DdManager * dd = (DdManager *)pNode->pNtk->pManFunc;
        DdNode * bVar, * bCof0, * bCof1;
        bVar = Cudd_bddIthVar( dd, iFanin );
        bCof0 = Cudd_Cofactor( dd, (DdNode *)pNode->pData, Cudd_Not(bVar) );   Cudd_Ref( bCof0 );
        bCof1 = Cudd_Cofactor( dd, (DdNode *)pNode->pData, bVar );             Cudd_Ref( bCof1 );
        Cudd_RecursiveDeref( dd, (DdNode *)pNode->pData );
        pNode->pData = Cudd_bddIte( dd, bVar, bCof0, bCof1 );        Cudd_Ref( (DdNode *)pNode->pData );
        Cudd_RecursiveDeref( dd, bCof0 );
        Cudd_RecursiveDeref( dd, bCof1 );
    }
#endif
    else
        assert( 0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeConeCollect()

ABC_DLL void Abc_NodeConeCollect	(	Abc_Obj_t **	ppRoots,
		int	nRoots,
		Vec_Ptr_t *	vLeaves,
		Vec_Ptr_t *	vVisited,
		int	fIncludeFanins )

extern

Function*************************************************************

Synopsis [Get the nodes contained in the cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 444 of file abcReconv.c.

{
    Abc_Obj_t * pTemp;
    int i;
    // mark the fanins of the cone
    Abc_NodesMark( vLeaves );
    // collect the nodes in the DFS order
    Vec_PtrClear( vVisited );
    // add the fanins
    if ( fIncludeFanins )
        Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pTemp, i )
            Vec_PtrPush( vVisited, pTemp );
    // add other nodes
    for ( i = 0; i < nRoots; i++ )
        Abc_NodeConeMarkCollect_rec( ppRoots[i], vVisited );
    // unmark both sets
    Abc_NodesUnmark( vLeaves );
    Abc_NodesUnmark( vVisited );
}

Here is the caller graph for this function:

◆ Abc_NodeConvertSopToMvSop()

ABC_DLL char * Abc_NodeConvertSopToMvSop	(	int	nVars,
		Vec_Int_t *	vSop0,
		Vec_Int_t *	vSop1 )

extern

Function*************************************************************

Synopsis [Converts SOP into MV-SOP.]

Description []

SideEffects []

SeeAlso []

Definition at line 1033 of file abcBlifMv.c.

{
    char * pMvSop, * pCur;
    unsigned uCube;
    int nCubes, nSize, Value, i, k;
    // consider the case of the constant node
    if ( Vec_IntSize(vSop0) == 0 || Vec_IntSize(vSop1) == 0 )
    {
        // (temporary) create a tautology cube
        pMvSop = ABC_ALLOC( char, nVars + 3 );
        for ( k = 0; k < nVars; k++ )
            pMvSop[k] = '-';
        pMvSop[nVars] = '0' + (int)(Vec_IntSize(vSop1) > 0);
        pMvSop[nVars+1] = '\n';
        pMvSop[nVars+2] = 0;
        return pMvSop;
    }
    // find the total number of cubes
    nCubes = Vec_IntSize(vSop0) + Vec_IntSize(vSop1);
    // find the size of the MVSOP represented as a C-string
    // (each cube has nVars variables + one output literal + end-of-line,
    // and the string is zero-terminated)
    nSize = nCubes * (nVars + 2) + 1; 
    // allocate memory
    pMvSop = pCur = ABC_ALLOC( char, nSize );
    // fill in the negative polarity cubes
    Vec_IntForEachEntry( vSop0, uCube, i )
    {
        for ( k = 0; k < nVars; k++ )
        {
            Value = (uCube >> (2*k)) & 3;
            if ( Value == 1 )
                *pCur++ = '0';
            else if ( Value == 2 )
                *pCur++ = '1';
            else if ( Value == 0 )
                *pCur++ = '-';
            else
                assert( 0 );
        }
        *pCur++ = '0';
        *pCur++ = '\n';
    }
    // fill in the positive polarity cubes
    Vec_IntForEachEntry( vSop1, uCube, i )
    {
        for ( k = 0; k < nVars; k++ )
        {
            Value = (uCube >> (2*k)) & 3;
            if ( Value == 1 )
                *pCur++ = '0';
            else if ( Value == 2 )
                *pCur++ = '1';
            else if ( Value == 0 )
                *pCur++ = '-';
            else
                assert( 0 );
        }
        *pCur++ = '1';
        *pCur++ = '\n';
    }
    *pCur++ = 0;
    assert( pCur - pMvSop == nSize );
    return pMvSop;
}

Here is the caller graph for this function:

◆ Abc_NodeDeref_rec()

ABC_DLL int Abc_NodeDeref_rec ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Dereferences the node's MFFC.]

Description []

SideEffects []

SeeAlso []

Definition at line 215 of file abcRefs.c.

{
    Abc_Obj_t * pFanin;
    int i, Counter = 1;
    if ( Abc_ObjIsCi(pNode) )
        return 0;
    Abc_ObjForEachFanin( pNode, pFanin, i )
    {
        assert( pFanin->vFanouts.nSize > 0 );
        if ( --pFanin->vFanouts.nSize == 0 )
            Counter += Abc_NodeDeref_rec( pFanin );
    }
    return Counter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeEvalMvCost()

ABC_DLL int Abc_NodeEvalMvCost	(	int	nVars,
		Vec_Int_t *	vSop0,
		Vec_Int_t *	vSop1 )

extern

Function*************************************************************

Synopsis [Evaluates the cost of the cut.]

Description [The Boolean function of the cut is specified by two SOPs, which represent the negative/positive polarities of the cut function. Converts these two SOPs into a mutually-agreed-upon representation to be passed to the internal cost-evaluation procedure (see the above prototype Abc_NodeEvalMvCostInternal).]

SideEffects []

SeeAlso []

Definition at line 1140 of file abcBlifMv.c.

{
    char * pMvSop;
    int * pVarValues;
    int i, RetValue;
    // collect the input and output values (currently, they are binary)
    pVarValues = ABC_ALLOC( int, nVars + 1 );
    for ( i = 0; i <= nVars; i++ )
        pVarValues[i] = 2;
    // prepare MV-SOP for evaluation
    pMvSop = Abc_NodeConvertSopToMvSop( nVars, vSop0, vSop1 );
    // have a look at the MV-SOP:
//    printf( "%s\n", pMvSop );
    // get the result of internal cost evaluation
    RetValue = Abc_NodeEvalMvCostInternal( nVars, pVarValues, pMvSop );
    // cleanup
    ABC_FREE( pVarValues );
    ABC_FREE( pMvSop );
    return RetValue;
}

Here is the call graph for this function:

◆ Abc_NodeFindCoFanout()

ABC_DLL Abc_Obj_t * Abc_NodeFindCoFanout ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Checks if the internal node has CO fanout.]

Description []

SideEffects []

SeeAlso []

Definition at line 812 of file abcUtil.c.

{
    Abc_Obj_t * pFanout;
    int i;
    Abc_ObjForEachFanout( pNode, pFanout, i )
        if ( Abc_ObjIsCo(pFanout) )
            return pFanout;
    return NULL;
}

Here is the caller graph for this function:

◆ Abc_NodeFindCut()

ABC_DLL Vec_Ptr_t * Abc_NodeFindCut	(	Abc_ManCut_t *	p,
		Abc_Obj_t *	pRoot,
		int	fContain )

extern

Function*************************************************************

Synopsis [Finds a fanin-limited, reconvergence-driven cut for the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 256 of file abcReconv.c.

{
    Abc_Obj_t * pNode;
    int i;
 
    assert( !Abc_ObjIsComplement(pRoot) );
    assert( Abc_ObjIsNode(pRoot) );
 
    // start the visited nodes and mark them
    Vec_PtrClear( p->vVisited );
    Vec_PtrPush( p->vVisited, pRoot );
    Vec_PtrPush( p->vVisited, Abc_ObjFanin0(pRoot) );
    Vec_PtrPush( p->vVisited, Abc_ObjFanin1(pRoot) );
    pRoot->fMarkB = 1;
    Abc_ObjFanin0(pRoot)->fMarkB = 1;
    Abc_ObjFanin1(pRoot)->fMarkB = 1;
 
    // start the cut 
    Vec_PtrClear( p->vNodeLeaves );
    Vec_PtrPush( p->vNodeLeaves, Abc_ObjFanin0(pRoot) );
    Vec_PtrPush( p->vNodeLeaves, Abc_ObjFanin1(pRoot) );
 
    // compute the cut
    while ( Abc_NodeBuildCutLevelOne_int( p->vVisited, p->vNodeLeaves, p->nNodeSizeMax, p->nNodeFanStop ) );
    assert( Vec_PtrSize(p->vNodeLeaves) <= p->nNodeSizeMax );
 
    // return if containing cut is not requested
    if ( !fContain )
    {
        // unmark both fMarkA and fMarkB in tbe TFI
        Abc_NodesUnmarkB( p->vVisited );
        return p->vNodeLeaves;
    }
 
//printf( "\n\n\n" );
    // compute the containing cut
    assert( p->nNodeSizeMax < p->nConeSizeMax );
    // copy the current boundary
    Vec_PtrClear( p->vConeLeaves );
    Vec_PtrForEachEntry( Abc_Obj_t *, p->vNodeLeaves, pNode, i )
        Vec_PtrPush( p->vConeLeaves, pNode );
    // compute the containing cut
    while ( Abc_NodeBuildCutLevelOne_int( p->vVisited, p->vConeLeaves, p->nConeSizeMax, p->nConeFanStop ) );
    assert( Vec_PtrSize(p->vConeLeaves) <= p->nConeSizeMax );
    // unmark TFI using fMarkA and fMarkB
    Abc_NodesUnmarkB( p->vVisited );
    return p->vNodeLeaves;
}

Here is the caller graph for this function:

◆ Abc_NodeFindFanin()

ABC_DLL int Abc_NodeFindFanin	(	Abc_Obj_t *	pNode,
		Abc_Obj_t *	pFanin )

extern

Function*************************************************************

Synopsis [Returns the index of the given fanin.]

Description []

SideEffects []

SeeAlso []

Definition at line 791 of file abcUtil.c.

{
    Abc_Obj_t * pThis;
    int i;
    Abc_ObjForEachFanin( pNode, pThis, i )
        if ( pThis == pFanin )
            return i;
    return -1;
}

Here is the caller graph for this function:

◆ Abc_NodeFindNonCoFanout()

ABC_DLL Abc_Obj_t * Abc_NodeFindNonCoFanout ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Checks if the internal node has CO fanout.]

Description []

SideEffects []

SeeAlso []

Definition at line 833 of file abcUtil.c.

{
    Abc_Obj_t * pFanout;
    int i;
    Abc_ObjForEachFanout( pNode, pFanout, i )
        if ( !Abc_ObjIsCo(pFanout) )
            return pFanout;
    return NULL;
}

◆ Abc_NodeFreeCuts()

ABC_DLL void Abc_NodeFreeCuts	(	void *	p,
		Abc_Obj_t *	pObj )

extern

Function*************************************************************

Synopsis [Computes the cuts for the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 527 of file abcCut.c.

{
    Cut_NodeFreeCuts( (Cut_Man_t *)p, pObj->Id );
}

Here is the call graph for this function:

◆ Abc_NodeFreeNames()

ABC_DLL void Abc_NodeFreeNames ( Vec_Ptr_t * vNames )

extern

Function*************************************************************

Synopsis [Gets fanin node names.]

Description []

SideEffects []

SeeAlso []

Definition at line 264 of file abcNames.c.

{
    int i;
    if ( vNames == NULL )
        return;
    for ( i = 0; i < vNames->nSize; i++ )
        ABC_FREE( vNames->pArray[i] );
    Vec_PtrFree( vNames );
}

Here is the caller graph for this function:

◆ Abc_NodeGetCuts()

ABC_DLL void * Abc_NodeGetCuts	(	void *	p,
		Abc_Obj_t *	pObj,
		int	fDag,
		int	fTree )

extern

Function*************************************************************

Synopsis [Computes the cuts for the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 433 of file abcCut.c.

{
    Abc_Obj_t * pFanin;
    int fDagNode, fTriv, TreeCode = 0;
//    assert( Abc_NtkIsStrash(pObj->pNtk) );
    assert( Abc_ObjFaninNum(pObj) == 2 );
 
    // check if the node is a DAG node
    fDagNode = (Abc_ObjFanoutNum(pObj) > 1 && !Abc_NodeIsMuxControlType(pObj));
    // increment the counter of DAG nodes
    if ( fDagNode ) Cut_ManIncrementDagNodes( (Cut_Man_t *)p );
    // add the trivial cut if the node is a DAG node, or if we compute all cuts
    fTriv = fDagNode || !fDag;
    // check if fanins are DAG nodes
    if ( fTree )
    {
        pFanin = Abc_ObjFanin0(pObj);
        TreeCode |=  (Abc_ObjFanoutNum(pFanin) > 1 && !Abc_NodeIsMuxControlType(pFanin));
        pFanin = Abc_ObjFanin1(pObj);
        TreeCode |= ((Abc_ObjFanoutNum(pFanin) > 1 && !Abc_NodeIsMuxControlType(pFanin)) << 1);
    }
 
    // changes due to the global/local cut computation
    {
        Cut_Params_t * pParams = Cut_ManReadParams((Cut_Man_t *)p);
        if ( pParams->fLocal )
        {
            Vec_Int_t * vNodeAttrs = Cut_ManReadNodeAttrs((Cut_Man_t *)p);
            fDagNode = Vec_IntEntry( vNodeAttrs, pObj->Id );
            if ( fDagNode ) Cut_ManIncrementDagNodes( (Cut_Man_t *)p );
//            fTriv = fDagNode || !pParams->fGlobal;
            fTriv = !Vec_IntEntry( vNodeAttrs, pObj->Id );
            TreeCode = 0;
            pFanin = Abc_ObjFanin0(pObj);
            TreeCode |=  Vec_IntEntry( vNodeAttrs, pFanin->Id );
            pFanin = Abc_ObjFanin1(pObj);
            TreeCode |= (Vec_IntEntry( vNodeAttrs, pFanin->Id ) << 1);
        }
    }
    return Cut_NodeComputeCuts( (Cut_Man_t *)p, pObj->Id, Abc_ObjFaninId0(pObj), Abc_ObjFaninId1(pObj),  
        Abc_ObjFaninC0(pObj), Abc_ObjFaninC1(pObj), fTriv, TreeCode );  
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeGetCutsRecursive()

ABC_DLL void * Abc_NodeGetCutsRecursive	(	void *	p,
		Abc_Obj_t *	pObj,
		int	fDag,
		int	fTree )

extern

Function*************************************************************

Synopsis [Computes the cuts for the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 412 of file abcCut.c.

{
    void * pList;
    if ( (pList = Abc_NodeReadCuts( p, pObj )) )
        return pList;
    Abc_NodeGetCutsRecursive( p, Abc_ObjFanin0(pObj), fDag, fTree );
    Abc_NodeGetCutsRecursive( p, Abc_ObjFanin1(pObj), fDag, fTree );
    return Abc_NodeGetCuts( p, pObj, fDag, fTree );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeGetCutsSeq()

ABC_DLL void Abc_NodeGetCutsSeq	(	void *	p,
		Abc_Obj_t *	pObj,
		int	fTriv )

extern

Function*************************************************************

Synopsis [Computes the cuts for the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 487 of file abcCut.c.

{
/*
    int CutSetNum;
    assert( Abc_NtkIsSeq(pObj->pNtk) );
    assert( Abc_ObjFaninNum(pObj) == 2 );
    fTriv     = pObj->fMarkC ? 0 : fTriv;
    CutSetNum = pObj->fMarkC ? (int)pObj->pCopy : -1;
    Cut_NodeComputeCutsSeq( p, pObj->Id, Abc_ObjFaninId0(pObj), Abc_ObjFaninId1(pObj),  
        Abc_ObjFaninC0(pObj), Abc_ObjFaninC1(pObj), Seq_ObjFaninL0(pObj), Seq_ObjFaninL1(pObj), fTriv, CutSetNum );  
*/
}

Here is the call graph for this function:

◆ Abc_NodeGetFakeNames()

ABC_DLL Vec_Ptr_t * Abc_NodeGetFakeNames ( int nNames )

extern

Function*************************************************************

Synopsis [Gets fanin node names.]

Description []

SideEffects []

SeeAlso []

Definition at line 228 of file abcNames.c.

{
    Vec_Ptr_t * vNames;
    char Buffer[5];
    int i;
 
    vNames = Vec_PtrAlloc( nNames );
    for ( i = 0; i < nNames; i++ )
    {
        if ( nNames < 26 )
        {
            Buffer[0] = 'a' + i;
            Buffer[1] = 0;
        }
        else
        {
            Buffer[0] = 'a' + i%26;
            Buffer[1] = '0' + i/26;
            Buffer[2] = 0;
        }
        Vec_PtrPush( vNames, Extra_UtilStrsav(Buffer) );
    }
    return vNames;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeGetFaninNames()

ABC_DLL Vec_Ptr_t * Abc_NodeGetFaninNames ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Gets fanin node names.]

Description []

SideEffects []

SeeAlso []

Definition at line 206 of file abcNames.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pFanin;
    int i;
    vNodes = Vec_PtrAlloc( 100 );
    Abc_ObjForEachFanin( pNode, pFanin, i )
        Vec_PtrPush( vNodes, Abc_UtilStrsav(Abc_ObjName(pFanin)) );
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeHasUniqueCoFanout()

ABC_DLL Abc_Obj_t * Abc_NodeHasUniqueCoFanout ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Checks if the internal node has CO drivers with the same name.]

Description [Checks if the internal node can borrow its name from CO fanouts. This is possible if all COs with non-complemented fanin edge pointing to this node have the same name.]

SideEffects []

SeeAlso []

Definition at line 856 of file abcUtil.c.

{
    Abc_Obj_t * pFanout, * pFanoutCo;
    int i;
    pFanoutCo = NULL;
    Abc_ObjForEachFanout( pNode, pFanout, i )
    {
        if ( !Abc_ObjIsCo(pFanout) )
            continue;
        if ( Abc_ObjFaninC0(pFanout) )
            continue;
        if ( pFanoutCo == NULL )
        {
            assert( Abc_ObjFaninNum(pFanout) == 1 );
            assert( Abc_ObjFanin0(pFanout) == pNode );
            pFanoutCo = pFanout;
            continue;
        }
        if ( strcmp( Abc_ObjName(pFanoutCo), Abc_ObjName(pFanout) ) ) // they have diff names
            return NULL;
    }
    return pFanoutCo;
}

Here is the call graph for this function:

◆ Abc_NodeIsBuf()

ABC_DLL int Abc_NodeIsBuf ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns 1 if the node is a buffer.]

Description []

SideEffects []

SeeAlso []

Definition at line 948 of file abcObj.c.

{ 
    Abc_Ntk_t * pNtk = pNode->pNtk;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
    assert( Abc_ObjIsNode(pNode) ); 
    if ( Abc_ObjFaninNum(pNode) != 1 )
        return 0;
    if ( Abc_NtkHasSop(pNtk) )
        return Abc_SopIsBuf((char *)pNode->pData);
#ifdef ABC_USE_CUDD
    if ( Abc_NtkHasBdd(pNtk) )
        return !Cudd_IsComplement(pNode->pData);
#endif
    if ( Abc_NtkHasAig(pNtk) )
        return !Hop_IsComplement((Hop_Obj_t *)pNode->pData);
    if ( Abc_NtkHasMapping(pNtk) )
        return pNode->pData == Mio_LibraryReadBuf((Mio_Library_t *)Abc_FrameReadLibGen());
    assert( 0 );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeIsConst()

ABC_DLL int Abc_NodeIsConst ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns 1 if the node is a constant 0 node.]

Description []

SideEffects []

SeeAlso []

Definition at line 867 of file abcObj.c.

{ 
    assert( Abc_NtkIsLogic(pNode->pNtk) || Abc_NtkIsNetlist(pNode->pNtk) );
    return Abc_ObjIsNode(pNode) && Abc_ObjFaninNum(pNode) == 0;
}

Here is the caller graph for this function:

◆ Abc_NodeIsConst0()

ABC_DLL int Abc_NodeIsConst0 ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns 1 if the node is a constant 0 node.]

Description []

SideEffects []

SeeAlso []

Definition at line 884 of file abcObj.c.

{ 
    Abc_Ntk_t * pNtk = pNode->pNtk;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
    assert( Abc_ObjIsNode(pNode) );      
    if ( !Abc_NodeIsConst(pNode) )
        return 0;
    if ( Abc_NtkHasSop(pNtk) )
        return Abc_SopIsConst0((char *)pNode->pData);
#ifdef ABC_USE_CUDD
    if ( Abc_NtkHasBdd(pNtk) )
        return Cudd_IsComplement(pNode->pData);
#endif
    if ( Abc_NtkHasAig(pNtk) )
        return Hop_IsComplement((Hop_Obj_t *)pNode->pData)? 1:0;
    if ( Abc_NtkHasMapping(pNtk) )
        return pNode->pData == Mio_LibraryReadConst0((Mio_Library_t *)Abc_FrameReadLibGen());
    assert( 0 );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeIsConst1()

ABC_DLL int Abc_NodeIsConst1 ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns 1 if the node is a constant 1 node.]

Description []

SideEffects []

SeeAlso []

Definition at line 916 of file abcObj.c.

{ 
    Abc_Ntk_t * pNtk = pNode->pNtk;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
    assert( Abc_ObjIsNode(pNode) );      
    if ( !Abc_NodeIsConst(pNode) )
        return 0;
    if ( Abc_NtkHasSop(pNtk) )
        return Abc_SopIsConst1((char *)pNode->pData);
#ifdef ABC_USE_CUDD
    if ( Abc_NtkHasBdd(pNtk) )
        return !Cudd_IsComplement(pNode->pData);
#endif
    if ( Abc_NtkHasAig(pNtk) )
        return !Hop_IsComplement((Hop_Obj_t *)pNode->pData);
    if ( Abc_NtkHasMapping(pNtk) )
        return pNode->pData == Mio_LibraryReadConst1((Mio_Library_t *)Abc_FrameReadLibGen());
    assert( 0 );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeIsExorType()

ABC_DLL int Abc_NodeIsExorType ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns 1 if the node is the root of EXOR/NEXOR.]

Description []

SideEffects []

SeeAlso []

Definition at line 1300 of file abcUtil.c.

{
    Abc_Obj_t * pNode0, * pNode1;
    // check that the node is regular
    assert( !Abc_ObjIsComplement(pNode) );
    // if the node is not AND, this is not EXOR
    if ( !Abc_AigNodeIsAnd(pNode) )
        return 0;
    // if the children are not complemented, this is not EXOR
    if ( !Abc_ObjFaninC0(pNode) || !Abc_ObjFaninC1(pNode) )
        return 0;
    // get children
    pNode0 = Abc_ObjFanin0(pNode);
    pNode1 = Abc_ObjFanin1(pNode);
    // if the children are not ANDs, this is not EXOR
    if ( Abc_ObjFaninNum(pNode0) != 2 || Abc_ObjFaninNum(pNode1) != 2 )
        return 0;
    // this is AIG, which means the fanins should be ordered
    assert( Abc_ObjFaninId0(pNode0) != Abc_ObjFaninId1(pNode1) || 
            Abc_ObjFaninId0(pNode1) != Abc_ObjFaninId1(pNode0) );
    // if grand children are not the same, this is not EXOR
    if ( Abc_ObjFaninId0(pNode0) != Abc_ObjFaninId0(pNode1) ||
         Abc_ObjFaninId1(pNode0) != Abc_ObjFaninId1(pNode1) )
         return 0;
    // finally, if the complemented edges are matched, this is not EXOR
    if ( Abc_ObjFaninC0(pNode0) == Abc_ObjFaninC0(pNode1) || 
         Abc_ObjFaninC1(pNode0) == Abc_ObjFaninC1(pNode1) )
         return 0;
    return 1;
}

Here is the caller graph for this function:

◆ Abc_NodeIsInv()

ABC_DLL int Abc_NodeIsInv ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns 1 if the node is an inverter.]

Description []

SideEffects []

SeeAlso []

Definition at line 980 of file abcObj.c.

{ 
    Abc_Ntk_t * pNtk = pNode->pNtk;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
    assert( Abc_ObjIsNode(pNode) ); 
    if ( Abc_ObjFaninNum(pNode) != 1 )
        return 0;
    if ( Abc_NtkHasSop(pNtk) )
        return Abc_SopIsInv((char *)pNode->pData);
#ifdef ABC_USE_CUDD
    if ( Abc_NtkHasBdd(pNtk) )
        return Cudd_IsComplement(pNode->pData);
#endif
    if ( Abc_NtkHasAig(pNtk) )
        return Hop_IsComplement((Hop_Obj_t *)pNode->pData)? 1:0;
    if ( Abc_NtkHasMapping(pNtk) )
        return pNode->pData == Mio_LibraryReadInv((Mio_Library_t *)Abc_FrameReadLibGen());
    assert( 0 );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeIsMuxControlType()

ABC_DLL int Abc_NodeIsMuxControlType ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns 1 if the node is the control type of the MUX.]

Description []

SideEffects []

SeeAlso []

Definition at line 1398 of file abcUtil.c.

{
    Abc_Obj_t * pNode0, * pNode1;
    // check that the node is regular
    assert( !Abc_ObjIsComplement(pNode) );
    // skip the node that do not have two fanouts
    if ( Abc_ObjFanoutNum(pNode) != 2 )
        return 0;
    // get the fanouts
    pNode0 = Abc_ObjFanout( pNode, 0 );
    pNode1 = Abc_ObjFanout( pNode, 1 );
    // if they have more than one fanout, we are not interested
    if ( Abc_ObjFanoutNum(pNode0) != 1 ||  Abc_ObjFanoutNum(pNode1) != 1 )
        return 0;
    // if the fanouts have the same fanout, this is MUX or EXOR (or a redundant gate (CA)(CB))
    return Abc_ObjFanout0(pNode0) == Abc_ObjFanout0(pNode1);
}

Here is the caller graph for this function:

◆ Abc_NodeIsMuxType()

ABC_DLL int Abc_NodeIsMuxType ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns 1 if the node is the root of MUX or EXOR/NEXOR.]

Description []

SideEffects []

SeeAlso []

Definition at line 1342 of file abcUtil.c.

{
    Abc_Obj_t * pNode0, * pNode1;
    // check that the node is regular
    assert( !Abc_ObjIsComplement(pNode) );
    // if the node is not AND, this is not MUX
    if ( !Abc_AigNodeIsAnd(pNode) )
        return 0;
    // if the children are not complemented, this is not MUX
    if ( !Abc_ObjFaninC0(pNode) || !Abc_ObjFaninC1(pNode) )
        return 0;
    // get children
    pNode0 = Abc_ObjFanin0(pNode);
    pNode1 = Abc_ObjFanin1(pNode);
    // if the children are not ANDs, this is not MUX
    if ( !Abc_AigNodeIsAnd(pNode0) || !Abc_AigNodeIsAnd(pNode1) )
        return 0;
    // otherwise the node is MUX iff it has a pair of equal grandchildren with opposite polarity
    return (Abc_ObjFaninId0(pNode0) == Abc_ObjFaninId0(pNode1) && (Abc_ObjFaninC0(pNode0) ^ Abc_ObjFaninC0(pNode1))) || 
           (Abc_ObjFaninId0(pNode0) == Abc_ObjFaninId1(pNode1) && (Abc_ObjFaninC0(pNode0) ^ Abc_ObjFaninC1(pNode1))) ||
           (Abc_ObjFaninId1(pNode0) == Abc_ObjFaninId0(pNode1) && (Abc_ObjFaninC1(pNode0) ^ Abc_ObjFaninC0(pNode1))) ||
           (Abc_ObjFaninId1(pNode0) == Abc_ObjFaninId1(pNode1) && (Abc_ObjFaninC1(pNode0) ^ Abc_ObjFaninC1(pNode1)));
}

Here is the caller graph for this function:

◆ Abc_NodeMffcConeSupp()

ABC_DLL void Abc_NodeMffcConeSupp	(	Abc_Obj_t *	pNode,
		Vec_Ptr_t *	vCone,
		Vec_Ptr_t *	vSupp )

extern

Function*************************************************************

Synopsis [Collects the support of the derefed MFFC.]

Description []

SideEffects []

SeeAlso []

Definition at line 299 of file abcRefs.c.

{
    assert( Abc_ObjIsNode(pNode) );
    assert( !Abc_ObjIsComplement(pNode) );
    if ( vCone ) Vec_PtrClear( vCone );
    if ( vSupp ) Vec_PtrClear( vSupp );
    Abc_NtkIncrementTravId( pNode->pNtk );
    Abc_NodeMffcConeSupp_rec( pNode, vCone, vSupp, 1 );
//    printf( "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeMffcLabel()

ABC_DLL int Abc_NodeMffcLabel	(	Abc_Obj_t *	pNode,
		Vec_Ptr_t *	vNodes )

extern

Function*************************************************************

Synopsis [Collects the internal nodes of the MFFC limited by cut.]

Description []

SideEffects [Increments the trav ID and marks visited nodes.]

SeeAlso []

Definition at line 439 of file abcRefs.c.

{
    int Count1, Count2;
    // dereference the node
    Count1 = Abc_NodeDeref_rec( pNode );
    // collect the nodes inside the MFFC
    Abc_NtkIncrementTravId( pNode->pNtk );
    Abc_NodeMffcLabel_rec( pNode, 1, vNodes );
    // reference it back
    Count2 = Abc_NodeRef_rec( pNode );
    assert( Count1 == Count2 );
    return Count1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeMffcLabelAig()

ABC_DLL int Abc_NodeMffcLabelAig ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Labels MFFC with the current traversal ID.]

Description []

SideEffects []

SeeAlso []

Definition at line 100 of file abcRefs.c.

{
    int nConeSize1, nConeSize2;
    assert( Abc_NtkIsStrash(pNode->pNtk) );
    assert( !Abc_ObjIsComplement( pNode ) );
    assert( Abc_ObjIsNode( pNode ) );
    if ( Abc_ObjFaninNum(pNode) == 0 )
        return 0;
    nConeSize1 = Abc_NodeRefDeref( pNode, 0, 1 ); // dereference
    nConeSize2 = Abc_NodeRefDeref( pNode, 1, 0 ); // reference
    assert( nConeSize1 == nConeSize2 );
    assert( nConeSize1 > 0 );
    return nConeSize1;
}

Here is the caller graph for this function:

◆ Abc_NodeMffcSize()

ABC_DLL int Abc_NodeMffcSize ( Abc_Obj_t * pNode )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Returns the MFFC size.]

Description []

SideEffects []

SeeAlso []

Definition at line 48 of file abcRefs.c.

{
    int nConeSize1, nConeSize2;
//    assert( Abc_NtkIsStrash(pNode->pNtk) );
//    assert( !Abc_ObjIsComplement( pNode ) );
    assert( Abc_ObjIsNode( pNode ) );
    if ( Abc_ObjFaninNum(pNode) == 0 )
        return 0;
    nConeSize1 = Abc_NodeRefDeref( pNode, 0, 0 ); // dereference
    nConeSize2 = Abc_NodeRefDeref( pNode, 1, 0 ); // reference
    assert( nConeSize1 == nConeSize2 );
    assert( nConeSize1 > 0 );
    return nConeSize1;
}

Here is the caller graph for this function:

◆ Abc_NodeMffcSizeStop()

ABC_DLL int Abc_NodeMffcSizeStop ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns the MFFC size while stopping at the complemented edges.]

Description []

SideEffects []

SeeAlso []

Definition at line 74 of file abcRefs.c.

{
    int nConeSize1, nConeSize2;
    assert( Abc_NtkIsStrash(pNode->pNtk) );
    assert( !Abc_ObjIsComplement( pNode ) );
    assert( Abc_ObjIsNode( pNode ) );
    if ( Abc_ObjFaninNum(pNode) == 0 )
        return 0;
    nConeSize1 = Abc_NodeRefDerefStop( pNode, 0 ); // dereference
    nConeSize2 = Abc_NodeRefDerefStop( pNode, 1 ); // reference
    assert( nConeSize1 == nConeSize2 );
    assert( nConeSize1 > 0 );
    return nConeSize1;
}

◆ Abc_NodeMffcSizeSupp()

ABC_DLL int Abc_NodeMffcSizeSupp ( Abc_Obj_t * pNode )

extern

◆ Abc_NodeMinimumBase()

ABC_DLL int Abc_NodeMinimumBase ( Abc_Obj_t * pNode )

extern

Definition at line 893 of file abcMinBase.c.

893{ return 0; }

◆ Abc_NodePrintFactor()

ABC_DLL void Abc_NodePrintFactor	(	FILE *	pFile,
		Abc_Obj_t *	pNode,
		int	fUseRealNames )

extern

Function*************************************************************

Synopsis [Prints the factored form of one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1101 of file abcPrint.c.

{
    Dec_Graph_t * pGraph;
    Vec_Ptr_t * vNamesIn;
    if ( Abc_ObjIsCo(pNode) )
        pNode = Abc_ObjFanin0(pNode);
    if ( Abc_ObjIsPi(pNode) )
    {
        fprintf( pFile, "Skipping the PI node.\n" );
        return;
    }
    if ( Abc_ObjIsLatch(pNode) )
    {
        fprintf( pFile, "Skipping the latch.\n" );
        return;
    }
    assert( Abc_ObjIsNode(pNode) );
    pGraph = Dec_Factor( (char *)pNode->pData );
    if ( fUseRealNames )
    {
        vNamesIn = Abc_NodeGetFaninNames(pNode);
        Dec_GraphPrint( stdout, pGraph, (char **)vNamesIn->pArray, Abc_ObjName(pNode) );
        Abc_NodeFreeNames( vNamesIn );
    }
    else
        Dec_GraphPrint( stdout, pGraph, (char **)NULL, Abc_ObjName(pNode) );
    Dec_GraphFree( pGraph );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodePrintFanio()

ABC_DLL void Abc_NodePrintFanio	(	FILE *	pFile,
		Abc_Obj_t *	pNode )

extern

Function*************************************************************

Synopsis [Prints the fanins/fanouts of a node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1048 of file abcPrint.c.

{
    Abc_Obj_t * pNode2;
    int i;
    if ( Abc_ObjIsPo(pNode) )
        pNode = Abc_ObjFanin0(pNode);
 
    fprintf( pFile, "Node %s", Abc_ObjName(pNode) );
    fprintf( pFile, "\n" );
 
    fprintf( pFile, "Fanins (%d): ", Abc_ObjFaninNum(pNode) );
    Abc_ObjForEachFanin( pNode, pNode2, i )
        fprintf( pFile, " %s", Abc_ObjName(pNode2) );
    fprintf( pFile, "\n" );
 
    fprintf( pFile, "Fanouts (%d): ", Abc_ObjFaninNum(pNode) );
    Abc_ObjForEachFanout( pNode, pNode2, i )
        fprintf( pFile, " %s", Abc_ObjName(pNode2) );
    fprintf( pFile, "\n" );
}

Here is the call graph for this function:

◆ Abc_NodePrintLevel()

ABC_DLL void Abc_NodePrintLevel	(	FILE *	pFile,
		Abc_Obj_t *	pNode )

extern

Function*************************************************************

Synopsis [Prints the factored form of one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1358 of file abcPrint.c.

{
    Abc_Obj_t * pDriver;
    Vec_Ptr_t * vNodes;
 
    pDriver = Abc_ObjIsCo(pNode)? Abc_ObjFanin0(pNode) : pNode;
    if ( Abc_ObjIsPi(pDriver) )
    {
        fprintf( pFile, "Primary input.\n" );
        return;
    }
    if ( Abc_ObjIsLatch(pDriver) )
    {
        fprintf( pFile, "Latch.\n" );
        return;
    }
    if ( Abc_NodeIsConst(pDriver) )
    {
        fprintf( pFile, "Constant %d.\n", !Abc_ObjFaninC0(pNode) );
        return;
    }
    // print the level
    fprintf( pFile, "Level = %3d.  ", pDriver->Level );
    // print the size of MFFC
    fprintf( pFile, "Mffc = %5d.  ", Abc_NodeMffcSize(pDriver) );
    // print the size of the shole cone
    vNodes = Abc_NtkDfsNodes( pNode->pNtk, &pDriver, 1 );
    fprintf( pFile, "Cone = %5d.  ", Vec_PtrSize(vNodes) );
    Vec_PtrFree( vNodes );
    fprintf( pFile, "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeReadArrival()

ABC_DLL Abc_Time_t * Abc_NodeReadArrival ( Abc_Obj_t * pNode )

extern

Definition at line 85 of file abcTiming.c.

{
    assert( pNode->pNtk->pManTime );
    return Abc_NodeArrival(pNode);
}

Here is the caller graph for this function:

◆ Abc_NodeReadArrivalAve()

ABC_DLL float Abc_NodeReadArrivalAve ( Abc_Obj_t * pNode )

extern

Definition at line 103 of file abcTiming.c.

{
    return 0.5 * Abc_NodeArrival(pNode)->Rise + 0.5 * Abc_NodeArrival(pNode)->Fall;
}

◆ Abc_NodeReadArrivalWorst()

ABC_DLL float Abc_NodeReadArrivalWorst ( Abc_Obj_t * pNode )

extern

Definition at line 111 of file abcTiming.c.

{
    return Abc_MaxFloat( Abc_NodeArrival(pNode)->Rise, Abc_NodeArrival(pNode)->Fall );
}

Here is the caller graph for this function:

◆ Abc_NodeReadCuts()

ABC_DLL void * Abc_NodeReadCuts	(	void *	p,
		Abc_Obj_t *	pObj )

extern

Function*************************************************************

Synopsis [Computes the cuts for the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 511 of file abcCut.c.

{
    return Cut_NodeReadCutsNew( (Cut_Man_t *)p, pObj->Id );  
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeReadInputDrive()

ABC_DLL Abc_Time_t * Abc_NodeReadInputDrive	(	Abc_Ntk_t *	pNtk,
		int	iPi )

extern

Definition at line 141 of file abcTiming.c.

{
    assert( pNtk->pManTime );
    return pNtk->pManTime->tInDrive ? pNtk->pManTime->tInDrive + iPi : NULL;
}

Here is the caller graph for this function:

◆ Abc_NodeReadInputDriveWorst()

ABC_DLL float Abc_NodeReadInputDriveWorst	(	Abc_Ntk_t *	pNtk,
		int	iPi )

extern

Definition at line 151 of file abcTiming.c.

{
    return Abc_MaxFloat( Abc_NodeReadInputDrive(pNtk, iPi)->Rise, Abc_NodeReadInputDrive(pNtk, iPi)->Fall );
}

Here is the call graph for this function:

◆ Abc_NodeReadOutputLoad()

ABC_DLL Abc_Time_t * Abc_NodeReadOutputLoad	(	Abc_Ntk_t *	pNtk,
		int	iPo )

extern

Definition at line 146 of file abcTiming.c.

{
    assert( pNtk->pManTime );
    return pNtk->pManTime->tOutLoad ? pNtk->pManTime->tOutLoad + iPo : NULL;
}

Here is the caller graph for this function:

◆ Abc_NodeReadOutputLoadWorst()

ABC_DLL float Abc_NodeReadOutputLoadWorst	(	Abc_Ntk_t *	pNtk,
		int	iPo )

extern

Definition at line 155 of file abcTiming.c.

{
    return Abc_MaxFloat( Abc_NodeReadOutputLoad(pNtk, iPo)->Rise, Abc_NodeReadOutputLoad(pNtk, iPo)->Fall );
}

Here is the call graph for this function:

◆ Abc_NodeReadRequired()

ABC_DLL Abc_Time_t * Abc_NodeReadRequired ( Abc_Obj_t * pNode )

extern

Definition at line 90 of file abcTiming.c.

{
    assert( pNode->pNtk->pManTime );
    return Abc_NodeRequired(pNode);
}

Here is the caller graph for this function:

◆ Abc_NodeReadRequiredAve()

ABC_DLL float Abc_NodeReadRequiredAve ( Abc_Obj_t * pNode )

extern

Definition at line 107 of file abcTiming.c.

{
    return 0.5 * Abc_NodeReadRequired(pNode)->Rise + 0.5 * Abc_NodeReadRequired(pNode)->Fall;
}

Here is the call graph for this function:

◆ Abc_NodeReadRequiredWorst()

ABC_DLL float Abc_NodeReadRequiredWorst ( Abc_Obj_t * pNode )

extern

Definition at line 115 of file abcTiming.c.

{
    return Abc_MinFloat( Abc_NodeReadRequired(pNode)->Rise, Abc_NodeReadRequired(pNode)->Fall );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeRecognizeMux()

ABC_DLL Abc_Obj_t * Abc_NodeRecognizeMux	(	Abc_Obj_t *	pNode,
		Abc_Obj_t **	ppNodeT,
		Abc_Obj_t **	ppNodeE )

extern

Function*************************************************************

Synopsis [Recognizes what nodes are control and data inputs of a MUX.]

Description [If the node is a MUX, returns the control variable C. Assigns nodes T and E to be the then and else variables of the MUX. Node C is never complemented. Nodes T and E can be complemented. This function also recognizes EXOR/NEXOR gates as MUXes.]

SideEffects []

SeeAlso []

Definition at line 1430 of file abcUtil.c.

{
    Abc_Obj_t * pNode0, * pNode1;
    assert( !Abc_ObjIsComplement(pNode) );
    assert( Abc_NodeIsMuxType(pNode) );
    // get children
    pNode0 = Abc_ObjFanin0(pNode);
    pNode1 = Abc_ObjFanin1(pNode);
    // find the control variable
//    if ( pNode1->p1 == Fraig_Not(pNode2->p1) )
    if ( Abc_ObjFaninId0(pNode0) == Abc_ObjFaninId0(pNode1) && (Abc_ObjFaninC0(pNode0) ^ Abc_ObjFaninC0(pNode1)) )
    {
//        if ( Fraig_IsComplement(pNode1->p1) )
        if ( Abc_ObjFaninC0(pNode0) )
        { // pNode2->p1 is positive phase of C
            *ppNodeT = Abc_ObjNot(Abc_ObjChild1(pNode1));//pNode2->p2);
            *ppNodeE = Abc_ObjNot(Abc_ObjChild1(pNode0));//pNode1->p2);
            return Abc_ObjChild0(pNode1);//pNode2->p1;
        }
        else
        { // pNode1->p1 is positive phase of C
            *ppNodeT = Abc_ObjNot(Abc_ObjChild1(pNode0));//pNode1->p2);
            *ppNodeE = Abc_ObjNot(Abc_ObjChild1(pNode1));//pNode2->p2);
            return Abc_ObjChild0(pNode0);//pNode1->p1;
        }
    }
//    else if ( pNode1->p1 == Fraig_Not(pNode2->p2) )
    else if ( Abc_ObjFaninId0(pNode0) == Abc_ObjFaninId1(pNode1) && (Abc_ObjFaninC0(pNode0) ^ Abc_ObjFaninC1(pNode1)) )
    {
//        if ( Fraig_IsComplement(pNode1->p1) )
        if ( Abc_ObjFaninC0(pNode0) )
        { // pNode2->p2 is positive phase of C
            *ppNodeT = Abc_ObjNot(Abc_ObjChild0(pNode1));//pNode2->p1);
            *ppNodeE = Abc_ObjNot(Abc_ObjChild1(pNode0));//pNode1->p2);
            return Abc_ObjChild1(pNode1);//pNode2->p2;
        }
        else
        { // pNode1->p1 is positive phase of C
            *ppNodeT = Abc_ObjNot(Abc_ObjChild1(pNode0));//pNode1->p2);
            *ppNodeE = Abc_ObjNot(Abc_ObjChild0(pNode1));//pNode2->p1);
            return Abc_ObjChild0(pNode0);//pNode1->p1;
        }
    }
//    else if ( pNode1->p2 == Fraig_Not(pNode2->p1) )
    else if ( Abc_ObjFaninId1(pNode0) == Abc_ObjFaninId0(pNode1) && (Abc_ObjFaninC1(pNode0) ^ Abc_ObjFaninC0(pNode1)) )
    {
//        if ( Fraig_IsComplement(pNode1->p2) )
        if ( Abc_ObjFaninC1(pNode0) )
        { // pNode2->p1 is positive phase of C
            *ppNodeT = Abc_ObjNot(Abc_ObjChild1(pNode1));//pNode2->p2);
            *ppNodeE = Abc_ObjNot(Abc_ObjChild0(pNode0));//pNode1->p1);
            return Abc_ObjChild0(pNode1);//pNode2->p1;
        }
        else
        { // pNode1->p2 is positive phase of C
            *ppNodeT = Abc_ObjNot(Abc_ObjChild0(pNode0));//pNode1->p1);
            *ppNodeE = Abc_ObjNot(Abc_ObjChild1(pNode1));//pNode2->p2);
            return Abc_ObjChild1(pNode0);//pNode1->p2;
        }
    }
//    else if ( pNode1->p2 == Fraig_Not(pNode2->p2) )
    else if ( Abc_ObjFaninId1(pNode0) == Abc_ObjFaninId1(pNode1) && (Abc_ObjFaninC1(pNode0) ^ Abc_ObjFaninC1(pNode1)) )
    {
//        if ( Fraig_IsComplement(pNode1->p2) )
        if ( Abc_ObjFaninC1(pNode0) )
        { // pNode2->p2 is positive phase of C
            *ppNodeT = Abc_ObjNot(Abc_ObjChild0(pNode1));//pNode2->p1);
            *ppNodeE = Abc_ObjNot(Abc_ObjChild0(pNode0));//pNode1->p1);
            return Abc_ObjChild1(pNode1);//pNode2->p2;
        }
        else
        { // pNode1->p2 is positive phase of C
            *ppNodeT = Abc_ObjNot(Abc_ObjChild0(pNode0));//pNode1->p1);
            *ppNodeE = Abc_ObjNot(Abc_ObjChild0(pNode1));//pNode2->p1);
            return Abc_ObjChild1(pNode0);//pNode1->p2;
        }
    }
    assert( 0 ); // this is not MUX
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeRef_rec()

ABC_DLL int Abc_NodeRef_rec ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [References the node's MFFC.]

Description []

SideEffects []

SeeAlso []

Definition at line 241 of file abcRefs.c.

{
    Abc_Obj_t * pFanin;
    int i, Counter = 1;
    if ( Abc_ObjIsCi(pNode) )
        return 0;
    Abc_ObjForEachFanin( pNode, pFanin, i )
    {
        if ( pFanin->vFanouts.nSize++ == 0 )
            Counter += Abc_NodeRef_rec( pFanin );
    }
    return Counter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NodeRemoveDupFanins()

ABC_DLL int Abc_NodeRemoveDupFanins ( Abc_Obj_t * pNode )

extern

◆ Abc_NodeStrash()

ABC_DLL Abc_Obj_t * Abc_NodeStrash	(	Abc_Ntk_t *	pNtkNew,
		Abc_Obj_t *	pNodeOld,
		int	fRecord )

extern

Function*************************************************************

Synopsis [Strashes one logic node.]

Description [Assume the network is in the AIG form]

SideEffects []

SeeAlso []

Definition at line 468 of file abcStrash.c.

{
    Hop_Man_t * pMan;
    Hop_Obj_t * pRoot;
    Abc_Obj_t * pFanin;
    int i;
    assert( Abc_ObjIsNode(pNodeOld) );
    assert( Abc_NtkHasAig(pNodeOld->pNtk) && !Abc_NtkIsStrash(pNodeOld->pNtk) );
    // get the local AIG manager and the local root node
    pMan = (Hop_Man_t *)pNodeOld->pNtk->pManFunc;
    pRoot = (Hop_Obj_t *)pNodeOld->pData;
    // check the constant case
    if ( Abc_NodeIsConst(pNodeOld) || Hop_Regular(pRoot) == Hop_ManConst1(pMan) )
        return Abc_ObjNotCond( Abc_AigConst1(pNtkNew), Hop_IsComplement(pRoot) );
    // perform special case-strashing using the record of AIG subgraphs
/*
    if ( fRecord && Abc_NtkRecIsRunning() && Abc_ObjFaninNum(pNodeOld) > 2 && Abc_ObjFaninNum(pNodeOld) <= Abc_NtkRecVarNum() )
    {
        extern Vec_Int_t * Abc_NtkRecMemory();
        extern int Abc_NtkRecStrashNode( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pObj, unsigned * pTruth, int nVars );
        int nVars = Abc_NtkRecVarNum();
        Vec_Int_t * vMemory = Abc_NtkRecMemory();
        unsigned * pTruth = Hop_ManConvertAigToTruth( pMan, Hop_Regular(pRoot), nVars, vMemory, 0 );
        assert( Extra_TruthSupportSize(pTruth, nVars) == Abc_ObjFaninNum(pNodeOld) ); // should be swept
        if ( Hop_IsComplement(pRoot) )
            Extra_TruthNot( pTruth, pTruth, nVars );
        if ( Abc_NtkRecStrashNode( pNtkNew, pNodeOld, pTruth, nVars ) )
            return pNodeOld->pCopy;
    }
*/
    // set elementary variables
    Abc_ObjForEachFanin( pNodeOld, pFanin, i )
        Hop_IthVar(pMan, i)->pData = pFanin->pCopy;
    // strash the AIG of this node
    Abc_NodeStrash_rec( (Abc_Aig_t *)pNtkNew->pManFunc, Hop_Regular(pRoot) );
    Hop_ConeUnmark_rec( Hop_Regular(pRoot) );
    // return the final node
    return Abc_ObjNotCond( (Abc_Obj_t *)Hop_Regular(pRoot)->pData, Hop_IsComplement(pRoot) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkAddDummyBoxNames()

ABC_DLL void Abc_NtkAddDummyBoxNames ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Adds dummy names.]

Description []

SideEffects []

SeeAlso []

Definition at line 547 of file abcNames.c.

{
    char * pName, PrefLi[100], PrefLo[100];
    Abc_Obj_t * pObj;
    int nDigits, i, k, CountCur, CountMax = 0;
    // if PIs/POs already have nodes with what looks like latch names
    // we need to add different prefix for the new latches
    Abc_NtkForEachPi( pNtk, pObj, i )
    {
        CountCur = 0;
        pName = Abc_ObjName(pObj);
        for ( k = 0; pName[k]; k++ )
            if ( pName[k] == 'l' )
                CountCur++;
            else
                break;
        CountMax = Abc_MaxInt( CountMax, CountCur );
    }
    Abc_NtkForEachPo( pNtk, pObj, i )
    {
        CountCur = 0;
        pName = Abc_ObjName(pObj);
        for ( k = 0; pName[k]; k++ )
            if ( pName[k] == 'l' )
                CountCur++;
            else
                break;
        CountMax = Abc_MaxInt( CountMax, CountCur );
    }
//printf( "CountMax = %d\n", CountMax );
    assert( CountMax < 100-2 );
    for ( i = 0; i <= CountMax; i++ )
        PrefLi[i] = PrefLo[i] = 'l';
    PrefLi[i] = 'i';
    PrefLo[i] = 'o';
    PrefLi[i+1] = 0;
    PrefLo[i+1] = 0;
    // create latch names
    assert( !Abc_NtkIsNetlist(pNtk) );
    nDigits = Abc_Base10Log( Abc_NtkLatchNum(pNtk) );
    Abc_NtkForEachLatch( pNtk, pObj, i )
    {
        Abc_ObjAssignName( pObj, Abc_ObjNameDummy("l", i, nDigits), NULL );
        Abc_ObjAssignName( Abc_ObjFanin0(pObj),  Abc_ObjNameDummy(PrefLi, i, nDigits), NULL );
        Abc_ObjAssignName( Abc_ObjFanout0(pObj), Abc_ObjNameDummy(PrefLo, i, nDigits), NULL );
    }
/*
    nDigits = Abc_Base10Log( Abc_NtkBlackboxNum(pNtk) );
    Abc_NtkForEachBlackbox( pNtk, pObj, i )
    {
        pName = Abc_ObjAssignName( pObj, Abc_ObjNameDummy("B", i, nDigits), NULL );
        nDigitsF = Abc_Base10Log( Abc_ObjFaninNum(pObj) );
        Abc_ObjForEachFanin( pObj, pTerm, k )
            Abc_ObjAssignName( Abc_ObjFanin0(pObj), pName, Abc_ObjNameDummy("i", k, nDigitsF) );
        nDigitsF = Abc_Base10Log( Abc_ObjFanoutNum(pObj) );
        Abc_ObjForEachFanout( pObj, pTerm, k )
            Abc_ObjAssignName( Abc_ObjFanin0(pObj), pName, Abc_ObjNameDummy("o", k, nDigitsF) );
    }
*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkAddDummyPiNames()

ABC_DLL void Abc_NtkAddDummyPiNames ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Adds dummy names.]

Description []

SideEffects []

SeeAlso []

Definition at line 495 of file abcNames.c.

{
    Abc_Obj_t * pObj;
    int nDigits, i;
    nDigits = Abc_Base10Log( Abc_NtkPiNum(pNtk) );
    Abc_NtkForEachPi( pNtk, pObj, i )
        Abc_ObjAssignName( pObj, Abc_ObjNameDummy("pi", i, nDigits), NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkAddDummyPoNames()

ABC_DLL void Abc_NtkAddDummyPoNames ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Adds dummy names.]

Description []

SideEffects []

SeeAlso []

Definition at line 521 of file abcNames.c.

{
    Abc_Obj_t * pObj;
    int nDigits, i;
    nDigits = Abc_Base10Log( Abc_NtkPoNum(pNtk) );
    Abc_NtkForEachPo( pNtk, pObj, i )
        Abc_ObjAssignName( pObj, Abc_ObjNameDummy("po", i, nDigits), NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkAddLatch()

ABC_DLL Abc_Obj_t * Abc_NtkAddLatch	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t *	pDriver,
		Abc_InitType_t	Init )

extern

Function*************************************************************

Synopsis [Creates latch with the given initial value.]

Description []

SideEffects []

SeeAlso []

Definition at line 254 of file abcLatch.c.

{
    Abc_Obj_t * pLatchOut, * pLatch, * pLatchIn;
    pLatchOut = Abc_NtkCreateBo(pNtk);
    pLatch    = Abc_NtkCreateLatch(pNtk);
    pLatchIn  = Abc_NtkCreateBi(pNtk);
    Abc_ObjAssignName( pLatchOut, Abc_ObjName(pLatch), "_lo" );
    Abc_ObjAssignName( pLatchIn,  Abc_ObjName(pLatch), "_li" );
    Abc_ObjAddFanin( pLatchOut, pLatch );
    Abc_ObjAddFanin( pLatch, pLatchIn );
    if ( pDriver )
    Abc_ObjAddFanin( pLatchIn, pDriver );
    pLatch->pData = (void *)Init;
    return pLatchOut;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkAigToBdd()

ABC_DLL int Abc_NtkAigToBdd ( Abc_Ntk_t * pNtk )

extern

Definition at line 869 of file abcFunc.c.

869{ return 1; }

Here is the caller graph for this function:

◆ Abc_NtkAigToGia()

ABC_DLL Gia_Man_t * Abc_NtkAigToGia	(	Abc_Ntk_t *	p,
		int	fGiaSimple )

extern

Function*************************************************************

Synopsis [Converts the network from AIG to BDD representation.]

Description []

SideEffects []

SeeAlso []

Definition at line 1050 of file abcFunc.c.

{
    Gia_Man_t * pNew;
    Hop_Man_t * pHopMan;
    Hop_Obj_t * pHopObj;
    Vec_Int_t * vMapping = NULL;
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pNode, * pFanin;
    int i, k, nObjs, iGiaObj;
    assert( Abc_NtkIsAigLogic(p) );
    pHopMan = (Hop_Man_t *)p->pManFunc;
    // create new manager
    pNew = Gia_ManStart( 10000 );
    pNew->pName = Abc_UtilStrsav( Abc_NtkName(p) );
    pNew->pSpec = Abc_UtilStrsav( Abc_NtkSpec(p) );
    pNew->fGiaSimple = fGiaSimple;
    Abc_NtkCleanCopy( p );
    Hop_ManConst1(pHopMan)->iData = 1;
    // create primary inputs
    Abc_NtkForEachCi( p, pNode, i )
        pNode->iTemp = Gia_ManAppendCi(pNew);
    // find the number of objects
    nObjs = 1 + Abc_NtkCiNum(p) + Abc_NtkCoNum(p);
    Abc_NtkForEachNode( p, pNode, i )
        nObjs += Abc_ObjIsBarBuf(pNode) ? 1 : Hop_DagSize( (Hop_Obj_t *)pNode->pData );
    if ( !fGiaSimple )
        vMapping = Vec_IntStart( nObjs );
    // iterate through nodes used in the mapping
    vNodes = Abc_NtkDfs( p, 0 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
    {
        if ( Abc_ObjIsBarBuf(pNode) )
        {
            assert( !Abc_ObjFaninC0(pNode) );
            pNode->iTemp = Gia_ManAppendBuf( pNew, Abc_ObjFanin0(pNode)->iTemp );
            continue;
        }
        Abc_ObjForEachFanin( pNode, pFanin, k )
            Hop_ManPi(pHopMan, k)->iData = pFanin->iTemp;
        pHopObj = Hop_Regular( (Hop_Obj_t *)pNode->pData );
        if ( Hop_DagSize(pHopObj) > 0 )
        {
            assert( Abc_ObjFaninNum(pNode) <= Hop_ManPiNum(pHopMan) );
            Abc_ConvertAigToGia( pNew, pHopObj );
            iGiaObj = Abc_Lit2Var( pHopObj->iData );
            if ( vMapping && Gia_ObjIsAnd(Gia_ManObj(pNew, iGiaObj)) && !Vec_IntEntry(vMapping, iGiaObj) )
            {
                Vec_IntWriteEntry( vMapping, iGiaObj, Vec_IntSize(vMapping) );
                Vec_IntPush( vMapping, Abc_ObjFaninNum(pNode) );
                Abc_ObjForEachFanin( pNode, pFanin, k )
                    Vec_IntPush( vMapping, Abc_Lit2Var(pFanin->iTemp)  );
                Vec_IntPush( vMapping, iGiaObj );
            }
        }
        pNode->iTemp = Abc_LitNotCond( pHopObj->iData, Hop_IsComplement( (Hop_Obj_t *)pNode->pData ) );
    }
    // create primary outputs
    Abc_NtkForEachCo( p, pNode, i )
        Gia_ManAppendCo( pNew, Abc_ObjFanin0(pNode)->iTemp );
    Gia_ManSetRegNum( pNew, Abc_NtkLatchNum(p) );
    // copy original IDs
    pNew->vIdsOrig = Vec_IntStart( Gia_ManObjNum(pNew) );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
        Vec_IntWriteEntry( pNew->vIdsOrig, Abc_Lit2Var(pNode->iTemp), Abc_ObjId(pNode) );
    Vec_PtrFree( vNodes );
    // finish mapping 
    assert( Gia_ManObjNum(pNew) <= nObjs );
    assert( pNew->vMapping == NULL );
    pNew->vMapping = vMapping;
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkAlloc()

ABC_DLL Abc_Ntk_t * Abc_NtkAlloc	(	Abc_NtkType_t	Type,
		Abc_NtkFunc_t	Func,
		int	fUseMemMan )

extern

DECLARATIONS ///.

CFile****************************************************************

FileName [abcNtk.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Network creation/duplication/deletion procedures.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: abcNtk.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Creates a new Ntk.]

Description []

SideEffects []

SeeAlso []

Definition at line 53 of file abcNtk.c.

{
    Abc_Ntk_t * pNtk;
    pNtk = ABC_ALLOC( Abc_Ntk_t, 1 );
    memset( pNtk, 0, sizeof(Abc_Ntk_t) );
    pNtk->ntkType     = Type;
    pNtk->ntkFunc     = Func;
    // start the object storage
    pNtk->vObjs       = Vec_PtrAlloc( 100 );
    pNtk->vPios       = Vec_PtrAlloc( 100 );
    pNtk->vPis        = Vec_PtrAlloc( 100 );
    pNtk->vPos        = Vec_PtrAlloc( 100 );
    pNtk->vCis        = Vec_PtrAlloc( 100 );
    pNtk->vCos        = Vec_PtrAlloc( 100 );
    pNtk->vBoxes      = Vec_PtrAlloc( 100 );
    pNtk->vLtlProperties = Vec_PtrAlloc( 100 );
    // start the memory managers
    pNtk->pMmObj      = fUseMemMan? Mem_FixedStart( sizeof(Abc_Obj_t) ) : NULL;
    pNtk->pMmStep     = fUseMemMan? Mem_StepStart( ABC_NUM_STEPS ) : NULL;
    // get ready to assign the first Obj ID
    pNtk->nTravIds    = 1;
    // start the functionality manager
    if ( !Abc_NtkIsStrash(pNtk) )
        Vec_PtrPush( pNtk->vObjs, NULL );
    if ( Abc_NtkIsStrash(pNtk) )
        pNtk->pManFunc = Abc_AigAlloc( pNtk );
    else if ( Abc_NtkHasSop(pNtk) || Abc_NtkHasBlifMv(pNtk) )
        pNtk->pManFunc = Mem_FlexStart();
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNtk) )
        pNtk->pManFunc = Cudd_Init( 20, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
#endif
    else if ( Abc_NtkHasAig(pNtk) )
        pNtk->pManFunc = Hop_ManStart();
    else if ( Abc_NtkHasMapping(pNtk) )
        pNtk->pManFunc = Abc_FrameReadLibGen();
    else if ( !Abc_NtkHasBlackbox(pNtk) )
        assert( 0 );
    // name manager
    pNtk->pManName = Nm_ManCreate( 200 );
    // attribute manager
    pNtk->vAttrs = Vec_PtrStart( VEC_ATTR_TOTAL_NUM );
    // estimated AndGateDelay
    pNtk->AndGateDelay = 0.0;
    return pNtk;
}

Here is the call graph for this function:

◆ Abc_NtkAppend()

ABC_DLL int Abc_NtkAppend	(	Abc_Ntk_t *	pNtk1,
		Abc_Ntk_t *	pNtk2,
		int	fAddPos )

extern

Function*************************************************************

Synopsis [Appends the second network to the first.]

Description [Modifies the first network by adding the logic of the second. Performs structural hashing while appending the networks. Does not change the second network. Returns 0 if the appending failed, 1 otherise.]

SideEffects []

SeeAlso []

Definition at line 320 of file abcStrash.c.

{
    Abc_Obj_t * pObj;
    char * pName;
    int i, nNewCis;
    // the first network should be an AIG
    assert( Abc_NtkIsStrash(pNtk1) );
    assert( Abc_NtkIsLogic(pNtk2) || Abc_NtkIsStrash(pNtk2) ); 
    if ( Abc_NtkIsLogic(pNtk2) && !Abc_NtkToAig(pNtk2) )
    {
        printf( "Converting to AIGs has failed.\n" );
        return 0;
    }
    // check that the networks have the same PIs
    // reorder PIs of pNtk2 according to pNtk1
    if ( !Abc_NtkCompareSignals( pNtk1, pNtk2, 1, 1 ) )
        printf( "Abc_NtkAppend(): The union of the network PIs is computed (warning).\n" );
    // perform strashing
    nNewCis = 0;
    Abc_NtkCleanCopy( pNtk2 );
    if ( Abc_NtkIsStrash(pNtk2) )
        Abc_AigConst1(pNtk2)->pCopy = Abc_AigConst1(pNtk1);
    Abc_NtkForEachCi( pNtk2, pObj, i )
    {
        pName = Abc_ObjName(pObj);
        pObj->pCopy = Abc_NtkFindCi(pNtk1, Abc_ObjName(pObj));
        if ( pObj->pCopy == NULL )
        {
            pObj->pCopy = Abc_NtkDupObj(pNtk1, pObj, 1);
            nNewCis++;
        }
    }
    if ( nNewCis )
        printf( "Warning: Procedure Abc_NtkAppend() added %d new CIs.\n", nNewCis );
    // add pNtk2 to pNtk1 while strashing
    if ( Abc_NtkIsLogic(pNtk2) )
        Abc_NtkStrashPerform( pNtk2, pNtk1, 1, 0 );
    else
        Abc_NtkForEachNode( pNtk2, pObj, i )
            pObj->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtk1->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
    // add the COs of the second network
    if ( fAddPos )
    {
        Abc_NtkForEachPo( pNtk2, pObj, i )
        {
            Abc_NtkDupObj( pNtk1, pObj, 0 );
            Abc_ObjAddFanin( pObj->pCopy, Abc_ObjChild0Copy(pObj) );
            Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(pObj), NULL );
        }
    }
    else
    {
        Abc_Obj_t * pObjOld, * pDriverOld, * pDriverNew;
        int fCompl, iNodeId;
        // OR the choices
        Abc_NtkForEachCo( pNtk2, pObj, i )
        {
            iNodeId = Nm_ManFindIdByNameTwoTypes( pNtk1->pManName, Abc_ObjName(pObj), ABC_OBJ_PO, ABC_OBJ_BI );
//            if ( iNodeId < 0 )
//                continue;
            assert( iNodeId >= 0 );
            pObjOld = Abc_NtkObj( pNtk1, iNodeId );
            // derive the new driver
            pDriverOld = Abc_ObjChild0( pObjOld );
            pDriverNew = Abc_ObjChild0Copy( pObj );
            pDriverNew = Abc_AigOr( (Abc_Aig_t *)pNtk1->pManFunc, pDriverOld, pDriverNew );
            if ( Abc_ObjRegular(pDriverOld) == Abc_ObjRegular(pDriverNew) )
                continue;
            // replace the old driver by the new driver
            fCompl = Abc_ObjRegular(pDriverOld)->fPhase ^ Abc_ObjRegular(pDriverNew)->fPhase;
            Abc_ObjPatchFanin( pObjOld, Abc_ObjRegular(pDriverOld), Abc_ObjNotCond(Abc_ObjRegular(pDriverNew), fCompl) );
        }
    }
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtk1 ) )
    {
        printf( "Abc_NtkAppend: The network check has failed.\n" );
        return 0;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkAppendToCone()

ABC_DLL void Abc_NtkAppendToCone	(	Abc_Ntk_t *	pNtkNew,
		Abc_Ntk_t *	pNtk,
		Vec_Ptr_t *	vRoots )

extern

Function*************************************************************

Synopsis [Adds new nodes to the cone.]

Description []

SideEffects []

SeeAlso []

Definition at line 1075 of file abcNtk.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj;
    int i, iNodeId;
 
    assert( Abc_NtkIsStrash(pNtkNew) );
    assert( Abc_NtkIsStrash(pNtk) );
 
    // collect the nodes in the TFI of the output (mark the TFI)
    vNodes = Abc_NtkDfsNodes( pNtk, (Abc_Obj_t **)Vec_PtrArray(vRoots), Vec_PtrSize(vRoots) );
 
    // establish connection between the constant nodes
    Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkNew);
 
    // create the PIs
    Abc_NtkForEachCi( pNtk, pObj, i )
    {
        // skip CIs that are not used
        if ( !Abc_NodeIsTravIdCurrent(pObj) )
            continue;
        // find the corresponding CI in the new network
        iNodeId = Nm_ManFindIdByNameTwoTypes( pNtkNew->pManName, Abc_ObjName(pObj), ABC_OBJ_PI, ABC_OBJ_BO );
        if ( iNodeId == -1 )
        {
            pObj->pCopy = Abc_NtkCreatePi(pNtkNew);
            Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(pObj), NULL );
        }
        else
            pObj->pCopy = Abc_NtkObj( pNtkNew, iNodeId );
    }
 
    // copy the nodes
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
        pObj->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkNew->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
    Vec_PtrFree( vNodes );
 
    // do not add the COs
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkAppendToCone(): Network check has failed.\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkAttach()

ABC_DLL int Abc_NtkAttach ( Abc_Ntk_t * pNtk )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Attaches gates from the current library to the internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 60 of file abcAttach.c.

{
    Mio_Library_t * pGenlib;
    unsigned ** puTruthGates;
    unsigned uTruths[6][2];
    Abc_Obj_t * pNode;
    Mio_Gate_t ** ppGates;
    int nGates, nFanins, i;
 
    assert( Abc_NtkIsSopLogic(pNtk) );
 
    // check that the library is available
    pGenlib = (Mio_Library_t *)Abc_FrameReadLibGen();
    if ( pGenlib == NULL )
    {
        printf( "The current library is not available.\n" );
        return 0;
    }
 
    // start the truth tables
    Abc_AttachSetupTruthTables( uTruths );
    
    // collect all the gates
    ppGates = Mio_CollectRoots( pGenlib, 6, (float)1.0e+20, 1, &nGates, 0 );
 
    // derive the gate truth tables
    puTruthGates    = ABC_ALLOC( unsigned *, nGates );
    puTruthGates[0] = ABC_ALLOC( unsigned, 2 * nGates );
    for ( i = 1; i < nGates; i++ )
        puTruthGates[i] = puTruthGates[i-1] + 2;
    for ( i = 0; i < nGates; i++ )
        Mio_DeriveTruthTable( ppGates[i], uTruths, Mio_GateReadPinNum(ppGates[i]), 6, puTruthGates[i] );
 
    // assign the gates to pNode->pCopy
    Abc_NtkCleanCopy( pNtk );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        nFanins = Abc_ObjFaninNum(pNode);
        if ( nFanins == 0 )
        {
            if ( Abc_SopIsConst1((char *)pNode->pData) )
                pNode->pCopy = (Abc_Obj_t *)Mio_LibraryReadConst1(pGenlib);
            else
                pNode->pCopy = (Abc_Obj_t *)Mio_LibraryReadConst0(pGenlib);
        }
        else if ( nFanins == 1 )
        {
            if ( Abc_SopIsBuf((char *)pNode->pData) )
                pNode->pCopy = (Abc_Obj_t *)Mio_LibraryReadBuf(pGenlib);
            else
                pNode->pCopy = (Abc_Obj_t *)Mio_LibraryReadInv(pGenlib);
        }
        else if ( nFanins > 6 )
        {
            printf( "Cannot attach gate with more than 6 inputs to node %s.\n", Abc_ObjName(pNode) );
            ABC_FREE( puTruthGates[0] );
            ABC_FREE( puTruthGates );
            ABC_FREE( ppGates );
            return 0;
        }
        else if ( !Abc_NodeAttach( pNode, ppGates, puTruthGates, nGates, uTruths ) )
        {
            printf( "Could not attach the library gate to node %s.\n", Abc_ObjName(pNode) );
            ABC_FREE( puTruthGates[0] );
            ABC_FREE( puTruthGates );
            ABC_FREE( ppGates );
            return 0;
        }
    }
    ABC_FREE( puTruthGates[0] );
    ABC_FREE( puTruthGates );
    ABC_FREE( ppGates );
    ABC_FREE( s_pPerms );
 
    // perform the final transformation
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( pNode->pCopy == NULL )
        {
            printf( "Some elementary gates (constant, buffer, or inverter) are missing in the library.\n" );
            return 0;
        }
    }
 
    // replace SOP representation by the gate representation
    Abc_NtkForEachNode( pNtk, pNode, i )
        pNode->pData = pNode->pCopy, pNode->pCopy = NULL;
    pNtk->ntkFunc = ABC_FUNC_MAP;
    Extra_MmFlexStop( (Extra_MmFlex_t *)pNtk->pManFunc );
    pNtk->pManFunc = pGenlib;
 
    printf( "Library gates are successfully attached to the nodes.\n" );
 
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkAttach: The network check has failed.\n" );
        return 0;
    }
    return 1;
}

Here is the call graph for this function:

◆ Abc_NtkAttrFree()

ABC_DLL void * Abc_NtkAttrFree	(	Abc_Ntk_t *	pNtk,
		int	Attr,
		int	fFreeMan )

extern

DECLARATIONS ///.

CFile****************************************************************

FileName [abcUtil.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Various utilities.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: abcUtil.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Frees one attribute manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 55 of file abcUtil.c.

{  
    void * pUserMan;
    Vec_Att_t * pAttrMan;
    pAttrMan = (Vec_Att_t *)Vec_PtrEntry( pNtk->vAttrs, Attr );
    Vec_PtrWriteEntry( pNtk->vAttrs, Attr, NULL );
    pUserMan = Vec_AttFree( pAttrMan, fFreeMan );
    return pUserMan;
}

Here is the caller graph for this function:

◆ Abc_NtkBalance()

ABC_DLL Abc_Ntk_t * Abc_NtkBalance	(	Abc_Ntk_t *	pNtk,
		int	fDuplicate,
		int	fSelective,
		int	fUpdateLevel )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Balances the AIG network.]

Description []

SideEffects []

SeeAlso []

Definition at line 53 of file abcBalance.c.

{
//    extern void Abc_NtkHaigTranfer( Abc_Ntk_t * pNtkOld, Abc_Ntk_t * pNtkNew );
    Abc_Ntk_t * pNtkAig;
    assert( Abc_NtkIsStrash(pNtk) );
    // compute the required times
    if ( fSelective )
    {
        Abc_NtkStartReverseLevels( pNtk, 0 );
        Abc_NtkMarkCriticalNodes( pNtk );
    }
    // perform balancing
    pNtkAig = Abc_NtkStartFrom( pNtk, ABC_NTK_STRASH, ABC_FUNC_AIG );
    // transfer HAIG
//    Abc_NtkHaigTranfer( pNtk, pNtkAig );
    // perform balancing
    Abc_NtkBalancePerform( pNtk, pNtkAig, fDuplicate, fSelective, fUpdateLevel );
    Abc_NtkFinalize( pNtk, pNtkAig );
    Abc_AigCleanup( (Abc_Aig_t *)pNtkAig->pManFunc );
    // undo the required times
    if ( fSelective )
    {
        Abc_NtkStopReverseLevels( pNtk );
        Abc_NtkCleanMarkA( pNtk );
    }
    if ( pNtk->pExdc )
        pNtkAig->pExdc = Abc_NtkDup( pNtk->pExdc );
    // make sure everything is okay
    if ( !Abc_NtkCheck( pNtkAig ) )
    {
        printf( "Abc_NtkBalance: The network check has failed.\n" );
        Abc_NtkDelete( pNtkAig );
        return NULL;
    }
//Abc_NtkPrintCiLevels( pNtkAig );
    return pNtkAig;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkBalanceExor()

ABC_DLL Abc_Ntk_t * Abc_NtkBalanceExor	(	Abc_Ntk_t *	pNtk,
		int	fUpdateLevel,
		int	fVerbose )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 4078 of file abcDar.c.

{
    extern void Dar_BalancePrintStats( Aig_Man_t * p );
    Abc_Ntk_t * pNtkAig;
    Aig_Man_t * pMan, * pTemp;//, * pTemp2;
    assert( Abc_NtkIsStrash(pNtk) );
    // derive AIG with EXORs
    pMan = Abc_NtkToDar( pNtk, 1, 0 );
    if ( pMan == NULL )
        return NULL;
//    Aig_ManPrintStats( pMan );
    if ( fVerbose )
        Dar_BalancePrintStats( pMan );
    // perform balancing
    pTemp = Dar_ManBalance( pMan, fUpdateLevel );
//    Aig_ManPrintStats( pTemp );
    // create logic network
    pNtkAig = Abc_NtkFromDar( pNtk, pTemp );
    Aig_ManStop( pTemp );
    Aig_ManStop( pMan );
    return pNtkAig;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkBarBufsFromBuffers()

ABC_DLL Abc_Ntk_t * Abc_NtkBarBufsFromBuffers	(	Abc_Ntk_t *	pNtkBase,
		Abc_Ntk_t *	pNtk )

extern

Definition at line 462 of file abcBarBuf.c.

{
    Abc_Ntk_t * pNtkNew;
    Abc_Obj_t * pObj, * pFanin, * pLatch;
    int i, k, nBarBufs;
    assert( Abc_NtkIsLogic(pNtkBase) );
    assert( Abc_NtkIsLogic(pNtk) );
    assert( pNtkBase->nBarBufs == Abc_NtkLatchNum(pNtkBase) );
    // start the network
    pNtkNew = Abc_NtkStartFrom( pNtkBase, pNtk->ntkType, pNtk->ntkFunc );
    // transfer PI pointers
    Abc_NtkForEachPi( pNtk, pObj, i )
        pObj->pCopy = Abc_NtkPi(pNtkNew, i);
    // assuming that the order/number of barbufs remains the same
    nBarBufs = 0;
    Abc_NtkForEachNode( pNtk, pObj, i )
    {
        if ( Abc_ObjIsBarBuf(pObj) )
        {
            pLatch = Abc_NtkBox(pNtkNew, nBarBufs++);
            Abc_ObjAddFanin( Abc_ObjFanin0(pLatch), Abc_ObjFanin0(pObj)->pCopy );
            pObj->pCopy = Abc_ObjFanout0(pLatch);
        }
        else
        {
            Abc_NtkDupObj( pNtkNew, pObj, 1 );
            Abc_ObjForEachFanin( pObj, pFanin, k )
                Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
        }
    }
    assert( nBarBufs == pNtkBase->nBarBufs );
    // connect POs
    Abc_NtkForEachPo( pNtk, pObj, i )
        Abc_ObjAddFanin( Abc_NtkPo(pNtkNew, i), Abc_ObjFanin0(pObj)->pCopy );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkBarBufsToBuffers()

ABC_DLL Abc_Ntk_t * Abc_NtkBarBufsToBuffers ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Converts the network to dedicated barbufs and back.]

Description []

SideEffects []

SeeAlso []

Definition at line 424 of file abcBarBuf.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Ntk_t * pNtkNew;
    Abc_Obj_t * pObj, * pFanin;
    int i, k;
    assert( Abc_NtkIsLogic(pNtk) );
    assert( pNtk->pDesign == NULL );
    assert( pNtk->nBarBufs > 0 );
    assert( pNtk->nBarBufs == Abc_NtkLatchNum(pNtk) );
    vNodes = Abc_NtkToBarBufsCollect( pNtk );
    // start the network
    pNtkNew = Abc_NtkAlloc( ABC_NTK_LOGIC, pNtk->ntkFunc, 1 );
    pNtkNew->pName = Extra_UtilStrsav(pNtk->pName);
    pNtkNew->pSpec = Extra_UtilStrsav(pNtk->pSpec);
    // create objects
    Abc_NtkCleanCopy( pNtk );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
    {
        if ( Abc_ObjIsPi(pObj) )
            Abc_NtkDupObj( pNtkNew, pObj, 1 );
        else if ( Abc_ObjIsPo( pObj) )
            Abc_ObjAddFanin( Abc_NtkDupObj(pNtkNew, pObj, 1), Abc_ObjFanin0(pObj)->pCopy );
        else if ( Abc_ObjIsBi(pObj) || Abc_ObjIsBo(pObj) )
            pObj->pCopy = Abc_ObjFanin0(pObj)->pCopy;
        else if ( Abc_ObjIsLatch(pObj) )
            Abc_ObjAddFanin( (pObj->pCopy = Abc_NtkCreateNode(pNtkNew)), Abc_ObjFanin0(pObj)->pCopy );
        else if ( Abc_ObjIsNode(pObj) )
        {
            Abc_NtkDupObj( pNtkNew, pObj, 1 );
            Abc_ObjForEachFanin( pObj, pFanin, k )
                Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
        }
        else assert( 0 );
    }
    Vec_PtrFree( vNodes );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkBddToMuxes()

ABC_DLL Abc_Ntk_t * Abc_NtkBddToMuxes	(	Abc_Ntk_t *	pNtk,
		int	fGlobal,
		int	Limit,
		int	fUseAdd )

extern

Definition at line 687 of file abcNtbdd.c.

687{ return NULL; }

Here is the caller graph for this function:

◆ Abc_NtkBddToSop()

ABC_DLL int Abc_NtkBddToSop	(	Abc_Ntk_t *	pNtk,
		int	fMode,
		int	nCubeLimit,
		int	fCubeSort )

extern

Definition at line 866 of file abcFunc.c.

866{ return 1; }

Here is the caller graph for this function:

◆ Abc_NtkBuildGlobalBdds()

ABC_DLL void * Abc_NtkBuildGlobalBdds	(	Abc_Ntk_t *	pNtk,
		int	fBddSizeMax,
		int	fDropInternal,
		int	fReorder,
		int	fReverse,
		int	fVerbose )

extern

◆ Abc_NtkCharNames()

ABC_DLL void Abc_NtkCharNames ( Abc_Ntk_t * pNtk )

extern

Definition at line 627 of file abcNames.c.

{
    Nm_ManFree( pNtk->pManName );
    pNtk->pManName = Nm_ManCreate( Abc_NtkCiNum(pNtk) + Abc_NtkCoNum(pNtk) + Abc_NtkBoxNum(pNtk) );
    Abc_NtkAddCharPiNames( pNtk );
    Abc_NtkAddCharPoNames( pNtk );
    Abc_NtkAddDummyBoxNames( pNtk );
}

Here is the call graph for this function:

◆ Abc_NtkCheck()

ABC_DLL int Abc_NtkCheck ( Abc_Ntk_t * pNtk )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Checks the integrity of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 64 of file abcCheck.c.

{ 
   return !Abc_FrameIsFlagEnabled( "check" ) || Abc_NtkDoCheck( pNtk );
}

Here is the call graph for this function:

◆ Abc_NtkCheckObj()

ABC_DLL int Abc_NtkCheckObj	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t *	pObj )

extern

Function*************************************************************

Synopsis [Checks the connectivity of the object.]

Description []

SideEffects []

SeeAlso []

Definition at line 420 of file abcCheck.c.

{
    Abc_Obj_t * pFanin, * pFanout;
    int Value = 1;
    int i, k;
 
    // check the network
    if ( pObj->pNtk != pNtk )
    {
        fprintf( stdout, "NetworkCheck: Object \"%s\" does not belong to the network.\n", Abc_ObjName(pObj) );
        return 0;
    }
    // check the object ID
    if ( pObj->Id < 0 || (int)pObj->Id >= Abc_NtkObjNumMax(pNtk) )
    {
        fprintf( stdout, "NetworkCheck: Object \"%s\" has incorrect ID.\n", Abc_ObjName(pObj) );
        return 0;
    }
 
    if ( !Abc_FrameIsFlagEnabled("checkfio") )
        return Value;
 
    // go through the fanins of the object and make sure fanins have this object as a fanout
    Abc_ObjForEachFanin( pObj, pFanin, i )
    {
        if ( Vec_IntFind( &pFanin->vFanouts, pObj->Id ) == -1 )
        {
            fprintf( stdout, "NodeCheck: Object \"%s\" has fanin ", Abc_ObjName(pObj) );
            fprintf( stdout, "\"%s\" but the fanin does not have it as a fanout.\n", Abc_ObjName(pFanin) );
            Value = 0;
        }
    }
    // go through the fanouts of the object and make sure fanouts have this object as a fanin
    Abc_ObjForEachFanout( pObj, pFanout, i )
    {
        if ( Vec_IntFind( &pFanout->vFanins, pObj->Id ) == -1 )
        {
            fprintf( stdout, "NodeCheck: Object \"%s\" has fanout ", Abc_ObjName(pObj) );
            fprintf( stdout, "\"%s\" but the fanout does not have it as a fanin.\n", Abc_ObjName(pFanout) );
            Value = 0;
        }
    }
 
    // make sure fanins are not duplicated
    for ( i = 0; i < pObj->vFanins.nSize; i++ )
        for ( k = i + 1; k < pObj->vFanins.nSize; k++ )
            if ( pObj->vFanins.pArray[k] == pObj->vFanins.pArray[i] )
            {
                printf( "Warning: Node %s has", Abc_ObjName(pObj) );
                printf( " duplicated fanin %s.\n", Abc_ObjName(Abc_ObjFanin(pObj,k)) );
            }
 
    // save time: do not check large fanout lists
    if ( pObj->vFanouts.nSize > 100 )
        return Value;
 
    // make sure fanouts are not duplicated
    for ( i = 0; i < pObj->vFanouts.nSize; i++ )
        for ( k = i + 1; k < pObj->vFanouts.nSize; k++ )
            if ( pObj->vFanouts.pArray[k] == pObj->vFanouts.pArray[i] )
            {
                printf( "Warning: Node %s has", Abc_ObjName(pObj) );
                printf( " duplicated fanout %s.\n", Abc_ObjName(Abc_ObjFanout(pObj,k)) );
            }
 
    return Value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCheckRead()

ABC_DLL int Abc_NtkCheckRead ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Checks the integrity of the network after reading.]

Description []

SideEffects []

SeeAlso []

Definition at line 80 of file abcCheck.c.

{
   return !Abc_FrameIsFlagEnabled( "checkread" ) || Abc_NtkDoCheck( pNtk );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCheckUniqueCiNames()

ABC_DLL int Abc_NtkCheckUniqueCiNames ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns 0 if CI names are repeated.]

Description []

SideEffects []

SeeAlso []

Definition at line 862 of file abcCheck.c.

{
    Vec_Ptr_t * vNames;
    Abc_Obj_t * pObj;
    int i, fRetValue = 1;
    assert( !Abc_NtkIsNetlist(pNtk) );
    vNames = Vec_PtrAlloc( Abc_NtkCiNum(pNtk) );
    Abc_NtkForEachCi( pNtk, pObj, i )
        Vec_PtrPush( vNames, Abc_ObjName(pObj) );
    Vec_PtrSort( vNames, (int (*)(const void *, const void *))Abc_NtkNamesCompare );
    for ( i = 1; i < Abc_NtkCiNum(pNtk); i++ )
        if ( !strcmp( (const char *)Vec_PtrEntry(vNames,i-1), (const char *)Vec_PtrEntry(vNames,i) ) )
        {
            printf( "Abc_NtkCheck: Repeated CI names: %s and %s.\n", (char*)Vec_PtrEntry(vNames,i-1), (char*)Vec_PtrEntry(vNames,i) );
            fRetValue = 0;
        }
    Vec_PtrFree( vNames );
    return fRetValue;
}

Here is the call graph for this function:

◆ Abc_NtkCheckUniqueCioNames()

ABC_DLL int Abc_NtkCheckUniqueCioNames ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns 0 if there is a pair of CI/CO with the same name and logic in between.]

Description []

SideEffects []

SeeAlso []

Definition at line 927 of file abcCheck.c.

{
    Abc_Obj_t * pObj, * pObjCi, * pFanin;
    int i, nCiId, fRetValue = 1;
    assert( !Abc_NtkIsNetlist(pNtk) );
    Abc_NtkForEachCo( pNtk, pObj, i )
    {
        nCiId = Nm_ManFindIdByNameTwoTypes( pNtk->pManName, Abc_ObjName(pObj), ABC_OBJ_PI, ABC_OBJ_BO );
        if ( nCiId == -1 )
            continue;
        pObjCi = Abc_NtkObj( pNtk, nCiId );
        assert( !strcmp( Abc_ObjName(pObj), Abc_ObjName(pObjCi) ) );
        pFanin = Abc_ObjFanin0(pObj);
        if ( pFanin != pObjCi )
        {
            printf( "Abc_NtkCheck: A CI/CO pair share the name (%s) but do not link directly. The name of the CO fanin is %s.\n", 
                Abc_ObjName(pObj), Abc_ObjName(Abc_ObjFanin0(pObj)) );
            fRetValue = 0;
        }
    }
    return fRetValue;
}

Here is the call graph for this function:

◆ Abc_NtkCheckUniqueCoNames()

ABC_DLL int Abc_NtkCheckUniqueCoNames ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns 0 if CO names are repeated.]

Description []

SideEffects []

SeeAlso []

Definition at line 893 of file abcCheck.c.

{
    Vec_Ptr_t * vNames;
    Abc_Obj_t * pObj;
    int i, fRetValue = 1;
    assert( !Abc_NtkIsNetlist(pNtk) );
    vNames = Vec_PtrAlloc( Abc_NtkCoNum(pNtk) );
    Abc_NtkForEachCo( pNtk, pObj, i )
        Vec_PtrPush( vNames, Abc_ObjName(pObj) );
    Vec_PtrSort( vNames, (int (*)(const void *, const void *))Abc_NtkNamesCompare );
    for ( i = 1; i < Abc_NtkCoNum(pNtk); i++ )
    {
//        printf( "%s\n", Vec_PtrEntry(vNames,i) );
        if ( !strcmp( (const char *)Vec_PtrEntry(vNames,i-1), (const char *)Vec_PtrEntry(vNames,i) ) )
        {
            printf( "Abc_NtkCheck: Repeated CO names: %s and %s.\n", (char*)Vec_PtrEntry(vNames,i-1), (char*)Vec_PtrEntry(vNames,i) );
            fRetValue = 0;
        }
    }
    Vec_PtrFree( vNames );
    return fRetValue;
}

Here is the call graph for this function:

◆ Abc_NtkCleanCopy()

ABC_DLL void Abc_NtkCleanCopy ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Cleans the copy field of all objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 540 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->pCopy = NULL;
}

◆ Abc_NtkCleanCopy_rec()

ABC_DLL void Abc_NtkCleanCopy_rec ( Abc_Ntk_t * pNtk )

extern

Definition at line 547 of file abcUtil.c.

{
    Abc_Obj_t * pObj; 
    int i;
    Abc_NtkCleanCopy( pNtk );
    Abc_NtkForEachBox( pNtk, pObj, i )
        Abc_NtkCleanCopy_rec( Abc_ObjModel(pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCleanData()

ABC_DLL void Abc_NtkCleanData ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Cleans the copy field of all objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 567 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->pData = NULL;
}

Here is the caller graph for this function:

◆ Abc_NtkCleanMarkA()

ABC_DLL void Abc_NtkCleanMarkA ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Cleans the copy field of all objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 696 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->fMarkA = 0;
}

Here is the caller graph for this function:

◆ Abc_NtkCleanMarkAB()

ABC_DLL void Abc_NtkCleanMarkAB ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Cleans the copy field of all objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 753 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->fMarkA = pObj->fMarkB = 0;
}

Here is the caller graph for this function:

◆ Abc_NtkCleanMarkABC()

ABC_DLL void Abc_NtkCleanMarkABC ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Cleans the copy field of all objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 772 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->fMarkA = pObj->fMarkB = pObj->fMarkC = 0;
}

Here is the caller graph for this function:

◆ Abc_NtkCleanMarkB()

ABC_DLL void Abc_NtkCleanMarkB ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Cleans the copy field of all objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 715 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->fMarkB = 0;
}

◆ Abc_NtkCleanMarkC()

ABC_DLL void Abc_NtkCleanMarkC ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Cleans the copy field of all objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 734 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->fMarkC = 0;
}

Here is the caller graph for this function:

◆ Abc_NtkCleanNames()

ABC_DLL void Abc_NtkCleanNames ( Abc_Ntk_t * pNtk )

extern

Definition at line 635 of file abcNames.c.

{  
    Abc_Obj_t * pObj; int i;
    Nm_Man_t * pManName = Nm_ManCreate( Abc_NtkCiNum(pNtk) + Abc_NtkCoNum(pNtk) + Abc_NtkBoxNum(pNtk) );
    Abc_NtkForEachCi( pNtk, pObj, i )
        Nm_ManStoreIdName( pManName, pObj->Id, pObj->Type, Abc_ObjName(pObj), NULL );
    Abc_NtkForEachCo( pNtk, pObj, i )
        Nm_ManStoreIdName( pManName, pObj->Id, pObj->Type, Abc_ObjName(pObj), NULL );
    Nm_ManFree( pNtk->pManName );
    pNtk->pManName = pManName;
}

Here is the call graph for this function:

◆ Abc_NtkCleanNext()

ABC_DLL void Abc_NtkCleanNext ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Cleans the copy field of all objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 669 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->pNext = NULL;
}

Here is the caller graph for this function:

◆ Abc_NtkCleanNext_rec()

ABC_DLL void Abc_NtkCleanNext_rec ( Abc_Ntk_t * pNtk )

extern

Definition at line 676 of file abcUtil.c.

{
    Abc_Obj_t * pObj; 
    int i;
    Abc_NtkCleanNext( pNtk );
    Abc_NtkForEachBox( pNtk, pObj, i )
        Abc_NtkCleanNext_rec( Abc_ObjModel(pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCleanup()

ABC_DLL int Abc_NtkCleanup	(	Abc_Ntk_t *	pNtk,
		int	fVerbose )

extern

Function*************************************************************

Synopsis [Removes dangling nodes.]

Description [Returns the number of nodes removed.]

SideEffects []

SeeAlso []

Definition at line 478 of file abcSweep.c.

{
    Vec_Ptr_t * vNodes;
    int Counter;
    assert( Abc_NtkIsLogic(pNtk) );
    // mark the nodes reachable from the POs
    vNodes = Abc_NtkDfs( pNtk, 0 );
    Counter = Abc_NtkReduceNodes( pNtk, vNodes );
    if ( fVerbose )
        printf( "Cleanup removed %d dangling nodes.\n", Counter );
    Vec_PtrFree( vNodes );
    return Counter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCleanupNodes()

ABC_DLL int Abc_NtkCleanupNodes	(	Abc_Ntk_t *	pNtk,
		Vec_Ptr_t *	vRoots,
		int	fVerbose )

extern

Function*************************************************************

Synopsis [Removes dangling nodes.]

Description [Returns the number of nodes removed.]

SideEffects []

SeeAlso []

Definition at line 503 of file abcSweep.c.

{
    Vec_Ptr_t * vNodes, * vStarts;
    Abc_Obj_t * pObj;
    int i, Counter;
    assert( Abc_NtkIsLogic(pNtk) );
    // collect starting nodes into one array
    vStarts = Vec_PtrAlloc( 1000 );
    Abc_NtkForEachCo( pNtk, pObj, i )
        Vec_PtrPush( vStarts, pObj );
    Vec_PtrForEachEntry( Abc_Obj_t *, vRoots, pObj, i )
        if ( pObj )
            Vec_PtrPush( vStarts, pObj );
    // mark the nodes reachable from the POs
    vNodes = Abc_NtkDfsNodes( pNtk, (Abc_Obj_t **)Vec_PtrArray(vStarts), Vec_PtrSize(vStarts) );
    Vec_PtrFree( vStarts );
    Counter = Abc_NtkReduceNodes( pNtk, vNodes );
    if ( fVerbose )
        printf( "Cleanup removed %d dangling nodes.\n", Counter );
    Vec_PtrFree( vNodes );
    return Counter;
}

Here is the call graph for this function:

◆ Abc_NtkCleanupSeq()

ABC_DLL int Abc_NtkCleanupSeq	(	Abc_Ntk_t *	pNtk,
		int	fLatchSweep,
		int	fAutoSweep,
		int	fVerbose )

extern

Function*************************************************************

Synopsis [Sequential cleanup.]

Description [Performs three tasks:

Removes logic that does not feed into POs.
Removes latches driven by constant values equal to the initial state.
Replaces the autonomous components by additional PI variables.]

SideEffects []

SeeAlso []

Definition at line 919 of file abcSweep.c.

{
    Vec_Ptr_t * vNodes;
    int Counter;
    assert( Abc_NtkIsLogic(pNtk) );
    // mark the nodes reachable from the POs
    vNodes = Abc_NtkDfsSeq( pNtk );
    Vec_PtrFree( vNodes );
    // remove the non-marked nodes
    Counter = Abc_NodeRemoveNonCurrentObjects( pNtk );
    if ( fVerbose )
        printf( "Cleanup removed %4d dangling objects.\n", Counter );
    // check if some of the latches can be removed
    if ( fLatchSweep )
    {
        Counter = Abc_NtkLatchSweep( pNtk );
        if ( fVerbose )
            printf( "Cleanup removed %4d redundant latches.\n", Counter );
    }
    // detect the autonomous components
    if ( fAutoSweep )
    {
        vNodes = Abc_NtkDfsSeqReverse( pNtk );
        Vec_PtrFree( vNodes );
        // replace them by PIs
        Counter = Abc_NtkReplaceAutonomousLogic( pNtk );
        if ( fVerbose )
            printf( "Cleanup added   %4d additional PIs.\n", Counter );
        // remove the non-marked nodes
        Counter = Abc_NodeRemoveNonCurrentObjects( pNtk );
        if ( fVerbose )
            printf( "Cleanup removed %4d autonomous objects.\n", Counter );
    }
    // check
    if ( !Abc_NtkCheck( pNtk ) )
        printf( "Abc_NtkCleanupSeq: The network check has failed.\n" );
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCloneObj()

ABC_DLL Abc_Obj_t * Abc_NtkCloneObj ( Abc_Obj_t * pObj )

extern

Function*************************************************************

Synopsis [Clones the objects in the same network but does not assign its function.]

Description []

SideEffects []

SeeAlso []

Definition at line 442 of file abcObj.c.

{
    Abc_Obj_t * pClone, * pFanin;
    int i;
    pClone = Abc_NtkCreateObj( pObj->pNtk, (Abc_ObjType_t)pObj->Type );   
    Abc_ObjForEachFanin( pObj, pFanin, i )
        Abc_ObjAddFanin( pClone, pFanin );
    return pClone;
}

Here is the call graph for this function:

◆ Abc_NtkClpGia()

ABC_DLL Gia_Man_t * Abc_NtkClpGia ( Abc_Ntk_t * pNtk )

extern

Definition at line 574 of file abcCollapse.c.

{
    int i, iLit;
    Gia_Man_t * pNew;
    Abc_Obj_t * pNode;
    assert( Abc_NtkIsStrash(pNtk) );
    pNew = Gia_ManStart( 1000 );
    pNew->pName = Abc_UtilStrsav( pNtk->pName );
    pNew->pSpec = Abc_UtilStrsav( pNtk->pSpec );
    Abc_NtkForEachObj( pNtk, pNode, i )
        pNode->iTemp = -1;
    Abc_AigConst1(pNtk)->iTemp = 1;
    Abc_NtkForEachCi( pNtk, pNode, i )
        pNode->iTemp = Gia_ManAppendCi(pNew);
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        iLit = Abc_NtkClpGia_rec( pNew, Abc_ObjFanin0(pNode) );
        iLit = Abc_LitNotCond( iLit, Abc_ObjFaninC0(pNode) );
        Gia_ManAppendCo( pNew, iLit );
    }
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCollapse()

ABC_DLL Abc_Ntk_t * Abc_NtkCollapse	(	Abc_Ntk_t *	pNtk,
		int	fBddSizeMax,
		int	fDualRail,
		int	fReorder,
		int	fReverse,
		int	fDumpOrder,
		int	fVerbose )

extern

DECLARATIONS ///.

CFile****************************************************************

FileName [abcCollapse.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Collapsing the network into two-levels.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: abcCollapse.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

]

Definition at line 250 of file abcCollapse.c.

{
    return NULL;
}

Here is the caller graph for this function:

◆ Abc_NtkCollapseSat()

ABC_DLL Abc_Ntk_t * Abc_NtkCollapseSat	(	Abc_Ntk_t *	pNtk,
		int	nCubeLim,
		int	nBTLimit,
		int	nCostMax,
		int	fCanon,
		int	fReverse,
		int	fCnfShared,
		int	fVerbose )

extern

Definition at line 943 of file abcCollapse.c.

{
    Abc_Ntk_t * pNtkNew;
    assert( Abc_NtkIsStrash(pNtk) );
    pNtkNew = Abc_NtkFromSopsInt( pNtk, nCubeLim, nBTLimit, nCostMax, fCanon, fReverse, fCnfShared, fVerbose );
    if ( pNtkNew == NULL )
        return NULL;
    if ( pNtk->pExdc )
        pNtkNew->pExdc = Abc_NtkDup( pNtk->pExdc );
    if ( !Abc_NtkCheck( pNtkNew ) )
    {
        printf( "Abc_NtkCollapseSat: The network check has failed.\n" );
        Abc_NtkDelete( pNtkNew );
        return NULL;
    }
    return pNtkNew;
}

Here is the call graph for this function:

◆ Abc_NtkCollectCioNames()

ABC_DLL char ** Abc_NtkCollectCioNames	(	Abc_Ntk_t *	pNtk,
		int	fCollectCos )

extern

Function*************************************************************

Synopsis [Collects the CI or CO names.]

Description []

SideEffects []

SeeAlso []

Definition at line 285 of file abcNames.c.

{
    Abc_Obj_t * pObj;
    char ** ppNames;
    int i;
    if ( fCollectCos )
    {
        ppNames = ABC_ALLOC( char *, Abc_NtkCoNum(pNtk) );
        Abc_NtkForEachCo( pNtk, pObj, i )
            ppNames[i] = Abc_ObjName(pObj);
    }
    else
    {
        ppNames = ABC_ALLOC( char *, Abc_NtkCiNum(pNtk) );
        Abc_NtkForEachCi( pNtk, pObj, i )
            ppNames[i] = Abc_ObjName(pObj);
    }
    return ppNames;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCollectLatches()

ABC_DLL Vec_Ptr_t * Abc_NtkCollectLatches ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Collects all latches in the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 1667 of file abcUtil.c.

{
    Vec_Ptr_t * vLatches;
    Abc_Obj_t * pObj;
    int i;
    vLatches = Vec_PtrAlloc( 10 );
    Abc_NtkForEachObj( pNtk, pObj, i )
        Vec_PtrPush( vLatches, pObj );
    return vLatches;
}

◆ Abc_NtkCollectLatchValues()

ABC_DLL Vec_Int_t * Abc_NtkCollectLatchValues ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Strashes one logic node using its SOP.]

Description []

SideEffects []

SeeAlso []

Definition at line 181 of file abcLatch.c.

{
    Vec_Int_t * vValues;
    Abc_Obj_t * pLatch;
    int i;
    vValues = Vec_IntAlloc( Abc_NtkLatchNum(pNtk) );
    Abc_NtkForEachLatch( pNtk, pLatch, i )
        Vec_IntPush( vValues, Abc_LatchIsInit1(pLatch) );
    return vValues;
}

Here is the caller graph for this function:

◆ Abc_NtkCollectLatchValuesStr()

ABC_DLL char * Abc_NtkCollectLatchValuesStr ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Derives latch init string.]

Description []

SideEffects []

SeeAlso []

Definition at line 203 of file abcLatch.c.

{
    char * pInits;
    Abc_Obj_t * pLatch;
    int i;
    pInits = ABC_ALLOC( char, Abc_NtkLatchNum(pNtk) + 1 );
    Abc_NtkForEachLatch( pNtk, pLatch, i )
    {
        if ( Abc_LatchIsInit0(pLatch) )
            pInits[i] = '0';
        else if ( Abc_LatchIsInit1(pLatch) )
            pInits[i] = '1';
        else if ( Abc_LatchIsInitDc(pLatch) )
            pInits[i] = 'x';
        else
            assert( 0 );
    }
    pInits[i] = 0;
    return pInits;
}

◆ Abc_NtkCollectObjects()

ABC_DLL Vec_Ptr_t * Abc_NtkCollectObjects ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Collects all objects into one array.]

Description []

SideEffects []

SeeAlso []

Definition at line 1765 of file abcUtil.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pNode;
    int i;
    vNodes = Vec_PtrAlloc( 100 );
    Abc_NtkForEachObj( pNtk, pNode, i )
        Vec_PtrPush( vNodes, pNode );
    return vNodes;
}

Here is the caller graph for this function:

◆ Abc_NtkCombinePos()

ABC_DLL int Abc_NtkCombinePos	(	Abc_Ntk_t *	pNtk,
		int	fAnd,
		int	fXor )

extern

Function*************************************************************

Synopsis [Computes OR or AND of the POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1155 of file abcMiter.c.

{
    Abc_Obj_t * pNode, * pMiter;
    int i;
    assert( Abc_NtkIsStrash(pNtk) );
//    assert( Abc_NtkLatchNum(pNtk) == 0 );
    if ( Abc_NtkPoNum(pNtk) == 1 )
        return 1;
    // start the result
    if ( fAnd )
        pMiter = Abc_AigConst1(pNtk);
    else
        pMiter = Abc_ObjNot( Abc_AigConst1(pNtk) );
    // perform operations on the POs
    Abc_NtkForEachPo( pNtk, pNode, i )
        if ( fAnd )
            pMiter = Abc_AigAnd( (Abc_Aig_t *)pNtk->pManFunc, pMiter, Abc_ObjChild0(pNode) );
        else if ( fXor )
            pMiter = Abc_AigXor( (Abc_Aig_t *)pNtk->pManFunc, pMiter, Abc_ObjChild0(pNode) );
        else
            pMiter = Abc_AigOr( (Abc_Aig_t *)pNtk->pManFunc, pMiter, Abc_ObjChild0(pNode) );
    // remove the POs and their names
    for ( i = Abc_NtkPoNum(pNtk) - 1; i >= 0; i-- )
        Abc_NtkDeleteObj( Abc_NtkPo(pNtk, i) );
    assert( Abc_NtkPoNum(pNtk) == 0 );
    // create the new PO
    pNode = Abc_NtkCreatePo( pNtk );
    Abc_ObjAddFanin( pNode, pMiter );
    Abc_ObjAssignName( pNode, "miter", NULL );
    Abc_NtkOrderCisCos( pNtk );
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkOrPos: The network check has failed.\n" );
        return 0;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCompareSignals()

ABC_DLL int Abc_NtkCompareSignals	(	Abc_Ntk_t *	pNtk1,
		Abc_Ntk_t *	pNtk2,
		int	fOnlyPis,
		int	fComb )

extern

Function*************************************************************

Synopsis [Compares the signals of the networks.]

Description []

SideEffects [Ordering POs by name is a very bad idea! It destroys the natural order of the logic in the circuit.]

SeeAlso []

Definition at line 749 of file abcCheck.c.

{
    Abc_NtkOrderObjsByName( pNtk1, fComb );
    Abc_NtkOrderObjsByName( pNtk2, fComb );
    if ( !Abc_NtkComparePis( pNtk1, pNtk2, fComb ) )
        return 0;
    if ( !fOnlyPis )
    {
        if ( !Abc_NtkCompareBoxes( pNtk1, pNtk2, fComb ) )
            return 0;
        if ( !Abc_NtkComparePos( pNtk1, pNtk2, fComb ) )
            return 0;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkConverLatchNamesIntoNumbers()

ABC_DLL Vec_Ptr_t * Abc_NtkConverLatchNamesIntoNumbers ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Transfors the array of latch names into that of latch numbers.]

Description []

SideEffects []

SeeAlso []

Definition at line 364 of file abcLatch.c.

{
    Vec_Ptr_t * vResult, * vNames;
    Vec_Int_t * vNumbers;
    Abc_Obj_t * pObj;
    char * pName;
    int i, k, Num;
    if ( pNtk->vOnehots == NULL )
        return NULL;
    // set register numbers
    Abc_NtkForEachLatch( pNtk, pObj, i )
        pObj->pNext = (Abc_Obj_t *)(ABC_PTRINT_T)i;
    // add the numbers
    vResult = Vec_PtrAlloc( Vec_PtrSize(pNtk->vOnehots) );
    Vec_PtrForEachEntry( Vec_Ptr_t *, pNtk->vOnehots, vNames, i )
    {
        vNumbers = Vec_IntAlloc( Vec_PtrSize(vNames) );
        Vec_PtrForEachEntry( char *, vNames, pName, k )
        {
            Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_BO );
            if ( Num < 0 )
                continue;
            pObj = Abc_NtkObj( pNtk, Num );
            if ( Abc_ObjFaninNum(pObj) != 1 || !Abc_ObjIsLatch(Abc_ObjFanin0(pObj)) )
                continue;
            Vec_IntPush( vNumbers, (int)(ABC_PTRINT_T)pObj->pNext );
        }
        if ( Vec_IntSize( vNumbers ) > 1 )
        {
            Vec_PtrPush( vResult, vNumbers );
printf( "Converted %d one-hot registers.\n", Vec_IntSize(vNumbers) );
        }
        else
            Vec_IntFree( vNumbers );
    }
    // clean the numbers
    Abc_NtkForEachLatch( pNtk, pObj, i )
        pObj->pNext = NULL;
    return vResult;
}

Here is the call graph for this function:

◆ Abc_NtkConvertBlackboxes()

ABC_DLL Abc_Ntk_t * Abc_NtkConvertBlackboxes ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Extracts blackboxes by making them into additional PIs/POs.]

Description [The input netlist has not logic hierarchy. The resulting netlist has additional PIs/POs for each blackbox input/output.]

SideEffects []

SeeAlso []

Definition at line 598 of file abcHie.c.

{
    Abc_Ntk_t * pNtkNew;
    Abc_Obj_t * pObj, * pNet, * pFanin, * pTerm;
    int i, k;
 
    assert( Abc_NtkIsNetlist(pNtk) );
    assert( Abc_NtkWhiteboxNum(pNtk) == 0 );
 
    // start the network
    pNtkNew = Abc_NtkAlloc( pNtk->ntkType, pNtk->ntkFunc, 1 );
    // duplicate the name and the spec
    pNtkNew->pName = Extra_UtilStrsav( pNtk->pName );
    pNtkNew->pSpec = Extra_UtilStrsav( pNtk->pSpec );
 
    // clean the node copy fields
    Abc_NtkCleanCopy( pNtk );
 
    // mark the nodes that should not be connected
    Abc_NtkIncrementTravId( pNtk );
    Abc_NtkForEachBlackbox( pNtk, pObj, i )
        Abc_NodeSetTravIdCurrent( pObj );
    Abc_NtkForEachCi( pNtk, pTerm, i )
        Abc_NodeSetTravIdCurrent( pTerm );
    Abc_NtkForEachCo( pNtk, pTerm, i )
        Abc_NodeSetTravIdCurrent( pTerm );
    // unmark PIs and LIs/LOs
    Abc_NtkForEachPi( pNtk, pTerm, i )
        Abc_NodeSetTravIdPrevious( pTerm );
    Abc_NtkForEachLatchInput( pNtk, pTerm, i )
        Abc_NodeSetTravIdPrevious( pTerm );
    Abc_NtkForEachLatchOutput( pNtk, pTerm, i )
        Abc_NodeSetTravIdPrevious( pTerm );
    // copy the box outputs
    Abc_NtkForEachBlackbox( pNtk, pObj, i )
        Abc_ObjForEachFanout( pObj, pTerm, k )
            pTerm->pCopy = Abc_NtkCreatePi( pNtkNew );
 
    // duplicate other objects
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( !Abc_NodeIsTravIdCurrent(pObj) )
            Abc_NtkDupObj( pNtkNew, pObj, Abc_ObjIsNet(pObj) );
 
    // connect all objects
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( !Abc_NodeIsTravIdCurrent(pObj) )
            Abc_ObjForEachFanin( pObj, pFanin, k )
                Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
 
    // create unique PO for each net feeding into blackboxes or POs
    Abc_NtkIncrementTravId( pNtk );
    Abc_NtkForEachCo( pNtk, pTerm, i )
    {
        // skip latch inputs
        assert( Abc_ObjFanoutNum(pTerm) <= 1 );
        if ( Abc_ObjFanoutNum(pTerm) > 0 && Abc_ObjIsLatch(Abc_ObjFanout0(pTerm)) )
            continue;
        // check if the net is visited
        pNet = Abc_ObjFanin0(pTerm);
        if ( Abc_NodeIsTravIdCurrent(pNet) )
            continue;
        // create PO
        Abc_NodeSetTravIdCurrent( pNet );
        Abc_ObjAddFanin( Abc_NtkCreatePo(pNtkNew), pNet->pCopy );
    }
 
    // check integrity
    if ( !Abc_NtkCheck( pNtkNew ) )
    {
        fprintf( stdout, "Abc_NtkConvertBlackboxes(): Network check has failed.\n" );
        Abc_NtkDelete( pNtkNew );
        return NULL;
    }
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkConvertDcLatches()

ABC_DLL void Abc_NtkConvertDcLatches ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Converts registers with DC values into additional PIs.]

Description []

SideEffects []

SeeAlso []

Definition at line 310 of file abcLatch.c.

{
    Abc_Obj_t * pCtrl, * pLatch, * pMux, * pPi;
    Abc_InitType_t Init = ABC_INIT_ZERO;
    int i, fFound = 0, Counter;
    // check if there are latches with DC values
    Abc_NtkForEachLatch( pNtk, pLatch, i )
        if ( Abc_LatchIsInitDc(pLatch) )
        {
            fFound = 1;
            break;
        }
    if ( !fFound )
        return;
    // add control latch
    pCtrl = Abc_NtkAddLatch( pNtk, Abc_NtkCreateNodeConst1(pNtk), Init );
    // add fanouts for each latch with DC values
    Counter = 0;
    Abc_NtkForEachLatch( pNtk, pLatch, i )
    {
        if ( !Abc_LatchIsInitDc(pLatch) )
            continue;
        // change latch value
        pLatch->pData = (void *)Init;
        // if the latch output has the same name as a PO, rename it
        if ( Abc_NodeFindCoFanout( Abc_ObjFanout0(pLatch) ) )
        {
            Nm_ManDeleteIdName( pLatch->pNtk->pManName, Abc_ObjFanout0(pLatch)->Id );
            Abc_ObjAssignName( Abc_ObjFanout0(pLatch), Abc_ObjName(pLatch), "_lo" );
        }
        // create new PIs
        pPi = Abc_NtkCreatePi( pNtk );
        Abc_ObjAssignName( pPi, Abc_ObjName(pLatch), "_pi" );
        // create a new node and transfer fanout from latch output to the new node
        pMux = Abc_NtkCreateNode( pNtk );
        Abc_ObjTransferFanout( Abc_ObjFanout0(pLatch), pMux );
        // convert the node into a mux
        Abc_NtkNodeConvertToMux( pNtk, pCtrl, Abc_ObjFanout0(pLatch), pPi, pMux );
        Counter++;
    }
    printf( "The number of converted latches with DC values = %d.\n", Counter );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkConvertToBlifMv()

ABC_DLL int Abc_NtkConvertToBlifMv ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Converts SOP netlist into BLIF-MV netlist.]

Description []

SideEffects []

SeeAlso []

Definition at line 957 of file abcBlifMv.c.

{
#ifdef ABC_USE_CUDD
    Mem_Flex_t * pMmFlex;
    Abc_Obj_t * pNode;
    Vec_Str_t * vCube;
    char * pSop0, * pSop1, * pBlifMv, * pCube, * pCur;
    int Value, nCubes, nSize, i, k;
 
    assert( Abc_NtkIsNetlist(pNtk) );
    if ( !Abc_NtkToBdd(pNtk) )
    {
        printf( "Converting logic functions to BDDs has failed.\n" );
        return 0;
    }
 
    pMmFlex = Mem_FlexStart();
    vCube   = Vec_StrAlloc( 100 );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        // convert BDD into cubes for on-set and off-set
        Abc_NodeBddToCnf( pNode, pMmFlex, vCube, 0, &pSop0, &pSop1 );
        // allocate room for the MV-SOP
        nCubes = Abc_SopGetCubeNum(pSop0) + Abc_SopGetCubeNum(pSop1);
        nSize = nCubes*(2*Abc_ObjFaninNum(pNode) + 2)+1;
        pBlifMv = Mem_FlexEntryFetch( pMmFlex, nSize );
        // add the cubes
        pCur = pBlifMv;
        Abc_SopForEachCube( pSop0, Abc_ObjFaninNum(pNode), pCube )
        {
            Abc_CubeForEachVar( pCube, Value, k )
            {
                *pCur++ = Value;
                *pCur++ = ' ';
            }
            *pCur++ = '0';
            *pCur++ = '\n';
        }
        Abc_SopForEachCube( pSop1, Abc_ObjFaninNum(pNode), pCube )
        {
            Abc_CubeForEachVar( pCube, Value, k )
            {
                *pCur++ = Value;
                *pCur++ = ' ';
            }
            *pCur++ = '1';
            *pCur++ = '\n';
        }
        *pCur++ = 0;
        assert( pCur - pBlifMv == nSize );
        // update the node representation
        Cudd_RecursiveDeref( (DdManager *)pNtk->pManFunc, (DdNode *)pNode->pData );
        pNode->pData = pBlifMv;
    }
 
    // update the functionality type
    pNtk->ntkFunc = ABC_FUNC_BLIFMV;
    Cudd_Quit( (DdManager *)pNtk->pManFunc );
    pNtk->pManFunc = pMmFlex;
 
    Vec_StrFree( vCube );
#endif
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCountCopy()

ABC_DLL int Abc_NtkCountCopy ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Counts the number of nodes having non-trivial copies.]

Description []

SideEffects []

SeeAlso []

Definition at line 605 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i, Counter = 0;
    Abc_NtkForEachObj( pNtk, pObj, i )
    {
        if ( Abc_ObjIsNode(pObj) )
            Counter += (pObj->pCopy != NULL);
    }
    return Counter;
}

Here is the caller graph for this function:

◆ Abc_NtkCountSelfFeedLatches()

ABC_DLL int Abc_NtkCountSelfFeedLatches ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Checks if latches form self-loop.]

Description []

SideEffects []

SeeAlso []

Definition at line 92 of file abcLatch.c.

{
    Abc_Obj_t * pLatch;
    int i, Counter;
    Counter = 0;
    Abc_NtkForEachLatch( pNtk, pLatch, i )
    {
//        if ( Abc_NtkLatchIsSelfFeed(pLatch) && Abc_ObjFanoutNum(pLatch) > 1 )
//            printf( "Fanouts = %d.\n", Abc_ObjFanoutNum(pLatch) );
        Counter += Abc_NtkLatchIsSelfFeed( pLatch );
    }
    return Counter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateCone()

ABC_DLL Abc_Ntk_t * Abc_NtkCreateCone	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t *	pNode,
		char *	pNodeName,
		int	fUseAllCis )

extern

Function*************************************************************

Synopsis [Creates the network composed of one logic cone.]

Description []

SideEffects []

SeeAlso []

Definition at line 925 of file abcNtk.c.

{
    Abc_Ntk_t * pNtkNew; 
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj, * pFanin, * pNodeCoNew;
    char Buffer[1000];
    int i, k;
 
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsStrash(pNtk) );
    assert( Abc_ObjIsNode(pNode) || (Abc_NtkIsStrash(pNtk) && (Abc_AigNodeIsConst(pNode) || Abc_ObjIsCi(pNode)))  ); 
    
    // start the network
    pNtkNew = Abc_NtkAlloc( pNtk->ntkType, pNtk->ntkFunc, 1 );
    // set the name
    sprintf( Buffer, "%s_%s", pNtk->pName, pNodeName );
    pNtkNew->pName = Extra_UtilStrsav(Buffer);
 
    // establish connection between the constant nodes
    if ( Abc_NtkIsStrash(pNtk) )
        Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkNew);
 
    // collect the nodes in the TFI of the output (mark the TFI)
    vNodes = Abc_NtkDfsNodes( pNtk, &pNode, 1 );
    // create the PIs
    Abc_NtkForEachCi( pNtk, pObj, i )
    {
        if ( fUseAllCis || Abc_NodeIsTravIdCurrent(pObj) ) // TravId is set by DFS
        {
            pObj->pCopy = Abc_NtkCreatePi(pNtkNew);
            Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(pObj), NULL );
        }
    }
    // add the PO corresponding to this output
    pNodeCoNew = Abc_NtkCreatePo( pNtkNew );
    Abc_ObjAssignName( pNodeCoNew, pNodeName, NULL );
    // copy the nodes
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
    {
        // if it is an AIG, add to the hash table
        if ( Abc_NtkIsStrash(pNtk) )
        {
            pObj->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkNew->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
        }
        else
        {
            Abc_NtkDupObj( pNtkNew, pObj, 0 );
            Abc_ObjForEachFanin( pObj, pFanin, k )
                Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
        }
    }
    // connect the internal nodes to the new CO
    Abc_ObjAddFanin( pNodeCoNew, pNode->pCopy );
    Vec_PtrFree( vNodes );
 
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkCreateCone(): Network check has failed.\n" );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateConeArray()

ABC_DLL Abc_Ntk_t * Abc_NtkCreateConeArray	(	Abc_Ntk_t *	pNtk,
		Vec_Ptr_t *	vRoots,
		int	fUseAllCis )

extern

Function*************************************************************

Synopsis [Creates the network composed of several logic cones.]

Description []

SideEffects []

SeeAlso []

Definition at line 995 of file abcNtk.c.

{
    Abc_Ntk_t * pNtkNew; 
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj, * pFanin, * pNodeCoNew;
    char Buffer[1000];
    int i, k;
 
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsStrash(pNtk) );
    
    // start the network
    pNtkNew = Abc_NtkAlloc( pNtk->ntkType, pNtk->ntkFunc, 1 );
    // set the name
    sprintf( Buffer, "%s_part", pNtk->pName );
    pNtkNew->pName = Extra_UtilStrsav(Buffer);
 
    // establish connection between the constant nodes
    if ( Abc_NtkIsStrash(pNtk) )
        Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkNew);
 
    // collect the nodes in the TFI of the output (mark the TFI)
    vNodes = Abc_NtkDfsNodes( pNtk, (Abc_Obj_t **)Vec_PtrArray(vRoots), Vec_PtrSize(vRoots) );
 
    // create the PIs
    Abc_NtkForEachCi( pNtk, pObj, i )
    {
        if ( fUseAllCis || Abc_NodeIsTravIdCurrent(pObj) ) // TravId is set by DFS
        {
            pObj->pCopy = Abc_NtkCreatePi(pNtkNew);
            Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(pObj), NULL );
        }
    }
 
    // copy the nodes
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
    {
        // if it is an AIG, add to the hash table
        if ( Abc_NtkIsStrash(pNtk) )
        {
            pObj->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkNew->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
        }
        else
        {
            Abc_NtkDupObj( pNtkNew, pObj, 0 );
            Abc_ObjForEachFanin( pObj, pFanin, k )
                Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
        }
    }
    Vec_PtrFree( vNodes );
 
    // add the POs corresponding to the root nodes
    Vec_PtrForEachEntry( Abc_Obj_t *, vRoots, pObj, i )
    {
        // create the PO node
        pNodeCoNew = Abc_NtkCreatePo( pNtkNew );
        // connect the internal nodes to the new CO
        if ( Abc_ObjIsCo(pObj) )
            Abc_ObjAddFanin( pNodeCoNew, Abc_ObjChild0Copy(pObj) );
        else
            Abc_ObjAddFanin( pNodeCoNew, pObj->pCopy );
        // assign the name
        Abc_ObjAssignName( pNodeCoNew, Abc_ObjName(pObj), NULL );
    }
 
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkCreateConeArray(): Network check has failed.\n" );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateFromGias()

ABC_DLL Abc_Ntk_t * Abc_NtkCreateFromGias	(	char *	pName,
		Vec_Ptr_t *	vGias,
		Gia_Man_t *	pMulti )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2550 of file abcNtk.c.

{
    Gia_Man_t * pGia = pMulti ? pMulti : (Gia_Man_t *)Vec_PtrEntry(vGias, 0);
    Abc_Ntk_t * pNtk = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    Abc_Obj_t * pAbcObj, * pAbcObjPo;
    Gia_Obj_t * pObj; int i, k;
    pNtk->pName = Extra_UtilStrsav( pName );
    for ( k = 0; k < Gia_ManCiNum(pGia); k++ )
        Abc_NtkCreatePi( pNtk );
    if ( pMulti )
    {
        Gia_ManCleanValue(pGia);
        Gia_ManForEachCi( pGia, pObj, k )
            pObj->Value = Abc_ObjId( Abc_NtkCi(pNtk, k) );
        Gia_ManForEachAnd( pGia, pObj, k )
        {
            Abc_Obj_t * pAbcObj0 = Abc_NtkObj( pNtk, Gia_ObjFanin0(pObj)->Value );
            Abc_Obj_t * pAbcObj1 = Abc_NtkObj( pNtk, Gia_ObjFanin1(pObj)->Value );
            pAbcObj0 = Abc_ObjNotCond( pAbcObj0, Gia_ObjFaninC0(pObj) );
            pAbcObj1 = Abc_ObjNotCond( pAbcObj1, Gia_ObjFaninC1(pObj) );
            pAbcObj  = Abc_AigAnd( (Abc_Aig_t *)pNtk->pManFunc, pAbcObj0, pAbcObj1 );
            pObj->Value = Abc_ObjId( pAbcObj ); 
        }
        Gia_ManForEachCo( pGia, pObj, k )
        {
            //pObj = Gia_ManCo(pGia, 0);
            if ( Gia_ObjFaninId0p(pGia, pObj) == 0 )
                pAbcObj = Abc_ObjNot( Abc_AigConst1(pNtk) );
            else
                pAbcObj = Abc_NtkObj( pNtk, Gia_ObjFanin0(pObj)->Value );
            pAbcObj = Abc_ObjNotCond( pAbcObj, Gia_ObjFaninC0(pObj) );
            pAbcObjPo = Abc_NtkCreatePo( pNtk );
            Abc_ObjAddFanin( pAbcObjPo, pAbcObj );
        }
    }
    else
    {
    Vec_PtrForEachEntry( Gia_Man_t *, vGias, pGia, i )
    {
        assert( Gia_ManCoNum(pGia) == 1 );
        Gia_ManCleanValue(pGia);
        Gia_ManForEachCi( pGia, pObj, k )
            pObj->Value = Abc_ObjId( Abc_NtkCi(pNtk, k) );
        Gia_ManForEachAnd( pGia, pObj, k )
        {
            Abc_Obj_t * pAbcObj0 = Abc_NtkObj( pNtk, Gia_ObjFanin0(pObj)->Value );
            Abc_Obj_t * pAbcObj1 = Abc_NtkObj( pNtk, Gia_ObjFanin1(pObj)->Value );
            pAbcObj0 = Abc_ObjNotCond( pAbcObj0, Gia_ObjFaninC0(pObj) );
            pAbcObj1 = Abc_ObjNotCond( pAbcObj1, Gia_ObjFaninC1(pObj) );
            pAbcObj  = Abc_AigAnd( (Abc_Aig_t *)pNtk->pManFunc, pAbcObj0, pAbcObj1 );
            pObj->Value = Abc_ObjId( pAbcObj ); 
        }
        pObj = Gia_ManCo(pGia, 0);
        if ( Gia_ObjFaninId0p(pGia, pObj) == 0 )
            pAbcObj = Abc_ObjNot( Abc_AigConst1(pNtk) );
        else
            pAbcObj = Abc_NtkObj( pNtk, Gia_ObjFanin0(pObj)->Value );
        pAbcObj = Abc_ObjNotCond( pAbcObj, Gia_ObjFaninC0(pObj) );
        pAbcObjPo = Abc_NtkCreatePo( pNtk );
        Abc_ObjAddFanin( pAbcObjPo, pAbcObj );
    }
    }
    Abc_NtkAddDummyPiNames( pNtk );
    Abc_NtkAddDummyPoNames( pNtk );
    return pNtk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateFromNode()

ABC_DLL Abc_Ntk_t * Abc_NtkCreateFromNode	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t *	pNode )

extern

Function*************************************************************

Synopsis [Creates the network composed of one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1260 of file abcNtk.c.

{    
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pFanin, * pNodePo;
    int i;
    // start the network
    pNtkNew = Abc_NtkAlloc( pNtk->ntkType, pNtk->ntkFunc, 1 );
    pNtkNew->pName = Extra_UtilStrsav(Abc_ObjName(pNode));
    // add the PIs corresponding to the fanins of the node
    Abc_ObjForEachFanin( pNode, pFanin, i )
    {
        pFanin->pCopy = Abc_NtkCreatePi( pNtkNew );
        Abc_ObjAssignName( pFanin->pCopy, Abc_ObjName(pFanin), NULL );
    }
    // duplicate and connect the node
    pNode->pCopy = Abc_NtkDupObj( pNtkNew, pNode, 0 );
    Abc_ObjForEachFanin( pNode, pFanin, i )
        Abc_ObjAddFanin( pNode->pCopy, pFanin->pCopy );
    // create the only PO
    pNodePo = Abc_NtkCreatePo( pNtkNew );
    Abc_ObjAddFanin( pNodePo, pNode->pCopy );
    Abc_ObjAssignName( pNodePo, Abc_ObjName(pNode), NULL );
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkCreateFromNode(): Network check has failed.\n" );
    return pNtkNew;
}

Here is the call graph for this function:

◆ Abc_NtkCreateFromRange()

ABC_DLL Abc_Ntk_t * Abc_NtkCreateFromRange ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Creates the network composed of one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1298 of file abcNtk.c.

{    
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pObj, * pNodeNew, * pNodePo;
    Gia_Man_t * p = Abc_NtkClpGia( pNtk );  int i;
    Vec_Str_t * vStr = Gia_ManComputeRange( p );
    Gia_ManStop( p );
    pNtkNew = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_SOP, 1 );
    pNtkNew->pName = Extra_UtilStrsav("range");
    Abc_NtkForEachCo( pNtk, pObj, i )
        Abc_ObjAssignName( Abc_NtkCreatePi(pNtkNew), Abc_ObjName(pObj), NULL );
    pNodeNew = Abc_NtkCreateObj( pNtkNew, ABC_OBJ_NODE );
    pNodeNew->pData = Abc_SopRegister( (Mem_Flex_t *)pNtkNew->pManFunc, Vec_StrArray(vStr) );
    Vec_StrFree( vStr );
    Abc_NtkForEachCi( pNtkNew, pObj, i )
        Abc_ObjAddFanin( pNodeNew, pObj );
    pNodePo = Abc_NtkCreatePo( pNtkNew );
    Abc_ObjAddFanin( pNodePo, pNodeNew );
    Abc_ObjAssignName( pNodePo, "range", NULL );
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkCreateFromNode(): Network check has failed.\n" );
    return pNtkNew;
}

Here is the call graph for this function:

◆ Abc_NtkCreateFromSops()

ABC_DLL Abc_Ntk_t * Abc_NtkCreateFromSops	(	char *	pName,
		Vec_Ptr_t *	vSops )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2512 of file abcNtk.c.

{
    int i, k, nObjBeg;
    char * pSop = (char *)Vec_PtrEntry(vSops, 0);
    Abc_Ntk_t * pNtk = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_SOP, 1 );
    pNtk->pName = Extra_UtilStrsav( pName );
    for ( k = 0; pSop[k] != ' '; k++ )
        Abc_NtkCreatePi( pNtk );
    nObjBeg = Abc_NtkObjNumMax(pNtk);
    Vec_PtrForEachEntry( char *, vSops, pSop, i )
    {
        Abc_Obj_t * pObj = Abc_NtkCreateNode( pNtk );
        pObj->pData = Abc_SopRegister( (Mem_Flex_t*)pNtk->pManFunc, pSop );
        for ( k = 0; pSop[k] != ' '; k++ )
            Abc_ObjAddFanin( pObj, Abc_NtkCi(pNtk, k) );
    }
    for ( i = 0; i < Vec_PtrSize(vSops); i++ )
    {
        Abc_Obj_t * pObj = Abc_NtkObj( pNtk, nObjBeg + i );
        Abc_Obj_t * pObjPo = Abc_NtkCreatePo( pNtk );
        Abc_ObjAddFanin( pObjPo, pObj );
    }
    Abc_NtkAddDummyPiNames( pNtk );
    Abc_NtkAddDummyPoNames( pNtk );
    return pNtk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateMffc()

ABC_DLL Abc_Ntk_t * Abc_NtkCreateMffc	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t *	pNode,
		char *	pNodeName )

extern

Function*************************************************************

Synopsis [Creates the network composed of MFFC of one node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1128 of file abcNtk.c.

{
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pObj, * pFanin, * pNodeCoNew;
    Vec_Ptr_t * vCone, * vSupp;
    char Buffer[1000];
    int i, k;
 
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsStrash(pNtk) );
    assert( Abc_ObjIsNode(pNode) ); 
    
    // start the network
    pNtkNew = Abc_NtkAlloc( pNtk->ntkType, pNtk->ntkFunc, 1 );
    // set the name
    sprintf( Buffer, "%s_%s", pNtk->pName, pNodeName );
    pNtkNew->pName = Extra_UtilStrsav(Buffer);
 
    // establish connection between the constant nodes
    if ( Abc_NtkIsStrash(pNtk) )
        Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkNew);
 
    // collect the nodes in MFFC
    vCone = Vec_PtrAlloc( 100 );
    vSupp = Vec_PtrAlloc( 100 );
    Abc_NodeDeref_rec( pNode );
    Abc_NodeMffcConeSupp( pNode, vCone, vSupp );
    Abc_NodeRef_rec( pNode );
    // create the PIs
    Vec_PtrForEachEntry( Abc_Obj_t *, vSupp, pObj, i )
    {
        pObj->pCopy = Abc_NtkCreatePi(pNtkNew);
        Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(pObj), NULL );
    }
    // create the PO
    pNodeCoNew = Abc_NtkCreatePo( pNtkNew );
    Abc_ObjAssignName( pNodeCoNew, pNodeName, NULL );
    // copy the nodes
    Vec_PtrForEachEntry( Abc_Obj_t *, vCone, pObj, i )
    {
        // if it is an AIG, add to the hash table
        if ( Abc_NtkIsStrash(pNtk) )
        {
            pObj->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkNew->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
        }
        else
        {
            Abc_NtkDupObj( pNtkNew, pObj, 0 );
            Abc_ObjForEachFanin( pObj, pFanin, k )
                Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
        }
    }
    // connect the topmost node
    Abc_ObjAddFanin( pNodeCoNew, pNode->pCopy );
    Vec_PtrFree( vCone );
    Vec_PtrFree( vSupp );
 
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkCreateMffc(): Network check has failed.\n" );
    return pNtkNew;
}

Here is the call graph for this function:

◆ Abc_NtkCreateNodeAnd()

ABC_DLL Abc_Obj_t * Abc_NtkCreateNodeAnd	(	Abc_Ntk_t *	pNtk,
		Vec_Ptr_t *	vFanins )

extern

Function*************************************************************

Synopsis [Creates AND.]

Description []

SideEffects []

SeeAlso []

Definition at line 738 of file abcObj.c.

{
    Abc_Obj_t * pNode;
    int i;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
    pNode = Abc_NtkCreateNode( pNtk );   
    for ( i = 0; i < vFanins->nSize; i++ )
        Abc_ObjAddFanin( pNode, (Abc_Obj_t *)vFanins->pArray[i] );
    if ( Abc_NtkHasSop(pNtk) )
        pNode->pData = Abc_SopCreateAnd( (Mem_Flex_t *)pNtk->pManFunc, Vec_PtrSize(vFanins), NULL );
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNtk) )
        pNode->pData = Extra_bddCreateAnd( (DdManager *)pNtk->pManFunc, Vec_PtrSize(vFanins) ), Cudd_Ref((DdNode *)pNode->pData); 
#endif
    else if ( Abc_NtkHasAig(pNtk) )
        pNode->pData = Hop_CreateAnd( (Hop_Man_t *)pNtk->pManFunc, Vec_PtrSize(vFanins) ); 
    else
        assert( 0 );
    return pNode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateNodeBuf()

ABC_DLL Abc_Obj_t * Abc_NtkCreateNodeBuf	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t *	pFanin )

extern

Function*************************************************************

Synopsis [Creates buffer.]

Description []

SideEffects []

SeeAlso []

Definition at line 706 of file abcObj.c.

{
    Abc_Obj_t * pNode;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
    pNode = Abc_NtkCreateNode( pNtk ); 
    if ( pFanin ) Abc_ObjAddFanin( pNode, pFanin );
    if ( Abc_NtkHasSop(pNtk) )
        pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, "1 1\n" );
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNtk) )
        pNode->pData = Cudd_bddIthVar((DdManager *)pNtk->pManFunc,0), Cudd_Ref( (DdNode *)pNode->pData );
#endif
    else if ( Abc_NtkHasAig(pNtk) )
        pNode->pData = Hop_IthVar((Hop_Man_t *)pNtk->pManFunc,0);
    else if ( Abc_NtkHasMapping(pNtk) )
        pNode->pData = Mio_LibraryReadBuf((Mio_Library_t *)Abc_FrameReadLibGen());
    else
        assert( 0 );
    return pNode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateNodeConst0()

ABC_DLL Abc_Obj_t * Abc_NtkCreateNodeConst0 ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Creates constant 0 node.]

Description []

SideEffects []

SeeAlso []

Definition at line 612 of file abcObj.c.

{
    Abc_Obj_t * pNode;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
    pNode = Abc_NtkCreateNode( pNtk );   
    if ( Abc_NtkHasSop(pNtk) || Abc_NtkHasBlifMv(pNtk) )
        pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, " 0\n" );
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNtk) )
        pNode->pData = Cudd_ReadLogicZero((DdManager *)pNtk->pManFunc), Cudd_Ref( (DdNode *)pNode->pData );
#endif
    else if ( Abc_NtkHasAig(pNtk) )
        pNode->pData = Hop_ManConst0((Hop_Man_t *)pNtk->pManFunc);
    else if ( Abc_NtkHasMapping(pNtk) )
        pNode->pData = Mio_LibraryReadConst0((Mio_Library_t *)Abc_FrameReadLibGen());
    else if ( !Abc_NtkHasBlackbox(pNtk) )
        assert( 0 );
    return pNode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateNodeConst1()

ABC_DLL Abc_Obj_t * Abc_NtkCreateNodeConst1 ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Creates constant 1 node.]

Description []

SideEffects []

SeeAlso []

Definition at line 643 of file abcObj.c.

{
    Abc_Obj_t * pNode;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
    pNode = Abc_NtkCreateNode( pNtk );   
    if ( Abc_NtkHasSop(pNtk) || Abc_NtkHasBlifMv(pNtk) )
        pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, " 1\n" );
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNtk) )
        pNode->pData = Cudd_ReadOne((DdManager *)pNtk->pManFunc), Cudd_Ref( (DdNode *)pNode->pData );
#endif
    else if ( Abc_NtkHasAig(pNtk) )
        pNode->pData = Hop_ManConst1((Hop_Man_t *)pNtk->pManFunc);
    else if ( Abc_NtkHasMapping(pNtk) )
        pNode->pData = Mio_LibraryReadConst1((Mio_Library_t *)Abc_FrameReadLibGen());
    else if ( !Abc_NtkHasBlackbox(pNtk) )
        assert( 0 );
    return pNode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateNodeExor()

ABC_DLL Abc_Obj_t * Abc_NtkCreateNodeExor	(	Abc_Ntk_t *	pNtk,
		Vec_Ptr_t *	vFanins )

extern

Function*************************************************************

Synopsis [Creates EXOR.]

Description []

SideEffects []

SeeAlso []

Definition at line 802 of file abcObj.c.

{
    Abc_Obj_t * pNode;
    int i;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
    pNode = Abc_NtkCreateNode( pNtk );   
    for ( i = 0; i < vFanins->nSize; i++ )
        Abc_ObjAddFanin( pNode, (Abc_Obj_t *)vFanins->pArray[i] );
    if ( Abc_NtkHasSop(pNtk) )
        pNode->pData = Abc_SopCreateXorSpecial( (Mem_Flex_t *)pNtk->pManFunc, Vec_PtrSize(vFanins) );
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNtk) )
        pNode->pData = Extra_bddCreateExor( (DdManager *)pNtk->pManFunc, Vec_PtrSize(vFanins) ), Cudd_Ref((DdNode *)pNode->pData); 
#endif
    else if ( Abc_NtkHasAig(pNtk) )
        pNode->pData = Hop_CreateExor( (Hop_Man_t *)pNtk->pManFunc, Vec_PtrSize(vFanins) ); 
    else
        assert( 0 );
    return pNode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateNodeInv()

ABC_DLL Abc_Obj_t * Abc_NtkCreateNodeInv	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t *	pFanin )

extern

Function*************************************************************

Synopsis [Creates inverter.]

Description []

SideEffects []

SeeAlso []

Definition at line 674 of file abcObj.c.

{
    Abc_Obj_t * pNode;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
    pNode = Abc_NtkCreateNode( pNtk );   
    if ( pFanin ) Abc_ObjAddFanin( pNode, pFanin );
    if ( Abc_NtkHasSop(pNtk) )
        pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, "0 1\n" );
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNtk) )
        pNode->pData = Cudd_Not(Cudd_bddIthVar((DdManager *)pNtk->pManFunc,0)), Cudd_Ref( (DdNode *)pNode->pData );
#endif
    else if ( Abc_NtkHasAig(pNtk) )
        pNode->pData = Hop_Not(Hop_IthVar((Hop_Man_t *)pNtk->pManFunc,0));
    else if ( Abc_NtkHasMapping(pNtk) )
        pNode->pData = Mio_LibraryReadInv((Mio_Library_t *)Abc_FrameReadLibGen());
    else
        assert( 0 );
    return pNode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateNodeMux()

ABC_DLL Abc_Obj_t * Abc_NtkCreateNodeMux	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t *	pNodeC,
		Abc_Obj_t *	pNode1,
		Abc_Obj_t *	pNode0 )

extern

Function*************************************************************

Synopsis [Creates MUX.]

Description []

SideEffects []

SeeAlso []

Definition at line 834 of file abcObj.c.

{
    Abc_Obj_t * pNode;
    assert( Abc_NtkIsLogic(pNtk) );
    pNode = Abc_NtkCreateNode( pNtk );   
    Abc_ObjAddFanin( pNode, pNodeC );
    Abc_ObjAddFanin( pNode, pNode1 );
    Abc_ObjAddFanin( pNode, pNode0 );
    if ( Abc_NtkHasSop(pNtk) )
        pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, "11- 1\n0-1 1\n" );
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNtk) )
        pNode->pData = Cudd_bddIte((DdManager *)pNtk->pManFunc,Cudd_bddIthVar((DdManager *)pNtk->pManFunc,0),Cudd_bddIthVar((DdManager *)pNtk->pManFunc,1),Cudd_bddIthVar((DdManager *)pNtk->pManFunc,2)), Cudd_Ref( (DdNode *)pNode->pData );
#endif
    else if ( Abc_NtkHasAig(pNtk) )
        pNode->pData = Hop_Mux((Hop_Man_t *)pNtk->pManFunc,Hop_IthVar((Hop_Man_t *)pNtk->pManFunc,0),Hop_IthVar((Hop_Man_t *)pNtk->pManFunc,1),Hop_IthVar((Hop_Man_t *)pNtk->pManFunc,2));
    else
        assert( 0 );
    return pNode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateNodeOr()

ABC_DLL Abc_Obj_t * Abc_NtkCreateNodeOr	(	Abc_Ntk_t *	pNtk,
		Vec_Ptr_t *	vFanins )

extern

Function*************************************************************

Synopsis [Creates OR.]

Description []

SideEffects []

SeeAlso []

Definition at line 770 of file abcObj.c.

{
    Abc_Obj_t * pNode;
    int i;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
    pNode = Abc_NtkCreateNode( pNtk );   
    for ( i = 0; i < vFanins->nSize; i++ )
        Abc_ObjAddFanin( pNode, (Abc_Obj_t *)vFanins->pArray[i] );
    if ( Abc_NtkHasSop(pNtk) )
        pNode->pData = Abc_SopCreateOr( (Mem_Flex_t *)pNtk->pManFunc, Vec_PtrSize(vFanins), NULL );
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNtk) )
        pNode->pData = Extra_bddCreateOr( (DdManager *)pNtk->pManFunc, Vec_PtrSize(vFanins) ), Cudd_Ref((DdNode *)pNode->pData); 
#endif
    else if ( Abc_NtkHasAig(pNtk) )
        pNode->pData = Hop_CreateOr( (Hop_Man_t *)pNtk->pManFunc, Vec_PtrSize(vFanins) ); 
    else
        assert( 0 );
    return pNode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateObj()

ABC_DLL Abc_Obj_t * Abc_NtkCreateObj	(	Abc_Ntk_t *	pNtk,
		Abc_ObjType_t	Type )

extern

Function*************************************************************

Synopsis [Adds the node to the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 109 of file abcObj.c.

{
    Abc_Obj_t * pObj;
    // create new object, assign ID, and add to the array
    pObj = Abc_ObjAlloc( pNtk, Type );
    pObj->Id = pNtk->vObjs->nSize;
    Vec_PtrPush( pNtk->vObjs, pObj );
    pNtk->nObjCounts[Type]++;
    pNtk->nObjs++;
    // perform specialized operations depending on the object type
    switch (Type)
    {
        case ABC_OBJ_NONE:   
            assert(0); 
            break;
        case ABC_OBJ_CONST1: 
            assert(0); 
            break;
        case ABC_OBJ_PI:
//            pObj->iTemp = Vec_PtrSize(pNtk->vCis);
            Vec_PtrPush( pNtk->vPis, pObj );
            Vec_PtrPush( pNtk->vCis, pObj );
            break;
        case ABC_OBJ_PO:     
//            pObj->iTemp = Vec_PtrSize(pNtk->vCos);
            Vec_PtrPush( pNtk->vPos, pObj );
            Vec_PtrPush( pNtk->vCos, pObj );
            break;
        case ABC_OBJ_BI:     
            if ( pNtk->vCos ) Vec_PtrPush( pNtk->vCos, pObj );
            break;
        case ABC_OBJ_BO:     
            if ( pNtk->vCis ) Vec_PtrPush( pNtk->vCis, pObj );
            break;
        case ABC_OBJ_NET:  
        case ABC_OBJ_NODE: 
            break;
        case ABC_OBJ_LATCH:     
            pObj->pData = (void *)ABC_INIT_NONE;
        case ABC_OBJ_WHITEBOX:     
        case ABC_OBJ_BLACKBOX:     
            if ( pNtk->vBoxes ) Vec_PtrPush( pNtk->vBoxes, pObj );
            break;
        default:
            assert(0); 
            break;
    }
    return pObj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateTarget()

ABC_DLL Abc_Ntk_t * Abc_NtkCreateTarget	(	Abc_Ntk_t *	pNtk,
		Vec_Ptr_t *	vRoots,
		Vec_Int_t *	vValues )

extern

Function*************************************************************

Synopsis [Creates the miter composed of one multi-output cone.]

Description []

SideEffects []

SeeAlso []

Definition at line 1200 of file abcNtk.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pObj, * pFinal, * pOther, * pNodePo;
    int i;
 
    assert( Abc_NtkIsLogic(pNtk) );
    
    // start the network
    Abc_NtkCleanCopy( pNtk );
    pNtkNew = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    pNtkNew->pName = Extra_UtilStrsav(pNtk->pName);
 
    // collect the nodes in the TFI of the output
    vNodes = Abc_NtkDfsNodes( pNtk, (Abc_Obj_t **)vRoots->pArray, vRoots->nSize );
    // create the PIs
    Abc_NtkForEachCi( pNtk, pObj, i )
    {
        pObj->pCopy = Abc_NtkCreatePi(pNtkNew);
        Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(pObj), NULL );
    }
    // copy the nodes
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
        pObj->pCopy = Abc_NodeStrash( pNtkNew, pObj, 0 );
    Vec_PtrFree( vNodes );
 
    // add the PO
    pFinal = Abc_AigConst1( pNtkNew );
    Vec_PtrForEachEntry( Abc_Obj_t *, vRoots, pObj, i )
    {
        if ( Abc_ObjIsCo(pObj) )
            pOther = Abc_ObjFanin0(pObj)->pCopy;
        else
            pOther = pObj->pCopy;
        if ( Vec_IntEntry(vValues, i) == 0 )
            pOther = Abc_ObjNot(pOther);
        pFinal = Abc_AigAnd( (Abc_Aig_t *)pNtkNew->pManFunc, pFinal, pOther );
    }
 
    // add the PO corresponding to this output
    pNodePo = Abc_NtkCreatePo( pNtkNew );
    Abc_ObjAddFanin( pNodePo, pFinal );
    Abc_ObjAssignName( pNodePo, "miter", NULL );
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkCreateTarget(): Network check has failed.\n" );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateWithNode()

ABC_DLL Abc_Ntk_t * Abc_NtkCreateWithNode ( char * pSop )

extern

Function*************************************************************

Synopsis [Creates the network composed of one node with the given SOP.]

Description []

SideEffects []

SeeAlso []

Definition at line 1333 of file abcNtk.c.

{    
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pFanin, * pNode, * pNodePo;
    Vec_Ptr_t * vNames;
    int i, nVars;
    // start the network
    pNtkNew = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_SOP, 1 );
    pNtkNew->pName = Extra_UtilStrsav("ex");
    // create PIs
    Vec_PtrPush( pNtkNew->vObjs, NULL );
    nVars = Abc_SopGetVarNum( pSop );
    vNames = Abc_NodeGetFakeNames( nVars );
    for ( i = 0; i < nVars; i++ )
        Abc_ObjAssignName( Abc_NtkCreatePi(pNtkNew), (char *)Vec_PtrEntry(vNames, i), NULL );
    Abc_NodeFreeNames( vNames );
    // create the node, add PIs as fanins, set the function
    pNode = Abc_NtkCreateNode( pNtkNew );
    Abc_NtkForEachPi( pNtkNew, pFanin, i )
        Abc_ObjAddFanin( pNode, pFanin );
    pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtkNew->pManFunc, pSop );
    // create the only PO
    pNodePo = Abc_NtkCreatePo(pNtkNew);
    Abc_ObjAddFanin( pNodePo, pNode );
    Abc_ObjAssignName( pNodePo, "F", NULL );
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkCreateWithNode(): Network check has failed.\n" );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkCreateWithNodes()

ABC_DLL Abc_Ntk_t * Abc_NtkCreateWithNodes ( Vec_Ptr_t * vSop )

extern

Function*************************************************************

Synopsis [Creates the network composed of one node with the given SOP.]

Description []

SideEffects []

SeeAlso []

Definition at line 1374 of file abcNtk.c.

{    
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pFanin, * pNode, * pNodePo;
    Vec_Ptr_t * vNames;
    int i, k, nVars; char Buffer[100];
    char * pSop = (char *)Vec_PtrEntry(vSop, 0);
    // start the network
    pNtkNew = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_SOP, 1 );
    pNtkNew->pName = Extra_UtilStrsav("ex");
    // create PIs
    Vec_PtrPush( pNtkNew->vObjs, NULL );
    nVars = Abc_SopGetVarNum( pSop );
    vNames = Abc_NodeGetFakeNames( nVars );
    for ( i = 0; i < nVars; i++ )
        Abc_ObjAssignName( Abc_NtkCreatePi(pNtkNew), (char *)Vec_PtrEntry(vNames, i), NULL );
    Abc_NodeFreeNames( vNames );
    // create the node, add PIs as fanins, set the function
    Vec_PtrForEachEntry( char *, vSop, pSop, i )
    {        
        pNode = Abc_NtkCreateNode( pNtkNew );
        if ( Abc_SopGetVarNum(pSop) > 0 )
            Abc_NtkForEachPi( pNtkNew, pFanin, k )
                Abc_ObjAddFanin( pNode, pFanin );
        pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtkNew->pManFunc, pSop );
        // create the only PO
        pNodePo = Abc_NtkCreatePo(pNtkNew);
        Abc_ObjAddFanin( pNodePo, pNode );
        sprintf( Buffer, "F%d", i );
        Abc_ObjAssignName( pNodePo, Buffer, NULL );
    }
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkCreateWithNode(): Network check has failed.\n" );
    return pNtkNew;
}

Here is the call graph for this function:

◆ Abc_NtkDarLatchSweep()

ABC_DLL Abc_Ntk_t * Abc_NtkDarLatchSweep	(	Abc_Ntk_t *	pNtk,
		int	fLatchConst,
		int	fLatchEqual,
		int	fSaveNames,
		int	fUseMvSweep,
		int	nFramesSymb,
		int	nFramesSatur,
		int	fVerbose,
		int	fVeryVerbose )

extern

Function*************************************************************

Synopsis [Gives the current ABC network to AIG manager for processing.]

Description []

SideEffects []

SeeAlso []

Definition at line 3317 of file abcDar.c.

{
    extern void Aig_ManPrintControlFanouts( Aig_Man_t * p );
    Abc_Ntk_t * pNtkAig;
    Aig_Man_t * pMan, * pTemp;
    pMan = Abc_NtkToDar( pNtk, 0, 1 );
    if ( pMan == NULL )
        return NULL;
    if ( fSaveNames )
    {
        Aig_ManSeqCleanup( pMan );
        if ( fLatchConst && pMan->nRegs )
            pMan = Aig_ManConstReduce( pMan, fUseMvSweep, nFramesSymb, nFramesSatur, fVerbose, fVeryVerbose );
        if ( fLatchEqual && pMan->nRegs )
            pMan = Aig_ManReduceLaches( pMan, fVerbose );
    }
    else
    {
        if ( pMan->vFlopNums )
            Vec_IntFree( pMan->vFlopNums );
        pMan->vFlopNums = NULL;
        pMan = Aig_ManScl( pTemp = pMan, fLatchConst, fLatchEqual, fUseMvSweep, nFramesSymb, nFramesSatur, fVerbose, fVeryVerbose );
        Aig_ManStop( pTemp );
    }
 
    pNtkAig = Abc_NtkFromDarSeqSweep( pNtk, pMan );
//Aig_ManPrintControlFanouts( pMan );
    Aig_ManStop( pMan );
    return pNtkAig;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDarPrintCone()

ABC_DLL int Abc_NtkDarPrintCone ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 4054 of file abcDar.c.

{
    extern void Saig_ManPrintCones( Aig_Man_t * pAig );
    Aig_Man_t * pMan;
    pMan = Abc_NtkToDar( pNtk, 0, 1 );
    if ( pMan == NULL )
        return 0;
    assert( Aig_ManRegNum(pMan) > 0 );
    Saig_ManPrintCones( pMan );
    Aig_ManStop( pMan );
    return 1;
}

Here is the call graph for this function:

◆ Abc_NtkDelayTrace()

ABC_DLL float Abc_NtkDelayTrace	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t *	pOut,
		Abc_Obj_t *	pIn,
		int	fPrint )

extern

Function*************************************************************

Synopsis [Performs delay-trace of the network. If input (pIn) or output (pOut) are given, finds the most-timing-critical path between them and prints it to the standard output. If input and/or output are not given, finds the most-critical path in the network and prints it.]

Description []

SideEffects []

SeeAlso []

Definition at line 1031 of file abcTiming.c.

{
    Vec_Int_t * vSlacks = NULL;
    Abc_Obj_t * pNode, * pDriver;
    Vec_Ptr_t * vNodes;
    Abc_Time_t * pTime;
    float tArrivalMax;
    int i;
 
    assert( Abc_NtkIsMappedLogic(pNtk) );
    assert( pOut == NULL || Abc_ObjIsCo(pOut) );
    assert( pIn == NULL || Abc_ObjIsCi(pIn) );
 
    // create slacks (need slacks if printing is requested even if pIn/pOut are not given)
    if ( pOut || pIn || fPrint )
        vSlacks = Abc_NtkDelayTraceSlackStart( pNtk );
 
    // compute the timing
    Abc_NtkTimePrepare( pNtk );
    vNodes = Abc_NtkDfs( pNtk, 1 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
        Abc_NodeDelayTraceArrival( pNode, vSlacks );
    Vec_PtrFree( vNodes );
 
    // get the latest arrival times
    tArrivalMax = -ABC_INFINITY;
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        pDriver = Abc_ObjFanin0(pNode);
        pTime   = Abc_NodeArrival(pDriver);
        if ( tArrivalMax < Abc_MaxFloat(pTime->Fall, pTime->Rise) )
            tArrivalMax = Abc_MaxFloat(pTime->Fall, pTime->Rise);
    }
 
    // determine the output to print
    if ( fPrint && pOut == NULL )
    {
        Abc_NtkForEachCo( pNtk, pNode, i )
        {
            pDriver = Abc_ObjFanin0(pNode);
            pTime   = Abc_NodeArrival(pDriver);
            if ( tArrivalMax == Abc_MaxFloat(pTime->Fall, pTime->Rise) )
                pOut = pNode;
        }
        assert( pOut != NULL );
    }
 
    if ( fPrint )
    {
        Vec_Ptr_t * vPath = Vec_PtrAlloc( 100 );
        Vec_Int_t * vBest = Vec_IntStartFull( Abc_NtkObjNumMax(pNtk) );
        // traverse to determine the critical path
        Abc_NtkIncrementTravId( pNtk );
        if ( !Abc_NtkDelayTraceCritPath_rec( vSlacks, Abc_ObjFanin0(pOut), pIn, vBest ) )
        {
            if ( pIn == NULL )
                printf( "The logic cone of PO \"%s\" has no primary inputs.\n", Abc_ObjName(pOut) );
            else
                printf( "There is no combinational path between PI \"%s\" and PO \"%s\".\n", Abc_ObjName(pIn), Abc_ObjName(pOut) );
        }
        else
        {
            float Slack = 0.0, SlackAdd;
            int k, iFanin, Length = 0;
            Abc_Obj_t * pFanin;
            // check the additional slack
            SlackAdd = Abc_NodeReadRequiredWorst(pOut) - Abc_NodeReadArrivalWorst(Abc_ObjFanin0(pOut));
            // collect the critical path
            Abc_NtkDelayTraceCritPathCollect_rec( vSlacks, Abc_ObjFanin0(pOut), vBest, vPath );
            if ( pIn == NULL )
                pIn = (Abc_Obj_t *)Vec_PtrEntry( vPath, 0 );
            // find the longest gate name
            Vec_PtrForEachEntry( Abc_Obj_t *, vPath, pNode, i )
                if ( Abc_ObjIsNode(pNode) )
                    Length = Abc_MaxInt( Length, strlen(Mio_GateReadName((Mio_Gate_t *)pNode->pData)) );
            // print critical path
            Abc_NtkLevel( pNtk );
            printf( "Critical path from PI \"%s\" to PO \"%s\":\n", Abc_ObjName(pIn), Abc_ObjName(pOut) ); 
            Vec_PtrForEachEntry( Abc_Obj_t *, vPath, pNode, i )
            {
                printf( "Level %3d : ", Abc_ObjLevel(pNode) );
                if ( Abc_ObjIsCi(pNode) )
                {
                    printf( "Primary input \"%s\".   ", Abc_ObjName(pNode) );
                    printf( "Arrival time =%6.1f. ", Abc_NodeReadArrivalWorst(pNode) );
                    printf( "\n" );
                    continue;
                }
                if ( Abc_ObjIsCo(pNode) )
                {
                    printf( "Primary output \"%s\".   ", Abc_ObjName(pNode) );
                    printf( "Arrival =%6.1f. ", Abc_NodeReadArrivalWorst(pNode) );
                }
                else
                {
                    assert( Abc_ObjIsNode(pNode) );
                    iFanin = Abc_NodeFindFanin( pNode, (Abc_Obj_t *)Vec_PtrEntry(vPath,i-1) );
                    Slack = Abc_NtkDelayTraceSlack(vSlacks, pNode, iFanin);
                    printf( "%10s/", Abc_ObjName(pNode) );
                    printf( "%-4s", Mio_GateReadPinName((Mio_Gate_t *)pNode->pData, iFanin) );
                    printf( " (%s)", Mio_GateReadName((Mio_Gate_t *)pNode->pData) );
                    for ( k = strlen(Mio_GateReadName((Mio_Gate_t *)pNode->pData)); k < Length; k++ )
                        printf( " " );
                    printf( "   " );
                    printf( "Arrival =%6.1f.   ", Abc_NodeReadArrivalWorst(pNode) );
                    printf( "I/O times: (" );
                    Abc_ObjForEachFanin( pNode, pFanin, k )
                        printf( "%s%.1f", (k? ", ":""), Abc_NodeReadArrivalWorst(pFanin) );
//                    printf( " -> %.1f)", Abc_NodeReadArrival(pNode)->Worst + Slack + SlackAdd );
                    printf( " -> %.1f)", Abc_NodeReadArrivalWorst(pNode) );
                }
                printf( "\n" );
            }
            printf( "Level %3d : ", Abc_ObjLevel(Abc_ObjFanin0(pOut)) + 1 );
            printf( "Primary output \"%s\".   ", Abc_ObjName(pOut) );
            printf( "Required time = %6.1f.  ", Abc_NodeReadRequiredWorst(pOut) );
            printf( "Path slack = %6.1f.\n", SlackAdd );
        }
        Vec_PtrFree( vPath );
        Vec_IntFree( vBest );
    }
 
    Vec_IntFreeP( &vSlacks );
    return tArrivalMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDelayTraceLut()

ABC_DLL float Abc_NtkDelayTraceLut	(	Abc_Ntk_t *	pNtk,
		int	fUseLutLib )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 100 of file abcSpeedup.c.

{
    int fUseSorting = 1;
    int pPinPerm[32];
    float pPinDelays[32];
    If_LibLut_t * pLutLib;
    Abc_Obj_t * pNode, * pFanin;
    Vec_Ptr_t * vNodes;
    float tArrival, tRequired, tSlack, * pDelays;
    int i, k;
 
    assert( Abc_NtkIsLogic(pNtk) );
    // get the library
    pLutLib = fUseLutLib?  (If_LibLut_t *)Abc_FrameReadLibLut() : NULL;
    if ( pLutLib && pLutLib->LutMax < Abc_NtkGetFaninMax(pNtk) )
    {
        printf( "The max LUT size (%d) is less than the max fanin count (%d).\n", 
            pLutLib->LutMax, Abc_NtkGetFaninMax(pNtk) );
        return -ABC_INFINITY;
    }
 
    // initialize the arrival times
    ABC_FREE( pNtk->pLutTimes );
    pNtk->pLutTimes = ABC_ALLOC( float, 3 * Abc_NtkObjNumMax(pNtk) );
    for ( i = 0; i < Abc_NtkObjNumMax(pNtk); i++ )
    {
        pNtk->pLutTimes[3*i+0] = pNtk->pLutTimes[3*i+2] = 0;
        pNtk->pLutTimes[3*i+1] = ABC_INFINITY;
    }
 
    // propagate arrival times
    vNodes = Abc_NtkDfs( pNtk, 1 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
    {
        tArrival = -ABC_INFINITY;
        if ( pLutLib == NULL )
        {
            Abc_ObjForEachFanin( pNode, pFanin, k )
                if ( tArrival < Abc_ObjArrival(pFanin) + 1.0 )
                    tArrival = Abc_ObjArrival(pFanin) + 1.0;
        }
        else if ( !pLutLib->fVarPinDelays )
        {
            pDelays = pLutLib->pLutDelays[Abc_ObjFaninNum(pNode)];
            Abc_ObjForEachFanin( pNode, pFanin, k )
                if ( tArrival < Abc_ObjArrival(pFanin) + pDelays[0] )
                    tArrival = Abc_ObjArrival(pFanin) + pDelays[0];
        }
        else
        {
            pDelays = pLutLib->pLutDelays[Abc_ObjFaninNum(pNode)];
            if ( fUseSorting )
            {
                Abc_NtkDelayTraceSortPins( pNode, pPinPerm, pPinDelays );
                Abc_ObjForEachFanin( pNode, pFanin, k ) 
                    if ( tArrival < Abc_ObjArrival(Abc_ObjFanin(pNode,pPinPerm[k])) + pDelays[k] )
                        tArrival = Abc_ObjArrival(Abc_ObjFanin(pNode,pPinPerm[k])) + pDelays[k];
            }
            else
            {
                Abc_ObjForEachFanin( pNode, pFanin, k )
                    if ( tArrival < Abc_ObjArrival(pFanin) + pDelays[k] )
                        tArrival = Abc_ObjArrival(pFanin) + pDelays[k];
            }
        }
        if ( Abc_ObjFaninNum(pNode) == 0 )
            tArrival = 0.0;
        Abc_ObjSetArrival( pNode, tArrival );
    }
    Vec_PtrFree( vNodes );
 
    // get the latest arrival times
    tArrival = -ABC_INFINITY;
    Abc_NtkForEachCo( pNtk, pNode, i )
        if ( tArrival < Abc_ObjArrival(Abc_ObjFanin0(pNode)) )
            tArrival = Abc_ObjArrival(Abc_ObjFanin0(pNode));
 
    // initialize the required times
    Abc_NtkForEachCo( pNtk, pNode, i )
        if ( Abc_ObjRequired(Abc_ObjFanin0(pNode)) > tArrival )
            Abc_ObjSetRequired( Abc_ObjFanin0(pNode), tArrival );
 
    // propagate the required times
    vNodes = Abc_NtkDfsReverse( pNtk );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
    {
        if ( pLutLib == NULL )
        {
            tRequired = Abc_ObjRequired(pNode) - (float)1.0;
            Abc_ObjForEachFanin( pNode, pFanin, k )
                if ( Abc_ObjRequired(pFanin) > tRequired )
                    Abc_ObjSetRequired( pFanin, tRequired );
        }
        else if ( !pLutLib->fVarPinDelays )
        {
            pDelays = pLutLib->pLutDelays[Abc_ObjFaninNum(pNode)];
            tRequired = Abc_ObjRequired(pNode) - pDelays[0];
            Abc_ObjForEachFanin( pNode, pFanin, k )
                if ( Abc_ObjRequired(pFanin) > tRequired )
                    Abc_ObjSetRequired( pFanin, tRequired );
        }
        else 
        {
            pDelays = pLutLib->pLutDelays[Abc_ObjFaninNum(pNode)];
            if ( fUseSorting )
            {
                Abc_NtkDelayTraceSortPins( pNode, pPinPerm, pPinDelays );
                Abc_ObjForEachFanin( pNode, pFanin, k )
                {
                    tRequired = Abc_ObjRequired(pNode) - pDelays[k];
                    if ( Abc_ObjRequired(Abc_ObjFanin(pNode,pPinPerm[k])) > tRequired )
                        Abc_ObjSetRequired( Abc_ObjFanin(pNode,pPinPerm[k]), tRequired );
                }
            }
            else
            {
                Abc_ObjForEachFanin( pNode, pFanin, k )
                {
                    tRequired = Abc_ObjRequired(pNode) - pDelays[k];
                    if ( Abc_ObjRequired(pFanin) > tRequired )
                        Abc_ObjSetRequired( pFanin, tRequired );
                }
            }
        }
        // set slack for this object
        tSlack = Abc_ObjRequired(pNode) - Abc_ObjArrival(pNode);
        assert( tSlack + 0.001 > 0.0 );
        Abc_ObjSetSlack( pNode, tSlack < 0.0 ? 0.0 : tSlack );
    }
    Vec_PtrFree( vNodes );
    return tArrival;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDelete()

ABC_DLL void Abc_NtkDelete ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Deletes the Ntk.]

Description []

SideEffects []

SeeAlso []

Definition at line 1421 of file abcNtk.c.

{
    Abc_Obj_t * pObj;
    void * pAttrMan;
    int TotalMemory, i;
    int fWarning = 0;
//    int LargePiece = (4 << ABC_NUM_STEPS);
    if ( pNtk == NULL )
        return;
    // free EXDC Ntk
    if ( pNtk->pExdc )
        Abc_NtkDelete( pNtk->pExdc );
    if ( pNtk->pExcare )
        Abc_NtkDelete( (Abc_Ntk_t *)pNtk->pExcare );
    // dereference the BDDs
    if ( Abc_NtkHasBdd(pNtk) )
    {
#ifdef ABC_USE_CUDD
        Abc_NtkForEachNode( pNtk, pObj, i )
            Cudd_RecursiveDeref( (DdManager *)pNtk->pManFunc, (DdNode *)pObj->pData );
#endif
    }
    // make sure all the marks are clean
    Abc_NtkForEachObj( pNtk, pObj, i )
    {
        // free large fanout arrays
//        if ( pNtk->pMmObj && pObj->vFanouts.nCap * 4 > LargePiece )
//            ABC_FREE( pObj->vFanouts.pArray );
        // these flags should be always zero
        // if this is not true, something is wrong somewhere
//        assert( pObj->fMarkA == 0 );
//        assert( pObj->fMarkB == 0 );
//        assert( pObj->fMarkC == 0 );
        if ( !fWarning && (pObj->fMarkA || pObj->fMarkB || pObj->fMarkC) )
            { printf( "Flags A, B, or C are not zero.\n" ), fWarning = 1; }
    }
    // free the nodes
    if ( pNtk->pMmStep == NULL )
    {
        Abc_NtkForEachObj( pNtk, pObj, i )
        {
            ABC_FREE( pObj->vFanouts.pArray );
            ABC_FREE( pObj->vFanins.pArray );
        }
    }
    if ( pNtk->pMmObj == NULL )
    {
        Abc_NtkForEachObj( pNtk, pObj, i )
            ABC_FREE( pObj );
    }
        
    // free the arrays
    Vec_PtrFree( pNtk->vPios );
    Vec_PtrFree( pNtk->vPis );
    Vec_PtrFree( pNtk->vPos );
    Vec_PtrFree( pNtk->vCis );
    Vec_PtrFree( pNtk->vCos );
    Vec_PtrFree( pNtk->vObjs );
    Vec_PtrFree( pNtk->vBoxes );
    ABC_FREE( pNtk->vTravIds.pArray );
    if ( pNtk->vLevelsR ) Vec_IntFree( pNtk->vLevelsR );
    ABC_FREE( pNtk->pModel );
    ABC_FREE( pNtk->pSeqModel );
    if ( pNtk->vSeqModelVec )
        Vec_PtrFreeFree( pNtk->vSeqModelVec );
    TotalMemory  = 0;
    TotalMemory += pNtk->pMmObj? Mem_FixedReadMemUsage(pNtk->pMmObj)  : 0;
    TotalMemory += pNtk->pMmStep? Mem_StepReadMemUsage(pNtk->pMmStep) : 0;
//    fprintf( stdout, "The total memory allocated internally by the network = %0.2f MB.\n", ((double)TotalMemory)/(1<<20) );
    // free the storage 
    if ( pNtk->pMmObj )
        Mem_FixedStop( pNtk->pMmObj, 0 );
    if ( pNtk->pMmStep )
        Mem_StepStop ( pNtk->pMmStep, 0 );
    // name manager
    Nm_ManFree( pNtk->pManName );
    // free the timing manager
    if ( pNtk->pManTime )
        Abc_ManTimeStop( pNtk->pManTime );
    Vec_IntFreeP( &pNtk->vPhases );
    // start the functionality manager
    if ( Abc_NtkIsStrash(pNtk) )
        Abc_AigFree( (Abc_Aig_t *)pNtk->pManFunc );
    else if ( Abc_NtkHasSop(pNtk) || Abc_NtkHasBlifMv(pNtk) )
        Mem_FlexStop( (Mem_Flex_t *)pNtk->pManFunc, 0 );
#ifdef ABC_USE_CUDD
    else if ( Abc_NtkHasBdd(pNtk) )
        Extra_StopManager( (DdManager *)pNtk->pManFunc );
#endif
    else if ( Abc_NtkHasAig(pNtk) )
        { if ( pNtk->pManFunc ) Hop_ManStop( (Hop_Man_t *)pNtk->pManFunc ); }
    else if ( Abc_NtkHasMapping(pNtk) )
        pNtk->pManFunc = NULL;
    else if ( !Abc_NtkHasBlackbox(pNtk) )
        assert( 0 );
    // free the hierarchy
    if ( pNtk->pDesign )
    {
        Abc_DesFree( pNtk->pDesign, pNtk );
        pNtk->pDesign = NULL;
    }
//    if ( pNtk->pBlackBoxes ) 
//        Vec_IntFree( pNtk->pBlackBoxes );
    // free node attributes
    Vec_PtrForEachEntry( Abc_Obj_t *, pNtk->vAttrs, pAttrMan, i )
        if ( pAttrMan )
            Vec_AttFree( (Vec_Att_t *)pAttrMan, 1 );
    assert( pNtk->pSCLib == NULL );
    Vec_IntFreeP( &pNtk->vGates );
    Vec_PtrFree( pNtk->vAttrs );
    Vec_IntFreeP( &pNtk->vNameIds );
    ABC_FREE( pNtk->pWLoadUsed );
    ABC_FREE( pNtk->pName );
    ABC_FREE( pNtk->pSpec );
    ABC_FREE( pNtk->pLutTimes );
    if ( pNtk->vOnehots )
        Vec_VecFree( (Vec_Vec_t *)pNtk->vOnehots );
    Vec_PtrFreeP( &pNtk->vLtlProperties );
    Vec_IntFreeP( &pNtk->vObjPerm );
    Vec_IntFreeP( &pNtk->vTopo );
    Vec_IntFreeP( &pNtk->vFins );
    Vec_IntFreeP( &pNtk->vOrigNodeIds );
    ABC_FREE( pNtk );
}

Here is the call graph for this function:

◆ Abc_NtkDeleteAll_rec()

ABC_DLL void Abc_NtkDeleteAll_rec ( Abc_Obj_t * pObj )

extern

Function*************************************************************

Synopsis [Deletes the node and MFFC of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 315 of file abcObj.c.

{
    Vec_Ptr_t * vNodes;
    int i;
    assert( !Abc_ObjIsComplement(pObj) );
    assert( Abc_ObjFanoutNum(pObj) == 0 );
    // delete fanins and fanouts
    vNodes = Vec_PtrAlloc( 100 );
    Abc_NodeCollectFanins( pObj, vNodes );
    Abc_NtkDeleteObj( pObj );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
        if ( !Abc_ObjIsNode(pObj) && Abc_ObjFanoutNum(pObj) == 0 )
            Abc_NtkDeleteAll_rec( pObj );
    Vec_PtrFree( vNodes );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDeleteObj()

ABC_DLL void Abc_NtkDeleteObj ( Abc_Obj_t * pObj )

extern

Function*************************************************************

Synopsis [Deletes the object from the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 170 of file abcObj.c.

{
    Abc_Ntk_t * pNtk = pObj->pNtk;
    Vec_Ptr_t * vNodes;
    int i;
    assert( !Abc_ObjIsComplement(pObj) );
    // remove from the table of names
    if ( Nm_ManFindNameById(pObj->pNtk->pManName, pObj->Id) )
        Nm_ManDeleteIdName(pObj->pNtk->pManName, pObj->Id);
    // delete fanins and fanouts
    vNodes = Vec_PtrAlloc( 100 );
    Abc_NodeCollectFanouts( pObj, vNodes );
    for ( i = 0; i < vNodes->nSize; i++ )
        Abc_ObjDeleteFanin( (Abc_Obj_t *)vNodes->pArray[i], pObj );
    Abc_NodeCollectFanins( pObj, vNodes );
    for ( i = 0; i < vNodes->nSize; i++ )
        Abc_ObjDeleteFanin( pObj, (Abc_Obj_t *)vNodes->pArray[i] );
    Vec_PtrFree( vNodes );
    // remove from the list of objects
    Vec_PtrWriteEntry( pNtk->vObjs, pObj->Id, NULL );
    pObj->Id = (1<<26)-1;
    pNtk->nObjCounts[pObj->Type]--;
    pNtk->nObjs--;
    // perform specialized operations depending on the object type
    switch (pObj->Type)
    {
        case ABC_OBJ_NONE:   
            assert(0); 
            break;
        case ABC_OBJ_CONST1: 
            assert(0); 
            break;
        case ABC_OBJ_PI:     
            Vec_PtrRemove( pNtk->vPis, pObj );
            Vec_PtrRemove( pNtk->vCis, pObj );
            break;
        case ABC_OBJ_PO:     
            Vec_PtrRemove( pNtk->vPos, pObj );
            Vec_PtrRemove( pNtk->vCos, pObj );
            break;
        case ABC_OBJ_BI:     
            if ( pNtk->vCos ) Vec_PtrRemove( pNtk->vCos, pObj );
            break;
        case ABC_OBJ_BO:     
            if ( pNtk->vCis ) Vec_PtrRemove( pNtk->vCis, pObj );
            break;
        case ABC_OBJ_NET:  
            break;
        case ABC_OBJ_NODE: 
#ifdef ABC_USE_CUDD
            if ( Abc_NtkHasBdd(pNtk) )
                Cudd_RecursiveDeref( (DdManager *)pNtk->pManFunc, (DdNode *)pObj->pData );
#endif
            pObj->pData = NULL;
            break;
        case ABC_OBJ_LATCH:     
        case ABC_OBJ_WHITEBOX:     
        case ABC_OBJ_BLACKBOX:     
            if ( pNtk->vBoxes ) Vec_PtrRemove( pNtk->vBoxes, pObj );
            break;
        default:
            assert(0); 
            break;
    }
    // recycle the object memory
    Abc_ObjRecycle( pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDeleteObj_rec()

ABC_DLL void Abc_NtkDeleteObj_rec	(	Abc_Obj_t *	pObj,
		int	fOnlyNodes )

extern

Function*************************************************************

Synopsis [Deletes the node and MFFC of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 278 of file abcObj.c.

{
    Vec_Ptr_t * vNodes;
    int i;
    assert( !Abc_ObjIsComplement(pObj) );
    assert( !Abc_ObjIsPi(pObj) );
    assert( Abc_ObjFanoutNum(pObj) == 0 );
    // delete fanins and fanouts
    vNodes = Vec_PtrAlloc( 100 );
    Abc_NodeCollectFanins( pObj, vNodes );
    Abc_NtkDeleteObj( pObj );
    if ( fOnlyNodes )
    {
        Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
            if ( Abc_ObjIsNode(pObj) && Abc_ObjFanoutNum(pObj) == 0 )
                Abc_NtkDeleteObj_rec( pObj, fOnlyNodes );
    }
    else
    {
        Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
            if ( !Abc_ObjIsPi(pObj) && Abc_ObjFanoutNum(pObj) == 0 )
                Abc_NtkDeleteObj_rec( pObj, fOnlyNodes );
    }
    Vec_PtrFree( vNodes );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDeleteObjPo()

ABC_DLL void Abc_NtkDeleteObjPo ( Abc_Obj_t * pObj )

extern

Function*************************************************************

Synopsis [Deletes the PO from the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 249 of file abcObj.c.

{
    assert( Abc_ObjIsPo(pObj) );
    // remove from the table of names
    if ( Nm_ManFindNameById(pObj->pNtk->pManName, pObj->Id) )
        Nm_ManDeleteIdName(pObj->pNtk->pManName, pObj->Id);
    // delete fanins
    Abc_ObjDeleteFanin( pObj, Abc_ObjFanin0(pObj) );
    // remove from the list of objects
    Vec_PtrWriteEntry( pObj->pNtk->vObjs, pObj->Id, NULL );
    pObj->Id = (1<<26)-1;
    pObj->pNtk->nObjCounts[pObj->Type]--;
    pObj->pNtk->nObjs--;
    // recycle the object memory
    Abc_ObjRecycle( pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDeriveFromBdd()

ABC_DLL Abc_Ntk_t * Abc_NtkDeriveFromBdd	(	void *	dd,
		void *	bFunc,
		char *	pNamePo,
		Vec_Ptr_t *	vNamesPi )

extern

Here is the caller graph for this function:

◆ Abc_NtkDfs()

ABC_DLL Vec_Ptr_t * Abc_NtkDfs	(	Abc_Ntk_t *	pNtk,
		int	fCollectAll )

extern

Function*************************************************************

Synopsis [Returns the DFS ordered array of logic nodes.]

Description [Collects only the internal nodes, leaving out CIs and CO. However it marks with the current TravId both CIs and COs.]

SideEffects []

SeeAlso []

Definition at line 82 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj;
    int i;
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    if ( pNtk->nBarBufs2 > 0 )
    {
        Abc_NtkForEachBarBuf( pNtk, pObj, i )
        {
            Abc_NodeSetTravIdCurrent( pObj );
            Abc_NtkDfs_rec( Abc_ObjFanin0Ntk(Abc_ObjFanin0(pObj)), vNodes );
            Vec_PtrPush( vNodes, pObj );
        }
    }
    Abc_NtkForEachCo( pNtk, pObj, i )
    {
        Abc_NodeSetTravIdCurrent( pObj );
        Abc_NtkDfs_rec( Abc_ObjFanin0Ntk(Abc_ObjFanin0(pObj)), vNodes );
    }
    // collect dangling nodes if asked to
    if ( fCollectAll )
    {
        Abc_NtkForEachNode( pNtk, pObj, i )
            if ( !Abc_NodeIsTravIdCurrent(pObj) )
                Abc_NtkDfs_rec( pObj, vNodes );
    }
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDfs2()

ABC_DLL Vec_Ptr_t * Abc_NtkDfs2 ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns the DFS ordered array of logic nodes.]

Description [Collects only the internal nodes, leaving out CIs and CO. However it marks with the current TravId both CIs and COs.]

SideEffects []

SeeAlso []

Definition at line 127 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes = Vec_PtrAlloc( 100 );
    Abc_Obj_t * pObj;  int i;
    Abc_NtkIncrementTravId( pNtk );
    Abc_NtkForEachCo( pNtk, pObj, i )
    {
        Abc_NodeSetTravIdCurrent( pObj );
        Abc_NtkDfs_rec( Abc_ObjFanin0Ntk(Abc_ObjFanin0(pObj)), vNodes );
    }
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDfsHie()

ABC_DLL Vec_Ptr_t * Abc_NtkDfsHie	(	Abc_Ntk_t *	pNtk,
		int	fCollectAll )

extern

Function*************************************************************

Synopsis [Returns the DFS ordered array of all objects.]

Description [This procedure collects everything from POs to PIs.]

SideEffects []

SeeAlso []

Definition at line 665 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj;
    int i;
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    Abc_NtkForEachPo( pNtk, pObj, i )
        Abc_NtkDfsHie_rec( pObj, vNodes );
    // collect dangling nodes if asked to
    if ( fCollectAll )
    {
        Abc_NtkForEachObj( pNtk, pObj, i )
            if ( !Abc_NodeIsTravIdCurrent(pObj) )
                Abc_NtkDfs_rec( pObj, vNodes );
    }
    return vNodes;
}

Here is the call graph for this function:

◆ Abc_NtkDfsIter()

ABC_DLL Vec_Ptr_t * Abc_NtkDfsIter	(	Abc_Ntk_t *	pNtk,
		int	fCollectAll )

extern

Function*************************************************************

Synopsis [Returns the DFS ordered array of logic nodes.]

Description [Collects only the internal nodes, leaving CIs and CO. However it marks with the current TravId both CIs and COs.]

SideEffects []

SeeAlso []

Definition at line 573 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes, * vStack;
    Abc_Obj_t * pObj;
    int i;
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 1000 );
    vStack = Vec_PtrAlloc( 1000 );
    Abc_NtkForEachCo( pNtk, pObj, i )
    {
        Abc_NodeSetTravIdCurrent( pObj );
        Abc_NtkDfs_iter( vStack, Abc_ObjFanin0Ntk(Abc_ObjFanin0(pObj)), vNodes );
    }
    // collect dangling nodes if asked to
    if ( fCollectAll )
    { 
        Abc_NtkForEachNode( pNtk, pObj, i )
            if ( !Abc_NodeIsTravIdCurrent(pObj) )
                Abc_NtkDfs_iter( vStack, pObj, vNodes );
    }
    Vec_PtrFree( vStack );
    return vNodes;
}

Here is the call graph for this function:

◆ Abc_NtkDfsIterNodes()

ABC_DLL Vec_Ptr_t * Abc_NtkDfsIterNodes	(	Abc_Ntk_t *	pNtk,
		Vec_Ptr_t *	vRoots )

extern

Function*************************************************************

Synopsis [Returns the DFS ordered array of logic nodes.]

Description [Collects only the internal nodes, leaving CIs and CO. However it marks with the current TravId both CIs and COs.]

SideEffects []

SeeAlso []

Definition at line 611 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes, * vStack;
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkIncrementTravId( pNtk );
    vNodes = Vec_PtrAlloc( 1000 );
    vStack = Vec_PtrAlloc( 1000 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vRoots, pObj, i )
        if ( !Abc_NodeIsTravIdCurrent(Abc_ObjRegular(pObj)) )
            Abc_NtkDfs_iter( vStack, Abc_ObjRegular(pObj), vNodes );
    Vec_PtrFree( vStack );
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDfsNodes()

ABC_DLL Vec_Ptr_t * Abc_NtkDfsNodes	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t **	ppNodes,
		int	nNodes )

extern

Function*************************************************************

Synopsis [Returns the DFS ordered array of logic nodes.]

Description [Collects only the internal nodes, leaving out PIs, POs and latches.]

SideEffects []

SeeAlso []

Definition at line 151 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    int i;
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    // go through the PO nodes and call for each of them
    for ( i = 0; i < nNodes; i++ )
    {
        if ( Abc_NtkIsStrash(pNtk) && Abc_AigNodeIsConst(ppNodes[i]) )
            continue;
        if ( Abc_ObjIsCo(ppNodes[i]) )
        {
            Abc_NodeSetTravIdCurrent(ppNodes[i]);
            Abc_NtkDfs_rec( Abc_ObjFanin0Ntk(Abc_ObjFanin0(ppNodes[i])), vNodes );
        }
        else if ( Abc_ObjIsNode(ppNodes[i]) || Abc_ObjIsCi(ppNodes[i]) )
            Abc_NtkDfs_rec( ppNodes[i], vNodes );
    }
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDfsReverse()

ABC_DLL Vec_Ptr_t * Abc_NtkDfsReverse ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns the reverse DFS ordered array of logic nodes.]

Description [Collects only the internal nodes, leaving out CIs/COs. However it marks both CIs and COs with the current TravId.]

SideEffects []

SeeAlso []

Definition at line 221 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj, * pFanout;
    int i, k;
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    Abc_NtkForEachCi( pNtk, pObj, i )
    {
        Abc_NodeSetTravIdCurrent( pObj );
        pObj = Abc_ObjFanout0Ntk(pObj);
        Abc_ObjForEachFanout( pObj, pFanout, k )
            Abc_NtkDfsReverse_rec( pFanout, vNodes );
    }
    // add constant nodes in the end
    if ( !Abc_NtkIsStrash(pNtk) ) {
        Abc_NtkForEachNode( pNtk, pObj, i )
            if ( Abc_NodeIsConst(pObj) )
                Vec_PtrPush( vNodes, pObj );
    }
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDfsReverseNodes()

ABC_DLL Vec_Ptr_t * Abc_NtkDfsReverseNodes	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t **	ppNodes,
		int	nNodes )

extern

Function*************************************************************

Synopsis [Returns the levelized array of TFO nodes.]

Description [Collects the levelized array of internal nodes, leaving out CIs/COs. However it marks both CIs and COs with the current TravId.]

SideEffects []

SeeAlso []

Definition at line 294 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj, * pFanout;
    int i, k;
    assert( Abc_NtkIsStrash(pNtk) );
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrStart( Abc_AigLevel(pNtk) + 1 );
    for ( i = 0; i < nNodes; i++ )
    {
        pObj = ppNodes[i];
        assert( Abc_ObjIsCi(pObj) );
        Abc_NodeSetTravIdCurrent( pObj );
        pObj = Abc_ObjFanout0Ntk(pObj);
        Abc_ObjForEachFanout( pObj, pFanout, k )
            Abc_NtkDfsReverseNodes_rec( pFanout, vNodes );
    }
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDfsReverseNodesContained()

ABC_DLL Vec_Ptr_t * Abc_NtkDfsReverseNodesContained	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t **	ppNodes,
		int	nNodes )

extern

Function*************************************************************

Synopsis [Returns the levelized array of TFO nodes.]

Description [Collects the levelized array of internal nodes, leaving out CIs/COs. However it marks both CIs and COs with the current TravId. Collects only the nodes whose support does not exceed the set of given CI nodes.]

SideEffects []

SeeAlso []

Definition at line 329 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj, * pFanout, * pFanin;
    int i, k, m, nLevels;
    // set the levels
    nLevels = Abc_NtkLevel( pNtk );
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrStart( nLevels + 2 );
    for ( i = 0; i < nNodes; i++ )
    {
        pObj = ppNodes[i];
        assert( Abc_ObjIsCi(pObj) );
        Abc_NodeSetTravIdCurrent( pObj );
        // add to the array
        assert( pObj->Level == 0 );
        pObj->pCopy = (Abc_Obj_t *)Vec_PtrEntry( vNodes, pObj->Level );
        Vec_PtrWriteEntry( vNodes, pObj->Level, pObj );
    }
    // iterate through the levels
    for ( i = 0; i <= nLevels; i++ )
    {
        // iterate through the nodes on each level
        for ( pObj = (Abc_Obj_t *)Vec_PtrEntry(vNodes, i); pObj; pObj = pObj->pCopy )
        {
            // iterate through the fanouts of each node
            Abc_ObjForEachFanout( pObj, pFanout, k )
            {
                // skip visited nodes
                if ( Abc_NodeIsTravIdCurrent(pFanout) )
                    continue;
                // visit the fanins of this fanout
                Abc_ObjForEachFanin( pFanout, pFanin, m )
                {
                    if ( !Abc_NodeIsTravIdCurrent(pFanin) )
                        break;
                }
                if ( m < Abc_ObjFaninNum(pFanout) )
                    continue;
                // all fanins are already collected
 
                // mark the node as visited
                Abc_NodeSetTravIdCurrent( pFanout );
                // handle the COs
                if ( Abc_ObjIsCo(pFanout) )
                    pFanout->Level = nLevels + 1;
                // add to the array
                pFanout->pCopy = (Abc_Obj_t *)Vec_PtrEntry( vNodes, pFanout->Level );
                Vec_PtrWriteEntry( vNodes, pFanout->Level, pFanout );
                // handle the COs
                if ( Abc_ObjIsCo(pFanout) )
                    pFanout->Level = 0;
            }
        }
    }
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDfsSeq()

ABC_DLL Vec_Ptr_t * Abc_NtkDfsSeq ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns the array of nodes and latches reachable from POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 428 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj;
    int i;
    assert( !Abc_NtkIsNetlist(pNtk) );
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    Abc_NtkForEachPo( pNtk, pObj, i )
        Abc_NtkDfsSeq_rec( pObj, vNodes );
    // mark the PIs
    Abc_NtkForEachPi( pNtk, pObj, i )
        Abc_NtkDfsSeq_rec( pObj, vNodes );
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDfsSeqReverse()

ABC_DLL Vec_Ptr_t * Abc_NtkDfsSeqReverse ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns the array of nodes and latches reachable from POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 485 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj;
    int i;
    assert( !Abc_NtkIsNetlist(pNtk) );
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    Abc_NtkForEachPi( pNtk, pObj, i )
        Abc_NtkDfsSeqReverse_rec( pObj, vNodes );
    // mark the logic feeding into POs
    Abc_NtkForEachPo( pNtk, pObj, i )
        Abc_NtkDfsSeq_rec( pObj, vNodes );
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDfsWithBoxes()

ABC_DLL Vec_Ptr_t * Abc_NtkDfsWithBoxes ( Abc_Ntk_t * pNtk )

extern

Definition at line 799 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkIncrementTravId( pNtk );
    vNodes = Vec_PtrAlloc( 100 );
    Abc_NtkForEachPo( pNtk, pObj, i )
    {
        assert( Abc_ObjIsNet(Abc_ObjFanin0(pObj)) );
        Abc_NtkDfsWithBoxes_rec( Abc_ObjFanin0Ntk(Abc_ObjFanin0(pObj)), vNodes );
    }
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDoCheck()

ABC_DLL int Abc_NtkDoCheck ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Checks the integrity of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 96 of file abcCheck.c.

{
    Abc_Obj_t * pObj, * pNet, * pNode;
    int i;
 
    // check network types
    if ( !Abc_NtkIsNetlist(pNtk) && !Abc_NtkIsLogic(pNtk) && !Abc_NtkIsStrash(pNtk) )
    {
        fprintf( stdout, "NetworkCheck: Unknown network type.\n" );
        return 0;
    }
    if ( !Abc_NtkHasSop(pNtk) && !Abc_NtkHasBdd(pNtk) && !Abc_NtkHasAig(pNtk) && !Abc_NtkHasMapping(pNtk) && !Abc_NtkHasBlifMv(pNtk) && !Abc_NtkHasBlackbox(pNtk) )
    {
        fprintf( stdout, "NetworkCheck: Unknown functionality type.\n" );
        return 0;
    }
    if ( Abc_NtkHasMapping(pNtk) )
    {
        if ( pNtk->pManFunc != Abc_FrameReadLibGen() )
        {
            fprintf( stdout, "NetworkCheck: The library of the mapped network is not the global library.\n" );
            return 0;
        }
    }
 
    if ( Abc_NtkHasOnlyLatchBoxes(pNtk) )
    {
        // check CI/CO numbers
        if ( Abc_NtkPiNum(pNtk) + Abc_NtkLatchNum(pNtk) != Abc_NtkCiNum(pNtk) )
        {
            fprintf( stdout, "NetworkCheck: Number of CIs does not match number of PIs and latches.\n" );
            fprintf( stdout, "One possible reason is that latches are added twice:\n" );
            fprintf( stdout, "in procedure Abc_NtkCreateObj() and in the user's code.\n" );
            return 0;
        }
        if ( Abc_NtkPoNum(pNtk) + Abc_NtkLatchNum(pNtk) != Abc_NtkCoNum(pNtk) )
        {
            fprintf( stdout, "NetworkCheck: Number of COs does not match number of POs, asserts, and latches.\n" );
            fprintf( stdout, "One possible reason is that latches are added twice:\n" );
            fprintf( stdout, "in procedure Abc_NtkCreateObj() and in the user's code.\n" );
            return 0;
        }
    }
 
    // check the names
    if ( !Abc_NtkCheckNames( pNtk ) )
        return 0;
 
    // check PIs and POs
    Abc_NtkCleanCopy( pNtk );
    if ( !Abc_NtkCheckPis( pNtk ) )
        return 0;
    if ( !Abc_NtkCheckPos( pNtk ) )
        return 0;
 
    if ( Abc_NtkHasBlackbox(pNtk) )
        return 1;
 
    // check the connectivity of objects
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( !Abc_NtkCheckObj( pNtk, pObj ) )
            return 0;
 
    // if it is a netlist change nets and latches
    if ( Abc_NtkIsNetlist(pNtk) )
    {
        if ( Abc_NtkNetNum(pNtk) == 0 )
            fprintf( stdout, "NetworkCheck: Warning! Netlist has no nets.\n" );
        // check the nets
        Abc_NtkForEachNet( pNtk, pNet, i )
            if ( !Abc_NtkCheckNet( pNtk, pNet ) )
                return 0;
    }
    else
    {
        if ( Abc_NtkNetNum(pNtk) != 0 )
        {
            fprintf( stdout, "NetworkCheck: A network that is not a netlist has nets.\n" );
            return 0;
        }
    }
 
    // check the nodes
    if ( Abc_NtkIsStrash(pNtk) )
    {
        if ( !Abc_AigCheck( (Abc_Aig_t *)pNtk->pManFunc ) )
            return 0;
    }
    else
    {
        Abc_NtkForEachNode( pNtk, pNode, i )
            if ( !Abc_NtkCheckNode( pNtk, pNode ) )
                return 0;
    }
 
    // check the latches
    Abc_NtkForEachLatch( pNtk, pNode, i )
        if ( !Abc_NtkCheckLatch( pNtk, pNode ) )
            return 0;
 
    // finally, check for combinational loops
//  clk = Abc_Clock();
    if ( !Abc_NtkIsAcyclic( pNtk ) )
    {
        fprintf( stdout, "NetworkCheck: Network contains a combinational loop.\n" );
        return 0;
    }
//  ABC_PRT( "Acyclic  ", Abc_Clock() - clk );
 
    // check the EXDC network if present
    if ( pNtk->pExdc )
        Abc_NtkCheck( pNtk->pExdc );
/*
    // check the hierarchy
    if ( Abc_NtkIsNetlist(pNtk) && pNtk->tName2Model )
    {
        stmm_generator * gen;
        Abc_Ntk_t * pNtkTemp;
        char * pName;
        // check other networks
        stmm_foreach_item( pNtk->tName2Model, gen, &pName, (char **)&pNtkTemp )
        {
            pNtkTemp->fHiePath = pNtkTemp->fHieVisited = 0;
            if ( !Abc_NtkCheck( pNtkTemp ) )
                return 0;
        }
        // check acyclic dependency of the models
        if ( !Abc_NtkIsAcyclicHierarchy( pNtk ) )
        {
            fprintf( stdout, "NetworkCheck: Network hierarchical dependences contains a cycle.\n" );
            return 0;
        }
    }
*/
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareAlloc()

ABC_DLL Odc_Man_t * Abc_NtkDontCareAlloc	(	int	nVarsMax,
		int	nLevels,
		int	fVerbose,
		int	fVeryVerbose )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Allocates the don't-care manager.]

Description [The parameters are the max number of cut variables, the number of fanout levels used for the ODC computation, and verbosiness.]

SideEffects []

SeeAlso []

Definition at line 163 of file abcOdc.c.

{
    Odc_Man_t * p;
    unsigned * pData;
    int i, k;
    p = ABC_ALLOC( Odc_Man_t, 1 );
    memset( p, 0, sizeof(Odc_Man_t) );
    assert( nVarsMax > 4 && nVarsMax < 16 );
    assert( nLevels > 0 && nLevels < 10 );
 
    srand( 0xABC );
 
    // dont'-care parameters
    p->nVarsMax     = nVarsMax;
    p->nLevels      = nLevels;
    p->fVerbose     = fVerbose;
    p->fVeryVerbose = fVeryVerbose;
    p->nPercCutoff  = 10;
    p->skipQuant    = 0;
 
    // windowing
    p->vRoots    = Vec_PtrAlloc( 128 );
    p->vBranches = Vec_PtrAlloc( 128 );
 
    // internal AIG package
    // allocate room for objects
    p->nObjsAlloc = ABC_DC_MAX_NODES; 
    p->pObjs = ABC_ALLOC( Odc_Obj_t, p->nObjsAlloc * sizeof(Odc_Obj_t) );
    p->nPis  = nVarsMax + 32;
    p->nObjs = 1 + p->nPis;
    memset( p->pObjs, 0, p->nObjs * sizeof(Odc_Obj_t) );
    // set the PI masks
    for ( i = 0; i < 32; i++ )
        p->pObjs[1 + p->nVarsMax + i].uMask = (1 << i);
    // allocate hash table
    p->nTableSize = p->nObjsAlloc/3 + 1;
    p->pTable = ABC_ALLOC( Odc_Lit_t, p->nTableSize * sizeof(Odc_Lit_t) );
    memset( p->pTable, 0, p->nTableSize * sizeof(Odc_Lit_t) );
    p->vUsedSpots = Vec_IntAlloc( 1000 );
 
    // truth tables
    p->nWords = Abc_TruthWordNum( p->nVarsMax );
    p->nBits = p->nWords * 8 * sizeof(unsigned);
    p->vTruths = Vec_PtrAllocSimInfo( p->nObjsAlloc, p->nWords );
    p->vTruthsElem = Vec_PtrAllocSimInfo( p->nVarsMax, p->nWords );
 
    // set elementary truth tables
    Abc_InfoFill( (unsigned *)Vec_PtrEntry(p->vTruths, 0), p->nWords );
    for ( k = 0; k < p->nVarsMax; k++ )
    {
//        pData = Odc_ObjTruth( p, Odc_Var(p, k) );
        pData = (unsigned *)Vec_PtrEntry( p->vTruthsElem, k );
        Abc_InfoClear( pData, p->nWords );
        for ( i = 0; i < p->nBits; i++ )
            if ( i & (1 << k) )
                pData[i>>5] |= (1 << (i&31));
    }
 
    // set random truth table for the additional inputs
    for ( k = p->nVarsMax; k < p->nPis; k++ )
    {
        pData = Odc_ObjTruth( p, Odc_Var(p, k) );
        Abc_InfoRandom( pData, p->nWords );
    }
 
    // set the miter to the unused value
    p->iRoot = 0xffff;
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareClear()

ABC_DLL void Abc_NtkDontCareClear ( Odc_Man_t * p )

extern

Function*************************************************************

Synopsis [Clears the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 244 of file abcOdc.c.

{
    abctime clk = Abc_Clock();
    // clean the structural hashing table
    if ( Vec_IntSize(p->vUsedSpots) > p->nTableSize/3 ) // more than one third
        memset( p->pTable, 0, sizeof(Odc_Lit_t) * p->nTableSize );
    else
    {
        int iSpot, i;
        Vec_IntForEachEntry( p->vUsedSpots, iSpot, i )
            p->pTable[iSpot] = 0;
    }
    Vec_IntClear( p->vUsedSpots ); 
    // reset the number of nodes
    p->nObjs = 1 + p->nPis;
    // reset the root node
    p->iRoot = 0xffff;
 
p->timeClean += Abc_Clock() - clk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareCompute()

ABC_DLL int Abc_NtkDontCareCompute	(	Odc_Man_t *	p,
		Abc_Obj_t *	pNode,
		Vec_Ptr_t *	vLeaves,
		unsigned *	puTruth )

extern

Function*************************************************************

Synopsis [Computes ODCs for the node in terms of the cut variables.]

Description [Returns the number of don't care minterms in the truth table. In particular, this procedure returns 0 if there is no don't-cares.]

SideEffects []

SeeAlso []

Definition at line 1042 of file abcOdc.c.

{
    int nMints, RetValue;
    abctime clk, clkTotal = Abc_Clock();
 
    p->nWins++;
    
    // set the parameters
    assert( !Abc_ObjIsComplement(pNode) );
    assert( Abc_ObjIsNode(pNode) );
    assert( Vec_PtrSize(vLeaves) <= p->nVarsMax );
    p->vLeaves = vLeaves;
    p->pNode = pNode;
 
    // compute the window
clk = Abc_Clock();
    RetValue = Abc_NtkDontCareWindow( p );
p->timeWin += Abc_Clock() - clk;
    if ( !RetValue )
    {
p->timeAbort += Abc_Clock() - clkTotal;
        Abc_InfoFill( puTruth, p->nWords );
        p->nWinsEmpty++;        
        return 0;
    }
 
    if ( p->fVeryVerbose )
    {
        printf( " %5d : ", pNode->Id );
        printf( "Leaf = %2d ", Vec_PtrSize(p->vLeaves) );
        printf( "Root = %2d ", Vec_PtrSize(p->vRoots) );
        printf( "Bran = %2d ", Vec_PtrSize(p->vBranches) );
        printf( " |  " );
    }
 
    // transfer the window into the AIG package
clk = Abc_Clock();
    Abc_NtkDontCareTransfer( p );
p->timeMiter += Abc_Clock() - clk;
 
    // simulate to estimate the amount of don't-cares
clk = Abc_Clock();
    nMints = Abc_NtkDontCareSimulateBefore( p, puTruth );
p->timeSim += Abc_Clock() - clk;
    if ( p->fVeryVerbose )
    {
        printf( "AIG = %5d ", Odc_NodeNum(p) );
        printf( "%6.2f %%  ", 100.0 * (p->nBits - nMints) / p->nBits );
    }
 
    // if there is less then the given percentage of don't-cares, skip
    if ( 100.0 * (p->nBits - nMints) / p->nBits < 1.0 * p->nPercCutoff )
    {
p->timeAbort += Abc_Clock() - clkTotal;
        if ( p->fVeryVerbose )
            printf( "Simulation cutoff.\n" );
        Abc_InfoFill( puTruth, p->nWords );
        p->nSimsEmpty++;
        return 0;
    }
 
    // quantify external variables
clk = Abc_Clock();
    RetValue = Abc_NtkDontCareQuantify( p );
p->timeQuant += Abc_Clock() - clk;
    if ( !RetValue )
    {
p->timeAbort += Abc_Clock() - clkTotal;
        if ( p->fVeryVerbose )
            printf( "=== Overflow! ===\n" );
        Abc_InfoFill( puTruth, p->nWords );
        p->nQuantsOver++;
        return 0;
    }
 
    // get the truth table
clk = Abc_Clock();
    Abc_NtkDontCareSimulateSetElem( p );
    nMints = Abc_NtkDontCareSimulate( p, puTruth );
p->timeTruth += Abc_Clock() - clk;
    if ( p->fVeryVerbose )
    {
        printf( "AIG = %5d ", Odc_NodeNum(p) );
        printf( "%6.2f %%  ", 100.0 * (p->nBits - nMints) / p->nBits );
        printf( "\n" );
    }
p->timeTotal += Abc_Clock() - clkTotal;
    p->nWinsFinish++;
    p->nTotalDcs += (int)(100.0 * (p->nBits - nMints) / p->nBits);
    return nMints;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDontCareFree()

ABC_DLL void Abc_NtkDontCareFree ( Odc_Man_t * p )

extern

Function*************************************************************

Synopsis [Frees the don't-care manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 276 of file abcOdc.c.

{
    if ( p->fVerbose )
    {
        printf( "Wins = %5d. Empty = %5d. SimsEmpty = %5d. QuantOver = %5d. WinsFinish = %5d.\n", 
            p->nWins, p->nWinsEmpty, p->nSimsEmpty, p->nQuantsOver, p->nWinsFinish );
        printf( "Ave DCs per window = %6.2f %%. Ave DCs per finished window = %6.2f %%.\n", 
            1.0*p->nTotalDcs/p->nWins, 1.0*p->nTotalDcs/p->nWinsFinish );
        printf( "Runtime stats of the ODC manager:\n" );
        ABC_PRT( "Cleaning    ", p->timeClean );
        ABC_PRT( "Windowing   ", p->timeWin   );
        ABC_PRT( "Miter       ", p->timeMiter );
        ABC_PRT( "Simulation  ", p->timeSim   );
        ABC_PRT( "Quantifying ", p->timeQuant );
        ABC_PRT( "Truth table ", p->timeTruth );
        ABC_PRT( "TOTAL       ", p->timeTotal );
        ABC_PRT( "Aborted     ", p->timeAbort );
    }
    Vec_PtrFree( p->vRoots );
    Vec_PtrFree( p->vBranches );
    Vec_PtrFree( p->vTruths );
    Vec_PtrFree( p->vTruthsElem );
    Vec_IntFree( p->vUsedSpots );
    ABC_FREE( p->pObjs );
    ABC_FREE( p->pTable );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Abc_NtkDup()

ABC_DLL Abc_Ntk_t * Abc_NtkDup ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Duplicate the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 472 of file abcNtk.c.

{
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pObj, * pFanin;
    int i, k;
    if ( pNtk == NULL )
        return NULL;
    // start the network
    pNtkNew = Abc_NtkStartFrom( pNtk, pNtk->ntkType, pNtk->ntkFunc );
    // copy the internal nodes
    if ( Abc_NtkIsStrash(pNtk) )
    {
        // copy the AND gates
        Abc_AigForEachAnd( pNtk, pObj, i )
            pObj->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkNew->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
        // relink the choice nodes
        Abc_AigForEachAnd( pNtk, pObj, i )
            if ( pObj->pData )
                pObj->pCopy->pData = ((Abc_Obj_t *)pObj->pData)->pCopy;
        // relink the CO nodes
        Abc_NtkForEachCo( pNtk, pObj, i )
            Abc_ObjAddFanin( pObj->pCopy, Abc_ObjChild0Copy(pObj) );
        // get the number of nodes before and after
        if ( Abc_NtkNodeNum(pNtk) != Abc_NtkNodeNum(pNtkNew) )
            printf( "Warning: Structural hashing during duplication reduced %d nodes (this is a minor bug).\n",
                Abc_NtkNodeNum(pNtk) - Abc_NtkNodeNum(pNtkNew) );
    }
    else
    {
        // duplicate the nets and nodes (CIs/COs/latches already dupped)
        Abc_NtkForEachObj( pNtk, pObj, i )
            if ( pObj->pCopy == NULL )
                Abc_NtkDupObj(pNtkNew, pObj, Abc_NtkHasBlackbox(pNtk) && Abc_ObjIsNet(pObj));
        // reconnect all objects (no need to transfer attributes on edges)
        Abc_NtkForEachObj( pNtk, pObj, i )
            if ( !Abc_ObjIsBox(pObj) && !Abc_ObjIsBo(pObj) )
                Abc_ObjForEachFanin( pObj, pFanin, k )
                    Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
        // move object IDs
        if ( pNtk->vOrigNodeIds ) 
        {
            pNtkNew->vOrigNodeIds = Vec_IntStartFull( Abc_NtkObjNumMax(pNtkNew) );
            Abc_NtkForEachObj( pNtk, pObj, i )
                if ( pObj->pCopy && Vec_IntEntry(pNtk->vOrigNodeIds, pObj->Id) > 0 )
                    Vec_IntWriteEntry( pNtkNew->vOrigNodeIds, pObj->pCopy->Id, Vec_IntEntry(pNtk->vOrigNodeIds, pObj->Id) );
        }
        
    }
    // duplicate the EXDC Ntk
    if ( pNtk->pExdc )
        pNtkNew->pExdc = Abc_NtkDup( pNtk->pExdc );
    if ( pNtk->pExcare )
        pNtkNew->pExcare = Abc_NtkDup( (Abc_Ntk_t *)pNtk->pExcare );
    // duplicate timing manager
    if ( pNtk->pManTime )
        Abc_NtkTimeInitialize( pNtkNew, pNtk );
    if ( pNtk->vPhases )
        Abc_NtkTransferPhases( pNtkNew, pNtk );
    if ( pNtk->pWLoadUsed )
        pNtkNew->pWLoadUsed = Abc_UtilStrsav( pNtk->pWLoadUsed );
    // check correctness
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkDup(): Network check has failed.\n" );
    pNtk->pCopy = pNtkNew;
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDupBox()

ABC_DLL Abc_Obj_t * Abc_NtkDupBox	(	Abc_Ntk_t *	pNtkNew,
		Abc_Obj_t *	pBox,
		int	fCopyName )

extern

Function*************************************************************

Synopsis [Duplicates the latch with its input/output terminals.]

Description []

SideEffects []

SeeAlso []

Definition at line 415 of file abcObj.c.

{
    Abc_Obj_t * pTerm, * pBoxNew;
    int i;
    assert( Abc_ObjIsBox(pBox) );
    // duplicate the box 
    pBoxNew = Abc_NtkDupObj( pNtkNew, pBox, fCopyName );
    // duplicate the fanins and connect them
    Abc_ObjForEachFanin( pBox, pTerm, i )
        Abc_ObjAddFanin( pBoxNew, Abc_NtkDupObj(pNtkNew, pTerm, fCopyName) );
    // duplicate the fanouts and connect them
    Abc_ObjForEachFanout( pBox, pTerm, i )
        Abc_ObjAddFanin( Abc_NtkDupObj(pNtkNew, pTerm, fCopyName), pBoxNew );
    return pBoxNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDupDfs()

ABC_DLL Abc_Ntk_t * Abc_NtkDupDfs ( Abc_Ntk_t * pNtk )

extern

Definition at line 538 of file abcNtk.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pObj, * pFanin;
    int i, k;
    if ( pNtk == NULL )
        return NULL;
    assert( !Abc_NtkIsStrash(pNtk) && !Abc_NtkIsNetlist(pNtk) );
    // start the network
    pNtkNew = Abc_NtkStartFrom( pNtk, pNtk->ntkType, pNtk->ntkFunc );
    // copy the internal nodes
    vNodes = Abc_NtkDfs( pNtk, 0 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
        Abc_NtkDupObj( pNtkNew, pObj, 0 );
    Vec_PtrFree( vNodes );
    // reconnect all objects (no need to transfer attributes on edges)
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( !Abc_ObjIsBox(pObj) && !Abc_ObjIsBo(pObj) )
            Abc_ObjForEachFanin( pObj, pFanin, k )
                if ( pObj->pCopy && pFanin->pCopy )
                    Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
    // duplicate the EXDC Ntk
    if ( pNtk->pExdc )
        pNtkNew->pExdc = Abc_NtkDup( pNtk->pExdc );
    if ( pNtk->pExcare )
        pNtkNew->pExcare = Abc_NtkDup( (Abc_Ntk_t *)pNtk->pExcare );
    // duplicate timing manager
    if ( pNtk->pManTime )
        Abc_NtkTimeInitialize( pNtkNew, pNtk );
    if ( pNtk->vPhases )
        Abc_NtkTransferPhases( pNtkNew, pNtk );
    if ( pNtk->pWLoadUsed )
        pNtkNew->pWLoadUsed = Abc_UtilStrsav( pNtk->pWLoadUsed );
    // check correctness
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkDup(): Network check has failed.\n" );
    pNtk->pCopy = pNtkNew;
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDupDfsNoBarBufs()

ABC_DLL Abc_Ntk_t * Abc_NtkDupDfsNoBarBufs ( Abc_Ntk_t * pNtk )

extern

Definition at line 578 of file abcNtk.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pObj, * pFanin;
    int i, k;
    if ( pNtk == NULL )
        return NULL;
    assert( Abc_NtkIsLogic(pNtk) );
    assert( pNtk->nBarBufs2 > 0 );
    // start the network
    pNtkNew = Abc_NtkStartFrom( pNtk, pNtk->ntkType, pNtk->ntkFunc );
    // copy the internal nodes
    vNodes = Abc_NtkDfs2( pNtk );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
        if ( Abc_ObjIsBarBuf(pObj) )
            pObj->pCopy = Abc_ObjFanin0(pObj)->pCopy;
        else
            Abc_NtkDupObj( pNtkNew, pObj, 0 );
    Vec_PtrFree( vNodes );
    // reconnect all objects (no need to transfer attributes on edges)
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( !Abc_ObjIsBox(pObj) && !Abc_ObjIsBo(pObj) && !Abc_ObjIsBarBuf(pObj) )
            Abc_ObjForEachFanin( pObj, pFanin, k )
                if ( pObj->pCopy && pFanin->pCopy )
                    Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
    // duplicate the EXDC Ntk
    if ( pNtk->pExdc )
        pNtkNew->pExdc = Abc_NtkDup( pNtk->pExdc );
    if ( pNtk->pExcare )
        pNtkNew->pExcare = Abc_NtkDup( (Abc_Ntk_t *)pNtk->pExcare );
    // duplicate timing manager
    if ( pNtk->pManTime )
        Abc_NtkTimeInitialize( pNtkNew, pNtk );
    if ( pNtk->vPhases )
        Abc_NtkTransferPhases( pNtkNew, pNtk );
    if ( pNtk->pWLoadUsed )
        pNtkNew->pWLoadUsed = Abc_UtilStrsav( pNtk->pWLoadUsed );
    // check correctness
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkDup(): Network check has failed.\n" );
    pNtk->pCopy = pNtkNew;
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkDupObj()

ABC_DLL Abc_Obj_t * Abc_NtkDupObj	(	Abc_Ntk_t *	pNtkNew,
		Abc_Obj_t *	pObj,
		int	fCopyName )

extern

Function*************************************************************

Synopsis [Duplicate the Obj.]

Description []

SideEffects []

SeeAlso []

Definition at line 342 of file abcObj.c.

{
    Abc_Obj_t * pObjNew;
    // create the new object
    pObjNew = Abc_NtkCreateObj( pNtkNew, (Abc_ObjType_t)pObj->Type );
    // transfer names of the terminal objects
    if ( fCopyName )
    {
        if ( Abc_ObjIsCi(pObj) )
        {
            if ( !Abc_NtkIsNetlist(pNtkNew) )
                Abc_ObjAssignName( pObjNew, Abc_ObjName(Abc_ObjFanout0Ntk(pObj)), NULL );
        }
        else if ( Abc_ObjIsCo(pObj) )
        {
            if ( !Abc_NtkIsNetlist(pNtkNew) )
            {
                if ( Abc_ObjIsPo(pObj) )
                    Abc_ObjAssignName( pObjNew, Abc_ObjName(Abc_ObjFanin0Ntk(pObj)), NULL );
                else
                {
                    assert( Abc_ObjIsLatch(Abc_ObjFanout0(pObj)) );
                    Abc_ObjAssignName( pObjNew, Abc_ObjName(pObj), NULL );
                }
            }
        }
        else if ( Abc_ObjIsBox(pObj) || Abc_ObjIsNet(pObj) )
            Abc_ObjAssignName( pObjNew, Abc_ObjName(pObj), NULL );
    }
    // copy functionality/names
    if ( Abc_ObjIsNode(pObj) ) // copy the function if functionality is compatible
    {
        if ( pNtkNew->ntkFunc == pObj->pNtk->ntkFunc ) 
        {
            if ( Abc_NtkIsStrash(pNtkNew) ) 
            {}
            else if ( Abc_NtkHasSop(pNtkNew) || Abc_NtkHasBlifMv(pNtkNew) )
                pObjNew->pData = Abc_SopRegister( (Mem_Flex_t *)pNtkNew->pManFunc, (char *)pObj->pData );
#ifdef ABC_USE_CUDD
            else if ( Abc_NtkHasBdd(pNtkNew) )
                pObjNew->pData = Cudd_bddTransfer((DdManager *)pObj->pNtk->pManFunc, (DdManager *)pNtkNew->pManFunc, (DdNode *)pObj->pData), Cudd_Ref((DdNode *)pObjNew->pData);
#endif
            else if ( Abc_NtkHasAig(pNtkNew) )
                pObjNew->pData = Hop_Transfer((Hop_Man_t *)pObj->pNtk->pManFunc, (Hop_Man_t *)pNtkNew->pManFunc, (Hop_Obj_t *)pObj->pData, Abc_ObjFaninNum(pObj));
            else if ( Abc_NtkHasMapping(pNtkNew) )
                pObjNew->pData = pObj->pData, pNtkNew->nBarBufs2 += !pObj->pData;
            else assert( 0 );
        }
    }
    else if ( Abc_ObjIsNet(pObj) ) // copy the name
    {
    }
    else if ( Abc_ObjIsLatch(pObj) ) // copy the reset value
        pObjNew->pData = pObj->pData;
    pObjNew->fPersist = pObj->fPersist;
    // transfer HAIG
//    pObjNew->pEquiv = pObj->pEquiv;
    // remember the new node in the old node
    pObj->pCopy = pObjNew;
    return pObjNew;
}

Here is the call graph for this function:

◆ Abc_NtkDupTransformMiter()

ABC_DLL Abc_Ntk_t * Abc_NtkDupTransformMiter ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Duplicate the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 669 of file abcNtk.c.

{
    Abc_Ntk_t * pNtkNew;
    Abc_Obj_t * pObj, * pObj2, * pMiter;
    int i;
    assert( Abc_NtkIsStrash(pNtk) );
    // start the network
    pNtkNew = Abc_NtkAlloc( pNtk->ntkType, pNtk->ntkFunc, 1 );
    pNtkNew->nConstrs   = pNtk->nConstrs;
    pNtkNew->nBarBufs   = pNtk->nBarBufs;
    // duplicate the name and the spec
    pNtkNew->pName = Extra_UtilStrsav(pNtk->pName);
    pNtkNew->pSpec = Extra_UtilStrsav(pNtk->pSpec);
    // clean the node copy fields
    Abc_NtkCleanCopy( pNtk );
    // map the constant nodes
     Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkNew);
    // clone CIs/CIs/boxes
    Abc_NtkForEachPi( pNtk, pObj, i )
        Abc_NtkDupObj( pNtkNew, pObj, 1 );
    Abc_NtkForEachPo( pNtk, pObj, i )
        Abc_NtkDupObj( pNtkNew, pObj, 1 ), i++;
    Abc_NtkForEachBox( pNtk, pObj, i )
        Abc_NtkDupBox( pNtkNew, pObj, 1 );
    // copy the AND gates
    Abc_AigForEachAnd( pNtk, pObj, i )
        pObj->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkNew->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
    // create new miters
    Abc_NtkForEachPo( pNtk, pObj, i )
    {
        pObj2 = Abc_NtkPo( pNtk, ++i );
        pMiter = Abc_AigXor( (Abc_Aig_t *)pNtkNew->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild0Copy(pObj2) );
        Abc_ObjAddFanin( pObj->pCopy, pMiter );
    }
    Abc_NtkForEachLatchInput( pNtk, pObj, i )
        Abc_ObjAddFanin( pObj->pCopy, Abc_ObjChild0Copy(pObj) );
    // cleanup
    Abc_AigCleanup( (Abc_Aig_t *)pNtkNew->pManFunc );
    // check that the CI/CO/latches are copied correctly
    assert( Abc_NtkPiNum(pNtk) == Abc_NtkPiNum(pNtkNew) );
    assert( Abc_NtkPoNum(pNtk) == 2*Abc_NtkPoNum(pNtkNew) );
    assert( Abc_NtkLatchNum(pNtk) == Abc_NtkLatchNum(pNtkNew) );
    return pNtkNew;
}

Here is the call graph for this function:

◆ Abc_NtkFanoutCounts()

ABC_DLL Vec_Int_t * Abc_NtkFanoutCounts ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Creates the array of fanout counters.]

Description []

SideEffects []

SeeAlso []

Definition at line 1741 of file abcUtil.c.

{
    Vec_Int_t * vFanNums;
    Abc_Obj_t * pObj;
    int i;
    vFanNums = Vec_IntAlloc( 0 );
    Vec_IntFill( vFanNums, Abc_NtkObjNumMax(pNtk), -1 );
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( Abc_ObjIsCi(pObj) || Abc_ObjIsNode(pObj) )
            Vec_IntWriteEntry( vFanNums, i, Abc_ObjFanoutNum(pObj) );
    return vFanNums;
}

Here is the caller graph for this function:

◆ Abc_NtkFetchTwinNode()

ABC_DLL Abc_Obj_t * Abc_NtkFetchTwinNode ( Abc_Obj_t * pNode )

extern

Function*************************************************************

Synopsis [Returns the twin node if it exists.]

Description []

SideEffects []

SeeAlso []

Definition at line 804 of file abcMap.c.

{
    Abc_Obj_t * pNode2;
    Mio_Gate_t * pGate = (Mio_Gate_t *)pNode->pData;
    assert( Abc_NtkHasMapping(pNode->pNtk) );
    if ( pGate == NULL || Mio_GateReadTwin(pGate) == NULL )
        return NULL;
    // assuming the twin node is following next
    if ( (int)Abc_ObjId(pNode) == Abc_NtkObjNumMax(pNode->pNtk) - 1 )
        return NULL;
    pNode2 = Abc_NtkObj( pNode->pNtk, Abc_ObjId(pNode) + 1 );
    if ( pNode2 == NULL || !Abc_ObjIsNode(pNode2) || Abc_ObjFaninNum(pNode) != Abc_ObjFaninNum(pNode2) )
        return NULL;
    if ( Mio_GateReadTwin(pGate) != (Mio_Gate_t *)pNode2->pData )
        return NULL;
    return pNode2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFillTemp()

ABC_DLL void Abc_NtkFillTemp ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Cleans the copy field of all objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 586 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->iTemp = -1;
}

Here is the caller graph for this function:

◆ Abc_NtkFinalize()

ABC_DLL void Abc_NtkFinalize	(	Abc_Ntk_t *	pNtk,
		Abc_Ntk_t *	pNtkNew )

extern

Function*************************************************************

Synopsis [Finalizes the network using the existing network as a model.]

Description []

SideEffects []

SeeAlso []

Definition at line 355 of file abcNtk.c.

{
    Abc_Obj_t * pObj, * pDriver, * pDriverNew;
    int i;
    // set the COs of the strashed network
    Abc_NtkForEachCo( pNtk, pObj, i )
    {
        pDriver    = Abc_ObjFanin0Ntk( Abc_ObjFanin0(pObj) );
        pDriverNew = Abc_ObjNotCond(pDriver->pCopy, Abc_ObjFaninC0(pObj));
        Abc_ObjAddFanin( pObj->pCopy, pDriverNew );
    }
    // duplicate timing manager
    if ( pNtk->pManTime )
        Abc_NtkTimeInitialize( pNtkNew, pNtk );
    if ( pNtk->vPhases )
        Abc_NtkTransferPhases( pNtkNew, pNtk );
    if ( pNtk->pWLoadUsed )
        pNtkNew->pWLoadUsed = Abc_UtilStrsav( pNtk->pWLoadUsed );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFinalizeRead()

ABC_DLL void Abc_NtkFinalizeRead ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Finalizes the network using the existing network as a model.]

Description []

SideEffects []

SeeAlso []

Definition at line 413 of file abcNtk.c.

{
    Abc_Obj_t * pBox, * pObj, * pTerm, * pNet;
    int i;
    if ( Abc_NtkHasBlackbox(pNtk) && Abc_NtkBoxNum(pNtk) == 0 )
    {
        pBox = Abc_NtkCreateBlackbox(pNtk);
        Abc_NtkForEachPi( pNtk, pObj, i )
        {
            pTerm = Abc_NtkCreateBi(pNtk);
            Abc_ObjAddFanin( pTerm, Abc_ObjFanout0(pObj) );
            Abc_ObjAddFanin( pBox, pTerm );
        }
        Abc_NtkForEachPo( pNtk, pObj, i )
        {
            pTerm = Abc_NtkCreateBo(pNtk);
            Abc_ObjAddFanin( pTerm, pBox );
            Abc_ObjAddFanin( Abc_ObjFanin0(pObj), pTerm );
        }
        return;
    }
    assert( Abc_NtkIsNetlist(pNtk) );
 
    // check if constant 0 net is used
    pNet = Abc_NtkFindNet( pNtk, "1\'b0" );
    if ( pNet )
    {
        if ( Abc_ObjFanoutNum(pNet) == 0 )
            Abc_NtkDeleteObj(pNet);
        else if ( Abc_ObjFaninNum(pNet) == 0 )
            Abc_ObjAddFanin( pNet, Abc_NtkCreateNodeConst0(pNtk) );
    }
    // check if constant 1 net is used
    pNet = Abc_NtkFindNet( pNtk, "1\'b1" );
    if ( pNet )
    {
        if ( Abc_ObjFanoutNum(pNet) == 0 )
            Abc_NtkDeleteObj(pNet);
        else if ( Abc_ObjFaninNum(pNet) == 0 )
            Abc_ObjAddFanin( pNet, Abc_NtkCreateNodeConst1(pNtk) );
    }
    // fix the net drivers
    Abc_NtkFixNonDrivenNets( pNtk );
 
    // reorder the CI/COs to PI/POs first
    Abc_NtkOrderCisCos( pNtk );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFindCi()

ABC_DLL Abc_Obj_t * Abc_NtkFindCi	(	Abc_Ntk_t *	pNtk,
		char *	pName )

extern

Function*************************************************************

Synopsis [Returns CI with the given name.]

Description []

SideEffects []

SeeAlso []

Definition at line 538 of file abcObj.c.

{
    int Num;
    assert( !Abc_NtkIsNetlist(pNtk) );
    Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_PI );
    if ( Num >= 0 )
        return Abc_NtkObj( pNtk, Num );
    Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_BO );
    if ( Num >= 0 )
        return Abc_NtkObj( pNtk, Num );
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFindCo()

ABC_DLL Abc_Obj_t * Abc_NtkFindCo	(	Abc_Ntk_t *	pNtk,
		char *	pName )

extern

Function*************************************************************

Synopsis [Returns CO with the given name.]

Description []

SideEffects []

SeeAlso []

Definition at line 562 of file abcObj.c.

{
    int Num;
    assert( !Abc_NtkIsNetlist(pNtk) );
    Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_PO );
    if ( Num >= 0 )
        return Abc_NtkObj( pNtk, Num );
    Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_BI );
    if ( Num >= 0 )
        return Abc_NtkObj( pNtk, Num );
    return NULL;
}

Here is the call graph for this function:

◆ Abc_NtkFindExact()

ABC_DLL Abc_Ntk_t * Abc_NtkFindExact	(	word *	pTruth,
		int	nVars,
		int	nFunc,
		int	nMaxDepth,
		int *	pArrTimeProfile,
		int	nBTLimit,
		int	nStartGates,
		int	fVerbose )

extern

Function*************************************************************

Synopsis [Find minimum size networks with a SAT solver.]

Description [If nMaxDepth is -1, then depth constraints are ignored. If nMaxDepth is not -1, one can set pArrTimeProfile which should have the length of nVars. One can ignore pArrTimeProfile by setting it to NULL.]

SideEffects []

SeeAlso []

Definition at line 2414 of file abcExact.c.

{
    Ses_Man_t * pSes;
    char * pSol;
    Abc_Ntk_t * pNtk = NULL;
    abctime timeStart;
 
    /* some checks */
    assert( nVars >= 2 && nVars <= 8 );
 
    timeStart = Abc_Clock();
 
    pSes = Ses_ManAlloc( pTruth, nVars, nFunc, nMaxDepth, pArrTimeProfile, 0, nBTLimit, fVerbose );
    pSes->nStartGates = nStartGates;
    pSes->fReasonVerbose = 0;
    pSes->fSatVerbose = 0;
    if ( fVerbose )
        Ses_ManPrintFuncs( pSes );
 
    if ( ( pSol = Ses_ManFindMinimumSize( pSes ) ) != NULL )
    {
        pNtk = Ses_ManExtractNtk( pSol );
        ABC_FREE( pSol );
    }
 
    pSes->timeTotal = Abc_Clock() - timeStart;
 
    if ( fVerbose )
        Ses_ManPrintRuntime( pSes );
 
    /* cleanup */
    Ses_ManClean( pSes );
 
    return pNtk;
}

Here is the caller graph for this function:

◆ Abc_NtkFindNet()

ABC_DLL Abc_Obj_t * Abc_NtkFindNet	(	Abc_Ntk_t *	pNtk,
		char *	pName )

extern

Function*************************************************************

Synopsis [Returns the net with the given name.]

Description []

SideEffects []

SeeAlso []

Definition at line 515 of file abcObj.c.

{
    Abc_Obj_t * pNet;
    int ObjId;
    assert( Abc_NtkIsNetlist(pNtk) );
    ObjId = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_NET );
    if ( ObjId == -1 )
        return NULL;
    pNet = Abc_NtkObj( pNtk, ObjId );
    return pNet;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFindNode()

ABC_DLL Abc_Obj_t * Abc_NtkFindNode	(	Abc_Ntk_t *	pNtk,
		char *	pName )

extern

Function*************************************************************

Synopsis [Returns the net with the given name.]

Description []

SideEffects []

SeeAlso []

Definition at line 464 of file abcObj.c.

{
    Abc_Obj_t * pObj;
    int Num;
    // try to find the terminal
    Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_PO );
    if ( Num >= 0 )
        return Abc_ObjFanin0( Abc_NtkObj( pNtk, Num ) );
    Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_BI );
    if ( Num >= 0 )
        return Abc_ObjFanin0( Abc_NtkObj( pNtk, Num ) );
    Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_NODE );
    if ( Num >= 0 )
        return Abc_NtkObj( pNtk, Num );
    // find the internal node
    if ( pName[0] != 'n' )
    {
        printf( "Name \"%s\" is not found among CO or node names (internal names often look as \"n<num>\").\n", pName );
        return NULL;
    }
    Num = atoi( pName + 1 );
    if ( Num < 0 || Num >= Abc_NtkObjNumMax(pNtk) )
    {
        printf( "The node \"%s\" with ID %d is not in the current network.\n", pName, Num );
        return NULL;
    }
    pObj = Abc_NtkObj( pNtk, Num );
    if ( pObj == NULL )
    {
        printf( "The node \"%s\" with ID %d has been removed from the current network.\n", pName, Num );
        return NULL;
    }
    if ( !Abc_ObjIsNode(pObj) )
    {
        printf( "Object with ID %d is not a node.\n", Num );
        return NULL;
    }
    return pObj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFindOrCreateNet()

ABC_DLL Abc_Obj_t * Abc_NtkFindOrCreateNet	(	Abc_Ntk_t *	pNtk,
		char *	pName )

extern

Function*************************************************************

Synopsis [Finds or creates the net.]

Description []

SideEffects []

SeeAlso []

Definition at line 587 of file abcObj.c.

{
    Abc_Obj_t * pNet;
    assert( Abc_NtkIsNetlist(pNtk) );
    if ( pName && (pNet = Abc_NtkFindNet( pNtk, pName )) )
        return pNet;
//printf( "Creating net %s.\n", pName );
    // create a new net
    pNet = Abc_NtkCreateNet( pNtk );
    if ( pName )
        Nm_ManStoreIdName( pNtk->pManName, pNet->Id, pNet->Type, pName, NULL );
    return pNet;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFixNonDrivenNets()

ABC_DLL void Abc_NtkFixNonDrivenNets ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Reads the verilog file.]

Description []

SideEffects []

SeeAlso []

Definition at line 1557 of file abcNtk.c.

{ 
    Vec_Ptr_t * vNets;
    Abc_Obj_t * pNet, * pNode;
    int i;
 
    if ( Abc_NtkNodeNum(pNtk) == 0 && Abc_NtkBoxNum(pNtk) == 0 )
        return;
 
    // special case
    pNet = Abc_NtkFindNet( pNtk, "$false" );
    if ( pNet != NULL )
    {
        pNode = Abc_NtkCreateNodeConst0( pNtk );
        Abc_ObjAddFanin( pNet, pNode );
    }
    pNet = Abc_NtkFindNet( pNtk, "$undef" );
    if ( pNet != NULL )
    {
        pNode = Abc_NtkCreateNodeConst0( pNtk );
        Abc_ObjAddFanin( pNet, pNode );
    }
    pNet = Abc_NtkFindNet( pNtk, "$true" );
    if ( pNet != NULL )
    {
        pNode = Abc_NtkCreateNodeConst1( pNtk );
        Abc_ObjAddFanin( pNet, pNode );
    }
    pNet = Abc_NtkFindNet( pNtk, "[_c1_]" );
    if ( pNet != NULL )
    {
        pNode = Abc_NtkCreateNodeConst1( pNtk );
        Abc_ObjAddFanin( pNet, pNode );
    }
 
    // check for non-driven nets
    vNets = Vec_PtrAlloc( 100 );
    Abc_NtkForEachNet( pNtk, pNet, i )
    {
        if ( Abc_ObjFaninNum(pNet) > 0 )
            continue;
        // add the constant 0 driver
        pNode = Abc_NtkCreateNodeConst0( pNtk );
        // add the fanout net
        Abc_ObjAddFanin( pNet, pNode );
        // add the net to those for which the warning will be printed
        Vec_PtrPush( vNets, pNet );
    }
 
    // print the warning
    if ( vNets->nSize > 0 )
    {
        printf( "Warning: Constant-0 drivers added to %d non-driven nets in network \"%s\":\n", Vec_PtrSize(vNets), pNtk->pName );
        Vec_PtrForEachEntry( Abc_Obj_t *, vNets, pNet, i )
        {
            printf( "%s%s", (i? ", ": ""), Abc_ObjName(pNet) );
            if ( i == 3 )
            {
                if ( Vec_PtrSize(vNets) > 3 )
                    printf( " ..." );
                break;
            }
        }
        printf( "\n" );
    }
    Vec_PtrFree( vNets );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFlattenHierarchyGia()

ABC_DLL Gia_Man_t * Abc_NtkFlattenHierarchyGia	(	Abc_Ntk_t *	pNtk,
		Vec_Ptr_t **	pvBuffers,
		int	fVerbose )

extern

Definition at line 418 of file abcHieGia.c.

{
    int fUseBufs = 1;
    Gia_Man_t * pNew, * pTemp; 
    Abc_Ntk_t * pModel;
    Abc_Obj_t * pTerm;
    Vec_Ptr_t * vSupers;
    Vec_Ptr_t * vBuffers = fUseBufs ? Vec_PtrAlloc(1000) : NULL;
    int i, Counter = 0; 
    assert( Abc_NtkIsNetlist(pNtk) );
//    Abc_NtkPrintBoxInfo( pNtk );
 
    // set the PI/PO numbers
    Counter -= Abc_NtkPiNum(pNtk) + Abc_NtkPoNum(pNtk);
    if ( !pNtk->pDesign )
        Counter += Gia_ManFlattenLogicPrepare( pNtk );
    else
        Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pModel, i )
            Counter += Gia_ManFlattenLogicPrepare( pModel );
 
    // start the manager
    pNew = Gia_ManStart( Abc_NtkObjNumMax(pNtk) );
    pNew->pName = Abc_UtilStrsav(pNtk->pName);
    pNew->pSpec = Abc_UtilStrsav(pNtk->pSpec);
 
    // create PIs and buffers
    Abc_NtkForEachPi( pNtk, pTerm, i )
        pTerm->iTemp = Gia_ManAppendCi( pNew );
 
    // call recursively
    vSupers = Vec_PtrAlloc( 100 );
    Gia_ManHashAlloc( pNew );
    Abc_NtkForEachPo( pNtk, pTerm, i )
        Abc_NtkFlattenHierarchyGia_rec( pNew, vSupers, pTerm, vBuffers );
    Gia_ManHashStop( pNew );
    Vec_PtrFree( vSupers );
    printf( "Hierarchy reader flattened %d instances of boxes and added %d barbufs (out of %d).\n", 
        pNtk->pDesign ? Vec_PtrSize(pNtk->pDesign->vModules)-1 : 0, Vec_PtrSize(vBuffers), Counter );
 
    // create buffers and POs
    Abc_NtkForEachPo( pNtk, pTerm, i )
        Gia_ManAppendCo( pNew, pTerm->iTemp );
 
    if ( pvBuffers )
        *pvBuffers = vBuffers;
    else
        Vec_PtrFreeP( &vBuffers );
 
    // cleanup
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
//    Gia_ManPrintStats( pNew, NULL );
    pNew = Gia_ManSweepHierarchy( pTemp = pNew );
    Gia_ManStop( pTemp );
//    Gia_ManPrintStats( pNew, NULL );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFlattenLogicHierarchy()

ABC_DLL Abc_Ntk_t * Abc_NtkFlattenLogicHierarchy ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Flattens the logic hierarchy of the netlist.]

Description []

SideEffects []

SeeAlso []

Definition at line 514 of file abcHie.c.

{
    extern Abc_Des_t * Abc_DesDupBlackboxes( Abc_Des_t * p, Abc_Ntk_t * pNtkSave );
    Vec_Str_t * vPref;
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pTerm, * pNet;
    int i, Counter = -1;
 
    assert( Abc_NtkIsNetlist(pNtk) );
//    Abc_NtkPrintBoxInfo( pNtk );
 
    // start the network
    pNtkNew = Abc_NtkAlloc( pNtk->ntkType, pNtk->ntkFunc, 1 );
    // duplicate the name and the spec
    pNtkNew->pName = Extra_UtilStrsav(pNtk->pName);
    pNtkNew->pSpec = Extra_UtilStrsav(pNtk->pSpec);
 
    // clean the node copy fields
    Abc_NtkCleanCopy( pNtk );
 
    // duplicate PIs/POs and their nets
    Abc_NtkForEachPi( pNtk, pTerm, i )
    {
        Abc_NtkDupObj( pNtkNew, pTerm, 0 );
        pNet = Abc_ObjFanout0( pTerm );
        pNet->pCopy = Abc_NtkFindOrCreateNet( pNtkNew, Abc_ObjName(pNet) );
        Abc_ObjAddFanin( pNet->pCopy, pTerm->pCopy );
    }
    Abc_NtkForEachPo( pNtk, pTerm, i )
    {
        Abc_NtkDupObj( pNtkNew, pTerm, 0 );
        pNet = Abc_ObjFanin0( pTerm );
        pNet->pCopy = Abc_NtkFindOrCreateNet( pNtkNew, Abc_ObjName(pNet) );
        Abc_ObjAddFanin( pTerm->pCopy, pNet->pCopy );
    }
 
    // recursively flatten hierarchy, create internal logic, add new PI/PO names if there are black boxes
    vPref = Vec_StrAlloc( 1000 );
    Vec_StrPrintStr( vPref, Abc_NtkName(pNtk) );
    Abc_NtkFlattenLogicHierarchy_rec( pNtkNew, pNtk, &Counter, vPref );
    printf( "Hierarchy reader flattened %d instances of logic boxes and left %d black boxes.\n", 
        Counter, Abc_NtkBlackboxNum(pNtkNew) );
    Vec_StrFree( vPref );
 
    if ( pNtk->pDesign )
    {
        // pass on the design
        assert( Vec_PtrEntry(pNtk->pDesign->vTops, 0) == pNtk );
        pNtkNew->pDesign = Abc_DesDupBlackboxes( pNtk->pDesign, pNtkNew );
        // update the pointers
        Abc_NtkForEachBlackbox( pNtkNew, pTerm, i )
            pTerm->pData = ((Abc_Ntk_t *)pTerm->pData)->pCopy;
    }
 
    // we may have added property outputs
    Abc_NtkOrderCisCos( pNtkNew );
 
    // copy the timing information
//    Abc_ManTimeDup( pNtk, pNtkNew );
    // duplicate EXDC 
    if ( pNtk->pExdc )
        printf( "EXDC is not transformed.\n" );
    if ( !Abc_NtkCheck( pNtkNew ) )
    {
        fprintf( stdout, "Abc_NtkFlattenLogicHierarchy(): Network check has failed.\n" );
        Abc_NtkDelete( pNtkNew );
        return NULL;
    }
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFraig()

ABC_DLL Abc_Ntk_t * Abc_NtkFraig	(	Abc_Ntk_t *	pNtk,
		void *	pParams,
		int	fAllNodes,
		int	fExdc )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Interfaces the network with the FRAIG package.]

Description []

SideEffects []

SeeAlso []

Definition at line 58 of file abcFraig.c.

{
    Fraig_Params_t * pPars = (Fraig_Params_t *)pParams;
    Abc_Ntk_t * pNtkNew;
    Fraig_Man_t * pMan; 
    // check if EXDC is present
    if ( fExdc && pNtk->pExdc == NULL )
        fExdc = 0, printf( "Warning: Networks has no EXDC.\n" );
    // perform fraiging
    pMan = (Fraig_Man_t *)Abc_NtkToFraig( pNtk, pParams, fAllNodes, fExdc ); 
    // add algebraic choices
//    if ( pPars->fChoicing )
//        Fraig_ManAddChoices( pMan, 0, 6 );
    // prove the miter if asked to
    if ( pPars->fTryProve )
        Fraig_ManProveMiter( pMan );
    // reconstruct FRAIG in the new network
    if ( fExdc ) 
        pNtkNew = Abc_NtkFromFraig2( pMan, pNtk );
    else
        pNtkNew = Abc_NtkFromFraig( pMan, pNtk );
    Fraig_ManFree( pMan );
    if ( pNtk->pExdc )
        pNtkNew->pExdc = Abc_NtkDup( pNtk->pExdc );
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkNew ) )
    {
        printf( "Abc_NtkFraig: The network check has failed.\n" );
        Abc_NtkDelete( pNtkNew );
        return NULL;
    }
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFraigRestore()

ABC_DLL Abc_Ntk_t * Abc_NtkFraigRestore	(	int	nPatsRand,
		int	nPatsDyna,
		int	nBTLimit )

extern

Function*************************************************************

Synopsis [Interfaces the network with the FRAIG package.]

Description []

SideEffects []

SeeAlso []

Definition at line 698 of file abcFraig.c.

{
    extern Abc_Ntk_t * Abc_NtkFraigPartitioned( Vec_Ptr_t * vStore, void * pParams );
    Fraig_Params_t Params;
    Vec_Ptr_t * vStore;
    Abc_Ntk_t * pNtk, * pFraig;
    int nWords1, nWords2, nWordsMin;
//    abctime clk = Abc_Clock();
 
    // get the stored network
    vStore = Abc_FrameReadStore();
    if ( Vec_PtrSize(vStore) == 0 )
    {
        printf( "There are no network currently in storage.\n" );
        return NULL;
    }
//    printf( "Currently stored %d networks will be fraiged.\n", Vec_PtrSize(vStore) );
    pNtk = (Abc_Ntk_t *)Vec_PtrEntry( vStore, 0 );
 
    // swap the first and last network
    // this should lead to the primary choice being "better" because of synthesis
    if ( Vec_PtrSize(vStore) > 1 )
    {
        pNtk = (Abc_Ntk_t *)Vec_PtrPop( vStore );
        Vec_PtrPush( vStore, Vec_PtrEntry(vStore,0) );
        Vec_PtrWriteEntry( vStore, 0, pNtk );
    }
 
    // to determine the number of simulation patterns
    // use the following strategy
    // at least 64 words (32 words random and 32 words dynamic)
    // no more than 256M for one circuit (128M + 128M)
    nWords1 = 32;
    nWords2 = (1<<27) / (Abc_NtkNodeNum(pNtk) + Abc_NtkCiNum(pNtk));
    nWordsMin = Abc_MinInt( nWords1, nWords2 );
 
    // set parameters for fraiging
    Fraig_ParamsSetDefault( &Params );
    Params.nPatsRand  = nPatsRand ? nPatsRand : nWordsMin * 32;    // the number of words of random simulation info
    Params.nPatsDyna  = nPatsDyna ? nPatsDyna : nWordsMin * 32;    // the number of words of dynamic simulation info
    Params.nBTLimit   = nBTLimit;          // the max number of backtracks to perform
    Params.fFuncRed   =    1;              // performs only one level hashing
    Params.fFeedBack  =    1;              // enables solver feedback
    Params.fDist1Pats =    1;              // enables distance-1 patterns
    Params.fDoSparse  =    1;              // performs equiv tests for sparse functions 
    Params.fChoicing  =    1;              // enables recording structural choices
    Params.fTryProve  =    0;              // tries to solve the final miter
    Params.fInternal  =    1;              // does not show progress bar
    Params.fVerbose   =    0;              // the verbosiness flag
 
    // perform partitioned computation of structural choices
    pFraig = Abc_NtkFraigPartitioned( vStore, &Params );
    Abc_NtkFraigStoreClean();
//ABC_PRT( "Total choicing time", Abc_Clock() - clk );
    return pFraig;
}

Here is the call graph for this function:

◆ Abc_NtkFraigStore()

ABC_DLL int Abc_NtkFraigStore ( Abc_Ntk_t * pNtkAdd )

extern

Function*************************************************************

Synopsis [Interfaces the network with the FRAIG package.]

Description []

SideEffects []

SeeAlso []

Definition at line 654 of file abcFraig.c.

{
    Vec_Ptr_t * vStore;
    Abc_Ntk_t * pNtk;
    // create the network to be stored
    pNtk = Abc_NtkStrash( pNtkAdd, 0, 0, 0 );
    if ( pNtk == NULL )
    {
        printf( "Abc_NtkFraigStore: Initial strashing has failed.\n" );
        return 0;
    }
    // get the network currently stored
    vStore = Abc_FrameReadStore();
    if ( Vec_PtrSize(vStore) > 0 )
    {
        // check that the networks have the same PIs
        extern int Abc_NodeCompareCiCo( Abc_Ntk_t * pNtkOld, Abc_Ntk_t * pNtkNew );
        if ( !Abc_NodeCompareCiCo(pNtk, (Abc_Ntk_t *)Vec_PtrEntry(vStore, 0)) )
        {
            // reorder PIs of pNtk2 according to pNtk1
            if ( !Abc_NtkCompareSignals( pNtk, (Abc_Ntk_t *)Vec_PtrEntry(vStore, 0), 1, 1 ) )
            {
                printf( "Trying to store the network with different primary inputs.\n" );
                printf( "The previously stored networks are deleted and this one is added.\n" );
                Abc_NtkFraigStoreClean();
            }
        }
    }
    Vec_PtrPush( vStore, pNtk );
//    printf( "The number of AIG nodes added to storage = %5d.\n", Abc_NtkNodeNum(pNtk) );
    return 1;
}

Here is the call graph for this function:

◆ Abc_NtkFraigStoreClean()

ABC_DLL void Abc_NtkFraigStoreClean ( )

extern

Function*************************************************************

Synopsis [Interfaces the network with the FRAIG package.]

Description []

SideEffects []

SeeAlso []

Definition at line 766 of file abcFraig.c.

{
    Vec_Ptr_t * vStore;
    Abc_Ntk_t * pNtk;
    int i;
    vStore = Abc_FrameReadStore();
    Vec_PtrForEachEntry( Abc_Ntk_t *, vStore, pNtk, i )
        Abc_NtkDelete( pNtk );
    Vec_PtrClear( vStore );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFraigTrust()

ABC_DLL Abc_Ntk_t * Abc_NtkFraigTrust ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Interfaces the network with the FRAIG package.]

Description []

SideEffects []

SeeAlso []

Definition at line 485 of file abcFraig.c.

{
    Abc_Ntk_t * pNtkNew;
 
    if ( !Abc_NtkIsSopLogic(pNtk) )
    {
        printf( "Abc_NtkFraigTrust: Trust mode works for netlists and logic SOP networks.\n" );
        return NULL;
    }
 
    if ( !Abc_NtkFraigTrustCheck(pNtk) )
    {
        printf( "Abc_NtkFraigTrust: The network does not look like an AIG with choice nodes.\n" );
        return NULL;
    }
    
    // perform strashing
    pNtkNew = Abc_NtkStartFrom( pNtk, ABC_NTK_STRASH, ABC_FUNC_AIG );
    Abc_NtkFraigTrustOne( pNtk, pNtkNew );
    Abc_NtkFinalize( pNtk, pNtkNew );
    Abc_NtkReassignIds( pNtkNew );
 
    // print a warning about choice nodes
    printf( "Warning: The resulting AIG contains %d choice nodes.\n", Abc_NtkGetChoiceNum( pNtkNew ) );
 
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkNew ) )
    {
        printf( "Abc_NtkFraigTrust: The network check has failed.\n" );
        Abc_NtkDelete( pNtkNew );
        return NULL;
    }
    return pNtkNew;
}

Here is the call graph for this function:

◆ Abc_NtkFrames()

ABC_DLL Abc_Ntk_t * Abc_NtkFrames	(	Abc_Ntk_t *	pNtk,
		int	nFrames,
		int	fInitial,
		int	fVerbose )

extern

Function*************************************************************

Synopsis [Derives the timeframes of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 775 of file abcMiter.c.

{
    char Buffer[1000];
    ProgressBar * pProgress;
    Abc_Ntk_t * pNtkFrames;
    Abc_Obj_t * pLatch, * pLatchOut;
    int i, Counter;
    assert( nFrames > 0 );
    assert( Abc_NtkIsStrash(pNtk) );
    assert( Abc_NtkIsDfsOrdered(pNtk) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
    // start the new network
    pNtkFrames = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    sprintf( Buffer, "%s_%d_frames", pNtk->pName, nFrames );
    pNtkFrames->pName = Extra_UtilStrsav(Buffer);
    // map the constant nodes
    Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkFrames);
    
    // create new latches (or their initial values) and remember them in the new latches
    if ( !fInitial )
    {
        Abc_NtkForEachLatch( pNtk, pLatch, i )
            Abc_NtkDupBox( pNtkFrames, pLatch, 1 );
    }
    else
    {
        Counter = 0;
        Abc_NtkForEachLatch( pNtk, pLatch, i )
        {
            pLatchOut = Abc_ObjFanout0(pLatch);
            if ( Abc_LatchIsInitNone(pLatch) || Abc_LatchIsInitDc(pLatch) ) // don't-care initial value - create a new PI
            {
                pLatchOut->pCopy = Abc_NtkCreatePi(pNtkFrames);
                Abc_ObjAssignName( pLatchOut->pCopy, Abc_ObjName(pLatchOut), NULL );
                Counter++;
            }
            else
                pLatchOut->pCopy = Abc_ObjNotCond( Abc_AigConst1(pNtkFrames), Abc_LatchIsInit0(pLatch) );
        }
        if ( Counter )
            printf( "Warning: %d uninitialized latches are replaced by free PI variables.\n", Counter );
    }
    
    // create the timeframes
    pProgress = Extra_ProgressBarStart( stdout, nFrames );
    for ( i = 0; i < nFrames; i++ )
    {
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        Abc_NtkAddFrame( pNtkFrames, pNtk, i );
    }
    Extra_ProgressBarStop( pProgress );
    
    // connect the new latches to the outputs of the last frame
    if ( !fInitial )
    {
        // we cannot use pLatch->pCopy here because pLatch->pCopy is used for temporary storage of strashed values
        Abc_NtkForEachLatch( pNtk, pLatch, i )
            Abc_ObjAddFanin( Abc_ObjFanin0(pLatch)->pCopy, Abc_ObjFanout0(pLatch)->pCopy );
    }
 
    // remove dangling nodes
    Abc_AigCleanup( (Abc_Aig_t *)pNtkFrames->pManFunc );
    // reorder the latches
    Abc_NtkOrderCisCos( pNtkFrames );
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkFrames ) )
    {
        printf( "Abc_NtkFrames: The network check has failed.\n" );
        Abc_NtkDelete( pNtkFrames );
        return NULL;
    }
    return pNtkFrames;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFreeGlobalBdds()

ABC_DLL void * Abc_NtkFreeGlobalBdds	(	Abc_Ntk_t *	pNtk,
		int	fFreeMan )

extern

◆ Abc_NtkFreeMvVars()

ABC_DLL void Abc_NtkFreeMvVars ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Stops the Mv-Var manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 69 of file abcBlifMv.c.

{ 
    Mem_Flex_t * pUserMan;
    pUserMan = (Mem_Flex_t *)Abc_NtkAttrFree( pNtk, VEC_ATTR_GLOBAL_BDD, 0 ); 
    Mem_FlexStop( pUserMan, 0 );
}

Here is the call graph for this function:

◆ Abc_NtkFromBarBufs()

ABC_DLL Abc_Ntk_t * Abc_NtkFromBarBufs	(	Abc_Ntk_t *	pNtkBase,
		Abc_Ntk_t *	pNtk )

extern

Definition at line 263 of file abcBarBuf.c.

{
    Abc_Ntk_t * pNtkNew, * pTemp;
    Vec_Ptr_t * vLiMaps, * vLoMaps;
    Abc_Obj_t * pObj, * pLiMap, * pLoMap;
    int i, k;
    assert( pNtkBase->pDesign != NULL );
    assert( Abc_NtkIsNetlist(pNtk) );
    assert( Abc_NtkIsNetlist(pNtkBase) );
    assert( Abc_NtkLatchNum(pNtkBase) == 0 );
    assert( Abc_NtkLatchNum(pNtk) == pNtk->nBarBufs );
    assert( Abc_NtkWhiteboxNum(pNtk) == 0 );
    assert( Abc_NtkBlackboxNum(pNtk) == 0 );
    assert( Abc_NtkPiNum(pNtk) == Abc_NtkPiNum(pNtkBase) );
    assert( Abc_NtkPoNum(pNtk) == Abc_NtkPoNum(pNtkBase) );
    // start networks
    Abc_NtkCleanCopy_rec( pNtkBase );
    Vec_PtrForEachEntry( Abc_Ntk_t *, pNtkBase->pDesign->vModules, pTemp, i )
        pTemp->pCopy = Abc_NtkStartFrom( pTemp, pNtk->ntkType, pNtk->ntkFunc );
    Vec_PtrForEachEntry( Abc_Ntk_t *, pNtkBase->pDesign->vModules, pTemp, i )
        pTemp->pCopy->pAltView = pTemp->pAltView ? pTemp->pAltView->pCopy : NULL;
    // update box models
    Vec_PtrForEachEntry( Abc_Ntk_t *, pNtkBase->pDesign->vModules, pTemp, i )
        Abc_NtkForEachBox( pTemp, pObj, k )
            if ( Abc_ObjIsWhitebox(pObj) || Abc_ObjIsBlackbox(pObj) )
                pObj->pCopy->pData = Abc_ObjModel(pObj)->pCopy;
    // create the design
    pNtkNew = pNtkBase->pCopy;
    pNtkNew->pDesign = Abc_DesCreate( pNtkBase->pDesign->pName );
    Vec_PtrForEachEntry( Abc_Ntk_t *, pNtkBase->pDesign->vModules, pTemp, i )
        Abc_DesAddModel( pNtkNew->pDesign, pTemp->pCopy );
    Vec_PtrForEachEntry( Abc_Ntk_t *, pNtkBase->pDesign->vTops, pTemp, i )
        Vec_PtrPush( pNtkNew->pDesign->vTops, pTemp->pCopy );
    assert( Vec_PtrEntry(pNtkNew->pDesign->vTops, 0) == pNtkNew );
    // transfer copy attributes to pNtk
    Abc_NtkCleanCopy( pNtk );
    Abc_NtkForEachPi( pNtk, pObj, i )
        pObj->pCopy = Abc_NtkPi(pNtkNew, i);
    Abc_NtkForEachPo( pNtk, pObj, i )
        pObj->pCopy = Abc_NtkPo(pNtkNew, i);
    Abc_NtkCollectPiPos( pNtkBase, &vLiMaps, &vLoMaps );
    assert( Vec_PtrSize(vLiMaps) == Abc_NtkLatchNum(pNtk) );
    assert( Vec_PtrSize(vLoMaps) == Abc_NtkLatchNum(pNtk) );
    Vec_PtrForEachEntryTwo( Abc_Obj_t *, vLiMaps, Abc_Obj_t *, vLoMaps, pLiMap, pLoMap, i )
    {
        pObj = Abc_NtkBox( pNtk, i );
        Abc_ObjFanin0(pObj)->pCopy = pLiMap->pCopy; 
        Abc_ObjFanout0(pObj)->pCopy = pLoMap->pCopy; 
    }
    Vec_PtrFree( vLiMaps );
    Vec_PtrFree( vLoMaps );
    // create internal nodes
    Abc_NtkForEachCo( pNtk, pObj, i )
        Abc_ObjAddFanin( pObj->pCopy, Abc_NtkFromBarBufs_rec(pObj->pCopy->pNtk, Abc_ObjFanin0(pObj)) );
    // transfer net names
    Abc_NtkForEachCi( pNtk, pObj, i )
    {
        if ( Abc_ObjFanoutNum(pObj->pCopy) == 0 ) // handle PI without fanout
            Abc_ObjAddFanin( Abc_NtkCreateNet(pObj->pCopy->pNtk), pObj->pCopy );
        Nm_ManStoreIdName( pObj->pCopy->pNtk->pManName, Abc_ObjFanout0(pObj->pCopy)->Id, Abc_ObjFanout0(pObj->pCopy)->Type, Abc_ObjName(Abc_ObjFanout0(pObj)), NULL );
    }
    Abc_NtkForEachCo( pNtk, pObj, i )
        Nm_ManStoreIdName( pObj->pCopy->pNtk->pManName, Abc_ObjFanin0(pObj->pCopy)->Id, Abc_ObjFanin0(pObj->pCopy)->Type, Abc_ObjName(Abc_ObjFanin0(pObj)), NULL );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkFunctionalIso()

ABC_DLL int Abc_NtkFunctionalIso	(	Abc_Ntk_t *	pNtk,
		int	iCo1,
		int	iCo2,
		int	fCommon )

extern

Definition at line 1048 of file abcDfs.c.

{
    Abc_Ntk_t * pNtkNew; int Result;
    if ( Abc_NtkIsStrash(pNtk) )
        return Abc_NtkFunctionalIsoInt( pNtk, iCo1, iCo2, fCommon );
    pNtkNew = Abc_NtkStrash( pNtk, 0, 0, 0 );
    Result = Abc_NtkFunctionalIsoInt( pNtkNew, iCo1, iCo2, fCommon );
    Abc_NtkDelete( pNtkNew );
    return Result;
}

Here is the call graph for this function:

◆ Abc_NtkGetAigNodeNum()

ABC_DLL int Abc_NtkGetAigNodeNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Reads the number of BDD nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 276 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i, nNodes = 0;
    assert( Abc_NtkIsAigLogic(pNtk) );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        assert( pNode->pData );
        if ( Abc_ObjFaninNum(pNode) < 2 )
            continue;
//printf( "%d ", Hop_DagSize( pNode->pData ) );
        nNodes += pNode->pData? Hop_DagSize( (Hop_Obj_t *)pNode->pData ) : 0;
    }
    return nNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkGetBddNodeNum()

ABC_DLL int Abc_NtkGetBddNodeNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Reads the number of BDD nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 247 of file abcUtil.c.

{
    int nNodes = 0;
#ifdef ABC_USE_CUDD
    Abc_Obj_t * pNode;
    int i;
    assert( Abc_NtkIsBddLogic(pNtk) );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        assert( pNode->pData );
        if ( Abc_ObjFaninNum(pNode) < 2 )
            continue;
        nNodes += pNode->pData? -1 + Cudd_DagSize( (DdNode *)pNode->pData ) : 0;
    }
#endif
    return nNodes;
}

Here is the caller graph for this function:

◆ Abc_NtkGetBufNum()

ABC_DLL int Abc_NtkGetBufNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Counts the number of exors.]

Description []

SideEffects []

SeeAlso []

Definition at line 423 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i, Counter = 0;
    Abc_NtkForEachNode( pNtk, pNode, i )
        Counter += (Abc_ObjFaninNum(pNode) == 1);
    return Counter;
}

Here is the caller graph for this function:

◆ Abc_NtkGetChoiceNum()

ABC_DLL int Abc_NtkGetChoiceNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns 1 if it is an AIG with choice nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 463 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i, Counter;
    if ( !Abc_NtkIsStrash(pNtk) )
        return 0;
    Counter = 0;
    Abc_NtkForEachNode( pNtk, pNode, i )
        Counter += Abc_AigNodeIsChoice( pNode );
    return Counter;
}

Here is the caller graph for this function:

◆ Abc_NtkGetCiArrivalFloats()

ABC_DLL float * Abc_NtkGetCiArrivalFloats ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Sets the CI node levels according to the arrival info.]

Description []

SideEffects []

SeeAlso []

Definition at line 789 of file abcTiming.c.

{
    float * p;
    Abc_Obj_t * pNode;
    int i;
    p = ABC_CALLOC( float, Abc_NtkCiNum(pNtk) );
    if ( pNtk->pManTime == NULL )
        return p;
    // set the PI arrival times
    Abc_NtkForEachCi( pNtk, pNode, i )
        p[i] = Abc_NodeReadArrivalWorst(pNode);
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkGetCiArrivalTimes()

ABC_DLL Abc_Time_t * Abc_NtkGetCiArrivalTimes ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Sets the CI node levels according to the arrival info.]

Description []

SideEffects []

SeeAlso []

Definition at line 750 of file abcTiming.c.

{
    Abc_Time_t * p;
    Abc_Obj_t * pNode;
    int i;
    p = ABC_CALLOC( Abc_Time_t, Abc_NtkCiNum(pNtk) );
    if ( pNtk->pManTime == NULL )
        return p;
    // set the PI arrival times
    Abc_NtkForEachCi( pNtk, pNode, i )
        p[i] = *Abc_NodeArrival(pNode);
    return p;
}

Here is the caller graph for this function:

◆ Abc_NtkGetCiIds()

ABC_DLL Vec_Int_t * Abc_NtkGetCiIds ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns the array of CI IDs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1787 of file abcUtil.c.

{
    Vec_Int_t * vCiIds;
    Abc_Obj_t * pObj;
    int i;
    vCiIds = Vec_IntAlloc( Abc_NtkCiNum(pNtk) );
    Abc_NtkForEachCi( pNtk, pObj, i )
        Vec_IntPush( vCiIds, pObj->Id );
    return vCiIds;
}

◆ Abc_NtkGetClauseNum()

ABC_DLL int Abc_NtkGetClauseNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Reads the number of BDD nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 303 of file abcUtil.c.

{
    int nClauses = 0;
#ifdef ABC_USE_CUDD
    extern int Abc_CountZddCubes( DdManager * dd, DdNode * zCover );
    Abc_Obj_t * pNode;
    DdNode * bCover, * zCover, * bFunc;
    DdManager * dd = (DdManager *)pNtk->pManFunc;
    int i;
    assert( Abc_NtkIsBddLogic(pNtk) );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        assert( pNode->pData );
        bFunc = (DdNode *)pNode->pData;
 
        bCover = Cudd_zddIsop( dd, bFunc, bFunc, &zCover );  
        Cudd_Ref( bCover );
        Cudd_Ref( zCover );
        nClauses += Abc_CountZddCubes( dd, zCover );
        Cudd_RecursiveDeref( dd, bCover );
        Cudd_RecursiveDerefZdd( dd, zCover );
 
        bCover = Cudd_zddIsop( dd, Cudd_Not(bFunc), Cudd_Not(bFunc), &zCover );  
        Cudd_Ref( bCover );
        Cudd_Ref( zCover );
        nClauses += Abc_CountZddCubes( dd, zCover );
        Cudd_RecursiveDeref( dd, bCover );
        Cudd_RecursiveDerefZdd( dd, zCover );
    }
#endif
    return nClauses;
}

◆ Abc_NtkGetCoRequiredFloats()

ABC_DLL float * Abc_NtkGetCoRequiredFloats ( Abc_Ntk_t * pNtk )

extern

Definition at line 802 of file abcTiming.c.

{
    float * p;
    Abc_Obj_t * pNode;
    int i;
    if ( pNtk->pManTime == NULL )
        return NULL;
    // set the PO required times
    p = ABC_CALLOC( float, Abc_NtkCoNum(pNtk) );
    Abc_NtkForEachCo( pNtk, pNode, i )
        p[i] = Abc_NodeReadRequiredWorst(pNode);
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkGetCoRequiredTimes()

ABC_DLL Abc_Time_t * Abc_NtkGetCoRequiredTimes ( Abc_Ntk_t * pNtk )

extern

Definition at line 763 of file abcTiming.c.

{
    Abc_Time_t * p;
    Abc_Obj_t * pNode;
    int i;
    p = ABC_CALLOC( Abc_Time_t, Abc_NtkCoNum(pNtk) );
    if ( pNtk->pManTime == NULL )
        return p;
    // set the PO required times
    Abc_NtkForEachCo( pNtk, pNode, i )
        p[i] = *Abc_NodeRequired(pNode);
    return p;
}

Here is the caller graph for this function:

◆ Abc_NtkGetCubeNum()

ABC_DLL int Abc_NtkGetCubeNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Reads the number of cubes of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 117 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i, nCubes = 0;
    assert( Abc_NtkHasSop(pNtk) );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( Abc_NodeIsConst(pNode) )
            continue;
        assert( pNode->pData );
        nCubes += Abc_SopGetCubeNum( (char *)pNode->pData );
    }
    return nCubes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkGetCubePairNum()

ABC_DLL int Abc_NtkGetCubePairNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Reads the number of cubes of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 143 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i;
    word nCubes, nCubePairs = 0;
    assert( Abc_NtkHasSop(pNtk) );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( Abc_NodeIsConst(pNode) )
            continue;
        assert( pNode->pData );
        nCubes = (word)Abc_SopGetCubeNum( (char *)pNode->pData );
        if ( nCubes > 1 )
            nCubePairs += nCubes * (nCubes - 1) / 2;
    }
    return (int)(nCubePairs > (1<<30) ? (1<<30) : nCubePairs);
}

Here is the call graph for this function:

◆ Abc_NtkGetExorNum()

ABC_DLL int Abc_NtkGetExorNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Counts the number of exors.]

Description []

SideEffects []

SeeAlso []

Definition at line 383 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i, Counter = 0;
    Abc_NtkForEachNode( pNtk, pNode, i )
        Counter += pNode->fExor;
    return Counter;
}

Here is the caller graph for this function:

◆ Abc_NtkGetFaninMax()

ABC_DLL int Abc_NtkGetFaninMax ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Reads the maximum number of fanins.]

Description []

SideEffects []

SeeAlso []

Definition at line 486 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i, nFaninsMax = 0;
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( nFaninsMax < Abc_ObjFaninNum(pNode) )
            nFaninsMax = Abc_ObjFaninNum(pNode);
    }
    return nFaninsMax;
}

Here is the caller graph for this function:

◆ Abc_NtkGetFanoutMax()

ABC_DLL int Abc_NtkGetFanoutMax ( Abc_Ntk_t * pNtk )

extern

Definition at line 497 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i, nFaninsMax = 0;
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( nFaninsMax < Abc_ObjFanoutNum(pNode) )
            nFaninsMax = Abc_ObjFanoutNum(pNode);
    }
    return nFaninsMax;
}

Here is the caller graph for this function:

◆ Abc_NtkGetLargeNodeNum()

ABC_DLL int Abc_NtkGetLargeNodeNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Counts the number of exors.]

Description []

SideEffects []

SeeAlso []

Definition at line 443 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i, Counter = 0;
    Abc_NtkForEachNode( pNtk, pNode, i )
        Counter += (Abc_ObjFaninNum(pNode) > 1);
    return Counter;
}

Here is the caller graph for this function:

◆ Abc_NtkGetLitFactNum()

ABC_DLL int Abc_NtkGetLitFactNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Counts the number of literals in the factored forms.]

Description []

SideEffects []

SeeAlso []

Definition at line 196 of file abcUtil.c.

{
    Dec_Graph_t * pFactor;
    Abc_Obj_t * pNode;
    int nNodes, i;
    assert( Abc_NtkHasSop(pNtk) );
    nNodes = 0;
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( Abc_NodeIsConst(pNode) )
            continue;
        pFactor = Dec_Factor( (char *)pNode->pData );
        nNodes += 1 + Dec_GraphNodeNum(pFactor);
        Dec_GraphFree( pFactor );
    }
    return nNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkGetLitNum()

ABC_DLL int Abc_NtkGetLitNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Reads the number of literals in the SOPs of the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 172 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i, nLits = 0;
    assert( Abc_NtkHasSop(pNtk) );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        assert( pNode->pData );
        nLits += Abc_SopGetLitNum( (char *)pNode->pData );
    }
    return nLits;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkGetMappedArea()

ABC_DLL double Abc_NtkGetMappedArea ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Computes the area of the mapped circuit.]

Description []

SideEffects []

SeeAlso []

Definition at line 347 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    double TotalArea;
    int i;
    assert( Abc_NtkHasMapping(pNtk) );
    TotalArea = 0.0;
    Abc_NtkForEachNode( pNtk, pObj, i )
    {
        if ( Abc_ObjIsBarBuf(pObj) )
            continue;
//        assert( pObj->pData );
        if ( pObj->pData == NULL )
        {
            printf( "Node without mapping is encountered.\n" );
            continue;
        }
        TotalArea += Mio_GateReadArea( (Mio_Gate_t *)pObj->pData );
        // assuming that twin gates follow each other
        if ( Abc_NtkFetchTwinNode(pObj) )
            i++;
    }
    return TotalArea;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkGetMuxNum()

ABC_DLL int Abc_NtkGetMuxNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Counts the number of exors.]

Description []

SideEffects []

SeeAlso []

Definition at line 403 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i, Counter = 0;
    Abc_NtkForEachNode( pNtk, pNode, i )
        Counter += Abc_NodeIsMuxType(pNode);
    return Counter;
}

Here is the call graph for this function:

◆ Abc_NtkGetTotalFanins()

ABC_DLL int Abc_NtkGetTotalFanins ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Reads the total number of all fanins.]

Description []

SideEffects []

SeeAlso []

Definition at line 520 of file abcUtil.c.

{
    Abc_Obj_t * pNode;
    int i, nFanins = 0;
    Abc_NtkForEachNode( pNtk, pNode, i )
        nFanins += Abc_ObjFaninNum(pNode);
    return nFanins;
}

Here is the caller graph for this function:

◆ Abc_NtkHaigStart()

ABC_DLL int Abc_NtkHaigStart ( Abc_Ntk_t * pNtk )

extern

◆ Abc_NtkHaigStop()

ABC_DLL int Abc_NtkHaigStop ( Abc_Ntk_t * pNtk )

extern

◆ Abc_NtkHaigUse()

ABC_DLL Abc_Ntk_t * Abc_NtkHaigUse ( Abc_Ntk_t * pNtk )

extern

◆ Abc_NtkInsertBlifMv()

ABC_DLL Abc_Ntk_t * Abc_NtkInsertBlifMv	(	Abc_Ntk_t *	pNtkBase,
		Abc_Ntk_t *	pNtkLogic )

extern

Function*************************************************************

Synopsis [Inserts processed network into original base MV network.]

Description [The original network remembers the interface of combinational logic (PIs/POs/latches names and values). The processed network may be binary or multi-valued (currently, multi-value is not supported). The resulting network has the same interface as the original network while the internal logic is the same as that of the processed network.]

SideEffects []

SeeAlso []

Definition at line 912 of file abcBlifMv.c.

{
    Abc_Ntk_t * pNtkSkel, * pNtkNew;
    Abc_Obj_t * pBox;
 
    assert( Abc_NtkIsNetlist(pNtkBase) );
    assert( Abc_NtkHasBlifMv(pNtkBase) );
    assert( Abc_NtkWhiteboxNum(pNtkBase) == 0 );
    assert( Abc_NtkBlackboxNum(pNtkBase) == 0 );
 
    assert( Abc_NtkIsNetlist(pNtkLogic) );
    assert( Abc_NtkHasBlifMv(pNtkLogic) );
    assert( Abc_NtkWhiteboxNum(pNtkLogic) == 0 );
    assert( Abc_NtkBlackboxNum(pNtkLogic) == 0 );
 
    // extract the skeleton of the old network
    pNtkSkel = Abc_NtkSkeletonBlifMv( pNtkBase );
 
    // set the implementation of the box to be the same as the processed network
    assert( Abc_NtkWhiteboxNum(pNtkSkel) == 1 );
    pBox = Abc_NtkBox( pNtkSkel, 0 );
    assert( Abc_ObjIsWhitebox(pBox) );
    assert( pBox->pData == NULL );
    assert( Abc_ObjFaninNum(pBox) == Abc_NtkPiNum(pNtkLogic) );
    assert( Abc_ObjFanoutNum(pBox) == Abc_NtkPoNum(pNtkLogic) );
    pBox->pData = pNtkLogic;
 
    // flatten the hierarchy to insert the processed network
    pNtkNew = Abc_NtkFlattenLogicHierarchy( pNtkSkel );
    pBox->pData = NULL;
    Abc_NtkDelete( pNtkSkel );
    return pNtkNew;    
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkInsertHierarchyGia()

ABC_DLL void Abc_NtkInsertHierarchyGia	(	Abc_Ntk_t *	pNtk,
		Abc_Ntk_t *	pNew,
		int	fVerbose )

extern

Definition at line 535 of file abcHieGia.c.

{
    Vec_Ptr_t * vBuffers;
    Gia_Man_t * pGia = Abc_NtkFlattenHierarchyGia( pNtk, &vBuffers, 0 );
    Abc_Ntk_t * pModel;  
    Abc_Obj_t * pObj; 
    int i, k = 0;
 
    assert( Gia_ManPiNum(pGia) == Abc_NtkPiNum(pNtk) );
    assert( Gia_ManPiNum(pGia) == Abc_NtkPiNum(pNew) );
    assert( Gia_ManPoNum(pGia) == Abc_NtkPoNum(pNtk) );
    assert( Gia_ManPoNum(pGia) == Abc_NtkPoNum(pNew) );
    assert( Gia_ManBufNum(pGia) == Vec_PtrSize(vBuffers) );
    assert( Gia_ManBufNum(pGia) == pNew->nBarBufs2 );
    Gia_ManStop( pGia );
 
    // clean the networks
    if ( !pNtk->pDesign )
        Abc_NtkCleanCopy( pNtk );
    else
        Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pModel, i )
            Abc_NtkCleanCopy( pModel );
 
    // annotate PIs and POs of each network with barbufs
    Abc_NtkForEachPi( pNew, pObj, i )
        Abc_NtkPi(pNtk, i)->pCopy = pObj;
    Abc_NtkForEachPo( pNew, pObj, i )
        Abc_NtkPo(pNtk, i)->pCopy = pObj;
    Abc_NtkForEachBarBuf( pNew, pObj, i )
        ((Abc_Obj_t *)Vec_PtrEntry(vBuffers, k++))->pCopy = pObj;
    Vec_PtrFree( vBuffers );
 
    // connect each model
    Abc_NtkCleanCopy( pNew );
    Gia_ManInsertOne( pNtk, pNew );
    if ( pNtk->pDesign )
        Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pModel, i )
            if ( pModel != pNtk )
                Gia_ManInsertOne( pModel, pNew );
}

Here is the call graph for this function:

◆ Abc_NtkInsertLatchValues()

ABC_DLL void Abc_NtkInsertLatchValues	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t *	vValues )

extern

Function*************************************************************

Synopsis [Strashes one logic node using its SOP.]

Description []

SideEffects []

SeeAlso []

Definition at line 235 of file abcLatch.c.

{
    Abc_Obj_t * pLatch;
    int i;
    Abc_NtkForEachLatch( pNtk, pLatch, i )
        pLatch->pData = (void *)(ABC_PTRINT_T)(vValues? (Vec_IntEntry(vValues,i)? ABC_INIT_ONE : ABC_INIT_ZERO) : ABC_INIT_DC);
}

Here is the caller graph for this function:

◆ Abc_NtkInsertNewLogic()

ABC_DLL Abc_Ntk_t * Abc_NtkInsertNewLogic	(	Abc_Ntk_t *	pNtkH,
		Abc_Ntk_t *	pNtkL )

extern

Function*************************************************************

Synopsis [Inserts blackboxes into the netlist.]

Description [The first arg is the netlist with blackboxes without logic hierarchy. The second arg is a non-hierarchical netlist derived from the above netlist after processing. This procedure create a new netlist, which is comparable to the original netlist with blackboxes, except that it contains logic nodes from the netlist after processing.]

SideEffects [This procedure silently assumes that blackboxes appear only in the top-level model. If they appear in other models as well, the name of the model and its number were appended to the names of blackbox inputs/outputs.]

SeeAlso []

Definition at line 691 of file abcHie.c.

{
    Abc_Des_t * pDesign;
    Abc_Ntk_t * pNtkNew;
    Abc_Obj_t * pObjH, * pObjL, * pNetH, * pNetL, * pTermH;
    int i, k;
 
    assert( Abc_NtkIsNetlist(pNtkH) );
    assert( Abc_NtkWhiteboxNum(pNtkH) == 0 );
    assert( Abc_NtkBlackboxNum(pNtkH) > 0 );
 
    assert( Abc_NtkIsNetlist(pNtkL) );
    assert( Abc_NtkWhiteboxNum(pNtkL) == 0 );
    assert( Abc_NtkBlackboxNum(pNtkL) == 0 );
 
    // prepare the logic network for copying
    Abc_NtkCleanCopy( pNtkL );
 
    // start the network
    pNtkNew = Abc_NtkAlloc( pNtkL->ntkType, pNtkL->ntkFunc, 1 );
    // duplicate the name and the spec
    pNtkNew->pName = Extra_UtilStrsav( pNtkH->pName );
    pNtkNew->pSpec = Extra_UtilStrsav( pNtkH->pSpec );
 
    // make sure every PI/PO has a PI/PO in the processed network
    Abc_NtkForEachPi( pNtkH, pObjH, i )
    {
        pNetH = Abc_ObjFanout0(pObjH);
        pNetL = Abc_NtkFindNet( pNtkL, Abc_ObjName(pNetH) );
        if ( pNetL == NULL || !Abc_ObjIsPi( Abc_ObjFanin0(pNetL) ) )
        {
            printf( "Error in Abc_NtkInsertNewLogic(): There is no PI corresponding to the PI %s.\n", Abc_ObjName(pNetH) );
            Abc_NtkDelete( pNtkNew );
            return NULL;
        }
        if ( pNetL->pCopy )
        {
            printf( "Error in Abc_NtkInsertNewLogic(): Primary input %s is repeated twice.\n", Abc_ObjName(pNetH) );
            Abc_NtkDelete( pNtkNew );
            return NULL;
        }
        // create the new net
        pNetL->pCopy = Abc_NtkFindOrCreateNet( pNtkNew, Abc_ObjName(pNetH) );
        Abc_NtkDupObj( pNtkNew, Abc_ObjFanin0(pNetL), 0 );
    }
 
    // make sure every BB has a PI/PO in the processed network
    Abc_NtkForEachBlackbox( pNtkH, pObjH, i )
    {
        // duplicate the box 
        Abc_NtkDupBox( pNtkNew, pObjH, 0 );
        pObjH->pCopy->pData = pObjH->pData;
        // create PIs
        Abc_ObjForEachFanout( pObjH, pTermH, k )
        {
            pNetH = Abc_ObjFanout0( pTermH );
            pNetL = Abc_NtkFindNet( pNtkL, Abc_ObjName(pNetH) );
            if ( pNetL == NULL || !Abc_ObjIsPi( Abc_ObjFanin0(pNetL) ) )
            {
                printf( "Error in Abc_NtkInsertNewLogic(): There is no PI corresponding to the inpout %s of blackbox %s.\n", Abc_ObjName(pNetH), Abc_ObjName(pObjH) );
                Abc_NtkDelete( pNtkNew );
                return NULL;
            }
            if ( pNetL->pCopy )
            {
                printf( "Error in Abc_NtkInsertNewLogic(): Box output %s is repeated twice.\n", Abc_ObjName(pNetH) );
                Abc_NtkDelete( pNtkNew );
                return NULL;
            }
            // create net and map the PI
            pNetL->pCopy = Abc_NtkFindOrCreateNet( pNtkNew, Abc_ObjName(pNetH) );
            Abc_ObjFanin0(pNetL)->pCopy = pTermH->pCopy;
        }
    }
 
    Abc_NtkForEachPo( pNtkH, pObjH, i )
    {
        pNetH = Abc_ObjFanin0(pObjH);
        pNetL = Abc_NtkFindNet( pNtkL, Abc_ObjName(pNetH) );
        if ( pNetL == NULL || !Abc_ObjIsPo( Abc_ObjFanout0(pNetL) ) )
        {
            printf( "Error in Abc_NtkInsertNewLogic(): There is no PO corresponding to the PO %s.\n", Abc_ObjName(pNetH) );
            Abc_NtkDelete( pNtkNew );
            return NULL;
        }
        if ( pNetL->pCopy )
            continue;
        // create the new net
        pNetL->pCopy = Abc_NtkFindOrCreateNet( pNtkNew, Abc_ObjName(pNetH) );
        Abc_NtkDupObj( pNtkNew, Abc_ObjFanout0(pNetL), 0 );
    }
    Abc_NtkForEachBlackbox( pNtkH, pObjH, i )
    {
        Abc_ObjForEachFanin( pObjH, pTermH, k )
        {
            char * pName;
            pNetH = Abc_ObjFanin0( pTermH );
            pName = Abc_ObjName(pNetH);
            pNetL = Abc_NtkFindNet( pNtkL, Abc_ObjName(pNetH) );
            if ( pNetL == NULL || !Abc_ObjIsPo( Abc_ObjFanout0(pNetL) ) )
            {
                printf( "There is no PO corresponding to the input %s of blackbox %s.\n", Abc_ObjName(pNetH), Abc_ObjName(pObjH) );
                Abc_NtkDelete( pNtkNew );
                return NULL;
            }
            // create net and map the PO
            if ( pNetL->pCopy )
            {
                if ( Abc_ObjFanout0(pNetL)->pCopy == NULL )
                    Abc_ObjFanout0(pNetL)->pCopy = pTermH->pCopy;
                else
                    Abc_ObjAddFanin( pTermH->pCopy, pNetL->pCopy );
                continue;
            }
            pNetL->pCopy = Abc_NtkFindOrCreateNet( pNtkNew, Abc_ObjName(pNetH) );
            Abc_ObjFanout0(pNetL)->pCopy = pTermH->pCopy;
        }
    }
 
    // duplicate other objects of the logic network
    Abc_NtkForEachObj( pNtkL, pObjL, i )
        if ( pObjL->pCopy == NULL && !Abc_ObjIsPo(pObjL) ) // skip POs feeding into PIs
            Abc_NtkDupObj( pNtkNew, pObjL, Abc_ObjIsNet(pObjL) );
 
    // connect objects
    Abc_NtkForEachObj( pNtkL, pObjL, i )
        Abc_ObjForEachFanin( pObjL, pNetL, k )
            if ( pObjL->pCopy )
                Abc_ObjAddFanin( pObjL->pCopy, pNetL->pCopy );
 
    // transfer the design
    pDesign = pNtkH->pDesign;  pNtkH->pDesign = NULL;
    assert( Vec_PtrEntry( pDesign->vModules, 0 ) == pNtkH );
    Vec_PtrWriteEntry( pDesign->vModules, 0, pNtkNew );
    pNtkNew->pDesign = pDesign;
 
    // check integrity
    if ( !Abc_NtkCheck( pNtkNew ) )
    {
        fprintf( stdout, "Abc_NtkInsertNewLogic(): Network check has failed.\n" );
        Abc_NtkDelete( pNtkNew );
        return NULL;
    }
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkInvertConstraints()

ABC_DLL void Abc_NtkInvertConstraints ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Complements the constraint outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 2244 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    if ( Abc_NtkConstrNum(pNtk) == 0 )
        return;
    Abc_NtkForEachPo( pNtk, pObj, i )
    {
        if ( i >= Abc_NtkPoNum(pNtk) - Abc_NtkConstrNum(pNtk) )
            Abc_ObjXorFaninC( pObj, 0 );
    }
}

Here is the caller graph for this function:

◆ Abc_NtkIsAcyclic()

ABC_DLL int Abc_NtkIsAcyclic ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Detects combinational loops.]

Description [This procedure is based on the idea suggested by Donald Chai. As we traverse the network and visit the nodes, we need to distinquish three types of nodes: (1) those that are visited for the first time, (2) those that have been visited in this traversal but are currently not on the traversal path, (3) those that have been visited and are currently on the travesal path. When the node of type (3) is encountered, it means that there is a combinational loop. To mark the three types of nodes, two new values of the traversal IDs are used.]

SideEffects []

SeeAlso []

Definition at line 1614 of file abcDfs.c.

{
    Abc_Obj_t * pNode;
    int fAcyclic;
    int i;
    // set the traversal ID for this DFS ordering
    Abc_NtkIncrementTravId( pNtk );   
    Abc_NtkIncrementTravId( pNtk );   
    // pNode->TravId == pNet->nTravIds      means "pNode is on the path"
    // pNode->TravId == pNet->nTravIds - 1  means "pNode is visited but is not on the path"
    // pNode->TravId <  pNet->nTravIds - 1  means "pNode is not visited"
    // traverse the network to detect cycles
    fAcyclic = 1;
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        pNode = Abc_ObjFanin0Ntk(Abc_ObjFanin0(pNode));
        if ( Abc_NodeIsTravIdPrevious(pNode) )
            continue;
        // traverse the output logic cone
        if ( (fAcyclic = Abc_NtkIsAcyclic_rec(pNode)) )
            continue;
        // stop as soon as the first loop is detected
        fprintf( stdout, " CO \"%s\"\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
        break;
    }
    return fAcyclic;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkIsAcyclicHierarchy()

ABC_DLL int Abc_NtkIsAcyclicHierarchy ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns 0 if the network hierachy contains a cycle.]

Description []

SideEffects []

SeeAlso []

Definition at line 817 of file abcCheck.c.

{
    Abc_Ntk_t * pTemp;
    int i, RetValue;
    assert( Abc_NtkIsNetlist(pNtk) && pNtk->pDesign );
    // clear the modules
    Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pTemp, i )
        pTemp->fHieVisited = pTemp->fHiePath = 0;
    // traverse
    pNtk->fHiePath = 1;
    RetValue = Abc_NtkIsAcyclicHierarchy_rec( pNtk );
    pNtk->fHiePath = 0;
    // clear the modules
    Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pTemp, i )
        pTemp->fHieVisited = pTemp->fHiePath = 0;
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkIsAcyclicWithBoxes()

ABC_DLL int Abc_NtkIsAcyclicWithBoxes ( Abc_Ntk_t * pNtk )

extern

Definition at line 1702 of file abcDfs.c.

{
    Abc_Obj_t * pNode;
    int fAcyclic;
    int i;
    // set the traversal ID for this DFS ordering
    Abc_NtkIncrementTravId( pNtk );   
    Abc_NtkIncrementTravId( pNtk );   
    // pNode->TravId == pNet->nTravIds      means "pNode is on the path"
    // pNode->TravId == pNet->nTravIds - 1  means "pNode is visited but is not on the path"
    // pNode->TravId <  pNet->nTravIds - 1  means "pNode is not visited"
    // traverse the network to detect cycles
    fAcyclic = 1;
    Abc_NtkForEachPo( pNtk, pNode, i )
    {
        pNode = Abc_ObjFanin0Ntk(Abc_ObjFanin0(pNode));
        if ( Abc_ObjIsBo(pNode) )
            pNode = Abc_ObjFanin0(pNode);
        if ( Abc_NodeIsTravIdPrevious(pNode) )
            continue;
        // traverse the output logic cone
        if ( (fAcyclic = Abc_NtkIsAcyclicWithBoxes_rec(pNode)) )
            continue;
        // stop as soon as the first loop is detected
        fprintf( stdout, " PO \"%s\"\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
        break;
    }
    if ( fAcyclic )
    {
        Abc_NtkForEachLatchInput( pNtk, pNode, i )
        {
            pNode = Abc_ObjFanin0Ntk(Abc_ObjFanin0(pNode));
            if ( Abc_ObjIsBo(pNode) )
                pNode = Abc_ObjFanin0(pNode);
            if ( Abc_NodeIsTravIdPrevious(pNode) )
                continue;
            // traverse the output logic cone
            if ( (fAcyclic = Abc_NtkIsAcyclicWithBoxes_rec(pNode)) )
                continue;
            // stop as soon as the first loop is detected
            fprintf( stdout, " PO \"%s\"\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
            break;
        }
    }
    return fAcyclic;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkIsDfsOrdered()

ABC_DLL int Abc_NtkIsDfsOrdered ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns 1 if the ordering of nodes is DFS.]

Description []

SideEffects []

SeeAlso []

Definition at line 698 of file abcDfs.c.

{
    Abc_Obj_t * pNode, * pFanin;
    int i, k;
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // mark the CIs
    Abc_NtkForEachCi( pNtk, pNode, i )
        Abc_NodeSetTravIdCurrent( pNode );
    // go through the nodes
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        // check the fanins of the node
        Abc_ObjForEachFanin( pNode, pFanin, k )
            if ( !Abc_NodeIsTravIdCurrent(pFanin) )
                return 0;
        // check the choices of the node
        if ( Abc_NtkIsStrash(pNtk) && Abc_AigNodeIsChoice(pNode) )
            for ( pFanin = (Abc_Obj_t *)pNode->pData; pFanin; pFanin = (Abc_Obj_t *)pFanin->pData )
                if ( !Abc_NodeIsTravIdCurrent(pFanin) )
                    return 0;
        // mark the node as visited
        Abc_NodeSetTravIdCurrent( pNode );
    }
    return 1;
}

Here is the caller graph for this function:

◆ Abc_NtkIsTopo()

ABC_DLL int Abc_NtkIsTopo ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Checks if the logic network is in the topological order.]

Description []

SideEffects []

SeeAlso []

Definition at line 2888 of file abcUtil.c.

{
    Abc_Obj_t * pObj, * pFanin;
    int i, k, Counter = 0;
    Abc_NtkIncrementTravId( pNtk );
    Abc_NtkForEachCi( pNtk, pObj, i )
        Abc_NodeSetTravIdCurrent(pObj);
    Abc_NtkForEachNode( pNtk, pObj, i )
    {
        // check if fanins are in the topo order
        Abc_ObjForEachFanin( pObj, pFanin, k )
            if ( !Abc_NodeIsTravIdCurrent(pFanin) )
                break;
        if ( k != Abc_ObjFaninNum(pObj) )
        {
            if ( Counter++ == 0 )
                printf( "Node %d is out of topo order.\n", Abc_ObjId(pObj) );
        }
        Abc_NodeSetTravIdCurrent(pObj);
    }
    if ( Counter )
        printf( "Topological order does not hold for %d internal nodes.\n", Counter );
    return (int)(Counter == 0);
}

Here is the caller graph for this function:

◆ Abc_NtkIsTrueCex()

ABC_DLL int Abc_NtkIsTrueCex	(	Abc_Ntk_t *	pNtk,
		Abc_Cex_t *	pCex )

extern

Function*************************************************************

Synopsis [Returns the PO values under the given input pattern.]

Description []

SideEffects []

SeeAlso []

Definition at line 1074 of file abcVerify.c.

{
    extern Aig_Man_t * Abc_NtkToDar( Abc_Ntk_t * pNtk, int fExors, int fRegisters );
    Aig_Man_t * pMan;
    int status = 0, fStrashed = 0;
    if ( !Abc_NtkIsStrash(pNtk) )
    {
        pNtk = Abc_NtkStrash(pNtk, 0, 0, 0);
        fStrashed = 1;
    }
    pMan = Abc_NtkToDar( pNtk, 0, 1 );
    if ( pMan )
    {
        status = Saig_ManVerifyCex( pMan, pCex );
        Aig_ManStop( pMan );
    }
    if ( fStrashed )
        Abc_NtkDelete( pNtk );
    return status;
}

Here is the call graph for this function:

◆ Abc_NtkIsValidCex()

ABC_DLL int Abc_NtkIsValidCex	(	Abc_Ntk_t *	pNtk,
		Abc_Cex_t *	pCex )

extern

Function*************************************************************

Synopsis [Returns 1 if the number of PIs matches.]

Description []

SideEffects []

SeeAlso []

Definition at line 1106 of file abcVerify.c.

{
    return Abc_NtkPiNum(pNtk) == pCex->nPis;
}

◆ Abc_NtkIvyProve()

ABC_DLL int Abc_NtkIvyProve	(	Abc_Ntk_t **	ppNtk,
		void *	pPars )

extern

Function*************************************************************

Synopsis [Gives the current ABC network to AIG manager for processing.]

Description []

SideEffects []

SeeAlso []

Definition at line 503 of file abcIvy.c.

{
    Prove_Params_t * pParams = (Prove_Params_t *)pPars;
    Abc_Ntk_t * pNtk = *ppNtk, * pNtkTemp;
    Abc_Obj_t * pObj, * pFanin;
    Ivy_Man_t * pMan;
    Aig_Man_t * pMan2;
    int RetValue;
    assert( Abc_NtkIsStrash(pNtk) || Abc_NtkIsLogic(pNtk) );
    // experiment with various parameters settings
//    pParams->fUseBdds = 1;
//    pParams->fBddReorder = 1;
//    pParams->nTotalBacktrackLimit = 10000;
 
    // strash the network if it is not strashed already
    if ( !Abc_NtkIsStrash(pNtk) )
    {
        pNtk = Abc_NtkStrash( pNtkTemp = pNtk, 0, 1, 0 );
        Abc_NtkDelete( pNtkTemp );
    }
 
    // check the case when the 0000 simulation pattern detect the bug
    pObj = Abc_NtkPo(pNtk,0);
    pFanin = Abc_ObjFanin0(pObj);
    if ( Abc_ObjFanin0(pObj)->fPhase != (unsigned)Abc_ObjFaninC0(pObj) )
    {
        pNtk->pModel = ABC_CALLOC( int, Abc_NtkCiNum(pNtk) );
        return 0;
    }
 
    // changed in "src\sat\fraig\fraigMan.c"
    //    pParams->nMiteringLimitStart  = 300;    // starting mitering limit
    // to be
    //    pParams->nMiteringLimitStart  = 5000;    // starting mitering limit
 
    // if SAT only, solve without iteration
//    RetValue = Abc_NtkMiterSat( pNtk, 2*(ABC_INT64_T)pParams->nMiteringLimitStart, (ABC_INT64_T)0, 0, NULL, NULL );
    pMan2 = Abc_NtkToDar( pNtk, 0, 0 );
    RetValue = Fra_FraigSat( pMan2, (ABC_INT64_T)pParams->nMiteringLimitStart, (ABC_INT64_T)0, 0, 0, 0, 1, 0, 0, 0 ); 
    pNtk->pModel = (int *)pMan2->pData, pMan2->pData = NULL;
    Aig_ManStop( pMan2 );
//    pNtk->pModel = Aig_ManReleaseData( pMan2 );
    if ( RetValue >= 0 )
        return RetValue;
 
    // apply AIG rewriting
    if ( pParams->fUseRewriting && Abc_NtkNodeNum(pNtk) > 500 )
    {
//        abctime clk = Abc_Clock();
//printf( "Before rwsat = %d. ", Abc_NtkNodeNum(pNtk) );
        pParams->fUseRewriting = 0;
        pNtk = Abc_NtkBalance( pNtkTemp = pNtk, 0, 0, 0 );          
        Abc_NtkDelete( pNtkTemp );
        Abc_NtkRewrite( pNtk, 0, 0, 0, 0, 0 );
        pNtk = Abc_NtkBalance( pNtkTemp = pNtk, 0, 0, 0 );          
        Abc_NtkDelete( pNtkTemp );
        Abc_NtkRewrite( pNtk, 0, 0, 0, 0, 0 );
        Abc_NtkRefactor( pNtk, 10, 1, 16, 0, 0, 0, 0 );
//printf( "After rwsat = %d. ", Abc_NtkNodeNum(pNtk) );
//ABC_PRT( "Time", Abc_Clock() - clk );
    }
 
    // convert ABC network into IVY network
    pMan = Abc_NtkIvyBefore( pNtk, 0, 0 );
 
    // solve the CEC problem
    RetValue = Ivy_FraigProve( &pMan, pParams );
//    RetValue = -1;
 
    // convert IVY network into ABC network    
    pNtk = Abc_NtkIvyAfter( pNtkTemp = pNtk, pMan, 0, 0 );
    Abc_NtkDelete( pNtkTemp );
    // transfer model if given
    pNtk->pModel = (int *)pMan->pData; pMan->pData = NULL;
    Ivy_ManStop( pMan );
 
    // try to prove it using brute force SAT with good CNF encoding
    if ( RetValue < 0 )
    {
        pMan2 = Abc_NtkToDar( pNtk, 0, 0 );
        // dump the miter before entering high-effort solving
        if ( pParams->fVerbose )
        {
            char pFileName[100];
            sprintf( pFileName, "cecmiter.aig" );
            Ioa_WriteAiger( pMan2, pFileName, 0, 0 );
            printf( "Intermediate reduced miter is written into file \"%s\".\n", pFileName );
        }
        RetValue = Fra_FraigSat( pMan2, pParams->nMiteringLimitLast, 0, 0, 0, 0, 0, 0, 0, pParams->fVerbose ); 
        pNtk->pModel = (int *)pMan2->pData, pMan2->pData = NULL;
        Aig_ManStop( pMan2 );
    }
 
    // try to prove it using brute force BDDs
#ifdef ABC_USE_CUDD
    if ( RetValue < 0 && pParams->fUseBdds )
    {
        if ( pParams->fVerbose )
        {
            printf( "Attempting BDDs with node limit %d ...\n", pParams->nBddSizeLimit );
            fflush( stdout );
        }
        pNtk = Abc_NtkCollapse( pNtkTemp = pNtk, pParams->nBddSizeLimit, 0, pParams->fBddReorder, 0, 0, 0 );
        if ( pNtk )   
        {
            Abc_NtkDelete( pNtkTemp );
            RetValue = ( (Abc_NtkNodeNum(pNtk) == 1) && (Abc_ObjFanin0(Abc_NtkPo(pNtk,0))->pData == Cudd_ReadLogicZero((DdManager *)pNtk->pManFunc)) );
        }
        else 
            pNtk = pNtkTemp;
    }
#endif
 
    // return the result
    *ppNtk = pNtk;
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkLatchIsSelfFeed()

ABC_DLL int Abc_NtkLatchIsSelfFeed ( Abc_Obj_t * pLatch )

extern

Function*************************************************************

Synopsis [Checks if latches form self-loop.]

Description []

SideEffects []

SeeAlso []

Definition at line 71 of file abcLatch.c.

{
    Abc_Obj_t * pFanin;
    assert( Abc_ObjIsLatch(pLatch) );
    pFanin = Abc_ObjFanin0(Abc_ObjFanin0(pLatch));
    if ( !Abc_ObjIsBo(pFanin) || !Abc_ObjIsLatch(Abc_ObjFanin0(pFanin)) )
        return 0;
    return Abc_NtkLatchIsSelfFeed_rec( Abc_ObjFanin0(pFanin), pLatch );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkLevel()

ABC_DLL int Abc_NtkLevel ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Computes the number of logic levels not counting PIs/POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1449 of file abcDfs.c.

{
    Abc_Obj_t * pNode;
    int i, LevelsMax;
    // set the CI levels
    if ( pNtk->pManTime == NULL || pNtk->AndGateDelay <= 0 )
        Abc_NtkForEachCi( pNtk, pNode, i )
            pNode->Level = 0;
    else
        Abc_NtkForEachCi( pNtk, pNode, i )
            pNode->Level = (int)(Abc_MaxFloat(0, Abc_NodeReadArrivalWorst(pNode)) / pNtk->AndGateDelay);
    // perform the traversal
    LevelsMax = 0;
    Abc_NtkIncrementTravId( pNtk );
    if ( pNtk->nBarBufs == 0 )
    {
        Abc_NtkForEachNode( pNtk, pNode, i )
        {
            Abc_NtkLevel_rec( pNode );
            if ( LevelsMax < (int)pNode->Level )
                LevelsMax = (int)pNode->Level;
        }
    }
    else
    {
        Abc_NtkForEachLiPo( pNtk, pNode, i )
        {
            Abc_Obj_t * pDriver = Abc_ObjFanin0(pNode);
            Abc_NtkLevel_rec( pDriver );
            if ( LevelsMax < (int)pDriver->Level )
                LevelsMax = (int)pDriver->Level;
            // transfer the delay
            if ( i < pNtk->nBarBufs )
                Abc_ObjFanout0(Abc_ObjFanout0(pNode))->Level = pDriver->Level;
        }
    }
    return LevelsMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkLevelize()

ABC_DLL Vec_Vec_t * Abc_NtkLevelize ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Computes the number of logic levels not counting PIs/POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1423 of file abcDfs.c.

{
    Abc_Obj_t * pObj;
    Vec_Vec_t * vLevels;
    int nLevels, i;
    nLevels = Abc_NtkLevel( pNtk );
    vLevels = Vec_VecStart( nLevels + 1 );
    Abc_NtkForEachNode( pNtk, pObj, i )
    {
        assert( (int)pObj->Level <= nLevels );
        Vec_VecPush( vLevels, pObj->Level, pObj );
    }
    return vLevels;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkLevelR()

ABC_DLL int Abc_NtkLevelR ( Abc_Ntk_t * pNtk )

extern

Definition at line 1517 of file abcDfs.c.

{
    int i, LevelMax = Abc_NtkLevelReverse( pNtk );
    Abc_Obj_t * pNode;
    Abc_NtkForEachObj( pNtk, pNode, i )
        pNode->Level = (int)(LevelMax - pNode->Level + 1);
    return LevelMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkLevelReverse()

ABC_DLL int Abc_NtkLevelReverse ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Computes the number of logic levels not counting PIs/POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1499 of file abcDfs.c.

{
    Abc_Obj_t * pNode;
    int i, LevelsMax;
    // set the CO levels to zero
    Abc_NtkForEachCo( pNtk, pNode, i )
        pNode->Level = 0;
    // perform the traversal
    LevelsMax = 0;
    Abc_NtkIncrementTravId( pNtk );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        Abc_NtkLevelReverse_rec( pNode );
        if ( LevelsMax < (int)pNode->Level )
            LevelsMax = (int)pNode->Level;
    }
    return LevelsMax;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkLoadCopy()

ABC_DLL void Abc_NtkLoadCopy	(	Abc_Ntk_t *	pNtk,
		Vec_Ptr_t *	vCopies )

extern

Function*************************************************************

Synopsis [Loads copy field of the objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 650 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->pCopy = (Abc_Obj_t *)Vec_PtrEntry( vCopies, i );
}

Here is the caller graph for this function:

◆ Abc_NtkLogicHasSimpleCos()

ABC_DLL int Abc_NtkLogicHasSimpleCos ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns 1 if COs of a logic network are simple.]

Description [The COs of a logic network are simple under three conditions: (1) The edge from CO to its driver is not complemented. (2) If CI is a driver of a CO, they have the same name.] (3) If two COs share the same driver, they have the same name.]

SideEffects []

SeeAlso []

Definition at line 942 of file abcUtil.c.

{
    Abc_Obj_t * pNode, * pDriver;
    int i;
    assert( Abc_NtkIsLogic(pNtk) );
    Abc_NtkIncrementTravId( pNtk );
    Abc_NtkForEachCo( pNtk, pNode, i ) 
    {
        // if the driver is complemented, this is an error
        pDriver = Abc_ObjFanin0(pNode);
        if ( Abc_ObjFaninC0(pNode) )
            return 0;
        // if the driver is a CI and has different name, this is an error
        if ( Abc_ObjIsCi(pDriver) && strcmp(Abc_ObjName(pDriver), Abc_ObjName(pNode)) )
            return 0;
        // if the driver is visited for the first time, remember the CO name
        if ( !Abc_NodeIsTravIdCurrent(pDriver) )
        {
            pDriver->pNext = (Abc_Obj_t *)Abc_ObjName(pNode);
            Abc_NodeSetTravIdCurrent(pDriver);
            continue;
        }
        // the driver has second CO - if they have different name, this is an error
        if ( strcmp((char *)pDriver->pNext, Abc_ObjName(pNode)) ) // diff names
            return 0;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkLogicMakeDirectSops()

ABC_DLL void Abc_NtkLogicMakeDirectSops ( Abc_Ntk_t * pNtk )

extern

Definition at line 868 of file abcFunc.c.

868{}

◆ Abc_NtkLogicMakeSimpleCos()

ABC_DLL int Abc_NtkLogicMakeSimpleCos	(	Abc_Ntk_t *	pNtk,
		int	fDuplicate )

extern

Function*************************************************************

Synopsis [Transforms the network to have simple COs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1080 of file abcUtil.c.

{
    int fAddBuffers = 1;
    Vec_Ptr_t * vDrivers, * vCoTerms;
    Abc_Obj_t * pNode, * pDriver, * pDriverNew, * pFanin;
    int i, k, LevelMax, nTotal = 0;
    assert( Abc_NtkIsLogic(pNtk) );
    LevelMax = Abc_NtkLevel(pNtk);
//    Abc_NtkLogicMakeSimpleCosTest( pNtk, fDuplicate );
 
    // fix constant drivers
    Abc_NtkForEachCo( pNtk, pNode, i ) 
    {
        pDriver = Abc_ObjFanin0(pNode);
        if ( !Abc_NodeIsConst(pDriver) )
            continue;
        pDriverNew = (Abc_ObjFaninC0(pNode) == Abc_NodeIsConst0(pDriver)) ? Abc_NtkCreateNodeConst1(pNtk) : Abc_NtkCreateNodeConst0(pNtk);
        if ( Abc_ObjFaninC0(pNode) )
            Abc_ObjXorFaninC( pNode, 0 );
        Abc_ObjPatchFanin( pNode, pDriver, pDriverNew );
        if ( Abc_ObjFanoutNum(pDriver) == 0 )
            Abc_NtkDeleteObj( pDriver );
    }
 
    // collect drivers pointed by complemented edges
    vDrivers = Vec_PtrAlloc( 100 );
    Abc_NtkIncrementTravId( pNtk );
    Abc_NtkForEachCo( pNtk, pNode, i ) 
    {
        if ( !Abc_ObjFaninC0(pNode) )
            continue;
        pDriver = Abc_ObjFanin0(pNode);
        if ( Abc_NodeIsTravIdCurrent(pDriver) )
            continue;
        Abc_NodeSetTravIdCurrent(pDriver);
        Vec_PtrPush( vDrivers, pDriver );
    }
    // fix complemented drivers
    if ( Vec_PtrSize(vDrivers) > 0 )
    {
        int nDupGates = 0, nDupInvs = 0, nDupChange = 0;
        Vec_Ptr_t * vFanouts = Vec_PtrAlloc( 100 );
        Vec_PtrForEachEntry( Abc_Obj_t *, vDrivers, pDriver, i )
        {
            int fHasDir = 0, fHasInv = 0, fHasOther = 0;
            Abc_ObjForEachFanout( pDriver, pNode, k )
            {
                if ( !Abc_ObjIsCo(pNode) )
                {
                    assert( !Abc_ObjFaninC0(pNode) );
                    fHasOther = 1;
                    continue;
                }
                if ( Abc_ObjFaninC0(pNode) )
                    fHasInv = 1;
                else //if ( Abc_ObjFaninC0(pNode) )
                    fHasDir = 1;
            }
            assert( fHasInv );
            if ( Abc_ObjIsCi(pDriver) || fHasDir || (fHasOther && Abc_NtkHasMapping(pNtk)) ) // cannot change
            {
                // duplicate if critical
                if ( fDuplicate && Abc_ObjIsNode(pDriver) && Abc_ObjLevel(pDriver) == LevelMax )
                {
                    pDriverNew = Abc_NtkDupObj( pNtk, pDriver, 0 ); 
                    Abc_ObjForEachFanin( pDriver, pFanin, k )
                        Abc_ObjAddFanin( pDriverNew, pFanin );
                    Abc_NodeComplement( pDriverNew );
                    nDupGates++;
                }
                else // add inverter
                {
                    pDriverNew = Abc_NtkCreateNodeInv( pNtk, pDriver );
                    nDupInvs++;
                }
                // collect CO fanouts to be redirected to the new node
                Vec_PtrClear( vFanouts );
                Abc_ObjForEachFanout( pDriver, pNode, k )
                    if ( Abc_ObjIsCo(pNode) && Abc_ObjFaninC0(pNode) )
                        Vec_PtrPush( vFanouts, pNode );
                assert( Vec_PtrSize(vFanouts) > 0 );
                Vec_PtrForEachEntry( Abc_Obj_t *, vFanouts, pNode, k )
                {
                    Abc_ObjXorFaninC( pNode, 0 );
                    Abc_ObjPatchFanin( pNode, pDriver, pDriverNew );
                    assert( Abc_ObjIsCi(pDriver) || Abc_ObjFanoutNum(pDriver) > 0 );
                }
            }
            else // can change
            {
                // change polarity of the driver
                assert( Abc_ObjIsNode(pDriver) );
                Abc_NodeComplement( pDriver );
                Abc_ObjForEachFanout( pDriver, pNode, k )
                {
                    if ( Abc_ObjIsCo(pNode) )
                    {
                        assert( Abc_ObjFaninC0(pNode) );
                        Abc_ObjXorFaninC( pNode, 0 );
                    }
                    else if ( Abc_ObjIsNode(pNode) )
                        Abc_NodeComplementInput( pNode, pDriver );
                    else assert( 0 );
                }
                nDupChange++;
            }
        }
        Vec_PtrFree( vFanouts );
//        printf( "Resolving inverted CO drivers: Invs = %d. Dups = %d. Changes = %d.\n",
//            nDupInvs, nDupGates, nDupChange );
        nTotal += nDupInvs + nDupGates;
    }
    Vec_PtrFree( vDrivers );
 
    // collect COs that needs fixing by adding buffers or duplicating
    vCoTerms = Vec_PtrAlloc( 100 );
    Abc_NtkIncrementTravId( pNtk );
    
    // The following cases should be addressed only if the network is written 
    // into a BLIF file. Otherwise, it is possible to skip them:
    // (1) if a CO points to a CI with a different name
    // (2) if an internal node drives more than one CO
    if ( fAddBuffers )
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        // if the driver is a CI and has different name, this is an error
        pDriver = Abc_ObjFanin0(pNode);
        if ( Abc_ObjIsCi(pDriver) && strcmp(Abc_ObjName(pDriver), Abc_ObjName(pNode)) )
        {
            Vec_PtrPush( vCoTerms, pNode );
            continue;
        }
        // if the driver is visited for the first time, remember the CO name
        if ( !Abc_NodeIsTravIdCurrent(pDriver) )
        {
            pDriver->pNext = (Abc_Obj_t *)Abc_ObjName(pNode);
            Abc_NodeSetTravIdCurrent(pDriver);
            continue;
        }
        // the driver has second CO - if they have different name, this is an error
        if ( strcmp((char *)pDriver->pNext, Abc_ObjName(pNode)) ) // diff names
        {
            Vec_PtrPush( vCoTerms, pNode );
            continue;
        }
    }
    // fix duplication problem
    if ( Vec_PtrSize(vCoTerms) > 0 )
    {
        int nDupBufs = 0, nDupGates = 0;
        Vec_PtrForEachEntry( Abc_Obj_t *, vCoTerms, pNode, i )
        {
            pDriver = Abc_ObjFanin0(pNode);
            // duplicate if critical
            if ( fDuplicate && Abc_ObjIsNode(pDriver) && (Abc_NtkHasMapping(pNtk) || Abc_ObjLevel(pDriver) == LevelMax) )
            {
                pDriverNew = Abc_NtkDupObj( pNtk, pDriver, 0 ); 
                Abc_ObjForEachFanin( pDriver, pFanin, k )
                    Abc_ObjAddFanin( pDriverNew, pFanin );
                nDupGates++;
            }
            else // add buffer
            {
                pDriverNew = Abc_NtkCreateNodeBuf( pNtk, pDriver );
                Abc_ObjAssignName( pDriverNew, Abc_ObjName(pDriver), "_buf" );
                nDupBufs++;
            }
            // swing the PO
            Abc_ObjPatchFanin( pNode, pDriver, pDriverNew );
            assert( Abc_ObjIsCi(pDriver) || Abc_ObjFanoutNum(pDriver) > 0 );
        }
//        printf( "Resolving shared CO drivers: Bufs = %d. Dups = %d.\n", nDupBufs, nDupGates );
        nTotal += nDupBufs + nDupGates;
    }
    Vec_PtrFree( vCoTerms );
    return nTotal;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMakeComb()

ABC_DLL void Abc_NtkMakeComb	(	Abc_Ntk_t *	pNtk,
		int	fRemoveLatches )

extern

Function*************************************************************

Synopsis [Converts the network to combinational.]

Description []

SideEffects []

SeeAlso []

Definition at line 1637 of file abcNtk.c.

{
    Abc_Obj_t * pObj;
    int i;
 
    if ( Abc_NtkIsComb(pNtk) )
        return;
 
    assert( !Abc_NtkIsNetlist(pNtk) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
 
    // detach the latches
//    Abc_NtkForEachLatch( pNtk, pObj, i )
    Vec_PtrForEachEntryReverse( Abc_Obj_t *, pNtk->vBoxes, pObj, i )
        Abc_NtkDeleteObj( pObj );
    assert( Abc_NtkLatchNum(pNtk) == 0 );
    assert( Abc_NtkBoxNum(pNtk) == 0 );
 
    // move CIs to become PIs
    Vec_PtrClear( pNtk->vPis );
    Abc_NtkForEachCi( pNtk, pObj, i )
    {
        if ( Abc_ObjIsBo(pObj) )
        {
            pObj->Type = ABC_OBJ_PI;
            pNtk->nObjCounts[ABC_OBJ_PI]++;
            pNtk->nObjCounts[ABC_OBJ_BO]--;
        }
        Vec_PtrPush( pNtk->vPis, pObj );
    }
    assert( Abc_NtkBoNum(pNtk) == 0 );
 
    if ( fRemoveLatches )
    {
        // remove registers
        Vec_Ptr_t * vBos;
        vBos = Vec_PtrAlloc( 100 );
        Vec_PtrClear( pNtk->vPos );
        Abc_NtkForEachCo( pNtk, pObj, i )
            if ( Abc_ObjIsBi(pObj) )
                Vec_PtrPush( vBos, pObj );
            else
                Vec_PtrPush( pNtk->vPos, pObj );
        // remove COs
        Vec_PtrFree( pNtk->vCos );
        pNtk->vCos = NULL;
        // remove the BOs
        Vec_PtrForEachEntry( Abc_Obj_t *, vBos, pObj, i )
            Abc_NtkDeleteObj( pObj );
        Vec_PtrFree( vBos );
        // create COs
        pNtk->vCos = Vec_PtrDup( pNtk->vPos );
        // cleanup
        if ( Abc_NtkIsLogic(pNtk) )
            Abc_NtkCleanup( pNtk, 0 );
        else if ( Abc_NtkIsStrash(pNtk) )
            Abc_AigCleanup( (Abc_Aig_t *)pNtk->pManFunc );
        else
            assert( 0 );
    }
    else
    {
        // move COs to become POs
        Vec_PtrClear( pNtk->vPos );
        Abc_NtkForEachCo( pNtk, pObj, i )
        {
            if ( Abc_ObjIsBi(pObj) )
            {
                pObj->Type = ABC_OBJ_PO;
                pNtk->nObjCounts[ABC_OBJ_PO]++;
                pNtk->nObjCounts[ABC_OBJ_BI]--;
            }
            Vec_PtrPush( pNtk->vPos, pObj );
        }
    }
    assert( Abc_NtkBiNum(pNtk) == 0 );
 
    if ( !Abc_NtkCheck( pNtk ) )
        fprintf( stdout, "Abc_NtkMakeComb(): Network check has failed.\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMakeLegit()

ABC_DLL int Abc_NtkMakeLegit ( Abc_Ntk_t * pNtk )

extern

Definition at line 634 of file abcFanOrder.c.

{
    Abc_Obj_t * pNode;
    int i, Counter = 0;
    assert( Abc_NtkHasSop(pNtk) );
    Abc_NtkForEachNode( pNtk, pNode, i )
        Counter += Abc_NodeMakeLegit( pNode );
    if ( Counter )
        Abc_Print( 0, "%d nodes were made dist1-cube-free and/or single-cube-containment-free.\n", Counter );
    return 1;
}

Here is the call graph for this function:

◆ Abc_NtkManCutReadCutLarge()

ABC_DLL Vec_Ptr_t * Abc_NtkManCutReadCutLarge ( Abc_ManCut_t * p )

extern

Function*************************************************************

Synopsis [Returns the leaves of the cone.]

Description []

SideEffects []

SeeAlso []

Definition at line 644 of file abcReconv.c.

{
    return p->vConeLeaves;
}

Here is the caller graph for this function:

◆ Abc_NtkManCutReadCutSmall()

ABC_DLL Vec_Ptr_t * Abc_NtkManCutReadCutSmall ( Abc_ManCut_t * p )

extern

Function*************************************************************

Synopsis [Returns the leaves of the cone.]

Description []

SideEffects []

SeeAlso []

Definition at line 660 of file abcReconv.c.

{
    return p->vNodeLeaves;
}

Here is the caller graph for this function:

◆ Abc_NtkManCutReadVisited()

ABC_DLL Vec_Ptr_t * Abc_NtkManCutReadVisited ( Abc_ManCut_t * p )

extern

Function*************************************************************

Synopsis [Returns the leaves of the cone.]

Description []

SideEffects []

SeeAlso []

Definition at line 676 of file abcReconv.c.

{
    return p->vVisited;
}

Here is the caller graph for this function:

◆ Abc_NtkManCutStart()

ABC_DLL Abc_ManCut_t * Abc_NtkManCutStart	(	int	nNodeSizeMax,
		int	nConeSizeMax,
		int	nNodeFanStop,
		int	nConeFanStop )

extern

Function*************************************************************

Synopsis [Starts the resynthesis manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 595 of file abcReconv.c.

{
    Abc_ManCut_t * p;
    p = ABC_ALLOC( Abc_ManCut_t, 1 );
    memset( p, 0, sizeof(Abc_ManCut_t) );
    p->vNodeLeaves  = Vec_PtrAlloc( 100 );
    p->vConeLeaves  = Vec_PtrAlloc( 100 );
    p->vVisited     = Vec_PtrAlloc( 100 );
    p->vLevels      = Vec_VecAlloc( 100 );
    p->vNodesTfo    = Vec_PtrAlloc( 100 );
    p->nNodeSizeMax = nNodeSizeMax;
    p->nConeSizeMax = nConeSizeMax;
    p->nNodeFanStop = nNodeFanStop;
    p->nConeFanStop = nConeFanStop;
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkManCutStop()

ABC_DLL void Abc_NtkManCutStop ( Abc_ManCut_t * p )

extern

Function*************************************************************

Synopsis [Stops the resynthesis manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 623 of file abcReconv.c.

{
    Vec_PtrFree( p->vNodeLeaves );
    Vec_PtrFree( p->vConeLeaves );
    Vec_PtrFree( p->vVisited    );
    Vec_VecFree( p->vLevels );
    Vec_PtrFree( p->vNodesTfo );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Abc_NtkMapToSop()

ABC_DLL int Abc_NtkMapToSop ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Unmaps the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 1228 of file abcFunc.c.

{
    extern void * Abc_FrameReadLibGen();                    
    return Abc_NtkMapToSopUsingLibrary(pNtk, Abc_FrameReadLibGen());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMapToSopUsingLibrary()

ABC_DLL int Abc_NtkMapToSopUsingLibrary	(	Abc_Ntk_t *	pNtk,
		void *	library )

extern

Function*************************************************************

Synopsis [Unmaps the network with user provided Mio library.]

Description []

SideEffects []

SeeAlso []

Definition at line 1194 of file abcFunc.c.

{
    Abc_Obj_t * pNode;
    char * pSop;
    int i;
 
    assert( Abc_NtkHasMapping(pNtk) );
    // update the functionality manager
    assert( pNtk->pManFunc == (void*) library );
    pNtk->pManFunc = Mem_FlexStart();
    // update the nodes
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( Abc_ObjIsBarBuf(pNode) )
            continue;
        pSop = Mio_GateReadSop((Mio_Gate_t *)pNode->pData);
        assert( Abc_SopGetVarNum(pSop) == Abc_ObjFaninNum(pNode) );
        pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, pSop );
    }
    pNtk->ntkFunc  = ABC_FUNC_SOP;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMfsTotalGlitching()

ABC_DLL float Abc_NtkMfsTotalGlitching	(	Abc_Ntk_t *	pNtk,
		int	nPats,
		int	Prob,
		int	fVerbose )

extern

Function*************************************************************

Synopsis [Returns the percentable of increased power due to glitching.]

Description []

SideEffects []

SeeAlso []

Definition at line 1942 of file abcPrint.c.

{
    int nSwitches, nGlitches;
    Gli_Man_t * p;
    Vec_Ptr_t * vNodes;
    Vec_Int_t * vFanins;
    Abc_Obj_t * pObj, * pFanin;
    int i, k, nFaninMax = Abc_NtkGetFaninMax(pNtk);
    if ( !Abc_NtkIsMappedLogic(pNtk) )
        return Abc_NtkMfsTotalGlitchingLut( pNtk, nPats, Prob, fVerbose );
    assert( Abc_NtkIsMappedLogic(pNtk) );
    if ( nFaninMax > 16 )
    {
        printf( "Abc_NtkMfsTotalGlitching() This procedure works only for mapped networks with LUTs size up to 6 inputs.\n" );
        return -1.0;
    }
    vNodes = Abc_NtkDfs( pNtk, 0 );
    vFanins = Vec_IntAlloc( 6 );
 
    // derive network for glitch computation
    p = Gli_ManAlloc( Vec_PtrSize(vNodes) + Abc_NtkCiNum(pNtk) + Abc_NtkCoNum(pNtk),
        Abc_NtkLatchNum(pNtk), Abc_NtkGetTotalFanins(pNtk) + Abc_NtkCoNum(pNtk) );
    Abc_NtkForEachObj( pNtk, pObj, i )
        pObj->iTemp = -1;
    Abc_NtkForEachCi( pNtk, pObj, i )
        pObj->iTemp = Gli_ManCreateCi( p, Abc_ObjFanoutNum(pObj) );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
    {
        Vec_IntClear( vFanins );
        Abc_ObjForEachFanin( pObj, pFanin, k )
            Vec_IntPush( vFanins, pFanin->iTemp );
        pObj->iTemp = Gli_ManCreateNode( p, vFanins, Abc_ObjFanoutNum(pObj), Mio_GateReadTruthP((Mio_Gate_t *)pObj->pData) );
    }
    Abc_NtkForEachCo( pNtk, pObj, i )
        Gli_ManCreateCo( p, Abc_ObjFanin0(pObj)->iTemp );
 
    // compute glitching
    Gli_ManSwitchesAndGlitches( p, nPats, 1.0/Prob, fVerbose );
 
    // compute the ratio
    nSwitches = nGlitches = 0;
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( pObj->iTemp >= 0 )
        {
            nSwitches += Abc_ObjFanoutNum(pObj) * Gli_ObjNumSwitches(p, pObj->iTemp);
            nGlitches += Abc_ObjFanoutNum(pObj) * Gli_ObjNumGlitches(p, pObj->iTemp);
        }
 
    Gli_ManStop( p );
    Vec_PtrFree( vNodes );
    Vec_IntFree( vFanins );
    return nSwitches ? 100.0*(nGlitches-nSwitches)/nSwitches : 0.0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMfsTotalSwitching()

ABC_DLL float Abc_NtkMfsTotalSwitching ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Marks nodes for power-optimization.]

Description []

SideEffects []

SeeAlso []

Definition at line 163 of file abcPrint.c.

{
    extern Aig_Man_t * Abc_NtkToDar( Abc_Ntk_t * pNtk, int fExors, int fRegisters );
    extern Vec_Int_t * Saig_ManComputeSwitchProbs( Aig_Man_t * p, int nFrames, int nPref, int fProbOne );
    Vec_Int_t * vSwitching;
    float * pSwitching;
    Abc_Ntk_t * pNtkStr;
    Aig_Man_t * pAig;
    Aig_Obj_t * pObjAig;
    Abc_Obj_t * pObjAbc, * pObjAbc2;
    float Result = (float)0;
    int i;
    // strash the network
    pNtkStr = Abc_NtkStrash( pNtk, 0, 1, 0 );
    Abc_NtkForEachObj( pNtk, pObjAbc, i )
        if ( (pObjAbc->pTemp && Abc_ObjRegular((Abc_Obj_t *)pObjAbc->pTemp)->Type == ABC_FUNC_NONE) || (!Abc_ObjIsCi(pObjAbc) && !Abc_ObjIsNode(pObjAbc)) )
            pObjAbc->pTemp = NULL;
    // map network into an AIG
    pAig = Abc_NtkToDar( pNtkStr, 0, (int)(Abc_NtkLatchNum(pNtk) > 0) );
    vSwitching = Saig_ManComputeSwitchProbs( pAig, 48, 16, 0 );
    pSwitching = (float *)vSwitching->pArray;
    Abc_NtkForEachObj( pNtk, pObjAbc, i )
    {
        if ( (pObjAbc2 = Abc_ObjRegular((Abc_Obj_t *)pObjAbc->pTemp)) && (pObjAig = Aig_Regular((Aig_Obj_t *)pObjAbc2->pTemp)) )
        {
            Result += Abc_ObjFanoutNum(pObjAbc) * pSwitching[pObjAig->Id];
//            Abc_ObjPrint( stdout, pObjAbc );
//            printf( "%d = %.2f\n", i, Abc_ObjFanoutNum(pObjAbc) * pSwitching[pObjAig->Id] );
        }
    }
    Vec_IntFree( vSwitching );
    Aig_ManStop( pAig );
    Abc_NtkDelete( pNtkStr );
    return Result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMinimumBase()

ABC_DLL int Abc_NtkMinimumBase ( Abc_Ntk_t * pNtk )

extern

DECLARATIONS ///.

CFile****************************************************************

FileName [abcMinBase.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Makes nodes of the network minimum base.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: abcMinBase.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

]

Definition at line 892 of file abcMinBase.c.

892{ return 0; }

Here is the caller graph for this function:

◆ Abc_NtkMiter()

ABC_DLL Abc_Ntk_t * Abc_NtkMiter	(	Abc_Ntk_t *	pNtk1,
		Abc_Ntk_t *	pNtk2,
		int	fComb,
		int	nPartSize,
		int	fImplic,
		int	fMulti )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Derives the miter of two networks.]

Description [Preprocesses the networks to make sure that they are strashed.]

SideEffects []

SeeAlso []

Definition at line 59 of file abcMiter.c.

{
    Abc_Ntk_t * pTemp = NULL;
    int fRemove1, fRemove2;
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk1) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk2) );
    // check that the networks have the same PIs/POs/latches
    if ( !Abc_NtkCompareSignals( pNtk1, pNtk2, fImplic, fComb ) )
        return NULL;
    // make sure the circuits are strashed 
    fRemove1 = (!Abc_NtkIsStrash(pNtk1) || Abc_NtkGetChoiceNum(pNtk1)) && (pNtk1 = Abc_NtkStrash(pNtk1, 0, 0, 0));
    fRemove2 = (!Abc_NtkIsStrash(pNtk2) || Abc_NtkGetChoiceNum(pNtk2)) && (pNtk2 = Abc_NtkStrash(pNtk2, 0, 0, 0));
    if ( pNtk1 && pNtk2 )
        pTemp = Abc_NtkMiterInt( pNtk1, pNtk2, fComb, nPartSize, fImplic, fMulti );
    if ( fRemove1 )  Abc_NtkDelete( pNtk1 );
    if ( fRemove2 )  Abc_NtkDelete( pNtk2 );
    return pTemp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMiterAddCone()

ABC_DLL void Abc_NtkMiterAddCone	(	Abc_Ntk_t *	pNtk,
		Abc_Ntk_t *	pNtkMiter,
		Abc_Obj_t *	pRoot )

extern

Function*************************************************************

Synopsis [Performs mitering for one network.]

Description []

SideEffects []

SeeAlso []

Definition at line 254 of file abcMiter.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pNode;
    int i;
    // map the constant nodes
    Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkMiter);
    // perform strashing
    vNodes = Abc_NtkDfsNodes( pNtk, &pRoot, 1 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
        if ( Abc_AigNodeIsAnd(pNode) )
            pNode->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkMiter->pManFunc, Abc_ObjChild0Copy(pNode), Abc_ObjChild1Copy(pNode) );
    Vec_PtrFree( vNodes );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMiterAnd()

ABC_DLL Abc_Ntk_t * Abc_NtkMiterAnd	(	Abc_Ntk_t *	pNtk1,
		Abc_Ntk_t *	pNtk2,
		int	fOr,
		int	fCompl2 )

extern

Function*************************************************************

Synopsis [Derives the AND of two miters.]

Description [The network should have the same names of PIs.]

SideEffects []

SeeAlso []

Definition at line 387 of file abcMiter.c.

{
    char Buffer[1000];
    Abc_Ntk_t * pNtkMiter;
    Abc_Obj_t * pOutput1, * pOutput2;
    Abc_Obj_t * pRoot1, * pRoot2, * pMiter;
 
    assert( Abc_NtkIsStrash(pNtk1) );
    assert( Abc_NtkIsStrash(pNtk2) );
    assert( 1 == Abc_NtkCoNum(pNtk1) );
    assert( 1 == Abc_NtkCoNum(pNtk2) );
    assert( 0 == Abc_NtkLatchNum(pNtk1) );
    assert( 0 == Abc_NtkLatchNum(pNtk2) );
    assert( Abc_NtkCiNum(pNtk1) == Abc_NtkCiNum(pNtk2) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk1) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk2) );
 
    // start the new network
    pNtkMiter = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
//    sprintf( Buffer, "%s_%s_miter", pNtk1->pName, pNtk2->pName );
    sprintf( Buffer, "product" );
    pNtkMiter->pName = Extra_UtilStrsav(Buffer);
 
    // perform strashing
    Abc_NtkMiterPrepare( pNtk1, pNtk2, pNtkMiter, 1, -1, 0 );
    Abc_NtkMiterAddOne( pNtk1, pNtkMiter );
    Abc_NtkMiterAddOne( pNtk2, pNtkMiter );
//    Abc_NtkMiterFinalize( pNtk1, pNtk2, pNtkMiter, 1 );
    pRoot1 = Abc_NtkPo(pNtk1,0);
    pRoot2 = Abc_NtkPo(pNtk2,0);
    pOutput1 = Abc_ObjNotCond( Abc_ObjFanin0(pRoot1)->pCopy, Abc_ObjFaninC0(pRoot1) );
    pOutput2 = Abc_ObjNotCond( Abc_ObjFanin0(pRoot2)->pCopy, (int)Abc_ObjFaninC0(pRoot2) ^ fCompl2 );
    
    // create the miter of the two outputs
    if ( fOr )
        pMiter = Abc_AigOr( (Abc_Aig_t *)pNtkMiter->pManFunc, pOutput1, pOutput2 );
    else
        pMiter = Abc_AigAnd( (Abc_Aig_t *)pNtkMiter->pManFunc, pOutput1, pOutput2 );
    Abc_ObjAddFanin( Abc_NtkPo(pNtkMiter,0), pMiter );
 
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkMiter ) )
    {
        printf( "Abc_NtkMiterAnd: The network check has failed.\n" );
        Abc_NtkDelete( pNtkMiter );
        return NULL;
    }
    return pNtkMiter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMiterCofactor()

ABC_DLL Abc_Ntk_t * Abc_NtkMiterCofactor	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t *	vPiValues )

extern

Function*************************************************************

Synopsis [Derives the cofactor of the miter w.r.t. the set of vars.]

Description [The array of variable values contains -1/0/1 for each PI. -1 means this PI remains, 0/1 means this PI is set to 0/1.]

SideEffects []

SeeAlso []

Definition at line 450 of file abcMiter.c.

{
    char Buffer[1000];
    Abc_Ntk_t * pNtkMiter;
    Abc_Obj_t * pRoot, * pOutput1;
    int Value, i;
 
    assert( Abc_NtkIsStrash(pNtk) );
    assert( 1 == Abc_NtkCoNum(pNtk) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
 
    // start the new network
    pNtkMiter = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    sprintf( Buffer, "%s_miter", pNtk->pName );
    pNtkMiter->pName = Extra_UtilStrsav(Buffer);
 
    // get the root output
    pRoot = Abc_NtkCo( pNtk, 0 );
 
    // perform strashing
    Abc_NtkMiterPrepare( pNtk, pNtk, pNtkMiter, 1, -1, 0 );
    // set the first cofactor
    Vec_IntForEachEntry( vPiValues, Value, i )
    {
        if ( Value == -1 )
            continue;
        if ( Value == 0 )
        {
            Abc_NtkCi(pNtk, i)->pCopy = Abc_ObjNot( Abc_AigConst1(pNtkMiter) );
            continue;
        }
        if ( Value == 1 )
        {
            Abc_NtkCi(pNtk, i)->pCopy = Abc_AigConst1(pNtkMiter);
            continue;
        }
        assert( 0 );
    }
    // add the first cofactor
    Abc_NtkMiterAddCone( pNtk, pNtkMiter, pRoot );
 
    // save the output
    pOutput1 = Abc_ObjNotCond( Abc_ObjFanin0(pRoot)->pCopy, Abc_ObjFaninC0(pRoot) );
 
    // create the miter of the two outputs
    Abc_ObjAddFanin( Abc_NtkPo(pNtkMiter,0), pOutput1 );
 
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkMiter ) )
    {
        printf( "Abc_NtkMiterCofactor: The network check has failed.\n" );
        Abc_NtkDelete( pNtkMiter );
        return NULL;
    }
    return pNtkMiter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMiterForCofactors()

ABC_DLL Abc_Ntk_t * Abc_NtkMiterForCofactors	(	Abc_Ntk_t *	pNtk,
		int	Out,
		int	In1,
		int	In2 )

extern

Function*************************************************************

Synopsis [Derives the miter of two cofactors of one output.]

Description []

SideEffects []

SeeAlso []

Definition at line 517 of file abcMiter.c.

{
    char Buffer[1000];
    Abc_Ntk_t * pNtkMiter;
    Abc_Obj_t * pRoot, * pOutput1, * pOutput2, * pMiter;
 
    assert( Abc_NtkIsStrash(pNtk) );
    assert( Out < Abc_NtkCoNum(pNtk) );
    assert( In1 < Abc_NtkCiNum(pNtk) );
    assert( In2 < Abc_NtkCiNum(pNtk) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
 
    // start the new network
    pNtkMiter = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    sprintf( Buffer, "%s_miter", Abc_ObjName(Abc_NtkCo(pNtk, Out)) );
    pNtkMiter->pName = Extra_UtilStrsav(Buffer);
 
    // get the root output
    pRoot = Abc_NtkCo( pNtk, Out );
 
    // perform strashing
    Abc_NtkMiterPrepare( pNtk, pNtk, pNtkMiter, 1, -1, 0 );
    // set the first cofactor
    Abc_NtkCi(pNtk, In1)->pCopy = Abc_ObjNot( Abc_AigConst1(pNtkMiter) );
    if ( In2 >= 0 )
    Abc_NtkCi(pNtk, In2)->pCopy = Abc_AigConst1(pNtkMiter);
    // add the first cofactor
    Abc_NtkMiterAddCone( pNtk, pNtkMiter, pRoot );
 
    // save the output
    pOutput1 = Abc_ObjFanin0(pRoot)->pCopy;
 
    // set the second cofactor
    Abc_NtkCi(pNtk, In1)->pCopy = Abc_AigConst1(pNtkMiter);
    if ( In2 >= 0 )
    Abc_NtkCi(pNtk, In2)->pCopy = Abc_ObjNot( Abc_AigConst1(pNtkMiter) );
    // add the second cofactor
    Abc_NtkMiterAddCone( pNtk, pNtkMiter, pRoot );
 
    // save the output
    pOutput2 = Abc_ObjFanin0(pRoot)->pCopy;
 
    // create the miter of the two outputs
    pMiter = Abc_AigXor( (Abc_Aig_t *)pNtkMiter->pManFunc, pOutput1, pOutput2 );
    Abc_ObjAddFanin( Abc_NtkPo(pNtkMiter,0), pMiter );
 
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkMiter ) )
    {
        printf( "Abc_NtkMiter: The network check has failed.\n" );
        Abc_NtkDelete( pNtkMiter );
        return NULL;
    }
    return pNtkMiter;
}

Here is the call graph for this function:

◆ Abc_NtkMiterIsConstant()

ABC_DLL int Abc_NtkMiterIsConstant ( Abc_Ntk_t * pMiter )

extern

Function*************************************************************

Synopsis [Checks the status of the miter.]

Description [Return 0 if the miter is sat for at least one output. Return 1 if the miter is unsat for all its outputs. Returns -1 if the miter is undecided for some outputs.]

SideEffects []

SeeAlso []

Definition at line 682 of file abcMiter.c.

{
    Abc_Obj_t * pNodePo, * pChild;
    int i;
    assert( Abc_NtkIsStrash(pMiter) );
    Abc_NtkForEachPo( pMiter, pNodePo, i )
    {
        pChild = Abc_ObjChild0( pNodePo );
        // check if the output is constant 1
        if ( Abc_AigNodeIsConst(pChild) )
        {
            assert( Abc_ObjRegular(pChild) == Abc_AigConst1(pMiter) );
            if ( !Abc_ObjIsComplement(pChild) )
            {
                // if the miter is constant 1, return immediately
//                printf( "MITER IS CONSTANT 1!\n" );
                return 0;
            }
        }
/*
        // check if the output is not constant 0
        else if ( Abc_ObjRegular(pChild)->fPhase != (unsigned)Abc_ObjIsComplement(pChild) )
        {
            return 0;
        }
*/
        // if the miter is undecided (or satisfiable), return immediately
        else 
            return -1;
    }
    // return 1, meaning all outputs are constant zero
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMiterProve()

ABC_DLL int Abc_NtkMiterProve	(	Abc_Ntk_t **	ppNtk,
		void *	pPars )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Attempts to solve the miter using a number of tricks.]

Description [Returns -1 if timed out; 0 if SAT; 1 if UNSAT. Returns a simplified version of the original network (or a constant 0 network). In case the network is not a constant zero and a SAT assignment is found, pNtk->pModel contains a satisfying assignment.]

SideEffects []

SeeAlso []

Definition at line 62 of file abcProve.c.

{
    Prove_Params_t * pParams = (Prove_Params_t *)pPars;
    Abc_Ntk_t * pNtk, * pNtkTemp;
    int RetValue = -1, nIter, nSatFails, Counter;
    abctime clk; //, timeStart = Abc_Clock();
    ABC_INT64_T nSatConfs, nSatInspects, nInspectLimit;
 
    // get the starting network
    pNtk = *ppNtk;
    assert( Abc_NtkIsStrash(pNtk) );
    assert( Abc_NtkPoNum(pNtk) == 1 );
 
    if ( pParams->fVerbose )
    {
        printf( "RESOURCE LIMITS: Iterations = %d. Rewriting = %s. Fraiging = %s.\n",
            pParams->nItersMax, pParams->fUseRewriting? "yes":"no", pParams->fUseFraiging? "yes":"no" );
        printf( "Miter = %d (%3.1f).  Rwr = %d (%3.1f).  Fraig = %d (%3.1f).  Last = %d.\n", 
            pParams->nMiteringLimitStart,  pParams->nMiteringLimitMulti, 
            pParams->nRewritingLimitStart, pParams->nRewritingLimitMulti,
            pParams->nFraigingLimitStart,  pParams->nFraigingLimitMulti, pParams->nMiteringLimitLast );
    }
 
    // if SAT only, solve without iteration
    if ( !pParams->fUseRewriting && !pParams->fUseFraiging )
    {
        clk = Abc_Clock();
        RetValue = Abc_NtkMiterSat( pNtk, (ABC_INT64_T)pParams->nMiteringLimitLast, (ABC_INT64_T)0, 0, NULL, NULL );
        Abc_NtkMiterPrint( pNtk, "SAT solving", clk, pParams->fVerbose );
        *ppNtk = pNtk;
        return RetValue;
    }
 
    // check the current resource limits
    for ( nIter = 0; nIter < pParams->nItersMax; nIter++ )
    {
        if ( pParams->fVerbose )
        {
            printf( "ITERATION %2d : Confs = %6d. FraigBTL = %3d. \n", nIter+1, 
                 (int)(pParams->nMiteringLimitStart * pow(pParams->nMiteringLimitMulti,nIter)), 
                 (int)(pParams->nFraigingLimitStart * pow(pParams->nFraigingLimitMulti,nIter)) );
            fflush( stdout );
        }
 
        // try brute-force SAT
        clk = Abc_Clock();
        nInspectLimit = pParams->nTotalInspectLimit? pParams->nTotalInspectLimit - pParams->nTotalInspectsMade : 0;
        RetValue = Abc_NtkMiterSat( pNtk, (ABC_INT64_T)(pParams->nMiteringLimitStart * pow(pParams->nMiteringLimitMulti,nIter)), (ABC_INT64_T)nInspectLimit, 0, &nSatConfs, &nSatInspects );
        Abc_NtkMiterPrint( pNtk, "SAT solving", clk, pParams->fVerbose );
        if ( RetValue >= 0 )
            break;
 
        // add to the number of backtracks and inspects
        pParams->nTotalBacktracksMade += nSatConfs;
        pParams->nTotalInspectsMade   += nSatInspects;
        // check if global resource limit is reached
        if ( (pParams->nTotalBacktrackLimit && pParams->nTotalBacktracksMade >= pParams->nTotalBacktrackLimit) ||
             (pParams->nTotalInspectLimit   && pParams->nTotalInspectsMade   >= pParams->nTotalInspectLimit) )
        {
            printf( "Reached global limit on conflicts/inspects. Quitting.\n" );
            *ppNtk = pNtk;
            return -1;
        }
 
        // try rewriting
        if ( pParams->fUseRewriting )
        {
            clk = Abc_Clock();
            Counter = (int)(pParams->nRewritingLimitStart * pow(pParams->nRewritingLimitMulti,nIter));
//            Counter = 1;
            while ( 1 )
            {
/*
                extern Abc_Ntk_t * Abc_NtkIvyResyn( Abc_Ntk_t * pNtk, int fUpdateLevel, int fVerbose );
                pNtk = Abc_NtkIvyResyn( pNtkTemp = pNtk, 0, 0 );  Abc_NtkDelete( pNtkTemp );
                if ( (RetValue = Abc_NtkMiterIsConstant(pNtk)) >= 0 )
                    break;
                if ( --Counter == 0 )
                    break;
*/
/*
                Abc_NtkRewrite( pNtk, 0, 0, 0, 0, 0 );
                if ( (RetValue = Abc_NtkMiterIsConstant(pNtk)) >= 0 )
                    break;
                if ( --Counter == 0 )
                    break;
*/
                Abc_NtkRewrite( pNtk, 0, 0, 0, 0, 0 );
                if ( (RetValue = Abc_NtkMiterIsConstant(pNtk)) >= 0 )
                    break;
                if ( --Counter == 0 )
                    break;
                Abc_NtkRefactor( pNtk, 10, 1, 16, 0, 0, 0, 0 );
                if ( (RetValue = Abc_NtkMiterIsConstant(pNtk)) >= 0 )
                    break;
                if ( --Counter == 0 )
                    break;
                pNtk = Abc_NtkBalance( pNtkTemp = pNtk, 0, 0, 0 );  Abc_NtkDelete( pNtkTemp );
                if ( (RetValue = Abc_NtkMiterIsConstant(pNtk)) >= 0 )
                    break;
                if ( --Counter == 0 )
                    break;
            }
            Abc_NtkMiterPrint( pNtk, "Rewriting  ", clk, pParams->fVerbose );
        }
 
        if ( pParams->fUseFraiging )
        {
            // try FRAIGing
            clk = Abc_Clock();
            nInspectLimit = pParams->nTotalInspectLimit? pParams->nTotalInspectLimit - pParams->nTotalInspectsMade : 0;
            pNtk = Abc_NtkMiterFraig( pNtkTemp = pNtk, (int)(pParams->nFraigingLimitStart * pow(pParams->nFraigingLimitMulti,nIter)), nInspectLimit, &RetValue, &nSatFails, &nSatConfs, &nSatInspects );  Abc_NtkDelete( pNtkTemp );
            Abc_NtkMiterPrint( pNtk, "FRAIGing   ", clk, pParams->fVerbose );
//            printf( "NumFails = %d\n", nSatFails );
            if ( RetValue >= 0 )
                break;
 
            // add to the number of backtracks and inspects
            pParams->nTotalBacktracksMade += nSatConfs;
            pParams->nTotalInspectsMade += nSatInspects;
            // check if global resource limit is reached
            if ( (pParams->nTotalBacktrackLimit && pParams->nTotalBacktracksMade >= pParams->nTotalBacktrackLimit) ||
                 (pParams->nTotalInspectLimit   && pParams->nTotalInspectsMade   >= pParams->nTotalInspectLimit) )
            {
                printf( "Reached global limit on conflicts/inspects. Quitting.\n" );
                *ppNtk = pNtk;
                return -1;
            }
        }
 
    }    
 
    // try to prove it using brute force SAT
#ifdef ABC_USE_CUDD
    if ( RetValue < 0 && pParams->fUseBdds )
    {
        if ( pParams->fVerbose )
        {
            printf( "Attempting BDDs with node limit %d ...\n", pParams->nBddSizeLimit );
            fflush( stdout );
        }
        clk = Abc_Clock();
        pNtk = Abc_NtkCollapse( pNtkTemp = pNtk, pParams->nBddSizeLimit, 0, pParams->fBddReorder, 0, 0, 0 );
        if ( pNtk )   
        {
            Abc_NtkDelete( pNtkTemp );
            RetValue = ( (Abc_NtkNodeNum(pNtk) == 1) && (Abc_ObjFanin0(Abc_NtkPo(pNtk,0))->pData == Cudd_ReadLogicZero((DdManager *)pNtk->pManFunc)) );
        }
        else 
            pNtk = pNtkTemp;
        Abc_NtkMiterPrint( pNtk, "BDD building", clk, pParams->fVerbose );
    }
#endif
 
    if ( RetValue < 0 )
    {
        if ( pParams->fVerbose )
        {
            printf( "Attempting SAT with conflict limit %d ...\n", pParams->nMiteringLimitLast );
            fflush( stdout );
        }
        clk = Abc_Clock();
        nInspectLimit = pParams->nTotalInspectLimit? pParams->nTotalInspectLimit - pParams->nTotalInspectsMade : 0;
        RetValue = Abc_NtkMiterSat( pNtk, (ABC_INT64_T)pParams->nMiteringLimitLast, (ABC_INT64_T)nInspectLimit, 0, NULL, NULL );
        Abc_NtkMiterPrint( pNtk, "SAT solving", clk, pParams->fVerbose );
    }
 
    // assign the model if it was proved by rewriting (const 1 miter)
    if ( RetValue == 0 && pNtk->pModel == NULL )
    {
        pNtk->pModel = ABC_ALLOC( int, Abc_NtkCiNum(pNtk) );
        memset( pNtk->pModel, 0, sizeof(int) * Abc_NtkCiNum(pNtk) );
    }
    *ppNtk = pNtk;
    return RetValue;
}

Here is the call graph for this function:

◆ Abc_NtkMiterQuantify()

ABC_DLL Abc_Ntk_t * Abc_NtkMiterQuantify	(	Abc_Ntk_t *	pNtk,
		int	In,
		int	fExist )

extern

Function*************************************************************

Synopsis [Derives the miter of two cofactors of one output.]

Description []

SideEffects []

SeeAlso []

Definition at line 585 of file abcMiter.c.

{
    Abc_Ntk_t * pNtkMiter;
    Abc_Obj_t * pRoot, * pOutput1, * pOutput2, * pMiter;
 
    assert( Abc_NtkIsStrash(pNtk) );
    assert( 1 == Abc_NtkCoNum(pNtk) );
    assert( In < Abc_NtkCiNum(pNtk) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
 
    // start the new network
    pNtkMiter = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    pNtkMiter->pName = Extra_UtilStrsav( Abc_ObjName(Abc_NtkCo(pNtk, 0)) );
 
    // get the root output
    pRoot = Abc_NtkCo( pNtk, 0 );
 
    // perform strashing
    Abc_NtkMiterPrepare( pNtk, pNtk, pNtkMiter, 1, -1, 0 );
    // set the first cofactor
    Abc_NtkCi(pNtk, In)->pCopy = Abc_ObjNot( Abc_AigConst1(pNtkMiter) );
    // add the first cofactor
    Abc_NtkMiterAddCone( pNtk, pNtkMiter, pRoot );
    // save the output
//    pOutput1 = Abc_ObjFanin0(pRoot)->pCopy;
    pOutput1 = Abc_ObjNotCond( Abc_ObjFanin0(pRoot)->pCopy, Abc_ObjFaninC0(pRoot) );
 
    // set the second cofactor
    Abc_NtkCi(pNtk, In)->pCopy = Abc_AigConst1(pNtkMiter);
    // add the second cofactor
    Abc_NtkMiterAddCone( pNtk, pNtkMiter, pRoot );
    // save the output
//    pOutput2 = Abc_ObjFanin0(pRoot)->pCopy;
    pOutput2 = Abc_ObjNotCond( Abc_ObjFanin0(pRoot)->pCopy, Abc_ObjFaninC0(pRoot) );
 
    // create the miter of the two outputs
    if ( fExist ) 
        pMiter = Abc_AigOr( (Abc_Aig_t *)pNtkMiter->pManFunc, pOutput1, pOutput2 );
    else
        pMiter = Abc_AigAnd( (Abc_Aig_t *)pNtkMiter->pManFunc, pOutput1, pOutput2 );
    Abc_ObjAddFanin( Abc_NtkPo(pNtkMiter,0), pMiter );
 
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkMiter ) )
    {
        printf( "Abc_NtkMiter: The network check has failed.\n" );
        Abc_NtkDelete( pNtkMiter );
        return NULL;
    }
    return pNtkMiter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMiterQuantifyPis()

ABC_DLL Abc_Ntk_t * Abc_NtkMiterQuantifyPis ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Quantifies all the PIs existentially from the only PO of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 648 of file abcMiter.c.

{
    Abc_Ntk_t * pNtkTemp;
    Abc_Obj_t * pObj;
    int i;
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
 
    Abc_NtkForEachPi( pNtk, pObj, i )
    {
        if ( Abc_ObjFanoutNum(pObj) == 0 )
            continue;
        pNtk = Abc_NtkMiterQuantify( pNtkTemp = pNtk, i, 1 );
        Abc_NtkDelete( pNtkTemp );
    }
 
    return pNtk;
}

Here is the call graph for this function:

◆ Abc_NtkMiterReport()

ABC_DLL void Abc_NtkMiterReport ( Abc_Ntk_t * pMiter )

extern

Function*************************************************************

Synopsis [Reports the status of the miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 727 of file abcMiter.c.

{
    Abc_Obj_t * pChild, * pNode;
    int i;
    if ( Abc_NtkPoNum(pMiter) == 1 )
    {
        pChild = Abc_ObjChild0( Abc_NtkPo(pMiter,0) );
        if ( Abc_AigNodeIsConst(pChild) )
        {
            if ( Abc_ObjIsComplement(pChild) )
                printf( "Unsatisfiable.\n" );
            else
                printf( "Satisfiable. (Constant 1).\n" );
        }
        else
            printf( "Satisfiable.\n" );
    }
    else
    {
        Abc_NtkForEachPo( pMiter, pNode, i )
        {
            pChild = Abc_ObjChild0( Abc_NtkPo(pMiter,i) );
            printf( "Output #%2d : ", i );
            if ( Abc_AigNodeIsConst(pChild) )
            {
                if ( Abc_ObjIsComplement(pChild) )
                    printf( "Unsatisfiable.\n" );
                else
                    printf( "Satisfiable. (Constant 1).\n" );
            }
            else
                printf( "Satisfiable.\n" );
        }
    }
}

◆ Abc_NtkMiterSat()

ABC_DLL int Abc_NtkMiterSat	(	Abc_Ntk_t *	pNtk,
		ABC_INT64_T	nConfLimit,
		ABC_INT64_T	nInsLimit,
		int	fVerbose,
		ABC_INT64_T *	pNumConfs,
		ABC_INT64_T *	pNumInspects )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Attempts to solve the miter using an internal SAT sat_solver.]

Description [Returns -1 if timed out; 0 if SAT; 1 if UNSAT.]

SideEffects []

SeeAlso []

Definition at line 58 of file abcSat.c.

{
    sat_solver * pSat;
    lbool   status;
    int RetValue = 0;
    abctime clk;
 
    if ( pNumConfs )
        *pNumConfs = 0;
    if ( pNumInspects )
        *pNumInspects = 0;
 
    assert( Abc_NtkLatchNum(pNtk) == 0 );
 
//    if ( Abc_NtkPoNum(pNtk) > 1 )
//        fprintf( stdout, "Warning: The miter has %d outputs. SAT will try to prove all of them.\n", Abc_NtkPoNum(pNtk) );
 
    // load clauses into the sat_solver
    clk = Abc_Clock();
    pSat = (sat_solver *)Abc_NtkMiterSatCreate( pNtk, 0 );
    if ( pSat == NULL )
        return 1;
//printf( "%d \n", pSat->clauses.size );
//sat_solver_delete( pSat );
//return 1;
 
//    printf( "Created SAT problem with %d variable and %d clauses. ", sat_solver_nvars(pSat), sat_solver_nclauses(pSat) );
//    ABC_PRT( "Time", Abc_Clock() - clk );
 
    // simplify the problem
    clk = Abc_Clock();
    status = sat_solver_simplify(pSat);
//    printf( "Simplified the problem to %d variables and %d clauses. ", sat_solver_nvars(pSat), sat_solver_nclauses(pSat) );
//    ABC_PRT( "Time", Abc_Clock() - clk );
    if ( status == 0 )
    {
        sat_solver_delete( pSat );
//        printf( "The problem is UNSATISFIABLE after simplification.\n" );
        return 1;
    }
 
    // solve the miter
    clk = Abc_Clock();
    if ( fVerbose )
        pSat->verbosity = 1;
    status = sat_solver_solve( pSat, NULL, NULL, (ABC_INT64_T)nConfLimit, (ABC_INT64_T)nInsLimit, (ABC_INT64_T)0, (ABC_INT64_T)0 );
    if ( status == l_Undef )
    {
//        printf( "The problem timed out.\n" );
        RetValue = -1;
    }
    else if ( status == l_True )
    {
//        printf( "The problem is SATISFIABLE.\n" );
        RetValue = 0;
    }
    else if ( status == l_False )
    {
//        printf( "The problem is UNSATISFIABLE.\n" );
        RetValue = 1;
    }
    else
        assert( 0 );
//    ABC_PRT( "SAT sat_solver time", Abc_Clock() - clk );
//    printf( "The number of conflicts = %d.\n", (int)pSat->sat_solver_stats.conflicts );
 
    // if the problem is SAT, get the counterexample
    if ( status == l_True )
    {
//        Vec_Int_t * vCiIds = Abc_NtkGetCiIds( pNtk );
        Vec_Int_t * vCiIds = Abc_NtkGetCiSatVarNums( pNtk );
        pNtk->pModel = Sat_SolverGetModel( pSat, vCiIds->pArray, vCiIds->nSize );
        Vec_IntFree( vCiIds );
    }
    // free the sat_solver
    if ( fVerbose )
        Sat_SolverPrintStats( stdout, pSat );
 
    if ( pNumConfs )
        *pNumConfs = (int)pSat->stats.conflicts;
    if ( pNumInspects )
        *pNumInspects = (int)pSat->stats.inspects;
 
sat_solver_store_write( pSat, "trace.cnf" );
sat_solver_store_free( pSat );
 
    sat_solver_delete( pSat );
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkMiterSatCreate()

ABC_DLL void * Abc_NtkMiterSatCreate	(	Abc_Ntk_t *	pNtk,
		int	fAllPrimes )

extern

Function*************************************************************

Synopsis [Sets up the SAT sat_solver.]

Description []

SideEffects []

SeeAlso []

Definition at line 664 of file abcSat.c.

{
    sat_solver * pSat;
    Abc_Obj_t * pNode;
    int RetValue, i; //, clk = Abc_Clock();
 
    assert( Abc_NtkIsStrash(pNtk) || Abc_NtkIsBddLogic(pNtk) );
    if ( Abc_NtkIsBddLogic(pNtk) )
        return Abc_NtkMiterSatCreateLogic(pNtk, fAllPrimes);
 
    nMuxes = 0;
    pSat = sat_solver_new();
//sat_solver_store_alloc( pSat );
    RetValue = Abc_NtkMiterSatCreateInt( pSat, pNtk );
sat_solver_store_mark_roots( pSat );
 
    Abc_NtkForEachObj( pNtk, pNode, i )
        pNode->fMarkA = 0;
//    ASat_SolverWriteDimacs( pSat, "temp_sat.cnf", NULL, NULL, 1 );
    if ( RetValue == 0 )
    {
        sat_solver_delete(pSat);
        return NULL;
    }
//    printf( "Ands = %6d.  Muxes = %6d (%5.2f %%).  ", Abc_NtkNodeNum(pNtk), nMuxes, 300.0*nMuxes/Abc_NtkNodeNum(pNtk) );
//    ABC_PRT( "Creating sat_solver", Abc_Clock() - clk );
    return pSat;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkNodeSupport()

ABC_DLL Vec_Ptr_t * Abc_NtkNodeSupport	(	Abc_Ntk_t *	pNtk,
		Abc_Obj_t **	ppNodes,
		int	nNodes )

extern

Function*************************************************************

Synopsis [Returns the set of CI nodes in the support of the given nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 890 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    int i;
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    // go through the PO nodes and call for each of them
    for ( i = 0; i < nNodes; i++ )
        if ( Abc_ObjIsCo(ppNodes[i]) && Abc_ObjFaninNum(Abc_ObjFanin0(ppNodes[i])) != 0 )
            Abc_NtkNodeSupport_rec( Abc_ObjFanin0(ppNodes[i]), vNodes );
        else if ( !Abc_ObjIsCo(ppNodes[i]) && Abc_ObjFaninNum(ppNodes[i]) != 0 )
            Abc_NtkNodeSupport_rec( ppNodes[i], vNodes );
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkNodeSupportInt()

ABC_DLL Vec_Int_t * Abc_NtkNodeSupportInt	(	Abc_Ntk_t *	pNtk,
		int	iCo )

extern

Definition at line 940 of file abcDfs.c.

{
    Vec_Int_t * vNodes;
    Abc_Obj_t * pObj; 
    int i;
    if ( iCo < 0 || iCo >= Abc_NtkCoNum(pNtk) )
        return NULL;
    // save node indices in the CI nodes
    Abc_NtkForEachCi( pNtk, pObj, i )
        pObj->iTemp = i;
    // collect the indexes of CI nodes in the TFI of the CO node
    Abc_NtkIncrementTravId( pNtk );
    pObj = Abc_NtkCo( pNtk, iCo );
    vNodes = Vec_IntAlloc( 100 );
    Abc_NtkNodeSupportInt_rec( Abc_ObjFanin0(pObj), vNodes );
    Vec_IntSort( vNodes, 0 );
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkOrderCisCos()

ABC_DLL void Abc_NtkOrderCisCos ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Order CI/COs.]

Description []

SideEffects []

SeeAlso []

Definition at line 76 of file abcUtil.c.

{
    Abc_Obj_t * pObj, * pTerm;
    int i, k;
    Vec_PtrClear( pNtk->vCis );
    Vec_PtrClear( pNtk->vCos );
    Abc_NtkForEachPi( pNtk, pObj, i )
        Vec_PtrPush( pNtk->vCis, pObj );
    Abc_NtkForEachPo( pNtk, pObj, i )
        Vec_PtrPush( pNtk->vCos, pObj );
    Abc_NtkForEachBox( pNtk, pObj, i )
    {
        if ( Abc_ObjIsLatch(pObj) )
            continue;
        Abc_ObjForEachFanin( pObj, pTerm, k )
            Vec_PtrPush( pNtk->vCos, pTerm );
        Abc_ObjForEachFanout( pObj, pTerm, k )
            Vec_PtrPush( pNtk->vCis, pTerm );
    }
    Abc_NtkForEachBox( pNtk, pObj, i )
    {
        if ( !Abc_ObjIsLatch(pObj) )
            continue;
        Abc_ObjForEachFanin( pObj, pTerm, k )
            Vec_PtrPush( pNtk->vCos, pTerm );
        Abc_ObjForEachFanout( pObj, pTerm, k )
            Vec_PtrPush( pNtk->vCis, pTerm );
    }
}

Here is the caller graph for this function:

◆ Abc_NtkOrderObjsByName()

ABC_DLL void Abc_NtkOrderObjsByName	(	Abc_Ntk_t *	pNtk,
		int	fComb )

extern

Definition at line 330 of file abcNames.c.

{
    Abc_Obj_t * pObj;
    int i;
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
    // temporarily store the names in the copy field
    Abc_NtkForEachPi( pNtk, pObj, i )
        pObj->pCopy = (Abc_Obj_t *)Abc_ObjName(pObj);
    Abc_NtkForEachPo( pNtk, pObj, i )
        pObj->pCopy = (Abc_Obj_t *)Abc_ObjName(pObj);
    Abc_NtkForEachBox( pNtk, pObj, i )
        pObj->pCopy = (Abc_Obj_t *)Abc_ObjName(Abc_ObjFanout0(pObj));
    // order objects alphabetically
    qsort( (void *)Vec_PtrArray(pNtk->vPis), (size_t)Vec_PtrSize(pNtk->vPis), sizeof(Abc_Obj_t *), 
        (int (*)(const void *, const void *)) Abc_NodeCompareNames );
    qsort( (void *)Vec_PtrArray(pNtk->vPos), (size_t)Vec_PtrSize(pNtk->vPos), sizeof(Abc_Obj_t *), 
        (int (*)(const void *, const void *)) Abc_NodeCompareNames );
    // if the comparison if combinational (latches as PIs/POs), order them too
    if ( fComb )
        qsort( (void *)Vec_PtrArray(pNtk->vBoxes), (size_t)Vec_PtrSize(pNtk->vBoxes), sizeof(Abc_Obj_t *), 
            (int (*)(const void *, const void *)) Abc_NodeCompareNames );
    // order CIs/COs first PIs/POs(Asserts) then latches
    Abc_NtkOrderCisCos( pNtk );
    // clean the copy fields
    Abc_NtkForEachPi( pNtk, pObj, i )
        pObj->pCopy = NULL;
    Abc_NtkForEachPo( pNtk, pObj, i )
        pObj->pCopy = NULL;
    Abc_NtkForEachBox( pNtk, pObj, i )
        pObj->pCopy = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkPermute()

ABC_DLL void Abc_NtkPermute	(	Abc_Ntk_t *	pNtk,
		int	fInputs,
		int	fOutputs,
		int	fFlops,
		char *	pInPermFile,
		char *	pOutPermFile,
		char *	pFlopPermFile )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2206 of file abcNtk.c.

{
    Abc_Obj_t * pTemp;
    Vec_Int_t * vInputs, * vOutputs, * vFlops, * vTemp;
    int i, k, Entry;
    // start permutation arrays
    if ( pInPermFile )
    {
        vInputs = Abc_NtkReadSignalPerm( pInPermFile, Abc_NtkPiNum(pNtk) );
        if ( vInputs == NULL )
            return;
        fInputs = 1;
    }
    else
        vInputs  = Vec_IntStartNatural( Abc_NtkPiNum(pNtk) );
    if ( pOutPermFile )
    {
        vOutputs = Abc_NtkReadSignalPerm( pOutPermFile, Abc_NtkPoNum(pNtk) );
        if ( vOutputs == NULL )
            return;
        fOutputs = 1;
    }
    else
        vOutputs = Vec_IntStartNatural( Abc_NtkPoNum(pNtk) );
    if ( pFlopPermFile )
    {
        vFlops = Abc_NtkReadSignalPerm( pFlopPermFile, Abc_NtkLatchNum(pNtk) );
        if ( vFlops == NULL )
            return;
        fFlops   = 1;
    }
    else
        vFlops   = Vec_IntStartNatural( Abc_NtkLatchNum(pNtk) );
    // permute inputs
    Vec_Ptr_t * vCis = Vec_PtrDup(pNtk->vCis);
    Vec_Ptr_t * vCos = Vec_PtrDup(pNtk->vCos);
    Vec_Ptr_t * vFfs = Vec_PtrDup(pNtk->vBoxes);
    if ( fInputs )
    for ( i = 0; i < Abc_NtkPiNum(pNtk); i++ )
    {
        if ( pInPermFile ) 
        {
            k = Vec_IntEntry( vInputs, i );
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( vCis, k );
            Vec_PtrWriteEntry( pNtk->vPis, i, pTemp );
            Vec_PtrWriteEntry( pNtk->vCis, i, pTemp );   
        }
        else 
        {
            k = rand() % Abc_NtkPiNum(pNtk);
            // swap indexes
            Entry = Vec_IntEntry( vInputs, i );
            Vec_IntWriteEntry( vInputs, i, Vec_IntEntry(vInputs, k) );
            Vec_IntWriteEntry( vInputs, k, Entry );
            // swap PIs
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( pNtk->vPis, i );
            Vec_PtrWriteEntry( pNtk->vPis, i, Vec_PtrEntry(pNtk->vPis, k) );
            Vec_PtrWriteEntry( pNtk->vPis, k, pTemp );
            // swap CIs
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( pNtk->vCis, i );
            Vec_PtrWriteEntry( pNtk->vCis, i, Vec_PtrEntry(pNtk->vCis, k) );
            Vec_PtrWriteEntry( pNtk->vCis, k, pTemp );
        }
//printf( "Swapping PIs %d and %d.\n", i, k );
    }
    // permute outputs
    if ( fOutputs )
    for ( i = 0; i < Abc_NtkPoNum(pNtk); i++ )
    {
        if ( pOutPermFile ) 
        {
            k = Vec_IntEntry( vOutputs, i );
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( vCos, k );
            Vec_PtrWriteEntry( pNtk->vPos, i, pTemp );
            Vec_PtrWriteEntry( pNtk->vCos, i, pTemp );       
        }
        else 
        {
            k = rand() % Abc_NtkPoNum(pNtk);
            // swap indexes
            Entry = Vec_IntEntry( vOutputs, i );
            Vec_IntWriteEntry( vOutputs, i, Vec_IntEntry(vOutputs, k) );
            Vec_IntWriteEntry( vOutputs, k, Entry );
            // swap POs
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( pNtk->vPos, i );
            Vec_PtrWriteEntry( pNtk->vPos, i, Vec_PtrEntry(pNtk->vPos, k) );
            Vec_PtrWriteEntry( pNtk->vPos, k, pTemp );
            // swap COs
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( pNtk->vCos, i );
            Vec_PtrWriteEntry( pNtk->vCos, i, Vec_PtrEntry(pNtk->vCos, k) );
            Vec_PtrWriteEntry( pNtk->vCos, k, pTemp );
        }
//printf( "Swapping POs %d and %d.\n", i, k );
    }
    // permute flops
    assert( Abc_NtkBoxNum(pNtk) == Abc_NtkLatchNum(pNtk) );
    if ( fFlops )
    for ( i = 0; i < Abc_NtkLatchNum(pNtk); i++ )
    {
        if ( pFlopPermFile ) 
        {
            k = Vec_IntEntry( vFlops, i );
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( vFfs, k );
            Vec_PtrWriteEntry( pNtk->vBoxes, i, pTemp );  
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( vCis, Abc_NtkPiNum(pNtk)+k );
            Vec_PtrWriteEntry( pNtk->vCis, Abc_NtkPiNum(pNtk)+i, pTemp );
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( vCos, Abc_NtkPoNum(pNtk)+k );
            Vec_PtrWriteEntry( pNtk->vCos, Abc_NtkPoNum(pNtk)+i, pTemp );
        }
        else 
        {
            k = rand() % Abc_NtkLatchNum(pNtk);
            // swap indexes
            Entry = Vec_IntEntry( vFlops, i );
            Vec_IntWriteEntry( vFlops, i, Vec_IntEntry(vFlops, k) );
            Vec_IntWriteEntry( vFlops, k, Entry );
            // swap flops
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( pNtk->vBoxes, i );
            Vec_PtrWriteEntry( pNtk->vBoxes, i, Vec_PtrEntry(pNtk->vBoxes, k) );
            Vec_PtrWriteEntry( pNtk->vBoxes, k, pTemp );
            // swap CIs
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( pNtk->vCis, Abc_NtkPiNum(pNtk)+i );
            Vec_PtrWriteEntry( pNtk->vCis, Abc_NtkPiNum(pNtk)+i, Vec_PtrEntry(pNtk->vCis, Abc_NtkPiNum(pNtk)+k) );
            Vec_PtrWriteEntry( pNtk->vCis, Abc_NtkPiNum(pNtk)+k, pTemp );
            // swap COs
            pTemp = (Abc_Obj_t *)Vec_PtrEntry( pNtk->vCos, Abc_NtkPoNum(pNtk)+i );
            Vec_PtrWriteEntry( pNtk->vCos, Abc_NtkPoNum(pNtk)+i, Vec_PtrEntry(pNtk->vCos, Abc_NtkPoNum(pNtk)+k) );
            Vec_PtrWriteEntry( pNtk->vCos, Abc_NtkPoNum(pNtk)+k, pTemp );
        }
 
//printf( "Swapping flops %d and %d.\n", i, k );
    }
    Vec_PtrFree(vCis);
    Vec_PtrFree(vCos);
    Vec_PtrFree(vFfs);
    // invert arrays
    vInputs = Vec_IntInvert( vTemp = vInputs, -1 );
    Vec_IntFree( vTemp );
    vOutputs = Vec_IntInvert( vTemp = vOutputs, -1 );
    Vec_IntFree( vTemp );
    vFlops = Vec_IntInvert( vTemp = vFlops, -1 );
    Vec_IntFree( vTemp );
    // pack the results into the output array
    Vec_IntFreeP( &pNtk->vObjPerm );
    pNtk->vObjPerm = Vec_IntAlloc( Abc_NtkPiNum(pNtk) + Abc_NtkPoNum(pNtk) + Abc_NtkLatchNum(pNtk) );
    Vec_IntForEachEntry( vInputs, Entry, i )
        Vec_IntPush( pNtk->vObjPerm, Entry );
    Vec_IntForEachEntry( vOutputs, Entry, i )
        Vec_IntPush( pNtk->vObjPerm, Entry );
    Vec_IntForEachEntry( vFlops, Entry, i )
        Vec_IntPush( pNtk->vObjPerm, Entry );
    // cleanup
    Vec_IntFree( vInputs );
    Vec_IntFree( vOutputs );
    Vec_IntFree( vFlops );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkPhaseFrameNum()

ABC_DLL int Abc_NtkPhaseFrameNum ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Performs phase abstraction.]

Description []

SideEffects []

SeeAlso []

Definition at line 4145 of file abcDar.c.

{
    extern int Saig_ManPhaseFrameNum( Aig_Man_t * p, Vec_Int_t * vInits );
    Vec_Int_t * vInits;
    Aig_Man_t * pMan;
    int nFrames;
    pMan = Abc_NtkToDar( pNtk, 0, 1 );
    if ( pMan == NULL )
        return 1;
    vInits = Abc_NtkGetLatchValues(pNtk);
    nFrames = Saig_ManPhaseFrameNum( pMan, vInits );
    Vec_IntFree( vInits );
    Aig_ManStop( pMan );
    return nFrames;
}

Here is the call graph for this function:

◆ Abc_NtkPrepareTwoNtks()

ABC_DLL int Abc_NtkPrepareTwoNtks	(	FILE *	pErr,
		Abc_Ntk_t *	pNtk,
		char **	argv,
		int	argc,
		Abc_Ntk_t **	ppNtk1,
		Abc_Ntk_t **	ppNtk2,
		int *	pfDelete1,
		int *	pfDelete2,
		int	fCheck )

extern

Function*************************************************************

Synopsis [Prepares two network for a two-argument command similar to "verify".]

Description []

SideEffects []

SeeAlso []

Definition at line 1522 of file abcUtil.c.

{
    FILE * pFile;
    Abc_Ntk_t * pNtk1, * pNtk2, * pNtkTemp;
    int util_optind = 0;
 
    *pfDelete1 = 0;
    *pfDelete2 = 0;
    if ( argc == util_optind ) 
    { // use the spec
        if ( pNtk == NULL )
        {
            fprintf( pErr, "Empty current network.\n" );
            return 0;
        }
        if ( pNtk->pSpec == NULL )
        {
            fprintf( pErr, "The external spec is not given.\n" );
            return 0;
        }
        pFile = fopen( pNtk->pSpec, "r" );
        if ( pFile == NULL )
        {
            fprintf( pErr, "Cannot open the external spec file \"%s\".\n", pNtk->pSpec );
            return 0;
        }
        else
            fclose( pFile );
        pNtk1 = Abc_NtkDup(pNtk);
        pNtk2 = Io_Read( pNtk->pSpec, Io_ReadFileType(pNtk->pSpec), fCheck, 0 );
        if ( pNtk2 == NULL )
            return 0;
        *pfDelete1 = 1;
        *pfDelete2 = 1;
    }
    else if ( argc == util_optind + 1 ) 
    {
        if ( pNtk == NULL )
        {
            fprintf( pErr, "Empty current network.\n" );
            return 0;
        }
        pNtk1 = Abc_NtkDup(pNtk);
        pNtk2 = Io_Read( argv[util_optind], Io_ReadFileType(argv[util_optind]), fCheck, 0 );
        if ( pNtk2 == NULL )
            return 0;
        *pfDelete1 = 1;
        *pfDelete2 = 1;
    }
    else if ( argc == util_optind + 2 ) 
    {
        pNtk1 = Io_Read( argv[util_optind], Io_ReadFileType(argv[util_optind]), fCheck, 0 );
        if ( pNtk1 == NULL )
            return 0;
        pNtk2 = Io_Read( argv[util_optind+1], Io_ReadFileType(argv[util_optind+1]), fCheck, 0 );
        if ( pNtk2 == NULL )
        {
            Abc_NtkDelete( pNtk1 );
            return 0;
        }
        *pfDelete1 = 1;
        *pfDelete2 = 1;
    }
    else
    {
        fprintf( pErr, "Wrong number of arguments.\n" );
        return 0;
    }
 
    // make sure the networks are strashed
    if ( !Abc_NtkIsStrash(pNtk1) )
    {
        pNtkTemp = Abc_NtkStrash( pNtk1, 0, 1, 0 );
        if ( *pfDelete1 )
            Abc_NtkDelete( pNtk1 );
        pNtk1 = pNtkTemp;
        *pfDelete1 = 1;
    }
    if ( !Abc_NtkIsStrash(pNtk2) )
    {
        pNtkTemp = Abc_NtkStrash( pNtk2, 0, 1, 0 );
        if ( *pfDelete2 )
            Abc_NtkDelete( pNtk2 );
        pNtk2 = pNtkTemp;
        *pfDelete2 = 1;
    }
 
    *ppNtk1 = pNtk1;
    *ppNtk2 = pNtk2;
    return 1;
}

Here is the call graph for this function:

◆ Abc_NtkPrintBoxInfo()

ABC_DLL void Abc_NtkPrintBoxInfo ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Prints information about boxes.]

Description []

SideEffects []

SeeAlso []

Definition at line 431 of file abcHie.c.

{
    Vec_Ptr_t * vMods;
    Abc_Ntk_t * pModel, * pBoxModel;
    Abc_Obj_t * pObj;
    Vec_Int_t * vCounts;
    int i, k, Num;
    if ( pNtk->pDesign == NULL || pNtk->pDesign->vModules == NULL )
    {
//        printf( "There is no hierarchy information.\n" );
        return;
    }
    // sort models by name
    vMods = pNtk->pDesign->vModules;
    Vec_PtrSort( vMods, (int(*)(const void *, const void *))Abc_NtkCompareNames );
//    Vec_PtrForEachEntry( Abc_Ntk_t *, vMods, pModel, i )
//        printf( "%s\n", Abc_NtkName(pModel) );
 
    // swap the first model
    Num = Vec_PtrFind( vMods, pNtk );
    assert( Num >= 0 && Num < Vec_PtrSize(vMods) );
    pBoxModel = (Abc_Ntk_t *)Vec_PtrEntry(vMods, 0);
    Vec_PtrWriteEntry(vMods, 0, (Abc_Ntk_t *)Vec_PtrEntry(vMods, Num) );
    Vec_PtrWriteEntry(vMods, Num, pBoxModel );
 
    // print models
    vCounts = Vec_IntStart( Vec_PtrSize(vMods) );
    Vec_PtrForEachEntry( Abc_Ntk_t *, vMods, pModel, i )
    {
        if ( Abc_NtkBoxNum(pModel) == 0 )
            continue;
        Vec_IntFill( vCounts, Vec_IntSize(vCounts), 0 );
        Abc_NtkForEachBox( pModel, pObj, k )
        {
            pBoxModel = (Abc_Ntk_t *)pObj->pData;
            if ( pBoxModel == NULL )
                continue;
            Num = Vec_PtrFind( vMods, pBoxModel );
            assert( Num >= 0 && Num < Vec_PtrSize(vMods) );
            Vec_IntAddToEntry( vCounts, Num, 1 );
        }
 
//        Abc_NtkPrintStats( pModel, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
        printf( "MODULE  " );
        printf( "%-30s : ", Abc_NtkName(pModel) );
        printf( "PI=%6d ", Abc_NtkPiNum(pModel) );
        printf( "PO=%6d ", Abc_NtkPoNum(pModel) );
        printf( "BB=%6d ", Abc_NtkBoxNum(pModel) );
        printf( "ND=%6d ", Abc_NtkNodeNum(pModel) ); // sans constants
        printf( "Lev=%5d ", Abc_NtkLevel(pModel) );
        printf( "\n" );
 
        Vec_IntForEachEntry( vCounts, Num, k )
            if ( Num )
                printf( "%15d : %s\n", Num, Abc_NtkName((Abc_Ntk_t *)Vec_PtrEntry(vMods, k)) );
    }
    Vec_IntFree( vCounts );
    Vec_PtrForEachEntry( Abc_Ntk_t *, vMods, pModel, i )
    {
        if ( Abc_NtkBoxNum(pModel) != 0 )
            continue;
        printf( "MODULE   " );
        printf( "%-30s : ", Abc_NtkName(pModel) );
        printf( "PI=%6d ", Abc_NtkPiNum(pModel) );
        printf( "PO=%6d ", Abc_NtkPoNum(pModel) );
        printf( "BB=%6d ", Abc_NtkBoxNum(pModel) );
        printf( "ND=%6d ", Abc_NtkNodeNum(pModel) );
        printf( "Lev=%5d ", Abc_NtkLevel(pModel) );
        printf( "\n" );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkPrintCiLevels()

ABC_DLL void Abc_NtkPrintCiLevels ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2268 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachCi( pNtk, pObj, i )
        printf( "%c=%d ", 'a'+i, pObj->Level );
    printf( "\n" );
}

◆ Abc_NtkPrintFactor()

ABC_DLL void Abc_NtkPrintFactor	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fUseRealNames )

extern

Definition at line 1129 of file abcPrint.c.

{
    Abc_Obj_t * pNode;
    int i;
    assert( Abc_NtkIsSopLogic(pNtk) );
    Abc_NtkForEachNode( pNtk, pNode, i )
        Abc_NodePrintFactor( pFile, pNode, fUseRealNames );
}

Here is the call graph for this function:

◆ Abc_NtkPrintFanio()

ABC_DLL void Abc_NtkPrintFanio	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fUseFanio,
		int	fUsePio,
		int	fUseSupp,
		int	fUseCone )

extern

Definition at line 876 of file abcPrint.c.

{
    Vec_Int_t * vFan = Vec_IntAlloc( 0 );
    Vec_Int_t * vFon = Vec_IntAlloc( 0 );
    Vec_Int_t * vFanR = Vec_IntAlloc( 0 );
    Vec_Int_t * vFonR = Vec_IntAlloc( 0 );
    assert( fUseFanio + fUsePio + fUseSupp + fUseCone == 1 );
    if ( fUseFanio )
    {
        Abc_NtkFaninFanoutCounters( pNtk, vFan, vFon, vFanR, vFonR );
        Abc_NtkPrintDistribInternal( pFile, pNtk, "fanins", "fanouts", "Nodes", "fanin", "fanout", vFan, vFon, vFanR, vFonR ); 
    }
    else if ( fUsePio )
    {
        Abc_NtkInputOutputCounters( pNtk, vFan, vFon, vFanR, vFonR );
        Abc_NtkPrintDistribInternal( pFile, pNtk, "fanins", "fanouts", "I/O", "fanin", "fanout", vFan, vFon, vFanR, vFonR ); 
    }
    else if ( fUseSupp )
    {
        Abc_NtkInOutSupportCounters( pNtk, vFan, vFon, vFanR, vFonR );
        Abc_NtkPrintDistribInternal( pFile, pNtk, "input supports", "output supports", "I/O", "in-supp", "out-supp", vFan, vFon, vFanR, vFonR ); 
    }
    else if ( fUseCone )
    {
        Abc_NtkInOutConeCounters( pNtk, vFan, vFon, vFanR, vFonR );
        Abc_NtkPrintDistribInternal( pFile, pNtk, "input cones", "output cones", "I/O", "in-cone", "out-cone", vFan, vFon, vFanR, vFonR ); 
    }
    Vec_IntFree( vFan );
    Vec_IntFree( vFon );
    Vec_IntFree( vFanR );
    Vec_IntFree( vFonR );
}

Here is the call graph for this function:

◆ Abc_NtkPrintFanioNew()

ABC_DLL void Abc_NtkPrintFanioNew	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fMffc )

extern

Function*************************************************************

Synopsis [Prints the distribution of fanins/fanouts in the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 921 of file abcPrint.c.

{
    char Buffer[100];
    Abc_Obj_t * pNode;
    Vec_Int_t * vFanins, * vFanouts;
    int nFanins, nFanouts, nFaninsMax, nFanoutsMax, nFaninsAll, nFanoutsAll;
    int i, k, nSizeMax;
 
    // determine the largest fanin and fanout
    nFaninsMax = nFanoutsMax = 0;
    nFaninsAll = nFanoutsAll = 0;
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( fMffc && Abc_ObjFanoutNum(pNode) == 1 )
            continue;
        nFanins  = Abc_ObjFaninNum(pNode);
        if ( Abc_NtkIsNetlist(pNtk) )
            nFanouts = Abc_ObjFanoutNum( Abc_ObjFanout0(pNode) );
        else if ( fMffc )
            nFanouts = Abc_NodeMffcSize(pNode);
        else
            nFanouts = Abc_ObjFanoutNum(pNode);
        nFaninsAll  += nFanins;
        nFanoutsAll += nFanouts;
        nFaninsMax   = Abc_MaxInt( nFaninsMax, nFanins );
        nFanoutsMax  = Abc_MaxInt( nFanoutsMax, nFanouts );
    }
 
    // allocate storage for fanin/fanout numbers
    nSizeMax = Abc_MaxInt( 10 * (Abc_Base10Log(nFaninsMax) + 1), 10 * (Abc_Base10Log(nFanoutsMax) + 1) );
    vFanins  = Vec_IntStart( nSizeMax );
    vFanouts = Vec_IntStart( nSizeMax );
 
    // count the number of fanins and fanouts
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( fMffc && Abc_ObjFanoutNum(pNode) == 1 )
            continue;
        nFanins  = Abc_ObjFaninNum(pNode);
        if ( Abc_NtkIsNetlist(pNtk) )
            nFanouts = Abc_ObjFanoutNum( Abc_ObjFanout0(pNode) );
        else if ( fMffc )
            nFanouts = Abc_NodeMffcSize(pNode);
        else
            nFanouts = Abc_ObjFanoutNum(pNode);
 
        if ( nFanins < 10 )
            Vec_IntAddToEntry( vFanins, nFanins, 1 );
        else if ( nFanins < 100 )
            Vec_IntAddToEntry( vFanins, 10 + nFanins/10, 1 );
        else if ( nFanins < 1000 )
            Vec_IntAddToEntry( vFanins, 20 + nFanins/100, 1 );
        else if ( nFanins < 10000 )
            Vec_IntAddToEntry( vFanins, 30 + nFanins/1000, 1 );
        else if ( nFanins < 100000 )
            Vec_IntAddToEntry( vFanins, 40 + nFanins/10000, 1 );
        else if ( nFanins < 1000000 )
            Vec_IntAddToEntry( vFanins, 50 + nFanins/100000, 1 );
        else if ( nFanins < 10000000 )
            Vec_IntAddToEntry( vFanins, 60 + nFanins/1000000, 1 );
 
        if ( nFanouts < 10 )
            Vec_IntAddToEntry( vFanouts, nFanouts, 1 );
        else if ( nFanouts < 100 )
            Vec_IntAddToEntry( vFanouts, 10 + nFanouts/10, 1 );
        else if ( nFanouts < 1000 )
            Vec_IntAddToEntry( vFanouts, 20 + nFanouts/100, 1 );
        else if ( nFanouts < 10000 )
            Vec_IntAddToEntry( vFanouts, 30 + nFanouts/1000, 1 );
        else if ( nFanouts < 100000 )
            Vec_IntAddToEntry( vFanouts, 40 + nFanouts/10000, 1 );
        else if ( nFanouts < 1000000 )
            Vec_IntAddToEntry( vFanouts, 50 + nFanouts/100000, 1 );
        else if ( nFanouts < 10000000 )
            Vec_IntAddToEntry( vFanouts, 60 + nFanouts/1000000, 1 );
    }
 
    fprintf( pFile, "The distribution of fanins and fanouts in the network:\n" );
    fprintf( pFile, "         Number   Nodes with fanin  Nodes with fanout\n" );
    for ( k = 0; k < nSizeMax; k++ )
    {
        if ( vFanins->pArray[k] == 0 && vFanouts->pArray[k] == 0 )
            continue;
        if ( k < 10 )
            fprintf( pFile, "%15d : ", k );
        else
        {
            sprintf( Buffer, "%d - %d", (int)pow((double)10, k/10) * (k%10), (int)pow((double)10, k/10) * (k%10+1) - 1 );
            fprintf( pFile, "%15s : ", Buffer );
        }
        if ( vFanins->pArray[k] == 0 )
            fprintf( pFile, "              " );
        else
            fprintf( pFile, "%12d  ", vFanins->pArray[k] );
        fprintf( pFile, "    " );
        if ( vFanouts->pArray[k] == 0 )
            fprintf( pFile, "              " );
        else
            fprintf( pFile, "%12d  ", vFanouts->pArray[k] );
        fprintf( pFile, "\n" );
    }
    Vec_IntFree( vFanins );
    Vec_IntFree( vFanouts );
 
    fprintf( pFile, "Fanins: Max = %d. Ave = %.2f.  Fanouts: Max = %d. Ave =  %.2f.\n",
        nFaninsMax,  1.0*nFaninsAll/Abc_NtkNodeNum(pNtk),
        nFanoutsMax, 1.0*nFanoutsAll/Abc_NtkNodeNum(pNtk)  );
/*
    Abc_NtkForEachCi( pNtk, pNode, i )
    {
        printf( "%d ", Abc_ObjFanoutNum(pNode) );
    }
    printf( "\n" );
*/
}

Here is the call graph for this function:

◆ Abc_NtkPrintIo()

ABC_DLL void Abc_NtkPrintIo	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fPrintFlops )

extern

Function*************************************************************

Synopsis [Prints PIs/POs and LIs/LOs.]

Description []

SideEffects []

SeeAlso []

Definition at line 499 of file abcPrint.c.

{
    Abc_Obj_t * pObj;
    int i;
 
    fprintf( pFile, "Primary inputs (%d): ", Abc_NtkPiNum(pNtk) );
    Abc_NtkForEachPi( pNtk, pObj, i )
        fprintf( pFile, " %d=%s", i, Abc_ObjName(pObj) );
//        fprintf( pFile, " %s(%d)", Abc_ObjName(pObj), Abc_ObjFanoutNum(pObj) );
    fprintf( pFile, "\n" );
 
    fprintf( pFile, "Primary outputs (%d):", Abc_NtkPoNum(pNtk) );
    Abc_NtkForEachPo( pNtk, pObj, i )
        fprintf( pFile, " %d=%s", i, Abc_ObjName(pObj) );
    fprintf( pFile, "\n" );
 
    if ( !fPrintFlops )
        return;
 
    fprintf( pFile, "Latches (%d):  ", Abc_NtkLatchNum(pNtk) );
    Abc_NtkForEachLatch( pNtk, pObj, i )
        fprintf( pFile, " %s(%s=%s)", Abc_ObjName(pObj),
            Abc_ObjName(Abc_ObjFanout0(pObj)), Abc_ObjName(Abc_ObjFanin0(pObj)) );
    fprintf( pFile, "\n" );
}

Here is the call graph for this function:

◆ Abc_NtkPrintLatch()

ABC_DLL void Abc_NtkPrintLatch	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk )

extern

Function*************************************************************

Synopsis [Prints statistics about latches.]

Description []

SideEffects []

SeeAlso []

Definition at line 536 of file abcPrint.c.

{
    Abc_Obj_t * pLatch, * pFanin;
    int i, Counter0, Counter1, Counter2;
    int InitNums[4], Init;
 
    assert( !Abc_NtkIsNetlist(pNtk) );
    if ( Abc_NtkLatchNum(pNtk) == 0 )
    {
        fprintf( pFile, "The network is combinational.\n" );
        return;
    }
 
    for ( i = 0; i < 4; i++ )
        InitNums[i] = 0;
    Counter0 = Counter1 = Counter2 = 0;
    Abc_NtkForEachLatch( pNtk, pLatch, i )
    {
        Init = Abc_LatchInit( pLatch );
        assert( Init < 4 );
        InitNums[Init]++;
 
        pFanin = Abc_ObjFanin0(Abc_ObjFanin0(pLatch));
        if ( Abc_NtkIsLogic(pNtk) )
        {
            if ( !Abc_NodeIsConst(pFanin) )
                continue;
        }
        else if ( Abc_NtkIsStrash(pNtk) )
        {
            if ( !Abc_AigNodeIsConst(pFanin) )
                continue;
        }
        else
            assert( 0 );
 
        // the latch input is a constant node
        Counter0++;
        if ( Abc_LatchIsInitDc(pLatch) )
        {
            Counter1++;
            continue;
        }
        // count the number of cases when the constant is equal to the initial value
        if ( Abc_NtkIsStrash(pNtk) )
        {
            if ( Abc_LatchIsInit1(pLatch) == !Abc_ObjFaninC0(pLatch) )
                Counter2++;
        }
        else
        {
            if ( Abc_LatchIsInit1(pLatch) == Abc_NodeIsConst1(Abc_ObjFanin0(Abc_ObjFanin0(pLatch))) )
                Counter2++;
        }
    }
//    fprintf( pFile, "%-15s:  ", pNtk->pName );
    fprintf( pFile, "Total latches = %5d. Init0 = %d. Init1 = %d. InitDC = %d. Const data = %d.\n",
        Abc_NtkLatchNum(pNtk), InitNums[1], InitNums[2], InitNums[3], Counter0 );
//    fprintf( pFile, "Const fanin = %3d. DC init = %3d. Matching init = %3d. ", Counter0, Counter1, Counter2 );
//    fprintf( pFile, "Self-feed latches = %2d.\n", -1 ); //Abc_NtkCountSelfFeedLatches(pNtk) );
}

Here is the call graph for this function:

◆ Abc_NtkPrintLevel()

ABC_DLL void Abc_NtkPrintLevel	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fProfile,
		int	fListNodes,
		int	fOutputs,
		int	fVerbose )

extern

Definition at line 1231 of file abcPrint.c.

{
    Abc_Obj_t * pNode;
    int i, k, Length;
    if ( fOutputs )
    {
        Abc_NtkLevel(pNtk);
        printf( "Outputs by level: " );
        Abc_NtkForEachCo( pNtk, pNode, k )
            printf( "%d=%d ", k, Abc_ObjFanin0(pNode)->Level );
        printf( "\n" );
        return;        
    }
    if ( fListNodes )
    {
        int nLevels;
        nLevels = Abc_NtkLevel(pNtk);
        printf( "Nodes by level:\n" );
        for ( i = 0; i <= nLevels; i++ )
        {
            printf( "%2d : ", i );
            Abc_NtkForEachNode( pNtk, pNode, k )
                if ( (int)pNode->Level == i )
                    printf( " %s", Abc_NodeGetPrintName(pNode) );
            printf( "\n" );
        }
        return;
    }
 
    // print the delay profile
    if ( fProfile && Abc_NtkHasMapping(pNtk) )
    {
        int nIntervals = 12;
        float DelayMax, DelayCur, DelayDelta;
        int * pLevelCounts;
        int DelayInt, nOutsSum, nOutsTotal;
 
        // get the max delay and delta
        DelayMax   = Abc_NtkDelayTrace( pNtk, NULL, NULL, 0 );
        DelayDelta = DelayMax/nIntervals;
        // collect outputs by delay
        pLevelCounts = ABC_ALLOC( int, nIntervals );
        memset( pLevelCounts, 0, sizeof(int) * nIntervals );
        Abc_NtkForEachCo( pNtk, pNode, i )
        {
            if ( Abc_ObjIsNode(Abc_ObjFanin0(pNode)) && Abc_ObjFaninNum(Abc_ObjFanin0(pNode)) == 0 )
                DelayInt = 0;
            else
            {
                DelayCur  = Abc_NodeReadArrivalWorst( Abc_ObjFanin0(pNode) );
                DelayInt  = (int)(DelayCur / DelayDelta);
                if ( DelayInt >= nIntervals )
                    DelayInt = nIntervals - 1;
            }
            pLevelCounts[DelayInt]++;
        }
 
        nOutsSum   = 0;
        nOutsTotal = Abc_NtkCoNum(pNtk);
        for ( i = 0; i < nIntervals; i++ )
        {
            nOutsSum += pLevelCounts[i];
            printf( "[%8.2f - %8.2f] :   COs = %4d.   %5.1f %%\n",
                DelayDelta * i, DelayDelta * (i+1), pLevelCounts[i], 100.0 * nOutsSum/nOutsTotal );
        }
        ABC_FREE( pLevelCounts );
        return;
    }
    else if ( fProfile )
    {
        int LevelMax, * pLevelCounts;
        int nOutsSum, nOutsTotal;
 
        if ( !Abc_NtkIsStrash(pNtk) )
            Abc_NtkLevel(pNtk);
 
        LevelMax = 0;
        Abc_NtkForEachCo( pNtk, pNode, i )
            if ( LevelMax < (int)Abc_ObjFanin0(pNode)->Level )
                LevelMax = Abc_ObjFanin0(pNode)->Level;
        pLevelCounts = ABC_ALLOC( int, LevelMax + 1 );
        memset( pLevelCounts, 0, sizeof(int) * (LevelMax + 1) );
        Abc_NtkForEachCo( pNtk, pNode, i )
            pLevelCounts[Abc_ObjFanin0(pNode)->Level]++;
 
        nOutsSum   = 0;
        nOutsTotal = Abc_NtkCoNum(pNtk);
        for ( i = 0; i <= LevelMax; i++ )
            if ( pLevelCounts[i] )
            {
                nOutsSum += pLevelCounts[i];
                printf( "Level = %4d.  COs = %4d.   %5.1f %%\n", i, pLevelCounts[i], 100.0 * nOutsSum/nOutsTotal );
            }
        ABC_FREE( pLevelCounts );
        return;
    }
    assert( Abc_NtkIsStrash(pNtk) );
 
    if ( fVerbose )
    {
        // find the longest name
        Length = 0;
        Abc_NtkForEachCo( pNtk, pNode, i )
            if ( Length < (int)strlen(Abc_ObjName(pNode)) )
                Length = strlen(Abc_ObjName(pNode));
        if ( Length < 5 )
            Length = 5;
        // print stats for each output
        Abc_NtkForEachCo( pNtk, pNode, i )
        {
            fprintf( pFile, "CO %4d :  %*s    ", i, Length, Abc_ObjName(pNode) );
            Abc_NodePrintLevel( pFile, pNode );
    }
    }
}

Here is the call graph for this function:

◆ Abc_NtkPrintSkews()

ABC_DLL void Abc_NtkPrintSkews	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk,
		int	fPrintAll )

extern

◆ Abc_NtkPrintStats()

ABC_DLL void Abc_NtkPrintStats	(	Abc_Ntk_t *	pNtk,
		int	fFactored,
		int	fSaveBest,
		int	fDumpResult,
		int	fUseLutLib,
		int	fPrintMuxes,
		int	fPower,
		int	fGlitch,
		int	fSkipBuf,
		int	fSkipSmall,
		int	fPrintMem )

extern

Function*************************************************************

Synopsis [Print the vital stats of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 269 of file abcPrint.c.

{
    int nSingles = fSkipBuf ? Abc_NtkGetBufNum(pNtk) : 0;
    if ( fPrintMuxes && Abc_NtkIsStrash(pNtk) )
    {
        extern int Abc_NtkCountMuxes( Abc_Ntk_t * pNtk );
        int nXors = Abc_NtkGetExorNum(pNtk);
        int nMuxs = Abc_NtkCountMuxes(pNtk) - nXors;
        int nAnds = Abc_NtkNodeNum(pNtk) - (nMuxs + nXors) * 3 - nSingles;
        Abc_Print( 1, "XMA stats:  " );
        Abc_Print( 1,"Xor =%7d (%6.2f %%)  ", nXors, 300.0 * nXors / Abc_NtkNodeNum(pNtk) );
        Abc_Print( 1,"Mux =%7d (%6.2f %%)  ", nMuxs, 300.0 * nMuxs / Abc_NtkNodeNum(pNtk) );
        Abc_Print( 1,"And =%7d (%6.2f %%)  ",   nAnds, 100.0 * nAnds / Abc_NtkNodeNum(pNtk) );
        Abc_Print( 1,"Total =%7d",   nAnds + nXors + nMuxs );
        Abc_Print( 1,"\n" );
        return;
    }
    if ( fSaveBest )
        Abc_NtkCompareAndSaveBest( pNtk );
/*
    if ( fDumpResult )
    {
        char Buffer[1000] = {0};
        const char * pNameGen = pNtk->pSpec? Extra_FileNameGeneric( pNtk->pSpec ) : "nameless_";
        sprintf( Buffer, "%s_dump.blif", pNameGen );
        Io_Write( pNtk, Buffer, IO_FILE_BLIF );
        if ( pNtk->pSpec ) ABC_FREE( pNameGen );
    }
*/
 
//    if ( Abc_NtkIsStrash(pNtk) )
//        Abc_AigCountNext( pNtk->pManFunc );
 
#ifdef WIN32
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 15 ); // bright
    Abc_Print( 1,"%-30s:", pNtk->pName );
    SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), 7 );  // normal
#else
    Abc_Print( 1,"%s%-30s:%s", "\033[1;37m", pNtk->pName, "\033[0m" );  // bright
#endif
    Abc_Print( 1," i/o =%5d/%5d", Abc_NtkPiNum(pNtk), Abc_NtkPoNum(pNtk) );
    if ( Abc_NtkConstrNum(pNtk) )
        Abc_Print( 1,"(c=%d)", Abc_NtkConstrNum(pNtk) );
    Abc_Print( 1,"  lat =%5d", Abc_NtkLatchNum(pNtk) );
    if ( pNtk->nBarBufs )
        Abc_Print( 1,"(b=%d)", pNtk->nBarBufs );
    if ( Abc_NtkIsNetlist(pNtk) )
    {
        Abc_Print( 1,"  net =%5d", Abc_NtkNetNum(pNtk) );
        Abc_Print( 1,"  nd =%5d",  fSkipSmall ? Abc_NtkGetLargeNodeNum(pNtk) : Abc_NtkNodeNum(pNtk) - nSingles );
        Abc_Print( 1,"  wbox =%3d", Abc_NtkWhiteboxNum(pNtk) );
        Abc_Print( 1,"  bbox =%3d", Abc_NtkBlackboxNum(pNtk) );
    }
    else if ( Abc_NtkIsStrash(pNtk) )
    {
        Abc_Print( 1,"  and =%7d", Abc_NtkNodeNum(pNtk) );
        if ( Abc_NtkGetChoiceNum(pNtk) )
            Abc_Print( 1," (choice = %d)", Abc_NtkGetChoiceNum(pNtk) );
    }
    else
    {
        Abc_Print( 1,"  nd =%6d", fSkipSmall ? Abc_NtkGetLargeNodeNum(pNtk) : Abc_NtkNodeNum(pNtk) - nSingles );
        Abc_Print( 1,"  edge =%7d", Abc_NtkGetTotalFanins(pNtk) - nSingles );
    }
 
    if ( Abc_NtkIsStrash(pNtk) || Abc_NtkIsNetlist(pNtk) )
    {
    }
    else if ( Abc_NtkHasSop(pNtk) )
    {
 
        Abc_Print( 1,"  cube =%6d",  Abc_NtkGetCubeNum(pNtk) - nSingles );
        if ( fFactored )
            Abc_Print( 1,"  lit(sop) =%6d",  Abc_NtkGetLitNum(pNtk) - nSingles );
        if ( fFactored )
            Abc_Print( 1,"  lit(fac) =%6d",  Abc_NtkGetLitFactNum(pNtk) - nSingles );
    }
    else if ( Abc_NtkHasAig(pNtk) )
        Abc_Print( 1,"  aig  =%6d",  Abc_NtkGetAigNodeNum(pNtk) - nSingles );
    else if ( Abc_NtkHasBdd(pNtk) )
        Abc_Print( 1,"  bdd  =%6d",  Abc_NtkGetBddNodeNum(pNtk) - nSingles );
    else if ( Abc_NtkHasMapping(pNtk) )
    {
        int fHasTimeMan = (int)(pNtk->pManTime != NULL);
        assert( pNtk->pManFunc == Abc_FrameReadLibGen() );
        Abc_Print( 1,"  area =%5.2f", Abc_NtkGetMappedArea(pNtk) );
        Abc_Print( 1,"  delay =%5.2f", Abc_NtkDelayTrace(pNtk, NULL, NULL, 0) );
        if ( !fHasTimeMan && pNtk->pManTime )
        {
            Abc_ManTimeStop( pNtk->pManTime );
            pNtk->pManTime = NULL;
        }
    }
    else if ( !Abc_NtkHasBlackbox(pNtk) )
    {
        assert( 0 );
    }
 
    if ( Abc_NtkIsStrash(pNtk) )
    {
        extern int Abc_NtkGetMultiRefNum( Abc_Ntk_t * pNtk );
        Abc_Print( 1,"  lev =%3d", Abc_AigLevel(pNtk) );
//        Abc_Print( 1,"  ff = %5d", Abc_NtkNodeNum(pNtk) + 2 * (Abc_NtkCoNum(pNtk)+Abc_NtkGetMultiRefNum(pNtk)) );
//        Abc_Print( 1,"  var = %5d", Abc_NtkCiNum(pNtk) + Abc_NtkCoNum(pNtk)+Abc_NtkGetMultiRefNum(pNtk) );
    }
    else
        Abc_Print( 1,"  lev = %d", Abc_NtkLevel(pNtk) );
    if ( pNtk->nBarBufs2 )
        Abc_Print( 1,"  buf = %d", pNtk->nBarBufs2 );
    if ( fUseLutLib && Abc_FrameReadLibLut() )
        Abc_Print( 1,"  delay =%5.2f", Abc_NtkDelayTraceLut(pNtk, 1) );
    if ( fUseLutLib && Abc_FrameReadLibLut() )
        Abc_Print( 1,"  area =%5.2f", Abc_NtkGetArea(pNtk) );
    if ( fPower )
        Abc_Print( 1,"  power =%7.2f", Abc_NtkMfsTotalSwitching(pNtk) );
    if ( fGlitch )
    {
        if ( Abc_NtkIsLogic(pNtk) && Abc_NtkGetFaninMax(pNtk) <= 6 )
            Abc_Print( 1,"  glitch =%7.2f %%", Abc_NtkMfsTotalGlitching(pNtk, 4000, 8, 0) );
        else
            printf( "\nCurrently computes glitching only for K-LUT networks with K <= 6." );
    }
    if ( fPrintMem )
        Abc_Print( 1,"  mem =%5.2f MB", Abc_NtkMemory(pNtk)/(1<<20) );
    Abc_Print( 1,"\n" );
/*
    // print the statistic into a file
    if ( fDumpResult )
    {
        FILE * pTable = fopen( "abcstats.txt", "a+" );
        fprintf( pTable, "%s ",  pNtk->pName );
        fprintf( pTable, "%d ", Abc_NtkPiNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkPoNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkNodeNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkGetTotalFanins(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkLevel(pNtk) );
        fprintf( pTable, "\n" );
        fclose( pTable );
    }
*/
 
/*
    {
        FILE * pTable;
        pTable = fopen( "ibm/seq_stats.txt", "a+" );
//        fprintf( pTable, "%s ",  pNtk->pName );
//        fprintf( pTable, "%d ", Abc_NtkPiNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkPoNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkNodeNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkLatchNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkLevel(pNtk) );
        fprintf( pTable, "\n" );
        fclose( pTable );
    }
*/
 
/*
    // print the statistic into a file
    {
        FILE * pTable;
        pTable = fopen( "x/stats_new.txt", "a+" );
        fprintf( pTable, "%s ",  pNtk->pName );
//        fprintf( pTable, "%d ", Abc_NtkPiNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkPoNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkLevel(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkNodeNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkGetTotalFanins(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkLatchNum(pNtk) );
//        fprintf( pTable, "%.2f ", (float)(s_MappingMem)/(float)(1<<20) );
        fprintf( pTable, "%.2f", (float)(s_MappingTime)/(float)(CLOCKS_PER_SEC) );
//        fprintf( pTable, "%.2f", (float)(s_ResynTime)/(float)(CLOCKS_PER_SEC) );
        fprintf( pTable, "\n" );
        fclose( pTable );
 
        s_ResynTime = 0;
    }
*/
 
/*
    // print the statistic into a file
    {
        static int Counter = 0;
        extern int timeRetime;
        FILE * pTable;
        Counter++;
        pTable = fopen( "d/stats.txt", "a+" );
        fprintf( pTable, "%s ", pNtk->pName );
//        fprintf( pTable, "%d ", Abc_NtkPiNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkPoNum(pNtk) );
//        fprintf( pTable, "%d ", Abc_NtkLatchNum(pNtk) );
        fprintf( pTable, "%d ", Abc_NtkNodeNum(pNtk) );
        fprintf( pTable, "%.2f ", (float)(timeRetime)/(float)(CLOCKS_PER_SEC) );
        fprintf( pTable, "\n" );
        fclose( pTable );
    }
 
 
    s_TotalNodes += Abc_NtkNodeNum(pNtk);
    printf( "Total nodes = %6d   %6.2f MB   Changes = %6d.\n", 
        s_TotalNodes, s_TotalNodes * 20.0 / (1<<20), s_TotalChanges );
*/
 
//    if ( Abc_NtkHasSop(pNtk) )
//        printf( "The total number of cube pairs = %d.\n", Abc_NtkGetCubePairNum(pNtk) );
 
    if ( 0 )
    {
        FILE * pTable = fopen( "stats.txt", "a+" );
        if ( Abc_NtkIsStrash(pNtk) )
        fprintf( pTable, "%s ", pNtk->pName );
        fprintf( pTable, "%d ", Abc_NtkNodeNum(pNtk) );
        fclose( pTable );
    }
 
    fflush( stdout );
    if ( pNtk->pExdc )
        Abc_NtkPrintStats( pNtk->pExdc, fFactored, fSaveBest, fDumpResult, fUseLutLib, fPrintMuxes, fPower, fGlitch, fSkipBuf, fSkipSmall, fPrintMem );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkReadDefaultArrival()

ABC_DLL Abc_Time_t * Abc_NtkReadDefaultArrival ( Abc_Ntk_t * pNtk )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Reads the arrival.required time of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 75 of file abcTiming.c.

{
    assert( pNtk->pManTime );
    return &pNtk->pManTime->tArrDef;
}

Here is the caller graph for this function:

◆ Abc_NtkReadDefaultArrivalWorst()

ABC_DLL float Abc_NtkReadDefaultArrivalWorst ( Abc_Ntk_t * pNtk )

extern

Definition at line 95 of file abcTiming.c.

{
    return 0.5 * pNtk->pManTime->tArrDef.Rise + 0.5 * pNtk->pManTime->tArrDef.Fall;
}

◆ Abc_NtkReadDefaultInputDrive()

ABC_DLL Abc_Time_t * Abc_NtkReadDefaultInputDrive ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Reads the input drive / output load of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 131 of file abcTiming.c.

{
    assert( pNtk->pManTime );
    return &pNtk->pManTime->tInDriveDef;
}

Here is the caller graph for this function:

◆ Abc_NtkReadDefaultOutputLoad()

ABC_DLL Abc_Time_t * Abc_NtkReadDefaultOutputLoad ( Abc_Ntk_t * pNtk )

extern

Definition at line 136 of file abcTiming.c.

{
    assert( pNtk->pManTime );
    return &pNtk->pManTime->tOutLoadDef;
}

Here is the caller graph for this function:

◆ Abc_NtkReadDefaultRequired()

ABC_DLL Abc_Time_t * Abc_NtkReadDefaultRequired ( Abc_Ntk_t * pNtk )

extern

Definition at line 80 of file abcTiming.c.

{
    assert( pNtk->pManTime );
    return &pNtk->pManTime->tReqDef;
}

Here is the caller graph for this function:

◆ Abc_NtkReadDefaultRequiredWorst()

ABC_DLL float Abc_NtkReadDefaultRequiredWorst ( Abc_Ntk_t * pNtk )

extern

Definition at line 99 of file abcTiming.c.

{
    return 0.5 * pNtk->pManTime->tReqDef.Rise + 0.5 * pNtk->pManTime->tReqDef.Fall;
}

◆ Abc_NtkReassignIds()

ABC_DLL void Abc_NtkReassignIds ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Puts the nodes into the DFS order and reassign their IDs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1809 of file abcUtil.c.

{
    Vec_Ptr_t * vNodes;
    Vec_Ptr_t * vObjsNew;
    Abc_Obj_t * pNode, * pTemp, * pConst1;
    int i, k;
    assert( Abc_NtkIsStrash(pNtk) );
//printf( "Total = %d. Current = %d.\n", Abc_NtkObjNumMax(pNtk), Abc_NtkObjNum(pNtk) );
    // start the array of objects with new IDs
    vObjsNew = Vec_PtrAlloc( pNtk->nObjs );
    // put constant node first
    pConst1 = Abc_AigConst1(pNtk);
    assert( pConst1->Id == 0 );
    Vec_PtrPush( vObjsNew, pConst1 );
    // put PI nodes next
    Abc_NtkForEachPi( pNtk, pNode, i )
    {
        pNode->Id = Vec_PtrSize( vObjsNew );
        Vec_PtrPush( vObjsNew, pNode );
    }
    // put PO nodes next
    Abc_NtkForEachPo( pNtk, pNode, i )
    {
        pNode->Id = Vec_PtrSize( vObjsNew );
        Vec_PtrPush( vObjsNew, pNode );
    }
    // put latches and their inputs/outputs next
    Abc_NtkForEachBox( pNtk, pNode, i )
    {
        pNode->Id = Vec_PtrSize( vObjsNew );
        Vec_PtrPush( vObjsNew, pNode );
        Abc_ObjForEachFanin( pNode, pTemp, k )
        {
            pTemp->Id = Vec_PtrSize( vObjsNew );
            Vec_PtrPush( vObjsNew, pTemp );
        }
        Abc_ObjForEachFanout( pNode, pTemp, k )
        {
            pTemp->Id = Vec_PtrSize( vObjsNew );
            Vec_PtrPush( vObjsNew, pTemp );
        }
    }
    // finally, internal nodes in the DFS order
    vNodes = Abc_AigDfs( pNtk, 1, 0 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
    {
        if ( pNode == pConst1 )
            continue;
        pNode->Id = Vec_PtrSize( vObjsNew );
        Vec_PtrPush( vObjsNew, pNode );
    }
    Vec_PtrFree( vNodes );
    assert( Vec_PtrSize(vObjsNew) == pNtk->nObjs );
 
    // update the fanin/fanout arrays
    Abc_NtkForEachObj( pNtk, pNode, i )
    {
        Abc_ObjForEachFanin( pNode, pTemp, k )
            pNode->vFanins.pArray[k] = pTemp->Id;
        Abc_ObjForEachFanout( pNode, pTemp, k )
            pNode->vFanouts.pArray[k] = pTemp->Id;
    }
 
    // replace the array of objs
    Vec_PtrFree( pNtk->vObjs );
    pNtk->vObjs = vObjsNew;
 
    // rehash the AIG
    Abc_AigRehash( (Abc_Aig_t *)pNtk->pManFunc );
 
    // update the name manager!!!
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkRecAdd3()

ABC_DLL void Abc_NtkRecAdd3	(	Abc_Ntk_t *	pNtk,
		int	fUseSOPB )

extern

Function*************************************************************

Synopsis [Top level procedure for library construction.]

Description []

SideEffects []

SeeAlso []

Definition at line 833 of file abcRec3.c.

{
    extern Abc_Ntk_t * Abc_NtkIf( Abc_Ntk_t * pNtk, If_Par_t * pPars );
    If_Par_t Pars, * pPars = &Pars;
    Abc_Ntk_t * pNtkNew;
    int clk = Abc_Clock();
    if ( Abc_NtkGetChoiceNum( pNtk ) )
        printf( "Performing recoding structures with choices.\n" );
    // remember that the manager was used for library construction
    s_pMan3->fLibConstr = 1;
    // create hash table if not available
    if ( s_pMan3->pGia && Vec_IntSize(&s_pMan3->pGia->vHTable) == 0 )
        Gia_ManHashStart( s_pMan3->pGia );
 
    // set defaults
    memset( pPars, 0, sizeof(If_Par_t) );
    // user-controlable paramters
    pPars->nLutSize    =  s_pMan3->nVars;
    pPars->nCutsMax    =  s_pMan3->nCuts;
    pPars->DelayTarget = -1;
    pPars->Epsilon     =  (float)0.005;
    pPars->fArea       =  1;
    // internal parameters
    if ( fUseSOPB )
    {
        pPars->fTruth      =  1;
        pPars->fCutMin     =  0;
        pPars->fUsePerm    =  1; 
        pPars->fDelayOpt   =  1;
    }
    else
    {
        pPars->fTruth      =  1;
        pPars->fCutMin     =  1;
        pPars->fUsePerm    =  0; 
        pPars->fDelayOpt   =  0;
    }
    pPars->fSkipCutFilter = 0;
    pPars->pFuncCost   =  NULL;
    pPars->pFuncUser   =  Abc_NtkRecAddCut3;
    // perform recording
    pNtkNew = Abc_NtkIf( pNtk, pPars );
    Abc_NtkDelete( pNtkNew );
s_pMan3->timeTotal += Abc_Clock() - clk;
}

Here is the call graph for this function:

◆ Abc_NtkRecGetGia3()

ABC_DLL Gia_Man_t * Abc_NtkRecGetGia3 ( )

extern

Definition at line 1399 of file abcRec3.c.

{
    abctime clk = Abc_Clock();
    printf( "Before normalizing: Library has %d classes and %d AIG subgraphs with %d AND nodes.\n", 
        Vec_MemEntryNum(s_pMan3->vTtMem), Gia_ManPoNum(s_pMan3->pGia), Gia_ManAndNum(s_pMan3->pGia) );
    Lms_GiaNormalize( s_pMan3 );
    printf( "After normalizing:  Library has %d classes and %d AIG subgraphs with %d AND nodes.\n", 
        Vec_MemEntryNum(s_pMan3->vTtMem), Gia_ManPoNum(s_pMan3->pGia), Gia_ManAndNum(s_pMan3->pGia) );
    Abc_PrintTime( 1, "Normalization runtime", Abc_Clock() - clk );
    s_pMan3->fLibConstr = 0;
    return s_pMan3->pGia;
}

Here is the call graph for this function:

◆ Abc_NtkRecInputNum3()

ABC_DLL int Abc_NtkRecInputNum3 ( )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1391 of file abcRec3.c.

{
    return Gia_ManCiNum(s_pMan3->pGia);
}

◆ Abc_NtkRecIsRunning3()

ABC_DLL int Abc_NtkRecIsRunning3 ( )

extern

Definition at line 1395 of file abcRec3.c.

{
    return s_pMan3 != NULL;
}

Here is the caller graph for this function:

◆ Abc_NtkRecLibMerge3()

ABC_DLL void Abc_NtkRecLibMerge3 ( Gia_Man_t * pLib )

extern

Function*************************************************************

Synopsis [Recanonicizes the library and add it to the current library.]

Description []

SideEffects []

SeeAlso []

Definition at line 567 of file abcRec3.c.

{
    int fCheck = 0;
    Lms_Man_t * p = s_pMan3;
    Gia_Man_t * pGia = p->pGia;
    Vec_Str_t * vSupps;
    char pCanonPerm[LMS_VAR_MAX];
    unsigned uCanonPhase;
    word * pTruth;
    int i, k, Index, iFanin0, iFanin1, nLeaves;
    Gia_Obj_t * pObjPo, * pDriver, * pTemp = NULL;
    abctime clk, clk2 = Abc_Clock();
 
    if ( Gia_ManCiNum(pLib) != Gia_ManCiNum(pGia) )
    {
        printf( "The number of Library inputs (%d) differs from the number of Gia inputs (%d).\n", Gia_ManCiNum(pLib), Gia_ManCiNum(pGia) );
        return;
    }
    assert( Gia_ManCiNum(pLib) == Gia_ManCiNum(pGia) );
 
    // create hash table if not available
    if ( Vec_IntSize(&pGia->vHTable) == 0 )
        Gia_ManHashStart( pGia );
 
    // add AIG subgraphs
    vSupps = Lms_GiaSuppSizes( pLib );
    Gia_ManForEachCo( pLib, pObjPo, k )
    {
        // get support size
        nLeaves = Vec_StrEntry(vSupps, k);
        assert( nLeaves > 1 );
 
        // compute the truth table
clk = Abc_Clock();
        pTruth = Gia_ObjComputeTruthTable( pLib, Gia_ObjFanin0(pObjPo) );
p->timeTruth += Abc_Clock() - clk;
        // semi-canonicize
clk = Abc_Clock();
        memcpy( p->pTemp1, pTruth, p->nWords * sizeof(word) );
#ifdef LMS_USE_OLD_FORM
        uCanonPhase = Kit_TruthSemiCanonicize( (unsigned *)p->pTemp1, (unsigned *)p->pTemp2, nLeaves, pCanonPerm );
#else
        uCanonPhase = Abc_TtCanonicize( p->pTemp1, nLeaves, pCanonPerm );
#endif
        Abc_TtStretch5( (unsigned *)p->pTemp1, nLeaves, p->nVars );
p->timeCanon += Abc_Clock() - clk;
        // pCanonPerm and uCanonPhase show what was the variable corresponding to each var in the current truth
        if ( nLeaves == 2 && Abc_TtSupportSize(pTruth, 2) != 2 )
            continue;
 
clk = Abc_Clock();
        // map cut leaves into elementary variables of GIA
        for ( i = 0; i < nLeaves; i++ )
            Gia_ManCi( pLib, pCanonPerm[i] )->Value = Abc_Var2Lit( Gia_ObjId(pGia, Gia_ManPi(pGia, i)), (uCanonPhase >> i) & 1 );
        // build internal nodes
        assert( Vec_IntSize(pLib->vTtNodes) > 0 );
        Gia_ManForEachObjVec( pLib->vTtNodes, pLib, pTemp, i )
        {
            iFanin0 = Abc_LitNotCond( Gia_ObjFanin0(pTemp)->Value, Gia_ObjFaninC0(pTemp) );
            iFanin1 = Abc_LitNotCond( Gia_ObjFanin1(pTemp)->Value, Gia_ObjFaninC1(pTemp) );
            pTemp->Value = Gia_ManHashAnd( pGia, iFanin0, iFanin1 );
        }
p->timeBuild += Abc_Clock() - clk;
 
        // check if this node is already driving a PO
        assert( Gia_ObjIsAnd(pTemp) );
        pDriver = Gia_ManObj(pGia, Abc_Lit2Var(pTemp->Value));
        if ( pDriver->fMark1 )
        {
            p->nFilterSame++;
            continue;
        }
        pDriver->fMark1 = 1;
        // create output
        Gia_ManAppendCo( pGia, Abc_LitNotCond( pTemp->Value, (uCanonPhase >> nLeaves) & 1 ) );
 
        // verify truth table
        if ( fCheck )
        {
clk = Abc_Clock();
        pTemp = Gia_ManCo(pGia, Gia_ManCoNum(pGia)-1);
        pTruth = Gia_ObjComputeTruthTable( pGia, Gia_ManCo(pGia, Gia_ManCoNum(pGia)-1) );
p->timeCheck += Abc_Clock() - clk;
        if ( memcmp( p->pTemp1, pTruth, p->nWords * sizeof(word) ) != 0 )
        {
    
            Kit_DsdPrintFromTruth( (unsigned *)pTruth, nLeaves ); printf( "\n" );
            Kit_DsdPrintFromTruth( (unsigned *)p->pTemp1, nLeaves ); printf( "\n" );
            printf( "Truth table verification has failed.\n" );
    
            // drive PO with constant
            Gia_ManPatchCoDriver( pGia, Gia_ManCoNum(pGia)-1, 0 );
            // save truth table ID
            Vec_IntPush( p->vTruthIds, -1 );
            p->nFilterTruth++;
            continue;
        }
        }
 
clk = Abc_Clock();
        // add the resulting truth table to the hash table 
        Index = Vec_MemHashInsert( p->vTtMem, p->pTemp1 );
        // save truth table ID
        Vec_IntPush( p->vTruthIds, Index );
        assert( Gia_ManCoNum(pGia) == Vec_IntSize(p->vTruthIds) );
        p->nAdded++;
p->timeInsert += Abc_Clock() - clk;
    }
    Vec_StrFree( vSupps );
p->timeTotal += Abc_Clock() - clk2;
}

Here is the call graph for this function:

◆ Abc_NtkRecPs3()

ABC_DLL void Abc_NtkRecPs3 ( int fPrintLib )

extern

Definition at line 1411 of file abcRec3.c.

{
    Lms_ManPrint( s_pMan3 );
}

Here is the call graph for this function:

◆ Abc_NtkRecStart3()

ABC_DLL void Abc_NtkRecStart3	(	Gia_Man_t *	p,
		int	nVars,
		int	nCuts,
		int	fFuncOnly,
		int	fVerbose )

extern

Definition at line 1415 of file abcRec3.c.

{
    assert( s_pMan3 == NULL );
    s_pMan3 = Lms_ManStart( p, nVars, nCuts, fFuncOnly, fVerbose );
}

Here is the call graph for this function:

◆ Abc_NtkRecStop3()

ABC_DLL void Abc_NtkRecStop3 ( )

extern

Definition at line 1421 of file abcRec3.c.

{
    assert( s_pMan3 != NULL );
    Lms_ManStop( s_pMan3 );
    s_pMan3 = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkRefactor()

ABC_DLL int Abc_NtkRefactor	(	Abc_Ntk_t *	pNtk,
		int	nNodeSizeMax,
		int	nMinSaved,
		int	nConeSizeMax,
		int	fUpdateLevel,
		int	fUseZeros,
		int	fUseDcs,
		int	fVerbose )

extern

Function*************************************************************

Synopsis [Performs incremental resynthesis of the AIG.]

Description [Starting from each node, computes a reconvergence-driven cut, derives BDD of the cut function, constructs ISOP, factors the ISOP, and replaces the current implementation of the MFFC of the node by the new factored form, if the number of AIG nodes is reduced and the total number of levels of the AIG network is not increated. Returns the number of AIG nodes saved.]

SideEffects []

SeeAlso []

Definition at line 329 of file abcRefactor.c.

{
    extern int           Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int fUpdateLevel, int nGain );
    ProgressBar * pProgress;
    Abc_ManRef_t * pManRef;
    Abc_ManCut_t * pManCut;
    Dec_Graph_t * pFForm;
    Vec_Ptr_t * vFanins;
    Abc_Obj_t * pNode;
    abctime clk, clkStart = Abc_Clock();
    int i, nNodes, RetValue = 1;
 
    assert( Abc_NtkIsStrash(pNtk) );
    // cleanup the AIG
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
    // start the managers
    pManCut = Abc_NtkManCutStart( nNodeSizeMax, nConeSizeMax, 2, 1000 );
    pManRef = Abc_NtkManRefStart( nNodeSizeMax, nConeSizeMax, fUseDcs, fVerbose );
    pManRef->vLeaves   = Abc_NtkManCutReadCutLarge( pManCut );
    // compute the reverse levels if level update is requested
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
 
    // resynthesize each node once
    pManRef->nNodesBeg = Abc_NtkNodeNum(pNtk);
    nNodes = Abc_NtkObjNumMax(pNtk);
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        // skip the constant node
//        if ( Abc_NodeIsConst(pNode) )
//            continue;
        // skip persistant nodes
        if ( Abc_NodeIsPersistant(pNode) )
            continue;
        // skip the nodes with many fanouts
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
            continue;
        // stop if all nodes have been tried once
        if ( i >= nNodes )
            break;
        // compute a reconvergence-driven cut
clk = Abc_Clock();
        vFanins = Abc_NodeFindCut( pManCut, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
        // evaluate this cut
clk = Abc_Clock();
        pFForm = Abc_NodeRefactor( pManRef, pNode, vFanins, nMinSaved, fUpdateLevel, fUseZeros, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
        if ( pFForm == NULL )
            continue;
        // acceptable replacement found, update the graph
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFForm, fUpdateLevel, pManRef->nLastGain ) )
        {
            Dec_GraphFree( pFForm );
            RetValue = -1;
            break;
        }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFForm );
    }
    Extra_ProgressBarStop( pProgress );
pManRef->timeTotal = Abc_Clock() - clkStart;
    pManRef->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
    // print statistics of the manager
    if ( fVerbose )
        Abc_NtkManRefPrintStats( pManRef );
    // delete the managers
    Abc_NtkManCutStop( pManCut );
    Abc_NtkManRefStop( pManRef );
    // put the nodes into the DFS order and reassign their IDs
    Abc_NtkReassignIds( pNtk );
//    Abc_AigCheckFaninOrder( pNtk->pManFunc );
    if ( RetValue != -1 )
    {
        // fix the levels
        if ( fUpdateLevel )
            Abc_NtkStopReverseLevels( pNtk );
        else
            Abc_NtkLevel( pNtk );
        // check
        if ( !Abc_NtkCheck( pNtk ) )
        {
            printf( "Abc_NtkRefactor: The network check has failed.\n" );
            return 0;
        }
    }
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkRemoveDupFanins()

ABC_DLL int Abc_NtkRemoveDupFanins ( Abc_Ntk_t * pNtk )

extern

Definition at line 894 of file abcMinBase.c.

894{ return 0; }

◆ Abc_NtkRemoveSelfFeedLatches()

ABC_DLL int Abc_NtkRemoveSelfFeedLatches ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Replaces self-feeding latches by latches with constant inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 117 of file abcLatch.c.

{
    Abc_Obj_t * pLatch, * pConst1;
    int i, Counter;
    Counter = 0;
    Abc_NtkForEachLatch( pNtk, pLatch, i )
    {
        if ( Abc_NtkLatchIsSelfFeed( pLatch ) )
        {
            if ( Abc_NtkIsStrash(pNtk) )
                pConst1 = Abc_AigConst1(pNtk);
            else
                pConst1 = Abc_NtkCreateNodeConst1(pNtk);
            Abc_ObjPatchFanin( Abc_ObjFanin0(pLatch), Abc_ObjFanin0(Abc_ObjFanin0(pLatch)), pConst1 );
            Counter++;
        }
    }
    return Counter;
}

Here is the call graph for this function:

◆ Abc_NtkRestrash()

ABC_DLL Abc_Ntk_t * Abc_NtkRestrash	(	Abc_Ntk_t *	pNtk,
		int	fCleanup )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Reapplies structural hashing to the AIG.]

Description [Because of the structural hashing, this procedure should not change the number of nodes. It is useful to detect the bugs in the original AIG.]

SideEffects []

SeeAlso []

Definition at line 49 of file abcStrash.c.

{
//    extern int timeRetime;
    Vec_Ptr_t * vNodes;
    Abc_Ntk_t * pNtkAig;
    Abc_Obj_t * pObj;
    int i, nNodes;//, RetValue;
    assert( Abc_NtkIsStrash(pNtk) );
//timeRetime = Abc_Clock();
    // print warning about choice nodes
    if ( Abc_NtkGetChoiceNum( pNtk ) )
        printf( "Warning: The choice nodes in the original AIG are removed by strashing.\n" );
    // start the new network (constants and CIs of the old network will point to the their counterparts in the new network)
    pNtkAig = Abc_NtkStartFrom( pNtk, ABC_NTK_STRASH, ABC_FUNC_AIG );
    // restrash the nodes (assuming a topological order of the old network)
    vNodes = Abc_NtkDfs( pNtk, 0 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
        pObj->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkAig->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
    Vec_PtrFree( vNodes );
    // finalize the network
    Abc_NtkFinalize( pNtk, pNtkAig );
    // print warning about self-feed latches
//    if ( Abc_NtkCountSelfFeedLatches(pNtkAig) )
//        printf( "Warning: The network has %d self-feeding latches.\n", Abc_NtkCountSelfFeedLatches(pNtkAig) );
    // perform cleanup if requested
    if ( fCleanup && (nNodes = Abc_AigCleanup((Abc_Aig_t *)pNtkAig->pManFunc)) ) 
    {
//        printf( "Abc_NtkRestrash(): AIG cleanup removed %d nodes (this is a bug).\n", nNodes );
    }
    // duplicate EXDC 
    if ( pNtk->pExdc )
        pNtkAig->pExdc = Abc_NtkDup( pNtk->pExdc );
    // make sure everything is okay
    if ( !Abc_NtkCheck( pNtkAig ) )
    {
        printf( "Abc_NtkStrash: The network check has failed.\n" );
        Abc_NtkDelete( pNtkAig );
        return NULL;
    }
//timeRetime = Abc_Clock() - timeRetime;
//    if ( RetValue = Abc_NtkRemoveSelfFeedLatches(pNtkAig) )
//        printf( "Modified %d self-feeding latches. The result may not verify.\n", RetValue );
    return pNtkAig;
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkRestrashZero()

ABC_DLL Abc_Ntk_t * Abc_NtkRestrashZero	(	Abc_Ntk_t *	pNtk,
		int	fCleanup )

extern

Function*************************************************************

Synopsis [Reapplies structural hashing to the AIG.]

Description [Because of the structural hashing, this procedure should not change the number of nodes. It is useful to detect the bugs in the original AIG.]

SideEffects []

SeeAlso []

Definition at line 181 of file abcStrash.c.

{
//    extern int timeRetime;
    Abc_Ntk_t * pNtkAig;
    Abc_Obj_t * pObj;
    int i, nNodes;//, RetValue;
    int Counter = 0;
    assert( Abc_NtkIsStrash(pNtk) );
//timeRetime = Abc_Clock();
    // print warning about choice nodes
    if ( Abc_NtkGetChoiceNum( pNtk ) )
        printf( "Warning: The choice nodes in the original AIG are removed by strashing.\n" );
    // start the new network (constants and CIs of the old network will point to the their counterparts in the new network)
    pNtkAig = Abc_NtkStartFrom( pNtk, ABC_NTK_STRASH, ABC_FUNC_AIG );
    // complement the 1-values registers
    Abc_NtkForEachLatch( pNtk, pObj, i )
    {
        if ( Abc_LatchIsInitDc(pObj) )
            Counter++;
        else if ( Abc_LatchIsInit1(pObj) )
            Abc_ObjFanout0(pObj)->pCopy = Abc_ObjNot(Abc_ObjFanout0(pObj)->pCopy);
    }
    if ( Counter )
    printf( "Converting %d flops from don't-care to zero initial value.\n", Counter );
    // restrash the nodes (assuming a topological order of the old network)
    Abc_NtkForEachNode( pNtk, pObj, i )
        pObj->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkAig->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
    // finalize the network
    Abc_NtkFinalize( pNtk, pNtkAig );
    // complement the 1-valued registers
    Abc_NtkForEachLatch( pNtkAig, pObj, i )
        if ( Abc_LatchIsInit1(pObj) )
        {
            Abc_ObjXorFaninC( Abc_ObjFanin0(pObj), 0 );
            // if latch has PO as one of its fanouts change latch name
            if ( Abc_NodeFindCoFanout( Abc_ObjFanout0(pObj) ) )
            {
                Nm_ManDeleteIdName( pObj->pNtk->pManName, Abc_ObjFanout0(pObj)->Id );
                Abc_ObjAssignName( Abc_ObjFanout0(pObj), Abc_ObjName(Abc_ObjFanout0(pObj)), "_inv" );
            }
        }
    // set all constant-0 values
    Abc_NtkForEachLatch( pNtkAig, pObj, i )
        Abc_LatchSetInit0( pObj );
 
    // print warning about self-feed latches
//    if ( Abc_NtkCountSelfFeedLatches(pNtkAig) )
//        printf( "Warning: The network has %d self-feeding latches.\n", Abc_NtkCountSelfFeedLatches(pNtkAig) );
    // perform cleanup if requested
    if ( fCleanup && (nNodes = Abc_AigCleanup((Abc_Aig_t *)pNtkAig->pManFunc)) ) 
        printf( "Abc_NtkRestrash(): AIG cleanup removed %d nodes (this is a bug).\n", nNodes );
    // duplicate EXDC 
    if ( pNtk->pExdc )
        pNtkAig->pExdc = Abc_NtkDup( pNtk->pExdc );
    // transfer name IDs
    if ( pNtk->vNameIds )
        Abc_NtkTransferNameIds( pNtk, pNtkAig );
    if ( pNtk->vNameIds )
        Abc_NtkUpdateNameIds( pNtkAig );
    // make sure everything is okay
    if ( !Abc_NtkCheck( pNtkAig ) )
    {
        printf( "Abc_NtkStrash: The network check has failed.\n" );
        Abc_NtkDelete( pNtkAig );
        return NULL;
    }
//timeRetime = Abc_Clock() - timeRetime;
//    if ( RetValue = Abc_NtkRemoveSelfFeedLatches(pNtkAig) )
//        printf( "Modified %d self-feeding latches. The result may not verify.\n", RetValue );
    return pNtkAig;
 
}

Here is the call graph for this function:

◆ Abc_NtkReverseTopoOrder()

ABC_DLL void Abc_NtkReverseTopoOrder ( Abc_Ntk_t * pNtk )

extern

Definition at line 2664 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    assert( p->vTopo == NULL );
    p->vTopo = Vec_IntAlloc( 10 * Abc_NtkObjNumMax(p) );
    Vec_IntFill( p->vTopo, 2 * Abc_NtkObjNumMax(p), 0 );
    Abc_NtkForEachNode( p, pObj, i )
    {
        if ( Abc_NtkTopoHasBeg(pObj) )
            continue;
        Abc_NtkIncrementTravId( p );        
        Abc_NtkReverseTopoOrder_rec( pObj, 1 );
    }
    printf( "Nodes = %d.   Size = %d.  Ratio = %f.\n", 
        Abc_NtkNodeNum(p), Vec_IntSize(p->vTopo), 1.0*Vec_IntSize(p->vTopo)/Abc_NtkNodeNum(p) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkRewrite()

ABC_DLL int Abc_NtkRewrite	(	Abc_Ntk_t *	pNtk,
		int	fUpdateLevel,
		int	fUseZeros,
		int	fVerbose,
		int	fVeryVerbose,
		int	fPlaceEnable )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Performs incremental rewriting of the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 61 of file abcRewrite.c.

{
    extern int           Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int fUpdateLevel, int nGain );
    ProgressBar * pProgress;
    Cut_Man_t * pManCut;
    Rwr_Man_t * pManRwr;
    Abc_Obj_t * pNode;
//    Vec_Ptr_t * vAddedCells = NULL, * vUpdatedNets = NULL;
    Dec_Graph_t * pGraph;
    int i, nNodes, nGain, fCompl, RetValue = 1;
    abctime clk, clkStart = Abc_Clock();
 
    assert( Abc_NtkIsStrash(pNtk) );
    // cleanup the AIG
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
/*
    {
        Vec_Vec_t * vParts;
        vParts = Abc_NtkPartitionSmart( pNtk, 50, 1 );
        Vec_VecFree( vParts );
    }
*/
 
    // start placement package
//    if ( fPlaceEnable )
//    {
//        Abc_PlaceBegin( pNtk );
//        vAddedCells = Abc_AigUpdateStart( pNtk->pManFunc, &vUpdatedNets );
//    }
 
    // start the rewriting manager
    pManRwr = Rwr_ManStart( 0 );
    if ( pManRwr == NULL )
        return 0;
    // compute the reverse levels if level update is requested
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
    // start the cut manager
clk = Abc_Clock();
    pManCut = Abc_NtkStartCutManForRewrite( pNtk );
Rwr_ManAddTimeCuts( pManRwr, Abc_Clock() - clk );
    pNtk->pManCut = pManCut;
 
    if ( fVeryVerbose )
        Rwr_ScoresClean( pManRwr );
 
    // resynthesize each node once
    pManRwr->nNodesBeg = Abc_NtkNodeNum(pNtk);
    nNodes = Abc_NtkObjNumMax(pNtk);
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        // stop if all nodes have been tried once
        if ( i >= nNodes )
            break;
        // skip persistant nodes
        if ( Abc_NodeIsPersistant(pNode) )
            continue;
        // skip the nodes with many fanouts
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
            continue;
 
        // for each cut, try to resynthesize it
        nGain = Rwr_NodeRewrite( pManRwr, pManCut, pNode, fUpdateLevel, fUseZeros, fPlaceEnable );
        if ( !(nGain > 0 || (nGain == 0 && fUseZeros)) )
            continue;
        // if we end up here, a rewriting step is accepted
 
        // get hold of the new subgraph to be added to the AIG
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
 
        // reset the array of the changed nodes
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
 
        // complement the FF if needed
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain ) )
        {
            RetValue = -1;
            break;
        }
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
 
        // use the array of changed nodes to update placement
//        if ( fPlaceEnable )
//            Abc_PlaceUpdate( vAddedCells, vUpdatedNets );
    }
    Extra_ProgressBarStop( pProgress );
Rwr_ManAddTimeTotal( pManRwr, Abc_Clock() - clkStart );
    // print stats
    pManRwr->nNodesEnd = Abc_NtkNodeNum(pNtk);
    if ( fVerbose )
        Rwr_ManPrintStats( pManRwr );
//        Rwr_ManPrintStatsFile( pManRwr );
    if ( fVeryVerbose )
        Rwr_ScoresReport( pManRwr );
    // delete the managers
    Rwr_ManStop( pManRwr );
    Cut_ManStop( pManCut );
    pNtk->pManCut = NULL;
 
    // start placement package
//    if ( fPlaceEnable )
//    {
//        Abc_PlaceEnd( pNtk );
//        Abc_AigUpdateStop( pNtk->pManFunc );
//    }
 
    // put the nodes into the DFS order and reassign their IDs
    {
//        abctime clk = Abc_Clock();
    Abc_NtkReassignIds( pNtk );
//        ABC_PRT( "time", Abc_Clock() - clk );
    }
//    Abc_AigCheckFaninOrder( pNtk->pManFunc );
    // fix the levels
    if ( RetValue >= 0 )
    {
        if ( fUpdateLevel )
            Abc_NtkStopReverseLevels( pNtk );
        else
            Abc_NtkLevel( pNtk );
        // check
        if ( !Abc_NtkCheck( pNtk ) )
        {
            printf( "Abc_NtkRewrite: The network check has failed.\n" );
            return 0;
        }
    }
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkSaveCopy()

ABC_DLL Vec_Ptr_t * Abc_NtkSaveCopy ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Saves copy field of the objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 628 of file abcUtil.c.

{
    Vec_Ptr_t * vCopies;
    Abc_Obj_t * pObj;
    int i;
    vCopies = Vec_PtrStart( Abc_NtkObjNumMax(pNtk) );
    Abc_NtkForEachObj( pNtk, pObj, i )
        Vec_PtrWriteEntry( vCopies, i, pObj->pCopy );
    return vCopies;
}

Here is the caller graph for this function:

◆ Abc_NtkSetMvVarValues()

ABC_DLL void Abc_NtkSetMvVarValues	(	Abc_Obj_t *	pObj,
		int	nValues )

extern

Function*************************************************************

Synopsis [Duplicate the MV variable.]

Description []

SideEffects []

SeeAlso []

Definition at line 87 of file abcBlifMv.c.

{
    Mem_Flex_t * pFlex;
    struct temp 
    { 
        int nValues; 
        char ** pNames; 
    } * pVarStruct;
    assert( nValues > 1 );
    // skip binary signals
    if ( nValues == 2 )
        return;
    // skip already assigned signals
    if ( Abc_ObjMvVar(pObj) != NULL )
        return;
    // create the structure
    pFlex = (Mem_Flex_t *)Abc_NtkMvVarMan( pObj->pNtk );
    pVarStruct = (struct temp *)Mem_FlexEntryFetch( pFlex, sizeof(struct temp) );
    pVarStruct->nValues = nValues;
    pVarStruct->pNames = NULL;
    Abc_ObjSetMvVar( pObj, pVarStruct );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkSetNodeLevelsArrival()

ABC_DLL void Abc_NtkSetNodeLevelsArrival ( Abc_Ntk_t * pNtkOld )

extern

Function*************************************************************

Synopsis [Sets the CI node levels according to the arrival info.]

Description []

SideEffects []

SeeAlso []

Definition at line 722 of file abcTiming.c.

{
    Abc_Obj_t * pNodeOld, * pNodeNew;
    float tAndDelay;
    int i;
    if ( pNtkOld->pManTime == NULL )
        return;
    if ( Abc_FrameReadLibGen() == NULL || Mio_LibraryReadNand2((Mio_Library_t *)Abc_FrameReadLibGen()) == NULL )
        return;
    tAndDelay = Mio_LibraryReadDelayNand2Max((Mio_Library_t *)Abc_FrameReadLibGen());
    Abc_NtkForEachCi( pNtkOld, pNodeOld, i )
    {
        pNodeNew = pNodeOld->pCopy;
        pNodeNew->Level = (int)(Abc_NodeReadArrivalWorst(pNodeOld) / tAndDelay);
    }
}

Here is the call graph for this function:

◆ Abc_NtkShortNames()

ABC_DLL void Abc_NtkShortNames ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Replaces names by short names.]

Description []

SideEffects []

SeeAlso []

Definition at line 619 of file abcNames.c.

{
    Nm_ManFree( pNtk->pManName );
    pNtk->pManName = Nm_ManCreate( Abc_NtkCiNum(pNtk) + Abc_NtkCoNum(pNtk) + Abc_NtkBoxNum(pNtk) );
    Abc_NtkAddDummyPiNames( pNtk );
    Abc_NtkAddDummyPoNames( pNtk );
    Abc_NtkAddDummyBoxNames( pNtk );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkShow6VarFunc()

ABC_DLL void Abc_NtkShow6VarFunc	(	char *	pF0,
		char *	pF1 )

extern

Function*************************************************************

Synopsis [Prints K-map of 6-var function represented by truth table.]

Description []

SideEffects []

SeeAlso []

Definition at line 2089 of file abcPrint.c.

{
    word F0, F1;
    if ( strlen(pF0) != 16 )
    {
        printf( "Wrong length (%d) of 6-var truth table.\n", (int)strlen(pF0) );
        return;
    }
    if ( strlen(pF1) != 16 )
    {
        printf( "Wrong length (%d) of 6-var truth table.\n", (int)strlen(pF1) );
        return;
    }
    Extra_ReadHexadecimal( (unsigned *)&F0, pF0, 6 );
    Extra_ReadHexadecimal( (unsigned *)&F1, pF1, 6 );
    Abc_Show6VarFunc( F0, F1 );
}

Here is the call graph for this function:

◆ Abc_NtkSizeOfGlobalBdds()

ABC_DLL int Abc_NtkSizeOfGlobalBdds ( Abc_Ntk_t * pNtk )

extern

◆ Abc_NtkSopToAig()

ABC_DLL int Abc_NtkSopToAig ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Converts the network from SOP to AIG representation.]

Description []

SideEffects []

SeeAlso []

Definition at line 884 of file abcFunc.c.

{
    Abc_Obj_t * pNode;
    Hop_Man_t * pMan;
    int i, Max;
 
    assert( Abc_NtkHasSop(pNtk) ); 
 
    // make dist1-free and SCC-free
//    Abc_NtkMakeLegit( pNtk );
 
    // start the functionality manager
    pMan = Hop_ManStart();
    Max = Abc_NtkGetFaninMax(pNtk);
    if ( Max ) Hop_IthVar( pMan, Max-1 );
 
    // convert each node from SOP to BDD
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( Abc_ObjIsBarBuf(pNode) )
            continue;
        assert( pNode->pData );
        pNode->pData = Abc_ConvertSopToAig( pMan, (char *)pNode->pData );
        if ( pNode->pData == NULL )
        {
            Hop_ManStop( pMan );
            printf( "Abc_NtkSopToAig: Error while converting SOP into AIG.\n" );
            return 0;
        }
    }
    Mem_FlexStop( (Mem_Flex_t *)pNtk->pManFunc, 0 );
    pNtk->pManFunc = pMan;
 
    // update the network type
    pNtk->ntkFunc = ABC_FUNC_AIG;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkSopToBdd()

ABC_DLL int Abc_NtkSopToBdd ( Abc_Ntk_t * pNtk )

extern

Definition at line 865 of file abcFunc.c.

865{ return 1; }

Here is the caller graph for this function:

◆ Abc_NtkSortSops()

ABC_DLL void Abc_NtkSortSops ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Sorts fanins of each node to make SOPs more readable.]

Description []

SideEffects []

SeeAlso []

Definition at line 520 of file abcFanOrder.c.

{
    Abc_NtkSortCubes( pNtk, 1 );
    Abc_NtkOrderFaninsByLitCount( pNtk );
    Abc_NtkSortCubes( pNtk, 0 );
    Abc_NtkOrderFaninsByLitCountAndCubeCount( pNtk );
    Abc_NtkSortCubes( pNtk, 0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkStartFrom()

ABC_DLL Abc_Ntk_t * Abc_NtkStartFrom	(	Abc_Ntk_t *	pNtk,
		Abc_NtkType_t	Type,
		Abc_NtkFunc_t	Func )

extern

Function*************************************************************

Synopsis [Starts a new network using existing network as a model.]

Description []

SideEffects []

SeeAlso []

Definition at line 157 of file abcNtk.c.

{
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pObj;
    int fCopyNames, i;
    if ( pNtk == NULL )
        return NULL;
    // decide whether to copy the names
    fCopyNames = ( Type != ABC_NTK_NETLIST );
    // start the network
    pNtkNew = Func == ABC_FUNC_BDD ? Abc_NtkAllocBdd( Type, Func, 1, Abc_NtkCiNum(pNtk) ) : Abc_NtkAlloc( Type, Func, 1 );
    pNtkNew->nConstrs   = pNtk->nConstrs;
    pNtkNew->nBarBufs   = pNtk->nBarBufs;
    // duplicate the name and the spec
    pNtkNew->pName = Extra_UtilStrsav(pNtk->pName);
    pNtkNew->pSpec = Extra_UtilStrsav(pNtk->pSpec);
    // clean the node copy fields
    Abc_NtkCleanCopy( pNtk );
    // map the constant nodes
    if ( Abc_NtkIsStrash(pNtk) && Abc_NtkIsStrash(pNtkNew) )
        Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkNew);
    // clone CIs/CIs/boxes
    Abc_NtkForEachPi( pNtk, pObj, i )
        Abc_NtkDupObj( pNtkNew, pObj, fCopyNames );
    Abc_NtkForEachPo( pNtk, pObj, i )
        Abc_NtkDupObj( pNtkNew, pObj, fCopyNames );
    Abc_NtkForEachBox( pNtk, pObj, i )
        Abc_NtkDupBox( pNtkNew, pObj, fCopyNames );
    // transfer logic level
    Abc_NtkForEachCi( pNtk, pObj, i )
        pObj->pCopy->Level = pObj->Level;
    // transfer the names
//    Abc_NtkTrasferNames( pNtk, pNtkNew );
    Abc_ManTimeDup( pNtk, pNtkNew );
    if ( pNtk->vOnehots )
        pNtkNew->vOnehots = (Vec_Ptr_t *)Vec_VecDupInt( (Vec_Vec_t *)pNtk->vOnehots );
    if ( pNtk->pSeqModel )
        pNtkNew->pSeqModel = Abc_CexDup( pNtk->pSeqModel, Abc_NtkLatchNum(pNtk) );
    if ( pNtk->vObjPerm )
        pNtkNew->vObjPerm = Vec_IntDup( pNtk->vObjPerm );
    pNtkNew->AndGateDelay = pNtk->AndGateDelay;
    if ( pNtkNew->pManTime && Abc_FrameReadLibGen() && pNtkNew->AndGateDelay == 0.0 )
        pNtkNew->AndGateDelay = Mio_LibraryReadDelayAigNode((Mio_Library_t *)Abc_FrameReadLibGen());
    // initialize logic level of the CIs
    if ( pNtk->AndGateDelay != 0.0 && pNtk->pManTime != NULL && pNtk->ntkType != ABC_NTK_STRASH && Type == ABC_NTK_STRASH )
    {
        Abc_NtkForEachCi( pNtk, pObj, i )
            pObj->pCopy->Level = (int)(Abc_MaxFloat(0, Abc_NodeReadArrivalWorst(pObj)) / pNtk->AndGateDelay);
    }
    // check that the CI/CO/latches are copied correctly
    assert( Abc_NtkCiNum(pNtk)    == Abc_NtkCiNum(pNtkNew) );
    assert( Abc_NtkCoNum(pNtk)    == Abc_NtkCoNum(pNtkNew) );
    assert( Abc_NtkLatchNum(pNtk) == Abc_NtkLatchNum(pNtkNew) );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkStartFromNoLatches()

ABC_DLL Abc_Ntk_t * Abc_NtkStartFromNoLatches	(	Abc_Ntk_t *	pNtk,
		Abc_NtkType_t	Type,
		Abc_NtkFunc_t	Func )

extern

Function*************************************************************

Synopsis [Starts a new network using existing network as a model.]

Description []

SideEffects []

SeeAlso []

Definition at line 301 of file abcNtk.c.

{
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pObj;
    int i;
    if ( pNtk == NULL )
        return NULL;
    assert( Type != ABC_NTK_NETLIST );
    // start the network
    pNtkNew = Abc_NtkAlloc( Type, Func, 1 );
    pNtkNew->nConstrs   = pNtk->nConstrs;
    pNtkNew->nBarBufs   = pNtk->nBarBufs;
    // duplicate the name and the spec
    pNtkNew->pName = Extra_UtilStrsav(pNtk->pName);
    pNtkNew->pSpec = Extra_UtilStrsav(pNtk->pSpec);
    // clean the node copy fields
    Abc_NtkCleanCopy( pNtk );
    // map the constant nodes
    if ( Abc_NtkIsStrash(pNtk) && Abc_NtkIsStrash(pNtkNew) )
        Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkNew);
    // clone CIs/CIs/boxes
    Abc_NtkForEachPi( pNtk, pObj, i )
        Abc_NtkDupObj( pNtkNew, pObj, 1 );
    Abc_NtkForEachPo( pNtk, pObj, i )
        Abc_NtkDupObj( pNtkNew, pObj, 1 );
    Abc_NtkForEachBox( pNtk, pObj, i )
    {
        if ( Abc_ObjIsLatch(pObj) )
            continue;
        Abc_NtkDupBox(pNtkNew, pObj, 1);
    }
    if ( pNtk->vObjPerm )
        pNtkNew->vObjPerm = Vec_IntDup( pNtk->vObjPerm );
    pNtkNew->AndGateDelay = pNtk->AndGateDelay;
    // transfer the names
//    Abc_NtkTrasferNamesNoLatches( pNtk, pNtkNew );
    Abc_ManTimeDup( pNtk, pNtkNew );
    // check that the CI/CO/latches are copied correctly
    assert( Abc_NtkPiNum(pNtk) == Abc_NtkPiNum(pNtkNew) );
    assert( Abc_NtkPoNum(pNtk) == Abc_NtkPoNum(pNtkNew) );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkStartMvVars()

ABC_DLL void Abc_NtkStartMvVars ( Abc_Ntk_t * pNtk )

extern

DECLARATIONS ///.

CFile****************************************************************

FileName [abcBlifMv.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Procedures to process BLIF-MV networks and AIGs.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: abcBlifMv.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Starts the Mv-Var manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 49 of file abcBlifMv.c.

{
    Vec_Att_t * pAttMan;
    assert( Abc_NtkMvVar(pNtk) == NULL );
    pAttMan = Vec_AttAlloc( Abc_NtkObjNumMax(pNtk) + 1, Mem_FlexStart(), (void(*)(void*))Mem_FlexStop, NULL, NULL );
    Vec_PtrWriteEntry( pNtk->vAttrs, VEC_ATTR_MVVAR, pAttMan );
//printf( "allocing attr\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkStartNameIds()

ABC_DLL void Abc_NtkStartNameIds ( Abc_Ntk_t * p )

extern

Function*************************************************************

Synopsis [Saves name IDs into a file.]

Description []

SideEffects []

SeeAlso []

Definition at line 711 of file abcNames.c.

{
    char pFileName[1000];
    FILE * pFile;
    Abc_Obj_t * pObj, * pFanin;
    Vec_Ptr_t * vNodes;
    int i, Counter = 1;
    assert( Abc_NtkIsNetlist(p) );
    assert( p->vNameIds == NULL );
    assert( strlen(p->pSpec) < 1000 );
    sprintf( pFileName, "%s_%s_names.txt", Extra_FileNameGenericAppend(p->pSpec,""), Extra_FileNameExtension(p->pSpec) );
    pFile = fopen( pFileName, "wb" );
    p->vNameIds = Vec_IntStart( Abc_NtkObjNumMax(p) );
    // add inputs
    Abc_NtkForEachCi( p, pObj, i )
        fprintf( pFile, "%s            \n", Abc_ObjName(Abc_ObjFanout0(pObj)) ), Vec_IntWriteEntry(p->vNameIds, Abc_ObjId(pObj), 2*Counter++);
    // add outputs
    Abc_NtkForEachCo( p, pObj, i )
    {
        pFanin = Abc_ObjFanin0(Abc_ObjFanin0(pObj));
        if ( !Vec_IntEntry(p->vNameIds, Abc_ObjId(pFanin)) )
            fprintf( pFile, "%s            \n", Abc_ObjName(Abc_ObjFanout0(pFanin)) ), Vec_IntWriteEntry(p->vNameIds, Abc_ObjId(pFanin), 2*Counter++);
    }
    // add nodes in a topo order
    vNodes = Abc_NtkDfs( p, 1 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
        if ( !Vec_IntEntry(p->vNameIds, Abc_ObjId(pObj)) )
            fprintf( pFile, "%s            \n", Abc_ObjName(Abc_ObjFanout0(pObj)) ), Vec_IntWriteEntry(p->vNameIds, Abc_ObjId(pObj), 2*Counter++);
    Vec_PtrFree( vNodes );
    fclose( pFile );
    // transfer driver node names to COs
    Abc_NtkForEachCo( p, pObj, i )
    {
        pFanin = Abc_ObjFanin0(Abc_ObjFanin0(pObj));
        Vec_IntWriteEntry( p->vNameIds, Abc_ObjId(pObj), Vec_IntEntry(p->vNameIds, Abc_ObjId(pFanin)) );
        Vec_IntWriteEntry( p->vNameIds, Abc_ObjId(pFanin), 0 );
    }
}

Here is the call graph for this function:

◆ Abc_NtkStartRead()

ABC_DLL Abc_Ntk_t * Abc_NtkStartRead ( char * pName )

extern

Function*************************************************************

Synopsis [Starts a new network using existing network as a model.]

Description []

SideEffects []

SeeAlso []

Definition at line 386 of file abcNtk.c.

{
    Abc_Ntk_t * pNtkNew; 
    // allocate the empty network
    pNtkNew = Abc_NtkAlloc( ABC_NTK_NETLIST, ABC_FUNC_SOP, 1 );
    // set the specs
    pNtkNew->pName = Extra_FileNameGeneric(pName);
    pNtkNew->pSpec = Extra_UtilStrsav(pName);
    if ( pNtkNew->pName == NULL || strlen(pNtkNew->pName) == 0 )
    {
        ABC_FREE( pNtkNew->pName );
        pNtkNew->pName = Extra_UtilStrsav("unknown");
    }
    return pNtkNew;
}

Here is the call graph for this function:

◆ Abc_NtkStartReverseLevels()

ABC_DLL void Abc_NtkStartReverseLevels	(	Abc_Ntk_t *	pNtk,
		int	nMaxLevelIncrease )

extern

Function*************************************************************

Synopsis [Prepares for the computation of required levels.]

Description [This procedure should be called before the required times are used. It starts internal data structures, which records the level from the COs of the network nodes in reverse topologogical order.]

SideEffects []

SeeAlso []

Definition at line 1274 of file abcTiming.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pObj;
    int i;
    // remember the maximum number of direct levels
    pNtk->LevelMax = Abc_NtkLevel(pNtk) + nMaxLevelIncrease;
    // start the reverse levels
    pNtk->vLevelsR = Vec_IntAlloc( 0 );
    Vec_IntFill( pNtk->vLevelsR, 1 + Abc_NtkObjNumMax(pNtk), 0 );
    // compute levels in reverse topological order
    vNodes = Abc_NtkDfsReverse( pNtk );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
        Abc_ObjSetReverseLevel( pObj, Abc_ObjReverseLevelNew(pObj) );
    Vec_PtrFree( vNodes );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkStopReverseLevels()

ABC_DLL void Abc_NtkStopReverseLevels ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Cleans the data structures used to compute required levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 1302 of file abcTiming.c.

{
    assert( pNtk->vLevelsR );
    Vec_IntFree( pNtk->vLevelsR );
    pNtk->vLevelsR = NULL;
    pNtk->LevelMax = 0;
 
}

Here is the caller graph for this function:

◆ Abc_NtkStrash()

ABC_DLL Abc_Ntk_t * Abc_NtkStrash	(	Abc_Ntk_t *	pNtk,
		int	fAllNodes,
		int	fCleanup,
		int	fRecord )

extern

Function*************************************************************

Synopsis [Transforms logic network into structurally hashed AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 265 of file abcStrash.c.

{
    Abc_Ntk_t * pNtkAig;
    int nNodes;
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsStrash(pNtk) );
    // consider the special case when the network is already structurally hashed
    if ( Abc_NtkIsStrash(pNtk) )
        return Abc_NtkRestrash( pNtk, fCleanup );
    // convert the node representation in the logic network to the AIG form
    if ( !Abc_NtkToAig(pNtk) )
    {
        printf( "Converting to AIGs has failed.\n" );
        return NULL;
    }
    // perform strashing
//    Abc_NtkCleanCopy( pNtk );
    pNtkAig = Abc_NtkStartFrom( pNtk, ABC_NTK_STRASH, ABC_FUNC_AIG );
    Abc_NtkStrashPerform( pNtk, pNtkAig, fAllNodes, fRecord );
    Abc_NtkFinalize( pNtk, pNtkAig );
    // transfer name IDs
    if ( pNtk->vNameIds )
        Abc_NtkTransferNameIds( pNtk, pNtkAig );
    // print warning about self-feed latches
//    if ( Abc_NtkCountSelfFeedLatches(pNtkAig) )
//        printf( "Warning: The network has %d self-feeding latches.\n", Abc_NtkCountSelfFeedLatches(pNtkAig) );
    // perform cleanup if requested
    nNodes = fCleanup? Abc_AigCleanup((Abc_Aig_t *)pNtkAig->pManFunc) : 0;
//    if ( nNodes )
//        printf( "Warning: AIG cleanup removed %d nodes (this is not a bug).\n", nNodes );
    // duplicate EXDC 
    if ( pNtk->pExdc )
        pNtkAig->pExdc = Abc_NtkStrash( pNtk->pExdc, fAllNodes, fCleanup, fRecord );
    // make sure everything is okay
    if ( !Abc_NtkCheck( pNtkAig ) )
    {
        printf( "Abc_NtkStrash: The network check has failed.\n" );
        Abc_NtkDelete( pNtkAig );
        return NULL;
    }
    return pNtkAig;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkStrashBlifMv()

ABC_DLL Abc_Ntk_t * Abc_NtkStrashBlifMv ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Strashes the BLIF-MV netlist.]

Description []

SideEffects []

SeeAlso []

Definition at line 383 of file abcBlifMv.c.

{
    int fUsePositional = 0;
    Vec_Ptr_t * vNodes;
    Abc_Obj_t ** pBits;
    Abc_Obj_t ** pValues;
    Abc_Ntk_t * pNtkNew;
    Abc_Obj_t * pObj, * pTemp, * pBit, * pNet;
    int i, k, v, nValues, nValuesMax, nBits;
    int nCount1, nCount2;
 
    assert( Abc_NtkIsNetlist(pNtk) );
    assert( Abc_NtkHasBlifMv(pNtk) );
    assert( Abc_NtkWhiteboxNum(pNtk) == 0 );
    assert( Abc_NtkBlackboxNum(pNtk) == 0 );
 
    // get the largest number of values
    nValuesMax = 2;
    Abc_NtkForEachNet( pNtk, pObj, i )
    {
        nValues = Abc_ObjMvVarNum(pObj);
        if ( nValuesMax < nValues )
            nValuesMax = nValues;
    }
    nBits = Abc_Base2Log( nValuesMax );
    pBits = ABC_ALLOC( Abc_Obj_t *, nBits );
 
    // clean the node copy fields
    Abc_NtkCleanCopy( pNtk );
    // collect the nodes
    vNodes = Abc_NtkDfs( pNtk, 0 );
 
    // start the network
    pNtkNew = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    // duplicate the name and the spec
    pNtkNew->pName = Extra_UtilStrsav( pNtk->pName );
//    pNtkNew->pSpec = Extra_UtilStrsav( pNtk->pName );
 
    nCount1 = nCount2 = 0;
    // encode the CI nets
    Abc_NtkIncrementTravId( pNtk );
    if ( fUsePositional )
    {
        Abc_NtkForEachCi( pNtk, pObj, i )
        {
            if ( !Abc_ObjIsPi(pObj) )
                continue;
            pNet = Abc_ObjFanout0(pObj);
            nValues = Abc_ObjMvVarNum(pNet);
            pValues = ABC_ALLOC( Abc_Obj_t *, nValues );
            // create PIs for the values
            for ( v = 0; v < nValues; v++ )
            {
                pValues[v] = Abc_NtkCreatePi( pNtkNew );
                if ( nValuesMax == 2 )
                    Abc_ObjAssignName( pValues[v], Abc_ObjName(pNet), NULL );
                else
                    Abc_NtkConvertAssignName( pValues[v], pNet, v );
            }
            // save the values in the fanout net
            pNet->pCopy = (Abc_Obj_t *)pValues;
            // mark the net
            Abc_NodeSetTravIdCurrent( pNet );
        }
        Abc_NtkForEachCi( pNtk, pObj, i )
        {
            if ( Abc_ObjIsPi(pObj) )
                continue;
            pNet = Abc_ObjFanout0(pObj);
            nValues = Abc_ObjMvVarNum(pNet);
            pValues = ABC_ALLOC( Abc_Obj_t *, nValues );
            // create PIs for the values
            for ( v = 0; v < nValues; v++ )
            {
                pValues[v] = Abc_NtkCreateBo( pNtkNew );
                if ( nValuesMax == 2 )
                    Abc_ObjAssignName( pValues[v], Abc_ObjName(pNet), NULL );
                else
                    Abc_NtkConvertAssignName( pValues[v], pNet, v );
                nCount1++;
            }
            // save the values in the fanout net
            pNet->pCopy = (Abc_Obj_t *)pValues;
            // mark the net
            Abc_NodeSetTravIdCurrent( pNet );
        }
    }
    else
    {
        Abc_NtkForEachCi( pNtk, pObj, i )
        {
            if ( !Abc_ObjIsPi(pObj) )
                continue;
            pNet = Abc_ObjFanout0(pObj);
            nValues = Abc_ObjMvVarNum(pNet);
            pValues = ABC_ALLOC( Abc_Obj_t *, nValues );
            // create PIs for the encoding bits
            nBits = Abc_Base2Log( nValues );
            for ( k = 0; k < nBits; k++ )
            {
                pBits[k] = Abc_NtkCreatePi( pNtkNew );
                if ( nValuesMax == 2 )
                    Abc_ObjAssignName( pBits[k], Abc_ObjName(pNet), NULL );
                else
                    Abc_NtkConvertAssignName( pBits[k], pNet, k );
            }
            // encode the values
            for ( v = 0; v < nValues; v++ )
            {
                pValues[v] = Abc_AigConst1(pNtkNew);
                for ( k = 0; k < nBits; k++ )
                {
                    pBit = Abc_ObjNotCond( pBits[k], (v&(1<<k)) == 0 );
                    pValues[v] = Abc_AigAnd( (Abc_Aig_t *)pNtkNew->pManFunc, pValues[v], pBit );
                }
            }
            // save the values in the fanout net
            pNet->pCopy = (Abc_Obj_t *)pValues;
            // mark the net
            Abc_NodeSetTravIdCurrent( pNet );
        }
        Abc_NtkForEachCi( pNtk, pObj, i )
        {
            if ( Abc_ObjIsPi(pObj) )
                continue;
            pNet = Abc_ObjFanout0(pObj);
            nValues = Abc_ObjMvVarNum(pNet);
            pValues = ABC_ALLOC( Abc_Obj_t *, nValues );
            // create PIs for the encoding bits
            nBits = Abc_Base2Log( nValues );
            for ( k = 0; k < nBits; k++ )
            {
                pBits[k] = Abc_NtkCreateBo( pNtkNew );
                if ( nValuesMax == 2 )
                    Abc_ObjAssignName( pBits[k], Abc_ObjName(pNet), NULL );
                else
                    Abc_NtkConvertAssignName( pBits[k], pNet, k );
                nCount1++;
            }
            // encode the values
            for ( v = 0; v < nValues; v++ )
            {
                pValues[v] = Abc_AigConst1(pNtkNew);
                for ( k = 0; k < nBits; k++ )
                {
                    pBit = Abc_ObjNotCond( pBits[k], (v&(1<<k)) == 0 );
                    pValues[v] = Abc_AigAnd( (Abc_Aig_t *)pNtkNew->pManFunc, pValues[v], pBit );
                }
            }
            // save the values in the fanout net
            pNet->pCopy = (Abc_Obj_t *)pValues;
            // mark the net
            Abc_NodeSetTravIdCurrent( pNet );
        }
    }
 
    // process nodes in the topological order
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
        if ( !Abc_NodeStrashBlifMv( pNtkNew, pObj ) )
        {
            Abc_NtkDelete( pNtkNew );
            return NULL;
        }
    Vec_PtrFree( vNodes );
 
    // encode the CO nets
    if ( fUsePositional )
    {
        Abc_NtkForEachCo( pNtk, pObj, i )
        {
            if ( !Abc_ObjIsPo(pObj) )
                continue;
            pNet = Abc_ObjFanin0(pObj);
            // skip marked nets
//            if ( Abc_NodeIsTravIdCurrent(pNet) )
//                continue;
//            Abc_NodeSetTravIdCurrent( pNet );
            nValues = Abc_ObjMvVarNum(pNet);
            pValues = (Abc_Obj_t **)pNet->pCopy;
            for ( v = 0; v < nValues; v++ )
            {
                pTemp = Abc_NtkCreatePo( pNtkNew );
                Abc_ObjAddFanin( pTemp, pValues[v] );
                if ( nValuesMax == 2 )
                    Abc_ObjAssignName( pTemp, Abc_ObjName(pNet), NULL );
                else
                    Abc_NtkConvertAssignName( pTemp, pNet, v );
            }
        }
        Abc_NtkForEachCo( pNtk, pObj, i )
        {
            if ( Abc_ObjIsPo(pObj) )
                continue;
            pNet = Abc_ObjFanin0(pObj);
            // skip marked nets
//            if ( Abc_NodeIsTravIdCurrent(pNet) )
//                continue;
//            Abc_NodeSetTravIdCurrent( pNet );
            nValues = Abc_ObjMvVarNum(pNet);
            pValues = (Abc_Obj_t **)pNet->pCopy;
            for ( v = 0; v < nValues; v++ )
            {
                pTemp = Abc_NtkCreateBi( pNtkNew );
                Abc_ObjAddFanin( pTemp, pValues[v] );
                if ( nValuesMax == 2 )
                    Abc_ObjAssignName( pTemp, Abc_ObjName(pNet), NULL );
                else
                    Abc_NtkConvertAssignName( pTemp, pNet, v );
                nCount2++;
            }
        }
    }
    else // if ( fPositional == 0 )
    {
        Abc_NtkForEachCo( pNtk, pObj, i )
        {
            if ( !Abc_ObjIsPo(pObj) )
                continue;
            pNet = Abc_ObjFanin0(pObj);
            // skip marked nets
//            if ( Abc_NodeIsTravIdCurrent(pNet) )
//                continue;
//            Abc_NodeSetTravIdCurrent( pNet );
            nValues = Abc_ObjMvVarNum(pNet);
            pValues = (Abc_Obj_t **)pNet->pCopy;
            nBits = Abc_Base2Log( nValues );
            for ( k = 0; k < nBits; k++ )
            {
                pBit = Abc_ObjNot( Abc_AigConst1(pNtkNew) );
                for ( v = 0; v < nValues; v++ )
                    if ( v & (1<<k) )
                        pBit = Abc_AigOr( (Abc_Aig_t *)pNtkNew->pManFunc, pBit, pValues[v] );
                pTemp = Abc_NtkCreatePo( pNtkNew );
                Abc_ObjAddFanin( pTemp, pBit );
                if ( nValuesMax == 2 )
                    Abc_ObjAssignName( pTemp, Abc_ObjName(pNet), NULL );
                else
                    Abc_NtkConvertAssignName( pTemp, pNet, k );
            }
        }
        Abc_NtkForEachCo( pNtk, pObj, i )
        {
            if ( Abc_ObjIsPo(pObj) )
                continue;
            pNet = Abc_ObjFanin0(pObj);
            // skip marked nets
//            if ( Abc_NodeIsTravIdCurrent(pNet) )
//                continue;
//            Abc_NodeSetTravIdCurrent( pNet );
            nValues = Abc_ObjMvVarNum(pNet);
            pValues = (Abc_Obj_t **)pNet->pCopy;
            nBits = Abc_Base2Log( nValues );
            for ( k = 0; k < nBits; k++ )
            {
                pBit = Abc_ObjNot( Abc_AigConst1(pNtkNew) );
                for ( v = 0; v < nValues; v++ )
                    if ( v & (1<<k) )
                        pBit = Abc_AigOr( (Abc_Aig_t *)pNtkNew->pManFunc, pBit, pValues[v] );
                pTemp = Abc_NtkCreateBi( pNtkNew );
                Abc_ObjAddFanin( pTemp, pBit );
                if ( nValuesMax == 2 )
                    Abc_ObjAssignName( pTemp, Abc_ObjName(pNet), NULL );
                else
                    Abc_NtkConvertAssignName( pTemp, pNet, k );
                nCount2++;
            }
        }
    }
 
    if ( Abc_NtkLatchNum(pNtk) )
    {
        Vec_Ptr_t * vTemp;
        Abc_Obj_t * pLatch, * pObjLi, * pObjLo;
        int i;
        // move free vars to the front among the PIs
        vTemp = Vec_PtrAlloc( Vec_PtrSize(pNtkNew->vPis) );
        Abc_NtkForEachPi( pNtkNew, pObj, i )
            if ( strncmp( Abc_ObjName(pObj), "free_var_", 9 ) == 0 )
                Vec_PtrPush( vTemp, pObj );
        Abc_NtkForEachPi( pNtkNew, pObj, i )
            if ( strncmp( Abc_ObjName(pObj), "free_var_", 9 ) != 0 )
                Vec_PtrPush( vTemp, pObj );
        assert( Vec_PtrSize(vTemp) == Vec_PtrSize(pNtkNew->vPis) );
        Vec_PtrFree( pNtkNew->vPis );
        pNtkNew->vPis = vTemp;
        // move free vars to the front among the CIs
        vTemp = Vec_PtrAlloc( Vec_PtrSize(pNtkNew->vCis) );
        Abc_NtkForEachCi( pNtkNew, pObj, i )
            if ( strncmp( Abc_ObjName(pObj), "free_var_", 9 ) == 0 )
                Vec_PtrPush( vTemp, pObj );
        Abc_NtkForEachCi( pNtkNew, pObj, i )
            if ( strncmp( Abc_ObjName(pObj), "free_var_", 9 ) != 0 )
                Vec_PtrPush( vTemp, pObj );
        assert( Vec_PtrSize(vTemp) == Vec_PtrSize(pNtkNew->vCis) );
        Vec_PtrFree( pNtkNew->vCis );
        pNtkNew->vCis = vTemp;
        // create registers
        assert( nCount1 == nCount2 );
        for ( i = 0; i < nCount1; i++ )
        {
            // create latch
            pLatch = Abc_NtkCreateLatch( pNtkNew );
            Abc_LatchSetInit0( pLatch );
            Abc_ObjAssignName( pLatch, Abc_ObjName(pLatch), NULL );
            // connect
            pObjLi = Abc_NtkCo( pNtkNew, Abc_NtkCoNum(pNtkNew)-nCount1+i );
            pObjLo = Abc_NtkCi( pNtkNew, Abc_NtkCiNum(pNtkNew)-nCount1+i );
            Abc_ObjAddFanin( pLatch, pObjLi );
            Abc_ObjAddFanin( pObjLo, pLatch );
        }
    }
 
    // cleanup
    ABC_FREE( pBits );
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( pObj->pCopy )
            ABC_FREE( pObj->pCopy );
 
    // remove dangling nodes
    i = Abc_AigCleanup((Abc_Aig_t *)pNtkNew->pManFunc);
//    printf( "Cleanup removed %d nodes.\n", i );
//    Abc_NtkReassignIds( pNtkNew );
 
    // check integrity
    if ( !Abc_NtkCheck( pNtkNew ) )
    {
        fprintf( stdout, "Abc_NtkStrashBlifMv(): Network check has failed.\n" );
        Abc_NtkDelete( pNtkNew );
        return NULL;
    }
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkSupport()

ABC_DLL Vec_Ptr_t * Abc_NtkSupport ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Returns the set of CI nodes in the support of the given nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 859 of file abcDfs.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pNode;
    int i;
    // set the traversal ID
    Abc_NtkIncrementTravId( pNtk );
    // start the array of nodes
    vNodes = Vec_PtrAlloc( 100 );
    // go through the PO nodes and call for each of them
    Abc_NtkForEachCo( pNtk, pNode, i )
        Abc_NtkNodeSupport_rec( Abc_ObjFanin0(pNode), vNodes );
    // add unused CIs
    Abc_NtkForEachCi( pNtk, pNode, i )
        if ( !Abc_NodeIsTravIdCurrent( pNode ) )
            Vec_PtrPush( vNodes, pNode );
    assert( Vec_PtrSize(vNodes) == Abc_NtkCiNum(pNtk) );
    return vNodes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkSweep()

ABC_DLL int Abc_NtkSweep	(	Abc_Ntk_t *	pNtk,
		int	fVerbose )

extern

Definition at line 692 of file abcSweep.c.

692{ return 1; }

Here is the caller graph for this function:

◆ Abc_NtkSweepBufsInvs()

ABC_DLL int Abc_NtkSweepBufsInvs	(	Abc_Ntk_t *	pNtk,
		int	fVerbose )

extern

Function*************************************************************

Synopsis [Sweep to remove buffers and inverters.]

Description []

SideEffects []

SeeAlso []

Definition at line 969 of file abcSweep.c.

{
    Hop_Man_t * pMan;
    Abc_Obj_t * pObj, * pFanin;
    int i, k, fChanges = 1, Counter = 0;
    assert( Abc_NtkIsLogic(pNtk) ); 
    // convert network to BDD representation
    if ( !Abc_NtkToAig(pNtk) )
    {
        fprintf( stdout, "Converting to SOP has failed.\n" );
        return 1;
    }
    // get AIG manager
    pMan = (Hop_Man_t *)pNtk->pManFunc;
    // label selected nodes
    Abc_NtkIncrementTravId( pNtk );
    // iterate till no improvement
    while ( fChanges )
    {
        fChanges = 0;
        Abc_NtkForEachObj( pNtk, pObj, i )
        {
            Abc_ObjForEachFanin( pObj, pFanin, k )
            {
                // do not eliminate marked fanins
                if ( Abc_NodeIsTravIdCurrent(pFanin) )
                    continue;
                // do not eliminate constant nodes
                if ( !Abc_ObjIsNode(pFanin) || Abc_ObjFaninNum(pFanin) != 1 )
                    continue;
                // do not eliminate inverters into COs
                if ( Abc_ObjIsCo(pObj) && Abc_NodeIsInv(pFanin) )
                    continue;
                // do not eliminate buffers connecting PIs and POs 
//                if ( Abc_ObjIsCo(pObj) && Abc_ObjIsCi(Abc_ObjFanin0(pFanin)) )
//                    continue;
                fChanges = 1;
                Counter++;
                // update function of the node
                if ( Abc_NodeIsInv(pFanin) )
                    pObj->pData = Hop_Compose( pMan, (Hop_Obj_t *)pObj->pData, Hop_Not(Hop_IthVar(pMan, k)), k );
                // update the fanin
                Abc_ObjPatchFanin( pObj, pFanin, Abc_ObjFanin0(pFanin) );
                if ( Abc_ObjFanoutNum(pFanin) == 0 )
                    Abc_NtkDeleteObj(pFanin);            
            }
        }
    }
    if ( fVerbose )
        printf( "Removed %d single input nodes.\n", Counter );
    return Counter;
}

Here is the call graph for this function:

◆ Abc_NtkTimeInitialize()

ABC_DLL void Abc_NtkTimeInitialize	(	Abc_Ntk_t *	pNtk,
		Abc_Ntk_t *	pNtkOld )

extern

Function*************************************************************

Synopsis [Finalizes the timing manager after setting arr/req times.]

Description []

SideEffects []

SeeAlso []

Definition at line 343 of file abcTiming.c.

{
    Abc_Obj_t * pObj;
    Abc_Time_t ** ppTimes;
    int i;
    assert( pNtkOld == NULL || pNtkOld->pManTime != NULL );
    assert( pNtkOld == NULL || Abc_NtkCiNum(pNtk) == Abc_NtkCiNum(pNtkOld) );
    assert( pNtkOld == NULL || Abc_NtkCoNum(pNtk) == Abc_NtkCoNum(pNtkOld) );
    if ( pNtk->pManTime == NULL )
        return;
    // create timing manager with default values
    Abc_ManTimeExpand( pNtk->pManTime, Abc_NtkObjNumMax(pNtk), 0 );
    // set global defaults from pNtkOld
    if ( pNtkOld )
    {
        pNtk->pManTime->tArrDef = pNtkOld->pManTime->tArrDef;
        pNtk->pManTime->tReqDef = pNtkOld->pManTime->tReqDef;
        pNtk->AndGateDelay = pNtkOld->AndGateDelay;
    }
    // set the default timing for CI and COs
    ppTimes = (Abc_Time_t **)pNtk->pManTime->vArrs->pArray;
    Abc_NtkForEachCi( pNtk, pObj, i )
        *ppTimes[pObj->Id] = pNtkOld ? *Abc_NodeReadArrival(Abc_NtkCi(pNtkOld, i)) : pNtk->pManTime->tArrDef;
    ppTimes = (Abc_Time_t **)pNtk->pManTime->vReqs->pArray;
    Abc_NtkForEachCo( pNtk, pObj, i )
        *ppTimes[pObj->Id] = pNtkOld ? *Abc_NodeReadRequired(Abc_NtkCo(pNtkOld, i)) : pNtk->pManTime->tReqDef;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkTimeSetArrival()

ABC_DLL void Abc_NtkTimeSetArrival	(	Abc_Ntk_t *	pNtk,
		int	ObjId,
		float	Rise,
		float	Fall )

extern

Function*************************************************************

Synopsis [Sets the arrival time for an object.]

Description []

SideEffects []

SeeAlso []

Definition at line 208 of file abcTiming.c.

{
    Vec_Ptr_t * vTimes;
    Abc_Time_t * pTime;
 
    if ( pNtk->pManTime == NULL )
        pNtk->pManTime = Abc_ManTimeStart(pNtk);
    Abc_ManTimeExpand( pNtk->pManTime, ObjId + 1, 1 );
    // set the arrival time
    vTimes = pNtk->pManTime->vArrs;
    pTime = (Abc_Time_t *)vTimes->pArray[ObjId];
    pTime->Rise  = Rise;
    pTime->Fall  = Fall;
 
    
}

Here is the caller graph for this function:

◆ Abc_NtkTimeSetDefaultArrival()

ABC_DLL void Abc_NtkTimeSetDefaultArrival	(	Abc_Ntk_t *	pNtk,
		float	Rise,
		float	Fall )

extern

Function*************************************************************

Synopsis [Sets the default arrival time for the network.]

Description [Please note that .default_input_arrival and .default_output_required should precede .input_arrival and .output required. Otherwise, an overwrite may happen.]

SideEffects []

SeeAlso []

Definition at line 173 of file abcTiming.c.

{
    Abc_Obj_t * pObj; int i;
    if ( pNtk->pManTime == NULL )
        pNtk->pManTime = Abc_ManTimeStart(pNtk);
    pNtk->pManTime->tArrDef.Rise  = Rise;
    pNtk->pManTime->tArrDef.Fall  = Fall;
    // set the arrival times for each input
    Abc_NtkForEachCi( pNtk, pObj, i )
        Abc_NtkTimeSetArrival( pNtk, Abc_ObjId(pObj), Rise, Fall );    
}

Here is the call graph for this function:

◆ Abc_NtkTimeSetDefaultInputDrive()

ABC_DLL void Abc_NtkTimeSetDefaultInputDrive	(	Abc_Ntk_t *	pNtk,
		float	Rise,
		float	Fall )

extern

Function*************************************************************

Synopsis [Sets the default arrival time for the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 249 of file abcTiming.c.

{
//    if ( Rise == 0.0 && Fall == 0.0 )
//        return;
    if ( pNtk->pManTime == NULL )
        pNtk->pManTime = Abc_ManTimeStart(pNtk);
    pNtk->pManTime->tInDriveDef.Rise  = Rise;
    pNtk->pManTime->tInDriveDef.Fall  = Fall;
    if ( pNtk->pManTime->tInDrive != NULL )
    {
        int i;
        for ( i = 0; i < Abc_NtkCiNum(pNtk); i++ )
            if ( pNtk->pManTime->tInDrive[i].Rise == 0 && pNtk->pManTime->tInDrive[i].Fall == 0 )
                pNtk->pManTime->tInDrive[i] = pNtk->pManTime->tInDriveDef;
    }
}

◆ Abc_NtkTimeSetDefaultOutputLoad()

ABC_DLL void Abc_NtkTimeSetDefaultOutputLoad	(	Abc_Ntk_t *	pNtk,
		float	Rise,
		float	Fall )

extern

Definition at line 265 of file abcTiming.c.

{
//    if ( Rise == 0.0 && Fall == 0.0 )
//        return;
    if ( pNtk->pManTime == NULL )
        pNtk->pManTime = Abc_ManTimeStart(pNtk);
    pNtk->pManTime->tOutLoadDef.Rise  = Rise;
    pNtk->pManTime->tOutLoadDef.Fall  = Fall;
    if ( pNtk->pManTime->tOutLoad != NULL )
    {
        int i;
        for ( i = 0; i < Abc_NtkCoNum(pNtk); i++ )
            if ( pNtk->pManTime->tOutLoad[i].Rise == 0 && pNtk->pManTime->tOutLoad[i].Fall == 0 )
                pNtk->pManTime->tOutLoad[i] = pNtk->pManTime->tOutLoadDef;
    }
}

◆ Abc_NtkTimeSetDefaultRequired()

ABC_DLL void Abc_NtkTimeSetDefaultRequired	(	Abc_Ntk_t *	pNtk,
		float	Rise,
		float	Fall )

extern

Definition at line 184 of file abcTiming.c.

{
    Abc_Obj_t * pObj; int i;
    if ( pNtk->pManTime == NULL )
        pNtk->pManTime = Abc_ManTimeStart(pNtk);
    pNtk->pManTime->tReqDef.Rise  = Rise;
    pNtk->pManTime->tReqDef.Fall  = Fall;
    // set the required times for each output
        Abc_NtkForEachCo( pNtk, pObj, i ){
            Abc_NtkTimeSetRequired( pNtk, Abc_ObjId(pObj), Rise, Fall );
    }
}

Here is the call graph for this function:

◆ Abc_NtkTimeSetInputDrive()

ABC_DLL void Abc_NtkTimeSetInputDrive	(	Abc_Ntk_t *	pNtk,
		int	PiNum,
		float	Rise,
		float	Fall )

extern

Function*************************************************************

Synopsis [Sets the arrival time for an object.]

Description []

SideEffects []

SeeAlso []

Definition at line 293 of file abcTiming.c.

{
    Abc_Time_t * pTime;
    assert( PiNum >= 0 && PiNum < Abc_NtkCiNum(pNtk) );
    if ( pNtk->pManTime == NULL )
        pNtk->pManTime = Abc_ManTimeStart(pNtk);
    if ( pNtk->pManTime->tInDriveDef.Rise == Rise && pNtk->pManTime->tInDriveDef.Fall == Fall )
        return;
    if ( pNtk->pManTime->tInDrive == NULL )
    {
        int i;
        pNtk->pManTime->tInDrive = ABC_CALLOC( Abc_Time_t, Abc_NtkCiNum(pNtk) );
        for ( i = 0; i < Abc_NtkCiNum(pNtk); i++ )
            pNtk->pManTime->tInDrive[i] = pNtk->pManTime->tInDriveDef;
    }
    pTime = pNtk->pManTime->tInDrive + PiNum;
    pTime->Rise  = Rise;
    pTime->Fall  = Fall;
}

◆ Abc_NtkTimeSetOutputLoad()

ABC_DLL void Abc_NtkTimeSetOutputLoad	(	Abc_Ntk_t *	pNtk,
		int	PoNum,
		float	Rise,
		float	Fall )

extern

Definition at line 312 of file abcTiming.c.

{
    Abc_Time_t * pTime;
    assert( PoNum >= 0 && PoNum < Abc_NtkCoNum(pNtk) );
    if ( pNtk->pManTime == NULL )
        pNtk->pManTime = Abc_ManTimeStart(pNtk);
    if ( pNtk->pManTime->tOutLoadDef.Rise == Rise && pNtk->pManTime->tOutLoadDef.Fall == Fall )
        return;
    if ( pNtk->pManTime->tOutLoad == NULL )
    {
        int i;
        pNtk->pManTime->tOutLoad = ABC_CALLOC( Abc_Time_t, Abc_NtkCoNum(pNtk) );
        for ( i = 0; i < Abc_NtkCoNum(pNtk); i++ )
            pNtk->pManTime->tOutLoad[i] = pNtk->pManTime->tOutLoadDef;
    }
    pTime = pNtk->pManTime->tOutLoad + PoNum;
    pTime->Rise  = Rise;
    pTime->Fall  = Fall;
}

◆ Abc_NtkTimeSetRequired()

ABC_DLL void Abc_NtkTimeSetRequired	(	Abc_Ntk_t *	pNtk,
		int	ObjId,
		float	Rise,
		float	Fall )

extern

Definition at line 224 of file abcTiming.c.

{
    Vec_Ptr_t * vTimes;
    Abc_Time_t * pTime;
    if ( pNtk->pManTime == NULL )
        pNtk->pManTime = Abc_ManTimeStart(pNtk);
    Abc_ManTimeExpand( pNtk->pManTime, ObjId + 1, 1 );
    // set the required time
    vTimes = pNtk->pManTime->vReqs;
    pTime = (Abc_Time_t *)vTimes->pArray[ObjId];
    pTime->Rise  = Rise;
    pTime->Fall  = Fall;
}

Here is the caller graph for this function:

◆ Abc_NtkToAig()

ABC_DLL int Abc_NtkToAig ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Convers logic network to the SOP form.]

Description []

SideEffects []

SeeAlso []

Definition at line 1333 of file abcFunc.c.

{
    assert( !Abc_NtkIsStrash(pNtk) );
    if ( Abc_NtkHasBlackbox(pNtk) )
        return 1;
    if ( Abc_NtkHasAig(pNtk) )
        return 1;
    if ( Abc_NtkHasMapping(pNtk) )
    {
        Abc_NtkMapToSop(pNtk);
        return Abc_NtkSopToAig(pNtk);
    }
    if ( Abc_NtkHasBdd(pNtk) )
    {
        if ( !Abc_NtkBddToSop(pNtk, -1, ABC_INFINITY, 1) )
            return 0;
        return Abc_NtkSopToAig(pNtk);
    }
    if ( Abc_NtkHasSop(pNtk) )
        return Abc_NtkSopToAig(pNtk);
    assert( 0 );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkToBarBufs()

ABC_DLL Abc_Ntk_t * Abc_NtkToBarBufs ( Abc_Ntk_t * pNtk )

extern

Definition at line 180 of file abcBarBuf.c.

{
    char Buffer[1000];
    Vec_Ptr_t * vLiMaps, * vLoMaps;
    Abc_Ntk_t * pNtkNew, * pTemp;
    Abc_Obj_t * pLatch, * pObjLi, * pObjLo;
    Abc_Obj_t * pObj, * pLiMap, * pLoMap;
    int i, k, nBoxes;
    assert( Abc_NtkIsNetlist(pNtk) );
    if ( !Abc_NtkCheckSingleInstance(pNtk) )
        return NULL;
    assert( pNtk->pDesign != NULL );
    // start the network
    pNtkNew = Abc_NtkAlloc( ABC_NTK_LOGIC, pNtk->ntkFunc, 1 );
    pNtkNew->pName = Extra_UtilStrsav(pNtk->pName);
    pNtkNew->pSpec = Extra_UtilStrsav(pNtk->pSpec);
    // clone CIs/CIs/boxes
    Abc_NtkCleanCopy_rec( pNtk );
    Abc_NtkForEachPi( pNtk, pObj, i )
        Abc_ObjFanout0(pObj)->pCopy = Abc_NtkDupObj( pNtkNew, pObj, 1 );
    Abc_NtkForEachPo( pNtk, pObj, i )
        Abc_NtkDupObj( pNtkNew, pObj, 1 );
    // create latches and transfer copy labels
    nBoxes = Abc_NtkCollectPiPos( pNtk, &vLiMaps, &vLoMaps );
    Vec_PtrForEachEntryTwo( Abc_Obj_t *, vLiMaps, Abc_Obj_t *, vLoMaps, pLiMap, pLoMap, i )
    {
        pObjLi = Abc_NtkCreateBi(pNtkNew);
        pLatch = Abc_NtkCreateLatch(pNtkNew);
        pObjLo = Abc_NtkCreateBo(pNtkNew);
        Abc_ObjAddFanin( pLatch, pObjLi );
        Abc_ObjAddFanin( pObjLo, pLatch );
        pLatch->pData = (void *)ABC_INIT_ZERO;
        pTemp = NULL;
        if ( Abc_ObjFanin0(pLiMap)->pNtk != pNtk )
            pTemp = Abc_ObjFanin0(pLiMap)->pNtk;
        else if ( Abc_ObjFanout0(pLoMap)->pNtk != pNtk )
            pTemp = Abc_ObjFanout0(pLoMap)->pNtk;
        else assert( 0 );
        sprintf( Buffer, "_%s_in", Abc_NtkName(pTemp) );
        Abc_ObjAssignName( pObjLi, Abc_ObjName(Abc_ObjFanin0(pLiMap)), Buffer );
        sprintf( Buffer, "_%s_out", Abc_NtkName(pTemp) );
        Abc_ObjAssignName( pObjLo, Abc_ObjName(Abc_ObjFanout0(pLoMap)), Buffer );
        pLiMap->pCopy = pObjLi;
        Abc_ObjFanout0(pLoMap)->pCopy = pObjLo;
        assert( Abc_ObjIsNet(Abc_ObjFanout0(pLoMap)) );
    }
    Vec_PtrFree( vLiMaps );
    Vec_PtrFree( vLoMaps );
    // rebuild networks
    Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pTemp, i )
        Abc_NtkForEachCo( pTemp, pObj, k )
            Abc_ObjAddFanin( pObj->pCopy, Abc_NtkToBarBufs_rec(pNtkNew, Abc_ObjFanin0(pObj)) );
    pNtkNew->nBarBufs = Abc_NtkLatchNum(pNtkNew);
    printf( "Hierarchy reader flattened %d instances of logic boxes and introduced %d barbufs.\n", nBoxes, pNtkNew->nBarBufs );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkToBdd()

ABC_DLL int Abc_NtkToBdd ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Convers logic network to the SOP form.]

Description []

SideEffects []

SeeAlso []

Definition at line 1299 of file abcFunc.c.

{
    assert( !Abc_NtkIsStrash(pNtk) );
    if ( Abc_NtkHasBlackbox(pNtk) )
        return 1;
    if ( Abc_NtkHasBdd(pNtk) )
        return 1;
    if ( Abc_NtkHasMapping(pNtk) )
    {
        Abc_NtkMapToSop(pNtk);
        return Abc_NtkSopToBdd(pNtk);
    }
    if ( Abc_NtkHasSop(pNtk) )
    {
        Abc_NtkSopToAig(pNtk);
        return Abc_NtkAigToBdd(pNtk);
    }
    if ( Abc_NtkHasAig(pNtk) )
        return Abc_NtkAigToBdd(pNtk);
    assert( 0 );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkToFraig()

ABC_DLL void * Abc_NtkToFraig	(	Abc_Ntk_t *	pNtk,
		void *	pParams,
		int	fAllNodes,
		int	fExdc )

extern

Function*************************************************************

Synopsis [Transforms the strashed network into FRAIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 103 of file abcFraig.c.

{
    int fInternal = ((Fraig_Params_t *)pParams)->fInternal;
    Fraig_Man_t * pMan;
    ProgressBar * pProgress = NULL;
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pNode;
    int i;
 
    assert( Abc_NtkIsStrash(pNtk) );
 
    // create the FRAIG manager
    pMan = Fraig_ManCreate( (Fraig_Params_t *)pParams );
 
    // map the constant node
    Abc_NtkCleanCopy( pNtk );
    Abc_AigConst1(pNtk)->pCopy = (Abc_Obj_t *)Fraig_ManReadConst1(pMan);
    // create PIs and remember them in the old nodes
    Abc_NtkForEachCi( pNtk, pNode, i )
        pNode->pCopy = (Abc_Obj_t *)Fraig_ManReadIthVar(pMan, i);
 
    // perform strashing
    vNodes = Abc_AigDfs( pNtk, fAllNodes, 0 );
    if ( !fInternal )
        pProgress = Extra_ProgressBarStart( stdout, vNodes->nSize );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
    {
        if ( Abc_ObjFaninNum(pNode) == 0 )
            continue;
        if ( pProgress ) 
            Extra_ProgressBarUpdate( pProgress, i, NULL );
        pNode->pCopy = (Abc_Obj_t *)Fraig_NodeAnd( pMan, 
                Fraig_NotCond( Abc_ObjFanin0(pNode)->pCopy, (int)Abc_ObjFaninC0(pNode) ),
                Fraig_NotCond( Abc_ObjFanin1(pNode)->pCopy, (int)Abc_ObjFaninC1(pNode) ) );
    }
    if ( pProgress )
        Extra_ProgressBarStop( pProgress );
    Vec_PtrFree( vNodes );
 
    // use EXDC to change the mapping of nodes into FRAIG nodes
    if ( fExdc )
        Abc_NtkFraigRemapUsingExdc( pMan, pNtk );
 
    // set the primary outputs
    Abc_NtkForEachCo( pNtk, pNode, i )
        Fraig_ManSetPo( pMan, (Fraig_Node_t *)Abc_ObjNotCond( Abc_ObjFanin0(pNode)->pCopy, Abc_ObjFaninC0(pNode) ) );
    return pMan;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkToLogic()

ABC_DLL Abc_Ntk_t * Abc_NtkToLogic ( Abc_Ntk_t * pNtk )

extern

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Transform the netlist into a logic network.]

Description []

SideEffects []

SeeAlso []

Definition at line 52 of file abcNetlist.c.

{
    Abc_Ntk_t * pNtkNew; 
    Abc_Obj_t * pObj, * pFanin;
    int i, k;
    // consider the case of the AIG
    if ( Abc_NtkIsStrash(pNtk) )
        return Abc_NtkAigToLogicSop( pNtk );
    assert( Abc_NtkIsNetlist(pNtk) );
    // consider simple case when there is hierarchy
//    assert( pNtk->pDesign == NULL );
    assert( Abc_NtkWhiteboxNum(pNtk) == 0 );
    assert( Abc_NtkBlackboxNum(pNtk) == 0 );
    // start the network
    pNtkNew = Abc_NtkStartFrom( pNtk, ABC_NTK_LOGIC, pNtk->ntkFunc );
    // duplicate the nodes 
    Abc_NtkForEachNode( pNtk, pObj, i )
    {
        Abc_NtkDupObj(pNtkNew, pObj, 0);
        Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(Abc_ObjFanout0(pObj)), NULL );
    }
    // reconnect the internal nodes in the new network
    Abc_NtkForEachNode( pNtk, pObj, i )
        Abc_ObjForEachFanin( pObj, pFanin, k )
            Abc_ObjAddFanin( pObj->pCopy, Abc_ObjFanin0(pFanin)->pCopy );
    // collect the CO nodes
    Abc_NtkFinalize( pNtk, pNtkNew );
    // fix the problem with CO pointing directly to CIs
    Abc_NtkLogicMakeSimpleCos( pNtkNew, 0 );
    // duplicate EXDC 
    if ( pNtk->pExdc )
        pNtkNew->pExdc = Abc_NtkToLogic( pNtk->pExdc );
    if ( !Abc_NtkCheck( pNtkNew ) )
        fprintf( stdout, "Abc_NtkToLogic(): Network check has failed.\n" );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkToNetlist()

ABC_DLL Abc_Ntk_t * Abc_NtkToNetlist ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Transform the logic network into a netlist.]

Description []

SideEffects []

SeeAlso []

Definition at line 100 of file abcNetlist.c.

{
    Abc_Ntk_t * pNtkNew, * pNtkTemp; 
    assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsStrash(pNtk) );
    if ( Abc_NtkIsStrash(pNtk) )
    {
        pNtkTemp = Abc_NtkAigToLogicSop(pNtk);
        pNtkNew = Abc_NtkLogicToNetlist( pNtkTemp );
        Abc_NtkDelete( pNtkTemp );
        return pNtkNew;
    }
    return Abc_NtkLogicToNetlist( pNtk );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkToNetlistBench()

ABC_DLL Abc_Ntk_t * Abc_NtkToNetlistBench ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Converts the AIG into the netlist.]

Description [This procedure does not copy the choices.]

SideEffects []

SeeAlso []

Definition at line 125 of file abcNetlist.c.

{
    Abc_Ntk_t * pNtkNew, * pNtkTemp; 
    assert( Abc_NtkIsStrash(pNtk) );
    pNtkTemp = Abc_NtkAigToLogicSopBench( pNtk );
    pNtkNew = Abc_NtkLogicToNetlist( pNtkTemp );
    Abc_NtkDelete( pNtkTemp );
    return pNtkNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkTopmost()

ABC_DLL Abc_Ntk_t * Abc_NtkTopmost	(	Abc_Ntk_t *	pNtk,
		int	nLevels )

extern

Function*************************************************************

Synopsis [Copies the topmost levels of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 548 of file abcStrash.c.

{
    Abc_Ntk_t * pNtkNew;
    Abc_Obj_t * pObjNew, * pObj;
    int LevelCut, i;
    assert( Abc_NtkIsStrash(pNtk) );
    // get the cutoff level
    LevelCut = Abc_MaxInt( 0, Abc_AigLevel(pNtk) - nLevels );
    // start the network
    pNtkNew = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    pNtkNew->pName = Extra_UtilStrsav(pNtk->pName);
    // create PIs below the cut and nodes above the cut
    Abc_NtkCleanCopy( pNtk );
    Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkNew);
    Abc_NtkForEachCo( pNtk, pObj, i )
    {
        pObjNew = Abc_NtkTopmost_rec( pNtkNew, Abc_ObjFanin0(pObj), LevelCut );
        pObjNew = Abc_ObjNotCond( pObjNew, Abc_ObjFaninC0(pObj) );
        Abc_ObjAddFanin( (pObj->pCopy = Abc_NtkCreatePo(pNtkNew)), pObjNew );
    }
    // add the PO node and name
    Abc_NtkAddDummyPiNames( pNtkNew );
    Abc_NtkForEachCo( pNtk, pObj, i )
        Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(pObj), NULL );
    // make sure everything is okay
    if ( !Abc_NtkCheck( pNtkNew ) )
    {
        printf( "Abc_NtkTopmost: The network check has failed.\n" );
        Abc_NtkDelete( pNtkNew );
        return NULL;
    }
    return pNtkNew;
}

Here is the call graph for this function:

◆ Abc_NtkToSop()

ABC_DLL int Abc_NtkToSop	(	Abc_Ntk_t *	pNtk,
		int	fMode,
		int	nCubeLimit )

extern

Function*************************************************************

Synopsis [Convers logic network to the SOP form.]

Description []

SideEffects []

SeeAlso []

Definition at line 1261 of file abcFunc.c.

{
    assert( !Abc_NtkIsStrash(pNtk) );
    if ( Abc_NtkHasBlackbox(pNtk) )
        return 1;
    if ( Abc_NtkHasSop(pNtk) )
    {
        if ( fMode == -1 )
            return 1;
        if ( !Abc_NtkSopToBdd(pNtk) )
            return 0;
        return Abc_NtkBddToSop(pNtk, fMode, nCubeLimit, 1);
    }
    if ( Abc_NtkHasMapping(pNtk) )
        return Abc_NtkMapToSop(pNtk);
    if ( Abc_NtkHasBdd(pNtk) )
        return Abc_NtkBddToSop(pNtk, fMode, nCubeLimit, 1);
    if ( Abc_NtkHasAig(pNtk) )
    {
        if ( !Abc_NtkAigToBdd(pNtk) )
            return 0;
        return Abc_NtkBddToSop(pNtk, fMode, nCubeLimit, 1);
    }
    assert( 0 );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkTransferCopy()

ABC_DLL void Abc_NtkTransferCopy ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis [Adjusts the copy pointers.]

Description [This procedure assumes that the network was transformed into another network, which was in turn transformed into yet another network. It makes the pCopy pointers of the original network point to the objects of the yet another network.]

SideEffects []

SeeAlso []

Definition at line 1962 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( !Abc_ObjIsNet(pObj) )
            pObj->pCopy = pObj->pCopy? Abc_ObjCopyCond(pObj->pCopy) : NULL;
}

Here is the caller graph for this function:

◆ Abc_NtkTransferNameIds()

ABC_DLL void Abc_NtkTransferNameIds	(	Abc_Ntk_t *	p,
		Abc_Ntk_t *	pNew )

extern

Function*************************************************************

Synopsis [Remaps the AIG from the old manager into the new manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 761 of file abcNames.c.

{
    Abc_Obj_t * pObj, * pObjNew;
    int i;
    assert( p->vNameIds != NULL );
    assert( pNew->vNameIds == NULL );
    pNew->vNameIds = Vec_IntStart( Abc_NtkObjNumMax(pNew) );
//    Abc_NtkForEachCi( p, pObj, i )
//        printf( "%d ", Vec_IntEntry(p->vNameIds, Abc_ObjId(pObj)) );
//    printf( "\n" );
    Abc_NtkForEachObj( p, pObj, i )
        if ( pObj->pCopy && i < Vec_IntSize(p->vNameIds) && Vec_IntEntry(p->vNameIds, i) )
        {
            pObjNew = Abc_ObjRegular(pObj->pCopy);
            assert( Abc_ObjNtk(pObjNew) == pNew );
            if ( Abc_ObjIsCi(pObjNew) && !Abc_ObjIsCi(pObj) ) // do not overwrite CI name by internal node name
                continue;
            Vec_IntWriteEntry( pNew->vNameIds, Abc_ObjId(pObjNew), Vec_IntEntry(p->vNameIds, i) ^ Abc_ObjIsComplement(pObj->pCopy) );
        }
}

Here is the caller graph for this function:

◆ Abc_NtkTransferPhases()

ABC_DLL void Abc_NtkTransferPhases	(	Abc_Ntk_t *	pNtkNew,
		Abc_Ntk_t *	pNtk )

extern

Function*************************************************************

Synopsis [Transfers phase information to the new network.]

Description []

SideEffects []

SeeAlso []

Definition at line 2924 of file abcUtil.c.

{
    Abc_Obj_t * pObj;
    int i;
    assert( pNtk->vPhases != NULL );
    assert( Vec_IntSize(pNtk->vPhases) == Abc_NtkObjNumMax(pNtk) );
    assert( pNtkNew->vPhases == NULL );
    pNtkNew->vPhases = Vec_IntStart( Abc_NtkObjNumMax(pNtkNew) );
    Abc_NtkForEachObj( pNtk, pObj, i )
        if ( pObj->pCopy && !Abc_ObjIsNone( (Abc_Obj_t *)pObj->pCopy ) )
            Vec_IntWriteEntry( pNtkNew->vPhases, Abc_ObjId( (Abc_Obj_t *)pObj->pCopy ), Vec_IntEntry(pNtk->vPhases, i) );
}

Here is the caller graph for this function:

◆ Abc_NtkTrasferNames()

ABC_DLL void Abc_NtkTrasferNames	(	Abc_Ntk_t *	pNtk,
		Abc_Ntk_t *	pNtkNew )

extern

Function*************************************************************

Synopsis [Tranfers names to the old network.]

Description [Assumes that the new nodes are attached using pObj->pCopy.]

SideEffects []

SeeAlso []

Definition at line 146 of file abcNames.c.

{
    Abc_Obj_t * pObj;
    int i;
    assert( Abc_NtkPiNum(pNtk) == Abc_NtkPiNum(pNtkNew) );
    assert( Abc_NtkPoNum(pNtk) == Abc_NtkPoNum(pNtkNew) );
    assert( Abc_NtkBoxNum(pNtk) == Abc_NtkBoxNum(pNtkNew) );
    assert( Nm_ManNumEntries(pNtk->pManName) > 0 );
    assert( Nm_ManNumEntries(pNtkNew->pManName) == 0 );
    // copy the CI/CO/box names
    Abc_NtkForEachCi( pNtk, pObj, i )
        Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(Abc_ObjFanout0Ntk(pObj)), NULL );
    Abc_NtkForEachCo( pNtk, pObj, i ) 
        Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(Abc_ObjFanin0Ntk(pObj)), NULL );
    Abc_NtkForEachBox( pNtk, pObj, i ) 
        Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(pObj), NULL );
}

Here is the call graph for this function:

◆ Abc_NtkTrasferNamesNoLatches()

ABC_DLL void Abc_NtkTrasferNamesNoLatches	(	Abc_Ntk_t *	pNtk,
		Abc_Ntk_t *	pNtkNew )

extern

Function*************************************************************

Synopsis [Tranfers names to the old network.]

Description [Assumes that the new nodes are attached using pObj->pCopy.]

SideEffects []

SeeAlso []

Definition at line 175 of file abcNames.c.

{
    Abc_Obj_t * pObj;
    int i;
    assert( Abc_NtkPiNum(pNtk) == Abc_NtkPiNum(pNtkNew) );
    assert( Abc_NtkPoNum(pNtk) == Abc_NtkPoNum(pNtkNew) );
    assert( Nm_ManNumEntries(pNtk->pManName) > 0 );
    assert( Nm_ManNumEntries(pNtkNew->pManName) == 0 );
    // copy the CI/CO/box name and skip latches and theirs inputs/outputs
    Abc_NtkForEachCi( pNtk, pObj, i )
        if ( Abc_ObjFaninNum(pObj) == 0 || !Abc_ObjIsLatch(Abc_ObjFanin0(pObj)) )
            Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(Abc_ObjFanout0Ntk(pObj)), NULL );
    Abc_NtkForEachCo( pNtk, pObj, i ) 
        if ( Abc_ObjFanoutNum(pObj) == 0 || !Abc_ObjIsLatch(Abc_ObjFanout0(pObj)) )
            Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(Abc_ObjFanin0Ntk(pObj)), NULL );
    Abc_NtkForEachBox( pNtk, pObj, i ) 
        if ( !Abc_ObjIsLatch(pObj) )
            Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(pObj), NULL );
}

Here is the call graph for this function:

◆ Abc_NtkUnpermute()

ABC_DLL void Abc_NtkUnpermute ( Abc_Ntk_t * pNtk )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2409 of file abcNtk.c.

{
    Vec_Ptr_t * vTemp, * vTemp2, * vLatch;
    int i, * pInputs, * pOutputs, * pFlops;
    if ( pNtk->vObjPerm == NULL )
    {
        printf( "Abc_NtkUnpermute(): Initial permutation is not available.\n" );
        return;
    }
    assert( Abc_NtkBoxNum(pNtk) == Abc_NtkLatchNum(pNtk) );
    // get reverve permutation
    pInputs  = Vec_IntArray( pNtk->vObjPerm );
    pOutputs = pInputs  + Abc_NtkPiNum(pNtk);
    pFlops   = pOutputs + Abc_NtkPoNum(pNtk);
    // create new PI array
    vTemp = Vec_PtrAlloc( Abc_NtkPiNum(pNtk) );
    for ( i = 0; i < Abc_NtkPiNum(pNtk); i++ )
        Vec_PtrPush( vTemp, Abc_NtkPi(pNtk, pInputs[i]) );
    Vec_PtrFreeP( &pNtk->vPis );
    pNtk->vPis = vTemp;
    // create new PO array
    vTemp = Vec_PtrAlloc( Abc_NtkPoNum(pNtk) );
    for ( i = 0; i < Abc_NtkPoNum(pNtk); i++ )
        Vec_PtrPush( vTemp, Abc_NtkPo(pNtk, pOutputs[i]) );
    Vec_PtrFreeP( &pNtk->vPos );
    pNtk->vPos = vTemp;
    // create new CI/CO arrays
    vTemp  = Vec_PtrDup( pNtk->vPis );
    vTemp2 = Vec_PtrDup( pNtk->vPos );
    vLatch = Vec_PtrAlloc( Abc_NtkLatchNum(pNtk) );
    for ( i = 0; i < Abc_NtkLatchNum(pNtk); i++ )
    {
//printf( "Setting flop %d to be %d.\n", i, pFlops[i] );
        Vec_PtrPush( vTemp,  Abc_NtkCi(pNtk, Abc_NtkPiNum(pNtk) + pFlops[i]) );
        Vec_PtrPush( vTemp2, Abc_NtkCo(pNtk, Abc_NtkPoNum(pNtk) + pFlops[i]) );
        Vec_PtrPush( vLatch, Abc_NtkBox(pNtk, pFlops[i]) );
    }
    Vec_PtrFreeP( &pNtk->vCis );
    Vec_PtrFreeP( &pNtk->vCos );
    Vec_PtrFreeP( &pNtk->vBoxes );
    pNtk->vCis   = vTemp;
    pNtk->vCos   = vTemp2;
    pNtk->vBoxes = vLatch;
    // cleanup
    Vec_IntFreeP( &pNtk->vObjPerm );
}

◆ Abc_NtkUpdate()

ABC_DLL void Abc_NtkUpdate	(	Abc_Obj_t *	pObj,
		Abc_Obj_t *	pObjNew,
		Vec_Vec_t *	vLevels )

extern

Function*************************************************************

Synopsis [Replaces the node and incrementally updates levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 1423 of file abcTiming.c.

{
    // replace the old node by the new node
    pObjNew->Level = pObj->Level;
    Abc_ObjReplace( pObj, pObjNew );
    // update the level of the node
    Abc_NtkUpdateLevel( pObjNew, vLevels );
    Abc_ObjSetReverseLevel( pObjNew, 0 );
    Abc_NtkUpdateReverseLevel( pObjNew, vLevels );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkUpdateLevel()

ABC_DLL void Abc_NtkUpdateLevel	(	Abc_Obj_t *	pObjNew,
		Vec_Vec_t *	vLevels )

extern

Function*************************************************************

Synopsis [Incrementally updates level of the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1322 of file abcTiming.c.

{
    Abc_Obj_t * pFanout, * pTemp;
    int LevelOld, Lev, k, m;
//    int Counter = 0, CounterMax = 0;
    // check if level has changed
    LevelOld = Abc_ObjLevel(pObjNew);
    if ( LevelOld == Abc_ObjLevelNew(pObjNew) )
        return;
    // start the data structure for level update
    // we cannot fail to visit a node when using this structure because the 
    // nodes are stored by their _old_ levels, which are assumed to be correct
    Vec_VecClear( vLevels );
    Vec_VecPush( vLevels, LevelOld, pObjNew );
    pObjNew->fMarkA = 1;
    // recursively update level
    Vec_VecForEachEntryStart( Abc_Obj_t *, vLevels, pTemp, Lev, k, LevelOld )
    {
//        Counter--;
        pTemp->fMarkA = 0;
        assert( Abc_ObjLevel(pTemp) == Lev );
        Abc_ObjSetLevel( pTemp, Abc_ObjLevelNew(pTemp) );
        // if the level did not change, no need to check the fanout levels
        if ( Abc_ObjLevel(pTemp) == Lev )
            continue;
        // schedule fanout for level update
        Abc_ObjForEachFanout( pTemp, pFanout, m )
        {
            if ( !Abc_ObjIsCo(pFanout) && !pFanout->fMarkA )
            {
                assert( Abc_ObjLevel(pFanout) >= Lev );
                Vec_VecPush( vLevels, Abc_ObjLevel(pFanout), pFanout );
//                Counter++;
//                CounterMax = Abc_MaxFloat( CounterMax, Counter );
                pFanout->fMarkA = 1;
            }
        }
    }
//    printf( "%d ", CounterMax );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkUpdateNameIds()

ABC_DLL void Abc_NtkUpdateNameIds ( Abc_Ntk_t * p )

extern

Function*************************************************************

Synopsis [Updates file with name IDs.]

Description []

SideEffects []

SeeAlso []

Definition at line 793 of file abcNames.c.

{
    char pFileName[1000];
    Vec_Int_t * vStarts;
    Abc_Obj_t * pObj;
    FILE * pFile;
    int i, c, iVar, fCompl, fSeenSpace, Counter = 0;
    assert( !Abc_NtkIsNetlist(p) );
    assert( strlen(p->pSpec) < 1000 );
    assert( p->vNameIds != NULL );
    sprintf( pFileName, "%s_%s_names.txt", Extra_FileNameGenericAppend(p->pSpec,""), Extra_FileNameExtension(p->pSpec) );
    pFile = fopen( pFileName, "r+" );
    // collect info about lines
    fSeenSpace = 0;
    vStarts = Vec_IntAlloc( 1000 );
    Vec_IntPush( vStarts, -1 );
    while ( (c = fgetc(pFile)) != EOF && ++Counter )
        if ( c == ' ' && !fSeenSpace )
            Vec_IntPush(vStarts, Counter), fSeenSpace = 1;
        else if ( c == '\n' )
            fSeenSpace = 0;
    // add info about names
    Abc_NtkForEachObj( p, pObj, i )
    {
        if ( i == 0 || i >= Vec_IntSize(p->vNameIds) || !Vec_IntEntry(p->vNameIds, i) )
            continue;
        iVar = Abc_Lit2Var( Vec_IntEntry(p->vNameIds, i) );
        fCompl = Abc_LitIsCompl( Vec_IntEntry(p->vNameIds, i) );
        assert( iVar < Vec_IntSize(vStarts) );
        fseek( pFile, Vec_IntEntry(vStarts, iVar), SEEK_SET );
        fprintf( pFile, "%s%d", fCompl? "-":"", i );
    }
    printf( "Saved %d names into file \"%s\".\n", Vec_IntSize(vStarts)-1, pFileName );
    fclose( pFile );
    Vec_IntFree( vStarts );
    Vec_IntFreeP( &p->vNameIds );
//    Abc_NtkForEachObj( p, pObj, i )
//        Abc_ObjPrint( stdout, pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkUpdateReverseLevel()

ABC_DLL void Abc_NtkUpdateReverseLevel	(	Abc_Obj_t *	pObjNew,
		Vec_Vec_t *	vLevels )

extern

Function*************************************************************

Synopsis [Incrementally updates level of the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1374 of file abcTiming.c.

{
    Abc_Obj_t * pFanin, * pTemp;
    int LevelOld, LevFanin, Lev, k, m;
    // check if level has changed
    LevelOld = Abc_ObjReverseLevel(pObjNew);
    if ( LevelOld == Abc_ObjReverseLevelNew(pObjNew) )
        return;
    // start the data structure for level update
    // we cannot fail to visit a node when using this structure because the 
    // nodes are stored by their _old_ levels, which are assumed to be correct
    Vec_VecClear( vLevels );
    Vec_VecPush( vLevels, LevelOld, pObjNew );
    pObjNew->fMarkA = 1;
    // recursively update level
    Vec_VecForEachEntryStart( Abc_Obj_t *, vLevels, pTemp, Lev, k, LevelOld )
    {
        pTemp->fMarkA = 0;
        LevelOld = Abc_ObjReverseLevel(pTemp); 
        assert( LevelOld == Lev );
        Abc_ObjSetReverseLevel( pTemp, Abc_ObjReverseLevelNew(pTemp) );
        // if the level did not change, no need to check the fanout levels
        if ( Abc_ObjReverseLevel(pTemp) == Lev )
            continue;
        // schedule fanins for level update
        Abc_ObjForEachFanin( pTemp, pFanin, m )
        {
            if ( !Abc_ObjIsCi(pFanin) && !pFanin->fMarkA )
            {
                LevFanin = Abc_ObjReverseLevel( pFanin );
                assert( LevFanin >= Lev );
                Vec_VecPush( vLevels, LevFanin, pFanin );
                pFanin->fMarkA = 1;
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkVerifyGetCleanModel()

ABC_DLL int * Abc_NtkVerifyGetCleanModel	(	Abc_Ntk_t *	pNtk,
		int	nFrames )

extern

Function*************************************************************

Synopsis [Returns a dummy pattern full of zeros.]

Description []

SideEffects []

SeeAlso []

Definition at line 678 of file abcVerify.c.

{
    int * pModel = ABC_ALLOC( int, Abc_NtkCiNum(pNtk) * nFrames );
    memset( pModel, 0, sizeof(int) * Abc_NtkCiNum(pNtk) * nFrames );
    return pModel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkVerifySimulatePattern()

ABC_DLL int * Abc_NtkVerifySimulatePattern	(	Abc_Ntk_t *	pNtk,
		int *	pModel )

extern

Function*************************************************************

Synopsis [Returns the PO values under the given input pattern.]

Description []

SideEffects []

SeeAlso []

Definition at line 696 of file abcVerify.c.

{
    Abc_Obj_t * pNode;
    int * pValues, Value0, Value1, i;
    int fStrashed = 0;
    if ( !Abc_NtkIsStrash(pNtk) )
    {
        pNtk = Abc_NtkStrash(pNtk, 0, 0, 0);
        fStrashed = 1;
    }
/*
    printf( "Counter example: " );
    Abc_NtkForEachCi( pNtk, pNode, i )
        printf( " %d", pModel[i] );
    printf( "\n" );
*/
    // increment the trav ID
    Abc_NtkIncrementTravId( pNtk );
    // set the CI values
    Abc_AigConst1(pNtk)->pCopy = (Abc_Obj_t *)1;
    Abc_NtkForEachCi( pNtk, pNode, i )
        pNode->pCopy = (Abc_Obj_t *)(ABC_PTRINT_T)pModel[i];
    // simulate in the topological order
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        Value0 = ((int)(ABC_PTRINT_T)Abc_ObjFanin0(pNode)->pCopy) ^ (int)Abc_ObjFaninC0(pNode);
        Value1 = ((int)(ABC_PTRINT_T)Abc_ObjFanin1(pNode)->pCopy) ^ (int)Abc_ObjFaninC1(pNode);
        pNode->pCopy = (Abc_Obj_t *)(ABC_PTRINT_T)(Value0 & Value1);
    }
    // fill the output values
    pValues = ABC_ALLOC( int, Abc_NtkCoNum(pNtk) );
    Abc_NtkForEachCo( pNtk, pNode, i )
        pValues[i] = ((int)(ABC_PTRINT_T)Abc_ObjFanin0(pNode)->pCopy) ^ (int)Abc_ObjFaninC0(pNode);
    if ( fStrashed )
        Abc_NtkDelete( pNtk );
    return pValues;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_NtkWriteLogFile()

ABC_DLL void Abc_NtkWriteLogFile	(	char *	pFileName,
		Abc_Cex_t *	pCex,
		int	Status,
		int	nFrames,
		char *	pCommand )

extern

DECLARATIONS ///.

CFile****************************************************************

FileName [abcLog.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Log file printing.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: abcLog.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 68 of file abcLog.c.

{
    FILE * pFile;
    int i;
    pFile = fopen( pFileName, "w" );
    if ( pFile == NULL )
    {
        printf( "Cannot open log file for writing \"%s\".\n" , pFileName );
        return;
    }
    // write <result>
    if ( Status == 1 )
        fprintf( pFile, "snl_UNSAT" );
    else if ( Status == 0 )
        fprintf( pFile, "snl_SAT" );
    else if ( Status == -1 )
        fprintf( pFile, "snl_UNK" );
    else 
        printf( "Abc_NtkWriteLogFile(): Cannot recognize solving status.\n" );
    fprintf( pFile, " " );
    // write <bug_free_depth>
    fprintf( pFile, "%d", nFrames );
    fprintf( pFile, " " );
    // write <engine_name>
    fprintf( pFile, "%s", pCommand ? pCommand : "unknown" );
    if ( pCex && Status == 0 )
        fprintf( pFile, " %d", pCex->iPo );
    // write <cyc>
    if ( pCex && pCex->iFrame != nFrames )
        fprintf( pFile, " %d", pCex->iFrame );
    fprintf( pFile, "\n" );
    // write <INIT_STATE>
    if ( pCex == NULL )
        fprintf( pFile, "NULL" );
    else
    {
        for ( i = 0; i < pCex->nRegs; i++ )
            fprintf( pFile, "%d", Abc_InfoHasBit(pCex->pData,i) );
    }
    fprintf( pFile, "\n" );
    // write <TRACE>
    if ( pCex == NULL )
        fprintf( pFile, "NULL" );
    else
    {
        assert( pCex->nBits - pCex->nRegs == pCex->nPis * (pCex->iFrame + 1) );
        for ( i = pCex->nRegs; i < pCex->nBits; i++ )
            fprintf( pFile, "%d", Abc_InfoHasBit(pCex->pData,i) );
    }
    fprintf( pFile, "\n" );
    fclose( pFile );
}

◆ Abc_ObjAddFanin()

ABC_DLL void Abc_ObjAddFanin	(	Abc_Obj_t *	pObj,
		Abc_Obj_t *	pFanin )

extern

Function*************************************************************

Synopsis [Creates fanout/fanin relationship between the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 84 of file abcFanio.c.

{
    Abc_Obj_t * pFaninR = Abc_ObjRegular(pFanin);
    assert( !Abc_ObjIsComplement(pObj) );
    assert( pObj->pNtk == pFaninR->pNtk );
    assert( pObj->Id >= 0 && pFaninR->Id >= 0 );
    assert( !Abc_ObjIsPi(pObj) && !Abc_ObjIsPo(pFaninR) );    // fanin of PI or fanout of PO
    assert( !Abc_ObjIsCo(pObj) || !Abc_ObjFaninNum(pObj) );  // CO with two fanins
    assert( !Abc_ObjIsNet(pObj) || !Abc_ObjFaninNum(pObj) ); // net with two fanins
    Vec_IntPushMem( pObj->pNtk->pMmStep, &pObj->vFanins,     pFaninR->Id );
    Vec_IntPushMem( pObj->pNtk->pMmStep, &pFaninR->vFanouts, pObj->Id    );
    if ( Abc_ObjIsComplement(pFanin) )
        Abc_ObjSetFaninC( pObj, Abc_ObjFaninNum(pObj)-1 );
}

◆ Abc_ObjAlloc()

ABC_DLL Abc_Obj_t * Abc_ObjAlloc	(	Abc_Ntk_t *	pNtk,
		Abc_ObjType_t	Type )

extern

DECLARATIONS ///.

CFile****************************************************************

FileName [abcObj.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Object creation/duplication/deletion procedures.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: abcObj.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Creates a new object.]

Description []

SideEffects []

SeeAlso []

Definition at line 52 of file abcObj.c.

{
    Abc_Obj_t * pObj;
    if ( pNtk->pMmObj )
        pObj = (Abc_Obj_t *)Mem_FixedEntryFetch( pNtk->pMmObj );
    else
        pObj = (Abc_Obj_t *)ABC_ALLOC( Abc_Obj_t, 1 );
    memset( pObj, 0, sizeof(Abc_Obj_t) );
    pObj->pNtk = pNtk;
    pObj->Type = Type;
    pObj->Id   = -1;
    return pObj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ObjAssignName()

ABC_DLL char * Abc_ObjAssignName	(	Abc_Obj_t *	pObj,
		char *	pName,
		char *	pSuffix )

extern

Function*************************************************************

Synopsis [Assigns the given name to the object.]

Description [The object should not have a name assigned. The same name may be used for several objects, which they share the same net in the original netlist. (For example, latch output and primary output may have the same name.) This procedure returns the pointer to the internally stored representation of the given name.]

SideEffects []

SeeAlso []

Definition at line 69 of file abcNames.c.

{
    assert( pName != NULL );
    return Nm_ManStoreIdName( pObj->pNtk->pManName, pObj->Id, pObj->Type, pName, pSuffix );
}

Here is the call graph for this function:

◆ Abc_ObjDeleteFanin()

ABC_DLL void Abc_ObjDeleteFanin	(	Abc_Obj_t *	pObj,
		Abc_Obj_t *	pFanin )

extern

Function*************************************************************

Synopsis [Destroys fanout/fanin relationship between the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 111 of file abcFanio.c.

{
    assert( !Abc_ObjIsComplement(pObj) );
    assert( !Abc_ObjIsComplement(pFanin) );
    assert( pObj->pNtk == pFanin->pNtk );
    assert( pObj->Id >= 0 && pFanin->Id >= 0 );
    if ( !Vec_IntRemove( &pObj->vFanins, pFanin->Id ) )
    {
        printf( "The obj %d is not found among the fanins of obj %d ...\n", pFanin->Id, pObj->Id );
        return;
    }
    if ( !Vec_IntRemove( &pFanin->vFanouts, pObj->Id ) )
    {
        printf( "The obj %d is not found among the fanouts of obj %d ...\n", pObj->Id, pFanin->Id );
        return;
    }
}

Here is the caller graph for this function:

◆ Abc_ObjFanoutFaninNum()

ABC_DLL int Abc_ObjFanoutFaninNum	(	Abc_Obj_t *	pFanout,
		Abc_Obj_t *	pFanin )

extern

Function*************************************************************

Synopsis [Returns the index of the fanin in the fanin list of the fanout.]

Description []

SideEffects []

SeeAlso []

Definition at line 373 of file abcFanio.c.

{
    Abc_Obj_t * pObj;
    int i;
    Abc_ObjForEachFanin( pFanout, pObj, i )
        if ( pObj == pFanin )
            return i;
    return -1;
}

Here is the caller graph for this function:

◆ Abc_ObjInsertBetween()

ABC_DLL Abc_Obj_t * Abc_ObjInsertBetween	(	Abc_Obj_t *	pNodeIn,
		Abc_Obj_t *	pNodeOut,
		Abc_ObjType_t	Type )

extern

Function*************************************************************

Synopsis [Inserts one-input node of the type specified between the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 251 of file abcFanio.c.

{
    Abc_Obj_t * pNodeNew;
    int iFanoutIndex, iFaninIndex;
    // find pNodeOut among the fanouts of pNodeIn
    if ( (iFanoutIndex = Vec_IntFind( &pNodeIn->vFanouts, pNodeOut->Id )) == -1 )
    {
        printf( "Node %s is not among", Abc_ObjName(pNodeOut) );
        printf( " the fanouts of node %s...\n", Abc_ObjName(pNodeIn) );
        return NULL;
    }
    // find pNodeIn among the fanins of pNodeOut
    if ( (iFaninIndex = Vec_IntFind( &pNodeOut->vFanins, pNodeIn->Id )) == -1 )
    {
        printf( "Node %s is not among", Abc_ObjName(pNodeIn) );
        printf( " the fanins of node %s...\n", Abc_ObjName(pNodeOut) );
        return NULL;
    }
    // create the new node
    pNodeNew = Abc_NtkCreateObj( pNodeIn->pNtk, Type );
    // add pNodeIn as fanin and pNodeOut as fanout
    Vec_IntPushMem( pNodeNew->pNtk->pMmStep, &pNodeNew->vFanins,  pNodeIn->Id  );
    Vec_IntPushMem( pNodeNew->pNtk->pMmStep, &pNodeNew->vFanouts, pNodeOut->Id );
    // update the fanout of pNodeIn
    Vec_IntWriteEntry( &pNodeIn->vFanouts, iFanoutIndex, pNodeNew->Id );
    // update the fanin of pNodeOut
    Vec_IntWriteEntry( &pNodeOut->vFanins, iFaninIndex, pNodeNew->Id );
    return pNodeNew;
}

Here is the call graph for this function:

◆ Abc_ObjLevelNew()

ABC_DLL int Abc_ObjLevelNew ( Abc_Obj_t * pObj )

extern

Function*************************************************************

Synopsis [Computes the level of the node using its fanin levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 1170 of file abcTiming.c.

{
    Abc_Obj_t * pFanin;
    int i, Level = 0;
    Abc_ObjForEachFanin( pObj, pFanin, i )
        Level = Abc_MaxFloat( Level, Abc_ObjLevel(pFanin) );
    return Level + (int)(Abc_ObjFaninNum(pObj) > 0);
}

Here is the caller graph for this function:

◆ Abc_ObjName()

ABC_DLL char * Abc_ObjName ( Abc_Obj_t * pObj )

extern

DECLARATIONS ///.

CFile****************************************************************

FileName [abcNames.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Procedures working with net and node names.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: abcNames.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Returns the unique name for the object.]

Description [If the name previously did not exist, creates a new unique name but does not assign this name to the object. The temporary unique name is stored in a static buffer inside this procedure. It is important that the name is used before the function is called again!]

SideEffects []

SeeAlso []

Definition at line 49 of file abcNames.c.

{
    return Nm_ManCreateUniqueName( pObj->pNtk->pManName, pObj->Id );
}

Here is the call graph for this function:

◆ Abc_ObjNameDummy()

ABC_DLL char * Abc_ObjNameDummy	(	char *	pPrefix,
		int	Num,
		int	nDigits )

extern

Function*************************************************************

Synopsis [Returns the dummy PI name.]

Description []

SideEffects []

SeeAlso []

Definition at line 122 of file abcNames.c.

{
    static char Buffer[2000];
    sprintf( Buffer, "%s%0*d", pPrefix, nDigits, Num );
    return Buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ObjNamePrefix()

ABC_DLL char * Abc_ObjNamePrefix	(	Abc_Obj_t *	pObj,
		char *	pPrefix )

extern

Function*************************************************************

Synopsis [Appends name to the prefix]

Description []

SideEffects []

SeeAlso []

Definition at line 86 of file abcNames.c.

{
    static char Buffer[2000];
    sprintf( Buffer, "%s%s", pPrefix, Abc_ObjName(pObj) );
    return Buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ObjNameSuffix()

ABC_DLL char * Abc_ObjNameSuffix	(	Abc_Obj_t *	pObj,
		char *	pSuffix )

extern

Function*************************************************************

Synopsis [Appends suffic to the name.]

Description []

SideEffects []

SeeAlso []

Definition at line 104 of file abcNames.c.

{
    static char Buffer[2000];
    sprintf( Buffer, "%s%s", Abc_ObjName(pObj), pSuffix );
    return Buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ObjPatchFanin()

ABC_DLL void Abc_ObjPatchFanin	(	Abc_Obj_t *	pObj,
		Abc_Obj_t *	pFaninOld,
		Abc_Obj_t *	pFaninNew )

extern

Function*************************************************************

Synopsis [Replaces a fanin of the node.]

Description [The node is pObj. An old fanin of this node (pFaninOld) has to be replaced by a new fanin (pFaninNew). Assumes that the node and the old fanin are not complemented. The new fanin can be complemented. In this case, the polarity of the new fanin will change, compared to the polarity of the old fanin.]

SideEffects []

SeeAlso []

Definition at line 172 of file abcFanio.c.

{
    Abc_Obj_t * pFaninNewR = Abc_ObjRegular(pFaninNew);
    int iFanin;//, nLats;//, fCompl;
    assert( !Abc_ObjIsComplement(pObj) );
    assert( !Abc_ObjIsComplement(pFaninOld) );
    assert( pFaninOld != pFaninNewR );
//    assert( pObj != pFaninOld );
//    assert( pObj != pFaninNewR );
    assert( pObj->pNtk == pFaninOld->pNtk );
    assert( pObj->pNtk == pFaninNewR->pNtk );
    if ( (iFanin = Vec_IntFind( &pObj->vFanins, pFaninOld->Id )) == -1 )
    {
        printf( "Node %s is not among", Abc_ObjName(pFaninOld) );
        printf( " the fanins of node %s...\n", Abc_ObjName(pObj) );
        return;
    }
 
    // remember the attributes of the old fanin
//    fCompl = Abc_ObjFaninC(pObj, iFanin);
    // replace the old fanin entry by the new fanin entry (removes attributes)
    Vec_IntWriteEntry( &pObj->vFanins, iFanin, pFaninNewR->Id );
    // set the attributes of the new fanin
//    if ( fCompl ^ Abc_ObjIsComplement(pFaninNew) )
//        Abc_ObjSetFaninC( pObj, iFanin );
    if ( Abc_ObjIsComplement(pFaninNew) )
        Abc_ObjXorFaninC( pObj, iFanin );
 
//    if ( Abc_NtkIsSeq(pObj->pNtk) && (nLats = Seq_ObjFaninL(pObj, iFanin)) )
//        Seq_ObjSetFaninL( pObj, iFanin, nLats );
    // update the fanout of the fanin
    if ( !Vec_IntRemove( &pFaninOld->vFanouts, pObj->Id ) )
    {
        printf( "Node %s is not among", Abc_ObjName(pObj) );
        printf( " the fanouts of its old fanin %s...\n", Abc_ObjName(pFaninOld) );
//        return;
    }
    Vec_IntPushMem( pObj->pNtk->pMmStep, &pFaninNewR->vFanouts, pObj->Id );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ObjPatchFanoutFanin()

ABC_DLL void Abc_ObjPatchFanoutFanin	(	Abc_Obj_t *	pObj,
		int	iObjNew )

extern

Function*************************************************************

Synopsis [Replaces pObj by iObjNew in the fanin arrays of the fanouts.]

Description []

SideEffects []

SeeAlso []

Definition at line 223 of file abcFanio.c.

{
    Abc_Obj_t * pFanout;
    int i, k, Entry;
    // update fanouts of the node to point to this one
    Abc_ObjForEachFanout( pObj, pFanout, i )
    {
        Vec_IntForEachEntry( &pFanout->vFanins, Entry, k )
            if ( Entry == (int)Abc_ObjId(pObj) )
            {
                Vec_IntWriteEntry( &pFanout->vFanins, k, iObjNew );
                break;
            }
        assert( k < Vec_IntSize(&pFanout->vFanins) );
    }
}

◆ Abc_ObjPointerCompare()

ABC_DLL int Abc_ObjPointerCompare	(	void **	pp1,
		void **	pp2 )

extern

Function*************************************************************

Synopsis [Compares the pointers.]

Description []

SideEffects []

SeeAlso []

Definition at line 1939 of file abcUtil.c.

{
    if ( *pp1 < *pp2 )
        return -1;
    if ( *pp1 > *pp2 ) 
        return 1;
    return 0; 
}

Here is the caller graph for this function:

◆ Abc_ObjPrint()

ABC_DLL void Abc_ObjPrint	(	FILE *	pFile,
		Abc_Obj_t *	pObj )

extern

Function*************************************************************

Synopsis [Prints information about the object.]

Description []

SideEffects []

SeeAlso []

Definition at line 1674 of file abcPrint.c.

{
    Abc_Obj_t * pFanin;
    int i;
    fprintf( pFile, "Object %5d : ", pObj->Id );
    switch ( pObj->Type )
    {
        case ABC_OBJ_NONE:
            fprintf( pFile, "NONE   " );
            break;
        case ABC_OBJ_CONST1:
            fprintf( pFile, "Const1 " );
            break;
        case ABC_OBJ_PI:
            fprintf( pFile, "PI     " );
            break;
        case ABC_OBJ_PO:
            fprintf( pFile, "PO     " );
            break;
        case ABC_OBJ_BI:
            fprintf( pFile, "BI     " );
            break;
        case ABC_OBJ_BO:
            fprintf( pFile, "BO     " );
            break;
        case ABC_OBJ_NET:
            fprintf( pFile, "Net    " );
            break;
        case ABC_OBJ_NODE:
            fprintf( pFile, "Node   " );
            break;
        case ABC_OBJ_LATCH:
            fprintf( pFile, "Latch  " );
            break;
        case ABC_OBJ_WHITEBOX:
            fprintf( pFile, "Whitebox" );
            break;
        case ABC_OBJ_BLACKBOX:
            fprintf( pFile, "Blackbox" );
            break;
        default:
            assert(0);
            break;
    }
    // print the fanins
    fprintf( pFile, " Fanins ( " );
    Abc_ObjForEachFanin( pObj, pFanin, i )
        fprintf( pFile, "%d ", pFanin->Id );
    fprintf( pFile, ") " );
/*
    fprintf( pFile, " Fanouts ( " );
    Abc_ObjForEachFanout( pObj, pFanin, i )
        fprintf( pFile, "%d(%c) ", pFanin->Id, Abc_NodeIsTravIdCurrent(pFanin)? '+' : '-' );
    fprintf( pFile, ") " );
*/
    // print the logic function
    if ( Abc_ObjIsNode(pObj) && Abc_NtkIsSopLogic(pObj->pNtk) )
        fprintf( pFile, " %s", (char*)pObj->pData );
    else if ( Abc_ObjIsNode(pObj) && Abc_NtkIsMappedLogic(pObj->pNtk) )
        fprintf( pFile, " %s\n", Mio_GateReadName((Mio_Gate_t *)pObj->pData) );
    else
        fprintf( pFile, "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ObjRecycle()

ABC_DLL void Abc_ObjRecycle ( Abc_Obj_t * pObj )

extern

Function*************************************************************

Synopsis [Recycles the object.]

Description []

SideEffects []

SeeAlso []

Definition at line 77 of file abcObj.c.

{
    Abc_Ntk_t * pNtk = pObj->pNtk;
//    int LargePiece = (4 << ABC_NUM_STEPS);
    // free large fanout arrays
//    if ( pNtk->pMmStep && pObj->vFanouts.nCap * 4 > LargePiece )
//        free( pObj->vFanouts.pArray );
    if ( pNtk->pMmStep == NULL )
    {
        ABC_FREE( pObj->vFanouts.pArray );
        ABC_FREE( pObj->vFanins.pArray );
    }
    // clean the memory to make deleted object distinct from the live one
    memset( pObj, 0, sizeof(Abc_Obj_t) );
    // recycle the object
    if ( pNtk->pMmObj )
        Mem_FixedEntryRecycle( pNtk->pMmObj, (char *)pObj );
    else
        ABC_FREE( pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ObjRemoveFanins()

ABC_DLL void Abc_ObjRemoveFanins ( Abc_Obj_t * pObj )

extern

Function*************************************************************

Synopsis [Destroys fanout/fanin relationship between the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 141 of file abcFanio.c.

{
    Vec_Int_t * vFaninsOld;
    Abc_Obj_t * pFanin;
    int k;
    // remove old fanins
    vFaninsOld = &pObj->vFanins;
    for ( k = vFaninsOld->nSize - 1; k >= 0; k-- )
    {
        pFanin = Abc_NtkObj( pObj->pNtk, vFaninsOld->pArray[k] );
        Abc_ObjDeleteFanin( pObj, pFanin );
    }
    pObj->fCompl0 = 0;
    pObj->fCompl1 = 0;
    assert( vFaninsOld->nSize == 0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ObjReplace()

ABC_DLL void Abc_ObjReplace	(	Abc_Obj_t *	pNodeOld,
		Abc_Obj_t *	pNodeNew )

extern

Function*************************************************************

Synopsis [Replaces the node by a new node.]

Description []

SideEffects []

SeeAlso []

Definition at line 325 of file abcFanio.c.

{
    assert( !Abc_ObjIsComplement(pNodeOld) );
    assert( !Abc_ObjIsComplement(pNodeNew) );
    assert( pNodeOld->pNtk == pNodeNew->pNtk );
    assert( pNodeOld != pNodeNew );
    assert( Abc_ObjFanoutNum(pNodeOld) > 0 );
    // transfer the fanouts to the old node
    Abc_ObjTransferFanout( pNodeOld, pNodeNew );
    // remove the old node
    Abc_NtkDeleteObj_rec( pNodeOld, 1 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ObjReplaceByConstant()

ABC_DLL void Abc_ObjReplaceByConstant	(	Abc_Obj_t *	pNode,
		int	fConst1 )

extern

Function*************************************************************

Synopsis [Replaces a node by a constant.]

Description []

SideEffects []

SeeAlso []

Definition at line 349 of file abcFanio.c.

{
    Abc_Obj_t * pNodeNew;
    assert( Abc_NtkIsLogic(pNode->pNtk) );
    assert( !Abc_ObjIsCo(pNode) );
    pNodeNew = fConst1 ? Abc_NtkCreateNodeConst1(pNode->pNtk) : Abc_NtkCreateNodeConst0(pNode->pNtk);
    // transfer the fanouts to the old node
    Abc_ObjTransferFanout( pNode, pNodeNew );
    // remove the old node
    if ( Abc_ObjIsNode(pNode) )
        Abc_NtkDeleteObj_rec( pNode, 1 );
}

Here is the call graph for this function:

◆ Abc_ObjRequiredLevel()

ABC_DLL int Abc_ObjRequiredLevel ( Abc_Obj_t * pObj )

extern

Function*************************************************************

Synopsis [Returns required level of the node.]

Description [Converts the reverse levels of the node into its required level as follows: ReqLevel(Node) = MaxLevels(Ntk) + 1 - LevelR(Node).]

SideEffects []

SeeAlso []

Definition at line 1214 of file abcTiming.c.

{
    Abc_Ntk_t * pNtk = pObj->pNtk;
    assert( pNtk->vLevelsR );
    return pNtk->LevelMax + 1 - Abc_ObjReverseLevel(pObj);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ObjReverseLevel()

ABC_DLL int Abc_ObjReverseLevel ( Abc_Obj_t * pObj )

extern

Function*************************************************************

Synopsis [Returns the reverse level of the node.]

Description [The reverse level is the level of the node in reverse topological order, starting from the COs.]

SideEffects []

SeeAlso []

Definition at line 1233 of file abcTiming.c.

{
    Abc_Ntk_t * pNtk = pObj->pNtk;
    assert( pNtk->vLevelsR );
    Vec_IntFillExtra( pNtk->vLevelsR, pObj->Id + 1, 0 );
    return Vec_IntEntry(pNtk->vLevelsR, pObj->Id);
}

Here is the caller graph for this function:

◆ Abc_ObjReverseLevelNew()

ABC_DLL int Abc_ObjReverseLevelNew ( Abc_Obj_t * pObj )

extern

Function*************************************************************

Synopsis [Computes the reverse level of the node using its fanout levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 1190 of file abcTiming.c.

{
    Abc_Obj_t * pFanout;
    int i, LevelCur, Level = 0;
    Abc_ObjForEachFanout( pObj, pFanout, i )
    {
        LevelCur = Abc_ObjReverseLevel( pFanout );
        Level = Abc_MaxFloat( Level, LevelCur );
    }
    return Level + 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_ObjSetReverseLevel()

ABC_DLL void Abc_ObjSetReverseLevel	(	Abc_Obj_t *	pObj,
		int	LevelR )

extern

Function*************************************************************

Synopsis [Sets the reverse level of the node.]

Description [The reverse level is the level of the node in reverse topological order, starting from the COs.]

SideEffects []

SeeAlso []

Definition at line 1253 of file abcTiming.c.

{
    Abc_Ntk_t * pNtk = pObj->pNtk;
    assert( pNtk->vLevelsR );
    Vec_IntFillExtra( pNtk->vLevelsR, pObj->Id + 1, 0 );
    Vec_IntWriteEntry( pNtk->vLevelsR, pObj->Id, LevelR );
}

Here is the caller graph for this function:

◆ Abc_ObjTransferFanout()

ABC_DLL void Abc_ObjTransferFanout	(	Abc_Obj_t *	pNodeFrom,
		Abc_Obj_t *	pNodeTo )

extern

Function*************************************************************

Synopsis [Transfers fanout from the old node to the new node.]

Description []

SideEffects []

SeeAlso []

Definition at line 292 of file abcFanio.c.

{
    Vec_Ptr_t * vFanouts;
    int nFanoutsOld, i;
    assert( !Abc_ObjIsComplement(pNodeFrom) );
    assert( !Abc_ObjIsComplement(pNodeTo) );
    assert( !Abc_ObjIsPo(pNodeFrom) && !Abc_ObjIsPo(pNodeTo) );
    assert( pNodeFrom->pNtk == pNodeTo->pNtk );
    assert( pNodeFrom != pNodeTo );
    assert( !Abc_ObjIsNode(pNodeFrom) || Abc_ObjFanoutNum(pNodeFrom) > 0 );
    // get the fanouts of the old node
    nFanoutsOld = Abc_ObjFanoutNum(pNodeTo);
    vFanouts = Vec_PtrAlloc( nFanoutsOld );
    Abc_NodeCollectFanouts( pNodeFrom, vFanouts );
    // patch the fanin of each of them
    for ( i = 0; i < vFanouts->nSize; i++ )
        Abc_ObjPatchFanin( (Abc_Obj_t *)vFanouts->pArray[i], pNodeFrom, pNodeTo );
    assert( Abc_ObjFanoutNum(pNodeFrom) == 0 );
    assert( Abc_ObjFanoutNum(pNodeTo) == nFanoutsOld + vFanouts->nSize );
    Vec_PtrFree( vFanouts );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCheck()

ABC_DLL int Abc_SopCheck	(	char *	pSop,
		int	nFanins )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 871 of file abcSop.c.

{
    char * pCubes, * pCubesOld;
    int fFound0 = 0, fFound1 = 0;
 
    // check the logic function of the node
    for ( pCubes = pSop; *pCubes; pCubes++ )
    {
        // get the end of the next cube
        for ( pCubesOld = pCubes; *pCubes != ' '; pCubes++ );
        // compare the distance
        if ( pCubes - pCubesOld != nFanins )
        {
            fprintf( stdout, "Abc_SopCheck: SOP has a mismatch between its cover size (%d) and its fanin number (%d).\n",
                (int)(ABC_PTRDIFF_T)(pCubes - pCubesOld), nFanins );
            return 0;
        }
        // check the output values for this cube
        pCubes++;
        if ( *pCubes == '0' )
            fFound0 = 1;
        else if ( *pCubes == '1' )
            fFound1 = 1;
        else if ( *pCubes != 'x' && *pCubes != 'n' )
        {
            fprintf( stdout, "Abc_SopCheck: SOP has a strange character (%c) in the output part of its cube.\n", *pCubes );
            return 0;
        }
        // check the last symbol (new line)
        pCubes++;
        if ( *pCubes != '\n' )
        {
            fprintf( stdout, "Abc_SopCheck: SOP has a cube without new line in the end.\n" );
            return 0;
        }
    }
    if ( fFound0 && fFound1 )
    {
        fprintf( stdout, "Abc_SopCheck: SOP has cubes in both phases.\n" );
        return 0;
    }
    return 1;
}

◆ Abc_SopComplement()

ABC_DLL void Abc_SopComplement ( char * pSop )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 648 of file abcSop.c.

{
    char * pCur;
    for ( pCur = pSop; *pCur; pCur++ )
        if ( *pCur == '\n' )
        {
            if ( *(pCur - 1) == '0' )
                *(pCur - 1) = '1';
            else if ( *(pCur - 1) == '1' )
                *(pCur - 1) = '0';
            else if ( *(pCur - 1) == 'x' )
                *(pCur - 1) = 'n';
            else if ( *(pCur - 1) == 'n' )
                *(pCur - 1) = 'x';
            else
                assert( 0 );
        }
}

Here is the caller graph for this function:

◆ Abc_SopComplementVar()

ABC_DLL void Abc_SopComplementVar	(	char *	pSop,
		int	iVar )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 678 of file abcSop.c.

{
    char * pCube;
    int nVars = Abc_SopGetVarNum(pSop);
    assert( iVar < nVars );
    Abc_SopForEachCube( pSop, nVars, pCube )
    {
        if ( pCube[iVar] == '0' )
            pCube[iVar] = '1';
        else if ( pCube[iVar] == '1' )
            pCube[iVar] = '0';
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateAnd()

ABC_DLL char * Abc_SopCreateAnd	(	Mem_Flex_t *	pMan,
		int	nVars,
		int *	pfCompl )

extern

Function*************************************************************

Synopsis [Creates the multi-input AND cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 168 of file abcSop.c.

{
    char * pSop;
    int i;
    pSop = Abc_SopStart( pMan, 1, nVars );
    for ( i = 0; i < nVars; i++ )
        pSop[i] = '1' - (pfCompl? pfCompl[i] : 0);
    pSop[nVars + 1] = '1';
    return pSop;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateAnd2()

ABC_DLL char * Abc_SopCreateAnd2	(	Mem_Flex_t *	pMan,
		int	fCompl0,
		int	fCompl1 )

extern

Function*************************************************************

Synopsis [Creates the AND2 cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 145 of file abcSop.c.

{
    char Buffer[6];
    Buffer[0] = '1' - fCompl0;
    Buffer[1] = '1' - fCompl1;
    Buffer[2] = ' ';
    Buffer[3] = '1';
    Buffer[4] = '\n';
    Buffer[5] = 0;
    return Abc_SopRegister( pMan, Buffer );
}

Here is the call graph for this function:

◆ Abc_SopCreateBuf()

ABC_DLL char * Abc_SopCreateBuf ( Mem_Flex_t * pMan )

extern

Function*************************************************************

Synopsis [Creates the buf cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 367 of file abcSop.c.

{
    return Abc_SopRegister(pMan, "1 1\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateConst0()

ABC_DLL char * Abc_SopCreateConst0 ( Mem_Flex_t * pMan )

extern

Function*************************************************************

Synopsis [Creates the constant 1 cover with 0 variables.]

Description []

SideEffects []

SeeAlso []

Definition at line 129 of file abcSop.c.

{
    return Abc_SopRegister( pMan, " 0\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateConst1()

ABC_DLL char * Abc_SopCreateConst1 ( Mem_Flex_t * pMan )

extern

Function*************************************************************

Synopsis [Creates the constant 1 cover with 0 variables.]

Description []

SideEffects []

SeeAlso []

Definition at line 113 of file abcSop.c.

{
    return Abc_SopRegister( pMan, " 1\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateFromIsop()

ABC_DLL char * Abc_SopCreateFromIsop	(	Mem_Flex_t *	pMan,
		int	nVars,
		Vec_Int_t *	vCover )

extern

Function*************************************************************

Synopsis [Creates the cover from the ISOP computed from TT.]

Description []

SideEffects []

SeeAlso []

Definition at line 424 of file abcSop.c.

{
    char * pSop, * pCube;
    int i, k, Entry, Literal;
    assert( Vec_IntSize(vCover) > 0 );
    if ( Vec_IntSize(vCover) == 0 )
        return NULL;
    // start the cover
    pSop = Abc_SopStart( pMan, Vec_IntSize(vCover), nVars );
    // create cubes
    Vec_IntForEachEntry( vCover, Entry, i )
    {
        pCube = pSop + i * (nVars + 3);
        for ( k = 0; k < nVars; k++ )
        {
            Literal = 3 & (Entry >> (k << 1));
            if ( Literal == 1 )
                pCube[k] = '0';
            else if ( Literal == 2 )
                pCube[k] = '1';
            else if ( Literal != 0 )
                assert( 0 );
        }
    }
    return pSop;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateFromTruth()

ABC_DLL char * Abc_SopCreateFromTruth	(	Mem_Flex_t *	pMan,
		int	nVars,
		unsigned *	pTruth )

extern

Function*************************************************************

Synopsis [Creates the arbitrary cover from the truth table.]

Description []

SideEffects []

SeeAlso []

Definition at line 383 of file abcSop.c.

{
    char * pSop, * pCube;
    int nMints, Counter, i, k;
    if ( nVars == 0 )
        return pTruth[0] ? Abc_SopCreateConst1(pMan) : Abc_SopCreateConst0(pMan);
    // count the number of true minterms
    Counter = 0;
    nMints = (1 << nVars);
    for ( i = 0; i < nMints; i++ )
        Counter += ((pTruth[i>>5] & (1 << (i&31))) > 0);
    // SOP is not well-defined if the truth table is constant 0
    assert( Counter > 0 );
    if ( Counter == 0 )
        return NULL;
    // start the cover
    pSop = Abc_SopStart( pMan, Counter, nVars );
    // create true minterms
    Counter = 0;
    for ( i = 0; i < nMints; i++ )
        if ( (pTruth[i>>5] & (1 << (i&31))) > 0 )
        {
            pCube = pSop + Counter * (nVars + 3);
            for ( k = 0; k < nVars; k++ )
                pCube[k] = '0' + ((i & (1 << k)) > 0);
            Counter++;
        }
    return pSop;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateFromTruthIsop()

ABC_DLL char * Abc_SopCreateFromTruthIsop	(	Mem_Flex_t *	pMan,
		int	nVars,
		word *	pTruth,
		Vec_Int_t *	vCover )

extern

Function*************************************************************

Synopsis [Creates the cover from the ISOP computed from TT.]

Description []

SideEffects []

SeeAlso []

Definition at line 462 of file abcSop.c.

{
    char * pSop = NULL;
    int w, nWords  = Abc_Truth6WordNum( nVars );
    assert( nVars < 16 );
 
    for ( w = 0; w < nWords; w++ )
        if ( pTruth[w] )
            break;
    if ( w == nWords )
        return Abc_SopRegister( pMan, " 0\n" );
 
    for ( w = 0; w < nWords; w++ )
        if ( ~pTruth[w] )
            break;
    if ( w == nWords )
        return Abc_SopRegister( pMan, " 1\n" );
 
    {
        int RetValue = Kit_TruthIsop( (unsigned *)pTruth, nVars, vCover, 1 );
        assert( nVars > 0 );
        assert( RetValue == 0 || RetValue == 1 );
        pSop = Abc_SopCreateFromIsop( pMan, nVars, vCover );
        if ( RetValue )
            Abc_SopComplement( pSop );
    }
    return pSop;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateInv()

ABC_DLL char * Abc_SopCreateInv ( Mem_Flex_t * pMan )

extern

Function*************************************************************

Synopsis [Creates the inv cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 351 of file abcSop.c.

{
    return Abc_SopRegister(pMan, "0 1\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateMux()

ABC_DLL char * Abc_SopCreateMux ( Mem_Flex_t * pMan )

extern

Function*************************************************************

Synopsis [Creates the MUX cover.]

Description [The first input of MUX is the control. The second input is DATA1. The third input is DATA0.]

SideEffects []

SeeAlso []

Definition at line 335 of file abcSop.c.

{
    return Abc_SopRegister(pMan, "11- 1\n0-1 1\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateNand()

ABC_DLL char * Abc_SopCreateNand	(	Mem_Flex_t *	pMan,
		int	nVars )

extern

Function*************************************************************

Synopsis [Creates the multi-input NAND cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 190 of file abcSop.c.

{
    char * pSop;
    int i;
    pSop = Abc_SopStart( pMan, 1, nVars );
    for ( i = 0; i < nVars; i++ )
        pSop[i] = '1';
    pSop[nVars + 1] = '0';
    return pSop;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateNor()

ABC_DLL char * Abc_SopCreateNor	(	Mem_Flex_t *	pMan,
		int	nVars )

extern

Function*************************************************************

Synopsis [Creates the multi-input NOR cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 259 of file abcSop.c.

{
    char * pSop;
    int i;
    pSop = Abc_SopStart( pMan, 1, nVars );
    for ( i = 0; i < nVars; i++ )
        pSop[i] = '0';
    return pSop;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateNxor()

ABC_DLL char * Abc_SopCreateNxor	(	Mem_Flex_t *	pMan,
		int	nVars )

extern

Function*************************************************************

Synopsis [Creates the multi-input XNOR cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 317 of file abcSop.c.

{
    assert( nVars == 2 );
    return Abc_SopRegister(pMan, "11 1\n00 1\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateOr()

ABC_DLL char * Abc_SopCreateOr	(	Mem_Flex_t *	pMan,
		int	nVars,
		int *	pfCompl )

extern

Function*************************************************************

Synopsis [Creates the multi-input OR cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 212 of file abcSop.c.

{
    char * pSop;
    int i;
    pSop = Abc_SopStart( pMan, 1, nVars );
    for ( i = 0; i < nVars; i++ )
        pSop[i] = '0' + (pfCompl? pfCompl[i] : 0);
    pSop[nVars + 1] = '0';
    return pSop;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateOrMultiCube()

ABC_DLL char * Abc_SopCreateOrMultiCube	(	Mem_Flex_t *	pMan,
		int	nVars,
		int *	pfCompl )

extern

Function*************************************************************

Synopsis [Creates the multi-input OR cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 234 of file abcSop.c.

{
    char * pSop, * pCube;
    int i;
    pSop = Abc_SopStart( pMan, nVars, nVars );
    i = 0;
    Abc_SopForEachCube( pSop, nVars, pCube )
    {
        pCube[i] = '1' - (pfCompl? pfCompl[i] : 0);
        i++;
    }
    return pSop;
}

Here is the call graph for this function:

◆ Abc_SopCreateXor()

ABC_DLL char * Abc_SopCreateXor	(	Mem_Flex_t *	pMan,
		int	nVars )

extern

Function*************************************************************

Synopsis [Creates the multi-input XOR cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 280 of file abcSop.c.

{
    assert( nVars == 2 );
    return Abc_SopRegister(pMan, "01 1\n10 1\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopCreateXorSpecial()

ABC_DLL char * Abc_SopCreateXorSpecial	(	Mem_Flex_t *	pMan,
		int	nVars )

extern

Function*************************************************************

Synopsis [Creates the multi-input XOR cover (special case).]

Description []

SideEffects []

SeeAlso []

Definition at line 297 of file abcSop.c.

{
    char * pSop;
    pSop = Abc_SopCreateAnd( pMan, nVars, NULL );
    pSop[nVars+1] = 'x';
    assert( pSop[nVars+2] == '\n' );
    return pSop;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopDecoderLog()

ABC_DLL char * Abc_SopDecoderLog	(	Mem_Flex_t *	pMan,
		int	nValues )

extern

Function*************************************************************

Synopsis [Creates the decover node.]

Description [Produces MV-SOP for BLIF-MV representation.]

SideEffects []

SeeAlso []

Definition at line 1280 of file abcSop.c.

{
    char * pResult;
    Vec_Str_t * vSop;
    int i, b, nBits = Abc_Base2Log(nValues);
    assert( nValues > 1 && nValues <= (1<<nBits) );
    vSop = Vec_StrAlloc( 100 );
    for ( i = 0; i < nValues; i++ )
    {
        for ( b = 0; b < nBits; b++ )
        {
            Vec_StrPrintNum( vSop, (int)((i & (1 << b)) > 0) );
            Vec_StrPush( vSop, ' ' );
        }
        Vec_StrPrintNum( vSop, i );
        Vec_StrPush( vSop, '\n' );
    }
    Vec_StrPush( vSop, 0 );
    pResult = Abc_SopRegister( pMan, Vec_StrArray(vSop) );
    Vec_StrFree( vSop );
    return pResult;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopDecoderPos()

ABC_DLL char * Abc_SopDecoderPos	(	Mem_Flex_t *	pMan,
		int	nValues )

extern

Function*************************************************************

Synopsis [Creates the decoder node.]

Description [Produces MV-SOP for BLIF-MV representation.]

SideEffects []

SeeAlso []

Definition at line 1244 of file abcSop.c.

{
    char * pResult;
    Vec_Str_t * vSop;
    int i, k;
    assert( nValues > 1 );
    vSop = Vec_StrAlloc( 100 );
    for ( i = 0; i < nValues; i++ )
    {
        for ( k = 0; k < nValues; k++ )
        {
            if ( k == i )
                Vec_StrPrintStr( vSop, "1 " );
            else
                Vec_StrPrintStr( vSop, "- " );
        }
        Vec_StrPrintNum( vSop, i );
        Vec_StrPush( vSop, '\n' );
    }
    Vec_StrPush( vSop, 0 );
    pResult = Abc_SopRegister( pMan, Vec_StrArray(vSop) );
    Vec_StrFree( vSop );
    return pResult;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopEncoderLog()

ABC_DLL char * Abc_SopEncoderLog	(	Mem_Flex_t *	pMan,
		int	iBit,
		int	nValues )

extern

Function*************************************************************

Synopsis [Creates one encoder node.]

Description [Produces MV-SOP for BLIF-MV representation.]

SideEffects []

SeeAlso []

Definition at line 1200 of file abcSop.c.

{
    char * pResult;
    Vec_Str_t * vSop;
    int v, Counter, fFirst = 1, nBits = Abc_Base2Log(nValues);
    assert( iBit < nBits );
    // count the number of literals
    Counter = 0;
    for ( v = 0; v < nValues; v++ )
        Counter += ( (v & (1 << iBit)) > 0 );
    // create the cover
    vSop = Vec_StrAlloc( 100 );
    Vec_StrPrintStr( vSop, "d0\n" );
    if ( Counter > 1 )
        Vec_StrPrintStr( vSop, "(" );
    for ( v = 0; v < nValues; v++ )
        if ( v & (1 << iBit) )
        {
            if ( fFirst )
                fFirst = 0;
            else
                Vec_StrPush( vSop, ',' );
            Vec_StrPrintNum( vSop, v );
        }
    if ( Counter > 1 )
        Vec_StrPrintStr( vSop, ")" );
    Vec_StrPrintStr( vSop, " 1\n" );
    Vec_StrPush( vSop, 0 );
    pResult = Abc_SopRegister( pMan, Vec_StrArray(vSop) );
    Vec_StrFree( vSop );
    return pResult;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopEncoderPos()

ABC_DLL char * Abc_SopEncoderPos	(	Mem_Flex_t *	pMan,
		int	iValue,
		int	nValues )

extern

Function*************************************************************

Synopsis [Creates one encoder node.]

Description [Produces MV-SOP for BLIF-MV representation.]

SideEffects []

SeeAlso []

Definition at line 1181 of file abcSop.c.

{
    char Buffer[32];
    assert( iValue < nValues );
    sprintf( Buffer, "d0\n%d 1\n", iValue );
    return Abc_SopRegister( pMan, Buffer );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopFromTruthBin()

ABC_DLL char * Abc_SopFromTruthBin ( char * pTruth )

extern

Function*************************************************************

Synopsis [Derives SOP from the truth table representation.]

Description [Truth table is expected to be in the hexadecimal notation.]

SideEffects []

SeeAlso []

Definition at line 964 of file abcSop.c.

{
    char * pSopCover, * pCube;
    int nTruthSize, nVars, Digit, Length, Mint, i, b;
    Vec_Int_t * vMints;
 
    // get the number of variables
    nTruthSize = strlen(pTruth);
    nVars = Abc_Base2Log( nTruthSize );
    if ( nTruthSize != (1 << (nVars)) )
    {
        printf( "String %s does not look like a truth table of a %d-variable function.\n", pTruth, nVars );
        return NULL;
    }
 
    // collect the on-set minterms
    vMints = Vec_IntAlloc( 100 );
    for ( i = 0; i < nTruthSize; i++ )
    {
        if ( pTruth[i] >= '0' && pTruth[i] <= '1' )
            Digit = pTruth[i] - '0';
        else
        {
            Vec_IntFree( vMints );
            printf( "String %s does not look like a binary representation of the truth table.\n", pTruth );
            return NULL;
        }
        if ( Digit == 1 )
            Vec_IntPush( vMints, nTruthSize - 1 - i );
    }
/*    
    if ( Vec_IntSize( vMints ) == 0 || Vec_IntSize( vMints ) == nTruthSize )
    {
        Vec_IntFree( vMints );
        printf( "Cannot create constant function.\n" );
        return NULL;
    }
*/
    if ( Vec_IntSize(vMints) == 0 || Vec_IntSize(vMints) == (1 << nVars) )
    {
        pSopCover = ABC_ALLOC( char, 4 );
        pSopCover[0] = ' ';
        pSopCover[1] = '0' + (Vec_IntSize(vMints) > 0);
        pSopCover[2] = '\n';                        
        pSopCover[3] = 0;
    }
    else
    {
        // create the SOP representation of the minterms
        Length = Vec_IntSize(vMints) * (nVars + 3);
        pSopCover = ABC_ALLOC( char, Length + 1 );
        pSopCover[Length] = 0;
        Vec_IntForEachEntry( vMints, Mint, i )
        {
            pCube = pSopCover + i * (nVars + 3);
            for ( b = 0; b < nVars; b++ )
    //            if ( Mint & (1 << (nVars-1-b)) )
                if ( Mint & (1 << b) )
                    pCube[b] = '1';
                else
                    pCube[b] = '0';
            pCube[nVars + 0] = ' ';
            pCube[nVars + 1] = '1';
            pCube[nVars + 2] = '\n';
        }
    }
    Vec_IntFree( vMints );
    return pSopCover;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopFromTruthHex()

ABC_DLL char * Abc_SopFromTruthHex ( char * pTruth )

extern

Function*************************************************************

Synopsis [Derives SOP from the truth table representation.]

Description [Truth table is expected to be in the hexadecimal notation.]

SideEffects []

SeeAlso []

Definition at line 1060 of file abcSop.c.

{
    char * pSopCover, * pCube;
    int nTruthSize, nVars, Digit, Length, Mint, i, b;
    Vec_Int_t * vMints;
 
    // get the number of variables
    nTruthSize = strlen(pTruth);
    nVars = (nTruthSize < 2) ? 2 : Abc_Base2Log(nTruthSize) + 2;
    if ( nTruthSize != (1 << (nVars-2)) )
    {
        printf( "String %s does not look like a truth table of a %d-variable function.\n", pTruth, nVars );
        return NULL;
    }
 
    // collect the on-set minterms
    vMints = Vec_IntAlloc( 100 );
    for ( i = 0; i < nTruthSize; i++ )
    {
        if ( pTruth[i] >= '0' && pTruth[i] <= '9' )
            Digit = pTruth[i] - '0';
        else if ( pTruth[i] >= 'a' && pTruth[i] <= 'f' )
            Digit = 10 + pTruth[i] - 'a';
        else if ( pTruth[i] >= 'A' && pTruth[i] <= 'F' )
            Digit = 10 + pTruth[i] - 'A';
        else
        {
            printf( "String %s does not look like a hexadecimal representation of the truth table.\n", pTruth );
            return NULL;
        }
        for ( b = 0; b < 4; b++ )
            if ( Digit & (1 << b) )
                Vec_IntPush( vMints, 4*(nTruthSize-1-i)+b );
    }
 
    // create the SOP representation of the minterms
    if ( Vec_IntSize(vMints) == 0 || Vec_IntSize(vMints) == (1 << nVars) )
    {
        pSopCover = ABC_ALLOC( char, 4 );
        pSopCover[0] = ' ';
        pSopCover[1] = '0' + (Vec_IntSize(vMints) > 0);
        pSopCover[2] = '\n';                        
        pSopCover[3] = 0;
    }
    else
    {
        Length = Vec_IntSize(vMints) * (nVars + 3);
        pSopCover = ABC_ALLOC( char, Length + 1 );
        pSopCover[Length] = 0;
        Vec_IntForEachEntry( vMints, Mint, i )
        {
            pCube = pSopCover + i * (nVars + 3);
            for ( b = 0; b < nVars; b++ )
    //            if ( Mint & (1 << (nVars-1-b)) )
                if ( Mint & (1 << b) )
                    pCube[b] = '1';
                else
                    pCube[b] = '0';
            pCube[nVars + 0] = ' ';
            pCube[nVars + 1] = '1';
            pCube[nVars + 2] = '\n';
        }
    }
 
    Vec_IntFree( vMints );
    return pSopCover;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopFromTruthsBin()

ABC_DLL Vec_Ptr_t * Abc_SopFromTruthsBin ( char * pTruth )

extern

Definition at line 1033 of file abcSop.c.

{
    Vec_Ptr_t * vRes = Vec_PtrAlloc( 10 );
    char * pCopy = Abc_UtilStrsav(pTruth);
    char * pToken = strtok( pCopy, " \r\n\t|" );
    while ( pToken )
    {
        if ( !Abc_SopCheckReadTruth( vRes, pToken, 0 ) )
            break;
        Vec_PtrPush( vRes, Abc_SopFromTruthBin(pToken) );
        pToken = strtok( NULL, " \r\n\t|" );
    }
    ABC_FREE( pCopy );    
    return vRes;
}

Here is the call graph for this function:

◆ Abc_SopFromTruthsHex()

ABC_DLL Vec_Ptr_t * Abc_SopFromTruthsHex ( char * pTruth )

extern

Definition at line 1127 of file abcSop.c.

{
    Vec_Ptr_t * vRes = Vec_PtrAlloc( 10 );
    char * pCopy = Abc_UtilStrsav(pTruth);
    char * pToken = strtok( pCopy, " \r\n\t|" );
    while ( pToken )
    {
        if ( pToken[0] == '0' && pToken[1] == 'x' )
            pToken += 2;
        if ( !Abc_SopCheckReadTruth( vRes, pToken, 1 ) )
            break;
        Vec_PtrPush( vRes, Abc_SopFromTruthHex(pToken) );
        pToken = strtok( NULL, " \r\n\t|" );
    }
    ABC_FREE( pCopy );
    return vRes;
}

Here is the call graph for this function:

◆ Abc_SopGetCubeNum()

ABC_DLL int Abc_SopGetCubeNum ( char * pSop )

extern

Function*************************************************************

Synopsis [Reads the number of cubes in the cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 537 of file abcSop.c.

{
    char * pCur;
    int nCubes = 0;
    if ( pSop == NULL )
        return 0;
    for ( pCur = pSop; *pCur; pCur++ )
        nCubes += (*pCur == '\n');
    return nCubes;
}

Here is the caller graph for this function:

◆ Abc_SopGetIthCareLit()

ABC_DLL int Abc_SopGetIthCareLit	(	char *	pSop,
		int	i )

extern

Function*************************************************************

Synopsis [Returns the i-th literal of the cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 626 of file abcSop.c.

{
    char * pCube;
    int nVars;
    nVars = Abc_SopGetVarNum( pSop );
    Abc_SopForEachCube( pSop, nVars, pCube )
        if ( pCube[i] != '-' )
            return pCube[i] - '0';
    return -1;
}

Here is the call graph for this function:

◆ Abc_SopGetLitNum()

ABC_DLL int Abc_SopGetLitNum ( char * pSop )

extern

Function*************************************************************

Synopsis [Reads the number of SOP literals in the cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 559 of file abcSop.c.

{
    char * pCur;
    int nLits = 0;
    if ( pSop == NULL )
        return 0;
    for ( pCur = pSop; *pCur; pCur++ )
    {
        nLits  -= (*pCur == '\n');
        nLits  += (*pCur == '0' || *pCur == '1');
    }
    return nLits;
}

Here is the caller graph for this function:

◆ Abc_SopGetPhase()

ABC_DLL int Abc_SopGetPhase ( char * pSop )

extern

Function*************************************************************

Synopsis [Reads the phase of the cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 604 of file abcSop.c.

{
    int nVars = Abc_SopGetVarNum( pSop );
    if ( pSop[nVars+1] == '0' || pSop[nVars+1] == 'n' )
        return 0;
    if ( pSop[nVars+1] == '1' || pSop[nVars+1] == 'x' )
        return 1;
    assert( 0 );
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopGetVarNum()

ABC_DLL int Abc_SopGetVarNum ( char * pSop )

extern

Function*************************************************************

Synopsis [Reads the number of variables in the cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 584 of file abcSop.c.

{
    char * pCur;
    for ( pCur = pSop; *pCur != '\n'; pCur++ )
        if ( *pCur == 0 )
            return -1;
    return pCur - pSop - 2;
}

Here is the caller graph for this function:

◆ Abc_SopIsAndType()

ABC_DLL int Abc_SopIsAndType ( char * pSop )

extern

Function*************************************************************

Synopsis [Checks if the cover is AND with possibly complemented inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 796 of file abcSop.c.

{
    char * pCur;
    if ( Abc_SopGetCubeNum(pSop) != 1 )
        return 0;
    for ( pCur = pSop; *pCur != ' '; pCur++ )
        if ( *pCur == '-' )
            return 0;
    if ( pCur[1] != '1' )
        return 0;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopIsBuf()

ABC_DLL int Abc_SopIsBuf ( char * pSop )

extern

Function*************************************************************

Synopsis [Checks if the cover is constant 1.]

Description []

SideEffects []

SeeAlso []

Definition at line 756 of file abcSop.c.

{
    if ( pSop[4] != 0 )
        return 0;
    if ( (pSop[0] == '1' && pSop[2] == '1') || (pSop[0] == '0' && pSop[2] == '0') )
        return 1;
    return 0;
}

Here is the caller graph for this function:

◆ Abc_SopIsComplement()

ABC_DLL int Abc_SopIsComplement ( char * pSop )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 703 of file abcSop.c.

{
    char * pCur;
    for ( pCur = pSop; *pCur; pCur++ )
        if ( *pCur == '\n' )
            return (int)(*(pCur - 1) == '0' || *(pCur - 1) == 'n');
    assert( 0 );
    return 0;
}

Here is the caller graph for this function:

◆ Abc_SopIsConst0()

ABC_DLL int Abc_SopIsConst0 ( char * pSop )

extern

Function*************************************************************

Synopsis [Checks if the cover is constant 0.]

Description []

SideEffects []

SeeAlso []

Definition at line 724 of file abcSop.c.

{
    return pSop[0] == ' ' && pSop[1] == '0';
}

Here is the caller graph for this function:

◆ Abc_SopIsConst1()

ABC_DLL int Abc_SopIsConst1 ( char * pSop )

extern

Function*************************************************************

Synopsis [Checks if the cover is constant 1.]

Description []

SideEffects []

SeeAlso []

Definition at line 740 of file abcSop.c.

{
    return pSop[0] == ' ' && pSop[1] == '1';
}

Here is the caller graph for this function:

◆ Abc_SopIsExorType()

ABC_DLL int Abc_SopIsExorType ( char * pSop )

extern

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 850 of file abcSop.c.

{
    char * pCur;
    for ( pCur = pSop; *pCur; pCur++ )
        if ( *pCur == '\n' )
            return (int)(*(pCur - 1) == 'x' || *(pCur - 1) == 'n');
    assert( 0 );
    return 0;
}

Here is the caller graph for this function:

◆ Abc_SopIsInv()

ABC_DLL int Abc_SopIsInv ( char * pSop )

extern

Function*************************************************************

Synopsis [Checks if the cover is constant 1.]

Description []

SideEffects []

SeeAlso []

Definition at line 776 of file abcSop.c.

{
    if ( pSop[4] != 0 )
        return 0;
    if ( (pSop[0] == '0' && pSop[2] == '1') || (pSop[0] == '1' && pSop[2] == '0') )
        return 1;
    return 0;
}

Here is the caller graph for this function:

◆ Abc_SopIsOrType()

ABC_DLL int Abc_SopIsOrType ( char * pSop )

extern

Function*************************************************************

Synopsis [Checks if the cover is OR with possibly complemented inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 820 of file abcSop.c.

{
    char * pCube, * pCur;
    int nVars, nLits;
    nVars = Abc_SopGetVarNum( pSop );
    if ( nVars != Abc_SopGetCubeNum(pSop) )
        return 0;
    Abc_SopForEachCube( pSop, nVars, pCube )
    {
        // count the number of literals in the cube
        nLits = 0;
        for ( pCur = pCube; *pCur != ' '; pCur++ )
            nLits += ( *pCur != '-' );
        if ( nLits != 1 )
            return 0;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopRegister()

ABC_DLL char * Abc_SopRegister	(	Mem_Flex_t *	pMan,
		const char *	pName )

extern

DECLARATIONS ///.

CFile****************************************************************

FileName [abcSop.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Implementation of a simple SOP representation of nodes.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id: abcSop.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Registers the cube string with the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 62 of file abcSop.c.

{
    char * pRegName;
    if ( pName == NULL ) return NULL;
    pRegName = Mem_FlexEntryFetch( pMan, strlen(pName) + 1 );
    strcpy( pRegName, pName );
    return pRegName;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopStart()

ABC_DLL char * Abc_SopStart	(	Mem_Flex_t *	pMan,
		int	nCubes,
		int	nVars )

extern

Function*************************************************************

Synopsis [Creates the constant 1 cover with the given number of variables and cubes.]

Description []

SideEffects []

SeeAlso []

Definition at line 82 of file abcSop.c.

{
    char * pSopCover, * pCube;
    int i, Length;
 
    Length = nCubes * (nVars + 3);
    pSopCover = Mem_FlexEntryFetch( pMan, Length + 1 );
    memset( pSopCover, '-', (size_t)Length );
    pSopCover[Length] = 0;
 
    for ( i = 0; i < nCubes; i++ )
    {
        pCube = pSopCover + i * (nVars + 3);
        pCube[nVars + 0] = ' ';
        pCube[nVars + 1] = '1';
        pCube[nVars + 2] = '\n';
    }
    return pSopCover;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopSynthesizeOne()

ABC_DLL Gia_Man_t * Abc_SopSynthesizeOne	(	char *	pSop,
		int	fClp )

extern

Definition at line 3244 of file abcUtil.c.

{
    Abc_Ntk_t * pNtkNew, * pNtk;
    Vec_Ptr_t * vSops;
    if ( strlen(pSop) == 3 )
    {
        Gia_Man_t * pNew = Gia_ManStart( 1 );
        pNew->pName = Abc_UtilStrsav( "top" );
        //Gia_ManAppendCi( pNew );
        assert( pSop[1] == '0' || pSop[1] == '1' );
        Gia_ManAppendCo( pNew, pSop[1] == '1' );
        return pNew;
    }
    vSops = Vec_PtrAlloc( 1 );
    Vec_PtrPush( vSops, pSop );
    pNtk = Abc_NtkCreateFromSops( "top", vSops );
    Vec_PtrFree( vSops );
    Abc_FrameReplaceCurrentNetwork( Abc_FrameReadGlobalFrame(), pNtk );
    Abc_FrameSetBatchMode( 1 );
    if ( fClp ) 
    Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "clp; sop" );
    Cmd_CommandExecute( Abc_FrameGetGlobalFrame(), "fx; strash; balance; dc2" );
    Abc_FrameSetBatchMode( 0 );
    pNtkNew = Abc_FrameReadNtk( Abc_FrameReadGlobalFrame() );
    return Abc_NtkStrashToGia( pNtkNew );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopToTruth()

ABC_DLL word Abc_SopToTruth	(	char *	pSop,
		int	nInputs )

extern

Function*************************************************************

Synopsis [Computes truth table of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1314 of file abcSop.c.

{
    static word Truth[8] = {
        ABC_CONST(0xAAAAAAAAAAAAAAAA),
        ABC_CONST(0xCCCCCCCCCCCCCCCC),
        ABC_CONST(0xF0F0F0F0F0F0F0F0),
        ABC_CONST(0xFF00FF00FF00FF00),
        ABC_CONST(0xFFFF0000FFFF0000),
        ABC_CONST(0xFFFFFFFF00000000),
        ABC_CONST(0x0000000000000000),
        ABC_CONST(0xFFFFFFFFFFFFFFFF)
    };
    word Cube, Result = 0;
    int v, lit = 0;
    int nVars = Abc_SopGetVarNum(pSop);
    assert( nVars >= 0 && nVars <= 6 );
    assert( nVars == nInputs );
    do {
        Cube = Truth[7];
        for ( v = 0; v < nVars; v++, lit++ )
        {
            if ( pSop[lit] == '1' )
                Cube &=  Truth[v];
            else if ( pSop[lit] == '0' )
                Cube &= ~Truth[v];
            else if ( pSop[lit] != '-' )
                assert( 0 );
        }
        Result |= Cube;
        assert( pSop[lit] == ' ' );
        lit++;
        lit++;
        assert( pSop[lit] == '\n' );
        lit++;
    } while ( pSop[lit] );
    if ( Abc_SopIsComplement(pSop) )
        Result = ~Result;
    return Result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopToTruth7()

ABC_DLL void Abc_SopToTruth7	(	char *	pSop,
		int	nInputs,
		word	r[2] )

extern

Function*************************************************************

Synopsis [Computes truth table of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1365 of file abcSop.c.

{
    static word Truth[7][2] = {
        {ABC_CONST(0xAAAAAAAAAAAAAAAA),ABC_CONST(0xAAAAAAAAAAAAAAAA)},
        {ABC_CONST(0xCCCCCCCCCCCCCCCC),ABC_CONST(0xCCCCCCCCCCCCCCCC)},
        {ABC_CONST(0xF0F0F0F0F0F0F0F0),ABC_CONST(0xF0F0F0F0F0F0F0F0)},
        {ABC_CONST(0xFF00FF00FF00FF00),ABC_CONST(0xFF00FF00FF00FF00)},
        {ABC_CONST(0xFFFF0000FFFF0000),ABC_CONST(0xFFFF0000FFFF0000)},
        {ABC_CONST(0xFFFFFFFF00000000),ABC_CONST(0xFFFFFFFF00000000)},
        {ABC_CONST(0x0000000000000000),ABC_CONST(0xFFFFFFFFFFFFFFFF)},
    };
    word Cube[2];
    int v, lit = 0;
    int nVars = Abc_SopGetVarNum(pSop);
    assert( nVars >= 0 && nVars <= 7 );
    assert( nVars == nInputs );
    r[0] = r[1] = 0;
    do {
        Cube[0] = Cube[1] = ~(word)0;
        for ( v = 0; v < nVars; v++, lit++ )
        {
            if ( pSop[lit] == '1' )
            {
                Cube[0] &=  Truth[v][0];
                Cube[1] &=  Truth[v][1];
            }
            else if ( pSop[lit] == '0' )
            {
                Cube[0] &= ~Truth[v][0];
                Cube[1] &= ~Truth[v][1];
            }
            else if ( pSop[lit] != '-' )
                assert( 0 );
        }
        r[0] |= Cube[0];
        r[1] |= Cube[1];
        assert( pSop[lit] == ' ' );
        lit++;
        lit++;
        assert( pSop[lit] == '\n' );
        lit++;
    } while ( pSop[lit] );
    if ( Abc_SopIsComplement(pSop) )
    {
        r[0] = ~r[0];
        r[1] = ~r[1];
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_SopToTruthBig()

ABC_DLL void Abc_SopToTruthBig	(	char *	pSop,
		int	nInputs,
		word **	pVars,
		word *	pCube,
		word *	pRes )

extern

Function*************************************************************

Synopsis [Computes truth table of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1425 of file abcSop.c.

{
    int nVars = Abc_SopGetVarNum(pSop);
    int nWords = nVars <= 6 ? 1 : 1 << (nVars-6);
    int v, i, lit = 0;
    assert( nVars >= 0 && nVars <= 16 );
    assert( nVars == nInputs );
    for ( i = 0; i < nWords; i++ )
        pRes[i] = 0;
    do {
        for ( i = 0; i < nWords; i++ )
            pCube[i] = ~(word)0;
        for ( v = 0; v < nVars; v++, lit++ )
        {
            if ( pSop[lit] == '1' )
            {
                for ( i = 0; i < nWords; i++ )
                    pCube[i] &= pVars[v][i];
            }
            else if ( pSop[lit] == '0' )
            {
                for ( i = 0; i < nWords; i++ )
                    pCube[i] &= ~pVars[v][i];
            }
            else if ( pSop[lit] != '-' )
                assert( 0 );
        }
        for ( i = 0; i < nWords; i++ )
            pRes[i] |= pCube[i];
        assert( pSop[lit] == ' ' );
        lit++;
        lit++;
        assert( pSop[lit] == '\n' );
        lit++;
    } while ( pSop[lit] );
    if ( Abc_SopIsComplement(pSop) )
    {
        for ( i = 0; i < nWords; i++ )
            pRes[i] = ~pRes[i];
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Abc_VecObjPushUniqueOrderByLevel()

ABC_DLL void Abc_VecObjPushUniqueOrderByLevel	(	Vec_Ptr_t *	p,
		Abc_Obj_t *	pNode )

extern

Function*************************************************************

Synopsis [Inserts a new node in the order by levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 1269 of file abcUtil.c.

{
    Abc_Obj_t * pNode1, * pNode2;
    int i;
    if ( Vec_PtrPushUnique(p, pNode) )
        return;
    // find the p of the node
    for ( i = p->nSize-1; i > 0; i-- )
    {
        pNode1 = (Abc_Obj_t *)p->pArray[i  ];
        pNode2 = (Abc_Obj_t *)p->pArray[i-1];
        if ( Abc_ObjRegular(pNode1)->Level <= Abc_ObjRegular(pNode2)->Level )
            break;
        p->pArray[i  ] = pNode2;
        p->pArray[i-1] = pNode1;
    }
}

Classes

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ Abc_AigForEachAnd

◆ Abc_CubeForEachVar

◆ Abc_NtkForEachBarBuf

◆ Abc_NtkForEachBlackbox

◆ Abc_NtkForEachBox

◆ Abc_NtkForEachCi

◆ Abc_NtkForEachCo

◆ Abc_NtkForEachGate

◆ Abc_NtkForEachLatch

◆ Abc_NtkForEachLatchInput

◆ Abc_NtkForEachLatchOutput

◆ Abc_NtkForEachLiPo

◆ Abc_NtkForEachNet

◆ Abc_NtkForEachNode

◆ Abc_NtkForEachNode1

◆ Abc_NtkForEachNodeCi

◆ Abc_NtkForEachNodeCo

◆ Abc_NtkForEachNodeNotBarBuf

◆ Abc_NtkForEachNodeNotBarBuf1

◆ Abc_NtkForEachNodeReverse

◆ Abc_NtkForEachNodeReverse1

◆ Abc_NtkForEachObj

◆ Abc_NtkForEachObjReverse

◆ Abc_NtkForEachObjVec

◆ Abc_NtkForEachObjVecStart

◆ Abc_NtkForEachPi

◆ Abc_NtkForEachPo

◆ Abc_NtkForEachWhitebox

◆ Abc_ObjForEachFanin

◆ Abc_ObjForEachFaninId

◆ Abc_ObjForEachFanout

◆ Abc_ObjForEachFanoutId

◆ Abc_SopForEachCube

◆ Abc_SopForEachCubePair

Typedef Documentation

◆ Abc_Aig_t

◆ Abc_Des_t

◆ Abc_ManCut_t

◆ Abc_ManTime_t

◆ Abc_Ntk_t

◆ Abc_Obj_t

◆ Abc_Time_t

◆ Odc_Man_t

Enumeration Type Documentation

◆ Abc_InitType_t

◆ Abc_NtkFunc_t

◆ Abc_NtkType_t

◆ Abc_ObjType_t

Function Documentation

◆ Abc_AigAlloc()

◆ Abc_AigAnd()

◆ Abc_AigAndLookup()

◆ Abc_AigCheck()

◆ Abc_AigCheckFaninOrder()

◆ Abc_AigCleanup()

◆ Abc_AigConst1()

◆ Abc_AigDeleteNode()

◆ Abc_AigDfs()

◆ Abc_AigDfsMap()

◆ Abc_AigFree()

◆ Abc_AigGetLevelizedOrder()

◆ Abc_AigLevel()

◆ Abc_AigMiter()

◆ Abc_AigMux()

◆ Abc_AigMuxLookup()

◆ Abc_AigNodeHasComplFanoutEdge()

◆ Abc_AigNodeHasComplFanoutEdgeTrav()

◆ Abc_AigNodeIsAcyclic()

◆ Abc_AigOr()

◆ Abc_AigPrintNode()

◆ Abc_AigRehash()

◆ Abc_AigReplace()

◆ Abc_AigSetNodePhases()

◆ Abc_AigUpdateReset()