ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
Functions
abcObj.c File Reference
#include "abc.h"
#include "abcInt.h"
#include "base/main/main.h"
#include "map/mio/mio.h"
Include dependency graph for abcObj.c:

Go to the source code of this file.

Functions

ABC_NAMESPACE_IMPL_START Abc_Obj_t * Abc_ObjAlloc (Abc_Ntk_t *pNtk, Abc_ObjType_t Type)
 DECLARATIONS ///.
 
void Abc_ObjRecycle (Abc_Obj_t *pObj)
 
Abc_Obj_t * Abc_NtkCreateObj (Abc_Ntk_t *pNtk, Abc_ObjType_t Type)
 
void Abc_NtkDeleteObj (Abc_Obj_t *pObj)
 
void Abc_NtkDeleteObjPo (Abc_Obj_t *pObj)
 
void Abc_NtkDeleteObj_rec (Abc_Obj_t *pObj, int fOnlyNodes)
 
void Abc_NtkDeleteAll_rec (Abc_Obj_t *pObj)
 
Abc_Obj_t * Abc_NtkDupObj (Abc_Ntk_t *pNtkNew, Abc_Obj_t *pObj, int fCopyName)
 
Abc_Obj_t * Abc_NtkDupBox (Abc_Ntk_t *pNtkNew, Abc_Obj_t *pBox, int fCopyName)
 
Abc_Obj_t * Abc_NtkCloneObj (Abc_Obj_t *pObj)
 
Abc_Obj_t * Abc_NtkFindNode (Abc_Ntk_t *pNtk, char *pName)
 
Abc_Obj_t * Abc_NtkFindNet (Abc_Ntk_t *pNtk, char *pName)
 
Abc_Obj_t * Abc_NtkFindCi (Abc_Ntk_t *pNtk, char *pName)
 
Abc_Obj_t * Abc_NtkFindCo (Abc_Ntk_t *pNtk, char *pName)
 
Abc_Obj_t * Abc_NtkFindOrCreateNet (Abc_Ntk_t *pNtk, char *pName)
 
Abc_Obj_t * Abc_NtkCreateNodeConst0 (Abc_Ntk_t *pNtk)
 
Abc_Obj_t * Abc_NtkCreateNodeConst1 (Abc_Ntk_t *pNtk)
 
Abc_Obj_t * Abc_NtkCreateNodeInv (Abc_Ntk_t *pNtk, Abc_Obj_t *pFanin)
 
Abc_Obj_t * Abc_NtkCreateNodeBuf (Abc_Ntk_t *pNtk, Abc_Obj_t *pFanin)
 
Abc_Obj_t * Abc_NtkCreateNodeAnd (Abc_Ntk_t *pNtk, Vec_Ptr_t *vFanins)
 
Abc_Obj_t * Abc_NtkCreateNodeOr (Abc_Ntk_t *pNtk, Vec_Ptr_t *vFanins)
 
Abc_Obj_t * Abc_NtkCreateNodeExor (Abc_Ntk_t *pNtk, Vec_Ptr_t *vFanins)
 
Abc_Obj_t * Abc_NtkCreateNodeMux (Abc_Ntk_t *pNtk, Abc_Obj_t *pNodeC, Abc_Obj_t *pNode1, Abc_Obj_t *pNode0)
 
int Abc_NodeIsConst (Abc_Obj_t *pNode)
 
int Abc_NodeIsConst0 (Abc_Obj_t *pNode)
 
int Abc_NodeIsConst1 (Abc_Obj_t *pNode)
 
int Abc_NodeIsBuf (Abc_Obj_t *pNode)
 
int Abc_NodeIsInv (Abc_Obj_t *pNode)
 
void Abc_NodeComplement (Abc_Obj_t *pNode)
 
void Abc_NodeComplementInput (Abc_Obj_t *pNode, Abc_Obj_t *pFanin)
 

Function Documentation

◆ Abc_NodeComplement()

void Abc_NodeComplement ( Abc_Obj_t * pNode)

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

Synopsis [Complements the local functions of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1012 of file abcObj.c.

1013{
1014 assert( Abc_NtkIsLogic(pNode->pNtk) || Abc_NtkIsNetlist(pNode->pNtk) );
1015 assert( Abc_ObjIsNode(pNode) );
1016 if ( Abc_NtkHasSop(pNode->pNtk) )
1017 Abc_SopComplement( (char *)pNode->pData );
1018 else if ( Abc_NtkHasAig(pNode->pNtk) )
1019 pNode->pData = Hop_Not( (Hop_Obj_t *)pNode->pData );
1020#ifdef ABC_USE_CUDD
1021 else if ( Abc_NtkHasBdd(pNode->pNtk) )
1022 pNode->pData = Cudd_Not( pNode->pData );
1023#endif
1024 else
1025 assert( 0 );
1026}
Abc_SopComplement
ABC_DLL void Abc_SopComplement(char *pSop)
Definition abcSop.c:648
Hop_Obj_t
struct Hop_Obj_t_ Hop_Obj_t
Definition hop.h:50
Abc_Obj_t_::pData
void * pData
Definition abc.h:145
Abc_Obj_t_::pNtk
Abc_Ntk_t * pNtk
Definition abc.h:130
assert
#define assert(ex)
Definition util_old.h:213
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NodeComplementInput()

void Abc_NodeComplementInput ( Abc_Obj_t * pNode,
Abc_Obj_t * pFanin )

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

Synopsis [Changes the polarity of one fanin.]

Description []

SideEffects []

SeeAlso []

Definition at line 1039 of file abcObj.c.

1040{
1041 int iFanin;
1042 if ( (iFanin = Vec_IntFind( &pNode->vFanins, pFanin->Id )) == -1 )
1043 {
1044 printf( "Node %s should be among", Abc_ObjName(pFanin) );
1045 printf( " the fanins of node %s...\n", Abc_ObjName(pNode) );
1046 return;
1047 }
1048 if ( Abc_NtkHasSop(pNode->pNtk) )
1049 Abc_SopComplementVar( (char *)pNode->pData, iFanin );
1050 else if ( Abc_NtkHasAig(pNode->pNtk) )
1051 pNode->pData = Hop_Complement( (Hop_Man_t *)pNode->pNtk->pManFunc, (Hop_Obj_t *)pNode->pData, iFanin );
1052#ifdef ABC_USE_CUDD
1053 else if ( Abc_NtkHasBdd(pNode->pNtk) )
1054 {
1055 DdManager * dd = (DdManager *)pNode->pNtk->pManFunc;
1056 DdNode * bVar, * bCof0, * bCof1;
1057 bVar = Cudd_bddIthVar( dd, iFanin );
1058 bCof0 = Cudd_Cofactor( dd, (DdNode *)pNode->pData, Cudd_Not(bVar) ); Cudd_Ref( bCof0 );
1059 bCof1 = Cudd_Cofactor( dd, (DdNode *)pNode->pData, bVar ); Cudd_Ref( bCof1 );
1060 Cudd_RecursiveDeref( dd, (DdNode *)pNode->pData );
1061 pNode->pData = Cudd_bddIte( dd, bVar, bCof0, bCof1 ); Cudd_Ref( (DdNode *)pNode->pData );
1062 Cudd_RecursiveDeref( dd, bCof0 );
1063 Cudd_RecursiveDeref( dd, bCof1 );
1064 }
1065#endif
1066 else
1067 assert( 0 );
1068}
Abc_ObjName
ABC_DLL char * Abc_ObjName(Abc_Obj_t *pNode)
DECLARATIONS ///.
Definition abcNames.c:49
Abc_SopComplementVar
ABC_DLL void Abc_SopComplementVar(char *pSop, int iVar)
Definition abcSop.c:678
Hop_Man_t
typedefABC_NAMESPACE_HEADER_START struct Hop_Man_t_ Hop_Man_t
INCLUDES ///.
Definition hop.h:49
Hop_Complement
Hop_Obj_t * Hop_Complement(Hop_Man_t *p, Hop_Obj_t *pRoot, int iVar)
Definition hopDfs.c:469
Abc_Ntk_t_::pManFunc
void * pManFunc
Definition abc.h:191
Abc_Obj_t_::vFanins
Vec_Int_t vFanins
Definition abc.h:143
Abc_Obj_t_::Id
int Id
Definition abc.h:132
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NodeIsBuf()

int Abc_NodeIsBuf ( Abc_Obj_t * pNode)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 948 of file abcObj.c.

949{
950 Abc_Ntk_t * pNtk = pNode->pNtk;
951 assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
952 assert( Abc_ObjIsNode(pNode) );
953 if ( Abc_ObjFaninNum(pNode) != 1 )
954 return 0;
955 if ( Abc_NtkHasSop(pNtk) )
956 return Abc_SopIsBuf((char *)pNode->pData);
957#ifdef ABC_USE_CUDD
958 if ( Abc_NtkHasBdd(pNtk) )
959 return !Cudd_IsComplement(pNode->pData);
960#endif
961 if ( Abc_NtkHasAig(pNtk) )
962 return !Hop_IsComplement((Hop_Obj_t *)pNode->pData);
963 if ( Abc_NtkHasMapping(pNtk) )
964 return pNode->pData == Mio_LibraryReadBuf((Mio_Library_t *)Abc_FrameReadLibGen());
965 assert( 0 );
966 return 0;
967}
Abc_Ntk_t
struct Abc_Ntk_t_ Abc_Ntk_t
Definition abc.h:115
Abc_SopIsBuf
ABC_DLL int Abc_SopIsBuf(char *pSop)
Definition abcSop.c:756
Abc_FrameReadLibGen
ABC_DLL void * Abc_FrameReadLibGen()
Definition mainFrame.c:59
Mio_Library_t
struct Mio_LibraryStruct_t_ Mio_Library_t
Definition mio.h:42
Mio_LibraryReadBuf
Mio_Gate_t * Mio_LibraryReadBuf(Mio_Library_t *pLib)
Definition mioApi.c:49
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NodeIsConst()

int Abc_NodeIsConst ( Abc_Obj_t * pNode)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 867 of file abcObj.c.

868{
869 assert( Abc_NtkIsLogic(pNode->pNtk) || Abc_NtkIsNetlist(pNode->pNtk) );
870 return Abc_ObjIsNode(pNode) && Abc_ObjFaninNum(pNode) == 0;
871}
Here is the caller graph for this function:

◆ Abc_NodeIsConst0()

int Abc_NodeIsConst0 ( Abc_Obj_t * pNode)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 884 of file abcObj.c.

885{
886 Abc_Ntk_t * pNtk = pNode->pNtk;
887 assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
888 assert( Abc_ObjIsNode(pNode) );
889 if ( !Abc_NodeIsConst(pNode) )
890 return 0;
891 if ( Abc_NtkHasSop(pNtk) )
892 return Abc_SopIsConst0((char *)pNode->pData);
893#ifdef ABC_USE_CUDD
894 if ( Abc_NtkHasBdd(pNtk) )
895 return Cudd_IsComplement(pNode->pData);
896#endif
897 if ( Abc_NtkHasAig(pNtk) )
898 return Hop_IsComplement((Hop_Obj_t *)pNode->pData)? 1:0;
899 if ( Abc_NtkHasMapping(pNtk) )
900 return pNode->pData == Mio_LibraryReadConst0((Mio_Library_t *)Abc_FrameReadLibGen());
901 assert( 0 );
902 return 0;
903}
Abc_NodeIsConst
int Abc_NodeIsConst(Abc_Obj_t *pNode)
Definition abcObj.c:867
Abc_SopIsConst0
ABC_DLL int Abc_SopIsConst0(char *pSop)
Definition abcSop.c:724
Mio_LibraryReadConst0
Mio_Gate_t * Mio_LibraryReadConst0(Mio_Library_t *pLib)
Definition mioApi.c:51
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NodeIsConst1()

int Abc_NodeIsConst1 ( Abc_Obj_t * pNode)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 916 of file abcObj.c.

917{
918 Abc_Ntk_t * pNtk = pNode->pNtk;
919 assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
920 assert( Abc_ObjIsNode(pNode) );
921 if ( !Abc_NodeIsConst(pNode) )
922 return 0;
923 if ( Abc_NtkHasSop(pNtk) )
924 return Abc_SopIsConst1((char *)pNode->pData);
925#ifdef ABC_USE_CUDD
926 if ( Abc_NtkHasBdd(pNtk) )
927 return !Cudd_IsComplement(pNode->pData);
928#endif
929 if ( Abc_NtkHasAig(pNtk) )
930 return !Hop_IsComplement((Hop_Obj_t *)pNode->pData);
931 if ( Abc_NtkHasMapping(pNtk) )
932 return pNode->pData == Mio_LibraryReadConst1((Mio_Library_t *)Abc_FrameReadLibGen());
933 assert( 0 );
934 return 0;
935}
Abc_SopIsConst1
ABC_DLL int Abc_SopIsConst1(char *pSop)
Definition abcSop.c:740
Mio_LibraryReadConst1
Mio_Gate_t * Mio_LibraryReadConst1(Mio_Library_t *pLib)
Definition mioApi.c:52
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NodeIsInv()

int Abc_NodeIsInv ( Abc_Obj_t * pNode)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 980 of file abcObj.c.

981{
982 Abc_Ntk_t * pNtk = pNode->pNtk;
983 assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
984 assert( Abc_ObjIsNode(pNode) );
985 if ( Abc_ObjFaninNum(pNode) != 1 )
986 return 0;
987 if ( Abc_NtkHasSop(pNtk) )
988 return Abc_SopIsInv((char *)pNode->pData);
989#ifdef ABC_USE_CUDD
990 if ( Abc_NtkHasBdd(pNtk) )
991 return Cudd_IsComplement(pNode->pData);
992#endif
993 if ( Abc_NtkHasAig(pNtk) )
994 return Hop_IsComplement((Hop_Obj_t *)pNode->pData)? 1:0;
995 if ( Abc_NtkHasMapping(pNtk) )
996 return pNode->pData == Mio_LibraryReadInv((Mio_Library_t *)Abc_FrameReadLibGen());
997 assert( 0 );
998 return 0;
999}
Abc_SopIsInv
ABC_DLL int Abc_SopIsInv(char *pSop)
Definition abcSop.c:776
Mio_LibraryReadInv
Mio_Gate_t * Mio_LibraryReadInv(Mio_Library_t *pLib)
Definition mioApi.c:50
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkCloneObj()

Abc_Obj_t * Abc_NtkCloneObj ( Abc_Obj_t * pObj)

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.

443{
444 Abc_Obj_t * pClone, * pFanin;
445 int i;
446 pClone = Abc_NtkCreateObj( pObj->pNtk, (Abc_ObjType_t)pObj->Type );
447 Abc_ObjForEachFanin( pObj, pFanin, i )
448 Abc_ObjAddFanin( pClone, pFanin );
449 return pClone;
450}
Abc_NtkCreateObj
Abc_Obj_t * Abc_NtkCreateObj(Abc_Ntk_t *pNtk, Abc_ObjType_t Type)
Definition abcObj.c:109
Abc_Obj_t
struct Abc_Obj_t_ Abc_Obj_t
Definition abc.h:116
Abc_ObjAddFanin
ABC_DLL void Abc_ObjAddFanin(Abc_Obj_t *pObj, Abc_Obj_t *pFanin)
Definition abcFanio.c:84
Abc_ObjForEachFanin
#define Abc_ObjForEachFanin(pObj, pFanin, i)
Definition abc.h:527
Abc_ObjType_t
Abc_ObjType_t
Definition abc.h:86
Abc_Obj_t_::Type
unsigned Type
Definition abc.h:133
Here is the call graph for this function:

◆ Abc_NtkCreateNodeAnd()

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

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

Synopsis [Creates AND.]

Description []

SideEffects []

SeeAlso []

Definition at line 738 of file abcObj.c.

739{
740 Abc_Obj_t * pNode;
741 int i;
742 assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
743 pNode = Abc_NtkCreateNode( pNtk );
744 for ( i = 0; i < vFanins->nSize; i++ )
745 Abc_ObjAddFanin( pNode, (Abc_Obj_t *)vFanins->pArray[i] );
746 if ( Abc_NtkHasSop(pNtk) )
747 pNode->pData = Abc_SopCreateAnd( (Mem_Flex_t *)pNtk->pManFunc, Vec_PtrSize(vFanins), NULL );
748#ifdef ABC_USE_CUDD
749 else if ( Abc_NtkHasBdd(pNtk) )
750 pNode->pData = Extra_bddCreateAnd( (DdManager *)pNtk->pManFunc, Vec_PtrSize(vFanins) ), Cudd_Ref((DdNode *)pNode->pData);
751#endif
752 else if ( Abc_NtkHasAig(pNtk) )
753 pNode->pData = Hop_CreateAnd( (Hop_Man_t *)pNtk->pManFunc, Vec_PtrSize(vFanins) );
754 else
755 assert( 0 );
756 return pNode;
757}
Abc_SopCreateAnd
ABC_DLL char * Abc_SopCreateAnd(Mem_Flex_t *pMan, int nVars, int *pfCompl)
Definition abcSop.c:168
Extra_bddCreateAnd
DdNode * Extra_bddCreateAnd(DdManager *dd, int nVars)
Definition extraBddMisc.c:858
Hop_CreateAnd
Hop_Obj_t * Hop_CreateAnd(Hop_Man_t *p, int nVars)
Definition hopOper.c:320
Mem_Flex_t
struct Mem_Flex_t_ Mem_Flex_t
Definition mem.h:34
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkCreateNodeBuf()

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

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

Synopsis [Creates buffer.]

Description []

SideEffects []

SeeAlso []

Definition at line 706 of file abcObj.c.

707{
708 Abc_Obj_t * pNode;
709 assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
710 pNode = Abc_NtkCreateNode( pNtk );
711 if ( pFanin ) Abc_ObjAddFanin( pNode, pFanin );
712 if ( Abc_NtkHasSop(pNtk) )
713 pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, "1 1\n" );
714#ifdef ABC_USE_CUDD
715 else if ( Abc_NtkHasBdd(pNtk) )
716 pNode->pData = Cudd_bddIthVar((DdManager *)pNtk->pManFunc,0), Cudd_Ref( (DdNode *)pNode->pData );
717#endif
718 else if ( Abc_NtkHasAig(pNtk) )
719 pNode->pData = Hop_IthVar((Hop_Man_t *)pNtk->pManFunc,0);
720 else if ( Abc_NtkHasMapping(pNtk) )
721 pNode->pData = Mio_LibraryReadBuf((Mio_Library_t *)Abc_FrameReadLibGen());
722 else
723 assert( 0 );
724 return pNode;
725}
Abc_SopRegister
ABC_DLL char * Abc_SopRegister(Mem_Flex_t *pMan, const char *pName)
DECLARATIONS ///.
Definition abcSop.c:62
Hop_IthVar
Hop_Obj_t * Hop_IthVar(Hop_Man_t *p, int i)
FUNCTION DEFINITIONS ///.
Definition hopOper.c:63
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkCreateNodeConst0()

Abc_Obj_t * Abc_NtkCreateNodeConst0 ( Abc_Ntk_t * pNtk)

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

Synopsis [Creates constant 0 node.]

Description []

SideEffects []

SeeAlso []

Definition at line 612 of file abcObj.c.

613{
614 Abc_Obj_t * pNode;
615 assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
616 pNode = Abc_NtkCreateNode( pNtk );
617 if ( Abc_NtkHasSop(pNtk) || Abc_NtkHasBlifMv(pNtk) )
618 pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, " 0\n" );
619#ifdef ABC_USE_CUDD
620 else if ( Abc_NtkHasBdd(pNtk) )
621 pNode->pData = Cudd_ReadLogicZero((DdManager *)pNtk->pManFunc), Cudd_Ref( (DdNode *)pNode->pData );
622#endif
623 else if ( Abc_NtkHasAig(pNtk) )
624 pNode->pData = Hop_ManConst0((Hop_Man_t *)pNtk->pManFunc);
625 else if ( Abc_NtkHasMapping(pNtk) )
626 pNode->pData = Mio_LibraryReadConst0((Mio_Library_t *)Abc_FrameReadLibGen());
627 else if ( !Abc_NtkHasBlackbox(pNtk) )
628 assert( 0 );
629 return pNode;
630}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkCreateNodeConst1()

Abc_Obj_t * Abc_NtkCreateNodeConst1 ( Abc_Ntk_t * pNtk)

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

Synopsis [Creates constant 1 node.]

Description []

SideEffects []

SeeAlso []

Definition at line 643 of file abcObj.c.

644{
645 Abc_Obj_t * pNode;
646 assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
647 pNode = Abc_NtkCreateNode( pNtk );
648 if ( Abc_NtkHasSop(pNtk) || Abc_NtkHasBlifMv(pNtk) )
649 pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, " 1\n" );
650#ifdef ABC_USE_CUDD
651 else if ( Abc_NtkHasBdd(pNtk) )
652 pNode->pData = Cudd_ReadOne((DdManager *)pNtk->pManFunc), Cudd_Ref( (DdNode *)pNode->pData );
653#endif
654 else if ( Abc_NtkHasAig(pNtk) )
655 pNode->pData = Hop_ManConst1((Hop_Man_t *)pNtk->pManFunc);
656 else if ( Abc_NtkHasMapping(pNtk) )
657 pNode->pData = Mio_LibraryReadConst1((Mio_Library_t *)Abc_FrameReadLibGen());
658 else if ( !Abc_NtkHasBlackbox(pNtk) )
659 assert( 0 );
660 return pNode;
661}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkCreateNodeExor()

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

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

Synopsis [Creates EXOR.]

Description []

SideEffects []

SeeAlso []

Definition at line 802 of file abcObj.c.

803{
804 Abc_Obj_t * pNode;
805 int i;
806 assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
807 pNode = Abc_NtkCreateNode( pNtk );
808 for ( i = 0; i < vFanins->nSize; i++ )
809 Abc_ObjAddFanin( pNode, (Abc_Obj_t *)vFanins->pArray[i] );
810 if ( Abc_NtkHasSop(pNtk) )
811 pNode->pData = Abc_SopCreateXorSpecial( (Mem_Flex_t *)pNtk->pManFunc, Vec_PtrSize(vFanins) );
812#ifdef ABC_USE_CUDD
813 else if ( Abc_NtkHasBdd(pNtk) )
814 pNode->pData = Extra_bddCreateExor( (DdManager *)pNtk->pManFunc, Vec_PtrSize(vFanins) ), Cudd_Ref((DdNode *)pNode->pData);
815#endif
816 else if ( Abc_NtkHasAig(pNtk) )
817 pNode->pData = Hop_CreateExor( (Hop_Man_t *)pNtk->pManFunc, Vec_PtrSize(vFanins) );
818 else
819 assert( 0 );
820 return pNode;
821}
Abc_SopCreateXorSpecial
ABC_DLL char * Abc_SopCreateXorSpecial(Mem_Flex_t *pMan, int nVars)
Definition abcSop.c:297
Extra_bddCreateExor
DdNode * Extra_bddCreateExor(DdManager *dd, int nVars)
Definition extraBddMisc.c:908
Hop_CreateExor
Hop_Obj_t * Hop_CreateExor(Hop_Man_t *p, int nVars)
Definition hopOper.c:362
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkCreateNodeInv()

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

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

Synopsis [Creates inverter.]

Description []

SideEffects []

SeeAlso []

Definition at line 674 of file abcObj.c.

675{
676 Abc_Obj_t * pNode;
677 assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
678 pNode = Abc_NtkCreateNode( pNtk );
679 if ( pFanin ) Abc_ObjAddFanin( pNode, pFanin );
680 if ( Abc_NtkHasSop(pNtk) )
681 pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, "0 1\n" );
682#ifdef ABC_USE_CUDD
683 else if ( Abc_NtkHasBdd(pNtk) )
684 pNode->pData = Cudd_Not(Cudd_bddIthVar((DdManager *)pNtk->pManFunc,0)), Cudd_Ref( (DdNode *)pNode->pData );
685#endif
686 else if ( Abc_NtkHasAig(pNtk) )
687 pNode->pData = Hop_Not(Hop_IthVar((Hop_Man_t *)pNtk->pManFunc,0));
688 else if ( Abc_NtkHasMapping(pNtk) )
689 pNode->pData = Mio_LibraryReadInv((Mio_Library_t *)Abc_FrameReadLibGen());
690 else
691 assert( 0 );
692 return pNode;
693}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkCreateNodeMux()

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

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

Synopsis [Creates MUX.]

Description []

SideEffects []

SeeAlso []

Definition at line 834 of file abcObj.c.

835{
836 Abc_Obj_t * pNode;
837 assert( Abc_NtkIsLogic(pNtk) );
838 pNode = Abc_NtkCreateNode( pNtk );
839 Abc_ObjAddFanin( pNode, pNodeC );
840 Abc_ObjAddFanin( pNode, pNode1 );
841 Abc_ObjAddFanin( pNode, pNode0 );
842 if ( Abc_NtkHasSop(pNtk) )
843 pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, "11- 1\n0-1 1\n" );
844#ifdef ABC_USE_CUDD
845 else if ( Abc_NtkHasBdd(pNtk) )
846 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 );
847#endif
848 else if ( Abc_NtkHasAig(pNtk) )
849 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));
850 else
851 assert( 0 );
852 return pNode;
853}
Hop_Mux
Hop_Obj_t * Hop_Mux(Hop_Man_t *p, Hop_Obj_t *pC, Hop_Obj_t *p1, Hop_Obj_t *p0)
Definition hopOper.c:187
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkCreateNodeOr()

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

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

Synopsis [Creates OR.]

Description []

SideEffects []

SeeAlso []

Definition at line 770 of file abcObj.c.

771{
772 Abc_Obj_t * pNode;
773 int i;
774 assert( Abc_NtkIsLogic(pNtk) || Abc_NtkIsNetlist(pNtk) );
775 pNode = Abc_NtkCreateNode( pNtk );
776 for ( i = 0; i < vFanins->nSize; i++ )
777 Abc_ObjAddFanin( pNode, (Abc_Obj_t *)vFanins->pArray[i] );
778 if ( Abc_NtkHasSop(pNtk) )
779 pNode->pData = Abc_SopCreateOr( (Mem_Flex_t *)pNtk->pManFunc, Vec_PtrSize(vFanins), NULL );
780#ifdef ABC_USE_CUDD
781 else if ( Abc_NtkHasBdd(pNtk) )
782 pNode->pData = Extra_bddCreateOr( (DdManager *)pNtk->pManFunc, Vec_PtrSize(vFanins) ), Cudd_Ref((DdNode *)pNode->pData);
783#endif
784 else if ( Abc_NtkHasAig(pNtk) )
785 pNode->pData = Hop_CreateOr( (Hop_Man_t *)pNtk->pManFunc, Vec_PtrSize(vFanins) );
786 else
787 assert( 0 );
788 return pNode;
789}
Abc_SopCreateOr
ABC_DLL char * Abc_SopCreateOr(Mem_Flex_t *pMan, int nVars, int *pfCompl)
Definition abcSop.c:212
Extra_bddCreateOr
DdNode * Extra_bddCreateOr(DdManager *dd, int nVars)
Definition extraBddMisc.c:883
Hop_CreateOr
Hop_Obj_t * Hop_CreateOr(Hop_Man_t *p, int nVars)
Definition hopOper.c:341
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkCreateObj()

Abc_Obj_t * Abc_NtkCreateObj ( Abc_Ntk_t * pNtk,
Abc_ObjType_t Type )

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

Synopsis [Adds the node to the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 109 of file abcObj.c.

110{
111 Abc_Obj_t * pObj;
112 // create new object, assign ID, and add to the array
113 pObj = Abc_ObjAlloc( pNtk, Type );
114 pObj->Id = pNtk->vObjs->nSize;
115 Vec_PtrPush( pNtk->vObjs, pObj );
116 pNtk->nObjCounts[Type]++;
117 pNtk->nObjs++;
118 // perform specialized operations depending on the object type
119 switch (Type)
120 {
121 case ABC_OBJ_NONE:
122 assert(0);
123 break;
124 case ABC_OBJ_CONST1:
125 assert(0);
126 break;
127 case ABC_OBJ_PI:
128// pObj->iTemp = Vec_PtrSize(pNtk->vCis);
129 Vec_PtrPush( pNtk->vPis, pObj );
130 Vec_PtrPush( pNtk->vCis, pObj );
131 break;
132 case ABC_OBJ_PO:
133// pObj->iTemp = Vec_PtrSize(pNtk->vCos);
134 Vec_PtrPush( pNtk->vPos, pObj );
135 Vec_PtrPush( pNtk->vCos, pObj );
136 break;
137 case ABC_OBJ_BI:
138 if ( pNtk->vCos ) Vec_PtrPush( pNtk->vCos, pObj );
139 break;
140 case ABC_OBJ_BO:
141 if ( pNtk->vCis ) Vec_PtrPush( pNtk->vCis, pObj );
142 break;
143 case ABC_OBJ_NET:
144 case ABC_OBJ_NODE:
145 break;
146 case ABC_OBJ_LATCH:
147 pObj->pData = (void *)ABC_INIT_NONE;
148 case ABC_OBJ_WHITEBOX:
149 case ABC_OBJ_BLACKBOX:
150 if ( pNtk->vBoxes ) Vec_PtrPush( pNtk->vBoxes, pObj );
151 break;
152 default:
153 assert(0);
154 break;
155 }
156 return pObj;
157}
Abc_ObjAlloc
ABC_NAMESPACE_IMPL_START Abc_Obj_t * Abc_ObjAlloc(Abc_Ntk_t *pNtk, Abc_ObjType_t Type)
DECLARATIONS ///.
Definition abcObj.c:52
ABC_OBJ_NET
@ ABC_OBJ_NET
Definition abc.h:93
ABC_OBJ_NONE
@ ABC_OBJ_NONE
Definition abc.h:87
ABC_OBJ_NODE
@ ABC_OBJ_NODE
Definition abc.h:94
ABC_OBJ_BLACKBOX
@ ABC_OBJ_BLACKBOX
Definition abc.h:97
ABC_OBJ_BI
@ ABC_OBJ_BI
Definition abc.h:91
ABC_OBJ_BO
@ ABC_OBJ_BO
Definition abc.h:92
ABC_OBJ_WHITEBOX
@ ABC_OBJ_WHITEBOX
Definition abc.h:96
ABC_OBJ_PI
@ ABC_OBJ_PI
Definition abc.h:89
ABC_OBJ_LATCH
@ ABC_OBJ_LATCH
Definition abc.h:95
ABC_OBJ_PO
@ ABC_OBJ_PO
Definition abc.h:90
ABC_OBJ_CONST1
@ ABC_OBJ_CONST1
Definition abc.h:88
ABC_INIT_NONE
@ ABC_INIT_NONE
Definition abc.h:103
Abc_Ntk_t_::vCis
Vec_Ptr_t * vCis
Definition abc.h:165
Abc_Ntk_t_::vCos
Vec_Ptr_t * vCos
Definition abc.h:166
Abc_Ntk_t_::vPos
Vec_Ptr_t * vPos
Definition abc.h:164
Abc_Ntk_t_::vBoxes
Vec_Ptr_t * vBoxes
Definition abc.h:168
Abc_Ntk_t_::nObjs
int nObjs
Definition abc.h:172
Abc_Ntk_t_::nObjCounts
int nObjCounts[ABC_OBJ_NUMBER]
Definition abc.h:171
Abc_Ntk_t_::vPis
Vec_Ptr_t * vPis
Definition abc.h:163
Abc_Ntk_t_::vObjs
Vec_Ptr_t * vObjs
Definition abc.h:162
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkDeleteAll_rec()

void Abc_NtkDeleteAll_rec ( Abc_Obj_t * pObj)

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 315 of file abcObj.c.

316{
317 Vec_Ptr_t * vNodes;
318 int i;
319 assert( !Abc_ObjIsComplement(pObj) );
320 assert( Abc_ObjFanoutNum(pObj) == 0 );
321 // delete fanins and fanouts
322 vNodes = Vec_PtrAlloc( 100 );
323 Abc_NodeCollectFanins( pObj, vNodes );
324 Abc_NtkDeleteObj( pObj );
325 Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
326 if ( !Abc_ObjIsNode(pObj) && Abc_ObjFanoutNum(pObj) == 0 )
327 Abc_NtkDeleteAll_rec( pObj );
328 Vec_PtrFree( vNodes );
329}
Abc_NtkDeleteAll_rec
void Abc_NtkDeleteAll_rec(Abc_Obj_t *pObj)
Definition abcObj.c:315
Abc_NtkDeleteObj
void Abc_NtkDeleteObj(Abc_Obj_t *pObj)
Definition abcObj.c:170
Abc_NodeCollectFanins
ABC_DLL void Abc_NodeCollectFanins(Abc_Obj_t *pNode, Vec_Ptr_t *vNodes)
Definition abcUtil.c:1627
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition vecPtr.h:42
Vec_PtrForEachEntry
#define Vec_PtrForEachEntry(Type, vVec, pEntry, i)
MACRO DEFINITIONS ///.
Definition vecPtr.h:55
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkDeleteObj()

void Abc_NtkDeleteObj ( Abc_Obj_t * pObj)

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

Synopsis [Deletes the object from the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 170 of file abcObj.c.

171{
172 Abc_Ntk_t * pNtk = pObj->pNtk;
173 Vec_Ptr_t * vNodes;
174 int i;
175 assert( !Abc_ObjIsComplement(pObj) );
176 // remove from the table of names
177 if ( Nm_ManFindNameById(pObj->pNtk->pManName, pObj->Id) )
178 Nm_ManDeleteIdName(pObj->pNtk->pManName, pObj->Id);
179 // delete fanins and fanouts
180 vNodes = Vec_PtrAlloc( 100 );
181 Abc_NodeCollectFanouts( pObj, vNodes );
182 for ( i = 0; i < vNodes->nSize; i++ )
183 Abc_ObjDeleteFanin( (Abc_Obj_t *)vNodes->pArray[i], pObj );
184 Abc_NodeCollectFanins( pObj, vNodes );
185 for ( i = 0; i < vNodes->nSize; i++ )
186 Abc_ObjDeleteFanin( pObj, (Abc_Obj_t *)vNodes->pArray[i] );
187 Vec_PtrFree( vNodes );
188 // remove from the list of objects
189 Vec_PtrWriteEntry( pNtk->vObjs, pObj->Id, NULL );
190 pObj->Id = (1<<26)-1;
191 pNtk->nObjCounts[pObj->Type]--;
192 pNtk->nObjs--;
193 // perform specialized operations depending on the object type
194 switch (pObj->Type)
195 {
196 case ABC_OBJ_NONE:
197 assert(0);
198 break;
199 case ABC_OBJ_CONST1:
200 assert(0);
201 break;
202 case ABC_OBJ_PI:
203 Vec_PtrRemove( pNtk->vPis, pObj );
204 Vec_PtrRemove( pNtk->vCis, pObj );
205 break;
206 case ABC_OBJ_PO:
207 Vec_PtrRemove( pNtk->vPos, pObj );
208 Vec_PtrRemove( pNtk->vCos, pObj );
209 break;
210 case ABC_OBJ_BI:
211 if ( pNtk->vCos ) Vec_PtrRemove( pNtk->vCos, pObj );
212 break;
213 case ABC_OBJ_BO:
214 if ( pNtk->vCis ) Vec_PtrRemove( pNtk->vCis, pObj );
215 break;
216 case ABC_OBJ_NET:
217 break;
218 case ABC_OBJ_NODE:
219#ifdef ABC_USE_CUDD
220 if ( Abc_NtkHasBdd(pNtk) )
221 Cudd_RecursiveDeref( (DdManager *)pNtk->pManFunc, (DdNode *)pObj->pData );
222#endif
223 pObj->pData = NULL;
224 break;
225 case ABC_OBJ_LATCH:
226 case ABC_OBJ_WHITEBOX:
227 case ABC_OBJ_BLACKBOX:
228 if ( pNtk->vBoxes ) Vec_PtrRemove( pNtk->vBoxes, pObj );
229 break;
230 default:
231 assert(0);
232 break;
233 }
234 // recycle the object memory
235 Abc_ObjRecycle( pObj );
236}
Abc_ObjRecycle
void Abc_ObjRecycle(Abc_Obj_t *pObj)
Definition abcObj.c:77
Abc_NodeCollectFanouts
ABC_DLL void Abc_NodeCollectFanouts(Abc_Obj_t *pNode, Vec_Ptr_t *vNodes)
Definition abcUtil.c:1647
Abc_ObjDeleteFanin
ABC_DLL void Abc_ObjDeleteFanin(Abc_Obj_t *pObj, Abc_Obj_t *pFanin)
Definition abcFanio.c:111
Nm_ManFindNameById
char * Nm_ManFindNameById(Nm_Man_t *p, int ObjId)
Definition nmApi.c:199
Nm_ManDeleteIdName
void Nm_ManDeleteIdName(Nm_Man_t *p, int ObjId)
Definition nmApi.c:149
Abc_Ntk_t_::pManName
Nm_Man_t * pManName
Definition abc.h:160
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkDeleteObj_rec()

void Abc_NtkDeleteObj_rec ( Abc_Obj_t * pObj,
int fOnlyNodes )

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

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

Description []

SideEffects []

SeeAlso []

Definition at line 278 of file abcObj.c.

279{
280 Vec_Ptr_t * vNodes;
281 int i;
282 assert( !Abc_ObjIsComplement(pObj) );
283 assert( !Abc_ObjIsPi(pObj) );
284 assert( Abc_ObjFanoutNum(pObj) == 0 );
285 // delete fanins and fanouts
286 vNodes = Vec_PtrAlloc( 100 );
287 Abc_NodeCollectFanins( pObj, vNodes );
288 Abc_NtkDeleteObj( pObj );
289 if ( fOnlyNodes )
290 {
291 Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
292 if ( Abc_ObjIsNode(pObj) && Abc_ObjFanoutNum(pObj) == 0 )
293 Abc_NtkDeleteObj_rec( pObj, fOnlyNodes );
294 }
295 else
296 {
297 Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
298 if ( !Abc_ObjIsPi(pObj) && Abc_ObjFanoutNum(pObj) == 0 )
299 Abc_NtkDeleteObj_rec( pObj, fOnlyNodes );
300 }
301 Vec_PtrFree( vNodes );
302}
Abc_NtkDeleteObj_rec
void Abc_NtkDeleteObj_rec(Abc_Obj_t *pObj, int fOnlyNodes)
Definition abcObj.c:278
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkDeleteObjPo()

void Abc_NtkDeleteObjPo ( Abc_Obj_t * pObj)

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

Synopsis [Deletes the PO from the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 249 of file abcObj.c.

250{
251 assert( Abc_ObjIsPo(pObj) );
252 // remove from the table of names
253 if ( Nm_ManFindNameById(pObj->pNtk->pManName, pObj->Id) )
254 Nm_ManDeleteIdName(pObj->pNtk->pManName, pObj->Id);
255 // delete fanins
256 Abc_ObjDeleteFanin( pObj, Abc_ObjFanin0(pObj) );
257 // remove from the list of objects
258 Vec_PtrWriteEntry( pObj->pNtk->vObjs, pObj->Id, NULL );
259 pObj->Id = (1<<26)-1;
260 pObj->pNtk->nObjCounts[pObj->Type]--;
261 pObj->pNtk->nObjs--;
262 // recycle the object memory
263 Abc_ObjRecycle( pObj );
264}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkDupBox()

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

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

Synopsis [Duplicates the latch with its input/output terminals.]

Description []

SideEffects []

SeeAlso []

Definition at line 415 of file abcObj.c.

416{
417 Abc_Obj_t * pTerm, * pBoxNew;
418 int i;
419 assert( Abc_ObjIsBox(pBox) );
420 // duplicate the box
421 pBoxNew = Abc_NtkDupObj( pNtkNew, pBox, fCopyName );
422 // duplicate the fanins and connect them
423 Abc_ObjForEachFanin( pBox, pTerm, i )
424 Abc_ObjAddFanin( pBoxNew, Abc_NtkDupObj(pNtkNew, pTerm, fCopyName) );
425 // duplicate the fanouts and connect them
426 Abc_ObjForEachFanout( pBox, pTerm, i )
427 Abc_ObjAddFanin( Abc_NtkDupObj(pNtkNew, pTerm, fCopyName), pBoxNew );
428 return pBoxNew;
429}
Abc_NtkDupObj
Abc_Obj_t * Abc_NtkDupObj(Abc_Ntk_t *pNtkNew, Abc_Obj_t *pObj, int fCopyName)
Definition abcObj.c:342
Abc_ObjForEachFanout
#define Abc_ObjForEachFanout(pObj, pFanout, i)
Definition abc.h:529
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkDupObj()

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

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

Synopsis [Duplicate the Obj.]

Description []

SideEffects []

SeeAlso []

Definition at line 342 of file abcObj.c.

343{
344 Abc_Obj_t * pObjNew;
345 // create the new object
346 pObjNew = Abc_NtkCreateObj( pNtkNew, (Abc_ObjType_t)pObj->Type );
347 // transfer names of the terminal objects
348 if ( fCopyName )
349 {
350 if ( Abc_ObjIsCi(pObj) )
351 {
352 if ( !Abc_NtkIsNetlist(pNtkNew) )
353 Abc_ObjAssignName( pObjNew, Abc_ObjName(Abc_ObjFanout0Ntk(pObj)), NULL );
354 }
355 else if ( Abc_ObjIsCo(pObj) )
356 {
357 if ( !Abc_NtkIsNetlist(pNtkNew) )
358 {
359 if ( Abc_ObjIsPo(pObj) )
360 Abc_ObjAssignName( pObjNew, Abc_ObjName(Abc_ObjFanin0Ntk(pObj)), NULL );
361 else
362 {
363 assert( Abc_ObjIsLatch(Abc_ObjFanout0(pObj)) );
364 Abc_ObjAssignName( pObjNew, Abc_ObjName(pObj), NULL );
365 }
366 }
367 }
368 else if ( Abc_ObjIsBox(pObj) || Abc_ObjIsNet(pObj) )
369 Abc_ObjAssignName( pObjNew, Abc_ObjName(pObj), NULL );
370 }
371 // copy functionality/names
372 if ( Abc_ObjIsNode(pObj) ) // copy the function if functionality is compatible
373 {
374 if ( pNtkNew->ntkFunc == pObj->pNtk->ntkFunc )
375 {
376 if ( Abc_NtkIsStrash(pNtkNew) )
377 {}
378 else if ( Abc_NtkHasSop(pNtkNew) || Abc_NtkHasBlifMv(pNtkNew) )
379 pObjNew->pData = Abc_SopRegister( (Mem_Flex_t *)pNtkNew->pManFunc, (char *)pObj->pData );
380#ifdef ABC_USE_CUDD
381 else if ( Abc_NtkHasBdd(pNtkNew) )
382 pObjNew->pData = Cudd_bddTransfer((DdManager *)pObj->pNtk->pManFunc, (DdManager *)pNtkNew->pManFunc, (DdNode *)pObj->pData), Cudd_Ref((DdNode *)pObjNew->pData);
383#endif
384 else if ( Abc_NtkHasAig(pNtkNew) )
385 pObjNew->pData = Hop_Transfer((Hop_Man_t *)pObj->pNtk->pManFunc, (Hop_Man_t *)pNtkNew->pManFunc, (Hop_Obj_t *)pObj->pData, Abc_ObjFaninNum(pObj));
386 else if ( Abc_NtkHasMapping(pNtkNew) )
387 pObjNew->pData = pObj->pData, pNtkNew->nBarBufs2 += !pObj->pData;
388 else assert( 0 );
389 }
390 }
391 else if ( Abc_ObjIsNet(pObj) ) // copy the name
392 {
393 }
394 else if ( Abc_ObjIsLatch(pObj) ) // copy the reset value
395 pObjNew->pData = pObj->pData;
396 pObjNew->fPersist = pObj->fPersist;
397 // transfer HAIG
398// pObjNew->pEquiv = pObj->pEquiv;
399 // remember the new node in the old node
400 pObj->pCopy = pObjNew;
401 return pObjNew;
402}
Abc_ObjAssignName
ABC_DLL char * Abc_ObjAssignName(Abc_Obj_t *pObj, char *pName, char *pSuffix)
Definition abcNames.c:69
Hop_Transfer
Hop_Obj_t * Hop_Transfer(Hop_Man_t *pSour, Hop_Man_t *pDest, Hop_Obj_t *pObj, int nVars)
Definition hopDfs.c:353
Abc_Ntk_t_::nBarBufs2
int nBarBufs2
Definition abc.h:175
Abc_Ntk_t_::ntkFunc
Abc_NtkFunc_t ntkFunc
Definition abc.h:157
Abc_Obj_t_::pCopy
Abc_Obj_t * pCopy
Definition abc.h:148
Abc_Obj_t_::fPersist
unsigned fPersist
Definition abc.h:139
Here is the call graph for this function:

◆ Abc_NtkFindCi()

Abc_Obj_t * Abc_NtkFindCi ( Abc_Ntk_t * pNtk,
char * pName )

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

Synopsis [Returns CI with the given name.]

Description []

SideEffects []

SeeAlso []

Definition at line 538 of file abcObj.c.

539{
540 int Num;
541 assert( !Abc_NtkIsNetlist(pNtk) );
542 Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_PI );
543 if ( Num >= 0 )
544 return Abc_NtkObj( pNtk, Num );
545 Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_BO );
546 if ( Num >= 0 )
547 return Abc_NtkObj( pNtk, Num );
548 return NULL;
549}
Nm_ManFindIdByName
int Nm_ManFindIdByName(Nm_Man_t *p, char *pName, int Type)
Definition nmApi.c:219
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkFindCo()

Abc_Obj_t * Abc_NtkFindCo ( Abc_Ntk_t * pNtk,
char * pName )

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

Synopsis [Returns CO with the given name.]

Description []

SideEffects []

SeeAlso []

Definition at line 562 of file abcObj.c.

563{
564 int Num;
565 assert( !Abc_NtkIsNetlist(pNtk) );
566 Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_PO );
567 if ( Num >= 0 )
568 return Abc_NtkObj( pNtk, Num );
569 Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_BI );
570 if ( Num >= 0 )
571 return Abc_NtkObj( pNtk, Num );
572 return NULL;
573}
Here is the call graph for this function:

◆ Abc_NtkFindNet()

Abc_Obj_t * Abc_NtkFindNet ( Abc_Ntk_t * pNtk,
char * pName )

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

Synopsis [Returns the net with the given name.]

Description []

SideEffects []

SeeAlso []

Definition at line 515 of file abcObj.c.

516{
517 Abc_Obj_t * pNet;
518 int ObjId;
519 assert( Abc_NtkIsNetlist(pNtk) );
520 ObjId = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_NET );
521 if ( ObjId == -1 )
522 return NULL;
523 pNet = Abc_NtkObj( pNtk, ObjId );
524 return pNet;
525}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkFindNode()

Abc_Obj_t * Abc_NtkFindNode ( Abc_Ntk_t * pNtk,
char * pName )

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

Synopsis [Returns the net with the given name.]

Description []

SideEffects []

SeeAlso []

Definition at line 464 of file abcObj.c.

465{
466 Abc_Obj_t * pObj;
467 int Num;
468 // try to find the terminal
469 Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_PO );
470 if ( Num >= 0 )
471 return Abc_ObjFanin0( Abc_NtkObj( pNtk, Num ) );
472 Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_BI );
473 if ( Num >= 0 )
474 return Abc_ObjFanin0( Abc_NtkObj( pNtk, Num ) );
475 Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_NODE );
476 if ( Num >= 0 )
477 return Abc_NtkObj( pNtk, Num );
478 // find the internal node
479 if ( pName[0] != 'n' )
480 {
481 printf( "Name \"%s\" is not found among CO or node names (internal names often look as \"n<num>\").\n", pName );
482 return NULL;
483 }
484 Num = atoi( pName + 1 );
485 if ( Num < 0 || Num >= Abc_NtkObjNumMax(pNtk) )
486 {
487 printf( "The node \"%s\" with ID %d is not in the current network.\n", pName, Num );
488 return NULL;
489 }
490 pObj = Abc_NtkObj( pNtk, Num );
491 if ( pObj == NULL )
492 {
493 printf( "The node \"%s\" with ID %d has been removed from the current network.\n", pName, Num );
494 return NULL;
495 }
496 if ( !Abc_ObjIsNode(pObj) )
497 {
498 printf( "Object with ID %d is not a node.\n", Num );
499 return NULL;
500 }
501 return pObj;
502}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_NtkFindOrCreateNet()

Abc_Obj_t * Abc_NtkFindOrCreateNet ( Abc_Ntk_t * pNtk,
char * pName )

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

Synopsis [Finds or creates the net.]

Description []

SideEffects []

SeeAlso []

Definition at line 587 of file abcObj.c.

588{
589 Abc_Obj_t * pNet;
590 assert( Abc_NtkIsNetlist(pNtk) );
591 if ( pName && (pNet = Abc_NtkFindNet( pNtk, pName )) )
592 return pNet;
593//printf( "Creating net %s.\n", pName );
594 // create a new net
595 pNet = Abc_NtkCreateNet( pNtk );
596 if ( pName )
597 Nm_ManStoreIdName( pNtk->pManName, pNet->Id, pNet->Type, pName, NULL );
598 return pNet;
599}
Abc_NtkFindNet
Abc_Obj_t * Abc_NtkFindNet(Abc_Ntk_t *pNtk, char *pName)
Definition abcObj.c:515
Nm_ManStoreIdName
char * Nm_ManStoreIdName(Nm_Man_t *p, int ObjId, int Type, char *pName, char *pSuffix)
Definition nmApi.c:112
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_ObjAlloc()

ABC_NAMESPACE_IMPL_START Abc_Obj_t * Abc_ObjAlloc ( Abc_Ntk_t * pNtk,
Abc_ObjType_t Type )

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.

53{
54 Abc_Obj_t * pObj;
55 if ( pNtk->pMmObj )
56 pObj = (Abc_Obj_t *)Mem_FixedEntryFetch( pNtk->pMmObj );
57 else
58 pObj = (Abc_Obj_t *)ABC_ALLOC( Abc_Obj_t, 1 );
59 memset( pObj, 0, sizeof(Abc_Obj_t) );
60 pObj->pNtk = pNtk;
61 pObj->Type = Type;
62 pObj->Id = -1;
63 return pObj;
64}
ABC_ALLOC
#define ABC_ALLOC(type, num)
Definition abc_global.h:264
Mem_FixedEntryFetch
char * Mem_FixedEntryFetch(Mem_Fixed_t *p)
Definition mem.c:184
Abc_Ntk_t_::pMmObj
Mem_Fixed_t * pMmObj
Definition abc.h:189
memset
char * memset()
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_ObjRecycle()

void Abc_ObjRecycle ( Abc_Obj_t * pObj)

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

Synopsis [Recycles the object.]

Description []

SideEffects []

SeeAlso []

Definition at line 77 of file abcObj.c.

78{
79 Abc_Ntk_t * pNtk = pObj->pNtk;
80// int LargePiece = (4 << ABC_NUM_STEPS);
81 // free large fanout arrays
82// if ( pNtk->pMmStep && pObj->vFanouts.nCap * 4 > LargePiece )
83// free( pObj->vFanouts.pArray );
84 if ( pNtk->pMmStep == NULL )
85 {
86 ABC_FREE( pObj->vFanouts.pArray );
87 ABC_FREE( pObj->vFanins.pArray );
88 }
89 // clean the memory to make deleted object distinct from the live one
90 memset( pObj, 0, sizeof(Abc_Obj_t) );
91 // recycle the object
92 if ( pNtk->pMmObj )
93 Mem_FixedEntryRecycle( pNtk->pMmObj, (char *)pObj );
94 else
95 ABC_FREE( pObj );
96}
ABC_FREE
#define ABC_FREE(obj)
Definition abc_global.h:267
Mem_FixedEntryRecycle
void Mem_FixedEntryRecycle(Mem_Fixed_t *p, char *pEntry)
Definition mem.c:235
Abc_Ntk_t_::pMmStep
Mem_Step_t * pMmStep
Definition abc.h:190
Abc_Obj_t_::vFanouts
Vec_Int_t vFanouts
Definition abc.h:144
Here is the call graph for this function:
Here is the caller graph for this function: