1 /**CFile****************************************************************
2 
3   FileName    [cbaBlast.c]
4 
5   SystemName  [ABC: Logic synthesis and verification system.]
6 
7   PackageName [Hierarchical word-level netlist.]
8 
9   Synopsis    [Collapsing word-level design.]
10 
11   Author      [Alan Mishchenko]
12 
13   Affiliation [UC Berkeley]
14 
15   Date        [Ver. 1.0. Started - July 21, 2015.]
16 
17   Revision    [$Id: cbaBlast.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
18 
19 ***********************************************************************/
20 
21 #include "cba.h"
22 #include "base/abc/abc.h"
23 #include "map/mio/mio.h"
24 #include "bool/dec/dec.h"
25 #include "base/main/mainInt.h"
26 
27 ABC_NAMESPACE_IMPL_START
28 
29 ////////////////////////////////////////////////////////////////////////
30 ///                        DECLARATIONS                              ///
31 ////////////////////////////////////////////////////////////////////////
32 
33 ////////////////////////////////////////////////////////////////////////
34 ///                     FUNCTION DEFINITIONS                         ///
35 ////////////////////////////////////////////////////////////////////////
36 
37 /**Function*************************************************************
38 
39   Synopsis    [Helper functions.]
40 
41   Description []
42 
43   SideEffects []
44 
45   SeeAlso     []
46 
47 ***********************************************************************/
Cba_NtkPrepareBits(Cba_Ntk_t * p)48 int Cba_NtkPrepareBits( Cba_Ntk_t * p )
49 {
50     int i, nBits = 0;
51     Cba_NtkCleanFonCopies( p );
52     Cba_NtkForEachFon( p, i )
53     {
54         Cba_FonSetCopy( p, i, nBits );
55         nBits += Cba_FonRangeSize( p, i );
56     }
57     return nBits;
58 }
Cba_VecCopy(Vec_Int_t * vOut,int * pArray,int nSize)59 int * Cba_VecCopy( Vec_Int_t * vOut, int * pArray, int nSize )
60 {
61     int i; Vec_IntClear( vOut );
62     for( i = 0; i < nSize; i++)
63         Vec_IntPush( vOut, pArray[i] );
64     return Vec_IntArray( vOut );
65 }
Cba_ReadHexDigit(char HexChar)66 int Cba_ReadHexDigit( char HexChar )
67 {
68     if ( HexChar >= '0' && HexChar <= '9' )
69         return HexChar - '0';
70     if ( HexChar >= 'A' && HexChar <= 'F' )
71         return HexChar - 'A' + 10;
72     if ( HexChar >= 'a' && HexChar <= 'f' )
73         return HexChar - 'a' + 10;
74     assert( 0 ); // not a hexadecimal symbol
75     return -1; // return value which makes no sense
76 }
Cba_BlastConst(Cba_Ntk_t * p,Vec_Int_t * vOut,int iFon,int nTotal,int fSigned)77 void Cba_BlastConst( Cba_Ntk_t * p, Vec_Int_t * vOut, int iFon, int nTotal, int fSigned )
78 {
79     char * pConst = Cba_NtkConst(p, Cba_FonConst(iFon));
80     char * pLimit = pConst + strlen(pConst);
81     int i, Number, nBits = atoi( pConst );
82     assert( nBits <= nTotal );
83     while ( *pConst >= '0' && *pConst <= '9' )
84         pConst++;
85     assert( *pConst == '\'' );
86     pConst++;
87     if ( *pConst == 's' ) // assume signedness is already used in setting fSigned
88         pConst++;
89     Vec_IntClear( vOut );
90     if ( *pConst == 'b' )
91     {
92         while ( --pLimit > pConst )
93             Vec_IntPush( vOut, *pLimit == '0' ? 0 : 1 );
94     }
95     else if ( *pConst == 'h' )
96     {
97         while ( --pLimit > pConst )
98         {
99             Number = Cba_ReadHexDigit( *pLimit );
100             for ( i = 0; i < 4; i++ )
101                 Vec_IntPush( vOut, (Number >> i) & 1 );
102         }
103         if ( Vec_IntSize(vOut) > nTotal )
104             Vec_IntShrink( vOut, nTotal );
105     }
106     else if ( *pConst == 'd' )
107     {
108         Number = atoi( pConst+1 );
109         assert( Number <= 0x7FFFFFFF );
110         for ( i = 0; i < 32; i++ )
111             Vec_IntPush( vOut, (Number >> i) & 1 );
112         if ( Vec_IntSize(vOut) > nTotal )
113             Vec_IntShrink( vOut, nTotal );
114     }
115     else assert( 0 );
116     if ( fSigned && Vec_IntSize(vOut) < nTotal )
117         Vec_IntFillExtra( vOut, nTotal - Vec_IntSize(vOut), Vec_IntEntryLast(vOut) );
118 }
Cba_VecLoadFanins(Cba_Ntk_t * p,Vec_Int_t * vOut,int iFon,int * pFanins,int nFanins,int nTotal,int fSigned)119 int * Cba_VecLoadFanins( Cba_Ntk_t * p, Vec_Int_t * vOut, int iFon, int * pFanins, int nFanins, int nTotal, int fSigned )
120 {
121     assert( nFanins <= nTotal );
122     if ( Cba_FonIsReal(iFon) )
123     {
124         int i, Fill = fSigned ? pFanins[nFanins-1] : 0;
125         Vec_IntClear( vOut );
126         for( i = 0; i < nTotal; i++)
127             Vec_IntPush( vOut, i < nFanins ? pFanins[i] : Fill );
128     }
129     else if ( Cba_FonIsConst(iFon) )
130         Cba_BlastConst( p, vOut, iFon, nTotal, fSigned );
131     else if ( iFon == 0 ) // undriven input
132         Vec_IntFill( vOut, nTotal, 0 );
133     else assert( 0 );
134     assert( Vec_IntSize(vOut) == nTotal );
135     return Vec_IntArray( vOut );
136 }
Cba_NtkMuxTree_rec(Gia_Man_t * pNew,int * pCtrl,int nCtrl,Vec_Int_t * vData,int Shift)137 int Cba_NtkMuxTree_rec( Gia_Man_t * pNew, int * pCtrl, int nCtrl, Vec_Int_t * vData, int Shift )
138 {
139     int iLit0, iLit1;
140     if ( nCtrl == 0 )
141         return Vec_IntEntry( vData, Shift );
142     iLit0 = Cba_NtkMuxTree_rec( pNew, pCtrl, nCtrl-1, vData, Shift );
143     iLit1 = Cba_NtkMuxTree_rec( pNew, pCtrl, nCtrl-1, vData, Shift + (1<<(nCtrl-1)) );
144     return Gia_ManHashMux( pNew, pCtrl[nCtrl-1], iLit1, iLit0 );
145 }
146 
147 /**Function*************************************************************
148 
149   Synopsis    [Bit blasting for specific operations.]
150 
151   Description []
152 
153   SideEffects []
154 
155   SeeAlso     []
156 
157 ***********************************************************************/
Cba_BlastShiftRight(Gia_Man_t * pNew,int * pNum,int nNum,int * pShift,int nShift,int fSticky,Vec_Int_t * vRes)158 void Cba_BlastShiftRight( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, int fSticky, Vec_Int_t * vRes )
159 {
160     int * pRes = Cba_VecCopy( vRes, pNum, nNum );
161     int Fill = fSticky ? pNum[nNum-1] : 0;
162     int i, j, fShort = 0;
163     if ( nShift > 32 )
164         nShift = 32;
165     assert( nShift <= 32 );
166     for( i = 0; i < nShift; i++ )
167         for( j = 0; j < nNum - fSticky; j++ )
168         {
169             if( fShort || j + (1<<i) >= nNum )
170             {
171                 pRes[j] = Gia_ManHashMux( pNew, pShift[i], Fill, pRes[j] );
172                 if ( (1<<i) > nNum )
173                     fShort = 1;
174             }
175             else
176                 pRes[j] = Gia_ManHashMux( pNew, pShift[i], pRes[j+(1<<i)], pRes[j] );
177         }
178 }
Cba_BlastShiftLeft(Gia_Man_t * pNew,int * pNum,int nNum,int * pShift,int nShift,int fSticky,Vec_Int_t * vRes)179 void Cba_BlastShiftLeft( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, int fSticky, Vec_Int_t * vRes )
180 {
181     int * pRes = Cba_VecCopy( vRes, pNum, nNum );
182     int Fill = fSticky ? pNum[0] : 0;
183     int i, j, fShort = 0;
184     if ( nShift > 32 )
185         nShift = 32;
186     assert( nShift <= 32 );
187     for( i = 0; i < nShift; i++ )
188         for( j = nNum-1; j >= fSticky; j-- )
189         {
190             if( fShort || (1<<i) > j )
191             {
192                 pRes[j] = Gia_ManHashMux( pNew, pShift[i], Fill, pRes[j] );
193                 if ( (1<<i) > nNum )
194                     fShort = 1;
195             }
196             else
197                 pRes[j] = Gia_ManHashMux( pNew, pShift[i], pRes[j-(1<<i)], pRes[j] );
198         }
199 }
Cba_BlastRotateRight(Gia_Man_t * pNew,int * pNum,int nNum,int * pShift,int nShift,Vec_Int_t * vRes)200 void Cba_BlastRotateRight( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, Vec_Int_t * vRes )
201 {
202     int * pRes = Cba_VecCopy( vRes, pNum, nNum );
203     int i, j, * pTemp = ABC_ALLOC( int, nNum );
204     assert( nShift <= 32 );
205     for( i = 0; i < nShift; i++, pRes = Cba_VecCopy(vRes, pTemp, nNum) )
206         for( j = 0; j < nNum; j++ )
207             pTemp[j] = Gia_ManHashMux( pNew, pShift[i], pRes[(j+(1<<i))%nNum], pRes[j] );
208     ABC_FREE( pTemp );
209 }
Cba_BlastRotateLeft(Gia_Man_t * pNew,int * pNum,int nNum,int * pShift,int nShift,Vec_Int_t * vRes)210 void Cba_BlastRotateLeft( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, Vec_Int_t * vRes )
211 {
212     int * pRes = Cba_VecCopy( vRes, pNum, nNum );
213     int i, j, * pTemp = ABC_ALLOC( int, nNum );
214     assert( nShift <= 32 );
215     for( i = 0; i < nShift; i++, pRes = Cba_VecCopy(vRes, pTemp, nNum) )
216         for( j = 0; j < nNum; j++ )
217         {
218             int move = (j >= (1<<i)) ? (j-(1<<i))%nNum : (nNum - (((1<<i)-j)%nNum)) % nNum;
219             pTemp[j] = Gia_ManHashMux( pNew, pShift[i], pRes[move], pRes[j] );
220 //            pTemp[j] = Gia_ManHashMux( pNew, pShift[i], pRes[((unsigned)(nNum-(1<<i)+j))%nNum], pRes[j] );
221         }
222     ABC_FREE( pTemp );
223 }
Cba_BlastReduction(Gia_Man_t * pNew,int * pFans,int nFans,int Type)224 int Cba_BlastReduction( Gia_Man_t * pNew, int * pFans, int nFans, int Type )
225 {
226     if ( Type == CBA_BOX_RAND )
227     {
228         int k, iLit = 1;
229         for ( k = 0; k < nFans; k++ )
230             iLit = Gia_ManHashAnd( pNew, iLit, pFans[k] );
231         return iLit;
232     }
233     if ( Type == CBA_BOX_ROR )
234     {
235         int k, iLit = 0;
236         for ( k = 0; k < nFans; k++ )
237             iLit = Gia_ManHashOr( pNew, iLit, pFans[k] );
238         return iLit;
239     }
240     if ( Type == CBA_BOX_RXOR )
241     {
242         int k, iLit = 0;
243         for ( k = 0; k < nFans; k++ )
244             iLit = Gia_ManHashXor( pNew, iLit, pFans[k] );
245         return iLit;
246     }
247     assert( 0 );
248     return -1;
249 }
Cba_BlastLess2(Gia_Man_t * pNew,int * pArg0,int * pArg1,int nBits)250 int Cba_BlastLess2( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits )
251 {
252     int k, iKnown = 0, iRes = 0;
253     for ( k = nBits - 1; k >= 0; k-- )
254     {
255         iRes   = Gia_ManHashMux( pNew, iKnown, iRes, Gia_ManHashAnd(pNew, Abc_LitNot(pArg0[k]), pArg1[k]) );
256         iKnown = Gia_ManHashOr( pNew, iKnown, Gia_ManHashXor(pNew, pArg0[k], pArg1[k]) );
257         if ( iKnown == 1 )
258             break;
259     }
260     return iRes;
261 }
Cba_BlastLess_rec(Gia_Man_t * pNew,int * pArg0,int * pArg1,int nBits,int * pYes,int * pNo)262 void Cba_BlastLess_rec( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits, int * pYes, int * pNo )
263 {
264     if ( nBits > 1 )
265     {
266         int Yes = Gia_ManHashAnd( pNew, Abc_LitNot(pArg0[nBits-1]), pArg1[nBits-1] ), YesR;
267         int No  = Gia_ManHashAnd( pNew, Abc_LitNot(pArg1[nBits-1]), pArg0[nBits-1] ), NoR;
268         if ( Yes == 1 || No == 1 )
269         {
270             *pYes = Yes;
271             *pNo  = No;
272             return;
273         }
274         Cba_BlastLess_rec( pNew, pArg0, pArg1, nBits-1, &YesR, &NoR );
275         *pYes = Gia_ManHashOr( pNew, Yes, Gia_ManHashAnd(pNew, Abc_LitNot(No),  YesR) );
276         *pNo  = Gia_ManHashOr( pNew, No,  Gia_ManHashAnd(pNew, Abc_LitNot(Yes), NoR ) );
277         return;
278     }
279     assert( nBits == 1 );
280     *pYes = Gia_ManHashAnd( pNew, Abc_LitNot(pArg0[0]), pArg1[0] );
281     *pNo  = Gia_ManHashAnd( pNew, Abc_LitNot(pArg1[0]), pArg0[0] );
282 }
Cba_BlastLess(Gia_Man_t * pNew,int * pArg0,int * pArg1,int nBits)283 int Cba_BlastLess( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits )
284 {
285     int Yes, No;
286     if ( nBits == 0 )
287         return 0;
288     Cba_BlastLess_rec( pNew, pArg0, pArg1, nBits, &Yes, &No );
289     return Yes;
290 }
Cba_BlastLessSigned(Gia_Man_t * pNew,int * pArg0,int * pArg1,int nBits)291 int Cba_BlastLessSigned( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits )
292 {
293     int iDiffSign = Gia_ManHashXor( pNew, pArg0[nBits-1], pArg1[nBits-1] );
294     return Gia_ManHashMux( pNew, iDiffSign, pArg0[nBits-1], Cba_BlastLess(pNew, pArg0, pArg1, nBits-1) );
295 }
Cba_BlastFullAdder(Gia_Man_t * pNew,int a,int b,int c,int * pc,int * ps)296 void Cba_BlastFullAdder( Gia_Man_t * pNew, int a, int b, int c, int * pc, int * ps )
297 {
298     int fUseXor = 0;
299     if ( fUseXor )
300     {
301         int Xor  = Gia_ManHashXor(pNew, a, b);
302         int And1 = Gia_ManHashAnd(pNew, a, b);
303         int And2 = Gia_ManHashAnd(pNew, c, Xor);
304         *ps      = Gia_ManHashXor(pNew, c, Xor);
305         *pc      = Gia_ManHashOr (pNew, And1, And2);
306     }
307     else
308     {
309         int And1 = Gia_ManHashAnd(pNew, a, b);
310         int And1_= Gia_ManHashAnd(pNew, Abc_LitNot(a), Abc_LitNot(b));
311         int Xor  = Abc_LitNot(Gia_ManHashOr(pNew, And1, And1_));
312         int And2 = Gia_ManHashAnd(pNew, c, Xor);
313         int And2_= Gia_ManHashAnd(pNew, Abc_LitNot(c), Abc_LitNot(Xor));
314         *ps      = Abc_LitNot(Gia_ManHashOr(pNew, And2, And2_));
315         *pc      = Gia_ManHashOr (pNew, And1, And2);
316     }
317 }
Cba_BlastAdder(Gia_Man_t * pNew,int Carry,int * pAdd0,int * pAdd1,int nBits)318 int Cba_BlastAdder( Gia_Man_t * pNew, int Carry, int * pAdd0, int * pAdd1, int nBits ) // result is in pAdd0
319 {
320     int b;
321     for ( b = 0; b < nBits; b++ )
322         Cba_BlastFullAdder( pNew, pAdd0[b], pAdd1[b], Carry, &Carry, &pAdd0[b] );
323     return Carry;
324 }
Cba_BlastSubtract(Gia_Man_t * pNew,int * pAdd0,int * pAdd1,int nBits)325 void Cba_BlastSubtract( Gia_Man_t * pNew, int * pAdd0, int * pAdd1, int nBits ) // result is in pAdd0
326 {
327     int b, Carry = 1;
328     for ( b = 0; b < nBits; b++ )
329         Cba_BlastFullAdder( pNew, pAdd0[b], Abc_LitNot(pAdd1[b]), Carry, &Carry, &pAdd0[b] );
330 }
Cba_BlastMinus(Gia_Man_t * pNew,int * pNum,int nNum,Vec_Int_t * vRes)331 void Cba_BlastMinus( Gia_Man_t * pNew, int * pNum, int nNum, Vec_Int_t * vRes )
332 {
333     int * pRes  = Cba_VecCopy( vRes, pNum, nNum );
334     int i, invert = 0;
335     for ( i = 0; i < nNum; i++ )
336     {
337         pRes[i] = Gia_ManHashMux( pNew, invert, Abc_LitNot(pRes[i]), pRes[i] );
338         invert = Gia_ManHashOr( pNew, invert, pNum[i] );
339     }
340 }
Cba_BlastMultiplier2(Gia_Man_t * pNew,int * pArg0,int * pArg1,int nBits,Vec_Int_t * vTemp,Vec_Int_t * vRes)341 void Cba_BlastMultiplier2( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits, Vec_Int_t * vTemp, Vec_Int_t * vRes )
342 {
343     int i, j;
344     Vec_IntFill( vRes, nBits, 0 );
345     for ( i = 0; i < nBits; i++ )
346     {
347         Vec_IntFill( vTemp, i, 0 );
348         for ( j = 0; Vec_IntSize(vTemp) < nBits; j++ )
349             Vec_IntPush( vTemp, Gia_ManHashAnd(pNew, pArg0[j], pArg1[i]) );
350         assert( Vec_IntSize(vTemp) == nBits );
351         Cba_BlastAdder( pNew, 0, Vec_IntArray(vRes), Vec_IntArray(vTemp), nBits );
352     }
353 }
Cba_BlastFullAdderCtrl(Gia_Man_t * pNew,int a,int ac,int b,int c,int * pc,int * ps,int fNeg)354 void Cba_BlastFullAdderCtrl( Gia_Man_t * pNew, int a, int ac, int b, int c, int * pc, int * ps, int fNeg )
355 {
356     int And  = Abc_LitNotCond( Gia_ManHashAnd(pNew, a, ac), fNeg );
357     Cba_BlastFullAdder( pNew, And, b, c, pc, ps );
358 }
Cba_BlastFullAdderSubtr(Gia_Man_t * pNew,int a,int b,int c,int * pc,int * ps,int fSub)359 void Cba_BlastFullAdderSubtr( Gia_Man_t * pNew, int a, int b, int c, int * pc, int * ps, int fSub )
360 {
361     Cba_BlastFullAdder( pNew, Gia_ManHashXor(pNew, a, fSub), b, c, pc, ps );
362 }
Cba_BlastMultiplier(Gia_Man_t * pNew,int * pArgA,int * pArgB,int nArgA,int nArgB,Vec_Int_t * vTemp,Vec_Int_t * vRes,int fSigned)363 void Cba_BlastMultiplier( Gia_Man_t * pNew, int * pArgA, int * pArgB, int nArgA, int nArgB, Vec_Int_t * vTemp, Vec_Int_t * vRes, int fSigned )
364 {
365     int * pRes, * pArgC, * pArgS, a, b, Carry = fSigned;
366     assert( nArgA > 0 && nArgB > 0 );
367     assert( fSigned == 0 || fSigned == 1 );
368     // prepare result
369     Vec_IntFill( vRes, nArgA + nArgB, 0 );
370     pRes = Vec_IntArray( vRes );
371     // prepare intermediate storage
372     Vec_IntFill( vTemp, 2 * nArgA, 0 );
373     pArgC = Vec_IntArray( vTemp );
374     pArgS = pArgC + nArgA;
375     // create matrix
376     for ( b = 0; b < nArgB; b++ )
377         for ( a = 0; a < nArgA; a++ )
378             Cba_BlastFullAdderCtrl( pNew, pArgA[a], pArgB[b], pArgS[a], pArgC[a],
379                 &pArgC[a], a ? &pArgS[a-1] : &pRes[b], fSigned && ((a+1 == nArgA) ^ (b+1 == nArgB)) );
380     // final addition
381     pArgS[nArgA-1] = fSigned;
382     for ( a = 0; a < nArgA; a++ )
383         Cba_BlastFullAdderCtrl( pNew, 1, pArgC[a], pArgS[a], Carry, &Carry, &pRes[nArgB+a], 0 );
384 }
Cba_BlastDivider(Gia_Man_t * pNew,int * pNum,int nNum,int * pDiv,int nDiv,int fQuo,Vec_Int_t * vRes)385 void Cba_BlastDivider( Gia_Man_t * pNew, int * pNum, int nNum, int * pDiv, int nDiv, int fQuo, Vec_Int_t * vRes )
386 {
387     int * pRes  = Cba_VecCopy( vRes, pNum, nNum );
388     int * pQuo  = ABC_ALLOC( int, nNum );
389     int * pTemp = ABC_ALLOC( int, nNum );
390     int i, j, known, borrow, y_bit, top_bit;
391     assert( nNum == nDiv );
392     for ( j = nNum - 1; j >= 0; j-- )
393     {
394         known = 0;
395         for ( i = nNum - 1; i > nNum - 1 - j; i-- )
396         {
397             known = Gia_ManHashOr( pNew, known, pDiv[i] );
398             if( known == 1 )
399                 break;
400         }
401         pQuo[j] = known;
402         for ( i = nNum - 1; i >= 0; i-- )
403         {
404             if ( known == 1 )
405                 break;
406             y_bit = (i >= j) ? pDiv[i-j] : 0;
407             pQuo[j] = Gia_ManHashMux( pNew, known, pQuo[j], Gia_ManHashAnd( pNew, y_bit, Abc_LitNot(pRes[i]) ) );
408             known = Gia_ManHashOr( pNew, known, Gia_ManHashXor(pNew, y_bit, pRes[i]));
409         }
410         pQuo[j] = Abc_LitNot(pQuo[j]);
411         if ( pQuo[j] == 0 )
412             continue;
413         borrow = 0;
414         for ( i = 0; i < nNum; i++ )
415         {
416             top_bit  = Gia_ManHashMux( pNew, borrow, Abc_LitNot(pRes[i]), pRes[i] );
417             y_bit    = (i >= j) ? pDiv[i-j] : 0;
418             borrow   = Gia_ManHashMux( pNew, pRes[i], Gia_ManHashAnd(pNew, borrow, y_bit), Gia_ManHashOr(pNew, borrow, y_bit) );
419             pTemp[i] = Gia_ManHashXor( pNew, top_bit, y_bit );
420         }
421         if ( pQuo[j] == 1 )
422             Cba_VecCopy( vRes, pTemp, nNum );
423         else
424             for( i = 0; i < nNum; i++ )
425                 pRes[i] = Gia_ManHashMux( pNew, pQuo[j], pTemp[i], pRes[i] );
426     }
427     ABC_FREE( pTemp );
428     if ( fQuo )
429         Cba_VecCopy( vRes, pQuo, nNum );
430     ABC_FREE( pQuo );
431 }
432 // non-restoring divider
Cba_BlastDivider2(Gia_Man_t * pNew,int * pNum,int nNum,int * pDiv,int nDiv,int fQuo,Vec_Int_t * vRes)433 void Cba_BlastDivider2( Gia_Man_t * pNew, int * pNum, int nNum, int * pDiv, int nDiv, int fQuo, Vec_Int_t * vRes )
434 {
435     int i, * pRes  = Vec_IntArray(vRes);
436     int k, * pQuo  = ABC_ALLOC( int, nNum );
437     assert( nNum > 0 && nDiv > 0 );
438     assert( Vec_IntSize(vRes) < nNum + nDiv );
439     for ( i = 0; i < nNum + nDiv; i++ )
440         pRes[i] = i < nNum ? pNum[i] : 0;
441     for ( i = nNum-1; i >= 0; i-- )
442     {
443         int Cntrl = i == nNum-1 ? 1 : pQuo[i+1];
444         int Carry = Cntrl;
445         for ( k = 0; k <= nDiv; k++ )
446             Cba_BlastFullAdderSubtr( pNew, k < nDiv ? pDiv[k] : 0, pRes[i+k], Carry, &Carry, &pRes[i+k], Cntrl );
447         pQuo[i] = Abc_LitNot(pRes[i+nDiv]);
448     }
449     if ( fQuo )
450         Cba_VecCopy( vRes, pQuo, nNum );
451     else
452     {
453         int Carry = 0, Temp;
454         for ( k = 0; k < nDiv; k++ )
455         {
456             Cba_BlastFullAdder( pNew, pDiv[k], pRes[k], Carry, &Carry, &Temp );
457             pRes[k] = Gia_ManHashMux( pNew, pQuo[0], pRes[k], Temp );
458         }
459         Vec_IntShrink( vRes, nDiv );
460     }
461     ABC_FREE( pQuo );
462 }
Cba_BlastDividerSigned(Gia_Man_t * pNew,int * pNum,int nNum,int * pDiv,int nDiv,int fQuo,Vec_Int_t * vRes)463 void Cba_BlastDividerSigned( Gia_Man_t * pNew, int * pNum, int nNum, int * pDiv, int nDiv, int fQuo, Vec_Int_t * vRes )
464 {
465     Vec_Int_t * vNum   = Vec_IntAlloc( nNum );
466     Vec_Int_t * vDiv   = Vec_IntAlloc( nDiv );
467     Vec_Int_t * vRes00 = Vec_IntAlloc( nNum + nDiv );
468     Vec_Int_t * vRes01 = Vec_IntAlloc( nNum + nDiv );
469     Vec_Int_t * vRes10 = Vec_IntAlloc( nNum + nDiv );
470     Vec_Int_t * vRes11 = Vec_IntAlloc( nNum + nDiv );
471     Vec_Int_t * vRes2  = Vec_IntAlloc( nNum );
472     int k, iDiffSign   = Gia_ManHashXor( pNew, pNum[nNum-1], pDiv[nDiv-1] );
473     Cba_BlastMinus( pNew, pNum, nNum, vNum );
474     Cba_BlastMinus( pNew, pDiv, nDiv, vDiv );
475     Cba_BlastDivider( pNew,               pNum, nNum,               pDiv, nDiv, fQuo, vRes00 );
476     Cba_BlastDivider( pNew,               pNum, nNum, Vec_IntArray(vDiv), nDiv, fQuo, vRes01 );
477     Cba_BlastDivider( pNew, Vec_IntArray(vNum), nNum,               pDiv, nDiv, fQuo, vRes10 );
478     Cba_BlastDivider( pNew, Vec_IntArray(vNum), nNum, Vec_IntArray(vDiv), nDiv, fQuo, vRes11 );
479     Vec_IntClear( vRes );
480     for ( k = 0; k < nNum; k++ )
481     {
482         int Data0 =  Gia_ManHashMux( pNew, pDiv[nDiv-1], Vec_IntEntry(vRes01,k), Vec_IntEntry(vRes00,k) );
483         int Data1 =  Gia_ManHashMux( pNew, pDiv[nDiv-1], Vec_IntEntry(vRes11,k), Vec_IntEntry(vRes10,k) );
484         Vec_IntPush( vRes, Gia_ManHashMux(pNew, pNum[nNum-1], Data1, Data0) );
485     }
486     Cba_BlastMinus( pNew, Vec_IntArray(vRes), nNum, vRes2 );
487     for ( k = 0; k < nNum; k++ )
488         Vec_IntWriteEntry( vRes, k, Gia_ManHashMux(pNew, fQuo ? iDiffSign : pNum[nNum-1], Vec_IntEntry(vRes2,k), Vec_IntEntry(vRes,k)) );
489     Vec_IntFree( vNum );
490     Vec_IntFree( vDiv );
491     Vec_IntFree( vRes00 );
492     Vec_IntFree( vRes01 );
493     Vec_IntFree( vRes10 );
494     Vec_IntFree( vRes11 );
495     Vec_IntFree( vRes2 );
496     assert( Vec_IntSize(vRes) == nNum );
497 }
Cba_BlastZeroCondition(Gia_Man_t * pNew,int * pDiv,int nDiv,Vec_Int_t * vRes)498 void Cba_BlastZeroCondition( Gia_Man_t * pNew, int * pDiv, int nDiv, Vec_Int_t * vRes )
499 {
500     int i, Entry, iLit = Cba_BlastReduction( pNew, pDiv, nDiv, CBA_BOX_ROR );
501     Vec_IntForEachEntry( vRes, Entry, i )
502         Vec_IntWriteEntry( vRes, i, Gia_ManHashAnd(pNew, iLit, Entry) );
503 }
Cba_BlastTable(Gia_Man_t * pNew,word * pTable,int * pFans,int nFans,int nOuts,Vec_Int_t * vRes)504 void Cba_BlastTable( Gia_Man_t * pNew, word * pTable, int * pFans, int nFans, int nOuts, Vec_Int_t * vRes )
505 {
506     extern int Kit_TruthToGia( Gia_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory, Vec_Int_t * vLeaves, int fHash );
507     Vec_Int_t * vMemory = Vec_IntAlloc( 0 );
508     Vec_Int_t vLeaves = { nFans, nFans, pFans };
509     word * pTruth = ABC_ALLOC( word, Abc_TtWordNum(nFans) );
510     int o, i, m, iLit, nMints = (1 << nFans);
511     Vec_IntClear( vRes );
512     for ( o = 0; o < nOuts; o++ )
513     {
514         // derive truth table
515         memset( pTruth, 0, sizeof(word) * Abc_TtWordNum(nFans) );
516         for ( m = 0; m < nMints; m++ )
517             for ( i = 0; i < nFans; i++ )
518                 if ( Abc_TtGetBit( pTable, m * nFans + i ) )
519                     Abc_TtSetBit( pTruth, m );
520         // implement truth table
521         if ( nFans < 6 )
522             pTruth[0] = Abc_Tt6Stretch( pTruth[0], nFans );
523         iLit = Kit_TruthToGia( pNew, (unsigned *)pTruth, nFans, vMemory, &vLeaves, 1 );
524         Vec_IntPush( vRes, iLit );
525     }
526     Vec_IntFree( vMemory );
527     ABC_FREE( pTruth );
528 }
Cba_BlastPower(Gia_Man_t * pNew,int * pNum,int nNum,int * pExp,int nExp,Vec_Int_t * vTemp,Vec_Int_t * vRes)529 void Cba_BlastPower( Gia_Man_t * pNew, int * pNum, int nNum, int * pExp, int nExp, Vec_Int_t * vTemp, Vec_Int_t * vRes )
530 {
531     Vec_Int_t * vDegrees = Vec_IntAlloc( 2*nNum );
532     Vec_Int_t * vResTemp = Vec_IntAlloc( 2*nNum );
533     int i, * pDegrees = NULL, * pRes = Vec_IntArray(vRes);
534     int k, * pResTemp = Vec_IntArray(vResTemp);
535     Vec_IntFill( vRes, nNum, 0 );
536     Vec_IntWriteEntry( vRes, 0, 1 );
537     for ( i = 0; i < nExp; i++ )
538     {
539         if ( i == 0 )
540             pDegrees = Cba_VecCopy( vDegrees, pNum, nNum );
541         else
542         {
543             Cba_BlastMultiplier2( pNew, pDegrees, pDegrees, nNum, vTemp, vResTemp );
544             pDegrees = Cba_VecCopy( vDegrees, pResTemp, nNum );
545         }
546         Cba_BlastMultiplier2( pNew, pRes, pDegrees, nNum, vTemp, vResTemp );
547         for ( k = 0; k < nNum; k++ )
548             pRes[k] = Gia_ManHashMux( pNew, pExp[i], pResTemp[k], pRes[k] );
549     }
550     Vec_IntFree( vResTemp );
551     Vec_IntFree( vDegrees );
552 }
Cba_BlastSqrt(Gia_Man_t * pNew,int * pNum,int nNum,Vec_Int_t * vTmp,Vec_Int_t * vRes)553 void Cba_BlastSqrt( Gia_Man_t * pNew, int * pNum, int nNum, Vec_Int_t * vTmp, Vec_Int_t * vRes )
554 {
555     int * pRes, * pSum, * pSumP;
556     int i, k, Carry = -1;
557     assert( nNum % 2 == 0 );
558     Vec_IntFill( vRes, nNum/2, 0 );
559     Vec_IntFill( vTmp, 2*nNum, 0 );
560     pRes = Vec_IntArray( vRes );
561     pSum = Vec_IntArray( vTmp );
562     pSumP = pSum + nNum;
563     for ( i = 0; i < nNum/2; i++ )
564     {
565         pSumP[0] = pNum[nNum-2*i-2];
566         pSumP[1] = pNum[nNum-2*i-1];
567         for ( k = 0; k < i+1; k++ )
568             pSumP[k+2] = pSum[k];
569         for ( k = 0; k < i + 3; k++ )
570         {
571             if ( k >= 2 && k < i + 2 ) // middle ones
572                 Cba_BlastFullAdder( pNew, pSumP[k], Abc_LitNot(pRes[i-k+1]), Carry, &Carry, &pSum[k] );
573             else
574                 Cba_BlastFullAdder( pNew, pSumP[k], Abc_LitNot(k ? Carry:1), 1,     &Carry, &pSum[k] );
575             if ( k == 0 || k > i )
576                 Carry = Abc_LitNot(Carry);
577         }
578         pRes[i] = Abc_LitNot(Carry);
579         for ( k = 0; k < i + 3; k++ )
580             pSum[k] = Gia_ManHashMux( pNew, pRes[i], pSum[k], pSumP[k] );
581     }
582     Vec_IntReverseOrder( vRes );
583 }
584 
585 /**Function*************************************************************
586 
587   Synopsis    []
588 
589   Description []
590 
591   SideEffects []
592 
593   SeeAlso     []
594 
595 ***********************************************************************/
Cba_NtkBlast(Cba_Ntk_t * p,int fSeq)596 Gia_Man_t * Cba_NtkBlast( Cba_Ntk_t * p, int fSeq )
597 {
598     int fUseOldMultiplierBlasting = 0;
599     Gia_Man_t * pTemp, * pNew;
600     Vec_Int_t * vTemp0, * vTemp1, * vTemp2, * vRes;
601     Vec_Str_t * vInit = fSeq ? Vec_StrAlloc(100) : NULL;
602     Vec_Int_t * vBits = &p->vFonBits;
603     int nBits = Cba_NtkPrepareBits( p );
604     int * pFans0, * pFans1, * pFans2;
605     int nRange, nRange0, nRange1, nRange2;
606     int Type, iFon, iFon0, iFon1, iFon2, fSigned01;
607     int i, k, b, iFin, iObj, iLit, nAndPrev;
608     Vec_IntClear( vBits );
609     Vec_IntGrow( vBits, nBits );
610     vTemp0 = Vec_IntAlloc( 1000 );
611     vTemp1 = Vec_IntAlloc( 1000 );
612     vTemp2 = Vec_IntAlloc( 1000 );
613     vRes   = Vec_IntAlloc( 1000 );
614     // clean AND-gate counters
615     memset( p->pDesign->nAnds, 0, sizeof(int) * CBA_BOX_LAST );
616     // create AIG manager
617     pNew = Gia_ManStart( 5 * Cba_NtkObjNum(p) + 1000 );
618     pNew->pName = Abc_UtilStrsav( Cba_ManName(p->pDesign) );
619     Gia_ManHashAlloc( pNew );
620     // blast in the topological order
621     Cba_NtkForEachObj( p, i )
622     {
623         Type = Cba_ObjType(p, i);
624         if ( Type == CBA_OBJ_PO )
625             continue;
626         assert( Vec_IntSize(vBits) == Cba_FonCopy(p, Cba_ObjFon0(p, i)) );
627         nRange = Cba_ObjRangeSize(p, i); assert( nRange > 0 );
628         if ( Cba_ObjIsPi(p, i) || Cba_ObjIsSeq(p, i) )
629         {
630             for ( k = 0; k < nRange; k++ )
631                 Vec_IntPush( vBits, Gia_ManAppendCi(pNew) );
632             assert( Type == CBA_BOX_DFFCPL || Cba_ObjFonNum(p, i) == 1 );
633             continue;
634         }
635         assert( Cba_ObjFinNum(p, i) > 0 );
636         iFon0     = Cba_ObjFinNum(p, i) > 0 ? Cba_ObjFinFon(p, i, 0) : -1;
637         iFon1     = Cba_ObjFinNum(p, i) > 1 ? Cba_ObjFinFon(p, i, 1) : -1;
638         iFon2     = Cba_ObjFinNum(p, i) > 2 ? Cba_ObjFinFon(p, i, 2) : -1;
639         nRange0   = Cba_ObjFinNum(p, i) > 0 ? Cba_FonRangeSize(p, iFon0) : -1;
640         nRange1   = Cba_ObjFinNum(p, i) > 1 ? Cba_FonRangeSize(p, iFon1) : -1;
641         nRange2   = Cba_ObjFinNum(p, i) > 2 ? Cba_FonRangeSize(p, iFon2) : -1;
642         pFans0    = (Cba_ObjFinNum(p, i) > 0 && Cba_FonIsReal(iFon0)) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon0) ) : NULL;
643         pFans1    = (Cba_ObjFinNum(p, i) > 1 && Cba_FonIsReal(iFon1)) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon1) ) : NULL;
644         pFans2    = (Cba_ObjFinNum(p, i) > 2 && Cba_FonIsReal(iFon2)) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon2) ) : NULL;
645         fSigned01 = (Cba_ObjFinNum(p, i) > 1 && Cba_FonSigned(p, iFon0) && Cba_FonSigned(p, iFon1));
646         nAndPrev  = Gia_ManAndNum(pNew);
647         Vec_IntClear( vRes );
648         if ( Type == CBA_BOX_SLICE )
649         {
650             int Left   = Cba_ObjLeft( p, i );
651             int Right  = Cba_ObjRight( p, i );
652             int Left0  = Cba_FonLeft( p, iFon0 );
653             int Right0 = Cba_FonRight( p, iFon0 );
654             if ( Left > Right )
655             {
656                 assert( Left0 > Right0 );
657                 for ( k = Right; k <= Left; k++ )
658                     Vec_IntPush( vRes, pFans0[k - Right0] );
659             }
660             else
661             {
662                 assert( Left < Right && Left0 < Right0 );
663                 for ( k = Right; k >= Left; k-- )
664                     Vec_IntPush( vRes, pFans0[k - Right0] );
665             }
666         }
667         else if ( Type == CBA_BOX_CONCAT )
668         {
669             int iFinT, iFonT, nTotal = 0;
670             Cba_ObjForEachFinFon( p, i, iFinT, iFonT, k )
671                 nTotal += Cba_FonRangeSize( p, iFonT );
672             assert( nRange == nTotal );
673             Cba_ObjForEachFinFon( p, i, iFinT, iFonT, k )
674             {
675                 nRange0 = Cba_FonRangeSize( p, iFonT );
676                 pFans0  = Cba_FonIsReal(iFonT) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFonT) ) : NULL;
677                 pFans0  = Cba_VecLoadFanins( p, vTemp0, iFonT, pFans0, nRange0, nRange0, Cba_FonSigned(p, iFonT) );
678                 for ( b = 0; b < nRange0; b++ )
679                     Vec_IntPush( vRes, pFans0[b] );
680             }
681         }
682         else if ( Type == CBA_BOX_BUF )
683         {
684             int nRangeMax = Abc_MaxInt( nRange0, nRange );
685             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, Cba_FonSigned(p, iFon0) );
686             for ( k = 0; k < nRange; k++ )
687                 Vec_IntPush( vRes, pArg0[k] );
688         }
689         else if ( Type >= CBA_BOX_CF && Type <= CBA_BOX_CZ )
690         {
691             assert( 0 );
692             //word * pTruth = (word *)Cba_ObjFanins(p, i);
693             //for ( k = 0; k < nRange; k++ )
694             //    Vec_IntPush( vRes, Abc_TtGetBit(pTruth, k) );
695         }
696         else if ( Type == CBA_BOX_MUX || Type == CBA_BOX_NMUX )
697         {
698             // It is strange and disturbing that Verilog standard treats these statements differently:
699             // Statement 1:
700             //     assign o = i ? b : a;
701             // Statement 2:
702             //     always @( i or a or b )
703             //       begin
704             //         case ( i )
705             //           0 : o = a ;
706             //           1 : o = b ;
707             //         endcase
708             //       end
709             // If a is signed and b is unsigned,  Statement 1 does not sign-extend a, while Statement 2 does.
710             // The signedness of o does not matter.
711             //
712             // Below we (somewhat arbitrarily) distinguish these two by assuming that
713             // Statement 1 has three fanins, while Statement 2 has more than three fanins.
714             //
715             int iFinT, iFonT, fSigned = 1;
716             assert( nRange0 >= 1 && Cba_ObjFinNum(p, i) >= 3 );
717             assert( 1 + (1 << nRange0) == Cba_ObjFinNum(p, i) );
718             Cba_ObjForEachFinFon( p, i, iFinT, iFonT, k )
719                 if ( k > 0 )
720                     fSigned &= Cba_FonSigned(p, iFonT);
721             for ( b = 0; b < nRange; b++ )
722             {
723                 Vec_IntClear( vTemp0 );
724                 Cba_ObjForEachFinFon( p, i, iFinT, iFonT, k )
725                     if ( k > 0 )
726                     {
727                         nRange1 = Cba_FonRangeSize( p, iFonT );
728                         pFans1  = Cba_FonIsReal(iFonT) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFonT) ) : NULL;
729                         if ( Cba_ObjFinNum(p, i) == 3 ) // Statement 1
730                             Vec_IntPush( vTemp0, k < nRange1 ? pFans1[k] : (fSigned? pFans1[nRange1-1] : 0) );
731                         else // Statement 2
732                             Vec_IntPush( vTemp0, k < nRange1 ? pFans1[k] : (Cba_FonSigned(p, iFonT)? pFans1[nRange1-1] : 0) );
733                     }
734                 Vec_IntPush( vRes, Cba_NtkMuxTree_rec(pNew, pFans0, nRange0, vTemp0, 0) );
735             }
736         }
737         else if ( Type == CBA_BOX_SHIR || Type == CBA_BOX_SHIRA ||
738                   Type == CBA_BOX_SHIL || Type == CBA_BOX_SHILA )
739         {
740             int nRangeMax = Abc_MaxInt( nRange, nRange0 );
741             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, Cba_FonSigned(p, iFon0) );
742             if ( Type == CBA_BOX_SHIR || Type == CBA_BOX_SHIRA )
743                 Cba_BlastShiftRight( pNew, pArg0, nRangeMax, pFans1, nRange1, Cba_FonSigned(p, iFon0) && Type == CBA_BOX_SHIRA, vRes );
744             else
745                 Cba_BlastShiftLeft( pNew, pArg0, nRangeMax, pFans1, nRange1, 0, vRes );
746             Vec_IntShrink( vRes, nRange );
747         }
748         else if ( Type == CBA_BOX_ROTR )
749         {
750             assert( nRange0 == nRange );
751             Cba_BlastRotateRight( pNew, pFans0, nRange0, pFans1, nRange1, vRes );
752         }
753         else if ( Type == CBA_BOX_ROTL )
754         {
755             assert( nRange0 == nRange );
756             Cba_BlastRotateLeft( pNew, pFans0, nRange0, pFans1, nRange1, vRes );
757         }
758         else if ( Type == CBA_BOX_INV )
759         {
760             int nRangeMax = Abc_MaxInt( nRange, nRange0 );
761             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, Cba_FonSigned(p, iFon0) );
762             for ( k = 0; k < nRange; k++ )
763                 Vec_IntPush( vRes, Abc_LitNot(pArg0[k]) );
764         }
765         else if ( Type == CBA_BOX_AND )
766         {
767             int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
768             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
769             int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
770             for ( k = 0; k < nRange; k++ )
771                 Vec_IntPush( vRes, Gia_ManHashAnd(pNew, pArg0[k], pArg1[k]) );
772         }
773         else if ( Type == CBA_BOX_OR )
774         {
775             int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
776             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
777             int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
778             for ( k = 0; k < nRange; k++ )
779                 Vec_IntPush( vRes, Gia_ManHashOr(pNew, pArg0[k], pArg1[k]) );
780         }
781         else if ( Type == CBA_BOX_XOR )
782         {
783             int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
784             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
785             int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
786             for ( k = 0; k < nRange; k++ )
787                 Vec_IntPush( vRes, Gia_ManHashXor(pNew, pArg0[k], pArg1[k]) );
788         }
789         else if ( Type == CBA_BOX_LNOT )
790         {
791             iLit = Cba_BlastReduction( pNew, pFans0, nRange0, CBA_BOX_ROR );
792             Vec_IntFill( vRes, 1, Abc_LitNot(iLit) );
793             for ( k = 1; k < nRange; k++ )
794                 Vec_IntPush( vRes, 0 );
795         }
796         else if ( Type == CBA_BOX_LAND )
797         {
798             int iLit0 = Cba_BlastReduction( pNew, pFans0, nRange0, CBA_BOX_ROR );
799             int iLit1 = Cba_BlastReduction( pNew, pFans1, nRange1, CBA_BOX_ROR );
800             Vec_IntFill( vRes, 1, Gia_ManHashAnd(pNew, iLit0, iLit1) );
801             for ( k = 1; k < nRange; k++ )
802                 Vec_IntPush( vRes, 0 );
803         }
804         else if ( Type == CBA_BOX_LOR )
805         {
806             int iLit0 = Cba_BlastReduction( pNew, pFans0, nRange0, CBA_BOX_ROR );
807             int iLit1 = Cba_BlastReduction( pNew, pFans1, nRange1, CBA_BOX_ROR );
808             Vec_IntFill( vRes, 1, Gia_ManHashOr(pNew, iLit0, iLit1) );
809             for ( k = 1; k < nRange; k++ )
810                 Vec_IntPush( vRes, 0 );
811         }
812         else if ( Type == CBA_BOX_LXOR )
813         {
814             int iLit0 = Cba_BlastReduction( pNew, pFans0, nRange0, CBA_BOX_ROR );
815             int iLit1 = Cba_BlastReduction( pNew, pFans1, nRange1, CBA_BOX_ROR );
816             Vec_IntFill( vRes, 1, Gia_ManHashXor(pNew, iLit0, iLit1) );
817             for ( k = 1; k < nRange; k++ )
818                 Vec_IntPush( vRes, 0 );
819         }
820         else if ( Type == CBA_BOX_EQU || Type == CBA_BOX_NEQU )
821         {
822             int iLit = 0, nRangeMax = Abc_MaxInt( nRange0, nRange1 );
823             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
824             int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
825             for ( k = 0; k < nRangeMax; k++ )
826                 iLit = Gia_ManHashOr( pNew, iLit, Gia_ManHashXor(pNew, pArg0[k], pArg1[k]) );
827             Vec_IntFill( vRes, 1, Abc_LitNotCond(iLit, Type == CBA_BOX_EQU) );
828             for ( k = 1; k < nRange; k++ )
829                 Vec_IntPush( vRes, 0 );
830         }
831         else if ( Type == CBA_BOX_LTHAN || Type == CBA_BOX_METHAN ||
832                   Type == CBA_BOX_MTHAN || Type == CBA_BOX_LETHAN )
833         {
834             int nRangeMax = Abc_MaxInt( nRange0, nRange1 );
835             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
836             int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
837             int fSwap  = (Type == CBA_BOX_MTHAN  || Type == CBA_BOX_LETHAN);
838             int fCompl = (Type == CBA_BOX_METHAN || Type == CBA_BOX_LETHAN);
839             if ( fSwap ) ABC_SWAP( int *, pArg0, pArg1 );
840             if ( fSigned01 )
841                 iLit = Cba_BlastLessSigned( pNew, pArg0, pArg1, nRangeMax );
842             else
843                 iLit = Cba_BlastLess( pNew, pArg0, pArg1, nRangeMax );
844             iLit = Abc_LitNotCond( iLit, fCompl );
845             Vec_IntFill( vRes, 1, iLit );
846             for ( k = 1; k < nRange; k++ )
847                 Vec_IntPush( vRes, 0 );
848         }
849         else if ( Type == CBA_BOX_RAND || Type == CBA_BOX_ROR || Type == CBA_BOX_RXOR )
850         {
851             Vec_IntPush( vRes, Cba_BlastReduction( pNew, pFans0, nRange0, Type ) );
852             for ( k = 1; k < nRange; k++ )
853                 Vec_IntPush( vRes, 0 );
854         }
855         else if ( Type == CBA_BOX_ADD )
856         {
857             int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange1, nRange2) );
858             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, 1, 1, 0 );
859             int * pArg1 = Cba_VecLoadFanins( p, vRes,   iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
860             int * pArg2 = Cba_VecLoadFanins( p, vTemp1, iFon2, pFans2, nRange2, nRangeMax, fSigned01 );
861             int Carry   = Cba_BlastAdder( pNew, pArg0[0], pArg1, pArg2, nRange ); // result is in pArg1 (vRes)
862             assert( nRange0 == 1 );
863             Vec_IntShrink( vRes, nRange );
864             Vec_IntPush( vRes, Carry );
865         }
866         else if ( Type == CBA_BOX_SUB )
867         {
868             int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
869             int * pArg0 = Cba_VecLoadFanins( p, vRes,   iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
870             int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
871             Cba_BlastSubtract( pNew, pArg0, pArg1, nRange ); // result is in pFan0 (vRes)
872             Vec_IntShrink( vRes, nRange );
873         }
874         else if ( Type == CBA_BOX_MUL )
875         {
876             if ( fUseOldMultiplierBlasting )
877             {
878                 int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
879                 int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
880                 int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
881                 Cba_BlastMultiplier2( pNew, pArg0, pArg1, nRange, vTemp2, vRes );
882                 Vec_IntShrink( vRes, nRange );
883             }
884             else
885             {
886                 int nRangeMax = Abc_MaxInt(nRange0, nRange1);
887                 int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
888                 int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
889                 Cba_BlastMultiplier( pNew, pArg0, pArg1, nRangeMax, nRangeMax, vTemp2, vRes, fSigned01 );
890                 if ( nRange > nRangeMax + nRangeMax )
891                     Vec_IntFillExtra( vRes, nRange, fSigned01 ? Vec_IntEntryLast(vRes) : 0 );
892                 else
893                     Vec_IntShrink( vRes, nRange );
894                 assert( Vec_IntSize(vRes) == nRange );
895             }
896         }
897         else if ( Type == CBA_BOX_DIV || Type == CBA_BOX_MOD )
898         {
899             int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
900             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, fSigned01 );
901             int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRangeMax, fSigned01 );
902             if ( fSigned01 )
903                 Cba_BlastDividerSigned( pNew, pArg0, nRangeMax, pArg1, nRangeMax, Type == CBA_BOX_DIV, vRes );
904             else
905                 Cba_BlastDivider( pNew, pArg0, nRangeMax, pArg1, nRangeMax, Type == CBA_BOX_DIV, vRes );
906             Vec_IntShrink( vRes, nRange );
907             if ( Type == CBA_BOX_DIV )
908                 Cba_BlastZeroCondition( pNew, pFans1, nRange1, vRes );
909         }
910         else if ( Type == CBA_BOX_MIN )
911         {
912             int nRangeMax = Abc_MaxInt( nRange0, nRange );
913             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, Cba_FonSigned(p, iFon0) );
914             Cba_BlastMinus( pNew, pArg0, nRangeMax, vRes );
915             Vec_IntShrink( vRes, nRange );
916         }
917         else if ( Type == CBA_BOX_POW )
918         {
919             int nRangeMax = Abc_MaxInt(nRange0, nRange);
920             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRangeMax, Cba_FonSigned(p, iFon0) );
921             int * pArg1 = Cba_VecLoadFanins( p, vTemp1, iFon1, pFans1, nRange1, nRange1,   Cba_FonSigned(p, iFon1) );
922             Cba_BlastPower( pNew, pArg0, nRangeMax, pArg1, nRange1, vTemp2, vRes );
923             Vec_IntShrink( vRes, nRange );
924         }
925         else if ( Type == CBA_BOX_SQRT )
926         {
927             int * pArg0 = Cba_VecLoadFanins( p, vTemp0, iFon0, pFans0, nRange0, nRange0 + (nRange0 & 1), 0 );
928             nRange0 += (nRange0 & 1);
929             Cba_BlastSqrt( pNew, pArg0, nRange0, vTemp2, vRes );
930             if ( nRange > Vec_IntSize(vRes) )
931                 Vec_IntFillExtra( vRes, nRange, 0 );
932             else
933                 Vec_IntShrink( vRes, nRange );
934         }
935         else if ( Type == CBA_BOX_TABLE )
936         {
937             assert( 0 );
938             //Cba_BlastTable( pNew, Cba_ObjTable(p, p, i), pFans0, nRange0, nRange, vRes );
939         }
940         else assert( 0 );
941         Vec_IntAppend( vBits, vRes );
942         p->pDesign->nAnds[Type] += Gia_ManAndNum(pNew) - nAndPrev;
943     }
944     assert( nBits == Vec_IntSize(vBits) );
945     p->pDesign->nAnds[0] = Gia_ManAndNum(pNew);
946     // create COs
947     Cba_NtkForEachPo( p, iObj, i )
948     {
949         Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k )
950         {
951             nRange = Cba_FonRangeSize( p, iFon );
952             pFans0  = Cba_FonIsReal(iFon) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon) ) : NULL;
953             pFans0  = Cba_VecLoadFanins( p, vTemp0, iFon, pFans0, nRange, nRange, Cba_FonSigned(p, iFon) );
954             for ( b = 0; b < nRange; b++ )
955                 Gia_ManAppendCo( pNew, pFans0[b] );
956         }
957     }
958     Cba_NtkForEachBoxSeq( p, iObj, i )
959     {
960         if ( fSeq )
961         {
962             assert( Cba_ObjType(p, iObj) == CBA_BOX_DFFCPL );
963             iFon0 = Cba_ObjFinFon( p, iObj, 0 );
964             iFon1 = Cba_ObjFinFon( p, iObj, 1 );
965             nRange0 = Cba_FonRangeSize( p, iFon0 );
966             nRange1 = Cba_FonRangeSize( p, iFon1 );
967             assert( nRange0 == nRange1 );
968             Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k )
969             {
970                 nRange = Cba_FonRangeSize( p, iFon );
971                 pFans0 = Cba_FonIsReal(iFon) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon) ) : NULL;
972                 pFans0 = Cba_VecLoadFanins( p, vTemp0, iFon, pFans0, nRange0, nRange0, Cba_FonSigned(p, iFon) );
973                 if ( k == 0 )
974                 {
975                     for ( b = 0; b < nRange; b++ )
976                         Gia_ManAppendCo( pNew, pFans0[b] );
977                 }
978                 else if ( k == 1 )
979                 {
980                     for ( b = 0; b < nRange; b++ )
981                         if ( pFans0[b] == 0 )
982                             Vec_StrPush( vInit, '0' );
983                         else if ( pFans0[b] == 1 )
984                             Vec_StrPush( vInit, '1' );
985                         else
986                             Vec_StrPush( vInit, 'x' );
987                 }
988                 else break;
989             }
990         }
991         else // combinational
992         {
993             Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k )
994             {
995                 nRange = Cba_FonRangeSize( p, iFon );
996                 pFans0  = Cba_FonIsReal(iFon) ? Vec_IntEntryP( vBits, Cba_FonCopy(p, iFon) ) : NULL;
997                 pFans0  = Cba_VecLoadFanins( p, vTemp0, iFon, pFans0, nRange, nRange, Cba_FonSigned(p, iFon) );
998                 for ( b = 0; b < nRange; b++ )
999                     Gia_ManAppendCo( pNew, pFans0[b] );
1000             }
1001         }
1002     }
1003     Vec_IntFree( vTemp0 );
1004     Vec_IntFree( vTemp1 );
1005     Vec_IntFree( vTemp2 );
1006     Vec_IntFree( vRes );
1007     // finalize AIG
1008     pNew = Gia_ManCleanup( pTemp = pNew );
1009     Gia_ManDupRemapLiterals( vBits, pTemp );
1010     Gia_ManStop( pTemp );
1011     // transform AIG with init state
1012     if ( fSeq )
1013     {
1014         Gia_ManSetRegNum( pNew, Vec_StrSize(vInit) );
1015         Vec_StrPush( vInit, '\0' );
1016         pNew = Gia_ManDupZeroUndc( pTemp = pNew, Vec_StrArray(vInit), 0, 0, 1 );
1017         Gia_ManDupRemapLiterals( vBits, pTemp );
1018         Gia_ManStop( pTemp );
1019         Vec_StrFreeP( &vInit );
1020     }
1021     //Vec_IntErase( vBits );
1022     //Vec_IntErase( &p->vCopies );
1023     return pNew;
1024 }
1025 
1026 /**Function*************************************************************
1027 
1028   Synopsis    []
1029 
1030   Description []
1031 
1032   SideEffects []
1033 
1034   SeeAlso     []
1035 
1036 ***********************************************************************/
Cba_ManBlast(Cba_Man_t * p,int fBarBufs,int fSeq,int fVerbose)1037 Gia_Man_t * Cba_ManBlast( Cba_Man_t * p, int fBarBufs, int fSeq, int fVerbose )
1038 {
1039     return Cba_NtkBlast( Cba_ManRoot(p), fSeq );
1040 }
1041 
1042 /**Function*************************************************************
1043 
1044   Synopsis    []
1045 
1046   Description []
1047 
1048   SideEffects []
1049 
1050   SeeAlso     []
1051 
1052 ***********************************************************************/
Cba_ManInsertGia(Cba_Man_t * p,Gia_Man_t * pGia)1053 Cba_Man_t * Cba_ManInsertGia( Cba_Man_t * p, Gia_Man_t * pGia )
1054 {
1055     return NULL;
1056 }
Cba_ManInsertAbc(Cba_Man_t * p,void * pAbc)1057 Cba_Man_t * Cba_ManInsertAbc( Cba_Man_t * p, void * pAbc )
1058 {
1059     Abc_Ntk_t * pNtk = (Abc_Ntk_t *)pAbc;
1060     return (Cba_Man_t *)pNtk;
1061 }
1062 
1063 ////////////////////////////////////////////////////////////////////////
1064 ///                       END OF FILE                                ///
1065 ////////////////////////////////////////////////////////////////////////
1066 
1067 
1068 ABC_NAMESPACE_IMPL_END
1069 
1070