abc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
giaAig.h File Reference
#include "aig/aig/aig.h"
#include "gia.h"

Go to the source code of this file.

Functions

ABC_NAMESPACE_HEADER_START
Gia_Man_t
Gia_ManFromAig (Aig_Man_t *p)
 INCLUDES ///. More...
 
Gia_Man_tGia_ManFromAigChoices (Aig_Man_t *p)
 
Gia_Man_tGia_ManFromAigSimple (Aig_Man_t *p)
 
Gia_Man_tGia_ManFromAigSwitch (Aig_Man_t *p)
 
Aig_Man_tGia_ManToAig (Gia_Man_t *p, int fChoices)
 
Aig_Man_tGia_ManToAigSkip (Gia_Man_t *p, int nOutDelta)
 
Aig_Man_tGia_ManToAigSimple (Gia_Man_t *p)
 
void Gia_ManReprToAigRepr (Aig_Man_t *pAig, Gia_Man_t *pGia)
 
void Gia_ManReprToAigRepr2 (Aig_Man_t *pAig, Gia_Man_t *pGia)
 
void Gia_ManReprFromAigRepr (Aig_Man_t *pAig, Gia_Man_t *pGia)
 
void Gia_ManReprFromAigRepr2 (Aig_Man_t *pAig, Gia_Man_t *pGia)
 
Gia_Man_tGia_ManCompress2 (Gia_Man_t *p, int fUpdateLevel, int fVerbose)
 
Gia_Man_tGia_ManPerformDch (Gia_Man_t *p, void *pPars)
 
Gia_Man_tGia_ManAbstraction (Gia_Man_t *p, Vec_Int_t *vFlops)
 
void Gia_ManSeqCleanupClasses (Gia_Man_t *p, int fConst, int fEquiv, int fVerbose)
 
int Gia_ManSolveSat (Gia_Man_t *p)
 

Function Documentation

Gia_Man_t* Gia_ManAbstraction ( Gia_Man_t p,
Vec_Int_t vFlops 
)
Gia_Man_t* Gia_ManCompress2 ( Gia_Man_t p,
int  fUpdateLevel,
int  fVerbose 
)

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

Synopsis [Applies DC2 to the GIA manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 551 of file giaAig.c.

552 {
553  Gia_Man_t * pGia;
554  Aig_Man_t * pNew, * pTemp;
555  if ( p->pManTime && p->vLevels == NULL )
557  pNew = Gia_ManToAig( p, 0 );
558  pNew = Dar_ManCompress2( pTemp = pNew, 1, fUpdateLevel, 1, 0, fVerbose );
559  Aig_ManStop( pTemp );
560  pGia = Gia_ManFromAig( pNew );
561  Aig_ManStop( pNew );
562  Gia_ManTransferTiming( pGia, p );
563  return pGia;
564 }
typedefABC_NAMESPACE_HEADER_START struct Aig_Man_t_ Aig_Man_t
INCLUDES ///.
Definition: aig.h:50
void Aig_ManStop(Aig_Man_t *p)
Definition: aigMan.c:187
int Gia_ManLevelWithBoxes(Gia_Man_t *p)
Definition: giaTim.c:469
Gia_Man_t * Gia_ManFromAig(Aig_Man_t *p)
INCLUDES ///.
Definition: giaAig.c:73
Aig_Man_t * Dar_ManCompress2(Aig_Man_t *pAig, int fBalance, int fUpdateLevel, int fFanout, int fPower, int fVerbose)
Definition: darScript.c:235
Aig_Man_t * Gia_ManToAig(Gia_Man_t *p, int fChoices)
Definition: giaAig.c:277
void * pManTime
Definition: gia.h:165
void Gia_ManTransferTiming(Gia_Man_t *p, Gia_Man_t *pGia)
Definition: giaIf.c:1912
Definition: gia.h:95
Vec_Int_t * vLevels
Definition: gia.h:115

INCLUDES ///.

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

FileName [giaAig.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Scalable AIG package.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id:
giaAig.h,v 1.00 2005/06/20 00:00:00 alanmi Exp

]PARAMETERS ///BASIC TYPES ///MACRO DEFINITIONS ///FUNCTION DECLARATIONS ///

Definition at line 73 of file giaAig.c.

74 {
75  Gia_Man_t * pNew;
76  Aig_Obj_t * pObj;
77  int i;
78  // create the new manager
79  pNew = Gia_ManStart( Aig_ManObjNum(p) );
80  pNew->pName = Abc_UtilStrsav( p->pName );
81  pNew->pSpec = Abc_UtilStrsav( p->pSpec );
82  pNew->nConstrs = p->nConstrs;
83  // create room to store equivalences
84  if ( p->pEquivs )
85  pNew->pNexts = ABC_CALLOC( int, Aig_ManObjNum(p) );
86  // create the PIs
88  Aig_ManConst1(p)->iData = 1;
89  Aig_ManForEachCi( p, pObj, i )
90  pObj->iData = Gia_ManAppendCi( pNew );
91  // add logic for the POs
92  Aig_ManForEachCo( p, pObj, i )
93  Gia_ManFromAig_rec( pNew, p, Aig_ObjFanin0(pObj) );
94  Aig_ManForEachCo( p, pObj, i )
95  Gia_ManAppendCo( pNew, Gia_ObjChild0Copy(pObj) );
96  Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) );
97  if ( pNew->pNexts )
98  Gia_ManDeriveReprs( pNew );
99  return pNew;
100 }
void Gia_ManDeriveReprs(Gia_Man_t *p)
Definition: giaEquiv.c:129
int * pNexts
Definition: gia.h:122
static int Gia_ManAppendCo(Gia_Man_t *p, int iLit0)
Definition: gia.h:703
static Llb_Mgr_t * p
Definition: llb3Image.c:950
static int Aig_ManObjNum(Aig_Man_t *p)
Definition: aig.h:258
static int Gia_ManAppendCi(Gia_Man_t *p)
Definition: gia.h:583
static Aig_Obj_t * Aig_ObjFanin0(Aig_Obj_t *pObj)
Definition: aig.h:308
#define Aig_ManForEachCi(p, pObj, i)
ITERATORS ///.
Definition: aig.h:393
#define Aig_ManForEachCo(p, pObj, i)
Definition: aig.h:398
void Gia_ManSetRegNum(Gia_Man_t *p, int nRegs)
Definition: giaMan.c:628
int nConstrs
Definition: gia.h:117
char * pName
Definition: gia.h:97
if(last==0)
Definition: sparse_int.h:34
char * pSpec
Definition: gia.h:98
Gia_Man_t * Gia_ManStart(int nObjsMax)
DECLARATIONS ///.
Definition: giaMan.c:52
void Gia_ManFromAig_rec(Gia_Man_t *pNew, Aig_Man_t *p, Aig_Obj_t *pObj)
FUNCTION DEFINITIONS ///.
Definition: giaAig.c:54
Definition: aig.h:69
static Aig_Obj_t * Aig_ManConst1(Aig_Man_t *p)
Definition: aig.h:264
int iData
Definition: aig.h:88
static int Aig_ManRegNum(Aig_Man_t *p)
Definition: aig.h:260
Definition: gia.h:95
#define ABC_CALLOC(type, num)
Definition: abc_global.h:230
static ABC_NAMESPACE_IMPL_START int Gia_ObjChild0Copy(Aig_Obj_t *pObj)
DECLARATIONS ///.
Definition: giaAig.c:33
char * Abc_UtilStrsav(char *s)
Definition: starter.c:47
void Aig_ManCleanData(Aig_Man_t *p)
Definition: aigUtil.c:205
Gia_Man_t* Gia_ManFromAigChoices ( Aig_Man_t p)

Definition at line 132 of file giaAig.c.

133 {
134  Gia_Man_t * pNew;
135  Aig_Obj_t * pObj;
136  int i;
137  assert( p->pEquivs != NULL );
138  // create the new manager
139  pNew = Gia_ManStart( Aig_ManObjNum(p) );
140  pNew->pName = Abc_UtilStrsav( p->pName );
141  pNew->pSpec = Abc_UtilStrsav( p->pSpec );
142  pNew->nConstrs = p->nConstrs;
143  // create room to store equivalences
144  pNew->pSibls = ABC_CALLOC( int, Aig_ManObjNum(p) );
145  // create the PIs
146  Aig_ManCleanData( p );
147  Aig_ManConst1(p)->iData = 1;
148  Aig_ManForEachCi( p, pObj, i )
149  pObj->iData = Gia_ManAppendCi( pNew );
150  // add logic for the POs
151  Aig_ManForEachCo( p, pObj, i )
152  Gia_ManFromAigChoices_rec( pNew, p, Aig_ObjFanin0(pObj) );
153  Aig_ManForEachCo( p, pObj, i )
154  Gia_ManAppendCo( pNew, Gia_ObjChild0Copy(pObj) );
155  Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) );
156  assert( Gia_ManObjNum(pNew) == Aig_ManObjNum(p) );
157  return pNew;
158 }
static int Gia_ManAppendCo(Gia_Man_t *p, int iLit0)
Definition: gia.h:703
static Llb_Mgr_t * p
Definition: llb3Image.c:950
static int Aig_ManObjNum(Aig_Man_t *p)
Definition: aig.h:258
int * pSibls
Definition: gia.h:123
static int Gia_ManAppendCi(Gia_Man_t *p)
Definition: gia.h:583
static Aig_Obj_t * Aig_ObjFanin0(Aig_Obj_t *pObj)
Definition: aig.h:308
#define Aig_ManForEachCi(p, pObj, i)
ITERATORS ///.
Definition: aig.h:393
#define Aig_ManForEachCo(p, pObj, i)
Definition: aig.h:398
void Gia_ManSetRegNum(Gia_Man_t *p, int nRegs)
Definition: giaMan.c:628
void Gia_ManFromAigChoices_rec(Gia_Man_t *pNew, Aig_Man_t *p, Aig_Obj_t *pObj)
Definition: giaAig.c:113
int nConstrs
Definition: gia.h:117
char * pName
Definition: gia.h:97
char * pSpec
Definition: gia.h:98
Gia_Man_t * Gia_ManStart(int nObjsMax)
DECLARATIONS ///.
Definition: giaMan.c:52
Definition: aig.h:69
static Aig_Obj_t * Aig_ManConst1(Aig_Man_t *p)
Definition: aig.h:264
int iData
Definition: aig.h:88
static int Aig_ManRegNum(Aig_Man_t *p)
Definition: aig.h:260
Definition: gia.h:95
#define ABC_CALLOC(type, num)
Definition: abc_global.h:230
#define assert(ex)
Definition: util_old.h:213
static ABC_NAMESPACE_IMPL_START int Gia_ObjChild0Copy(Aig_Obj_t *pObj)
DECLARATIONS ///.
Definition: giaAig.c:33
char * Abc_UtilStrsav(char *s)
Definition: starter.c:47
void Aig_ManCleanData(Aig_Man_t *p)
Definition: aigUtil.c:205
static int Gia_ManObjNum(Gia_Man_t *p)
Definition: gia.h:388
Gia_Man_t* Gia_ManFromAigSimple ( Aig_Man_t p)

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

Synopsis [Duplicates AIG in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 171 of file giaAig.c.

172 {
173  Gia_Man_t * pNew;
174  Aig_Obj_t * pObj;
175  int i;
176  // create the new manager
177  pNew = Gia_ManStart( Aig_ManObjNum(p) );
178  pNew->pName = Abc_UtilStrsav( p->pName );
179  pNew->pSpec = Abc_UtilStrsav( p->pSpec );
180  pNew->nConstrs = p->nConstrs;
181  // create the PIs
182  Aig_ManCleanData( p );
183  Aig_ManForEachObj( p, pObj, i )
184  {
185  if ( Aig_ObjIsAnd(pObj) )
186  pObj->iData = Gia_ManAppendAnd( pNew, Gia_ObjChild0Copy(pObj), Gia_ObjChild1Copy(pObj) );
187  else if ( Aig_ObjIsCi(pObj) )
188  pObj->iData = Gia_ManAppendCi( pNew );
189  else if ( Aig_ObjIsCo(pObj) )
190  pObj->iData = Gia_ManAppendCo( pNew, Gia_ObjChild0Copy(pObj) );
191  else if ( Aig_ObjIsConst1(pObj) )
192  pObj->iData = 1;
193  else
194  assert( 0 );
195  }
196  Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) );
197  return pNew;
198 }
static int Gia_ManAppendAnd(Gia_Man_t *p, int iLit0, int iLit1)
Definition: gia.h:592
static int Gia_ManAppendCo(Gia_Man_t *p, int iLit0)
Definition: gia.h:703
static Llb_Mgr_t * p
Definition: llb3Image.c:950
static int Aig_ManObjNum(Aig_Man_t *p)
Definition: aig.h:258
static int Gia_ManAppendCi(Gia_Man_t *p)
Definition: gia.h:583
void Gia_ManSetRegNum(Gia_Man_t *p, int nRegs)
Definition: giaMan.c:628
int nConstrs
Definition: gia.h:117
char * pName
Definition: gia.h:97
char * pSpec
Definition: gia.h:98
static int Aig_ObjIsConst1(Aig_Obj_t *pObj)
Definition: aig.h:274
Gia_Man_t * Gia_ManStart(int nObjsMax)
DECLARATIONS ///.
Definition: giaMan.c:52
Definition: aig.h:69
int iData
Definition: aig.h:88
static int Aig_ManRegNum(Aig_Man_t *p)
Definition: aig.h:260
#define Aig_ManForEachObj(p, pObj, i)
Definition: aig.h:403
Definition: gia.h:95
#define assert(ex)
Definition: util_old.h:213
static int Gia_ObjChild1Copy(Aig_Obj_t *pObj)
Definition: giaAig.c:34
static ABC_NAMESPACE_IMPL_START int Gia_ObjChild0Copy(Aig_Obj_t *pObj)
DECLARATIONS ///.
Definition: giaAig.c:33
static int Aig_ObjIsCi(Aig_Obj_t *pObj)
Definition: aig.h:275
char * Abc_UtilStrsav(char *s)
Definition: starter.c:47
void Aig_ManCleanData(Aig_Man_t *p)
Definition: aigUtil.c:205
static int Aig_ObjIsCo(Aig_Obj_t *pObj)
Definition: aig.h:276
static int Aig_ObjIsAnd(Aig_Obj_t *pObj)
Definition: aig.h:278
Gia_Man_t* Gia_ManFromAigSwitch ( Aig_Man_t p)

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

Synopsis [Handles choices as additional combinational outputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 211 of file giaAig.c.

212 {
213  Gia_Man_t * pNew;
214  Aig_Obj_t * pObj;
215  int i;
216  // create the new manager
217  pNew = Gia_ManStart( Aig_ManObjNum(p) );
218  pNew->pName = Abc_UtilStrsav( p->pName );
219  pNew->pSpec = Abc_UtilStrsav( p->pSpec );
220  pNew->nConstrs = p->nConstrs;
221  // create the PIs
222  Aig_ManCleanData( p );
223  Aig_ManConst1(p)->iData = 1;
224  Aig_ManForEachCi( p, pObj, i )
225  pObj->iData = Gia_ManAppendCi( pNew );
226  // add POs corresponding to the nodes with choices
227  Aig_ManForEachNode( p, pObj, i )
228  if ( Aig_ObjRefs(pObj) == 0 )
229  {
230  Gia_ManFromAig_rec( pNew, p, pObj );
231  Gia_ManAppendCo( pNew, pObj->iData );
232  }
233  // add logic for the POs
234  Aig_ManForEachCo( p, pObj, i )
235  Gia_ManFromAig_rec( pNew, p, Aig_ObjFanin0(pObj) );
236  Aig_ManForEachCo( p, pObj, i )
237  pObj->iData = Gia_ManAppendCo( pNew, Gia_ObjChild0Copy(pObj) );
238  Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) );
239  return pNew;
240 }
static int Gia_ManAppendCo(Gia_Man_t *p, int iLit0)
Definition: gia.h:703
static Llb_Mgr_t * p
Definition: llb3Image.c:950
static int Aig_ManObjNum(Aig_Man_t *p)
Definition: aig.h:258
static int Gia_ManAppendCi(Gia_Man_t *p)
Definition: gia.h:583
static Aig_Obj_t * Aig_ObjFanin0(Aig_Obj_t *pObj)
Definition: aig.h:308
#define Aig_ManForEachCi(p, pObj, i)
ITERATORS ///.
Definition: aig.h:393
#define Aig_ManForEachCo(p, pObj, i)
Definition: aig.h:398
void Gia_ManSetRegNum(Gia_Man_t *p, int nRegs)
Definition: giaMan.c:628
int nConstrs
Definition: gia.h:117
#define Aig_ManForEachNode(p, pObj, i)
Definition: aig.h:413
char * pName
Definition: gia.h:97
if(last==0)
Definition: sparse_int.h:34
char * pSpec
Definition: gia.h:98
Gia_Man_t * Gia_ManStart(int nObjsMax)
DECLARATIONS ///.
Definition: giaMan.c:52
void Gia_ManFromAig_rec(Gia_Man_t *pNew, Aig_Man_t *p, Aig_Obj_t *pObj)
FUNCTION DEFINITIONS ///.
Definition: giaAig.c:54
Definition: aig.h:69
static Aig_Obj_t * Aig_ManConst1(Aig_Man_t *p)
Definition: aig.h:264
int iData
Definition: aig.h:88
static int Aig_ManRegNum(Aig_Man_t *p)
Definition: aig.h:260
Definition: gia.h:95
static int Aig_ObjRefs(Aig_Obj_t *pObj)
Definition: aig.h:300
static ABC_NAMESPACE_IMPL_START int Gia_ObjChild0Copy(Aig_Obj_t *pObj)
DECLARATIONS ///.
Definition: giaAig.c:33
char * Abc_UtilStrsav(char *s)
Definition: starter.c:47
void Aig_ManCleanData(Aig_Man_t *p)
Definition: aigUtil.c:205
Gia_Man_t* Gia_ManPerformDch ( Gia_Man_t p,
void *  pPars 
)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 577 of file giaAig.c.

578 {
579  Gia_Man_t * pGia;
580  Aig_Man_t * pNew;
581  if ( p->pManTime && p->vLevels == NULL )
583  pNew = Gia_ManToAig( p, 0 );
584  pNew = Dar_ManChoiceNew( pNew, (Dch_Pars_t *)pPars );
585 // pGia = Gia_ManFromAig( pNew );
586  pGia = Gia_ManFromAigChoices( pNew );
587  Aig_ManStop( pNew );
588  Gia_ManTransferTiming( pGia, p );
589  return pGia;
590 }
Aig_Man_t * Dar_ManChoiceNew(Aig_Man_t *pAig, Dch_Pars_t *pPars)
Definition: darScript.c:849
typedefABC_NAMESPACE_HEADER_START struct Aig_Man_t_ Aig_Man_t
INCLUDES ///.
Definition: aig.h:50
void Aig_ManStop(Aig_Man_t *p)
Definition: aigMan.c:187
int Gia_ManLevelWithBoxes(Gia_Man_t *p)
Definition: giaTim.c:469
typedefABC_NAMESPACE_HEADER_START struct Dch_Pars_t_ Dch_Pars_t
INCLUDES ///.
Definition: dch.h:43
Aig_Man_t * Gia_ManToAig(Gia_Man_t *p, int fChoices)
Definition: giaAig.c:277
void * pManTime
Definition: gia.h:165
void Gia_ManTransferTiming(Gia_Man_t *p, Gia_Man_t *pGia)
Definition: giaIf.c:1912
Definition: gia.h:95
Vec_Int_t * vLevels
Definition: gia.h:115
Gia_Man_t * Gia_ManFromAigChoices(Aig_Man_t *p)
Definition: giaAig.c:132
void Gia_ManReprFromAigRepr ( Aig_Man_t pAig,
Gia_Man_t pGia 
)

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

Synopsis [Transfers representatives from pAig to pGia.]

Description []

SideEffects []

SeeAlso []

Definition at line 487 of file giaAig.c.

488 {
489  Gia_Obj_t * pObjGia;
490  Aig_Obj_t * pObjAig, * pReprAig;
491  int i;
492  assert( pAig->pReprs != NULL );
493  assert( pGia->pReprs == NULL );
494  assert( Gia_ManObjNum(pGia) - Gia_ManCoNum(pGia) == Aig_ManObjNum(pAig) - Aig_ManCoNum(pAig) );
495  pGia->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(pGia) );
496  for ( i = 0; i < Gia_ManObjNum(pGia); i++ )
497  Gia_ObjSetRepr( pGia, i, GIA_VOID );
498  // move pointers from GIA to AIG
499  Gia_ManForEachObj( pGia, pObjGia, i )
500  {
501  if ( Gia_ObjIsCo(pObjGia) )
502  continue;
503  assert( i == 0 || !Abc_LitIsCompl(Gia_ObjValue(pObjGia)) );
504  pObjAig = Aig_ManObj( pAig, Abc_Lit2Var(Gia_ObjValue(pObjGia)) );
505  pObjAig->iData = i;
506  }
507  Aig_ManForEachObj( pAig, pObjAig, i )
508  {
509  if ( Aig_ObjIsCo(pObjAig) )
510  continue;
511  if ( pAig->pReprs[i] == NULL )
512  continue;
513  pReprAig = pAig->pReprs[i];
514  Gia_ObjSetRepr( pGia, pObjAig->iData, pReprAig->iData );
515  }
516  pGia->pNexts = Gia_ManDeriveNexts( pGia );
517 }
int * pNexts
Definition: gia.h:122
static int Aig_ManObjNum(Aig_Man_t *p)
Definition: aig.h:258
static int Gia_ObjValue(Gia_Obj_t *pObj)
Definition: gia.h:413
static Aig_Obj_t * Aig_ManObj(Aig_Man_t *p, int i)
Definition: aig.h:270
Definition: gia.h:75
static void Gia_ObjSetRepr(Gia_Man_t *p, int Id, int Num)
Definition: gia.h:888
static int Aig_ManCoNum(Aig_Man_t *p)
Definition: aig.h:252
static int Abc_LitIsCompl(int Lit)
Definition: abc_global.h:265
Definition: aig.h:69
int * Gia_ManDeriveNexts(Gia_Man_t *p)
Definition: giaEquiv.c:97
static int Gia_ObjIsCo(Gia_Obj_t *pObj)
Definition: gia.h:421
int iData
Definition: aig.h:88
#define GIA_VOID
Definition: gia.h:45
#define Aig_ManForEachObj(p, pObj, i)
Definition: aig.h:403
#define Gia_ManForEachObj(p, pObj, i)
MACRO DEFINITIONS ///.
Definition: gia.h:984
static int Abc_Lit2Var(int Lit)
Definition: abc_global.h:264
#define ABC_CALLOC(type, num)
Definition: abc_global.h:230
Gia_Rpr_t * pReprs
Definition: gia.h:121
#define assert(ex)
Definition: util_old.h:213
Definition: gia.h:56
static int Aig_ObjIsCo(Aig_Obj_t *pObj)
Definition: aig.h:276
static int Gia_ManObjNum(Gia_Man_t *p)
Definition: gia.h:388
static int Gia_ManCoNum(Gia_Man_t *p)
Definition: gia.h:384
void Gia_ManReprFromAigRepr2 ( Aig_Man_t pAig,
Gia_Man_t pGia 
)

Definition at line 518 of file giaAig.c.

519 {
520  Aig_Obj_t * pObjAig, * pReprAig;
521  int i;
522  assert( pAig->pReprs != NULL );
523  assert( pGia->pReprs == NULL );
524  assert( Gia_ManObjNum(pGia) - Gia_ManCoNum(pGia) == Aig_ManObjNum(pAig) - Aig_ManCoNum(pAig) );
525  pGia->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(pGia) );
526  for ( i = 0; i < Gia_ManObjNum(pGia); i++ )
527  Gia_ObjSetRepr( pGia, i, GIA_VOID );
528  Aig_ManForEachObj( pAig, pObjAig, i )
529  {
530  if ( Aig_ObjIsCo(pObjAig) )
531  continue;
532  if ( pAig->pReprs[i] == NULL )
533  continue;
534  pReprAig = pAig->pReprs[i];
535  Gia_ObjSetRepr( pGia, Abc_Lit2Var(pObjAig->iData), Abc_Lit2Var(pReprAig->iData) );
536  }
537  pGia->pNexts = Gia_ManDeriveNexts( pGia );
538 }
int * pNexts
Definition: gia.h:122
static int Aig_ManObjNum(Aig_Man_t *p)
Definition: aig.h:258
static void Gia_ObjSetRepr(Gia_Man_t *p, int Id, int Num)
Definition: gia.h:888
static int Aig_ManCoNum(Aig_Man_t *p)
Definition: aig.h:252
Definition: aig.h:69
int * Gia_ManDeriveNexts(Gia_Man_t *p)
Definition: giaEquiv.c:97
int iData
Definition: aig.h:88
#define GIA_VOID
Definition: gia.h:45
#define Aig_ManForEachObj(p, pObj, i)
Definition: aig.h:403
static int Abc_Lit2Var(int Lit)
Definition: abc_global.h:264
#define ABC_CALLOC(type, num)
Definition: abc_global.h:230
Gia_Rpr_t * pReprs
Definition: gia.h:121
#define assert(ex)
Definition: util_old.h:213
Definition: gia.h:56
static int Aig_ObjIsCo(Aig_Obj_t *pObj)
Definition: aig.h:276
static int Gia_ManObjNum(Gia_Man_t *p)
Definition: gia.h:388
static int Gia_ManCoNum(Gia_Man_t *p)
Definition: gia.h:384
void Gia_ManReprToAigRepr ( Aig_Man_t pAig,
Gia_Man_t pGia 
)

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

Synopsis [Transfers representatives from pGia to pAig.]

Description [Assumes that pGia was created from pAig.]

SideEffects []

SeeAlso []

Definition at line 435 of file giaAig.c.

436 {
437  Aig_Obj_t * pObj;
438  Gia_Obj_t * pGiaObj, * pGiaRepr;
439  int i;
440  assert( pAig->pReprs == NULL );
441  assert( pGia->pReprs != NULL );
442  // move pointers from AIG to GIA
443  Aig_ManForEachObj( pAig, pObj, i )
444  {
445  assert( i == 0 || !Abc_LitIsCompl(pObj->iData) );
446  pGiaObj = Gia_ManObj( pGia, Abc_Lit2Var(pObj->iData) );
447  pGiaObj->Value = i;
448  }
449  // set the pointers to the nodes in AIG
450  Aig_ManReprStart( pAig, Aig_ManObjNumMax(pAig) );
451  Gia_ManForEachObj( pGia, pGiaObj, i )
452  {
453  pGiaRepr = Gia_ObjReprObj( pGia, i );
454  if ( pGiaRepr == NULL )
455  continue;
456  Aig_ObjCreateRepr( pAig, Aig_ManObj(pAig, pGiaRepr->Value), Aig_ManObj(pAig, pGiaObj->Value) );
457  }
458 }
static Aig_Obj_t * Aig_ManObj(Aig_Man_t *p, int i)
Definition: aig.h:270
static Gia_Obj_t * Gia_ManObj(Gia_Man_t *p, int v)
Definition: gia.h:402
Definition: gia.h:75
static int Abc_LitIsCompl(int Lit)
Definition: abc_global.h:265
void Aig_ManReprStart(Aig_Man_t *p, int nIdMax)
DECLARATIONS ///.
Definition: aigRepr.c:45
Definition: aig.h:69
static int Aig_ManObjNumMax(Aig_Man_t *p)
Definition: aig.h:259
static Gia_Obj_t * Gia_ObjReprObj(Gia_Man_t *p, int Id)
Definition: gia.h:886
int iData
Definition: aig.h:88
#define Aig_ManForEachObj(p, pObj, i)
Definition: aig.h:403
#define Gia_ManForEachObj(p, pObj, i)
MACRO DEFINITIONS ///.
Definition: gia.h:984
static int Abc_Lit2Var(int Lit)
Definition: abc_global.h:264
void Aig_ObjCreateRepr(Aig_Man_t *p, Aig_Obj_t *pNode1, Aig_Obj_t *pNode2)
Definition: aigRepr.c:83
Gia_Rpr_t * pReprs
Definition: gia.h:121
#define assert(ex)
Definition: util_old.h:213
unsigned Value
Definition: gia.h:87
void Gia_ManReprToAigRepr2 ( Aig_Man_t pAig,
Gia_Man_t pGia 
)

Definition at line 459 of file giaAig.c.

460 {
461  Gia_Obj_t * pGiaObj, * pGiaRepr;
462  int i;
463  assert( pAig->pReprs == NULL );
464  assert( pGia->pReprs != NULL );
465  // set the pointers to the nodes in AIG
466  Aig_ManReprStart( pAig, Aig_ManObjNumMax(pAig) );
467  Gia_ManForEachObj( pGia, pGiaObj, i )
468  {
469  pGiaRepr = Gia_ObjReprObj( pGia, i );
470  if ( pGiaRepr == NULL )
471  continue;
472  Aig_ObjCreateRepr( pAig, Aig_ManObj(pAig, Abc_Lit2Var(pGiaRepr->Value)), Aig_ManObj(pAig, Abc_Lit2Var(pGiaObj->Value)) );
473  }
474 }
static Aig_Obj_t * Aig_ManObj(Aig_Man_t *p, int i)
Definition: aig.h:270
Definition: gia.h:75
void Aig_ManReprStart(Aig_Man_t *p, int nIdMax)
DECLARATIONS ///.
Definition: aigRepr.c:45
static int Aig_ManObjNumMax(Aig_Man_t *p)
Definition: aig.h:259
static Gia_Obj_t * Gia_ObjReprObj(Gia_Man_t *p, int Id)
Definition: gia.h:886
#define Gia_ManForEachObj(p, pObj, i)
MACRO DEFINITIONS ///.
Definition: gia.h:984
static int Abc_Lit2Var(int Lit)
Definition: abc_global.h:264
void Aig_ObjCreateRepr(Aig_Man_t *p, Aig_Obj_t *pNode1, Aig_Obj_t *pNode2)
Definition: aigRepr.c:83
Gia_Rpr_t * pReprs
Definition: gia.h:121
#define assert(ex)
Definition: util_old.h:213
unsigned Value
Definition: gia.h:87
void Gia_ManSeqCleanupClasses ( Gia_Man_t p,
int  fConst,
int  fEquiv,
int  fVerbose 
)

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

Synopsis [Computes equivalences after structural sequential cleanup.]

Description []

SideEffects []

SeeAlso []

Definition at line 603 of file giaAig.c.

604 {
605  Aig_Man_t * pNew, * pTemp;
606  pNew = Gia_ManToAigSimple( p );
607  pTemp = Aig_ManScl( pNew, fConst, fEquiv, 0, -1, -1, fVerbose, 0 );
608  Gia_ManReprFromAigRepr( pNew, p );
609  Aig_ManStop( pTemp );
610  Aig_ManStop( pNew );
611 }
Aig_Man_t * Gia_ManToAigSimple(Gia_Man_t *p)
Definition: giaAig.c:367
void Gia_ManReprFromAigRepr(Aig_Man_t *pAig, Gia_Man_t *pGia)
Definition: giaAig.c:487
typedefABC_NAMESPACE_HEADER_START struct Aig_Man_t_ Aig_Man_t
INCLUDES ///.
Definition: aig.h:50
void Aig_ManStop(Aig_Man_t *p)
Definition: aigMan.c:187
Aig_Man_t * Aig_ManScl(Aig_Man_t *pAig, int fLatchConst, int fLatchEqual, int fUseMvSweep, int nFramesSymb, int nFramesSatur, int fVerbose, int fVeryVerbose)
Definition: aigScl.c:650
int Gia_ManSolveSat ( Gia_Man_t p)

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

Synopsis [Solves SAT problem.]

Description []

SideEffects []

SeeAlso []

Definition at line 624 of file giaAig.c.

625 {
626 // extern int Fra_FraigSat( Aig_Man_t * pMan, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, int fFlipBits, int fAndOuts, int fNewSolver, int fVerbose );
627  Aig_Man_t * pNew;
628  int RetValue;//, clk = Abc_Clock();
629  pNew = Gia_ManToAig( p, 0 );
630  RetValue = Fra_FraigSat( pNew, 10000000, 0, 0, 0, 0, 1, 1, 0, 0 );
631  if ( RetValue == 0 )
632  {
633  Gia_Obj_t * pObj;
634  int i, * pInit = (int *)pNew->pData;
635  Gia_ManConst0(p)->fMark0 = 0;
636  Gia_ManForEachPi( p, pObj, i )
637  pObj->fMark0 = pInit[i];
638  Gia_ManForEachAnd( p, pObj, i )
639  pObj->fMark0 = (Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj)) &
640  (Gia_ObjFanin1(pObj)->fMark0 ^ Gia_ObjFaninC1(pObj));
641  Gia_ManForEachPo( p, pObj, i )
642  pObj->fMark0 = (Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj));
643  Gia_ManForEachPo( p, pObj, i )
644  if ( pObj->fMark0 != 1 )
645  break;
646  if ( i != Gia_ManPoNum(p) )
647  Abc_Print( 1, "Counter-example verification has failed. " );
648 // else
649 // Abc_Print( 1, "Counter-example verification succeeded. " );
650  }
651 /*
652  else if ( RetValue == 1 )
653  Abc_Print( 1, "The SAT problem is unsatisfiable. " );
654  else if ( RetValue == -1 )
655  Abc_Print( 1, "The SAT problem is undecided. " );
656  Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
657 */
658  Aig_ManStop( pNew );
659  return RetValue;
660 }
static int Gia_ManPoNum(Gia_Man_t *p)
Definition: gia.h:386
static int Gia_ObjFaninC1(Gia_Obj_t *pObj)
Definition: gia.h:452
typedefABC_NAMESPACE_HEADER_START struct Aig_Man_t_ Aig_Man_t
INCLUDES ///.
Definition: aig.h:50
void Aig_ManStop(Aig_Man_t *p)
Definition: aigMan.c:187
Definition: gia.h:75
static Gia_Obj_t * Gia_ObjFanin0(Gia_Obj_t *pObj)
Definition: gia.h:454
if(last==0)
Definition: sparse_int.h:34
#define Gia_ManForEachAnd(p, pObj, i)
Definition: gia.h:1002
Aig_Man_t * Gia_ManToAig(Gia_Man_t *p, int fChoices)
Definition: giaAig.c:277
static int Counter
#define Gia_ManForEachPi(p, pObj, i)
Definition: gia.h:1034
static void Abc_Print(int level, const char *format,...)
Definition: abc_global.h:313
unsigned fMark0
Definition: gia.h:79
static Gia_Obj_t * Gia_ManConst0(Gia_Man_t *p)
Definition: gia.h:400
static Gia_Obj_t * Gia_ObjFanin1(Gia_Obj_t *pObj)
Definition: gia.h:455
static int Gia_ObjFaninC0(Gia_Obj_t *pObj)
Definition: gia.h:451
#define Gia_ManForEachPo(p, pObj, i)
Definition: gia.h:1036
int Fra_FraigSat(Aig_Man_t *pMan, ABC_INT64_T nConfLimit, ABC_INT64_T nInsLimit, int nLearnedStart, int nLearnedDelta, int nLearnedPerce, int fFlipBits, int fAndOuts, int fNewSolver, int fVerbose)
ITERATORS ///.
Definition: fraCec.c:47
Aig_Man_t* Gia_ManToAig ( Gia_Man_t p,
int  fChoices 
)

Definition at line 277 of file giaAig.c.

278 {
279  Aig_Man_t * pNew;
280  Aig_Obj_t ** ppNodes;
281  Gia_Obj_t * pObj;
282  int i;
283  assert( !fChoices || (p->pNexts && p->pReprs) );
284  // create the new manager
285  pNew = Aig_ManStart( Gia_ManAndNum(p) );
286  pNew->pName = Abc_UtilStrsav( p->pName );
287  pNew->pSpec = Abc_UtilStrsav( p->pSpec );
288  pNew->nConstrs = p->nConstrs;
289 // pNew->pSpec = Abc_UtilStrsav( p->pName );
290  // duplicate representation of choice nodes
291  if ( fChoices )
292  pNew->pEquivs = ABC_CALLOC( Aig_Obj_t *, Gia_ManObjNum(p) );
293  // create the PIs
294  ppNodes = ABC_CALLOC( Aig_Obj_t *, Gia_ManObjNum(p) );
295  ppNodes[0] = Aig_ManConst0(pNew);
296  Gia_ManForEachCi( p, pObj, i )
297  ppNodes[Gia_ObjId(p, pObj)] = Aig_ObjCreateCi( pNew );
298  // transfer level
299  if ( p->vLevels )
300  Gia_ManForEachCi( p, pObj, i )
301  Aig_ObjSetLevel( ppNodes[Gia_ObjId(p, pObj)], Gia_ObjLevel(p, pObj) );
302  // add logic for the POs
303  Gia_ManForEachCo( p, pObj, i )
304  {
305  Gia_ManToAig_rec( pNew, ppNodes, p, Gia_ObjFanin0(pObj) );
306  ppNodes[Gia_ObjId(p, pObj)] = Aig_ObjCreateCo( pNew, Gia_ObjChild0Copy2(ppNodes, pObj, Gia_ObjId(p, pObj)) );
307  }
308  Aig_ManSetRegNum( pNew, Gia_ManRegNum(p) );
309  ABC_FREE( ppNodes );
310  return pNew;
311 }
Aig_Obj_t * Aig_ObjCreateCo(Aig_Man_t *p, Aig_Obj_t *pDriver)
Definition: aigObj.c:66
static int Aig_ObjSetLevel(Aig_Obj_t *pObj, int i)
Definition: aig.h:325
#define Gia_ManForEachCo(p, pObj, i)
Definition: gia.h:1022
int * pNexts
Definition: gia.h:122
typedefABC_NAMESPACE_HEADER_START struct Aig_Man_t_ Aig_Man_t
INCLUDES ///.
Definition: aig.h:50
Aig_Man_t * Aig_ManStart(int nNodesMax)
DECLARATIONS ///.
Definition: aigMan.c:47
Aig_Obj_t * Aig_ObjCreateCi(Aig_Man_t *p)
DECLARATIONS ///.
Definition: aigObj.c:45
static Aig_Obj_t * Aig_ManConst0(Aig_Man_t *p)
Definition: aig.h:263
Definition: gia.h:75
#define Gia_ManForEachCi(p, pObj, i)
Definition: gia.h:1016
static int Gia_ManAndNum(Gia_Man_t *p)
Definition: gia.h:389
static int Gia_ObjLevel(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition: gia.h:501
static Gia_Obj_t * Gia_ObjFanin0(Gia_Obj_t *pObj)
Definition: gia.h:454
int nConstrs
Definition: gia.h:117
char * pName
Definition: gia.h:97
void Aig_ManSetRegNum(Aig_Man_t *p, int nRegs)
Definition: aigMan.c:438
static Aig_Obj_t * Gia_ObjChild0Copy2(Aig_Obj_t **ppNodes, Gia_Obj_t *pObj, int Id)
Definition: giaAig.c:36
if(last==0)
Definition: sparse_int.h:34
char * pSpec
Definition: gia.h:98
Definition: aig.h:69
static int Gia_ObjId(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition: gia.h:410
#define ABC_FREE(obj)
Definition: abc_global.h:232
void Gia_ManToAig_rec(Aig_Man_t *pNew, Aig_Obj_t **ppNodes, Gia_Man_t *p, Gia_Obj_t *pObj)
Definition: giaAig.c:253
#define ABC_CALLOC(type, num)
Definition: abc_global.h:230
Gia_Rpr_t * pReprs
Definition: gia.h:121
#define assert(ex)
Definition: util_old.h:213
char * Abc_UtilStrsav(char *s)
Definition: starter.c:47
static int Gia_ManObjNum(Gia_Man_t *p)
Definition: gia.h:388
static int Gia_ManRegNum(Gia_Man_t *p)
Definition: gia.h:387
Aig_Man_t* Gia_ManToAigSimple ( Gia_Man_t p)

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

Synopsis [Duplicates AIG in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 367 of file giaAig.c.

368 {
369  Aig_Man_t * pNew;
370  Aig_Obj_t ** ppNodes;
371  Gia_Obj_t * pObj;
372  int i;
373  ppNodes = ABC_FALLOC( Aig_Obj_t *, Gia_ManObjNum(p) );
374  // create the new manager
375  pNew = Aig_ManStart( Gia_ManObjNum(p) );
376  pNew->pName = Abc_UtilStrsav( p->pName );
377  pNew->pSpec = Abc_UtilStrsav( p->pSpec );
378  pNew->nConstrs = p->nConstrs;
379  // create the PIs
380  Gia_ManForEachObj( p, pObj, i )
381  {
382  if ( Gia_ObjIsAnd(pObj) )
383  ppNodes[i] = Aig_And( pNew, Gia_ObjChild0Copy2(ppNodes, pObj, Gia_ObjId(p, pObj)), Gia_ObjChild1Copy2(ppNodes, pObj, Gia_ObjId(p, pObj)) );
384  else if ( Gia_ObjIsCi(pObj) )
385  ppNodes[i] = Aig_ObjCreateCi( pNew );
386  else if ( Gia_ObjIsCo(pObj) )
387  ppNodes[i] = Aig_ObjCreateCo( pNew, Gia_ObjChild0Copy2(ppNodes, pObj, Gia_ObjId(p, pObj)) );
388  else if ( Gia_ObjIsConst0(pObj) )
389  ppNodes[i] = Aig_ManConst0(pNew);
390  else
391  assert( 0 );
392  pObj->Value = Abc_Var2Lit( Aig_ObjId(Aig_Regular(ppNodes[i])), Aig_IsComplement(ppNodes[i]) );
393  assert( i == 0 || Aig_ObjId(ppNodes[i]) == i );
394  }
395  Aig_ManSetRegNum( pNew, Gia_ManRegNum(p) );
396  ABC_FREE( ppNodes );
397  return pNew;
398 }
Aig_Obj_t * Aig_ObjCreateCo(Aig_Man_t *p, Aig_Obj_t *pDriver)
Definition: aigObj.c:66
static Aig_Obj_t * Gia_ObjChild1Copy2(Aig_Obj_t **ppNodes, Gia_Obj_t *pObj, int Id)
Definition: giaAig.c:37
typedefABC_NAMESPACE_HEADER_START struct Aig_Man_t_ Aig_Man_t
INCLUDES ///.
Definition: aig.h:50
static int Gia_ObjIsConst0(Gia_Obj_t *pObj)
Definition: gia.h:430
static int Abc_Var2Lit(int Var, int fCompl)
Definition: abc_global.h:263
Aig_Man_t * Aig_ManStart(int nNodesMax)
DECLARATIONS ///.
Definition: aigMan.c:47
static int Aig_IsComplement(Aig_Obj_t *p)
Definition: aig.h:249
static Aig_Obj_t * Aig_Regular(Aig_Obj_t *p)
Definition: aig.h:246
Aig_Obj_t * Aig_ObjCreateCi(Aig_Man_t *p)
DECLARATIONS ///.
Definition: aigObj.c:45
static Aig_Obj_t * Aig_ManConst0(Aig_Man_t *p)
Definition: aig.h:263
Definition: gia.h:75
Aig_Obj_t * Aig_And(Aig_Man_t *p, Aig_Obj_t *p0, Aig_Obj_t *p1)
Definition: aigOper.c:104
int nConstrs
Definition: gia.h:117
char * pName
Definition: gia.h:97
void Aig_ManSetRegNum(Aig_Man_t *p, int nRegs)
Definition: aigMan.c:438
static Aig_Obj_t * Gia_ObjChild0Copy2(Aig_Obj_t **ppNodes, Gia_Obj_t *pObj, int Id)
Definition: giaAig.c:36
char * pSpec
Definition: gia.h:98
Definition: aig.h:69
static int Gia_ObjId(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition: gia.h:410
static int Gia_ObjIsCo(Gia_Obj_t *pObj)
Definition: gia.h:421
#define ABC_FREE(obj)
Definition: abc_global.h:232
static int Gia_ObjIsAnd(Gia_Obj_t *pObj)
Definition: gia.h:422
#define Gia_ManForEachObj(p, pObj, i)
MACRO DEFINITIONS ///.
Definition: gia.h:984
static int Aig_ObjId(Aig_Obj_t *pObj)
Definition: aig.h:286
#define assert(ex)
Definition: util_old.h:213
unsigned Value
Definition: gia.h:87
static int Gia_ObjIsCi(Gia_Obj_t *pObj)
Definition: gia.h:420
char * Abc_UtilStrsav(char *s)
Definition: starter.c:47
static int Gia_ManObjNum(Gia_Man_t *p)
Definition: gia.h:388
#define ABC_FALLOC(type, num)
Definition: abc_global.h:231
static int Gia_ManRegNum(Gia_Man_t *p)
Definition: gia.h:387
Aig_Man_t* Gia_ManToAigSkip ( Gia_Man_t p,
int  nOutDelta 
)

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

Synopsis [Duplicates AIG in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 324 of file giaAig.c.

325 {
326  Aig_Man_t * pNew;
327  Aig_Obj_t ** ppNodes;
328  Gia_Obj_t * pObj;
329  int i;
330  assert( p->pNexts == NULL && p->pReprs == NULL );
331  assert( nOutDelta > 0 && Gia_ManCoNum(p) % nOutDelta == 0 );
332  // create the new manager
333  pNew = Aig_ManStart( Gia_ManAndNum(p) );
334  pNew->pName = Abc_UtilStrsav( p->pName );
335  pNew->pSpec = Abc_UtilStrsav( p->pSpec );
336  pNew->nConstrs = p->nConstrs;
337 // pNew->pSpec = Abc_UtilStrsav( p->pName );
338  // create the PIs
339  ppNodes = ABC_CALLOC( Aig_Obj_t *, Gia_ManObjNum(p) );
340  ppNodes[0] = Aig_ManConst0(pNew);
341  Gia_ManForEachCi( p, pObj, i )
342  ppNodes[Gia_ObjId(p, pObj)] = Aig_ObjCreateCi( pNew );
343  // add logic for the POs
344  Gia_ManForEachCo( p, pObj, i )
345  {
346  Gia_ManToAig_rec( pNew, ppNodes, p, Gia_ObjFanin0(pObj) );
347  if ( i % nOutDelta != 0 )
348  continue;
349  ppNodes[Gia_ObjId(p, pObj)] = Aig_ObjCreateCo( pNew, Gia_ObjChild0Copy2(ppNodes, pObj, Gia_ObjId(p, pObj)) );
350  }
351  Aig_ManSetRegNum( pNew, Gia_ManRegNum(p) );
352  ABC_FREE( ppNodes );
353  return pNew;
354 }
Aig_Obj_t * Aig_ObjCreateCo(Aig_Man_t *p, Aig_Obj_t *pDriver)
Definition: aigObj.c:66
#define Gia_ManForEachCo(p, pObj, i)
Definition: gia.h:1022
int * pNexts
Definition: gia.h:122
typedefABC_NAMESPACE_HEADER_START struct Aig_Man_t_ Aig_Man_t
INCLUDES ///.
Definition: aig.h:50
Aig_Man_t * Aig_ManStart(int nNodesMax)
DECLARATIONS ///.
Definition: aigMan.c:47
Aig_Obj_t * Aig_ObjCreateCi(Aig_Man_t *p)
DECLARATIONS ///.
Definition: aigObj.c:45
static Aig_Obj_t * Aig_ManConst0(Aig_Man_t *p)
Definition: aig.h:263
Definition: gia.h:75
#define Gia_ManForEachCi(p, pObj, i)
Definition: gia.h:1016
static int Gia_ManAndNum(Gia_Man_t *p)
Definition: gia.h:389
static Gia_Obj_t * Gia_ObjFanin0(Gia_Obj_t *pObj)
Definition: gia.h:454
int nConstrs
Definition: gia.h:117
char * pName
Definition: gia.h:97
void Aig_ManSetRegNum(Aig_Man_t *p, int nRegs)
Definition: aigMan.c:438
static Aig_Obj_t * Gia_ObjChild0Copy2(Aig_Obj_t **ppNodes, Gia_Obj_t *pObj, int Id)
Definition: giaAig.c:36
char * pSpec
Definition: gia.h:98
Definition: aig.h:69
static int Gia_ObjId(Gia_Man_t *p, Gia_Obj_t *pObj)
Definition: gia.h:410
#define ABC_FREE(obj)
Definition: abc_global.h:232
void Gia_ManToAig_rec(Aig_Man_t *pNew, Aig_Obj_t **ppNodes, Gia_Man_t *p, Gia_Obj_t *pObj)
Definition: giaAig.c:253
#define ABC_CALLOC(type, num)
Definition: abc_global.h:230
Gia_Rpr_t * pReprs
Definition: gia.h:121
#define assert(ex)
Definition: util_old.h:213
char * Abc_UtilStrsav(char *s)
Definition: starter.c:47
static int Gia_ManObjNum(Gia_Man_t *p)
Definition: gia.h:388
static int Gia_ManCoNum(Gia_Man_t *p)
Definition: gia.h:384
static int Gia_ManRegNum(Gia_Man_t *p)
Definition: gia.h:387