ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
ioWriteEdgelist.c
Go to the documentation of this file.
1
20
21#include "ioAbc.h"
22#include "base/main/main.h"
23#include "map/mio/mio.h"
24#include "bool/kit/kit.h"
25#include "map/if/if.h"
26
27ABC_NAMESPACE_IMPL_START
28
29
33
34static void Io_NtkEdgelistWrite( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches, int fBb2Wb, int fSeq , int fName);
35static void Io_NtkEdgelistWriteOne( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches, int fBb2Wb, int fSeq , int fName);
36static void Io_NtkEdgelistWritePis( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches );
37static void Io_NtkEdgelistWritePos( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches );
38static void Io_NtkEdgelistWriteSubckt( FILE * pFile, Abc_Obj_t * pNode );
39static void Io_NtkEdgelistWriteAsserts( FILE * pFile, Abc_Ntk_t * pNtk );
40static void Io_NtkEdgelistWriteNodeFanins( FILE * pFile, Abc_Obj_t * pNode, int fName);
41static int Io_NtkEdgelistWriteNode( FILE * pFile, Abc_Obj_t * pNode, int Length, int fName);
42static void Io_NtkEdgelistWriteLatch( FILE * pFile, Abc_Obj_t * pLatch , int fName);
43
47
59void Io_WriteEdgelist( Abc_Ntk_t * pNtk, char * FileName, int fWriteLatches, int fBb2Wb, int fSeq, int fName)
60{
61 FILE * pFile; int i;
62 // start writing the file
63 pFile = fopen( FileName, "w" );
64 if ( pFile == NULL )
65 {
66 fprintf( stdout, "Io_WriteEdgelist(): Cannot open the output file.\n" );
67 return;
68 }
69 fprintf( stdout, "WriteEdgelist (Verilog-to-PyG @ https://github.com/ycunxi/Verilog-to-PyG) starts writing to %s.\n", FileName );
70 fprintf( pFile, "# Benchmark Edgelist Dumping (beta) \"%s\" written by ABC on %s (more at https://github.com/ycunxi/Verilog-to-PyG)\n", pNtk->pName, Extra_TimeStamp() );
71 // write the master network
72 Io_NtkEdgelistWrite( pFile, pNtk, fWriteLatches, fBb2Wb, fSeq , fName);
73 // make sure there is no logic hierarchy
74// assert( Abc_NtkWhiteboxNum(pNtk) == 0 );
75 // write the hierarchy if present
76 if ( Abc_NtkBlackboxNum(pNtk) > 0 || Abc_NtkWhiteboxNum(pNtk) > 0 )
77 {
78 Abc_Ntk_t * pNtkTemp;
79 Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pNtkTemp, i )
80 {
81 if ( pNtkTemp == pNtk )
82 continue;
83 fprintf( pFile, "\n\n" );
84 Io_NtkEdgelistWrite( pFile, pNtkTemp, fWriteLatches, fBb2Wb, fSeq, fName);
85 }
86 }
87 fclose( pFile );
88}
89
101void Io_NtkEdgelistWrite_int( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches, int fBb2Wb, int fSeq , int fName)
102{
103 Abc_Ntk_t * pExdc;
104 assert( Abc_NtkIsNetlist(pNtk) );
105 // write the model name
106 // fprintf( pFile, ".model %s\n", Abc_NtkName(pNtk) );
107 // write the network
108 Io_NtkEdgelistWriteOne( pFile, pNtk, fWriteLatches, fBb2Wb, fSeq , fName);
109 // write EXDC network if it exists
110 pExdc = Abc_NtkExdc( pNtk );
111 if ( pExdc )
112 {
113 fprintf( pFile, "\n" );
114 fprintf( pFile, ".exdc\n" );
115 Io_NtkEdgelistWriteOne( pFile, pExdc, fWriteLatches, fBb2Wb, fSeq , fName);
116 }
117 // finalize the file
118 //fprintf( pFile, ".end\n" );
119}
120void Io_NtkEdgelistWrite( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches, int fBb2Wb, int fSeq , int fName)
121{
122 if( Abc_NtkIsNetlist(pNtk) )
123 Io_NtkEdgelistWrite_int( pFile, pNtk, fWriteLatches, fBb2Wb, fSeq , fName );
124 else
125 {
126 Abc_Ntk_t * pNtkTemp = Abc_NtkToNetlist(pNtk);
127 Io_NtkEdgelistWrite_int( pFile, pNtkTemp, fWriteLatches, fBb2Wb, fSeq , fName );
128 Abc_NtkDelete( pNtkTemp );
129 }
130}
142void Io_NtkEdgelistWriteConvertedBox( FILE * pFile, Abc_Ntk_t * pNtk, int fSeq )
143{
144 Abc_Obj_t * pObj;
145 int i, v;
146 if ( fSeq )
147 {
148 fprintf( pFile, ".attrib white box seq\n" );
149 }
150 else
151 {
152 fprintf( pFile, ".attrib white box comb\n" );
153 fprintf( pFile, ".delay 1\n" );
154 }
155 Abc_NtkForEachPo( pNtk, pObj, i )
156 {
157 // write the .names line
158 //fprintf( pFile, ".names" );
159 Io_NtkEdgelistWritePis( pFile, pNtk, 1 );
160 if ( fSeq )
161 fprintf( pFile, " %s_in\n", Abc_ObjName(Abc_ObjFanin0(pObj)) );
162 else
163 fprintf( pFile, " %s\n", Abc_ObjName(Abc_ObjFanin0(pObj)) );
164 for ( v = 0; v < Abc_NtkPiNum(pNtk); v++ )
165 fprintf( pFile, "1" );
166 fprintf( pFile, " 1\n" );
167 if ( fSeq )
168 fprintf( pFile, " %s_in %s 1\n", Abc_ObjName(Abc_ObjFanin0(pObj)), Abc_ObjName(Abc_ObjFanin0(pObj)) );
169 //fprintf( pFile, ".latch %s_in %s 1\n", Abc_ObjName(Abc_ObjFanin0(pObj)), Abc_ObjName(Abc_ObjFanin0(pObj)) );
170 }
171}
172
184char * Io_NtkWriteEdgelistDeriveSop( Mem_Flex_t * pMem, word uTruth, int nVars, Vec_Int_t * vCover )
185{
186 char * pSop;
187 int RetValue = Kit_TruthIsop( (unsigned *)&uTruth, nVars, vCover, 1 );
188 assert( RetValue == 0 || RetValue == 1 );
189 // check the case of constant cover
190 if ( Vec_IntSize(vCover) == 0 || (Vec_IntSize(vCover) == 1 && Vec_IntEntry(vCover,0) == 0) )
191 {
192 char * pStr0 = " 0\n", * pStr1 = " 1\n";
193 assert( RetValue == 0 );
194 return Vec_IntSize(vCover) == 0 ? pStr0 : pStr1;
195 }
196 // derive the AIG for that tree
197 pSop = Abc_SopCreateFromIsop( pMem, nVars, vCover );
198 if ( RetValue )
199 Abc_SopComplement( pSop );
200 return pSop;
201}
202
203
215void Io_NtkEdgelistWriteOne( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches, int fBb2Wb, int fSeq , int fName)
216{
217 ProgressBar * pProgress;
218 Abc_Obj_t * pNode, * pLatch;
219 int i, Length;
220 // write the PIs
221 Io_NtkEdgelistWritePis( pFile, pNtk, fWriteLatches );
222 // write the blackbox
223 if ( Abc_NtkHasBlackbox( pNtk ) )
224 {
225 if ( fBb2Wb )
226 Io_NtkEdgelistWriteConvertedBox( pFile, pNtk, fSeq );
227 else
228 fprintf( pFile, ".blackbox\n" );
229 return;
230 }
231
232 // write the timing info
233 Io_WriteTimingInfo( pFile, pNtk );
234
235 // write the latches
236 if ( fWriteLatches && !Abc_NtkIsComb(pNtk) )
237 {
238 //fprintf( pFile, "\n" );
239 Abc_NtkForEachLatch( pNtk, pLatch, i )
240 Io_NtkEdgelistWriteLatch( pFile, pLatch , fName);
241 //fprintf( pFile, "\n" );
242 }
243
244 // write the subcircuits
245// assert( Abc_NtkWhiteboxNum(pNtk) == 0 );
246 if ( Abc_NtkBlackboxNum(pNtk) > 0 || Abc_NtkWhiteboxNum(pNtk) > 0 )
247 {
248 fprintf( pFile, "\n" );
249 Abc_NtkForEachBlackbox( pNtk, pNode, i )
250 Io_NtkEdgelistWriteSubckt( pFile, pNode );
251 fprintf( pFile, "\n" );
252 Abc_NtkForEachWhitebox( pNtk, pNode, i )
253 Io_NtkEdgelistWriteSubckt( pFile, pNode );
254 fprintf( pFile, "\n" );
255 }
256
257 // write each internal node
258 Length = Abc_NtkHasMapping(pNtk)? Mio_LibraryReadGateNameMax((Mio_Library_t *)pNtk->pManFunc) : 0;
259 pProgress = Extra_ProgressBarStart( stdout, Abc_NtkObjNumMax(pNtk) );
260 Abc_NtkForEachNode( pNtk, pNode, i )
261 {
262 Extra_ProgressBarUpdate( pProgress, i, NULL );
263 if ( Io_NtkEdgelistWriteNode( pFile, pNode, Length, fName) ) // skip the next node
264 i++;
265 }
266 // write the POs
267 Io_NtkEdgelistWritePos( pFile, pNtk, fWriteLatches );
268
269 Extra_ProgressBarStop( pProgress );
270}
271
272
284void Io_NtkEdgelistWritePis( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches )
285{
286 Abc_Obj_t * pTerm, * pNet;
287 int LineLength;
288 int AddedLength;
289 int NameCounter;
290 int i;
291
292 LineLength = 7;
293 NameCounter = 0;
294
295 if ( fWriteLatches )
296 {
297 Abc_NtkForEachPi( pNtk, pTerm, i )
298 {
299 pNet = Abc_ObjFanout0(pTerm);
300 // get the line length after this name is written
301 AddedLength = strlen(Abc_ObjName(pNet)) + 1;
302 if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
303 { // write the line extender
304 // fprintf( pFile, " \\\n" );
305 // reset the line length
306 LineLength = 0;
307 NameCounter = 0;
308 }
309 fprintf( pFile, "%d %d Pi 00\n", Abc_ObjId(pTerm), Abc_ObjId(pNet) );
310 //fprintf( pFile, "%s %s Pi 00\n", Abc_ObjName(pTerm), Abc_ObjName(pNet) );
311 //fprintf( pFile, " %s", Abc_ObjName(pNet) );
312 LineLength += AddedLength;
313 NameCounter++;
314 }
315 }
316 else
317 {
318 Abc_NtkForEachCi( pNtk, pTerm, i )
319 {
320 pNet = Abc_ObjFanout0(pTerm);
321 // get the line length after this name is written
322 AddedLength = strlen(Abc_ObjName(pNet)) + 1;
323 if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
324 { // write the line extender
325 // fprintf( pFile, " \\\n" );
326 // reset the line length
327 LineLength = 0;
328 NameCounter = 0;
329 }
330 fprintf( pFile, "%d %d Pi 00\n", Abc_ObjId(pTerm), Abc_ObjId(pNet) );
331 //fprintf( pFile, "%s %s Pi\n", Abc_ObjName(pTerm), Abc_ObjName(pNet) );
332 //fprintf( pFile, " %s", Abc_ObjName(pNet) );
333 LineLength += AddedLength;
334 NameCounter++;
335 }
336 }
337}
338
350void Io_NtkEdgelistWritePos( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches )
351{
352 Abc_Obj_t * pTerm, * pNet;
353 int LineLength;
354 int AddedLength;
355 int NameCounter;
356 int i;
357
358 LineLength = 8;
359 NameCounter = 0;
360
361 if ( fWriteLatches )
362 {
363 Abc_NtkForEachPo( pNtk, pTerm, i )
364 {
365 pNet = Abc_ObjFanin0(pTerm);
366 // get the line length after this name is written
367 AddedLength = strlen(Abc_ObjName(pNet)) + 1;
368 if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
369 { // write the line extender
370 //fprintf( pFile, " \\\n" );
371 // reset the line length
372 LineLength = 0;
373 NameCounter = 0;
374 }
375 fprintf( pFile, "%d %d Po 00\n",Abc_ObjId(pNet), Abc_ObjId(pTerm) );
376 //fprintf( pFile, "%s %s Po 00\n", Abc_ObjName(pTerm), Abc_ObjName(pNet) );
377 LineLength += AddedLength;
378 NameCounter++;
379 }
380 }
381 else
382 {
383 Abc_NtkForEachCo( pNtk, pTerm, i )
384 {
385 pNet = Abc_ObjFanin0(pTerm);
386 // get the line length after this name is written
387 AddedLength = strlen(Abc_ObjName(pNet)) + 1;
388 if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
389 { // write the line extender
390 // fprintf( pFile, " \\\n" );
391 // reset the line length
392 LineLength = 0;
393 NameCounter = 0;
394 }
395 //fprintf( pFile, " %s", Abc_ObjName(pNet) );
396 fprintf( pFile, "%d %d Po 00\n",Abc_ObjId(pNet), Abc_ObjId(pTerm) );
397 //fprintf( pFile, "%s %s Po 00\n", Abc_ObjName(pTerm), Abc_ObjName(pNet) );
398 LineLength += AddedLength;
399 NameCounter++;
400 }
401 }
402}
403
415void Io_NtkEdgelistWriteSubckt( FILE * pFile, Abc_Obj_t * pNode )
416{
417 Abc_Ntk_t * pModel = (Abc_Ntk_t *)pNode->pData;
418 Abc_Obj_t * pTerm;
419 int i;
420 // write the subcircuit
421// fprintf( pFile, ".subckt %s %s", Abc_NtkName(pModel), Abc_ObjName(pNode) );
422 fprintf( pFile, ".subckt %s", Abc_NtkName(pModel) );
423 // write pairs of the formal=actual names
424 Abc_NtkForEachPi( pModel, pTerm, i )
425 {
426 fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanout0(pTerm)) );
427 pTerm = Abc_ObjFanin( pNode, i );
428 fprintf( pFile, "=%s", Abc_ObjName(Abc_ObjFanin0(pTerm)) );
429 }
430 Abc_NtkForEachPo( pModel, pTerm, i )
431 {
432 fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin0(pTerm)) );
433 pTerm = Abc_ObjFanout( pNode, i );
434 fprintf( pFile, "=%s", Abc_ObjName(Abc_ObjFanout0(pTerm)) );
435 }
436 fprintf( pFile, "\n" );
437}
438
450void Io_NtkEdgelistWriteLatch( FILE * pFile, Abc_Obj_t * pLatch , int fName)
451{
452 Abc_Obj_t * pNetLi, * pNetLo;
453 int Reset;
454 pNetLi = Abc_ObjFanin0( Abc_ObjFanin0(pLatch) );
455 pNetLo = Abc_ObjFanout0( Abc_ObjFanout0(pLatch) );
456 Reset = (int)(ABC_PTRUINT_T)Abc_ObjData( pLatch );
457 // write the latch line
458 // fprintf( pFile, ".latch" );
459 if (fName){
460 fprintf( pFile, "%s", Abc_ObjName(pNetLi) );
461 fprintf( pFile, " %s", Abc_ObjName(pNetLo) );
462 }
463 else{
464 fprintf( pFile, "%d", Abc_ObjId(pNetLi) );
465 fprintf( pFile, " %d", Abc_ObjId(pNetLo) );
466 }
467
468 fprintf( pFile, " REG %d\n", Reset-1 );
469 //fprintf( pFile, " {type:\"REG\" reset=\"%d\"}\n", Reset-1 );
470}
471
472
484void Io_NtkEdgelistWriteNodeFanins( FILE * pFile, Abc_Obj_t * pNode , int fName)
485{
486 Abc_Obj_t * pNet;
487 int LineLength;
488 int AddedLength;
489 int NameCounter;
490 char * pName;
491 int i;
492
493 LineLength = 6;
494 NameCounter = 0;
495 Abc_ObjForEachFanin( pNode, pNet, i )
496 {
497 char * temp = NULL;
498 int len;
499 // get the fanin name
500 pName = Abc_ObjName(pNet);
501 // get the line length after the fanin name is written
502 AddedLength = strlen(pName) + 1;
503 if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
504 { // write the line extender
505 fprintf( pFile, " \\\n" );
506 // reset the line length
507 LineLength = 0;
508 NameCounter = 0;
509 }
510 if (fName){
511 fprintf( pFile, "%s", Abc_ObjName(pNet) );
512 }
513 else{
514 fprintf( pFile, "%d", Abc_ObjId(pNet) );
515 }
516 LineLength += AddedLength;
517 NameCounter++;
518
519 // get the output name
520 pName = Abc_ObjName(Abc_ObjFanout0(pNode));
521 // get the line length after the output name is written
522 AddedLength = strlen(pName) + 1;
523 if ( NameCounter && LineLength + AddedLength > 75 )
524 { // write the line extender
525 fprintf( pFile, " \\\n" );
526 // reset the line length
527 LineLength = 0;
528 NameCounter = 0;
529 }
530 //char temp[sizeof((char*)Abc_ObjData(pNode))];
531 //strcpy(temp, (char*)Abc_ObjData(pNode));
532 temp = Abc_UtilStrsav((char*)Abc_ObjData(pNode));
533 len = strlen(temp);
534 if (len > 0) {
535 temp[len - 1] = '\0';
536 temp[len - 2] = '\0';
537 temp[len - 3] = '\0';
538 }
539 if (fName){
540 if (Abc_ObjIsCi(pNode))
541 fprintf( pFile, " %s Pi AIG %s\n", Abc_ObjName(Abc_ObjFanout0(pNode)), temp);
542 else if (Abc_ObjIsCo(Abc_ObjFanout0(pNode)))
543 fprintf( pFile, " %s AIG Po %s\n", Abc_ObjName(Abc_ObjFanout0(pNode)), temp);
544 else
545 fprintf( pFile, " %s AIG %s\n", Abc_ObjName(Abc_ObjFanout0(pNode)), temp);
546
547 }
548 else{
549 if (Abc_ObjIsCi(pNode))
550 fprintf( pFile, " %d Pi AIG %s\n", Abc_ObjId(Abc_ObjFanout0(pNode)), temp);
551 else if (Abc_ObjIsCo(Abc_ObjFanout0(pNode)))
552 fprintf( pFile, " %d AIG Po %s\n", Abc_ObjId(Abc_ObjFanout0(pNode)), temp);
553 else
554 fprintf( pFile, " %d AIG %s\n", Abc_ObjId(Abc_ObjFanout0(pNode)), temp);
555
556
557 }
558
559 //fprintf( pFile, " %d {type:\"AIG\" cube:\"%s\"}\n", Abc_ObjId(Abc_ObjFanout0(pNode)), temp);
560
561 ABC_FREE( temp );
562 }
563
564 /*
565 // get the output name
566 pName = Abc_ObjName(Abc_ObjFanout0(pNode));
567 // get the line length after the output name is written
568 AddedLength = strlen(pName) + 1;
569 if ( NameCounter && LineLength + AddedLength > 75 )
570 { // write the line extender
571 fprintf( pFile, " \\\n" );
572 // reset the line length
573 LineLength = 0;
574 NameCounter = 0;
575 }
576 fprintf( pFile, " %s", pName );
577 */
578}
579
591void Io_NtkEdgelistWriteSubcktFanins( FILE * pFile, Abc_Obj_t * pNode )
592{
593 Abc_Obj_t * pNet;
594 int LineLength;
595 int AddedLength;
596 int NameCounter;
597 char * pName;
598 int i;
599
600 LineLength = 6;
601 NameCounter = 0;
602
603 // get the output name
604 pName = Abc_ObjName(Abc_ObjFanout0(pNode));
605 // get the line length after the output name is written
606 AddedLength = strlen(pName) + 1;
607 fprintf( pFile, " m%d", Abc_ObjId(pNode) );
608
609 // get the input names
610 Abc_ObjForEachFanin( pNode, pNet, i )
611 {
612 // get the fanin name
613 pName = Abc_ObjName(pNet);
614 // get the line length after the fanin name is written
615 AddedLength = strlen(pName) + 3;
616 if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
617 { // write the line extender
618 fprintf( pFile, " \\\n" );
619 // reset the line length
620 LineLength = 0;
621 NameCounter = 0;
622 }
623 fprintf( pFile, " %c=%s", 'a'+i, pName );
624 LineLength += AddedLength;
625 NameCounter++;
626 }
627
628 // get the output name
629 pName = Abc_ObjName(Abc_ObjFanout0(pNode));
630 // get the line length after the output name is written
631 AddedLength = strlen(pName) + 3;
632 if ( NameCounter && LineLength + AddedLength > 75 )
633 { // write the line extender
634 fprintf( pFile, " \\\n" );
635 // reset the line length
636 LineLength = 0;
637 NameCounter = 0;
638 }
639 fprintf( pFile, " %c=%s", 'o', pName );
640}
641
642
654int Io_NtkEdgelistWriteNodeGate( FILE * pFile, Abc_Obj_t * pNode, int Length, int fName)
655{
656 static int fReport = 0;
657 Mio_Gate_t * pGate = (Mio_Gate_t *)pNode->pData;
658 Mio_Pin_t * pGatePin;
659 Abc_Obj_t * pNode2;
660 int i;
661 for ( pGatePin = Mio_GateReadPins(pGate), i = 0; pGatePin; pGatePin = Mio_PinReadNext(pGatePin), i++ ){
662 if (fName)
663 fprintf( pFile, "%s ", Abc_ObjName( Abc_ObjFanin(pNode,i) ) );
664 else
665 fprintf( pFile, "%d ", Abc_ObjId( Abc_ObjFanin(pNode,i) ) );
666 }
667 //fprintf( pFile, "%s=%s ", Mio_PinReadName(pGatePin), Abc_ObjName( Abc_ObjFanin(pNode,i) ) );
668 assert ( i == Abc_ObjFaninNum(pNode) );
669 if (fName)
670 fprintf( pFile, "%s", Abc_ObjName( Abc_ObjFanout0(pNode) ) );
671 else
672 fprintf( pFile, "%d", Abc_ObjId( Abc_ObjFanout0(pNode) ) );
673
674 //fprintf( pFile, "%s=%s", Mio_GateReadOutName(pGate), Abc_ObjName( Abc_ObjFanout0(pNode) ) );
675 if ( Mio_GateReadTwin(pGate) == NULL ){
676 //print gate type
677 fprintf( pFile, " %s", Mio_GateReadName(pGate) );
678 fprintf( pFile, " %lu", Mio_GateReadTruth(pGate) );
679 //Vec_Int_t * Expr = Mio_GateReadExpr(pGate);
680 //Vec_IntPrint(Expr);
681 return 0;
682 }
683 pNode2 = Abc_NtkFetchTwinNode( pNode );
684 if ( pNode2 == NULL )
685 {
686 if ( !fReport )
687 fReport = 1, printf( "Warning: Missing second output of gate(s) \"%s\".\n", Mio_GateReadName(pGate) );
688 return 0;
689 }
690 fprintf( pFile, " %s", Abc_ObjName( Abc_ObjFanout0(pNode2) ) );
691 //print gate type
692 fprintf( pFile, " %s", Mio_GateReadName(pGate));
693 fprintf( pFile, " %lu", Mio_GateReadTruth(pGate) );
694 return 1;
695}
696
708int Io_NtkEdgelistWriteNode( FILE * pFile, Abc_Obj_t * pNode, int Length, int fName)
709{
710 int RetValue = 0;
711 if ( Abc_NtkHasMapping(pNode->pNtk) )
712 {
713 // write the .gate line
714 if ( Abc_ObjIsBarBuf(pNode) )
715 {
716 printf("ERROR: not implemented\n");
717 return 0;
718 fprintf( pFile, ".barbuf " );
719 fprintf( pFile, "%s %s", Abc_ObjName(Abc_ObjFanin0(pNode)), Abc_ObjName(Abc_ObjFanout0(pNode)) );
720 fprintf( pFile, "\n" );
721 }
722 else
723 {
724 //fprintf( pFile, ".gate" );
725 RetValue = Io_NtkEdgelistWriteNodeGate( pFile, pNode, Length, fName);
726 fprintf( pFile, "\n" );
727 }
728 }
729 else
730 {
731 // write the .names line
732 //fprintf( pFile, ".names" );
733 Io_NtkEdgelistWriteNodeFanins( pFile, pNode, fName);
734 // write the cubes
735 // fprintf( pFile, " %s", (char*)Abc_ObjData(pNode) );
736 }
737 return RetValue;
738}
739
751int Io_NtkEdgelistWriteNodeSubckt( FILE * pFile, Abc_Obj_t * pNode, int Length )
752{
753 int RetValue = 0;
754 fprintf( pFile, ".subckt" );
755 Io_NtkEdgelistWriteSubcktFanins( pFile, pNode );
756 fprintf( pFile, "\n" );
757 return RetValue;
758}
759
760
772void Io_NtkEdgelistWriteNodeInt( FILE * pFile, Abc_Obj_t * pNode, Vec_Int_t * vCover )
773{
774 Abc_Obj_t * pNet;
775 int i, nVars = Abc_ObjFaninNum(pNode);
776 if ( nVars > 7 )
777 {
778 printf( "Node \"%s\" has more than 7 inputs. Writing Edgelist has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
779 return;
780 }
781
782 fprintf( pFile, "\n" );
783 if ( nVars <= 4 )
784 {
785 Abc_ObjForEachFanin( pNode, pNet, i )
786 fprintf( pFile, " %s", Abc_ObjName(pNet) );
787 // get the output name
788 fprintf( pFile, " %s ", Abc_ObjName(Abc_ObjFanout0(pNode)) );
789 // write the cubes
790 fprintf( pFile, "%s\n", (char*)Abc_ObjData(pNode) );
791 }
792 else
793 {
794 extern int If_Dec6PickBestMux( word t, word Cofs[2] );
795 extern int If_Dec7PickBestMux( word t[2], word c0r[2], word c1r[2] );
796 extern word If_Dec6MinimumBase( word uTruth, int * pSupp, int nVarsAll, int * pnVars );
797 extern void If_Dec7MinimumBase( word uTruth[2], int * pSupp, int nVarsAll, int * pnVars );
798 extern word If_Dec6Perform( word t, int fDerive );
799 extern word If_Dec7Perform( word t[2], int fDerive );
800
801 char * pSop;
802 word z, uTruth6 = 0, uTruth7[2], Cofs6[2], Cofs7[2][2];
803 int c, iVar, nVarsMin[2], pVars[2][10];
804
805 // collect variables
806 Abc_ObjForEachFanin( pNode, pNet, i )
807 pVars[0][i] = pVars[1][i] = i;
808
809 // derive truth table
810 if ( nVars == 7 )
811 {
812 Abc_SopToTruth7( (char*)Abc_ObjData(pNode), nVars, uTruth7 );
813 iVar = If_Dec7PickBestMux( uTruth7, Cofs7[0], Cofs7[1] );
814 }
815 else
816 {
817 uTruth6 = Abc_SopToTruth( (char*)Abc_ObjData(pNode), nVars );
818 iVar = If_Dec6PickBestMux( uTruth6, Cofs6 );
819 }
820
821 // perform MUX decomposition
822 if ( iVar >= 0 )
823 {
824 if ( nVars == 7 )
825 {
826 If_Dec7MinimumBase( Cofs7[0], pVars[0], nVars, &nVarsMin[0] );
827 If_Dec7MinimumBase( Cofs7[1], pVars[1], nVars, &nVarsMin[1] );
828 }
829 else
830 {
831 Cofs6[0] = If_Dec6MinimumBase( Cofs6[0], pVars[0], nVars, &nVarsMin[0] );
832 Cofs6[1] = If_Dec6MinimumBase( Cofs6[1], pVars[1], nVars, &nVarsMin[1] );
833 }
834 assert( nVarsMin[0] < 5 );
835 assert( nVarsMin[1] < 5 );
836 // write MUX
837 //fprintf( pFile, ".names" );
838 fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,iVar)) );
839 fprintf( pFile, " %s_cascade0", Abc_ObjName(Abc_ObjFanout0(pNode)) );
840 fprintf( pFile, " %s_cascade1", Abc_ObjName(Abc_ObjFanout0(pNode)) );
841 fprintf( pFile, " %s\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
842 fprintf( pFile, "1-1 1\n01- 1\n" );
843 // write cofactors
844 for ( c = 0; c < 2; c++ )
845 {
846 pSop = Io_NtkWriteEdgelistDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc,
847 (word)(nVars == 7 ? Cofs7[c][0] : Cofs6[c]), nVarsMin[c], vCover );
848 //fprintf( pFile, ".names" );
849 for ( i = 0; i < nVarsMin[c]; i++ )
850 fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,pVars[c][i])) );
851 fprintf( pFile, " %s_cascade%d\n", Abc_ObjName(Abc_ObjFanout0(pNode)), c );
852 fprintf( pFile, "%s", pSop );
853 }
854 return;
855 }
856 assert( nVars == 6 || nVars == 7 );
857
858 // try cascade decomposition
859 if ( nVars == 7 )
860 {
861 z = If_Dec7Perform( uTruth7, 1 );
862 //If_Dec7Verify( uTruth7, z );
863 }
864 else
865 {
866 z = If_Dec6Perform( uTruth6, 1 );
867 //If_Dec6Verify( uTruth6, z );
868 }
869 if ( z == 0 )
870 {
871 printf( "Node \"%s\" is not decomposable. Writing Edgelist has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
872 return;
873 }
874
875 // derive nodes
876 for ( c = 1; c >= 0; c-- )
877 {
878 // collect fanins
879 uTruth7[c] = ((c ? z >> 32 : z) & 0xffff);
880 uTruth7[c] |= (uTruth7[c] << 16);
881 uTruth7[c] |= (uTruth7[c] << 32);
882 for ( i = 0; i < 4; i++ )
883 pVars[c][i] = (z >> (c*32+16+4*i)) & 7;
884
885 // minimize truth table
886 Cofs6[c] = If_Dec6MinimumBase( uTruth7[c], pVars[c], 4, &nVarsMin[c] );
887
888 // write the nodes
889 //fprintf( pFile, ".names" );
890 for ( i = 0; i < nVarsMin[c]; i++ )
891 if ( pVars[c][i] == 7 )
892 fprintf( pFile, " %s_cascade", Abc_ObjName(Abc_ObjFanout0(pNode)) );
893 else
894 fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,pVars[c][i])) );
895 fprintf( pFile, " %s%s\n", Abc_ObjName(Abc_ObjFanout0(pNode)), c? "" : "_cascade" );
896
897 // write SOP
898 pSop = Io_NtkWriteEdgelistDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc,
899 (word)Cofs6[c], nVarsMin[c], vCover );
900 fprintf( pFile, "%s", pSop );
901 }
902 }
903}
904
916void Io_NtkEdgelistWriteNodeIntStruct( FILE * pFile, Abc_Obj_t * pNode, Vec_Int_t * vCover, char * pStr )
917{
918 Abc_Obj_t * pNet;
919 int nLeaves = Abc_ObjFaninNum(pNode);
920 int i, nLutLeaf, nLutLeaf2, nLutRoot, Length;
921
922 // quit if parameters are wrong
923 Length = strlen(pStr);
924 if ( Length != 2 && Length != 3 )
925 {
926 printf( "Wrong LUT struct (%s)\n", pStr );
927 return;
928 }
929 for ( i = 0; i < Length; i++ )
930 if ( pStr[i] - '0' < 3 || pStr[i] - '0' > 6 )
931 {
932 printf( "The LUT size (%d) should belong to {3,4,5,6}.\n", pStr[i] - '0' );
933 return;
934 }
935
936 nLutLeaf = pStr[0] - '0';
937 nLutLeaf2 = ( Length == 3 ) ? pStr[1] - '0' : 0;
938 nLutRoot = pStr[Length-1] - '0';
939 if ( nLeaves > nLutLeaf - 1 + (nLutLeaf2 ? nLutLeaf2 - 1 : 0) + nLutRoot )
940 {
941 printf( "The node size (%d) is too large for the LUT structure %s.\n", nLeaves, pStr );
942 return;
943 }
944
945 // consider easy case
946 fprintf( pFile, "\n" );
947 if ( nLeaves <= Abc_MaxInt( nLutLeaf2, Abc_MaxInt(nLutLeaf, nLutRoot) ) )
948 {
949 // write the .names line
951 Abc_ObjForEachFanin( pNode, pNet, i )
952 fprintf( pFile, " %s", Abc_ObjName(pNet) );
953 // get the output name
954 fprintf( pFile, " %s ", Abc_ObjName(Abc_ObjFanout0(pNode)) );
955 // write the cubes
956 fprintf( pFile, "%s\n", (char*)Abc_ObjData(pNode) );
957 return;
958 }
959 else
960 {
961 extern int If_CluMinimumBase( word * t, int * pSupp, int nVarsAll, int * pnVars );
962
963 static word TruthStore[16][1<<10] = {{0}}, * pTruths[16];
964 word pCube[1<<10], pRes[1<<10], Func0, Func1, Func2;
965 char pLut0[32], pLut1[32], pLut2[32] = {0}, * pSop;
966// int nVarsMin[3], pVars[3][20];
967
968 if ( TruthStore[0][0] == 0 )
969 {
970 static word Truth6[6] = {
971 ABC_CONST(0xAAAAAAAAAAAAAAAA),
972 ABC_CONST(0xCCCCCCCCCCCCCCCC),
973 ABC_CONST(0xF0F0F0F0F0F0F0F0),
974 ABC_CONST(0xFF00FF00FF00FF00),
975 ABC_CONST(0xFFFF0000FFFF0000),
976 ABC_CONST(0xFFFFFFFF00000000)
977 };
978 int nVarsMax = 16;
979 int nWordsMax = (1 << 10);
980 int i, k;
981 assert( nVarsMax <= 16 );
982 for ( i = 0; i < nVarsMax; i++ )
983 pTruths[i] = TruthStore[i];
984 for ( i = 0; i < 6; i++ )
985 for ( k = 0; k < nWordsMax; k++ )
986 pTruths[i][k] = Truth6[i];
987 for ( i = 6; i < nVarsMax; i++ )
988 for ( k = 0; k < nWordsMax; k++ )
989 pTruths[i][k] = ((k >> (i-6)) & 1) ? ~(word)0 : 0;
990 }
991
992 // collect variables
993// Abc_ObjForEachFanin( pNode, pNet, i )
994// pVars[0][i] = pVars[1][i] = pVars[2][i] = i;
995
996 // derive truth table
997 Abc_SopToTruthBig( (char*)Abc_ObjData(pNode), nLeaves, pTruths, pCube, pRes );
998 if ( Kit_TruthIsConst0((unsigned *)pRes, nLeaves) || Kit_TruthIsConst1((unsigned *)pRes, nLeaves) )
999 {
1000 fprintf( pFile, "%s\n const%d\n", Abc_ObjName(Abc_ObjFanout0(pNode)), Kit_TruthIsConst1((unsigned *)pRes, nLeaves) );
1001 return;
1002 }
1003
1004// Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
1005// Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
1006
1007 // perform decomposition
1008 if ( Length == 2 )
1009 {
1010 if ( !If_CluCheckExt( NULL, pRes, nLeaves, nLutLeaf, nLutRoot, pLut0, pLut1, &Func0, &Func1 ) )
1011 {
1012 Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
1013 Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
1014 printf( "Node \"%s\" is not decomposable. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
1015 return;
1016 }
1017 }
1018 else
1019 {
1020 if ( !If_CluCheckExt3( NULL, pRes, nLeaves, nLutLeaf, nLutLeaf2, nLutRoot, pLut0, pLut1, pLut2, &Func0, &Func1, &Func2 ) )
1021 {
1022 Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
1023 Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
1024 printf( "Node \"%s\" is not decomposable. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
1025 return;
1026 }
1027 }
1028
1029 // write leaf node
1030 // //fprintf( pFile, ".names" );
1031 for ( i = 0; i < pLut1[0]; i++ )
1032 fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,pLut1[2+i])) );
1033 fprintf( pFile, " %s_lut1\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
1034 // write SOP
1035 pSop = Io_NtkWriteEdgelistDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func1, pLut1[0], vCover );
1036 fprintf( pFile, "%s", pSop );
1037
1038 if ( Length == 3 && pLut2[0] > 0 )
1039 {
1040 // write leaf node
1041 // //fprintf( pFile, ".names" );
1042 for ( i = 0; i < pLut2[0]; i++ )
1043 if ( pLut2[2+i] == nLeaves )
1044 fprintf( pFile, " %s_lut1", Abc_ObjName(Abc_ObjFanout0(pNode)) );
1045 else
1046 fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,pLut2[2+i])) );
1047 fprintf( pFile, " %s_lut2\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
1048 // write SOP
1049 pSop = Io_NtkWriteEdgelistDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func2, pLut2[0], vCover );
1050 fprintf( pFile, "%s", pSop );
1051 }
1052
1053 // write root node
1054 // //fprintf( pFile, ".names" );
1055 for ( i = 0; i < pLut0[0]; i++ )
1056 if ( pLut0[2+i] == nLeaves )
1057 fprintf( pFile, " %s_lut1", Abc_ObjName(Abc_ObjFanout0(pNode)) );
1058 else if ( pLut0[2+i] == nLeaves+1 )
1059 fprintf( pFile, " %s_lut2", Abc_ObjName(Abc_ObjFanout0(pNode)) );
1060 else
1061 fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,pLut0[2+i])) );
1062 fprintf( pFile, " %s\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
1063 // write SOP
1064 pSop = Io_NtkWriteEdgelistDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func0, pLut0[0], vCover );
1065 fprintf( pFile, "%s", pSop );
1066 }
1067}
1068
1080void Io_NtkEdgelistWriteModelIntStruct( FILE * pFile, Abc_Obj_t * pNode, Vec_Int_t * vCover, char * pStr )
1081{
1082 Abc_Obj_t * pNet;
1083 int nLeaves = Abc_ObjFaninNum(pNode);
1084 int i, nLutLeaf, nLutLeaf2, nLutRoot, Length;
1085
1086 // write the header
1087 /*
1088 fprintf( pFile, "\n" );
1089 fprintf( pFile, ".model m%d\n", Abc_ObjName(pNode) );
1090 fprintf( pFile, ".inputs" );
1091 for ( i = 0; i < Abc_ObjFaninNum(pNode); i++ )
1092 fprintf( pFile, " %c", 'a' + i );
1093 fprintf( pFile, "\n" );
1094 fprintf( pFile, ".outputs o\n" );
1095 */
1096 // quit if parameters are wrong
1097 Length = strlen(pStr);
1098 if ( Length != 2 && Length != 3 )
1099 {
1100 printf( "Wrong LUT struct (%s)\n", pStr );
1101 return;
1102 }
1103 for ( i = 0; i < Length; i++ )
1104 if ( pStr[i] - '0' < 3 || pStr[i] - '0' > 6 )
1105 {
1106 printf( "The LUT size (%d) should belong to {3,4,5,6}.\n", pStr[i] - '0' );
1107 return;
1108 }
1109
1110 nLutLeaf = pStr[0] - '0';
1111 nLutLeaf2 = ( Length == 3 ) ? pStr[1] - '0' : 0;
1112 nLutRoot = pStr[Length-1] - '0';
1113 if ( nLeaves > nLutLeaf - 1 + (nLutLeaf2 ? nLutLeaf2 - 1 : 0) + nLutRoot )
1114 {
1115 printf( "The node size (%d) is too large for the LUT structure %s.\n", nLeaves, pStr );
1116 return;
1117 }
1118
1119 // consider easy case
1120 if ( nLeaves <= Abc_MaxInt( nLutLeaf2, Abc_MaxInt(nLutLeaf, nLutRoot) ) )
1121 {
1122 // write the .names line
1123 // //fprintf( pFile, ".names" );
1124 Abc_ObjForEachFanin( pNode, pNet, i )
1125 fprintf( pFile, "%c", 'a' + i );
1126 // get the output name
1127 fprintf( pFile, " %s", "o" );
1128 // write the cubes
1129 fprintf( pFile, " %s\n", (char*)Abc_ObjData(pNode) );
1130 //fprintf( pFile, ".end\n" );
1131 return;
1132 }
1133 else
1134 {
1135 extern int If_CluMinimumBase( word * t, int * pSupp, int nVarsAll, int * pnVars );
1136
1137 static word TruthStore[16][1<<10] = {{0}}, * pTruths[16];
1138 word pCube[1<<10], pRes[1<<10], Func0, Func1, Func2;
1139 char pLut0[32], pLut1[32], pLut2[32] = {0}, * pSop;
1140// int nVarsMin[3], pVars[3][20];
1141
1142 if ( TruthStore[0][0] == 0 )
1143 {
1144 static word Truth6[6] = {
1145 ABC_CONST(0xAAAAAAAAAAAAAAAA),
1146 ABC_CONST(0xCCCCCCCCCCCCCCCC),
1147 ABC_CONST(0xF0F0F0F0F0F0F0F0),
1148 ABC_CONST(0xFF00FF00FF00FF00),
1149 ABC_CONST(0xFFFF0000FFFF0000),
1150 ABC_CONST(0xFFFFFFFF00000000)
1151 };
1152 int nVarsMax = 16;
1153 int nWordsMax = (1 << 10);
1154 int i, k;
1155 assert( nVarsMax <= 16 );
1156 for ( i = 0; i < nVarsMax; i++ )
1157 pTruths[i] = TruthStore[i];
1158 for ( i = 0; i < 6; i++ )
1159 for ( k = 0; k < nWordsMax; k++ )
1160 pTruths[i][k] = Truth6[i];
1161 for ( i = 6; i < nVarsMax; i++ )
1162 for ( k = 0; k < nWordsMax; k++ )
1163 pTruths[i][k] = ((k >> (i-6)) & 1) ? ~(word)0 : 0;
1164 }
1165
1166 // collect variables
1167// Abc_ObjForEachFanin( pNode, pNet, i )
1168// pVars[0][i] = pVars[1][i] = pVars[2][i] = i;
1169
1170 // derive truth table
1171 Abc_SopToTruthBig( (char*)Abc_ObjData(pNode), nLeaves, pTruths, pCube, pRes );
1172 if ( Kit_TruthIsConst0((unsigned *)pRes, nLeaves) || Kit_TruthIsConst1((unsigned *)pRes, nLeaves) )
1173 {
1174 fprintf( pFile, ".names %s\n %d\n", "o", Kit_TruthIsConst1((unsigned *)pRes, nLeaves) );
1175 fprintf( pFile, ".end\n" );
1176 return;
1177 }
1178
1179// Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
1180// Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
1181
1182 // perform decomposition
1183 if ( Length == 2 )
1184 {
1185 if ( !If_CluCheckExt( NULL, pRes, nLeaves, nLutLeaf, nLutRoot, pLut0, pLut1, &Func0, &Func1 ) )
1186 {
1187 Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
1188 Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
1189 printf( "Node \"%s\" is not decomposable. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
1190 return;
1191 }
1192 }
1193 else
1194 {
1195 if ( !If_CluCheckExt3( NULL, pRes, nLeaves, nLutLeaf, nLutLeaf2, nLutRoot, pLut0, pLut1, pLut2, &Func0, &Func1, &Func2 ) )
1196 {
1197 Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
1198 Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
1199 printf( "Node \"%s\" is not decomposable. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
1200 return;
1201 }
1202 }
1203
1204 // write leaf node
1205 // //fprintf( pFile, ".names" );
1206 for ( i = 0; i < pLut1[0]; i++ )
1207 fprintf( pFile, " %c", 'a' + pLut1[2+i] );
1208 fprintf( pFile, " lut1\n" );
1209 // write SOP
1210 pSop = Io_NtkWriteEdgelistDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func1, pLut1[0], vCover );
1211 fprintf( pFile, "%s", pSop );
1212
1213 if ( Length == 3 && pLut2[0] > 0 )
1214 {
1215 // write leaf node
1216 // //fprintf( pFile, ".names" );
1217 for ( i = 0; i < pLut2[0]; i++ )
1218 if ( pLut2[2+i] == nLeaves )
1219 fprintf( pFile, " lut1" );
1220 else
1221 fprintf( pFile, " %c", 'a' + pLut2[2+i] );
1222 fprintf( pFile, " lut2\n" );
1223 // write SOP
1224 pSop = Io_NtkWriteEdgelistDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func2, pLut2[0], vCover );
1225 fprintf( pFile, "%s", pSop );
1226 }
1227
1228 // write root node
1229 //fprintf( pFile, ".names" );
1230 for ( i = 0; i < pLut0[0]; i++ )
1231 if ( pLut0[2+i] == nLeaves )
1232 fprintf( pFile, " lut1" );
1233 else if ( pLut0[2+i] == nLeaves+1 )
1234 fprintf( pFile, " lut2" );
1235 else
1236 fprintf( pFile, " %c", 'a' + pLut0[2+i] );
1237 fprintf( pFile, " %s\n", "o" );
1238 // write SOP
1239 pSop = Io_NtkWriteEdgelistDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func0, pLut0[0], vCover );
1240 fprintf( pFile, "%s", pSop );
1241 fprintf( pFile, ".end\n" );
1242 }
1243}
1244
1245
1249
1250
1251ABC_NAMESPACE_IMPL_END
1252
Abc_Obj_t
struct Abc_Obj_t_ Abc_Obj_t
Definition abc.h:116
Abc_NtkForEachCo
#define Abc_NtkForEachCo(pNtk, pCo, i)
Definition abc.h:522
Abc_NtkForEachPo
#define Abc_NtkForEachPo(pNtk, pPo, i)
Definition abc.h:520
Abc_NtkFetchTwinNode
ABC_DLL Abc_Obj_t * Abc_NtkFetchTwinNode(Abc_Obj_t *pNode)
Definition abcMap.c:804
Abc_NtkForEachLatch
#define Abc_NtkForEachLatch(pNtk, pObj, i)
Definition abc.h:500
Abc_ObjForEachFanin
#define Abc_ObjForEachFanin(pObj, pFanin, i)
Definition abc.h:527
Abc_SopComplement
ABC_DLL void Abc_SopComplement(char *pSop)
Definition abcSop.c:648
Abc_NtkForEachBlackbox
#define Abc_NtkForEachBlackbox(pNtk, pObj, i)
Definition abc.h:512
Abc_ObjName
ABC_DLL char * Abc_ObjName(Abc_Obj_t *pNode)
DECLARATIONS ///.
Definition abcNames.c:49
Abc_Ntk_t
struct Abc_Ntk_t_ Abc_Ntk_t
Definition abc.h:115
Abc_NtkToNetlist
ABC_DLL Abc_Ntk_t * Abc_NtkToNetlist(Abc_Ntk_t *pNtk)
Definition abcNetlist.c:100
Abc_SopToTruthBig
ABC_DLL void Abc_SopToTruthBig(char *pSop, int nInputs, word **pVars, word *pCube, word *pRes)
Definition abcSop.c:1425
Abc_NtkForEachWhitebox
#define Abc_NtkForEachWhitebox(pNtk, pObj, i)
Definition abc.h:509
Abc_SopToTruth7
ABC_DLL void Abc_SopToTruth7(char *pSop, int nInputs, word r[2])
Definition abcSop.c:1365
Abc_NtkForEachPi
#define Abc_NtkForEachPi(pNtk, pPi, i)
Definition abc.h:516
Abc_SopCreateFromIsop
ABC_DLL char * Abc_SopCreateFromIsop(Mem_Flex_t *pMan, int nVars, Vec_Int_t *vCover)
Definition abcSop.c:424
Abc_NtkForEachCi
#define Abc_NtkForEachCi(pNtk, pCi, i)
Definition abc.h:518
Abc_NtkDelete
ABC_DLL void Abc_NtkDelete(Abc_Ntk_t *pNtk)
Definition abcNtk.c:1421
Abc_SopToTruth
ABC_DLL word Abc_SopToTruth(char *pSop, int nInputs)
Definition abcSop.c:1314
Abc_NtkForEachNode
#define Abc_NtkForEachNode(pNtk, pNode, i)
Definition abc.h:464
ABC_FREE
#define ABC_FREE(obj)
Definition abc_global.h:267
ABC_CONST
#define ABC_CONST(number)
PARAMETERS ///.
Definition abc_global.h:240
ABC_NAMESPACE_IMPL_START
#define ABC_NAMESPACE_IMPL_START
Definition abc_namespaces.h:54
ABC_NAMESPACE_IMPL_END
#define ABC_NAMESPACE_IMPL_END
Definition abc_namespaces.h:55
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition bblif.c:37
ProgressBar
ABC_NAMESPACE_IMPL_START typedef char ProgressBar
Definition bbrNtbdd.c:27
Extra_ProgressBarStop
void Extra_ProgressBarStop(ProgressBar *p)
Definition extraUtilProgress.c:118
Extra_TimeStamp
char * Extra_TimeStamp()
Definition extraUtilFile.c:465
Extra_ProgressBarStart
ProgressBar * Extra_ProgressBarStart(FILE *pFile, int nItemsTotal)
FUNCTION DEFINITIONS ///.
Definition extraUtilProgress.c:62
Extra_PrintHex
void Extra_PrintHex(FILE *pFile, unsigned *pTruth, int nVars)
Definition extraUtilFile.c:643
If_Dec7PickBestMux
int If_Dec7PickBestMux(word t[2], word c0r[2], word c1r[2])
Definition ifDec07.c:643
If_Dec6PickBestMux
int If_Dec6PickBestMux(word t, word Cofs[2])
Definition ifDec07.c:626
If_Dec6Perform
word If_Dec6Perform(word t, int fDerive)
Definition ifDec07.c:409
If_Dec7Perform
word If_Dec7Perform(word t0[2], int fDerive)
Definition ifDec07.c:449
If_Dec6MinimumBase
word If_Dec6MinimumBase(word uTruth, int *pSupp, int nVarsAll, int *pnVars)
Definition ifDec07.c:501
If_Dec7MinimumBase
void If_Dec7MinimumBase(word uTruth[2], int *pSupp, int nVarsAll, int *pnVars)
Definition ifDec07.c:533
If_CluMinimumBase
int If_CluMinimumBase(word *t, int *pSupp, int nVarsAll, int *pnVars)
Definition ifDec16.c:1532
If_CluCheckExt3
int If_CluCheckExt3(void *p, word *pTruth, int nVars, int nLutLeaf, int nLutLeaf2, int nLutRoot, char *pLut0, char *pLut1, char *pLut2, word *pFunc0, word *pFunc1, word *pFunc2)
Definition ifDec16.c:2079
If_CluCheckExt
int If_CluCheckExt(void *p, word *pTruth, int nVars, int nLutLeaf, int nLutRoot, char *pLut0, char *pLut1, word *pFunc0, word *pFunc1)
Definition ifDec16.c:2066
IO_WRITE_LINE_LENGTH
#define IO_WRITE_LINE_LENGTH
MACRO DEFINITIONS ///.
Definition ioAbc.h:75
Io_WriteTimingInfo
void Io_WriteTimingInfo(FILE *pFile, Abc_Ntk_t *pNtk)
Definition ioWriteBlif.c:674
Io_NtkEdgelistWriteConvertedBox
void Io_NtkEdgelistWriteConvertedBox(FILE *pFile, Abc_Ntk_t *pNtk, int fSeq)
Definition ioWriteEdgelist.c:142
Io_WriteEdgelist
void Io_WriteEdgelist(Abc_Ntk_t *pNtk, char *FileName, int fWriteLatches, int fBb2Wb, int fSeq, int fName)
FUNCTION DEFINITIONS ///.
Definition ioWriteEdgelist.c:59
Io_NtkEdgelistWriteNodeGate
int Io_NtkEdgelistWriteNodeGate(FILE *pFile, Abc_Obj_t *pNode, int Length, int fName)
Definition ioWriteEdgelist.c:654
Io_NtkWriteEdgelistDeriveSop
char * Io_NtkWriteEdgelistDeriveSop(Mem_Flex_t *pMem, word uTruth, int nVars, Vec_Int_t *vCover)
Definition ioWriteEdgelist.c:184
Io_NtkEdgelistWriteNodeSubckt
int Io_NtkEdgelistWriteNodeSubckt(FILE *pFile, Abc_Obj_t *pNode, int Length)
Definition ioWriteEdgelist.c:751
Io_NtkEdgelistWriteNodeInt
void Io_NtkEdgelistWriteNodeInt(FILE *pFile, Abc_Obj_t *pNode, Vec_Int_t *vCover)
Definition ioWriteEdgelist.c:772
Io_NtkEdgelistWriteSubcktFanins
void Io_NtkEdgelistWriteSubcktFanins(FILE *pFile, Abc_Obj_t *pNode)
Definition ioWriteEdgelist.c:591
Io_NtkEdgelistWriteNodeIntStruct
void Io_NtkEdgelistWriteNodeIntStruct(FILE *pFile, Abc_Obj_t *pNode, Vec_Int_t *vCover, char *pStr)
Definition ioWriteEdgelist.c:916
Io_NtkEdgelistWriteModelIntStruct
void Io_NtkEdgelistWriteModelIntStruct(FILE *pFile, Abc_Obj_t *pNode, Vec_Int_t *vCover, char *pStr)
Definition ioWriteEdgelist.c:1080
Io_NtkEdgelistWrite_int
void Io_NtkEdgelistWrite_int(FILE *pFile, Abc_Ntk_t *pNtk, int fWriteLatches, int fBb2Wb, int fSeq, int fName)
Definition ioWriteEdgelist.c:101
word
unsigned __int64 word
DECLARATIONS ///.
Definition kitPerm.c:36
Kit_TruthIsop
int Kit_TruthIsop(unsigned *puTruth, int nVars, Vec_Int_t *vMemory, int fTryBoth)
Definition kitIsop.c:134
Kit_DsdPrintFromTruth
void Kit_DsdPrintFromTruth(unsigned *pTruth, int nVars)
Definition kitDsd.c:491
Mio_GateReadPins
Mio_Pin_t * Mio_GateReadPins(Mio_Gate_t *pGate)
Definition mioApi.c:173
Mio_Library_t
struct Mio_LibraryStruct_t_ Mio_Library_t
Definition mio.h:42
Mio_GateReadTwin
Mio_Gate_t * Mio_GateReadTwin(Mio_Gate_t *pGate)
Definition mioApi.c:176
Mio_GateReadTruth
word Mio_GateReadTruth(Mio_Gate_t *pGate)
Definition mioApi.c:181
Mio_GateReadName
char * Mio_GateReadName(Mio_Gate_t *pGate)
Definition mioApi.c:169
Mio_PinReadNext
Mio_Pin_t * Mio_PinReadNext(Mio_Pin_t *pPin)
Definition mioApi.c:217
Mio_LibraryReadGateNameMax
int Mio_LibraryReadGateNameMax(Mio_Library_t *pLib)
Definition mioApi.c:81
Mio_Pin_t
struct Mio_PinStruct_t_ Mio_Pin_t
Definition mio.h:44
Mio_Gate_t
struct Mio_GateStruct_t_ Mio_Gate_t
Definition mio.h:43
Mem_Flex_t
struct Mem_Flex_t_ Mem_Flex_t
Definition mem.h:34
Abc_Des_t_::vModules
Vec_Ptr_t * vModules
Definition abc.h:225
Abc_Ntk_t_::pName
char * pName
Definition abc.h:158
Abc_Ntk_t_::pDesign
Abc_Des_t * pDesign
Definition abc.h:180
Abc_Ntk_t_::pManFunc
void * pManFunc
Definition abc.h:191
Abc_Obj_t_::pData
void * pData
Definition abc.h:145
Abc_Obj_t_::pNtk
Abc_Ntk_t * pNtk
Definition abc.h:130
assert
#define assert(ex)
Definition util_old.h:213
strlen
int strlen()
Vec_PtrForEachEntry
#define Vec_PtrForEachEntry(Type, vVec, pEntry, i)
MACRO DEFINITIONS ///.
Definition vecPtr.h:55