/src/base/io/ioWriteBlif.c
C | 1410 lines | 919 code | 100 blank | 391 comment | 200 complexity | 3243c85058d3f48aead4d746e4eb1db3 MD5 | raw file
Possible License(s): BSD-3-Clause
- /**CFile****************************************************************
- FileName [ioWriteBlif.c]
- SystemName [ABC: Logic synthesis and verification system.]
- PackageName [Command processing package.]
- Synopsis [Procedures to write BLIF files.]
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
- Date [Ver. 1.0. Started - June 20, 2005.]
- Revision [$Id: ioWriteBlif.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
- ***********************************************************************/
- #include "ioAbc.h"
- #include "base/main/main.h"
- #include "map/mio/mio.h"
- #include "bool/kit/kit.h"
- #include "map/if/if.h"
- ABC_NAMESPACE_IMPL_START
- ////////////////////////////////////////////////////////////////////////
- /// DECLARATIONS ///
- ////////////////////////////////////////////////////////////////////////
- static void Io_NtkWrite( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches, int fBb2Wb, int fSeq );
- static void Io_NtkWriteOne( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches, int fBb2Wb, int fSeq );
- static void Io_NtkWritePis( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches );
- static void Io_NtkWritePos( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches );
- static void Io_NtkWriteSubckt( FILE * pFile, Abc_Obj_t * pNode );
- static void Io_NtkWriteAsserts( FILE * pFile, Abc_Ntk_t * pNtk );
- static void Io_NtkWriteNodeFanins( FILE * pFile, Abc_Obj_t * pNode );
- static int Io_NtkWriteNode( FILE * pFile, Abc_Obj_t * pNode, int Length );
- static void Io_NtkWriteLatch( FILE * pFile, Abc_Obj_t * pLatch );
- ////////////////////////////////////////////////////////////////////////
- /// FUNCTION DEFINITIONS ///
- ////////////////////////////////////////////////////////////////////////
- /**Function*************************************************************
- Synopsis [Write the network into a BLIF file with the given name.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_WriteBlifLogic( Abc_Ntk_t * pNtk, char * FileName, int fWriteLatches )
- {
- Abc_Ntk_t * pNtkTemp;
- // derive the netlist
- pNtkTemp = Abc_NtkToNetlist(pNtk);
- if ( pNtkTemp == NULL )
- {
- fprintf( stdout, "Writing BLIF has failed.\n" );
- return;
- }
- Io_WriteBlif( pNtkTemp, FileName, fWriteLatches, 0, 0 );
- Abc_NtkDelete( pNtkTemp );
- }
- /**Function*************************************************************
- Synopsis [Write the network into a BLIF file with the given name.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_WriteBlif( Abc_Ntk_t * pNtk, char * FileName, int fWriteLatches, int fBb2Wb, int fSeq )
- {
- FILE * pFile;
- Abc_Ntk_t * pNtkTemp;
- int i;
- assert( Abc_NtkIsNetlist(pNtk) );
- // start writing the file
- pFile = fopen( FileName, "w" );
- if ( pFile == NULL )
- {
- fprintf( stdout, "Io_WriteBlif(): Cannot open the output file.\n" );
- return;
- }
- fprintf( pFile, "# Benchmark \"%s\" written by ABC on %s\n", pNtk->pName, Extra_TimeStamp() );
- // write the master network
- Io_NtkWrite( pFile, pNtk, fWriteLatches, fBb2Wb, fSeq );
- // make sure there is no logic hierarchy
- // assert( Abc_NtkWhiteboxNum(pNtk) == 0 );
- // write the hierarchy if present
- if ( Abc_NtkBlackboxNum(pNtk) > 0 || Abc_NtkWhiteboxNum(pNtk) > 0 )
- {
- Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pNtkTemp, i )
- {
- if ( pNtkTemp == pNtk )
- continue;
- fprintf( pFile, "\n\n" );
- Io_NtkWrite( pFile, pNtkTemp, fWriteLatches, fBb2Wb, fSeq );
- }
- }
- fclose( pFile );
- }
- /**Function*************************************************************
- Synopsis [Write the network into a BLIF file with the given name.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_NtkWrite( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches, int fBb2Wb, int fSeq )
- {
- Abc_Ntk_t * pExdc;
- assert( Abc_NtkIsNetlist(pNtk) );
- // write the model name
- fprintf( pFile, ".model %s\n", Abc_NtkName(pNtk) );
- // write the network
- Io_NtkWriteOne( pFile, pNtk, fWriteLatches, fBb2Wb, fSeq );
- // write EXDC network if it exists
- pExdc = Abc_NtkExdc( pNtk );
- if ( pExdc )
- {
- fprintf( pFile, "\n" );
- fprintf( pFile, ".exdc\n" );
- Io_NtkWriteOne( pFile, pExdc, fWriteLatches, fBb2Wb, fSeq );
- }
- // finalize the file
- fprintf( pFile, ".end\n" );
- }
- /**Function*************************************************************
- Synopsis [Write one network.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_NtkWriteConvertedBox( FILE * pFile, Abc_Ntk_t * pNtk, int fSeq )
- {
- Abc_Obj_t * pObj;
- int i, v;
- if ( fSeq )
- {
- fprintf( pFile, ".attrib white box seq\n" );
- }
- else
- {
- fprintf( pFile, ".attrib white box comb\n" );
- fprintf( pFile, ".delay 1\n" );
- }
- Abc_NtkForEachPo( pNtk, pObj, i )
- {
- // write the .names line
- fprintf( pFile, ".names" );
- Io_NtkWritePis( pFile, pNtk, 1 );
- if ( fSeq )
- fprintf( pFile, " %s_in\n", Abc_ObjName(Abc_ObjFanin0(pObj)) );
- else
- fprintf( pFile, " %s\n", Abc_ObjName(Abc_ObjFanin0(pObj)) );
- for ( v = 0; v < Abc_NtkPiNum(pNtk); v++ )
- fprintf( pFile, "1" );
- fprintf( pFile, " 1\n" );
- if ( fSeq )
- fprintf( pFile, ".latch %s_in %s 1\n", Abc_ObjName(Abc_ObjFanin0(pObj)), Abc_ObjName(Abc_ObjFanin0(pObj)) );
- }
- }
- /**Function*************************************************************
- Synopsis [Write one network.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_NtkWriteOne( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches, int fBb2Wb, int fSeq )
- {
- ProgressBar * pProgress;
- Abc_Obj_t * pNode, * pLatch;
- int i, Length;
- // write the PIs
- fprintf( pFile, ".inputs" );
- Io_NtkWritePis( pFile, pNtk, fWriteLatches );
- fprintf( pFile, "\n" );
- // write the POs
- fprintf( pFile, ".outputs" );
- Io_NtkWritePos( pFile, pNtk, fWriteLatches );
- fprintf( pFile, "\n" );
- // write the blackbox
- if ( Abc_NtkHasBlackbox( pNtk ) )
- {
- if ( fBb2Wb )
- Io_NtkWriteConvertedBox( pFile, pNtk, fSeq );
- else
- fprintf( pFile, ".blackbox\n" );
- return;
- }
- // write the timing info
- Io_WriteTimingInfo( pFile, pNtk );
- // write the latches
- if ( fWriteLatches && !Abc_NtkIsComb(pNtk) )
- {
- fprintf( pFile, "\n" );
- Abc_NtkForEachLatch( pNtk, pLatch, i )
- Io_NtkWriteLatch( pFile, pLatch );
- fprintf( pFile, "\n" );
- }
- // write the subcircuits
- // assert( Abc_NtkWhiteboxNum(pNtk) == 0 );
- if ( Abc_NtkBlackboxNum(pNtk) > 0 || Abc_NtkWhiteboxNum(pNtk) > 0 )
- {
- fprintf( pFile, "\n" );
- Abc_NtkForEachBlackbox( pNtk, pNode, i )
- Io_NtkWriteSubckt( pFile, pNode );
- fprintf( pFile, "\n" );
- Abc_NtkForEachWhitebox( pNtk, pNode, i )
- Io_NtkWriteSubckt( pFile, pNode );
- fprintf( pFile, "\n" );
- }
- // write each internal node
- Length = Abc_NtkHasMapping(pNtk)? Mio_LibraryReadGateNameMax((Mio_Library_t *)pNtk->pManFunc) : 0;
- pProgress = Extra_ProgressBarStart( stdout, Abc_NtkObjNumMax(pNtk) );
- Abc_NtkForEachNode( pNtk, pNode, i )
- {
- Extra_ProgressBarUpdate( pProgress, i, NULL );
- if ( Io_NtkWriteNode( pFile, pNode, Length ) ) // skip the next node
- i++;
- }
- Extra_ProgressBarStop( pProgress );
- }
- /**Function*************************************************************
- Synopsis [Writes the primary input list.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_NtkWritePis( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches )
- {
- Abc_Obj_t * pTerm, * pNet;
- int LineLength;
- int AddedLength;
- int NameCounter;
- int i;
- LineLength = 7;
- NameCounter = 0;
- if ( fWriteLatches )
- {
- Abc_NtkForEachPi( pNtk, pTerm, i )
- {
- pNet = Abc_ObjFanout0(pTerm);
- // get the line length after this name is written
- AddedLength = strlen(Abc_ObjName(pNet)) + 1;
- if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
- { // write the line extender
- fprintf( pFile, " \\\n" );
- // reset the line length
- LineLength = 0;
- NameCounter = 0;
- }
- fprintf( pFile, " %s", Abc_ObjName(pNet) );
- LineLength += AddedLength;
- NameCounter++;
- }
- }
- else
- {
- Abc_NtkForEachCi( pNtk, pTerm, i )
- {
- pNet = Abc_ObjFanout0(pTerm);
- // get the line length after this name is written
- AddedLength = strlen(Abc_ObjName(pNet)) + 1;
- if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
- { // write the line extender
- fprintf( pFile, " \\\n" );
- // reset the line length
- LineLength = 0;
- NameCounter = 0;
- }
- fprintf( pFile, " %s", Abc_ObjName(pNet) );
- LineLength += AddedLength;
- NameCounter++;
- }
- }
- }
- /**Function*************************************************************
- Synopsis [Writes the primary input list.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_NtkWritePos( FILE * pFile, Abc_Ntk_t * pNtk, int fWriteLatches )
- {
- Abc_Obj_t * pTerm, * pNet;
- int LineLength;
- int AddedLength;
- int NameCounter;
- int i;
- LineLength = 8;
- NameCounter = 0;
- if ( fWriteLatches )
- {
- Abc_NtkForEachPo( pNtk, pTerm, i )
- {
- pNet = Abc_ObjFanin0(pTerm);
- // get the line length after this name is written
- AddedLength = strlen(Abc_ObjName(pNet)) + 1;
- if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
- { // write the line extender
- fprintf( pFile, " \\\n" );
- // reset the line length
- LineLength = 0;
- NameCounter = 0;
- }
- fprintf( pFile, " %s", Abc_ObjName(pNet) );
- LineLength += AddedLength;
- NameCounter++;
- }
- }
- else
- {
- Abc_NtkForEachCo( pNtk, pTerm, i )
- {
- pNet = Abc_ObjFanin0(pTerm);
- // get the line length after this name is written
- AddedLength = strlen(Abc_ObjName(pNet)) + 1;
- if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
- { // write the line extender
- fprintf( pFile, " \\\n" );
- // reset the line length
- LineLength = 0;
- NameCounter = 0;
- }
- fprintf( pFile, " %s", Abc_ObjName(pNet) );
- LineLength += AddedLength;
- NameCounter++;
- }
- }
- }
- /**Function*************************************************************
- Synopsis [Write the latch into a file.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_NtkWriteSubckt( FILE * pFile, Abc_Obj_t * pNode )
- {
- Abc_Ntk_t * pModel = (Abc_Ntk_t *)pNode->pData;
- Abc_Obj_t * pTerm;
- int i;
- // write the subcircuit
- // fprintf( pFile, ".subckt %s %s", Abc_NtkName(pModel), Abc_ObjName(pNode) );
- fprintf( pFile, ".subckt %s", Abc_NtkName(pModel) );
- // write pairs of the formal=actual names
- Abc_NtkForEachPi( pModel, pTerm, i )
- {
- fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanout0(pTerm)) );
- pTerm = Abc_ObjFanin( pNode, i );
- fprintf( pFile, "=%s", Abc_ObjName(Abc_ObjFanin0(pTerm)) );
- }
- Abc_NtkForEachPo( pModel, pTerm, i )
- {
- fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin0(pTerm)) );
- pTerm = Abc_ObjFanout( pNode, i );
- fprintf( pFile, "=%s", Abc_ObjName(Abc_ObjFanout0(pTerm)) );
- }
- fprintf( pFile, "\n" );
- }
- /**Function*************************************************************
- Synopsis [Write the latch into a file.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_NtkWriteLatch( FILE * pFile, Abc_Obj_t * pLatch )
- {
- Abc_Obj_t * pNetLi, * pNetLo;
- int Reset;
- pNetLi = Abc_ObjFanin0( Abc_ObjFanin0(pLatch) );
- pNetLo = Abc_ObjFanout0( Abc_ObjFanout0(pLatch) );
- Reset = (int)(ABC_PTRUINT_T)Abc_ObjData( pLatch );
- // write the latch line
- fprintf( pFile, ".latch" );
- fprintf( pFile, " %10s", Abc_ObjName(pNetLi) );
- fprintf( pFile, " %10s", Abc_ObjName(pNetLo) );
- fprintf( pFile, " %d\n", Reset-1 );
- }
-
- /**Function*************************************************************
-
- Synopsis [Writes the primary input list.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
- ***********************************************************************/
- void Io_NtkWriteNodeFanins( FILE * pFile, Abc_Obj_t * pNode )
- {
- Abc_Obj_t * pNet;
- int LineLength;
- int AddedLength;
- int NameCounter;
- char * pName;
- int i;
-
- LineLength = 6;
- NameCounter = 0;
- Abc_ObjForEachFanin( pNode, pNet, i )
- {
- // get the fanin name
- pName = Abc_ObjName(pNet);
- // get the line length after the fanin name is written
- AddedLength = strlen(pName) + 1;
- if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
- { // write the line extender
- fprintf( pFile, " \\\n" );
- // reset the line length
- LineLength = 0;
- NameCounter = 0;
- }
- fprintf( pFile, " %s", pName );
- LineLength += AddedLength;
- NameCounter++;
- }
-
- // get the output name
- pName = Abc_ObjName(Abc_ObjFanout0(pNode));
- // get the line length after the output name is written
- AddedLength = strlen(pName) + 1;
- if ( NameCounter && LineLength + AddedLength > 75 )
- { // write the line extender
- fprintf( pFile, " \\\n" );
- // reset the line length
- LineLength = 0;
- NameCounter = 0;
- }
- fprintf( pFile, " %s", pName );
- }
-
- /**Function*************************************************************
-
- Synopsis [Writes the primary input list.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
- ***********************************************************************/
- void Io_NtkWriteSubcktFanins( FILE * pFile, Abc_Obj_t * pNode )
- {
- Abc_Obj_t * pNet;
- int LineLength;
- int AddedLength;
- int NameCounter;
- char * pName;
- int i;
-
- LineLength = 6;
- NameCounter = 0;
-
- // get the output name
- pName = Abc_ObjName(Abc_ObjFanout0(pNode));
- // get the line length after the output name is written
- AddedLength = strlen(pName) + 1;
- fprintf( pFile, " m%d", Abc_ObjId(pNode) );
-
- // get the input names
- Abc_ObjForEachFanin( pNode, pNet, i )
- {
- // get the fanin name
- pName = Abc_ObjName(pNet);
- // get the line length after the fanin name is written
- AddedLength = strlen(pName) + 3;
- if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
- { // write the line extender
- fprintf( pFile, " \\\n" );
- // reset the line length
- LineLength = 0;
- NameCounter = 0;
- }
- fprintf( pFile, " %c=%s", 'a'+i, pName );
- LineLength += AddedLength;
- NameCounter++;
- }
-
- // get the output name
- pName = Abc_ObjName(Abc_ObjFanout0(pNode));
- // get the line length after the output name is written
- AddedLength = strlen(pName) + 3;
- if ( NameCounter && LineLength + AddedLength > 75 )
- { // write the line extender
- fprintf( pFile, " \\\n" );
- // reset the line length
- LineLength = 0;
- NameCounter = 0;
- }
- fprintf( pFile, " %c=%s", 'o', pName );
- }
-
-
- /**Function*************************************************************
-
- Synopsis [Writes the primary input list.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
- ***********************************************************************/
- int Io_NtkWriteNodeGate( FILE * pFile, Abc_Obj_t * pNode, int Length )
- {
- static int fReport = 0;
- Mio_Gate_t * pGate = (Mio_Gate_t *)pNode->pData;
- Mio_Pin_t * pGatePin;
- Abc_Obj_t * pNode2;
- int i;
- fprintf( pFile, " %-*s ", Length, Mio_GateReadName(pGate) );
- for ( pGatePin = Mio_GateReadPins(pGate), i = 0; pGatePin; pGatePin = Mio_PinReadNext(pGatePin), i++ )
- fprintf( pFile, "%s=%s ", Mio_PinReadName(pGatePin), Abc_ObjName( Abc_ObjFanin(pNode,i) ) );
- assert ( i == Abc_ObjFaninNum(pNode) );
- fprintf( pFile, "%s=%s", Mio_GateReadOutName(pGate), Abc_ObjName( Abc_ObjFanout0(pNode) ) );
- if ( Mio_GateReadTwin(pGate) == NULL )
- return 0;
- pNode2 = Abc_NtkFetchTwinNode( pNode );
- if ( pNode2 == NULL )
- {
- if ( !fReport )
- fReport = 1, printf( "Warning: Missing second output of gate(s) \"%s\".\n", Mio_GateReadName(pGate) );
- return 0;
- }
- fprintf( pFile, " %s=%s", Mio_GateReadOutName((Mio_Gate_t *)pNode2->pData), Abc_ObjName( Abc_ObjFanout0(pNode2) ) );
- return 1;
- }
- /**Function*************************************************************
- Synopsis [Write the node into a file.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- int Io_NtkWriteNode( FILE * pFile, Abc_Obj_t * pNode, int Length )
- {
- int RetValue = 0;
- if ( Abc_NtkHasMapping(pNode->pNtk) )
- {
- // write the .gate line
- if ( Abc_ObjIsBarBuf(pNode) )
- {
- fprintf( pFile, ".barbuf " );
- fprintf( pFile, "%s %s", Abc_ObjName(Abc_ObjFanin0(pNode)), Abc_ObjName(Abc_ObjFanout0(pNode)) );
- fprintf( pFile, "\n" );
- }
- else
- {
- fprintf( pFile, ".gate" );
- RetValue = Io_NtkWriteNodeGate( pFile, pNode, Length );
- fprintf( pFile, "\n" );
- }
- }
- else
- {
- // write the .names line
- fprintf( pFile, ".names" );
- Io_NtkWriteNodeFanins( pFile, pNode );
- fprintf( pFile, "\n" );
- // write the cubes
- fprintf( pFile, "%s", (char*)Abc_ObjData(pNode) );
- }
- return RetValue;
- }
-
- /**Function*************************************************************
-
- Synopsis [Write the node into a file.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
- ***********************************************************************/
- int Io_NtkWriteNodeSubckt( FILE * pFile, Abc_Obj_t * pNode, int Length )
- {
- int RetValue = 0;
- fprintf( pFile, ".subckt" );
- Io_NtkWriteSubcktFanins( pFile, pNode );
- fprintf( pFile, "\n" );
- return RetValue;
- }
- /**Function*************************************************************
- Synopsis [Writes the timing info.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_WriteTimingInfo( FILE * pFile, Abc_Ntk_t * pNtk )
- {
- Abc_Obj_t * pNode;
- Abc_Time_t * pTime, * pTimeDefIn, * pTimeDefOut;
- int i;
- if ( pNtk->pManTime == NULL )
- return;
- fprintf( pFile, "\n" );
- if ( pNtk->AndGateDelay != 0.0 )
- fprintf( pFile, ".and_gate_delay %g\n", pNtk->AndGateDelay );
- pTimeDefIn = Abc_NtkReadDefaultArrival( pNtk );
- //if ( pTimeDefIn->Rise != 0.0 || pTimeDefIn->Fall != 0.0 )
- fprintf( pFile, ".default_input_arrival %g %g\n", pTimeDefIn->Rise, pTimeDefIn->Fall );
- pTimeDefOut = Abc_NtkReadDefaultRequired( pNtk );
- //if ( pTimeDefOut->Rise != ABC_INFINITY || pTimeDefOut->Fall != ABC_INFINITY )
- fprintf( pFile, ".default_output_required %g %g\n", pTimeDefOut->Rise, pTimeDefOut->Fall );
-
- fprintf( pFile, "\n" );
- Abc_NtkForEachPi( pNtk, pNode, i )
- {
- pTime = Abc_NodeReadArrival(pNode);
- if ( pTime->Rise == pTimeDefIn->Rise && pTime->Fall == pTimeDefIn->Fall )
- continue;
- fprintf( pFile, ".input_arrival %s %g %g\n", Abc_ObjName(Abc_ObjFanout0(pNode)), pTime->Rise, pTime->Fall );
- }
- Abc_NtkForEachPo( pNtk, pNode, i )
- {
- pTime = Abc_NodeReadRequired(pNode);
- if ( pTime->Rise == pTimeDefOut->Rise && pTime->Fall == pTimeDefOut->Fall )
- continue;
- fprintf( pFile, ".output_required %s %g %g\n", Abc_ObjName(Abc_ObjFanin0(pNode)), pTime->Rise, pTime->Fall );
- }
-
- fprintf( pFile, "\n" );
- pTimeDefIn = Abc_NtkReadDefaultInputDrive( pNtk );
- if ( pTimeDefIn->Rise != 0.0 || pTimeDefIn->Fall != 0.0 )
- fprintf( pFile, ".default_input_drive %g %g\n", pTimeDefIn->Rise, pTimeDefIn->Fall );
- if ( Abc_NodeReadInputDrive( pNtk, 0 ) )
- Abc_NtkForEachPi( pNtk, pNode, i )
- {
- pTime = Abc_NodeReadInputDrive( pNtk, i );
- if ( pTime->Rise == pTimeDefIn->Rise && pTime->Fall == pTimeDefIn->Fall )
- continue;
- fprintf( pFile, ".input_drive %s %g %g\n", Abc_ObjName(Abc_ObjFanout0(pNode)), pTime->Rise, pTime->Fall );
- }
-
- pTimeDefOut = Abc_NtkReadDefaultOutputLoad( pNtk );
- if ( pTimeDefOut->Rise != 0.0 || pTimeDefOut->Fall != 0.0 )
- fprintf( pFile, ".default_output_load %g %g\n", pTimeDefOut->Rise, pTimeDefOut->Fall );
- if ( Abc_NodeReadOutputLoad( pNtk, 0 ) )
- Abc_NtkForEachPo( pNtk, pNode, i )
- {
- pTime = Abc_NodeReadOutputLoad( pNtk, i );
- if ( pTime->Rise == pTimeDefOut->Rise && pTime->Fall == pTimeDefOut->Fall )
- continue;
- fprintf( pFile, ".output_load %s %g %g\n", Abc_ObjName(Abc_ObjFanin0(pNode)), pTime->Rise, pTime->Fall );
- }
-
- fprintf( pFile, "\n" );
- }
- /**Function*************************************************************
- Synopsis []
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Abc_NtkConvertBb2Wb( char * pFileNameIn, char * pFileNameOut, int fSeq, int fVerbose )
- {
- FILE * pFile;
- Abc_Ntk_t * pNetlist;
- // check the files
- pFile = fopen( pFileNameIn, "rb" );
- if ( pFile == NULL )
- {
- printf( "Input file \"%s\" cannot be opened.\n", pFileNameIn );
- return;
- }
- fclose( pFile );
- // check the files
- pFile = fopen( pFileNameOut, "wb" );
- if ( pFile == NULL )
- {
- printf( "Output file \"%s\" cannot be opened.\n", pFileNameOut );
- return;
- }
- fclose( pFile );
- // derive AIG for signal correspondence
- pNetlist = Io_ReadNetlist( pFileNameIn, Io_ReadFileType(pFileNameIn), 1 );
- if ( pNetlist == NULL )
- {
- printf( "Reading input file \"%s\" has failed.\n", pFileNameIn );
- return;
- }
- Io_WriteBlif( pNetlist, pFileNameOut, 1, 1, fSeq );
- Abc_NtkDelete( pNetlist );
- }
- /**Function*************************************************************
- Synopsis [Transforms truth table into an SOP.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- char * Io_NtkDeriveSop( Mem_Flex_t * pMem, word uTruth, int nVars, Vec_Int_t * vCover )
- {
- char * pSop;
- int RetValue = Kit_TruthIsop( (unsigned *)&uTruth, nVars, vCover, 1 );
- assert( RetValue == 0 || RetValue == 1 );
- // check the case of constant cover
- if ( Vec_IntSize(vCover) == 0 || (Vec_IntSize(vCover) == 1 && Vec_IntEntry(vCover,0) == 0) )
- {
- char * pStr0 = " 0\n", * pStr1 = " 1\n";
- assert( RetValue == 0 );
- return Vec_IntSize(vCover) == 0 ? pStr0 : pStr1;
- }
- // derive the AIG for that tree
- pSop = Abc_SopCreateFromIsop( pMem, nVars, vCover );
- if ( RetValue )
- Abc_SopComplement( pSop );
- return pSop;
- }
- /**Function*************************************************************
- Synopsis [Write the node into a file.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_NtkWriteNodeInt( FILE * pFile, Abc_Obj_t * pNode, Vec_Int_t * vCover )
- {
- Abc_Obj_t * pNet;
- int i, nVars = Abc_ObjFaninNum(pNode);
- if ( nVars > 7 )
- {
- printf( "Node \"%s\" has more than 7 inputs. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- return;
- }
- fprintf( pFile, "\n" );
- if ( nVars <= 4 )
- {
- // write the .names line
- fprintf( pFile, ".names" );
- Abc_ObjForEachFanin( pNode, pNet, i )
- fprintf( pFile, " %s", Abc_ObjName(pNet) );
- // get the output name
- fprintf( pFile, " %s\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- // write the cubes
- fprintf( pFile, "%s", (char*)Abc_ObjData(pNode) );
- }
- else
- {
- extern int If_Dec6PickBestMux( word t, word Cofs[2] );
- extern int If_Dec7PickBestMux( word t[2], word c0r[2], word c1r[2] );
- extern word If_Dec6MinimumBase( word uTruth, int * pSupp, int nVarsAll, int * pnVars );
- extern void If_Dec7MinimumBase( word uTruth[2], int * pSupp, int nVarsAll, int * pnVars );
- extern word If_Dec6Perform( word t, int fDerive );
- extern word If_Dec7Perform( word t[2], int fDerive );
- char * pSop;
- word z, uTruth6 = 0, uTruth7[2], Cofs6[2], Cofs7[2][2];
- int c, iVar, nVarsMin[2], pVars[2][10];
- // collect variables
- Abc_ObjForEachFanin( pNode, pNet, i )
- pVars[0][i] = pVars[1][i] = i;
- // derive truth table
- if ( nVars == 7 )
- {
- Abc_SopToTruth7( (char*)Abc_ObjData(pNode), nVars, uTruth7 );
- iVar = If_Dec7PickBestMux( uTruth7, Cofs7[0], Cofs7[1] );
- }
- else
- {
- uTruth6 = Abc_SopToTruth( (char*)Abc_ObjData(pNode), nVars );
- iVar = If_Dec6PickBestMux( uTruth6, Cofs6 );
- }
- // perform MUX decomposition
- if ( iVar >= 0 )
- {
- if ( nVars == 7 )
- {
- If_Dec7MinimumBase( Cofs7[0], pVars[0], nVars, &nVarsMin[0] );
- If_Dec7MinimumBase( Cofs7[1], pVars[1], nVars, &nVarsMin[1] );
- }
- else
- {
- Cofs6[0] = If_Dec6MinimumBase( Cofs6[0], pVars[0], nVars, &nVarsMin[0] );
- Cofs6[1] = If_Dec6MinimumBase( Cofs6[1], pVars[1], nVars, &nVarsMin[1] );
- }
- assert( nVarsMin[0] < 5 );
- assert( nVarsMin[1] < 5 );
- // write MUX
- fprintf( pFile, ".names" );
- fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,iVar)) );
- fprintf( pFile, " %s_cascade0", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- fprintf( pFile, " %s_cascade1", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- fprintf( pFile, " %s\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- fprintf( pFile, "1-1 1\n01- 1\n" );
- // write cofactors
- for ( c = 0; c < 2; c++ )
- {
- pSop = Io_NtkDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc,
- (word)(nVars == 7 ? Cofs7[c][0] : Cofs6[c]), nVarsMin[c], vCover );
- fprintf( pFile, ".names" );
- for ( i = 0; i < nVarsMin[c]; i++ )
- fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,pVars[c][i])) );
- fprintf( pFile, " %s_cascade%d\n", Abc_ObjName(Abc_ObjFanout0(pNode)), c );
- fprintf( pFile, "%s", pSop );
- }
- return;
- }
- assert( nVars == 6 || nVars == 7 );
- // try cascade decomposition
- if ( nVars == 7 )
- {
- z = If_Dec7Perform( uTruth7, 1 );
- //If_Dec7Verify( uTruth7, z );
- }
- else
- {
- z = If_Dec6Perform( uTruth6, 1 );
- //If_Dec6Verify( uTruth6, z );
- }
- if ( z == 0 )
- {
- printf( "Node \"%s\" is not decomposable. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- return;
- }
- // derive nodes
- for ( c = 1; c >= 0; c-- )
- {
- // collect fanins
- uTruth7[c] = ((c ? z >> 32 : z) & 0xffff);
- uTruth7[c] |= (uTruth7[c] << 16);
- uTruth7[c] |= (uTruth7[c] << 32);
- for ( i = 0; i < 4; i++ )
- pVars[c][i] = (z >> (c*32+16+4*i)) & 7;
- // minimize truth table
- Cofs6[c] = If_Dec6MinimumBase( uTruth7[c], pVars[c], 4, &nVarsMin[c] );
- // write the nodes
- fprintf( pFile, ".names" );
- for ( i = 0; i < nVarsMin[c]; i++ )
- if ( pVars[c][i] == 7 )
- fprintf( pFile, " %s_cascade", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- else
- fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,pVars[c][i])) );
- fprintf( pFile, " %s%s\n", Abc_ObjName(Abc_ObjFanout0(pNode)), c? "" : "_cascade" );
- // write SOP
- pSop = Io_NtkDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc,
- (word)Cofs6[c], nVarsMin[c], vCover );
- fprintf( pFile, "%s", pSop );
- }
- }
- }
- /**Function*************************************************************
- Synopsis [Write the node into a file.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_NtkWriteNodeIntStruct( FILE * pFile, Abc_Obj_t * pNode, Vec_Int_t * vCover, char * pStr )
- {
- Abc_Obj_t * pNet;
- int nLeaves = Abc_ObjFaninNum(pNode);
- int i, nLutLeaf, nLutLeaf2, nLutRoot, Length;
- // quit if parameters are wrong
- Length = strlen(pStr);
- if ( Length != 2 && Length != 3 )
- {
- printf( "Wrong LUT struct (%s)\n", pStr );
- return;
- }
- for ( i = 0; i < Length; i++ )
- if ( pStr[i] - '0' < 3 || pStr[i] - '0' > 6 )
- {
- printf( "The LUT size (%d) should belong to {3,4,5,6}.\n", pStr[i] - '0' );
- return;
- }
- nLutLeaf = pStr[0] - '0';
- nLutLeaf2 = ( Length == 3 ) ? pStr[1] - '0' : 0;
- nLutRoot = pStr[Length-1] - '0';
- if ( nLeaves > nLutLeaf - 1 + (nLutLeaf2 ? nLutLeaf2 - 1 : 0) + nLutRoot )
- {
- printf( "The node size (%d) is too large for the LUT structure %s.\n", nLeaves, pStr );
- return;
- }
- // consider easy case
- fprintf( pFile, "\n" );
- if ( nLeaves <= Abc_MaxInt( nLutLeaf2, Abc_MaxInt(nLutLeaf, nLutRoot) ) )
- {
- // write the .names line
- fprintf( pFile, ".names" );
- Abc_ObjForEachFanin( pNode, pNet, i )
- fprintf( pFile, " %s", Abc_ObjName(pNet) );
- // get the output name
- fprintf( pFile, " %s\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- // write the cubes
- fprintf( pFile, "%s", (char*)Abc_ObjData(pNode) );
- return;
- }
- else
- {
- extern int If_CluMinimumBase( word * t, int * pSupp, int nVarsAll, int * pnVars );
- static word TruthStore[16][1<<10] = {{0}}, * pTruths[16];
- word pCube[1<<10], pRes[1<<10], Func0, Func1, Func2;
- char pLut0[32], pLut1[32], pLut2[32] = {0}, * pSop;
- // int nVarsMin[3], pVars[3][20];
- if ( TruthStore[0][0] == 0 )
- {
- static word Truth6[6] = {
- ABC_CONST(0xAAAAAAAAAAAAAAAA),
- ABC_CONST(0xCCCCCCCCCCCCCCCC),
- ABC_CONST(0xF0F0F0F0F0F0F0F0),
- ABC_CONST(0xFF00FF00FF00FF00),
- ABC_CONST(0xFFFF0000FFFF0000),
- ABC_CONST(0xFFFFFFFF00000000)
- };
- int nVarsMax = 16;
- int nWordsMax = (1 << 10);
- int i, k;
- assert( nVarsMax <= 16 );
- for ( i = 0; i < nVarsMax; i++ )
- pTruths[i] = TruthStore[i];
- for ( i = 0; i < 6; i++ )
- for ( k = 0; k < nWordsMax; k++ )
- pTruths[i][k] = Truth6[i];
- for ( i = 6; i < nVarsMax; i++ )
- for ( k = 0; k < nWordsMax; k++ )
- pTruths[i][k] = ((k >> (i-6)) & 1) ? ~(word)0 : 0;
- }
- // collect variables
- // Abc_ObjForEachFanin( pNode, pNet, i )
- // pVars[0][i] = pVars[1][i] = pVars[2][i] = i;
- // derive truth table
- Abc_SopToTruthBig( (char*)Abc_ObjData(pNode), nLeaves, pTruths, pCube, pRes );
- if ( Kit_TruthIsConst0((unsigned *)pRes, nLeaves) || Kit_TruthIsConst1((unsigned *)pRes, nLeaves) )
- {
- fprintf( pFile, ".names %s\n %d\n", Abc_ObjName(Abc_ObjFanout0(pNode)), Kit_TruthIsConst1((unsigned *)pRes, nLeaves) );
- return;
- }
- // Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
- // Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
- // perform decomposition
- if ( Length == 2 )
- {
- if ( !If_CluCheckExt( NULL, pRes, nLeaves, nLutLeaf, nLutRoot, pLut0, pLut1, &Func0, &Func1 ) )
- {
- Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
- Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
- printf( "Node \"%s\" is not decomposable. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- return;
- }
- }
- else
- {
- if ( !If_CluCheckExt3( NULL, pRes, nLeaves, nLutLeaf, nLutLeaf2, nLutRoot, pLut0, pLut1, pLut2, &Func0, &Func1, &Func2 ) )
- {
- Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
- Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
- printf( "Node \"%s\" is not decomposable. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- return;
- }
- }
- // write leaf node
- fprintf( pFile, ".names" );
- for ( i = 0; i < pLut1[0]; i++ )
- fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,pLut1[2+i])) );
- fprintf( pFile, " %s_lut1\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- // write SOP
- pSop = Io_NtkDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func1, pLut1[0], vCover );
- fprintf( pFile, "%s", pSop );
- if ( Length == 3 && pLut2[0] > 0 )
- {
- // write leaf node
- fprintf( pFile, ".names" );
- for ( i = 0; i < pLut2[0]; i++ )
- if ( pLut2[2+i] == nLeaves )
- fprintf( pFile, " %s_lut1", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- else
- fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,pLut2[2+i])) );
- fprintf( pFile, " %s_lut2\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- // write SOP
- pSop = Io_NtkDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func2, pLut2[0], vCover );
- fprintf( pFile, "%s", pSop );
- }
- // write root node
- fprintf( pFile, ".names" );
- for ( i = 0; i < pLut0[0]; i++ )
- if ( pLut0[2+i] == nLeaves )
- fprintf( pFile, " %s_lut1", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- else if ( pLut0[2+i] == nLeaves+1 )
- fprintf( pFile, " %s_lut2", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- else
- fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin(pNode,pLut0[2+i])) );
- fprintf( pFile, " %s\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- // write SOP
- pSop = Io_NtkDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func0, pLut0[0], vCover );
- fprintf( pFile, "%s", pSop );
- }
- }
-
- /**Function*************************************************************
-
- Synopsis [Write the node into a file.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
- ***********************************************************************/
- void Io_NtkWriteModelIntStruct( FILE * pFile, Abc_Obj_t * pNode, Vec_Int_t * vCover, char * pStr )
- {
- Abc_Obj_t * pNet;
- int nLeaves = Abc_ObjFaninNum(pNode);
- int i, nLutLeaf, nLutLeaf2, nLutRoot, Length;
-
- // write the header
- fprintf( pFile, "\n" );
- fprintf( pFile, ".model m%d\n", Abc_ObjId(pNode) );
- fprintf( pFile, ".inputs" );
- for ( i = 0; i < Abc_ObjFaninNum(pNode); i++ )
- fprintf( pFile, " %c", 'a' + i );
- fprintf( pFile, "\n" );
- fprintf( pFile, ".outputs o\n" );
-
- // quit if parameters are wrong
- Length = strlen(pStr);
- if ( Length != 2 && Length != 3 )
- {
- printf( "Wrong LUT struct (%s)\n", pStr );
- return;
- }
- for ( i = 0; i < Length; i++ )
- if ( pStr[i] - '0' < 3 || pStr[i] - '0' > 6 )
- {
- printf( "The LUT size (%d) should belong to {3,4,5,6}.\n", pStr[i] - '0' );
- return;
- }
-
- nLutLeaf = pStr[0] - '0';
- nLutLeaf2 = ( Length == 3 ) ? pStr[1] - '0' : 0;
- nLutRoot = pStr[Length-1] - '0';
- if ( nLeaves > nLutLeaf - 1 + (nLutLeaf2 ? nLutLeaf2 - 1 : 0) + nLutRoot )
- {
- printf( "The node size (%d) is too large for the LUT structure %s.\n", nLeaves, pStr );
- return;
- }
-
- // consider easy case
- if ( nLeaves <= Abc_MaxInt( nLutLeaf2, Abc_MaxInt(nLutLeaf, nLutRoot) ) )
- {
- // write the .names line
- fprintf( pFile, ".names" );
- Abc_ObjForEachFanin( pNode, pNet, i )
- fprintf( pFile, " %c", 'a' + i );
- // get the output name
- fprintf( pFile, " %s\n", "o" );
- // write the cubes
- fprintf( pFile, "%s", (char*)Abc_ObjData(pNode) );
- fprintf( pFile, ".end\n" );
- return;
- }
- else
- {
- extern int If_CluMinimumBase( word * t, int * pSupp, int nVarsAll, int * pnVars );
-
- static word TruthStore[16][1<<10] = {{0}}, * pTruths[16];
- word pCube[1<<10], pRes[1<<10], Func0, Func1, Func2;
- char pLut0[32], pLut1[32], pLut2[32] = {0}, * pSop;
- // int nVarsMin[3], pVars[3][20];
-
- if ( TruthStore[0][0] == 0 )
- {
- static word Truth6[6] = {
- ABC_CONST(0xAAAAAAAAAAAAAAAA),
- ABC_CONST(0xCCCCCCCCCCCCCCCC),
- ABC_CONST(0xF0F0F0F0F0F0F0F0),
- ABC_CONST(0xFF00FF00FF00FF00),
- ABC_CONST(0xFFFF0000FFFF0000),
- ABC_CONST(0xFFFFFFFF00000000)
- };
- int nVarsMax = 16;
- int nWordsMax = (1 << 10);
- int i, k;
- assert( nVarsMax <= 16 );
- for ( i = 0; i < nVarsMax; i++ )
- pTruths[i] = TruthStore[i];
- for ( i = 0; i < 6; i++ )
- for ( k = 0; k < nWordsMax; k++ )
- pTruths[i][k] = Truth6[i];
- for ( i = 6; i < nVarsMax; i++ )
- for ( k = 0; k < nWordsMax; k++ )
- pTruths[i][k] = ((k >> (i-6)) & 1) ? ~(word)0 : 0;
- }
-
- // collect variables
- // Abc_ObjForEachFanin( pNode, pNet, i )
- // pVars[0][i] = pVars[1][i] = pVars[2][i] = i;
-
- // derive truth table
- Abc_SopToTruthBig( (char*)Abc_ObjData(pNode), nLeaves, pTruths, pCube, pRes );
- if ( Kit_TruthIsConst0((unsigned *)pRes, nLeaves) || Kit_TruthIsConst1((unsigned *)pRes, nLeaves) )
- {
- fprintf( pFile, ".names %s\n %d\n", "o", Kit_TruthIsConst1((unsigned *)pRes, nLeaves) );
- fprintf( pFile, ".end\n" );
- return;
- }
-
- // Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
- // Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
-
- // perform decomposition
- if ( Length == 2 )
- {
- if ( !If_CluCheckExt( NULL, pRes, nLeaves, nLutLeaf, nLutRoot, pLut0, pLut1, &Func0, &Func1 ) )
- {
- Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
- Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
- printf( "Node \"%s\" is not decomposable. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- return;
- }
- }
- else
- {
- if ( !If_CluCheckExt3( NULL, pRes, nLeaves, nLutLeaf, nLutLeaf2, nLutRoot, pLut0, pLut1, pLut2, &Func0, &Func1, &Func2 ) )
- {
- Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " );
- Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" );
- printf( "Node \"%s\" is not decomposable. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) );
- return;
- }
- }
-
- // write leaf node
- fprintf( pFile, ".names" );
- for ( i = 0; i < pLut1[0]; i++ )
- fprintf( pFile, " %c", 'a' + pLut1[2+i] );
- fprintf( pFile, " lut1\n" );
- // write SOP
- pSop = Io_NtkDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func1, pLut1[0], vCover );
- fprintf( pFile, "%s", pSop );
-
- if ( Length == 3 && pLut2[0] > 0 )
- {
- // write leaf node
- fprintf( pFile, ".names" );
- for ( i = 0; i < pLut2[0]; i++ )
- if ( pLut2[2+i] == nLeaves )
- fprintf( pFile, " lut1" );
- else
- fprintf( pFile, " %c", 'a' + pLut2[2+i] );
- fprintf( pFile, " lut2\n" );
- // write SOP
- pSop = Io_NtkDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func2, pLut2[0], vCover );
- fprintf( pFile, "%s", pSop );
- }
-
- // write root node
- fprintf( pFile, ".names" );
- for ( i = 0; i < pLut0[0]; i++ )
- if ( pLut0[2+i] == nLeaves )
- fprintf( pFile, " lut1" );
- else if ( pLut0[2+i] == nLeaves+1 )
- fprintf( pFile, " lut2" );
- else
- fprintf( pFile, " %c", 'a' + pLut0[2+i] );
- fprintf( pFile, " %s\n", "o" );
- // write SOP
- pSop = Io_NtkDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func0, pLut0[0], vCover );
- fprintf( pFile, "%s", pSop );
- fprintf( pFile, ".end\n" );
- }
- }
-
- /**Function*************************************************************
- Synopsis [Write the network into a BLIF file with the given name.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Io_WriteBlifInt( Abc_Ntk_t * pNtk, char * FileName, char * pLutStruct, int fUseHie )
- {
- FILE * pFile;
- Vec_Int_t * vCover;
- Abc_Obj_t * pNode, * pLatch;
- int i;
- assert( Abc_NtkIsNetlist(pNtk) );
- // start writing the file
- pFile = fopen( FileName, "w" );
- if ( pFile == NULL )
- {
- fprintf( stdout, "Io_WriteBlifInt(): Cannot open the output file.\n" );
- return;
- }
- fprintf( pFile, "# Benchmark \"%s\" written by ABC on %s\n", pNtk->pName, Extra_TimeStamp() );
- // write the model name
- fprintf( pFile, ".model %s\n", Abc_NtkName(pNtk) );
- // write the PIs
- fprintf( pFile, ".inputs" );
- Io_NtkWritePis( pFile, pNtk, 1 );
- fprintf( pFile, "\n" );
- // write the POs
- fprintf( pFile, ".outputs" );
- Io_NtkWritePos( pFile, pNtk, 1 );
- fprintf( pFile, "\n" );
- // write the latches
- if ( Abc_NtkLatchNum(pNtk) )
- fprintf( pFile, "\n" );
- Abc_NtkForEachLatch( pNtk, pLatch, i )
- Io_NtkWriteLatch( pFile, pLatch );
- if ( Abc_NtkLatchNum(pNtk) )
- fprintf( pFile, "\n" );
- // write the hierarchy
- vCover = Vec_IntAlloc( (1<<16) );
- if ( fUseHie )
- {
- // write each internal node
- fprintf( pFile, "\n" );
- Abc_NtkForEachNode( pNtk, pNode, i )
- Io_NtkWriteNodeSubckt( pFile, pNode, 0 );
- fprintf( pFile, ".end\n\n" );
- // write models
- Abc_NtkForEachNode( pNtk, pNode, i )
- Io_NtkWriteModelIntStruct( pFile, pNode, vCover, pLutStruct );
- fprintf( pFile, "\n" );
- }
- else
- {
- // write each internal node
- Abc_NtkForEachNode( pNtk, pNode, i )
- {
- if ( pLutStruct )
- Io_NtkWriteNodeIntStruct( pFile, pNode, vCover, pLutStruct );
- else
- Io_NtkWriteNodeInt( pFile, pNode, vCover );
- }
- fprintf( pFile, ".end\n\n" );
- }
- Vec_IntFree( vCover );
- fclose( pFile );
- }
-
- /**Function*************************************************************
-
- Synopsis [Write the network into a BLIF file with the given name.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
- ***********************************************************************/
- void Io_WriteBlifSpecial( Abc_Ntk_t * pNtk, char * FileName, char * pLutStruct, int fUseHie )
- {
- Abc_Ntk_t * pNtkTemp;
- assert( Abc_NtkIsLogic(pNtk) );
- Abc_NtkToSop( pNtk, -1, ABC_INFINITY );
- // derive the netlist
- pNtkTemp = Abc_NtkToNetlist(pNtk);
- if ( pNtkTemp == NULL )
- {
- fprintf( stdout, "Writing BLIF has failed.\n" );
- return;
- }
- if ( pLutStruct && fUseHie )
- Io_WriteBlifInt( pNtkTemp, FileName, pLutStruct, 1 );
- else
- Io_WriteBlifInt( pNtkTemp, FileName, pLutStruct, 0 );
- Abc_NtkDelete( pNtkTemp );
- }
- ////////////////////////////////////////////////////////////////////////
- /// END OF FILE ///
- ////////////////////////////////////////////////////////////////////////
- ABC_NAMESPACE_IMPL_END