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

Go to the source code of this file.

Functions

ABC_NAMESPACE_IMPL_START void Wln_WriteTableOne (FILE *pFile, int nFans, int nOuts, word *pTable, int Id)
 DECLARATIONS ///.
 
void Wln_WriteTables (FILE *pFile, Wln_Ntk_t *p)
 
void Wln_WriteAddPos (Wln_Ntk_t *p)
 
void Wln_WriteVerIntVec (FILE *pFile, Wln_Ntk_t *p, Vec_Int_t *vVec, int Start)
 
void Wln_WriteVerInt (FILE *pFile, Wln_Ntk_t *p)
 
void Wln_WriteVer (Wln_Ntk_t *p, char *pFileName)
 

Function Documentation

◆ Wln_WriteAddPos()

void Wln_WriteAddPos ( Wln_Ntk_t * p)

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

Synopsis [This was used to add POs to each node except PIs and MUXes.]

Description []

SideEffects []

SeeAlso []

Definition at line 97 of file wlnWriteVer.c.

98{
99 int iObj;
100 Wln_NtkForEachObj( p, iObj )
101 if ( !Wln_ObjIsCio(p, iObj) )
102 Wln_ObjCreateCo( p, iObj );
103}
p
Cube * p
Definition exorList.c:222
Wln_ObjCreateCo
int Wln_ObjCreateCo(Wln_Ntk_t *p, int iFanin)
Definition wlnObj.c:129
Wln_NtkForEachObj
#define Wln_NtkForEachObj(p, i)
MACRO DEFINITIONS ///.
Definition wln.h:187
Here is the call graph for this function:

◆ Wln_WriteTableOne()

ABC_NAMESPACE_IMPL_START void Wln_WriteTableOne ( FILE * pFile,
int nFans,
int nOuts,
word * pTable,
int Id )

DECLARATIONS ///.

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

FileName [wlnWriteVer.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Word-level network.]

Synopsis [Writing Verilog.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id
wlnWriteVer.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 wlnWriteVer.c.

46{
47 int m, nMints = (1<<nFans);
48// Abc_TtPrintHexArrayRev( stdout, pTable, nMints ); printf( "\n" );
49 assert( nOuts > 0 && nOuts <= 64 && (64 % nOuts) == 0 );
50 fprintf( pFile, "module table%d(ind, val);\n", Id );
51 fprintf( pFile, " input [%d:0] ind;\n", nFans-1 );
52 fprintf( pFile, " output [%d:0] val;\n", nOuts-1 );
53 fprintf( pFile, " reg [%d:0] val;\n", nOuts-1 );
54 fprintf( pFile, " always @(ind)\n" );
55 fprintf( pFile, " begin\n" );
56 fprintf( pFile, " case (ind)\n" );
57 for ( m = 0; m < nMints; m++ )
58 fprintf( pFile, " %d\'h%x: val = %d\'h%x;\n", nFans, m, nOuts, (unsigned)((pTable[(nOuts * m) >> 6] >> ((nOuts * m) & 63)) & Abc_Tt6Mask(nOuts)) );
59 fprintf( pFile, " endcase\n" );
60 fprintf( pFile, " end\n" );
61 fprintf( pFile, "endmodule\n" );
62 fprintf( pFile, "\n" );
63}
assert
#define assert(ex)
Definition util_old.h:213
Here is the caller graph for this function:

◆ Wln_WriteTables()

void Wln_WriteTables ( FILE * pFile,
Wln_Ntk_t * p )

Definition at line 64 of file wlnWriteVer.c.

65{
66 Vec_Int_t * vNodes;
67 word * pTable;
68 int i, iObj;
69 if ( p->vTables == NULL || Vec_PtrSize(p->vTables) == 0 )
70 return;
71 // map tables into their nodes
72 vNodes = Vec_IntStart( Vec_PtrSize(p->vTables) );
73 Wln_NtkForEachObj( p, iObj )
74 if ( Wln_ObjType(p, iObj) == ABC_OPER_TABLE )
75 Vec_IntWriteEntry( vNodes, Wln_ObjFanin1(p, iObj), iObj );
76 // write tables
77 Vec_PtrForEachEntry( word *, p->vTables, pTable, i )
78 {
79 int iNode = Vec_IntEntry( vNodes, i );
80 int iFanin = Wln_ObjFanin0( p, iNode );
81 Wln_WriteTableOne( pFile, Wln_ObjRange(p, iFanin), Wln_ObjRange(p, iNode), pTable, i );
82 }
83 Vec_IntFree( vNodes );
84}
ABC_OPER_TABLE
@ ABC_OPER_TABLE
Definition abcOper.h:129
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition bblif.c:37
word
unsigned __int64 word
DECLARATIONS ///.
Definition kitPerm.c:36
Vec_PtrForEachEntry
#define Vec_PtrForEachEntry(Type, vVec, pEntry, i)
MACRO DEFINITIONS ///.
Definition vecPtr.h:55
Wln_WriteTableOne
ABC_NAMESPACE_IMPL_START void Wln_WriteTableOne(FILE *pFile, int nFans, int nOuts, word *pTable, int Id)
DECLARATIONS ///.
Definition wlnWriteVer.c:45
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Wln_WriteVer()

void Wln_WriteVer ( Wln_Ntk_t * p,
char * pFileName )

Definition at line 478 of file wlnWriteVer.c.

479{
480 FILE * pFile;
481 pFile = fopen( pFileName, "w" );
482 if ( pFile == NULL )
483 {
484 fprintf( stdout, "Wln_WriteVer(): Cannot open the output file \"%s\".\n", pFileName );
485 return;
486 }
487 fprintf( pFile, "// Benchmark \"%s\" from file \"%s\" written by ABC on %s\n", p->pName, p->pSpec ? p->pSpec : "unknown", Extra_TimeStamp() );
488 fprintf( pFile, "\n" );
489 Wln_WriteTables( pFile, p );
490// if ( fAddCos )
491// Wln_WriteAddPos( p );
492 Wln_WriteVerInt( pFile, p );
493 fprintf( pFile, "\n" );
494 fclose( pFile );
495}
Extra_TimeStamp
char * Extra_TimeStamp()
Definition extraUtilFile.c:465
Wln_WriteTables
void Wln_WriteTables(FILE *pFile, Wln_Ntk_t *p)
Definition wlnWriteVer.c:64
Wln_WriteVerInt
void Wln_WriteVerInt(FILE *pFile, Wln_Ntk_t *p)
Definition wlnWriteVer.c:140
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Wln_WriteVerInt()

void Wln_WriteVerInt ( FILE * pFile,
Wln_Ntk_t * p )

Definition at line 140 of file wlnWriteVer.c.

141{
142 int k, j, iObj, iFanin;
143 char Range[100];
144 fprintf( pFile, "module %s ( ", p->pName );
145 fprintf( pFile, "\n " );
146 if ( Wln_NtkCiNum(p) > 0 )
147 {
148 Wln_WriteVerIntVec( pFile, p, &p->vCis, 3 );
149 fprintf( pFile, ",\n " );
150 }
151 if ( Wln_NtkCoNum(p) > 0 )
152 Wln_WriteVerIntVec( pFile, p, &p->vCos, 3 );
153 fprintf( pFile, " );\n" );
154 Wln_NtkForEachObj( p, iObj )
155 {
156 int End = Wln_ObjRangeEnd(p, iObj);
157 int Beg = Wln_ObjRangeBeg(p, iObj);
158 int nDigits = Abc_Base10Log(Abc_AbsInt(End)+1) + Abc_Base10Log(Abc_AbsInt(Beg)+1) + (int)(End < 0) + (int)(Beg < 0);
159 sprintf( Range, "%s[%d:%d]%*s", (!p->fSmtLib && Wln_ObjIsSigned(p, iObj)) ? "signed ":" ", End, Beg, 8-nDigits, "" );
160 fprintf( pFile, " " );
161 if ( Wln_ObjIsCi(p, iObj) )
162 fprintf( pFile, "input " );
163 else if ( Wln_ObjIsCo(p, iObj) )
164 fprintf( pFile, "output " );
165 else
166 fprintf( pFile, " " );
167 if ( Wln_ObjIsCio(p, iObj) )
168 {
169 fprintf( pFile, "wire %s %s ;\n", Range, Wln_ObjName(p, iObj) );
170 if ( Wln_ObjIsCi(p, iObj) )
171 continue;
172 fprintf( pFile, " assign " );
173 fprintf( pFile, "%-16s = %s ;\n", Wln_ObjName(p, iObj), Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
174 continue;
175 }
176 if ( Wln_ObjType(p, iObj) == ABC_OPER_SEL_NMUX || Wln_ObjType(p, iObj) == ABC_OPER_SEL_SEL )
177 fprintf( pFile, "reg %s ", Range );
178 else
179 fprintf( pFile, "wire %s ", Range );
180 if ( Wln_ObjType(p, iObj) == ABC_OPER_TABLE )
181 {
182 // wire [3:0] s4972; table0 s4972_Index(s4971, s4972);
183 fprintf( pFile, "%s ; table%d", Wln_ObjName(p, iObj), Wln_ObjFanin1(p, iObj) );
184 fprintf( pFile, " s%d_Index(%s, ", iObj, Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
185 fprintf( pFile, "%s)", Wln_ObjName(p, iObj) );
186 }
187 else if ( Wln_ObjType(p, iObj) == ABC_OPER_LUT )
188 {
189 // wire [3:0] s4972; LUT lut4972_Index(s4971, s4972);
190 fprintf( pFile, "%s ; LUT", Wln_ObjName(p, iObj) );
191 fprintf( pFile, " lut%d (%s, ", iObj, Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
192 for ( k = 1; k < Wln_ObjFaninNum(p, iObj); k++ )
193 fprintf( pFile, "%s, ", Wln_ObjName(p, Wln_ObjFanin(p, iObj, k)) );
194 fprintf( pFile, "%s)", Wln_ObjName(p, iObj) );
195 }
196 else if ( Wln_ObjIsConst(p, iObj) )
197 fprintf( pFile, "%-16s = %s", Wln_ObjName(p, iObj), Wln_ObjConstString(p, iObj) );
198 else if ( Wln_ObjType(p, iObj) == ABC_OPER_SHIFT_ROTR || Wln_ObjType(p, iObj) == ABC_OPER_SHIFT_ROTL )
199 {
200 // wire [27:0] s4960 = (s57 >> 17) | (s57 << 11);
201 int Num0 = Wln_ObjFanin1(p, iObj);
202 int Num1 = Wln_ObjRange(p, iObj) - Num0;
203 assert( Num0 > 0 && Num0 < Wln_ObjRange(p, iObj) );
204 fprintf( pFile, "%-16s = ", Wln_ObjName(p, iObj) );
205 if ( Wln_ObjType(p, iObj) == ABC_OPER_SHIFT_ROTR )
206 fprintf( pFile, "(%s >> %d) | (%s << %d)", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)), Num0, Wln_ObjName(p, Wln_ObjFanin0(p, iObj)), Num1 );
207 else
208 fprintf( pFile, "(%s << %d) | (%s >> %d)", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)), Num0, Wln_ObjName(p, Wln_ObjFanin0(p, iObj)), Num1 );
209 }
210 else if ( Wln_ObjType(p, iObj) == ABC_OPER_SEL_NMUX )
211 {
212 fprintf( pFile, "%s ;\n", Wln_ObjName(p, iObj) );
213 fprintf( pFile, " " );
214 fprintf( pFile, "always @( " );
215 Wln_ObjForEachFanin( p, iObj, iFanin, k )
216 fprintf( pFile, "%s%s", k ? " or ":"", Wln_ObjName(p, Wln_ObjFanin(p, iObj, k)) );
217 fprintf( pFile, " )\n" );
218 fprintf( pFile, " " );
219 fprintf( pFile, "begin\n" );
220 fprintf( pFile, " " );
221 fprintf( pFile, "case ( %s )\n", Wln_ObjName(p, Wln_ObjFanin(p, iObj, 0)) );
222 Wln_ObjForEachFanin( p, iObj, iFanin, k )
223 {
224 if ( !k ) continue;
225 fprintf( pFile, " " );
226 fprintf( pFile, "%d : %s = ", k-1, Wln_ObjName(p, iObj) );
227 fprintf( pFile, "%s ;\n", Wln_ObjName(p, Wln_ObjFanin(p, iObj, k)) );
228 }
229 fprintf( pFile, " " );
230 fprintf( pFile, "endcase\n" );
231 fprintf( pFile, " " );
232 fprintf( pFile, "end\n" );
233 continue;
234 }
235 else if ( Wln_ObjType(p, iObj) == ABC_OPER_SEL_SEL )
236 {
237 fprintf( pFile, "%s ;\n", Wln_ObjName(p, iObj) );
238 fprintf( pFile, " " );
239 fprintf( pFile, "always @( " );
240 Wln_ObjForEachFanin( p, iObj, iFanin, k )
241 fprintf( pFile, "%s%s", k ? " or ":"", Wln_ObjName(p, Wln_ObjFanin(p, iObj, k)) );
242 fprintf( pFile, " )\n" );
243 fprintf( pFile, " " );
244 fprintf( pFile, "begin\n" );
245 fprintf( pFile, " " );
246 fprintf( pFile, "case ( %s )\n", Wln_ObjName(p, Wln_ObjFanin(p, iObj, 0)) );
247 Wln_ObjForEachFanin( p, iObj, iFanin, k )
248 {
249 if ( !k ) continue;
250 fprintf( pFile, " " );
251 fprintf( pFile, "%d\'b", Wln_ObjFaninNum(p, iObj)-1 );
252 for ( j = Wln_ObjFaninNum(p, iObj)-1; j > 0; j-- )
253 fprintf( pFile, "%d", (int)(j==k) );
254 fprintf( pFile, " : %s = ", Wln_ObjName(p, iObj) );
255 fprintf( pFile, "%s ;\n", Wln_ObjName(p, Wln_ObjFanin(p, iObj, k)) );
256 }
257 fprintf( pFile, " " );
258 fprintf( pFile, "default" );
259 fprintf( pFile, " : %s = ", Wln_ObjName(p, iObj) );
260 fprintf( pFile, "%d\'b", Wln_ObjRange(p, iObj) );
261 for ( j = Wln_ObjRange(p, iObj)-1; j >= 0; j-- )
262 fprintf( pFile, "%d", 0 );
263 fprintf( pFile, " ;\n" );
264 fprintf( pFile, " " );
265 fprintf( pFile, "endcase\n" );
266 fprintf( pFile, " " );
267 fprintf( pFile, "end\n" );
268 continue;
269 }
270 else if ( Wln_ObjType(p, iObj) == ABC_OPER_SEL_DEC )
271 {
272 int nRange = Wln_ObjRange(p, Wln_ObjFanin0(p, iObj));
273 assert( (1 << nRange) == Wln_ObjRange(p, iObj) );
274 fprintf( pFile, "%s ;\n", Wln_ObjName(p, iObj) );
275 for ( k = 0; k < Wln_ObjRange(p, iObj); k++ )
276 {
277 fprintf( pFile, " " );
278 fprintf( pFile, "wire " );
279 fprintf( pFile, "%s_", Wln_ObjName(p, iObj) );
280 for ( j = 0; j < nRange; j++ )
281 fprintf( pFile, "%d", (k >> (nRange-1-j)) & 1 );
282 fprintf( pFile, " = " );
283 for ( j = 0; j < nRange; j++ )
284 fprintf( pFile, "%s%s%s[%d]",
285 j ? " & ":"", ((k >> (nRange-1-j)) & 1) ? " ":"~",
286 Wln_ObjName(p, Wln_ObjFanin(p, iObj, 0)), nRange-1-j );
287 fprintf( pFile, " ;\n" );
288 }
289 fprintf( pFile, " " );
290 fprintf( pFile, "assign %s = { ", Wln_ObjName(p, iObj) );
291 for ( k = Wln_ObjRange(p, iObj)-1; k >= 0; k-- )
292 {
293 fprintf( pFile, "%s%s_", k < Wln_ObjRange(p, iObj)-1 ? ", ":"", Wln_ObjName(p, iObj) );
294 for ( j = 0; j < nRange; j++ )
295 fprintf( pFile, "%d", (k >> (nRange-1-j)) & 1 );
296 }
297 fprintf( pFile, " } ;\n" );
298 continue;
299 }
300 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ARI_ADDSUB )
301 {
302 // out = mode ? a+b+cin : a-b-cin
303 fprintf( pFile, "%s ;\n", Wln_ObjName(p, iObj) );
304 fprintf( pFile, " " );
305 fprintf( pFile, "assign " );
306 fprintf( pFile, "%s = %s ? %s + %s + %s : %s - %s - %s ;\n",
307 Wln_ObjName(p, iObj), Wln_ObjName(p, Wln_ObjFanin0(p, iObj)),
308 Wln_ObjName(p, Wln_ObjFanin2(p, iObj)), Wln_ObjName(p, Wln_ObjFanin(p, iObj,3)), Wln_ObjName(p, Wln_ObjFanin1(p, iObj)),
309 Wln_ObjName(p, Wln_ObjFanin2(p, iObj)), Wln_ObjName(p, Wln_ObjFanin(p, iObj,3)), Wln_ObjName(p, Wln_ObjFanin1(p, iObj))
310 );
311 continue;
312 }
313 else if ( Wln_ObjType(p, iObj) == ABC_OPER_RAMR || Wln_ObjType(p, iObj) == ABC_OPER_RAMW )
314 {
315 if ( 1 )
316 {
317 fprintf( pFile, "%s ;\n", Wln_ObjName(p, iObj) );
318 fprintf( pFile, " " );
319 fprintf( pFile, "%s (", Wln_ObjType(p, iObj) == ABC_OPER_RAMR ? "ABC_READ" : "ABC_WRITE" );
320 Wln_ObjForEachFanin( p, iObj, iFanin, k )
321 fprintf( pFile, " .%s(%s),", k==0 ? "mem_in" : (k==1 ? "addr": "data"), Wln_ObjName(p, iFanin) );
322 fprintf( pFile, " .%s(%s) ) ;\n", Wln_ObjType(p, iObj) == ABC_OPER_RAMR ? "data" : "mem_out", Wln_ObjName(p, iObj) );
323 continue;
324 }
325 else
326 {
327 int nBitsMem = Wln_ObjRange(p, Wln_ObjFanin(p, iObj, 0) );
328 //int nBitsAddr = Wln_ObjRange(p, Wln_ObjFanin(p, iObj, 1) );
329 int nBitsDat = Wln_ObjType(p, iObj) == ABC_OPER_RAMR ? Wln_ObjRange(p, iObj) : Wln_ObjRange(p, Wln_ObjFanin(p, iObj, 2));
330 int Depth = nBitsMem / nBitsDat;
331 assert( nBitsMem % nBitsDat == 0 );
332 fprintf( pFile, "%s ;\n", Wln_ObjName(p, iObj) );
333 fprintf( pFile, " " );
334 fprintf( pFile, "%s_%d (", Wln_ObjType(p, iObj) == ABC_OPER_RAMR ? "CPL_MEM_READ" : "CPL_MEM_WRITE", Depth );
335 Wln_ObjForEachFanin( p, iObj, iFanin, k )
336 fprintf( pFile, " .%s(%s),", k==0 ? "mem_data_in" : (k==1 ? "addr_in": "data_in"), Wln_ObjName(p, iFanin) );
337 fprintf( pFile, " .%s(%s) ) ;\n", "data_out", Wln_ObjName(p, iObj) );
338 continue;
339 }
340 }
341 else if ( Wln_ObjType(p, iObj) == ABC_OPER_DFFRSE )
342 {
343 fprintf( pFile, "%s ;\n", Wln_ObjName(p, iObj) );
344 continue;
345 }
346 else
347 {
348 fprintf( pFile, "%-16s = ", Wln_ObjName(p, iObj) );
349 if ( Wln_ObjType(p, iObj) == ABC_OPER_BIT_BUF )
350 fprintf( pFile, "%s", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
351 else if ( Wln_ObjType(p, iObj) == ABC_OPER_BIT_MUX )
352 {
353 fprintf( pFile, "%s ? ", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
354 fprintf( pFile, "%s : ", Wln_ObjName(p, Wln_ObjFanin1(p, iObj)) );
355 fprintf( pFile, "%s", Wln_ObjName(p, Wln_ObjFanin2(p, iObj)) );
356 }
357 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ARI_MIN )
358 fprintf( pFile, "-%s", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
359 else if ( Wln_ObjType(p, iObj) == ABC_OPER_BIT_INV )
360 fprintf( pFile, "~%s", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
361 else if ( Wln_ObjType(p, iObj) == ABC_OPER_LOGIC_NOT )
362 fprintf( pFile, "!%s", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
363 else if ( Wln_ObjType(p, iObj) == ABC_OPER_RED_AND )
364 fprintf( pFile, "&%s", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
365 else if ( Wln_ObjType(p, iObj) == ABC_OPER_RED_OR )
366 fprintf( pFile, "|%s", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
367 else if ( Wln_ObjType(p, iObj) == ABC_OPER_RED_XOR )
368 fprintf( pFile, "^%s", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
369 else if ( Wln_ObjType(p, iObj) == ABC_OPER_RED_NAND )
370 fprintf( pFile, "~&%s", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
371 else if ( Wln_ObjType(p, iObj) == ABC_OPER_RED_NOR )
372 fprintf( pFile, "~|%s", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
373 else if ( Wln_ObjType(p, iObj) == ABC_OPER_RED_NXOR )
374 fprintf( pFile, "~^%s", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
375 else if ( Wln_ObjType(p, iObj) == ABC_OPER_SLICE )
376 fprintf( pFile, "%s [%d:%d]", Wln_ObjName(p, Wln_ObjFanin0(p, iObj)), Wln_ObjRangeEnd(p, iObj), Wln_ObjRangeBeg(p, iObj) );
377 else if ( Wln_ObjType(p, iObj) == ABC_OPER_SIGNEXT )
378 fprintf( pFile, "{ {%d{%s[%d]}}, %s }", Wln_ObjRange(p, iObj) - Wln_ObjRange(p, Wln_ObjFanin0(p, iObj)), Wln_ObjName(p, Wln_ObjFanin0(p, iObj)), Wln_ObjRange(p, Wln_ObjFanin0(p, iObj)) - 1, Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
379 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ZEROPAD )
380 fprintf( pFile, "{ {%d{1\'b0}}, %s }", Wln_ObjRange(p, iObj) - Wln_ObjRange(p, Wln_ObjFanin0(p, iObj)), Wln_ObjName(p, Wln_ObjFanin0(p, iObj)) );
381 else if ( Wln_ObjType(p, iObj) == ABC_OPER_CONCAT )
382 {
383 fprintf( pFile, "{" );
384 Wln_ObjForEachFanin( p, iObj, iFanin, k )
385 fprintf( pFile, " %s%s", Wln_ObjName(p, Wln_ObjFanin(p, iObj, k)), k == Wln_ObjFaninNum(p, iObj)-1 ? "":"," );
386 fprintf( pFile, " }" );
387 }
388 else
389 {
390 fprintf( pFile, "%s ", Wln_ObjName(p, Wln_ObjFanin(p, iObj, 0)) );
391 if ( Wln_ObjType(p, iObj) == ABC_OPER_SHIFT_R )
392 fprintf( pFile, ">>" );
393 else if ( Wln_ObjType(p, iObj) == ABC_OPER_SHIFT_RA )
394 fprintf( pFile, ">>>" );
395 else if ( Wln_ObjType(p, iObj) == ABC_OPER_SHIFT_L )
396 fprintf( pFile, "<<" );
397 else if ( Wln_ObjType(p, iObj) == ABC_OPER_SHIFT_LA )
398 fprintf( pFile, "<<<" );
399 else if ( Wln_ObjType(p, iObj) == ABC_OPER_BIT_AND )
400 fprintf( pFile, "&" );
401 else if ( Wln_ObjType(p, iObj) == ABC_OPER_BIT_OR )
402 fprintf( pFile, "|" );
403 else if ( Wln_ObjType(p, iObj) == ABC_OPER_BIT_XOR )
404 fprintf( pFile, "^" );
405 else if ( Wln_ObjType(p, iObj) == ABC_OPER_BIT_NAND )
406 fprintf( pFile, "~&" );
407 else if ( Wln_ObjType(p, iObj) == ABC_OPER_BIT_NOR )
408 fprintf( pFile, "~|" );
409 else if ( Wln_ObjType(p, iObj) == ABC_OPER_BIT_NXOR )
410 fprintf( pFile, "~^" );
411 else if ( Wln_ObjType(p, iObj) == ABC_OPER_LOGIC_IMPL )
412 fprintf( pFile, "=>" );
413 else if ( Wln_ObjType(p, iObj) == ABC_OPER_LOGIC_AND )
414 fprintf( pFile, "&&" );
415 else if ( Wln_ObjType(p, iObj) == ABC_OPER_LOGIC_OR )
416 fprintf( pFile, "||" );
417 else if ( Wln_ObjType(p, iObj) == ABC_OPER_LOGIC_XOR )
418 fprintf( pFile, "^^" );
419 else if ( Wln_ObjType(p, iObj) == ABC_OPER_COMP_EQU )
420 fprintf( pFile, "==" );
421 else if ( Wln_ObjType(p, iObj) == ABC_OPER_COMP_NOTEQU )
422 fprintf( pFile, "!=" );
423 else if ( Wln_ObjType(p, iObj) == ABC_OPER_COMP_LESS )
424 fprintf( pFile, "<" );
425 else if ( Wln_ObjType(p, iObj) == ABC_OPER_COMP_MORE )
426 fprintf( pFile, ">" );
427 else if ( Wln_ObjType(p, iObj) == ABC_OPER_COMP_LESSEQU )
428 fprintf( pFile, "<=" );
429 else if ( Wln_ObjType(p, iObj) == ABC_OPER_COMP_MOREEQU )
430 fprintf( pFile, ">=" );
431 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ARI_ADD )
432 fprintf( pFile, "+" );
433 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ARI_SUB )
434 fprintf( pFile, "-" );
435 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ARI_MUL )
436 fprintf( pFile, "*" );
437 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ARI_DIV )
438 fprintf( pFile, "/" );
439 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ARI_REM )
440 fprintf( pFile, "%%" );
441 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ARI_MOD )
442 fprintf( pFile, "%%" );
443 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ARI_POW )
444 fprintf( pFile, "**" );
445 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ARI_SQRT )
446 fprintf( pFile, "@" );
447 else if ( Wln_ObjType(p, iObj) == ABC_OPER_ARI_SQUARE )
448 fprintf( pFile, "#" );
449 else
450 {
451 //assert( 0 );
452 printf( "Failed to write node \"%s\" with unknown operator type (%d).\n", Wln_ObjName(p, iObj), Wln_ObjType(p, iObj) );
453 fprintf( pFile, "???\n" );
454 continue;
455 }
456 fprintf( pFile, " %s", Wln_ObjName(p, Wln_ObjFanin(p, iObj, 1)) );
457 if ( Wln_ObjFaninNum(p, iObj) == 3 && Wln_ObjType(p, iObj) == ABC_OPER_ARI_ADD )
458 fprintf( pFile, " + %s", Wln_ObjName(p, Wln_ObjFanin(p, iObj, 2)) );
459 }
460 }
461 fprintf( pFile, " ;%s\n", (p->fSmtLib && Wln_ObjIsSigned(p, iObj)) ? " // signed SMT-LIB operator" : "" );
462 }
463 iFanin = 0;
464 // write DFFs in the end
465 fprintf( pFile, "\n" );
466 Wln_NtkForEachFf( p, iObj, j )
467 {
468 char * pInNames[8] = {"d", "clk", "reset", "set", "enable", "async", "sre", "init"};
469 fprintf( pFile, " " );
470 fprintf( pFile, "%s (", "ABC_DFFRSE" );
471 Wln_ObjForEachFanin( p, iObj, iFanin, k )
472 if ( iFanin ) fprintf( pFile, " .%s(%s),", pInNames[k], Wln_ObjName(p, iFanin) );
473 fprintf( pFile, " .%s(%s) ) ;\n", "q", Wln_ObjName(p, iObj) );
474 }
475 fprintf( pFile, "\n" );
476 fprintf( pFile, "endmodule\n\n" );
477}
ABC_OPER_ZEROPAD
@ ABC_OPER_ZEROPAD
Definition abcOper.h:148
ABC_OPER_COMP_LESS
@ ABC_OPER_COMP_LESS
Definition abcOper.h:112
ABC_OPER_LOGIC_IMPL
@ ABC_OPER_LOGIC_IMPL
Definition abcOper.h:151
ABC_OPER_LUT
@ ABC_OPER_LUT
Definition abcOper.h:127
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_RED_NAND
@ ABC_OPER_RED_NAND
Definition abcOper.h:77
ABC_OPER_DFFRSE
@ ABC_OPER_DFFRSE
Definition abcOper.h:143
ABC_OPER_SIGNEXT
@ ABC_OPER_SIGNEXT
Definition abcOper.h:149
ABC_OPER_SEL_NMUX
@ ABC_OPER_SEL_NMUX
Definition abcOper.h:91
ABC_OPER_BIT_NAND
@ ABC_OPER_BIT_NAND
Definition abcOper.h:58
ABC_OPER_SHIFT_RA
@ ABC_OPER_SHIFT_RA
Definition abcOper.h:122
ABC_OPER_RAMW
@ ABC_OPER_RAMW
Definition abcOper.h:134
ABC_OPER_ARI_REM
@ ABC_OPER_ARI_REM
Definition abcOper.h:105
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_SHIFT_ROTL
@ ABC_OPER_SHIFT_ROTL
Definition abcOper.h:123
ABC_OPER_RED_NOR
@ ABC_OPER_RED_NOR
Definition abcOper.h:79
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_ARI_SQUARE
@ ABC_OPER_ARI_SQUARE
Definition abcOper.h:152
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_CONCAT
@ ABC_OPER_CONCAT
Definition abcOper.h:147
ABC_OPER_BIT_MUX
@ ABC_OPER_BIT_MUX
Definition abcOper.h:65
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_RAMR
@ ABC_OPER_RAMR
Definition abcOper.h:133
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_ARI_SQRT
@ ABC_OPER_ARI_SQRT
Definition abcOper.h:108
ABC_OPER_BIT_AND
@ ABC_OPER_BIT_AND
Definition abcOper.h:57
ABC_OPER_SEL_DEC
@ ABC_OPER_SEL_DEC
Definition abcOper.h:96
ABC_OPER_SLICE
@ ABC_OPER_SLICE
Definition abcOper.h:146
ABC_OPER_ARI_ADDSUB
@ ABC_OPER_ARI_ADDSUB
Definition abcOper.h:155
ABC_OPER_COMP_NOTEQU
@ ABC_OPER_COMP_NOTEQU
Definition abcOper.h:117
ABC_OPER_BIT_NOR
@ ABC_OPER_BIT_NOR
Definition abcOper.h:60
ABC_OPER_SHIFT_ROTR
@ ABC_OPER_SHIFT_ROTR
Definition abcOper.h:124
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_LOGIC_XOR
@ ABC_OPER_LOGIC_XOR
Definition abcOper.h:88
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
sprintf
char * sprintf()
Wln_WriteVerIntVec
void Wln_WriteVerIntVec(FILE *pFile, Wln_Ntk_t *p, Vec_Int_t *vVec, int Start)
Definition wlnWriteVer.c:117
Wln_NtkForEachFf
#define Wln_NtkForEachFf(p, iFf, i)
Definition wln.h:202
Wln_ObjForEachFanin
#define Wln_ObjForEachFanin(p, iObj, iFanin, i)
Definition wln.h:205
Wln_ObjConstString
char * Wln_ObjConstString(Wln_Ntk_t *p, int iObj)
Definition wlnObj.c:53
Wln_ObjName
char * Wln_ObjName(Wln_Ntk_t *p, int iObj)
DECLARATIONS ///.
Definition wlnObj.c:45
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Wln_WriteVerIntVec()

void Wln_WriteVerIntVec ( FILE * pFile,
Wln_Ntk_t * p,
Vec_Int_t * vVec,
int Start )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 117 of file wlnWriteVer.c.

118{
119 char * pName;
120 int LineLength = Start;
121 int NameCounter = 0;
122 int AddedLength, i, iObj;
123 Vec_IntForEachEntry( vVec, iObj, i )
124 {
125 pName = Wln_ObjName( p, iObj );
126 // get the line length after this name is written
127 AddedLength = strlen(pName) + 2;
128 if ( NameCounter && LineLength + AddedLength + 3 > 70 )
129 { // write the line extender
130 fprintf( pFile, "\n " );
131 // reset the line length
132 LineLength = Start;
133 NameCounter = 0;
134 }
135 fprintf( pFile, " %s%s", pName, (i==Vec_IntSize(vVec)-1)? "" : "," );
136 LineLength += AddedLength;
137 NameCounter++;
138 }
139}
strlen
int strlen()
Vec_IntForEachEntry
#define Vec_IntForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition vecInt.h:54
Here is the call graph for this function:
Here is the caller graph for this function: