ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
giaEnable.c
Go to the documentation of this file.
1
20
21#include "gia.h"
22
23ABC_NAMESPACE_IMPL_START
24
25
29
33
45void Gia_CollectSuper_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vSuper )
46{
47 // if the new node is complemented or a PI, another gate begins
48 if ( Gia_IsComplement(pObj) || Gia_ObjIsCi(pObj) )
49 {
50 Vec_IntPushUnique( vSuper, Gia_ObjId(p, Gia_Regular(pObj)) );
51 return;
52 }
53 assert( Gia_ObjIsAnd(pObj) );
54 // go through the branches
55 Gia_CollectSuper_rec( p, Gia_ObjChild0(pObj), vSuper );
56 Gia_CollectSuper_rec( p, Gia_ObjChild1(pObj), vSuper );
57}
58
70void Gia_CollectSuper( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vSuper )
71{
72 assert( !Gia_IsComplement(pObj) );
73 Vec_IntClear( vSuper );
74// Gia_CollectSuper_rec( p, pObj, vSuper );
75 if ( Gia_ObjIsAnd(pObj) )
76 {
77 Vec_IntPushUnique( vSuper, Gia_ObjId(p, Gia_ObjFanin0(pObj)) );
78 Vec_IntPushUnique( vSuper, Gia_ObjId(p, Gia_ObjFanin1(pObj)) );
79 }
80 else
81 Vec_IntPushUnique( vSuper, Gia_ObjId(p, Gia_Regular(pObj)) );
82
83}
84
96void Gia_ManPrintSignals( Gia_Man_t * p, int * pFreq, char * pStr )
97{
98 Vec_Int_t * vObjs;
99 int i, Counter = 0, nTotal = 0;
100 vObjs = Vec_IntAlloc( 100 );
101 for ( i = 0; i < Gia_ManObjNum(p); i++ )
102 if ( pFreq[i] > 1 )
103 {
104 nTotal += pFreq[i];
105 Counter++;
106 }
107 printf( "%s (total = %d driven = %d)\n", pStr, Counter, nTotal );
108 Counter = 0;
109 for ( i = 0; i < Gia_ManObjNum(p); i++ )
110 if ( pFreq[i] > 10 )
111 {
112 printf( "%3d : Obj = %6d Refs = %6d Freq = %6d\n",
113 ++Counter, i, Gia_ObjRefNum(p, Gia_ManObj(p,i)), pFreq[i] );
114 Vec_IntPush( vObjs, i );
115 }
116 Vec_IntFree( vObjs );
117}
118
130void Gia_ManDetectSeqSignals( Gia_Man_t * p, int fSetReset, int fVerbose )
131{
132 Vec_Int_t * vSuper;
133 Gia_Obj_t * pFlop, * pObjC, * pObj0, * pObj1, * pNode, * pTemp;
134 int i, k, Ent, * pSets, * pResets, * pEnables;
135 int nHaveSetReset = 0, nHaveEnable = 0;
136 assert( Gia_ManRegNum(p) > 0 );
137 pSets = ABC_CALLOC( int, Gia_ManObjNum(p) );
138 pResets = ABC_CALLOC( int, Gia_ManObjNum(p) );
139 pEnables = ABC_CALLOC( int, Gia_ManObjNum(p) );
140 vSuper = Vec_IntAlloc( 100 );
141 Gia_ManForEachRi( p, pFlop, i )
142 {
143 pNode = Gia_ObjFanin0(pFlop);
144 if ( !Gia_ObjIsAnd(pNode) )
145 continue;
146 // detect sets/resets
147 Gia_CollectSuper( p, pNode, vSuper );
148 if ( Gia_ObjFaninC0(pFlop) )
149 Vec_IntForEachEntry( vSuper, Ent, k )
150 pSets[Ent]++;
151 else
152 Vec_IntForEachEntry( vSuper, Ent, k )
153 pResets[Ent]++;
154 // detect enables
155 if ( !Gia_ObjIsMuxType(pNode) )
156 continue;
157 pObjC = Gia_ObjRecognizeMux( pNode, &pObj0, &pObj1 );
158 pTemp = Gia_ObjRiToRo( p, pFlop );
159 if ( Gia_Regular(pObj0) != pTemp && Gia_Regular(pObj1) != pTemp )
160 continue;
161 if ( !Gia_ObjFaninC0(pFlop) )
162 {
163 pObj0 = Gia_Not(pObj0);
164 pObj1 = Gia_Not(pObj1);
165 }
166 if ( Gia_IsComplement(pObjC) )
167 {
168 pObjC = Gia_Not(pObjC);
169 pTemp = pObj0;
170 pObj0 = pObj1;
171 pObj1 = pTemp;
172 }
173 // detect controls
174// Gia_CollectSuper( p, pObjC, vSuper );
175// Vec_IntForEachEntry( vSuper, Ent, k )
176// pEnables[Ent]++;
177 pEnables[Gia_ObjId(p, pObjC)]++;
178 nHaveEnable++;
179 }
180 Gia_ManForEachRi( p, pFlop, i )
181 {
182 pNode = Gia_ObjFanin0(pFlop);
183 if ( !Gia_ObjIsAnd(pNode) )
184 continue;
185 // detect sets/resets
186 Gia_CollectSuper( p, pNode, vSuper );
187 Vec_IntForEachEntry( vSuper, Ent, k )
188 if ( pSets[Ent] > 1 || pResets[Ent] > 1 )
189 {
190 nHaveSetReset++;
191 break;
192 }
193 }
194 Vec_IntFree( vSuper );
195 ABC_FREE( p->pRefs );
196 Gia_ManCreateRefs( p );
197 if ( fVerbose )
198 {
199 printf( "Flops with set/reset = %6d. Flops with enable = %6d.\n", nHaveSetReset, nHaveEnable );
200 if ( fSetReset )
201 {
202 Gia_ManPrintSignals( p, pSets, "Set signals" );
203 Gia_ManPrintSignals( p, pResets, "Reset signals" );
204 }
205 Gia_ManPrintSignals( p, pEnables, "Enable signals" );
206 }
207 ABC_FREE( p->pRefs );
208 ABC_FREE( pSets );
209 ABC_FREE( pResets );
210 ABC_FREE( pEnables );
211}
212
224Vec_Int_t * Gia_ManDetectSeqSignalsWithFanout( Gia_Man_t * p, int nFanMax, int fVerbose )
225{
226 Vec_Int_t * vResult;
227 Vec_Int_t * vSuper;
228 Gia_Obj_t * pFlop, * pObjC, * pObj0, * pObj1, * pNode, * pTemp;
229 int i, k, Ent, * pSets, * pResets, * pEnables;
230 int nHaveSetReset = 0, nHaveEnable = 0;
231 assert( Gia_ManRegNum(p) > 0 );
232 pSets = ABC_CALLOC( int, Gia_ManObjNum(p) );
233 pResets = ABC_CALLOC( int, Gia_ManObjNum(p) );
234 pEnables = ABC_CALLOC( int, Gia_ManObjNum(p) );
235 vSuper = Vec_IntAlloc( 100 );
236 Gia_ManForEachRi( p, pFlop, i )
237 {
238 pNode = Gia_ObjFanin0(pFlop);
239 if ( !Gia_ObjIsAnd(pNode) )
240 continue;
241 // detect sets/resets
242 Gia_CollectSuper( p, pNode, vSuper );
243 if ( Gia_ObjFaninC0(pFlop) )
244 Vec_IntForEachEntry( vSuper, Ent, k )
245 pSets[Ent]++;
246 else
247 Vec_IntForEachEntry( vSuper, Ent, k )
248 pResets[Ent]++;
249 // detect enables
250 if ( !Gia_ObjIsMuxType(pNode) )
251 continue;
252 pObjC = Gia_ObjRecognizeMux( pNode, &pObj0, &pObj1 );
253 pTemp = Gia_ObjRiToRo( p, pFlop );
254 if ( Gia_Regular(pObj0) != pTemp && Gia_Regular(pObj1) != pTemp )
255 continue;
256 if ( !Gia_ObjFaninC0(pFlop) )
257 {
258 pObj0 = Gia_Not(pObj0);
259 pObj1 = Gia_Not(pObj1);
260 }
261 if ( Gia_IsComplement(pObjC) )
262 {
263 pObjC = Gia_Not(pObjC);
264 pTemp = pObj0;
265 pObj0 = pObj1;
266 pObj1 = pTemp;
267 }
268 // detect controls
269// Gia_CollectSuper( p, pObjC, vSuper );
270// Vec_IntForEachEntry( vSuper, Ent, k )
271// pEnables[Ent]++;
272 pEnables[Gia_ObjId(p, pObjC)]++;
273 nHaveEnable++;
274 }
275 Gia_ManForEachRi( p, pFlop, i )
276 {
277 pNode = Gia_ObjFanin0(pFlop);
278 if ( !Gia_ObjIsAnd(pNode) )
279 continue;
280 // detect sets/resets
281 Gia_CollectSuper( p, pNode, vSuper );
282 Vec_IntForEachEntry( vSuper, Ent, k )
283 if ( pSets[Ent] > 1 || pResets[Ent] > 1 )
284 {
285 nHaveSetReset++;
286 break;
287 }
288 }
289 Vec_IntFree( vSuper );
290 vResult = Vec_IntAlloc( 100 );
291 for ( i = 1; i < Gia_ManObjNum(p); i++ )
292 if ( pSets[i] > nFanMax )
293 {
294 if ( fVerbose )
295 printf( "Adding set signal %d related to %d flops.\n", i, pSets[i] );
296 Vec_IntPushUnique( vResult, i );
297 }
298 for ( i = 1; i < Gia_ManObjNum(p); i++ )
299 if ( pResets[i] > nFanMax )
300 {
301 if ( fVerbose )
302 printf( "Adding reset signal %d related to %d flops.\n", i, pResets[i] );
303 Vec_IntPushUnique( vResult, i );
304 }
305 for ( i = 1; i < Gia_ManObjNum(p); i++ )
306 if ( pEnables[i] > nFanMax )
307 {
308 if ( fVerbose )
309 printf( "Adding enable signal %d related to %d flops.\n", i, pEnables[i] );
310 Vec_IntPushUnique( vResult, i );
311 }
312 ABC_FREE( pSets );
313 ABC_FREE( pResets );
314 ABC_FREE( pEnables );
315 return vResult;
316}
317
318
330Vec_Int_t * Gia_ManTransferFrames( Gia_Man_t * pAig, Gia_Man_t * pFrames, int nFrames, Gia_Man_t * pNew, Vec_Int_t * vSigs )
331{
332 Vec_Int_t * vSigsNew;
333 Gia_Obj_t * pObj, * pObjF;
334 int k, f;
335 vSigsNew = Vec_IntAlloc( 100 );
336 Gia_ManForEachObjVec( vSigs, pAig, pObj, k )
337 {
338 assert( Gia_ObjIsCand(pObj) );
339 for ( f = 0; f < nFrames; f++ )
340 {
341 pObjF = Gia_ManObj( pFrames, Abc_Lit2Var(Gia_ObjCopyF( pAig, f, pObj )) );
342 if ( pObjF->Value && ~pObjF->Value )
343 Vec_IntPushUnique( vSigsNew, Abc_Lit2Var(pObjF->Value) );
344 }
345 }
346 return vSigsNew;
347}
348
360Gia_Man_t * Gia_ManUnrollInit( Gia_Man_t * p, int nFrames )
361{
362 Gia_Man_t * pNew;
363 Gia_Obj_t * pObj, * pObjRi, * pObjRo;
364 int f, i;
365 Vec_IntFill( &p->vCopies, nFrames * Gia_ManObjNum(p), -1 );
366 pNew = Gia_ManStart( nFrames * Gia_ManObjNum(p) );
367 pNew->pName = Abc_UtilStrsav( p->pName );
368 pNew->pSpec = Abc_UtilStrsav( p->pSpec );
369 Gia_ManHashAlloc( pNew );
370 Gia_ManForEachRo( p, pObj, i )
371 Gia_ObjSetCopyF( p, 0, pObj, 0 );
372 for ( f = 0; f < nFrames; f++ )
373 {
374 Gia_ObjSetCopyF( p, f, Gia_ManConst0(p), 0 );
375 Gia_ManForEachPi( p, pObj, i )
376 Gia_ObjSetCopyF( p, f, pObj, Gia_ManAppendCi(pNew) );
377 Gia_ManForEachAnd( p, pObj, i )
378 Gia_ObjSetCopyF( p, f, pObj, Gia_ManHashAnd(pNew, Gia_ObjFanin0CopyF(p, f, pObj), Gia_ObjFanin1CopyF(p, f, pObj)) );
379 Gia_ManForEachCo( p, pObj, i )
380 Gia_ObjSetCopyF( p, f, pObj, Gia_ObjFanin0CopyF(p, f, pObj) );
381 Gia_ManForEachPo( p, pObj, i )
382 Gia_ManAppendCo( pNew, Gia_ObjCopyF(p, f, pObj) );
383 if ( f == nFrames - 1 )
384 break;
385 Gia_ManForEachRiRo( p, pObjRi, pObjRo, i )
386 Gia_ObjSetCopyF( p, f+1, pObjRo, Gia_ObjCopyF(p, f, pObjRi) );
387 }
388 Gia_ManHashStop( pNew );
389 return pNew;
390}
391
403Gia_Man_t * Gia_ManUnrollAndCofactor( Gia_Man_t * p, int nFrames, int nFanMax, int fVerbose )
404{
405 Vec_Int_t * vCofSigs, * vTemp;
406 Gia_Man_t * pAig, * pFrames, * pNew;
407 // compute initialized timeframes
408 pFrames = Gia_ManUnrollInit( p, nFrames );
409 pAig = Gia_ManCleanup( pFrames );
410 // compute and remap set/reset/enable signals
411 vCofSigs = Gia_ManDetectSeqSignalsWithFanout( p, nFanMax, fVerbose );
412 vCofSigs = Gia_ManTransferFrames( p, pFrames, nFrames, pAig, vTemp = vCofSigs );
413 Vec_IntFree( vTemp );
414 Gia_ManStop( pFrames );
415 Vec_IntErase( &p->vCopies );
416 // cofactor all these variables
417 pNew = Gia_ManDupCofAllInt( pAig, vCofSigs, fVerbose );
418 Vec_IntFree( vCofSigs );
419 Gia_ManStop( pAig );
420 return pNew;
421}
422
423
424
436Gia_Man_t * Gia_ManRemoveEnables2( Gia_Man_t * p )
437{
438 Gia_Man_t * pNew, * pAux;
439 Gia_Obj_t * pTemp, * pObjC, * pObj0, * pObj1, * pFlopIn, * pFlopOut;
440 Gia_Obj_t * pThis, * pNode;
441 int i;
442 pNew = Gia_ManStart( Gia_ManObjNum(p) );
443 pNew->pName = Abc_UtilStrsav( p->pName );
444 pNew->pSpec = Abc_UtilStrsav( p->pSpec );
445 Gia_ManHashAlloc( pNew );
446 Gia_ManFillValue( p );
447 Gia_ManConst0(p)->Value = 0;
448 Gia_ManForEachCi( p, pThis, i )
449 pThis->Value = Gia_ManAppendCi( pNew );
450 Gia_ManForEachAnd( p, pThis, i )
451 pThis->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pThis), Gia_ObjFanin1Copy(pThis) );
452 Gia_ManForEachPo( p, pThis, i )
453 pThis->Value = Gia_ObjFanin0Copy(pThis);
454 Gia_ManForEachRi( p, pFlopIn, i )
455 {
456 pNode = Gia_ObjFanin0(pFlopIn);
457 if ( !Gia_ObjIsMuxType(pNode) )
458 {
459 printf( "Cannot recognize enable of flop %d.\n", i );
460 continue;
461 }
462 pObjC = Gia_ObjRecognizeMux( pNode, &pObj1, &pObj0 );
463 pFlopOut = Gia_ObjRiToRo( p, pFlopIn );
464 if ( Gia_Regular(pObj0) != pFlopOut && Gia_Regular(pObj1) != pFlopOut )
465 {
466 printf( "Cannot recognize self-loop of enable flop %d.\n", i );
467 continue;
468 }
469 if ( !Gia_ObjFaninC0(pFlopIn) )
470 {
471 pObj0 = Gia_Not(pObj0);
472 pObj1 = Gia_Not(pObj1);
473 }
474 if ( Gia_IsComplement(pObjC) )
475 {
476 pObjC = Gia_Not(pObjC);
477 pTemp = pObj0;
478 pObj0 = pObj1;
479 pObj1 = pTemp;
480 }
481 if ( Gia_Regular(pObj0) == pFlopOut )
482 {
483// printf( "FlopIn compl = %d. FlopOut is d0. Complement = %d.\n",
484// Gia_ObjFaninC0(pFlopIn), Gia_IsComplement(pObj0) );
485 pFlopIn->Value = Abc_LitNotCond(Gia_Regular(pObj1)->Value, !Gia_IsComplement(pObj1));
486 }
487 else if ( Gia_Regular(pObj1) == pFlopOut )
488 {
489// printf( "FlopIn compl = %d. FlopOut is d1. Complement = %d.\n",
490// Gia_ObjFaninC0(pFlopIn), Gia_IsComplement(pObj1) );
491 pFlopIn->Value = Abc_LitNotCond(Gia_Regular(pObj0)->Value, !Gia_IsComplement(pObj0));
492 }
493 }
494 Gia_ManForEachCo( p, pThis, i )
495 Gia_ManAppendCo( pNew, pThis->Value );
496 Gia_ManHashStop( pNew );
497 Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
498 pNew = Gia_ManCleanup( pAux = pNew );
499 Gia_ManStop( pAux );
500 return pNew;
501}
502
514Gia_Man_t * Gia_ManRemoveEnables( Gia_Man_t * p )
515{
516 Vec_Ptr_t * vCtrls, * vDatas;
517 Vec_Int_t * vFlopClasses;
518 Gia_Man_t * pNew, * pAux;
519 Gia_Obj_t * pFlopIn, * pFlopOut, * pDriver, * pFan0, * pFan1, * pCtrl = NULL, * pData, * pObj;
520 int i, iClass, fCompl, Counter = 0;
521 vCtrls = Vec_PtrAlloc( 100 );
522 Vec_PtrPush( vCtrls, NULL );
523 vDatas = Vec_PtrAlloc( Gia_ManRegNum(p) );
524 vFlopClasses = Vec_IntAlloc( Gia_ManRegNum(p) );
525 Gia_ManForEachRi( p, pFlopIn, i )
526 {
527 fCompl = Gia_ObjFaninC0(pFlopIn);
528 pDriver = Gia_ObjFanin0(pFlopIn);
529 if ( !Gia_ObjIsAnd(pDriver) )
530 {
531 printf( "The flop driver %d is not a node.\n", i );
532 Vec_PtrPush( vDatas, NULL );
533 Vec_IntPush( vFlopClasses, 0 );
534 Counter++;
535 continue;
536 }
537 if ( !Gia_ObjFaninC0(pDriver) || !Gia_ObjFaninC1(pDriver) )
538 {
539 printf( "The flop driver %d is not an OR gate.\n", i );
540 Vec_PtrPush( vDatas, NULL );
541 Vec_IntPush( vFlopClasses, 0 );
542 Counter++;
543 continue;
544 }
545 pFan0 = Gia_ObjFanin0(pDriver);
546 pFan1 = Gia_ObjFanin1(pDriver);
547 if ( !Gia_ObjIsAnd(pFan0) || !Gia_ObjIsAnd(pFan1) )
548 {
549 printf( "The flop driver fanin %d is not a node.\n", i );
550 Vec_PtrPush( vDatas, NULL );
551 Vec_IntPush( vFlopClasses, 0 );
552 Counter++;
553 continue;
554 }
555 pFlopOut = Gia_ObjRiToRo( p, pFlopIn );
556 pFlopOut = Gia_NotCond( pFlopOut, !fCompl );
557 if ( Gia_ObjChild0(pFan0) != pFlopOut && Gia_ObjChild1(pFan0) != pFlopOut &&
558 Gia_ObjChild0(pFan1) != pFlopOut && Gia_ObjChild1(pFan1) != pFlopOut )
559 {
560 printf( "The flop %d does not have a self-loop.\n", i );
561 Vec_PtrPush( vDatas, NULL );
562 Vec_IntPush( vFlopClasses, 0 );
563 Counter++;
564 continue;
565 }
566 pData = NULL;
567 if ( Gia_ObjChild0(pFan0) == pFlopOut )
568 {
569 pCtrl = Gia_Not( Gia_ObjChild1(pFan0) );
570 if ( Gia_ObjFanin0(pFan1) == Gia_Regular(pCtrl) )
571 pData = Gia_ObjChild1(pFan1);
572 else
573 pData = Gia_ObjChild0(pFan1);
574 }
575 else if ( Gia_ObjChild1(pFan0) == pFlopOut )
576 {
577 pCtrl = Gia_Not( Gia_ObjChild0(pFan0) );
578 if ( Gia_ObjFanin0(pFan1) == Gia_Regular(pCtrl) )
579 pData = Gia_ObjChild1(pFan1);
580 else
581 pData = Gia_ObjChild0(pFan1);
582 }
583 else if ( Gia_ObjChild0(pFan1) == pFlopOut )
584 {
585 pCtrl = Gia_Not( Gia_ObjChild1(pFan1) );
586 if ( Gia_ObjFanin0(pFan0) == Gia_Regular(pCtrl) )
587 pData = Gia_ObjChild1(pFan0);
588 else
589 pData = Gia_ObjChild0(pFan0);
590 }
591 else if ( Gia_ObjChild1(pFan1) == pFlopOut )
592 {
593 pCtrl = Gia_Not( Gia_ObjChild0(pFan1) );
594 if ( Gia_ObjFanin0(pFan0) == Gia_Regular(pCtrl) )
595 pData = Gia_ObjChild1(pFan0);
596 else
597 pData = Gia_ObjChild0(pFan0);
598 }
599 else assert( 0 );
600 if ( Vec_PtrFind( vCtrls, pCtrl ) == -1 )
601 Vec_PtrPush( vCtrls, pCtrl );
602 iClass = Vec_PtrFind( vCtrls, pCtrl );
603 pData = Gia_NotCond( pData, !fCompl );
604 Vec_PtrPush( vDatas, pData );
605 Vec_IntPush( vFlopClasses, iClass );
606 }
607 assert( Vec_PtrSize( vDatas ) == Gia_ManRegNum(p) );
608 assert( Vec_IntSize( vFlopClasses ) == Gia_ManRegNum(p) );
609 printf( "Detected %d classes.\n", Vec_PtrSize(vCtrls) - (Counter == 0) );
610 Vec_PtrFree( vCtrls );
611
612
613 pNew = Gia_ManStart( Gia_ManObjNum(p) );
614 pNew->pName = Abc_UtilStrsav( p->pName );
615 pNew->pSpec = Abc_UtilStrsav( p->pSpec );
616 Gia_ManConst0(p)->Value = 0;
617 Gia_ManForEachObj1( p, pObj, i )
618 {
619 if ( Gia_ObjIsAnd(pObj) )
620 pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
621 else if ( Gia_ObjIsCi(pObj) )
622 pObj->Value = Gia_ManAppendCi( pNew );
623 else if ( Gia_ObjIsPo(p, pObj) )
624 pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
625 }
626 Gia_ManForEachRi( p, pObj, i )
627 {
628 pData = (Gia_Obj_t *)Vec_PtrEntry(vDatas, i);
629 if ( pData == NULL )
630 pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
631 else
632 pObj->Value = Gia_ManAppendCo( pNew, Abc_LitNotCond(Gia_Regular(pData)->Value, Gia_IsComplement(pData)) );
633 }
634 Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
635 Vec_PtrFree( vDatas );
636
637
638 pNew = Gia_ManCleanup( pAux = pNew );
639 Gia_ManStop( pAux );
640 pNew->vFlopClasses = vFlopClasses;
641 return pNew;
642}
643
647
648
649ABC_NAMESPACE_IMPL_END
650
ABC_CALLOC
#define ABC_CALLOC(type, num)
Definition abc_global.h:265
ABC_FREE
#define ABC_FREE(obj)
Definition abc_global.h:267
ABC_NAMESPACE_IMPL_START
#define ABC_NAMESPACE_IMPL_START
Definition abc_namespaces.h:54
ABC_NAMESPACE_IMPL_END
#define ABC_NAMESPACE_IMPL_END
Definition abc_namespaces.h:55
nTotal
int nTotal
DECLARATIONS ///.
Definition cutTruth.c:37
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition bblif.c:37
p
Cube * p
Definition exorList.c:222
Gia_ManPrintSignals
void Gia_ManPrintSignals(Gia_Man_t *p, int *pFreq, char *pStr)
Definition giaEnable.c:96
Gia_ManDetectSeqSignals
void Gia_ManDetectSeqSignals(Gia_Man_t *p, int fSetReset, int fVerbose)
Definition giaEnable.c:130
Gia_ManRemoveEnables2
Gia_Man_t * Gia_ManRemoveEnables2(Gia_Man_t *p)
Definition giaEnable.c:436
Gia_ManRemoveEnables
Gia_Man_t * Gia_ManRemoveEnables(Gia_Man_t *p)
Definition giaEnable.c:514
Gia_ManUnrollAndCofactor
Gia_Man_t * Gia_ManUnrollAndCofactor(Gia_Man_t *p, int nFrames, int nFanMax, int fVerbose)
Definition giaEnable.c:403
Gia_CollectSuper
void Gia_CollectSuper(Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vSuper)
Definition giaEnable.c:70
Gia_ManUnrollInit
Gia_Man_t * Gia_ManUnrollInit(Gia_Man_t *p, int nFrames)
Definition giaEnable.c:360
Gia_CollectSuper_rec
ABC_NAMESPACE_IMPL_START void Gia_CollectSuper_rec(Gia_Man_t *p, Gia_Obj_t *pObj, Vec_Int_t *vSuper)
DECLARATIONS ///.
Definition giaEnable.c:45
Gia_ManTransferFrames
Vec_Int_t * Gia_ManTransferFrames(Gia_Man_t *pAig, Gia_Man_t *pFrames, int nFrames, Gia_Man_t *pNew, Vec_Int_t *vSigs)
Definition giaEnable.c:330
Gia_ManDetectSeqSignalsWithFanout
Vec_Int_t * Gia_ManDetectSeqSignalsWithFanout(Gia_Man_t *p, int nFanMax, int fVerbose)
Definition giaEnable.c:224
Gia_ManStop
void Gia_ManStop(Gia_Man_t *p)
Definition giaMan.c:82
Gia_ManForEachRo
#define Gia_ManForEachRo(p, pObj, i)
Definition gia.h:1252
Gia_ObjRecognizeMux
Gia_Obj_t * Gia_ObjRecognizeMux(Gia_Obj_t *pNode, Gia_Obj_t **ppNodeT, Gia_Obj_t **ppNodeE)
Definition giaUtil.c:1056
Gia_ManForEachPo
#define Gia_ManForEachPo(p, pObj, i)
Definition gia.h:1250
Gia_ManForEachAnd
#define Gia_ManForEachAnd(p, pObj, i)
Definition gia.h:1214
Gia_ManSetRegNum
void Gia_ManSetRegNum(Gia_Man_t *p, int nRegs)
Definition giaMan.c:764
Gia_ManHashAlloc
void Gia_ManHashAlloc(Gia_Man_t *p)
Definition giaHash.c:105
Gia_ManForEachPi
#define Gia_ManForEachPi(p, pObj, i)
Definition gia.h:1248
Gia_ManStart
Gia_Man_t * Gia_ManStart(int nObjsMax)
FUNCTION DEFINITIONS ///.
Definition giaMan.c:57
Gia_Obj_t
struct Gia_Obj_t_ Gia_Obj_t
Definition gia.h:76
Gia_ObjIsMuxType
int Gia_ObjIsMuxType(Gia_Obj_t *pNode)
Definition giaUtil.c:982
Gia_ManFillValue
void Gia_ManFillValue(Gia_Man_t *p)
Definition giaUtil.c:369
Gia_Man_t
struct Gia_Man_t_ Gia_Man_t
Definition gia.h:96
Gia_ManForEachObj1
#define Gia_ManForEachObj1(p, pObj, i)
Definition gia.h:1192
Gia_ManForEachObjVec
#define Gia_ManForEachObjVec(vVec, p, pObj, i)
Definition gia.h:1194
Gia_ManDupCofAllInt
Gia_Man_t * Gia_ManDupCofAllInt(Gia_Man_t *p, Vec_Int_t *vSigs, int fVerbose)
Definition giaCof.c:936
Gia_ManCleanup
Gia_Man_t * Gia_ManCleanup(Gia_Man_t *p)
Definition giaScl.c:84
Gia_ManCreateRefs
void Gia_ManCreateRefs(Gia_Man_t *p)
Definition giaUtil.c:779
Gia_ManHashAnd
int Gia_ManHashAnd(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaHash.c:576
Gia_ManForEachCo
#define Gia_ManForEachCo(p, pObj, i)
Definition gia.h:1236
Gia_ManForEachCi
#define Gia_ManForEachCi(p, pObj, i)
Definition gia.h:1228
Gia_ManForEachRiRo
#define Gia_ManForEachRiRo(p, pObjRi, pObjRo, i)
Definition gia.h:1256
Gia_ManHashStop
void Gia_ManHashStop(Gia_Man_t *p)
Definition giaHash.c:149
Gia_ManForEachRi
#define Gia_ManForEachRi(p, pObj, i)
Definition gia.h:1254
Gia_Man_t_::pSpec
char * pSpec
Definition gia.h:100
Gia_Man_t_::vFlopClasses
Vec_Int_t * vFlopClasses
Definition gia.h:156
Gia_Man_t_::pName
char * pName
Definition gia.h:99
Gia_Obj_t_::Value
unsigned Value
Definition gia.h:89
assert
#define assert(ex)
Definition util_old.h:213
Vec_IntForEachEntry
#define Vec_IntForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition vecInt.h:54
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition vecPtr.h:42