ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
Functions
wlnBlast.c File Reference
#include "wln.h"
#include "base/wlc/wlc.h"
Include dependency graph for wlnBlast.c:

Go to the source code of this file.

Functions

ABC_NAMESPACE_IMPL_START void Rtl_VecExtend (Vec_Int_t *p, int nRange, int fSigned)
 DECLARATIONS ///.
 
void Rtl_NtkBlastNode (Gia_Man_t *pNew, int Type, int nIns, Vec_Int_t *vDatas, int nRange, int fSign0, int fSign1)
 

Function Documentation

◆ Rtl_NtkBlastNode()

void Rtl_NtkBlastNode ( Gia_Man_t * pNew,
int Type,
int nIns,
Vec_Int_t * vDatas,
int nRange,
int fSign0,
int fSign1 )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 61 of file wlnBlast.c.

62{
63 extern void Wlc_BlastMinus( Gia_Man_t * pNew, int * pNum, int nNum, Vec_Int_t * vRes );
64 extern int Wlc_BlastReduction( Gia_Man_t * pNew, int * pFans, int nFans, int Type );
65 extern int Wlc_BlastLess( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits );
66 extern int Wlc_BlastLessSigned( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits );
67 extern void Wlc_BlastShiftRight( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, int fSticky, Vec_Int_t * vRes );
68 extern void Wlc_BlastShiftLeft( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, int fSticky, Vec_Int_t * vRes );
69 extern int Wlc_BlastAdder( Gia_Man_t * pNew, int * pAdd0, int * pAdd1, int nBits, int Carry ); // result is in pAdd0
70 extern void Wlc_BlastSubtract( Gia_Man_t * pNew, int * pAdd0, int * pAdd1, int nBits, int Carry ); // result is in pAdd0
71 extern int Wlc_NtkCountConstBits( int * pArray, int nSize );
72 extern void Wlc_BlastBooth( Gia_Man_t * pNew, int * pArgA, int * pArgB, int nArgA, int nArgB, Vec_Int_t * vRes, int fSigned, int fCla, Vec_Wec_t ** pvProds, int fVerbose );
73 extern void Wlc_BlastMultiplier3( Gia_Man_t * pNew, int * pArgA, int * pArgB, int nArgA, int nArgB, Vec_Int_t * vRes, int fSigned, int fCla, Vec_Wec_t ** pvProds, int fVerbose );
74 extern void Wlc_BlastZeroCondition( Gia_Man_t * pNew, int * pDiv, int nDiv, Vec_Int_t * vRes );
75 extern void Wlc_BlastDividerTop( Gia_Man_t * pNew, int * pNum, int nNum, int * pDiv, int nDiv, int fQuo, Vec_Int_t * vRes, int fNonRest );
76 extern void Wlc_BlastDividerSigned( Gia_Man_t * pNew, int * pNum, int nNum, int * pDiv, int nDiv, int fQuo, Vec_Int_t * vRes, int fNonRest );
77 extern void Wlc_BlastPower( Gia_Man_t * pNew, int * pNum, int nNum, int * pExp, int nExp, Vec_Int_t * vTemp, Vec_Int_t * vRes );
78
79 int k, iLit, iLit0, iLit1;
80 if ( nIns == 1 )
81 {
82 Vec_Int_t * vArg = vDatas;
83 Vec_Int_t * vRes = vDatas+3;
84 assert( Vec_IntSize(vRes) == 0 );
85 if ( Type == ABC_OPER_BIT_INV ) // Y = ~A $not
86 {
87 assert( Vec_IntSize(vArg) == nRange );
88 Vec_IntForEachEntry( vArg, iLit, k )
89 Vec_IntPush( vRes, Abc_LitNot(iLit) );
90 return;
91 }
92 if ( Type == ABC_OPER_BIT_BUF ) // Y = +A $pos
93 {
94 assert( Vec_IntSize(vArg) == nRange );
95 Vec_IntForEachEntry( vArg, iLit, k )
96 Vec_IntPush( vRes, iLit );
97 return;
98 }
99 if ( Type == ABC_OPER_ARI_MIN ) // Y = -A $neg
100 {
101 assert( Vec_IntSize(vArg) == nRange );
102 Wlc_BlastMinus( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), vRes );
103 return;
104 }
105 if ( Type == ABC_OPER_RED_AND ) // Y = &A $reduce_and
106 {
107 assert( nRange == 1 );
108 Vec_IntPush( vRes, Wlc_BlastReduction( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), WLC_OBJ_REDUCT_AND ) );
109 for ( k = 1; k < nRange; k++ )
110 Vec_IntPush( vRes, 0 );
111 return;
112 }
113 if ( Type == ABC_OPER_RED_OR ) // Y = |A $reduce_or $reduce_bool
114 {
115 assert( nRange == 1 );
116 Vec_IntPush( vRes, Wlc_BlastReduction( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), WLC_OBJ_REDUCT_OR ) );
117 for ( k = 1; k < nRange; k++ )
118 Vec_IntPush( vRes, 0 );
119 return;
120 }
121 if ( Type == ABC_OPER_RED_XOR ) // Y = ^A $reduce_xor
122 {
123 assert( nRange == 1 );
124 Vec_IntPush( vRes, Wlc_BlastReduction( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), WLC_OBJ_REDUCT_XOR ) );
125 for ( k = 1; k < nRange; k++ )
126 Vec_IntPush( vRes, 0 );
127 return;
128 }
129 if ( Type == ABC_OPER_RED_NXOR ) // Y = ~^A $reduce_xnor
130 {
131 assert( nRange == 1 );
132 Vec_IntPush( vRes, Wlc_BlastReduction( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), WLC_OBJ_REDUCT_NXOR ) );
133 for ( k = 1; k < nRange; k++ )
134 Vec_IntPush( vRes, 0 );
135 return;
136 }
137 if ( Type == ABC_OPER_LOGIC_NOT ) // Y = !A $logic_not
138 {
139 int iLit = Wlc_BlastReduction( pNew, Vec_IntArray(vArg), Vec_IntSize(vArg), WLC_OBJ_REDUCT_OR );
140 assert( nRange == 1 );
141 Vec_IntFill( vRes, 1, Abc_LitNot(iLit) );
142 for ( k = 1; k < nRange; k++ )
143 Vec_IntPush( vRes, 0 );
144 return;
145 }
146 assert( 0 );
147 return;
148 }
149
150 if ( nIns == 2 )
151 {
152 Vec_Int_t * vArg0 = vDatas;
153 Vec_Int_t * vArg1 = vDatas+1;
154 Vec_Int_t * vRes = vDatas+3;
155 int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(Vec_IntSize(vArg0), Vec_IntSize(vArg1)) );
156 int nSizeArg0 = Vec_IntSize(vArg0);
157 int nSizeArg1 = Vec_IntSize(vArg1);
158 Rtl_VecExtend( vArg0, nRangeMax, fSign0 );
159 Rtl_VecExtend( vArg1, nRangeMax, fSign1 );
160 assert( Vec_IntSize(vArg0) == Vec_IntSize(vArg1) );
161 assert( Vec_IntSize(vRes) == 0 );
162 if ( Type == ABC_OPER_LOGIC_AND ) // Y = A && B $logic_and
163 {
164 int iLit0 = Wlc_BlastReduction( pNew, Vec_IntArray(vArg0), Vec_IntSize(vArg0), WLC_OBJ_REDUCT_OR );
165 int iLit1 = Wlc_BlastReduction( pNew, Vec_IntArray(vArg1), Vec_IntSize(vArg1), WLC_OBJ_REDUCT_OR );
166 assert( 1 == nRange );
167 Vec_IntFill( vRes, 1, Gia_ManHashAnd(pNew, iLit0, iLit1) );
168 for ( k = 1; k < nRange; k++ )
169 Vec_IntPush( vRes, 0 );
170 return;
171 }
172 if ( Type == ABC_OPER_LOGIC_OR ) // Y = A || B $logic_or
173 {
174 int iLit0 = Wlc_BlastReduction( pNew, Vec_IntArray(vArg0), Vec_IntSize(vArg0), WLC_OBJ_REDUCT_OR );
175 int iLit1 = Wlc_BlastReduction( pNew, Vec_IntArray(vArg1), Vec_IntSize(vArg1), WLC_OBJ_REDUCT_OR );
176 assert( 1 == nRange );
177 Vec_IntFill( vRes, 1, Gia_ManHashOr(pNew, iLit0, iLit1) );
178 for ( k = 1; k < nRange; k++ )
179 Vec_IntPush( vRes, 0 );
180 return;
181 }
182
183 if ( Type == ABC_OPER_BIT_AND ) // Y = A & B $and
184 {
185 Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
186 Vec_IntPush( vRes, Gia_ManHashAnd(pNew, iLit0, iLit1) );
187 Vec_IntShrink( vRes, nRange );
188 return;
189 }
190 if ( Type == ABC_OPER_BIT_OR ) // Y = A | B $or
191 {
192 Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
193 Vec_IntPush( vRes, Gia_ManHashOr(pNew, iLit0, iLit1) );
194 Vec_IntShrink( vRes, nRange );
195 return;
196 }
197 if ( Type == ABC_OPER_BIT_XOR ) // Y = A ^ B $xor
198 {
199 Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
200 Vec_IntPush( vRes, Gia_ManHashXor(pNew, iLit0, iLit1) );
201 Vec_IntShrink( vRes, nRange );
202 return;
203 }
204 if ( Type == ABC_OPER_BIT_NXOR ) // Y = A ~^ B $xnor
205 {
206 assert( Vec_IntSize(vArg0) == nRange );
207 Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
208 Vec_IntPush( vRes, Abc_LitNot(Gia_ManHashXor(pNew, iLit0, iLit1)) );
209 Vec_IntShrink( vRes, nRange );
210 return;
211 }
212/*
213 if ( !strcmp(pType, "$lt") ) return ABC_OPER_COMP_LESS; // Y = A < B $lt
214 if ( !strcmp(pType, "$le") ) return ABC_OPER_COMP_LESSEQU; // Y = A <= B $le
215 if ( !strcmp(pType, "$ge") ) return ABC_OPER_COMP_MOREEQU; // Y = A >= B $ge
216 if ( !strcmp(pType, "$gt") ) return ABC_OPER_COMP_MORE; // Y = A > B $gt
217 if ( !strcmp(pType, "$eq") ) return ABC_OPER_COMP_EQU; // Y = A == B $eq
218 if ( !strcmp(pType, "$ne") ) return ABC_OPER_COMP_NOTEQU; // Y = A != B $ne
219*/
220 if ( Type == ABC_OPER_COMP_EQU || Type == ABC_OPER_COMP_NOTEQU )
221 {
222 iLit = 0;
223 assert( nRange == 1 );
224 Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
225 iLit = Gia_ManHashOr( pNew, iLit, Gia_ManHashXor(pNew, iLit0, iLit1) );
226 Vec_IntFill( vRes, 1, Abc_LitNotCond(iLit, Type == ABC_OPER_COMP_EQU) );
227 for ( k = 1; k < nRange; k++ )
228 Vec_IntPush( vRes, 0 );
229 return;
230 }
231 if ( Type == ABC_OPER_COMP_LESS || Type == ABC_OPER_COMP_LESSEQU ||
232 Type == ABC_OPER_COMP_MORE || Type == ABC_OPER_COMP_MOREEQU )
233 {
234 int fSigned = fSign0 && fSign1;
235 int fSwap = (Type == ABC_OPER_COMP_MORE || Type == ABC_OPER_COMP_LESSEQU);
236 int fCompl = (Type == ABC_OPER_COMP_MOREEQU || Type == ABC_OPER_COMP_LESSEQU);
237 assert( Vec_IntSize(vArg0) == Vec_IntSize(vArg1) );
238 assert( nRange == 1 );
239 if ( fSwap )
240 ABC_SWAP( Vec_Int_t, *vArg0, *vArg1 )
241 if ( fSigned )
242 iLit = Wlc_BlastLessSigned( pNew, Vec_IntArray(vArg0), Vec_IntArray(vArg1), Vec_IntSize(vArg0) );
243 else
244 iLit = Wlc_BlastLess( pNew, Vec_IntArray(vArg0), Vec_IntArray(vArg1), Vec_IntSize(vArg0) );
245 iLit = Abc_LitNotCond( iLit, fCompl );
246 Vec_IntFill( vRes, 1, iLit );
247 for ( k = 1; k < nRange; k++ )
248 Vec_IntPush( vRes, 0 );
249 return;
250 }
251/*
252 if ( !strcmp(pType, "$shl") ) return ABC_OPER_SHIFT_L; // Y = A << B $shl
253 if ( !strcmp(pType, "$shr") ) return ABC_OPER_SHIFT_R; // Y = A >> B $shr
254 if ( !strcmp(pType, "$sshl") ) return ABC_OPER_SHIFT_LA; // Y = A <<< B $sshl
255 if ( !strcmp(pType, "$sshr") ) return ABC_OPER_SHIFT_RA; // Y = A >>> B $sshr
256*/
257 if ( Type == ABC_OPER_SHIFT_R || Type == ABC_OPER_SHIFT_RA ||
258 Type == ABC_OPER_SHIFT_L || Type == ABC_OPER_SHIFT_LA )
259 {
260 Vec_IntShrink( vArg1, nSizeArg1 );
261 if ( Type == ABC_OPER_SHIFT_R || Type == ABC_OPER_SHIFT_RA )
262 Wlc_BlastShiftRight( pNew, Vec_IntArray(vArg0), nRangeMax, Vec_IntArray(vArg1), nSizeArg1, fSign0 && Type == ABC_OPER_SHIFT_RA, vRes );
263 else
264 Wlc_BlastShiftLeft( pNew, Vec_IntArray(vArg0), nRangeMax, Vec_IntArray(vArg1), nSizeArg1, 0, vRes );
265 Vec_IntShrink( vRes, nRange );
266 return;
267 }
268/*
269 if ( !strcmp(pType, "$add") ) return ABC_OPER_ARI_ADD; // Y = A + B $add
270 if ( !strcmp(pType, "$sub") ) return ABC_OPER_ARI_SUB; // Y = A - B $sub
271 if ( !strcmp(pType, "$mul") ) return ABC_OPER_ARI_MUL; // Y = A * B $mul
272 if ( !strcmp(pType, "$div") ) return ABC_OPER_ARI_DIV; // Y = A / B $div
273 if ( !strcmp(pType, "$mod") ) return ABC_OPER_ARI_MOD; // Y = A % B $mod
274 if ( !strcmp(pType, "$pow") ) return ABC_OPER_ARI_POW; // Y = A ** B $pow
275*/
276 if ( Type == ABC_OPER_ARI_ADD || Type == ABC_OPER_ARI_SUB )
277 {
278 //Vec_IntPrint( vArg0 );
279 //Vec_IntPrint( vArg1 );
280 Vec_IntAppend( vRes, vArg0 );
281 if ( Type == ABC_OPER_ARI_ADD )
282 Wlc_BlastAdder( pNew, Vec_IntArray(vRes), Vec_IntArray(vArg1), nRangeMax, 0 ); // result is in pFan0 (vRes)
283 else
284 Wlc_BlastSubtract( pNew, Vec_IntArray(vRes), Vec_IntArray(vArg1), nRangeMax, 1 ); // result is in pFan0 (vRes)
285 Vec_IntShrink( vRes, nRange );
286 return;
287 }
288 if ( Type == ABC_OPER_ARI_MUL )
289 {
290 int fBooth = 1;
291 int fCla = 0;
292 int fSigned = fSign0 && fSign1;
293 //int i, iObj;
294 Vec_IntShrink( vArg0, nSizeArg0 );
295 Vec_IntShrink( vArg1, nSizeArg1 );
296
297 //printf( "Adding %d + %d + %d buffers\n", nSizeArg0, nSizeArg1, nRange );
298 //Vec_IntForEachEntry( vArg0, iObj, i )
299 // Vec_IntWriteEntry( vArg0, i, Gia_ManAppendBuf(pNew, iObj) );
300 //Vec_IntForEachEntry( vArg1, iObj, i )
301 // Vec_IntWriteEntry( vArg1, i, Gia_ManAppendBuf(pNew, iObj) );
302
303 if ( Wlc_NtkCountConstBits(Vec_IntArray(vArg0), Vec_IntSize(vArg0)) < Wlc_NtkCountConstBits(Vec_IntArray(vArg1), Vec_IntSize(vArg1)) )
304 ABC_SWAP( Vec_Int_t, *vArg0, *vArg1 )
305 if ( fBooth )
306 Wlc_BlastBooth( pNew, Vec_IntArray(vArg0), Vec_IntArray(vArg1), Vec_IntSize(vArg0), Vec_IntSize(vArg1), vRes, fSigned, fCla, NULL, 0 );
307 else
308 Wlc_BlastMultiplier3( pNew, Vec_IntArray(vArg0), Vec_IntArray(vArg1), Vec_IntSize(vArg0), Vec_IntSize(vArg1), vRes, fSigned, fCla, NULL, 0 );
309 if ( nRange > Vec_IntSize(vRes) )
310 Vec_IntFillExtra( vRes, nRange, fSigned ? Vec_IntEntryLast(vRes) : 0 );
311 else
312 Vec_IntShrink( vRes, nRange );
313 assert( Vec_IntSize(vRes) == nRange );
314
315 //Vec_IntForEachEntry( vRes, iObj, i )
316 // Vec_IntWriteEntry( vRes, i, Gia_ManAppendBuf(pNew, iObj) );
317 return;
318 }
319 if ( Type == ABC_OPER_ARI_DIV || Type == ABC_OPER_ARI_MOD )
320 {
321 int fDivBy0 = 1; // correct with 1
322 int fSigned = fSign0 && fSign1;
323 if ( fSigned )
324 Wlc_BlastDividerSigned( pNew, Vec_IntArray(vArg0), nRangeMax, Vec_IntArray(vArg1), nRangeMax, Type == ABC_OPER_ARI_DIV, vRes, 0 );
325 else
326 Wlc_BlastDividerTop( pNew, Vec_IntArray(vArg0), nRangeMax, Vec_IntArray(vArg1), nRangeMax, Type == ABC_OPER_ARI_DIV, vRes, 0 );
327 Vec_IntShrink( vRes, nRange );
328 if ( !fDivBy0 )
329 Wlc_BlastZeroCondition( pNew, Vec_IntArray(vArg1), nRange, vRes );
330 return;
331 }
332 if ( Type == ABC_OPER_ARI_POW )
333 {
334 Vec_Int_t * vTemp = vDatas+4;
335 Vec_IntGrow( vTemp, nRangeMax );
336 Vec_IntGrow( vRes, nRangeMax );
337 Vec_IntShrink( vArg1, nSizeArg1 );
338 Wlc_BlastPower( pNew, Vec_IntArray(vArg0), nRangeMax, Vec_IntArray(vArg1), Vec_IntSize(vArg1), vTemp, vRes );
339 Vec_IntShrink( vRes, nRange );
340 return;
341 }
342 }
343
344 if ( nIns == 3 )
345 {
346 if ( Type == ABC_OPER_SEL_NMUX ) // $mux
347 {
348 Vec_Int_t * vArg0 = vDatas;
349 Vec_Int_t * vArg1 = vDatas+1;
350 Vec_Int_t * vArgS = vDatas+2;
351 Vec_Int_t * vRes = vDatas+3;
352 int iCtrl = Vec_IntEntry(vArgS, 0);
353 //Vec_IntPrint( vArg0 );
354 //Vec_IntPrint( vArg1 );
355 //Vec_IntPrint( vArgS );
356 assert( Vec_IntSize(vArg0) == Vec_IntSize(vArg1) );
357 assert( Vec_IntSize(vArg0) == nRange );
358 assert( Vec_IntSize(vArgS) == 1 );
359 assert( Vec_IntSize(vRes) == 0 );
360 Vec_IntForEachEntryTwo( vArg0, vArg1, iLit0, iLit1, k )
361 Vec_IntPush( vRes, Gia_ManHashMux(pNew, iCtrl, iLit1, iLit0) );
362 return;
363 }
364 if ( Type == ABC_OPER_SEL_SEL ) // $pmux
365 {
366 int i, k, iLit;
367 Vec_Int_t * vArgA = vDatas;
368 Vec_Int_t * vArgB = vDatas+1;
369 Vec_Int_t * vArgS = vDatas+2;
370 Vec_Int_t * vRes = vDatas+3;
371 Vec_Int_t * vTemp = vDatas+4;
372 assert( Vec_IntSize(vArgA) == nRange ); // widthA = widthY
373 assert( Vec_IntSize(vArgB) == Vec_IntSize(vArgA)*Vec_IntSize(vArgS) ); // widthB == widthA*widthS
374 assert( Vec_IntSize(vRes) == 0 );
375 for ( i = 0; i < nRange; i++ )
376 {
377 int iCond = 1;
378 Vec_IntClear( vTemp );
379 Vec_IntForEachEntry( vArgS, iLit, k ) // iLit = S[i]
380 {
381 //Vec_IntPush( vTemp, Abc_LitNot( Gia_ManHashAnd(pNew, iLit, Vec_IntEntry(vArgB, nRange*(Vec_IntSize(vArgS)-1-k)+i)) ) ); // B[widthA*k+i]
382 Vec_IntPush( vTemp, Abc_LitNot( Gia_ManHashAnd(pNew, iLit, Vec_IntEntry(vArgB, nRange*k+i)) ) ); // B[widthA*k+i]
383 iCond = Gia_ManHashAnd( pNew, iCond, Abc_LitNot(iLit) );
384 }
385 Vec_IntPush( vTemp, Abc_LitNot( Gia_ManHashAnd(pNew, iCond, Vec_IntEntry(vArgA, i)) ) );
386 Vec_IntPush( vRes, Abc_LitNot( Gia_ManHashAndMulti(pNew, vTemp) ) );
387 }
388 return;
389 }
390 }
391}
ABC_OPER_COMP_LESS
@ ABC_OPER_COMP_LESS
Definition abcOper.h:112
ABC_OPER_LOGIC_OR
@ ABC_OPER_LOGIC_OR
Definition abcOper.h:86
ABC_OPER_RED_XOR
@ ABC_OPER_RED_XOR
Definition abcOper.h:80
ABC_OPER_COMP_EQU
@ ABC_OPER_COMP_EQU
Definition abcOper.h:116
ABC_OPER_ARI_MUL
@ ABC_OPER_ARI_MUL
Definition abcOper.h:101
ABC_OPER_SEL_NMUX
@ ABC_OPER_SEL_NMUX
Definition abcOper.h:91
ABC_OPER_SHIFT_RA
@ ABC_OPER_SHIFT_RA
Definition abcOper.h:122
ABC_OPER_BIT_XOR
@ ABC_OPER_BIT_XOR
Definition abcOper.h:61
ABC_OPER_COMP_MORE
@ ABC_OPER_COMP_MORE
Definition abcOper.h:115
ABC_OPER_RED_NXOR
@ ABC_OPER_RED_NXOR
Definition abcOper.h:81
ABC_OPER_SHIFT_L
@ ABC_OPER_SHIFT_L
Definition abcOper.h:119
ABC_OPER_LOGIC_NOT
@ ABC_OPER_LOGIC_NOT
Definition abcOper.h:83
ABC_OPER_ARI_DIV
@ ABC_OPER_ARI_DIV
Definition abcOper.h:103
ABC_OPER_RED_AND
@ ABC_OPER_RED_AND
Definition abcOper.h:76
ABC_OPER_RED_OR
@ ABC_OPER_RED_OR
Definition abcOper.h:78
ABC_OPER_SEL_SEL
@ ABC_OPER_SEL_SEL
Definition abcOper.h:92
ABC_OPER_ARI_POW
@ ABC_OPER_ARI_POW
Definition abcOper.h:106
ABC_OPER_COMP_LESSEQU
@ ABC_OPER_COMP_LESSEQU
Definition abcOper.h:113
ABC_OPER_LOGIC_AND
@ ABC_OPER_LOGIC_AND
Definition abcOper.h:84
ABC_OPER_COMP_MOREEQU
@ ABC_OPER_COMP_MOREEQU
Definition abcOper.h:114
ABC_OPER_ARI_MOD
@ ABC_OPER_ARI_MOD
Definition abcOper.h:104
ABC_OPER_SHIFT_R
@ ABC_OPER_SHIFT_R
Definition abcOper.h:120
ABC_OPER_SHIFT_LA
@ ABC_OPER_SHIFT_LA
Definition abcOper.h:121
ABC_OPER_BIT_INV
@ ABC_OPER_BIT_INV
Definition abcOper.h:56
ABC_OPER_BIT_AND
@ ABC_OPER_BIT_AND
Definition abcOper.h:57
ABC_OPER_COMP_NOTEQU
@ ABC_OPER_COMP_NOTEQU
Definition abcOper.h:117
ABC_OPER_BIT_OR
@ ABC_OPER_BIT_OR
Definition abcOper.h:59
ABC_OPER_BIT_BUF
@ ABC_OPER_BIT_BUF
Definition abcOper.h:55
ABC_OPER_ARI_SUB
@ ABC_OPER_ARI_SUB
Definition abcOper.h:100
ABC_OPER_BIT_NXOR
@ ABC_OPER_BIT_NXOR
Definition abcOper.h:62
ABC_OPER_ARI_MIN
@ ABC_OPER_ARI_MIN
Definition abcOper.h:107
ABC_OPER_ARI_ADD
@ ABC_OPER_ARI_ADD
Definition abcOper.h:99
ABC_SWAP
#define ABC_SWAP(Type, a, b)
Definition abc_global.h:253
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition bblif.c:37
Gia_ManHashAndMulti
int Gia_ManHashAndMulti(Gia_Man_t *p, Vec_Int_t *vLits)
Definition giaHash.c:783
Gia_ManHashOr
int Gia_ManHashOr(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaHash.c:621
Gia_ManHashXor
int Gia_ManHashXor(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaHash.c:668
Gia_Man_t
struct Gia_Man_t_ Gia_Man_t
Definition gia.h:96
Gia_ManHashMux
int Gia_ManHashMux(Gia_Man_t *p, int iCtrl, int iData1, int iData0)
Definition giaHash.c:692
Gia_ManHashAnd
int Gia_ManHashAnd(Gia_Man_t *p, int iLit0, int iLit1)
Definition giaHash.c:576
assert
#define assert(ex)
Definition util_old.h:213
Vec_IntForEachEntry
#define Vec_IntForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition vecInt.h:54
Vec_IntForEachEntryTwo
#define Vec_IntForEachEntryTwo(vVec1, vVec2, Entry1, Entry2, i)
Definition vecInt.h:66
Vec_Wec_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Wec_t_ Vec_Wec_t
INCLUDES ///.
Definition vecWec.h:42
Wlc_BlastAdder
int Wlc_BlastAdder(Gia_Man_t *pNew, int *pAdd0, int *pAdd1, int nBits, int Carry)
Definition wlcBlast.c:429
Wlc_BlastDividerSigned
void Wlc_BlastDividerSigned(Gia_Man_t *pNew, int *pNum, int nNum, int *pDiv, int nDiv, int fQuo, Vec_Int_t *vRes, int fNonRest)
Definition wlcBlast.c:764
Wlc_BlastPower
void Wlc_BlastPower(Gia_Man_t *pNew, int *pNum, int nNum, int *pExp, int nExp, Vec_Int_t *vTemp, Vec_Int_t *vRes)
Definition wlcBlast.c:844
Wlc_BlastZeroCondition
void Wlc_BlastZeroCondition(Gia_Man_t *pNew, int *pDiv, int nDiv, Vec_Int_t *vRes)
Definition wlcBlast.c:799
Wlc_BlastShiftRight
void Wlc_BlastShiftRight(Gia_Man_t *pNew, int *pNum, int nNum, int *pShift, int nShift, int fSticky, Vec_Int_t *vRes)
Definition wlcBlast.c:228
Wlc_NtkCountConstBits
ABC_NAMESPACE_IMPL_START int Wlc_NtkCountConstBits(int *pArray, int nSize)
DECLARATIONS ///.
Definition wlcBlast.c:48
Wlc_BlastBooth
void Wlc_BlastBooth(Gia_Man_t *pNew, int *pArgA, int *pArgB, int nArgA, int nArgB, Vec_Int_t *vRes, int fSigned, int fCla, Vec_Wec_t **pvProds, int fVerbose)
Definition wlcBlast.c:1242
Wlc_BlastLessSigned
int Wlc_BlastLessSigned(Gia_Man_t *pNew, int *pArg0, int *pArg1, int nBits)
Definition wlcBlast.c:372
Wlc_BlastMinus
void Wlc_BlastMinus(Gia_Man_t *pNew, int *pNum, int nNum, Vec_Int_t *vRes)
Definition wlcBlast.c:603
Wlc_BlastMultiplier3
void Wlc_BlastMultiplier3(Gia_Man_t *pNew, int *pArgA, int *pArgB, int nArgA, int nArgB, Vec_Int_t *vRes, int fSigned, int fCla, Vec_Wec_t **pvProds, int fVerbose)
Definition wlcBlast.c:1140
Wlc_BlastShiftLeft
void Wlc_BlastShiftLeft(Gia_Man_t *pNew, int *pNum, int nNum, int *pShift, int nShift, int fSticky, Vec_Int_t *vRes)
Definition wlcBlast.c:264
Wlc_BlastDividerTop
void Wlc_BlastDividerTop(Gia_Man_t *pNew, int *pNum, int nNum, int *pDiv, int nDiv, int fQuo, Vec_Int_t *vRes, int fNonRest)
Definition wlcBlast.c:757
Wlc_BlastSubtract
void Wlc_BlastSubtract(Gia_Man_t *pNew, int *pAdd0, int *pAdd1, int nBits, int Carry)
Definition wlcBlast.c:436
Wlc_BlastLess
int Wlc_BlastLess(Gia_Man_t *pNew, int *pArg0, int *pArg1, int nBits)
Definition wlcBlast.c:364
Wlc_BlastReduction
int Wlc_BlastReduction(Gia_Man_t *pNew, int *pFans, int nFans, int Type)
Definition wlcBlast.c:305
WLC_OBJ_REDUCT_AND
@ WLC_OBJ_REDUCT_AND
Definition wlc.h:82
WLC_OBJ_REDUCT_OR
@ WLC_OBJ_REDUCT_OR
Definition wlc.h:83
WLC_OBJ_REDUCT_XOR
@ WLC_OBJ_REDUCT_XOR
Definition wlc.h:84
WLC_OBJ_REDUCT_NXOR
@ WLC_OBJ_REDUCT_NXOR
Definition wlc.h:87
Rtl_VecExtend
ABC_NAMESPACE_IMPL_START void Rtl_VecExtend(Vec_Int_t *p, int nRange, int fSigned)
DECLARATIONS ///.
Definition wlnBlast.c:45
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Rtl_VecExtend()

ABC_NAMESPACE_IMPL_START void Rtl_VecExtend ( Vec_Int_t * p,
int nRange,
int fSigned )

DECLARATIONS ///.

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

FileName [wlnBlast.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Word-level network.]

Synopsis []

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - September 23, 2018.]

Revision [

Id
wlnBlast.c,v 1.00 2018/09/23 00:00:00 alanmi Exp

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file wlnBlast.c.

46{
47 Vec_IntFillExtra( p, nRange, fSigned ? Vec_IntEntryLast(p) : 0 );
48}
p
Cube * p
Definition exorList.c:222
Here is the caller graph for this function: