| /**CFile**************************************************************** |
| |
| FileName [sclLiberty.c] |
| |
| SystemName [ABC: Logic synthesis and verification system.] |
| |
| PackageName [Standard-cell library representation.] |
| |
| Synopsis [Liberty parser.] |
| |
| Author [Alan Mishchenko, Niklas Een] |
| |
| Affiliation [UC Berkeley] |
| |
| Date [Ver. 1.0. Started - August 24, 2012.] |
| |
| Revision [$Id: sclLiberty.c,v 1.0 2012/08/24 00:00:00 alanmi Exp $] |
| |
| ***********************************************************************/ |
| |
| #include "sclLib.h" |
| #include "misc/st/st.h" |
| #include "map/mio/mio.h" |
| |
| ABC_NAMESPACE_IMPL_START |
| |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// DECLARATIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| #define ABC_MAX_LIB_STR_LEN 5000 |
| |
| // entry types |
| typedef enum { |
| SCL_LIBERTY_NONE = 0, // 0: unknown |
| SCL_LIBERTY_PROC, // 1: procedure : key(head){body} |
| SCL_LIBERTY_EQUA, // 2: equation : key:head; |
| SCL_LIBERTY_LIST // 3: list : key(head) |
| } Scl_LibertyType_t; |
| |
| typedef struct Scl_Pair_t_ Scl_Pair_t; |
| struct Scl_Pair_t_ |
| { |
| int Beg; // item beginning |
| int End; // item end |
| }; |
| |
| typedef struct Scl_Item_t_ Scl_Item_t; |
| struct Scl_Item_t_ |
| { |
| int Type; // Scl_LibertyType_t |
| int iLine; // file line where the item's spec begins |
| Scl_Pair_t Key; // key part |
| Scl_Pair_t Head; // head part |
| Scl_Pair_t Body; // body part |
| int Next; // next item in the list |
| int Child; // first child item |
| }; |
| |
| typedef struct Scl_Tree_t_ Scl_Tree_t; |
| struct Scl_Tree_t_ |
| { |
| char * pFileName; // input Liberty file name |
| char * pContents; // file contents |
| int nContents; // file size |
| int nLines; // line counter |
| int nItems; // number of items |
| int nItermAlloc; // number of items allocated |
| Scl_Item_t * pItems; // the items |
| char * pError; // the error string |
| abctime clkStart; // beginning time |
| }; |
| |
| static inline Scl_Item_t * Scl_LibertyRoot( Scl_Tree_t * p ) { return p->pItems; } |
| static inline Scl_Item_t * Scl_LibertyItem( Scl_Tree_t * p, int v ) { assert( v < p->nItems ); return v < 0 ? NULL : p->pItems + v; } |
| static inline int Scl_LibertyCompare( Scl_Tree_t * p, Scl_Pair_t Pair, char * pStr ) { return strncmp( p->pContents+Pair.Beg, pStr, Pair.End-Pair.Beg ) || ((int)strlen(pStr) != Pair.End-Pair.Beg); } |
| static inline void Scl_PrintWord( FILE * pFile, Scl_Tree_t * p, Scl_Pair_t Pair ) { char * pBeg = p->pContents+Pair.Beg, * pEnd = p->pContents+Pair.End; while ( pBeg < pEnd ) fputc( *pBeg++, pFile ); } |
| static inline void Scl_PrintSpace( FILE * pFile, int nOffset ) { int i; for ( i = 0; i < nOffset; i++ ) fputc(' ', pFile); } |
| static inline int Scl_LibertyItemId( Scl_Tree_t * p, Scl_Item_t * pItem ) { return pItem - p->pItems; } |
| |
| #define Scl_ItemForEachChild( p, pItem, pChild ) \ |
| for ( pChild = Scl_LibertyItem(p, pItem->Child); pChild; pChild = Scl_LibertyItem(p, pChild->Next) ) |
| #define Scl_ItemForEachChildName( p, pItem, pChild, pName ) \ |
| for ( pChild = Scl_LibertyItem(p, pItem->Child); pChild; pChild = Scl_LibertyItem(p, pChild->Next) ) if ( Scl_LibertyCompare(p, pChild->Key, pName) ) {} else |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// FUNCTION DEFINITIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| /**Function************************************************************* |
| |
| Synopsis [Prints parse tree in Liberty format.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Scl_LibertyParseDumpItem( FILE * pFile, Scl_Tree_t * p, Scl_Item_t * pItem, int nOffset ) |
| { |
| if ( pItem->Type == SCL_LIBERTY_PROC ) |
| { |
| Scl_PrintSpace( pFile, nOffset ); |
| Scl_PrintWord( pFile, p, pItem->Key ); |
| fprintf( pFile, "(" ); |
| Scl_PrintWord( pFile, p, pItem->Head ); |
| fprintf( pFile, ") {\n" ); |
| if ( Scl_LibertyItem(p, pItem->Child) ) |
| Scl_LibertyParseDumpItem( pFile, p, Scl_LibertyItem(p, pItem->Child), nOffset + 2 ); |
| Scl_PrintSpace( pFile, nOffset ); |
| fprintf( pFile, "}\n" ); |
| } |
| else if ( pItem->Type == SCL_LIBERTY_EQUA ) |
| { |
| Scl_PrintSpace( pFile, nOffset ); |
| Scl_PrintWord( pFile, p, pItem->Key ); |
| fprintf( pFile, " : " ); |
| Scl_PrintWord( pFile, p, pItem->Head ); |
| fprintf( pFile, ";\n" ); |
| } |
| else if ( pItem->Type == SCL_LIBERTY_LIST ) |
| { |
| Scl_PrintSpace( pFile, nOffset ); |
| Scl_PrintWord( pFile, p, pItem->Key ); |
| fprintf( pFile, "(" ); |
| Scl_PrintWord( pFile, p, pItem->Head ); |
| fprintf( pFile, ");\n" ); |
| } |
| else assert( 0 ); |
| if ( Scl_LibertyItem(p, pItem->Next) ) |
| Scl_LibertyParseDumpItem( pFile, p, Scl_LibertyItem(p, pItem->Next), nOffset ); |
| } |
| int Scl_LibertyParseDump( Scl_Tree_t * p, char * pFileName ) |
| { |
| FILE * pFile; |
| if ( pFileName == NULL ) |
| pFile = stdout; |
| else |
| { |
| pFile = fopen( pFileName, "w" ); |
| if ( pFile == NULL ) |
| { |
| printf( "Scl_LibertyParseDump(): The output file is unavailable (absent or open).\n" ); |
| return 0; |
| } |
| } |
| Scl_LibertyParseDumpItem( pFile, p, Scl_LibertyRoot(p), 0 ); |
| if ( pFile != stdout ) |
| fclose( pFile ); |
| return 1; |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [Gets the name to write.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Scl_LibertyCountItems( char * pBeg, char * pEnd ) |
| { |
| int Counter = 0; |
| for ( ; pBeg < pEnd; pBeg++ ) |
| Counter += (*pBeg == '(' || *pBeg == ':'); |
| return Counter; |
| } |
| // removes C-style comments |
| /* |
| void Scl_LibertyWipeOutComments( char * pBeg, char * pEnd ) |
| { |
| char * pCur, * pStart; |
| for ( pCur = pBeg; pCur < pEnd; pCur++ ) |
| if ( pCur[0] == '/' && pCur[1] == '*' ) |
| for ( pStart = pCur; pCur < pEnd; pCur++ ) |
| if ( pCur[0] == '*' && pCur[1] == '/' ) |
| { |
| for ( ; pStart < pCur + 2; pStart++ ) |
| if ( *pStart != '\n' ) *pStart = ' '; |
| break; |
| } |
| } |
| */ |
| void Scl_LibertyWipeOutComments( char * pBeg, char * pEnd ) |
| { |
| char * pCur, * pStart; |
| for ( pCur = pBeg; pCur < pEnd-1; pCur++ ) |
| if ( pCur[0] == '/' && pCur[1] == '*' ) |
| { |
| for ( pStart = pCur; pCur < pEnd-1; pCur++ ) |
| if ( pCur[0] == '*' && pCur[1] == '/' ) |
| { |
| for ( ; pStart < pCur + 2; pStart++ ) |
| if ( *pStart != '\n' ) *pStart = ' '; |
| break; |
| } |
| } |
| else if ( pCur[0] == '/' && pCur[1] == '/' ) |
| { |
| for ( pStart = pCur; pCur < pEnd; pCur++ ) |
| if ( pCur[0] == '\n' || pCur == pEnd-1 ) |
| { |
| for ( ; pStart < pCur; pStart++ ) *pStart = ' '; |
| break; |
| } |
| } |
| } |
| static inline int Scl_LibertyCharIsSpace( char c ) |
| { |
| return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\\'; |
| } |
| static inline int Scl_LibertySkipSpaces( Scl_Tree_t * p, char ** ppPos, char * pEnd, int fStopAtNewLine ) |
| { |
| char * pPos = *ppPos; |
| for ( ; pPos < pEnd; pPos++ ) |
| { |
| if ( *pPos == '\n' ) |
| { |
| p->nLines++; |
| if ( fStopAtNewLine ) |
| break; |
| } |
| if ( !Scl_LibertyCharIsSpace(*pPos) ) |
| break; |
| } |
| *ppPos = pPos; |
| return pPos == pEnd; |
| } |
| // skips entry delimited by " :;(){}" and returns 1 if reached the end |
| static inline int Scl_LibertySkipEntry( char ** ppPos, char * pEnd ) |
| { |
| char * pPos = *ppPos; |
| if ( *pPos == '\"' ) |
| { |
| for ( pPos++; pPos < pEnd; pPos++ ) |
| if ( *pPos == '\"' ) |
| { |
| pPos++; |
| break; |
| } |
| } |
| else |
| { |
| for ( ; pPos < pEnd; pPos++ ) |
| if ( *pPos == ' ' || *pPos == '\r' || *pPos == '\n' || *pPos == '\t' || |
| *pPos == ':' || *pPos == ';' || |
| *pPos == '(' || *pPos == ')' || |
| *pPos == '{' || *pPos == '}' ) |
| break; |
| } |
| *ppPos = pPos; |
| return pPos == pEnd; |
| } |
| // finds the matching closing symbol |
| static inline char * Scl_LibertyFindMatch( char * pPos, char * pEnd ) |
| { |
| int Counter = 0; |
| assert( *pPos == '(' || *pPos == '{' ); |
| if ( *pPos == '(' ) |
| { |
| for ( ; pPos < pEnd; pPos++ ) |
| { |
| if ( *pPos == '(' ) |
| Counter++; |
| if ( *pPos == ')' ) |
| Counter--; |
| if ( Counter == 0 ) |
| break; |
| } |
| } |
| else |
| { |
| for ( ; pPos < pEnd; pPos++ ) |
| { |
| if ( *pPos == '{' ) |
| Counter++; |
| if ( *pPos == '}' ) |
| Counter--; |
| if ( Counter == 0 ) |
| break; |
| } |
| } |
| assert( *pPos == ')' || *pPos == '}' ); |
| return pPos; |
| } |
| // trims spaces around the head |
| static inline Scl_Pair_t Scl_LibertyUpdateHead( Scl_Tree_t * p, Scl_Pair_t Head ) |
| { |
| Scl_Pair_t Res; |
| char * pBeg = p->pContents + Head.Beg; |
| char * pEnd = p->pContents + Head.End; |
| char * pFirstNonSpace = NULL; |
| char * pLastNonSpace = NULL; |
| char * pChar; |
| for ( pChar = pBeg; pChar < pEnd; pChar++ ) |
| { |
| if ( *pChar == '\n' ) |
| p->nLines++; |
| if ( Scl_LibertyCharIsSpace(*pChar) ) |
| continue; |
| pLastNonSpace = pChar; |
| if ( pFirstNonSpace == NULL ) |
| pFirstNonSpace = pChar; |
| } |
| if ( pFirstNonSpace == NULL || pLastNonSpace == NULL ) |
| return Head; |
| assert( pFirstNonSpace && pLastNonSpace ); |
| Res.Beg = pFirstNonSpace - p->pContents; |
| Res.End = pLastNonSpace - p->pContents + 1; |
| return Res; |
| } |
| // returns new item |
| static inline Scl_Item_t * Scl_LibertyNewItem( Scl_Tree_t * p, int Type ) |
| { |
| p->pItems[p->nItems].iLine = p->nLines; |
| p->pItems[p->nItems].Type = Type; |
| p->pItems[p->nItems].Child = -1; |
| p->pItems[p->nItems].Next = -1; |
| return p->pItems + p->nItems++; |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [Gets the name to write.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| char * Scl_LibertyReadString( Scl_Tree_t * p, Scl_Pair_t Pair ) |
| { |
| static char Buffer[ABC_MAX_LIB_STR_LEN]; |
| assert( Pair.End-Pair.Beg < ABC_MAX_LIB_STR_LEN ); |
| strncpy( Buffer, p->pContents+Pair.Beg, Pair.End-Pair.Beg ); |
| if ( Pair.Beg < Pair.End && Buffer[0] == '\"' ) |
| { |
| assert( Buffer[Pair.End-Pair.Beg-1] == '\"' ); |
| Buffer[Pair.End-Pair.Beg-1] = 0; |
| return Buffer + 1; |
| } |
| Buffer[Pair.End-Pair.Beg] = 0; |
| return Buffer; |
| } |
| int Scl_LibertyItemNum( Scl_Tree_t * p, Scl_Item_t * pRoot, char * pName ) |
| { |
| Scl_Item_t * pItem; |
| int Counter = 0; |
| Scl_ItemForEachChildName( p, pRoot, pItem, pName ) |
| Counter++; |
| return Counter; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Returns free item.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Scl_LibertyBuildItem( Scl_Tree_t * p, char ** ppPos, char * pEnd ) |
| { |
| Scl_Item_t * pItem; |
| Scl_Pair_t Key, Head, Body; |
| char * pNext, * pStop; |
| Key.End = 0; |
| if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 0 ) ) |
| return -2; |
| Key.Beg = *ppPos - p->pContents; |
| if ( Scl_LibertySkipEntry( ppPos, pEnd ) ) |
| goto exit; |
| Key.End = *ppPos - p->pContents; |
| if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 0 ) ) |
| goto exit; |
| pNext = *ppPos; |
| if ( *pNext == ':' ) |
| { |
| *ppPos = pNext + 1; |
| if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 0 ) ) |
| goto exit; |
| Head.Beg = *ppPos - p->pContents; |
| if ( Scl_LibertySkipEntry( ppPos, pEnd ) ) |
| goto exit; |
| Head.End = *ppPos - p->pContents; |
| if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 1 ) ) |
| goto exit; |
| pNext = *ppPos; |
| while ( *pNext == '+' || *pNext == '-' || *pNext == '*' || *pNext == '/' ) |
| { |
| (*ppPos) += 1; |
| if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 0 ) ) |
| goto exit; |
| if ( Scl_LibertySkipEntry( ppPos, pEnd ) ) |
| goto exit; |
| Head.End = *ppPos - p->pContents; |
| if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 1 ) ) |
| goto exit; |
| pNext = *ppPos; |
| } |
| if ( *pNext != ';' && *pNext != '\n' ) |
| goto exit; |
| *ppPos = pNext + 1; |
| // end of equation |
| pItem = Scl_LibertyNewItem( p, SCL_LIBERTY_EQUA ); |
| pItem->Key = Key; |
| pItem->Head = Scl_LibertyUpdateHead( p, Head ); |
| pItem->Next = Scl_LibertyBuildItem( p, ppPos, pEnd ); |
| if ( pItem->Next == -1 ) |
| goto exit; |
| return Scl_LibertyItemId( p, pItem ); |
| } |
| if ( *pNext == '(' ) |
| { |
| pStop = Scl_LibertyFindMatch( pNext, pEnd ); |
| Head.Beg = pNext - p->pContents + 1; |
| Head.End = pStop - p->pContents; |
| *ppPos = pStop + 1; |
| if ( Scl_LibertySkipSpaces( p, ppPos, pEnd, 0 ) ) |
| { |
| // end of list |
| pItem = Scl_LibertyNewItem( p, SCL_LIBERTY_LIST ); |
| pItem->Key = Key; |
| pItem->Head = Scl_LibertyUpdateHead( p, Head ); |
| return Scl_LibertyItemId( p, pItem ); |
| } |
| pNext = *ppPos; |
| if ( *pNext == '{' ) // beginning of body |
| { |
| pStop = Scl_LibertyFindMatch( pNext, pEnd ); |
| Body.Beg = pNext - p->pContents + 1; |
| Body.End = pStop - p->pContents; |
| // end of body |
| pItem = Scl_LibertyNewItem( p, SCL_LIBERTY_PROC ); |
| pItem->Key = Key; |
| pItem->Head = Scl_LibertyUpdateHead( p, Head ); |
| pItem->Body = Body; |
| *ppPos = pNext + 1; |
| pItem->Child = Scl_LibertyBuildItem( p, ppPos, pStop ); |
| if ( pItem->Child == -1 ) |
| goto exit; |
| *ppPos = pStop + 1; |
| pItem->Next = Scl_LibertyBuildItem( p, ppPos, pEnd ); |
| if ( pItem->Next == -1 ) |
| goto exit; |
| return Scl_LibertyItemId( p, pItem ); |
| } |
| // end of list |
| if ( *pNext == ';' ) |
| *ppPos = pNext + 1; |
| pItem = Scl_LibertyNewItem( p, SCL_LIBERTY_LIST ); |
| pItem->Key = Key; |
| pItem->Head = Scl_LibertyUpdateHead( p, Head ); |
| pItem->Next = Scl_LibertyBuildItem( p, ppPos, pEnd ); |
| if ( pItem->Next == -1 ) |
| goto exit; |
| return Scl_LibertyItemId( p, pItem ); |
| } |
| if ( *pNext == ';' ) |
| { |
| *ppPos = pNext + 1; |
| return Scl_LibertyBuildItem(p, ppPos, pEnd); |
| } |
| exit: |
| if ( p->pError == NULL ) |
| { |
| p->pError = ABC_ALLOC( char, 1000 ); |
| sprintf( p->pError, "File \"%s\". Line %6d. Failed to parse entry \"%s\".\n", |
| p->pFileName, p->nLines, Scl_LibertyReadString(p, Key) ); |
| } |
| return -1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [File management.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Scl_LibertyFixFileName( char * pFileName ) |
| { |
| char * pHead; |
| for ( pHead = pFileName; *pHead; pHead++ ) |
| if ( *pHead == '>' ) |
| *pHead = '\\'; |
| } |
| int Scl_LibertyFileSize( char * pFileName ) |
| { |
| FILE * pFile; |
| int nFileSize; |
| pFile = fopen( pFileName, "rb" ); |
| if ( pFile == NULL ) |
| { |
| printf( "Scl_LibertyFileSize(): The input file is unavailable (absent or open).\n" ); |
| return 0; |
| } |
| fseek( pFile, 0, SEEK_END ); |
| nFileSize = ftell( pFile ); |
| fclose( pFile ); |
| return nFileSize; |
| } |
| char * Scl_LibertyFileContents( char * pFileName, int nContents ) |
| { |
| FILE * pFile = fopen( pFileName, "rb" ); |
| char * pContents = ABC_ALLOC( char, nContents+1 ); |
| int RetValue = 0; |
| RetValue = fread( pContents, nContents, 1, pFile ); |
| fclose( pFile ); |
| pContents[nContents] = 0; |
| return pContents; |
| } |
| void Scl_LibertyStringDump( char * pFileName, Vec_Str_t * vStr ) |
| { |
| FILE * pFile = fopen( pFileName, "wb" ); |
| int RetValue = 0; |
| if ( pFile == NULL ) |
| { |
| printf( "Scl_LibertyStringDump(): The output file is unavailable.\n" ); |
| return; |
| } |
| RetValue = fwrite( Vec_StrArray(vStr), 1, Vec_StrSize(vStr), pFile ); |
| fclose( pFile ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Starts the parsing manager.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Scl_Tree_t * Scl_LibertyStart( char * pFileName ) |
| { |
| Scl_Tree_t * p; |
| int RetValue; |
| // read the file into the buffer |
| Scl_LibertyFixFileName( pFileName ); |
| RetValue = Scl_LibertyFileSize( pFileName ); |
| if ( RetValue == 0 ) |
| return NULL; |
| // start the manager |
| p = ABC_ALLOC( Scl_Tree_t, 1 ); |
| memset( p, 0, sizeof(Scl_Tree_t) ); |
| p->clkStart = Abc_Clock(); |
| p->nContents = RetValue; |
| p->pContents = Scl_LibertyFileContents( pFileName, p->nContents ); |
| // other |
| p->pFileName = Abc_UtilStrsav( pFileName ); |
| p->nItermAlloc = 10 + Scl_LibertyCountItems( p->pContents, p->pContents+p->nContents ); |
| p->pItems = ABC_CALLOC( Scl_Item_t, p->nItermAlloc ); |
| p->nItems = 0; |
| p->nLines = 1; |
| return p; |
| } |
| void Scl_LibertyStop( Scl_Tree_t * p, int fVerbose ) |
| { |
| if ( fVerbose ) |
| { |
| printf( "Memory = %7.2f MB. ", 1.0 * (p->nContents + p->nItermAlloc * sizeof(Scl_Item_t))/(1<<20) ); |
| ABC_PRT( "Time", Abc_Clock() - p->clkStart ); |
| } |
| ABC_FREE( p->pFileName ); |
| ABC_FREE( p->pContents ); |
| ABC_FREE( p->pItems ); |
| ABC_FREE( p->pError ); |
| ABC_FREE( p ); |
| } |
| Scl_Tree_t * Scl_LibertyParse( char * pFileName, int fVerbose ) |
| { |
| Scl_Tree_t * p; |
| char * pPos; |
| if ( (p = Scl_LibertyStart(pFileName)) == NULL ) |
| return NULL; |
| pPos = p->pContents; |
| Scl_LibertyWipeOutComments( p->pContents, p->pContents+p->nContents ); |
| if ( (!Scl_LibertyBuildItem( p, &pPos, p->pContents + p->nContents )) == 0 ) |
| { |
| if ( p->pError ) printf( "%s", p->pError ); |
| printf( "Parsing failed. " ); |
| Abc_PrintTime( 1, "Parsing time", Abc_Clock() - p->clkStart ); |
| } |
| else if ( fVerbose ) |
| { |
| printf( "Parsing finished successfully. " ); |
| Abc_PrintTime( 1, "Parsing time", Abc_Clock() - p->clkStart ); |
| } |
| return p; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Fetching attributes.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Scl_LibertyReadCellIsFlop( Scl_Tree_t * p, Scl_Item_t * pCell ) |
| { |
| Scl_Item_t * pAttr; |
| Scl_ItemForEachChild( p, pCell, pAttr ) |
| if ( !Scl_LibertyCompare(p, pAttr->Key, "ff") || |
| !Scl_LibertyCompare(p, pAttr->Key, "latch") ) |
| return 1; |
| return 0; |
| } |
| char * Scl_LibertyReadCellArea( Scl_Tree_t * p, Scl_Item_t * pCell ) |
| { |
| Scl_Item_t * pArea; |
| Scl_ItemForEachChildName( p, pCell, pArea, "area" ) |
| return Scl_LibertyReadString(p, pArea->Head); |
| return 0; |
| } |
| char * Scl_LibertyReadCellLeakage( Scl_Tree_t * p, Scl_Item_t * pCell ) |
| { |
| Scl_Item_t * pItem, * pChild; |
| Scl_ItemForEachChildName( p, pCell, pItem, "cell_leakage_power" ) |
| return Scl_LibertyReadString(p, pItem->Head); |
| // look for another type |
| Scl_ItemForEachChildName( p, pCell, pItem, "leakage_power" ) |
| { |
| Scl_ItemForEachChildName( p, pItem, pChild, "when" ) |
| break; |
| if ( pChild && !Scl_LibertyCompare(p, pChild->Key, "when") ) |
| continue; |
| Scl_ItemForEachChildName( p, pItem, pChild, "value" ) |
| return Scl_LibertyReadString(p, pChild->Head); |
| } |
| return 0; |
| } |
| char * Scl_LibertyReadPinFormula( Scl_Tree_t * p, Scl_Item_t * pPin ) |
| { |
| Scl_Item_t * pFunc; |
| Scl_ItemForEachChildName( p, pPin, pFunc, "function" ) |
| return Scl_LibertyReadString(p, pFunc->Head); |
| return NULL; |
| } |
| int Scl_LibertyReadCellIsThreeState( Scl_Tree_t * p, Scl_Item_t * pCell ) |
| { |
| Scl_Item_t * pPin, * pItem; |
| Scl_ItemForEachChildName( p, pCell, pPin, "pin" ) |
| Scl_ItemForEachChildName( p, pPin, pItem, "three_state" ) |
| return 1; |
| return 0; |
| } |
| int Scl_LibertyReadCellOutputNum( Scl_Tree_t * p, Scl_Item_t * pCell ) |
| { |
| Scl_Item_t * pPin; |
| int Counter = 0; |
| Scl_ItemForEachChildName( p, pCell, pPin, "pin" ) |
| if ( Scl_LibertyReadPinFormula(p, pPin) ) |
| Counter++; |
| return Counter; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the standard cell library in Liberty format.] |
| |
| Description [Writes the resulting file in Genlib format.] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Vec_Str_t * Scl_LibertyReadGenlibStr( Scl_Tree_t * p, int fVerbose ) |
| { |
| Vec_Str_t * vStr; |
| Scl_Item_t * pCell, * pOutput, * pInput; |
| char * pFormula; |
| vStr = Vec_StrAlloc( 1000 ); |
| Vec_StrPrintStr( vStr, "GATE _const0_ 0.000000 z=CONST0;\n" ); |
| Vec_StrPrintStr( vStr, "GATE _const1_ 0.000000 z=CONST1;\n" ); |
| Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pCell, "cell" ) |
| { |
| if ( Scl_LibertyReadCellIsFlop(p, pCell) ) |
| { |
| if ( fVerbose ) printf( "Scl_LibertyReadGenlib() skipped sequential cell \"%s\".\n", Scl_LibertyReadString(p, pCell->Head) ); |
| continue; |
| } |
| if ( Scl_LibertyReadCellIsThreeState(p, pCell) ) |
| { |
| if ( fVerbose ) printf( "Scl_LibertyReadGenlib() skipped three-state cell \"%s\".\n", Scl_LibertyReadString(p, pCell->Head) ); |
| continue; |
| } |
| if ( Scl_LibertyReadCellOutputNum(p, pCell) == 0 ) |
| { |
| if ( fVerbose ) printf( "Scl_LibertyReadGenlib() skipped cell \"%s\" without logic function.\n", Scl_LibertyReadString(p, pCell->Head) ); |
| continue; |
| } |
| // iterate through output pins |
| Scl_ItemForEachChildName( p, pCell, pOutput, "pin" ) |
| { |
| if ( (pFormula = Scl_LibertyReadPinFormula(p, pOutput)) ) |
| continue; |
| if ( !strcmp(pFormula, "0") || !strcmp(pFormula, "1") ) |
| { |
| if ( fVerbose ) printf( "Scl_LibertyReadGenlib() skipped cell \"%s\" with constant formula \"%s\".\n", Scl_LibertyReadString(p, pCell->Head), pFormula ); |
| break; |
| } |
| Vec_StrPrintStr( vStr, "GATE " ); |
| Vec_StrPrintStr( vStr, Scl_LibertyReadString(p, pCell->Head) ); |
| Vec_StrPrintStr( vStr, " " ); |
| Vec_StrPrintStr( vStr, Scl_LibertyReadCellArea(p, pCell) ); |
| Vec_StrPrintStr( vStr, " " ); |
| Vec_StrPrintStr( vStr, Scl_LibertyReadString(p, pOutput->Head) ); |
| Vec_StrPrintStr( vStr, "=" ); |
| Vec_StrPrintStr( vStr, pFormula ); |
| Vec_StrPrintStr( vStr, ";\n" ); |
| // iterate through input pins |
| Scl_ItemForEachChildName( p, pCell, pInput, "pin" ) |
| { |
| if ( Scl_LibertyReadPinFormula(p, pInput) == NULL ) |
| continue; |
| Vec_StrPrintStr( vStr, " PIN " ); |
| Vec_StrPrintStr( vStr, Scl_LibertyReadString(p, pInput->Head) ); |
| Vec_StrPrintStr( vStr, " UNKNOWN 1 999 1.00 0.00 1.00 0.00\n" ); |
| } |
| } |
| } |
| Vec_StrPrintStr( vStr, "\n.end\n" ); |
| Vec_StrPush( vStr, '\0' ); |
| // printf( "%s", Vec_StrArray(vStr) ); |
| return vStr; |
| } |
| Vec_Str_t * Scl_LibertyParseGenlibStr( char * pFileName, int fVerbose ) |
| { |
| Scl_Tree_t * p; |
| Vec_Str_t * vStr; |
| p = Scl_LibertyParse( pFileName, fVerbose ); |
| if ( p == NULL ) |
| return NULL; |
| // Scl_LibertyRead( p, "temp_.lib" ); |
| vStr = Scl_LibertyReadGenlibStr( p, fVerbose ); |
| Scl_LibertyStop( p, fVerbose ); |
| // Scl_LibertyStringDump( "test_genlib.lib", vStr ); |
| return vStr; |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [Enabling debug output.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| //#define SCL_DEBUG |
| #ifdef SCL_DEBUG |
| static inline void Vec_StrPutI_( Vec_Str_t * vOut, int Val ) { printf( "%d ", Val ); Vec_StrPutI( vOut, Val ); } |
| static inline void Vec_StrPutW_( Vec_Str_t * vOut, word Val ) { printf( "%lu ", (long)Val ); Vec_StrPutW( vOut, Val ); } |
| static inline void Vec_StrPutF_( Vec_Str_t * vOut, float Val ) { printf( "%f ", Val ); Vec_StrPutF( vOut, Val ); } |
| static inline void Vec_StrPutS_( Vec_Str_t * vOut, char * Val ) { printf( "%s ", Val ); Vec_StrPutS( vOut, Val ); } |
| static inline void Vec_StrPut_( Vec_Str_t * vOut ) { printf( "\n" ); } |
| #else |
| static inline void Vec_StrPutI_( Vec_Str_t * vOut, int Val ) { Vec_StrPutI( vOut, Val ); } |
| static inline void Vec_StrPutW_( Vec_Str_t * vOut, word Val ) { Vec_StrPutW( vOut, Val ); } |
| static inline void Vec_StrPutF_( Vec_Str_t * vOut, float Val ) { Vec_StrPutF( vOut, Val ); } |
| static inline void Vec_StrPutS_( Vec_Str_t * vOut, char * Val ) { Vec_StrPutS( vOut, Val ); } |
| static inline void Vec_StrPut_( Vec_Str_t * vOut ) { } |
| #endif |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parsing Liberty into internal data representation.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| char * Scl_LibertyReadDefaultWireLoad( Scl_Tree_t * p ) |
| { |
| Scl_Item_t * pItem; |
| Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "default_wire_load" ) |
| return Scl_LibertyReadString(p, pItem->Head); |
| return ""; |
| } |
| char * Scl_LibertyReadDefaultWireLoadSel( Scl_Tree_t * p ) |
| { |
| Scl_Item_t * pItem; |
| Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "default_wire_load_selection" ) |
| return Scl_LibertyReadString(p, pItem->Head); |
| return ""; |
| } |
| float Scl_LibertyReadDefaultMaxTrans( Scl_Tree_t * p ) |
| { |
| Scl_Item_t * pItem; |
| Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "default_max_transition" ) |
| return atof(Scl_LibertyReadString(p, pItem->Head)); |
| return 0; |
| } |
| int Scl_LibertyReadTimeUnit( Scl_Tree_t * p ) |
| { |
| Scl_Item_t * pItem; |
| Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "time_unit" ) |
| { |
| char * pUnit = Scl_LibertyReadString(p, pItem->Head); |
| // 9=1ns, 10=100ps, 11=10ps, 12=1ps |
| if ( !strcmp(pUnit, "1ns") ) |
| return 9; |
| if ( !strcmp(pUnit, "100ps") ) |
| return 10; |
| if ( !strcmp(pUnit, "10ps") ) |
| return 11; |
| if ( !strcmp(pUnit, "1ps") ) |
| return 12; |
| break; |
| } |
| printf( "Libery parser cannot read \"time_unit\". Assuming time_unit : \"1ns\".\n" ); |
| return 9; |
| } |
| void Scl_LibertyReadLoadUnit( Scl_Tree_t * p, Vec_Str_t * vOut ) |
| { |
| Scl_Item_t * pItem; |
| Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "capacitive_load_unit" ) |
| { |
| // expecting (1.00,ff) or (1, pf) ... 12 or 15 for 'pf' or 'ff' |
| char * pHead = Scl_LibertyReadString(p, pItem->Head); |
| float First = atof(strtok(pHead, " \t\n\r\\\",")); |
| char * pSecond = strtok(NULL, " \t\n\r\\\","); |
| Vec_StrPutF_( vOut, First ); |
| if ( pSecond && !strcmp(pSecond, "pf") ) |
| Vec_StrPutI_( vOut, 12 ); |
| else if ( pSecond && !strcmp(pSecond, "ff") ) |
| Vec_StrPutI_( vOut, 15 ); |
| else break; |
| return; |
| } |
| printf( "Libery parser cannot read \"capacitive_load_unit\". Assuming capacitive_load_unit(1, pf).\n" ); |
| Vec_StrPutF_( vOut, 1.0 ); |
| Vec_StrPutI_( vOut, 12 ); |
| } |
| void Scl_LibertyReadWireLoad( Scl_Tree_t * p, Vec_Str_t * vOut ) |
| { |
| Scl_Item_t * pItem, * pChild; |
| Vec_StrPutI_( vOut, Scl_LibertyItemNum(p, Scl_LibertyRoot(p), "wire_load") ); |
| Vec_StrPut_( vOut ); |
| Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "wire_load" ) |
| { |
| Vec_StrPutS_( vOut, Scl_LibertyReadString(p, pItem->Head) ); |
| Scl_ItemForEachChildName( p, pItem, pChild, "capacitance" ) |
| Vec_StrPutF_( vOut, atof(Scl_LibertyReadString(p, pChild->Head)) ); |
| Scl_ItemForEachChildName( p, pItem, pChild, "slope" ) |
| Vec_StrPutF_( vOut, atof(Scl_LibertyReadString(p, pChild->Head)) ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPutI_( vOut, Scl_LibertyItemNum(p, pItem, "fanout_length") ); |
| Vec_StrPut_( vOut ); |
| Scl_ItemForEachChildName( p, pItem, pChild, "fanout_length" ) |
| { |
| char * pHead = Scl_LibertyReadString(p, pChild->Head); |
| int First = atoi( strtok(pHead, " ,") ); |
| float Second = atof( strtok(NULL, " ") ); |
| Vec_StrPutI_( vOut, First ); |
| Vec_StrPutF_( vOut, Second ); |
| Vec_StrPut_( vOut ); |
| } |
| Vec_StrPut_( vOut ); |
| } |
| Vec_StrPut_( vOut ); |
| } |
| void Scl_LibertyReadWireLoadSelect( Scl_Tree_t * p, Vec_Str_t * vOut ) |
| { |
| Scl_Item_t * pItem, * pChild; |
| Vec_StrPutI_( vOut, Scl_LibertyItemNum(p, Scl_LibertyRoot(p), "wire_load_selection") ); |
| Vec_StrPut_( vOut ); |
| Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pItem, "wire_load_selection" ) |
| { |
| Vec_StrPutS_( vOut, Scl_LibertyReadString(p, pItem->Head) ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPutI_( vOut, Scl_LibertyItemNum(p, pItem, "wire_load_from_area") ); |
| Vec_StrPut_( vOut ); |
| Scl_ItemForEachChildName( p, pItem, pChild, "wire_load_from_area" ) |
| { |
| char * pHead = Scl_LibertyReadString(p, pChild->Head); |
| float First = atof( strtok(pHead, " ,") ); |
| float Second = atof( strtok(NULL, " ,") ); |
| char * pThird = strtok(NULL, " "); |
| if ( pThird[0] == '\"' ) |
| assert(pThird[strlen(pThird)-1] == '\"'), pThird[strlen(pThird)-1] = 0, pThird++; |
| Vec_StrPutF_( vOut, First ); |
| Vec_StrPutF_( vOut, Second ); |
| Vec_StrPutS_( vOut, pThird ); |
| Vec_StrPut_( vOut ); |
| } |
| Vec_StrPut_( vOut ); |
| } |
| Vec_StrPut_( vOut ); |
| } |
| int Scl_LibertyReadDeriveStrength( Scl_Tree_t * p, Scl_Item_t * pCell ) |
| { |
| Scl_Item_t * pItem; |
| Scl_ItemForEachChildName( p, pCell, pItem, "drive_strength" ) |
| return atoi(Scl_LibertyReadString(p, pItem->Head)); |
| return 0; |
| } |
| int Scl_LibertyReadPinDirection( Scl_Tree_t * p, Scl_Item_t * pPin ) |
| { |
| Scl_Item_t * pItem; |
| Scl_ItemForEachChildName( p, pPin, pItem, "direction" ) |
| { |
| char * pToken = Scl_LibertyReadString(p, pItem->Head); |
| if ( !strcmp(pToken, "input") ) |
| return 0; |
| if ( !strcmp(pToken, "output") ) |
| return 1; |
| break; |
| } |
| return -1; |
| } |
| float Scl_LibertyReadPinCap( Scl_Tree_t * p, Scl_Item_t * pPin, char * pName ) |
| { |
| Scl_Item_t * pItem; |
| Scl_ItemForEachChildName( p, pPin, pItem, pName ) |
| return atof(Scl_LibertyReadString(p, pItem->Head)); |
| return 0; |
| } |
| Scl_Item_t * Scl_LibertyReadPinTiming( Scl_Tree_t * p, Scl_Item_t * pPinOut, char * pNameIn ) |
| { |
| Scl_Item_t * pTiming, * pPinIn; |
| Scl_ItemForEachChildName( p, pPinOut, pTiming, "timing" ) |
| Scl_ItemForEachChildName( p, pTiming, pPinIn, "related_pin" ) |
| if ( !strcmp(Scl_LibertyReadString(p, pPinIn->Head), pNameIn) ) |
| return pTiming; |
| return NULL; |
| } |
| Vec_Ptr_t * Scl_LibertyReadPinTimingAll( Scl_Tree_t * p, Scl_Item_t * pPinOut, char * pNameIn ) |
| { |
| Vec_Ptr_t * vTimings; |
| Scl_Item_t * pTiming, * pPinIn; |
| vTimings = Vec_PtrAlloc( 16 ); |
| Scl_ItemForEachChildName( p, pPinOut, pTiming, "timing" ) |
| Scl_ItemForEachChildName( p, pTiming, pPinIn, "related_pin" ) |
| if ( !strcmp(Scl_LibertyReadString(p, pPinIn->Head), pNameIn) ) |
| Vec_PtrPush( vTimings, pTiming ); |
| return vTimings; |
| } |
| int Scl_LibertyReadTimingSense( Scl_Tree_t * p, Scl_Item_t * pPin ) |
| { |
| Scl_Item_t * pItem; |
| Scl_ItemForEachChildName( p, pPin, pItem, "timing_sense" ) |
| { |
| char * pToken = Scl_LibertyReadString(p, pItem->Head); |
| if ( !strcmp(pToken, "positive_unate") ) |
| return sc_ts_Pos; |
| if ( !strcmp(pToken, "negative_unate") ) |
| return sc_ts_Neg; |
| if ( !strcmp(pToken, "non_unate") ) |
| return sc_ts_Non; |
| break; |
| } |
| return sc_ts_Non; |
| } |
| Vec_Flt_t * Scl_LibertyReadFloatVec( char * pName ) |
| { |
| char * pToken; |
| Vec_Flt_t * vValues = Vec_FltAlloc( 100 ); |
| for ( pToken = strtok(pName, " \t\n\r\\\","); pToken; pToken = strtok(NULL, " \t\n\r\\\",") ) |
| Vec_FltPush( vValues, atof(pToken) ); |
| return vValues; |
| } |
| |
| void Scl_LibertyDumpTables( Vec_Str_t * vOut, Vec_Flt_t * vInd1, Vec_Flt_t * vInd2, Vec_Flt_t * vValues ) |
| { |
| int i; float Entry; |
| // write entries |
| Vec_StrPutI_( vOut, Vec_FltSize(vInd1) ); |
| Vec_FltForEachEntry( vInd1, Entry, i ) |
| Vec_StrPutF_( vOut, Entry ); |
| Vec_StrPut_( vOut ); |
| // write entries |
| Vec_StrPutI_( vOut, Vec_FltSize(vInd2) ); |
| Vec_FltForEachEntry( vInd2, Entry, i ) |
| Vec_StrPutF_( vOut, Entry ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| // write entries |
| assert( Vec_FltSize(vInd1) * Vec_FltSize(vInd2) == Vec_FltSize(vValues) ); |
| Vec_FltForEachEntry( vValues, Entry, i ) |
| { |
| Vec_StrPutF_( vOut, Entry ); |
| if ( i % Vec_FltSize(vInd2) == Vec_FltSize(vInd2)-1 ) |
| Vec_StrPut_( vOut ); |
| } |
| // dump approximations |
| Vec_StrPut_( vOut ); |
| for ( i = 0; i < 3; i++ ) |
| Vec_StrPutF_( vOut, 0 ); |
| for ( i = 0; i < 4; i++ ) |
| Vec_StrPutF_( vOut, 0 ); |
| for ( i = 0; i < 6; i++ ) |
| Vec_StrPutF_( vOut, 0 ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| } |
| int Scl_LibertyScanTable( Scl_Tree_t * p, Vec_Ptr_t * vOut, Scl_Item_t * pTiming, char * pName, Vec_Ptr_t * vTemples ) |
| { |
| Vec_Flt_t * vIndex1 = NULL; |
| Vec_Flt_t * vIndex2 = NULL; |
| Vec_Flt_t * vValues = NULL; |
| Vec_Flt_t * vInd1, * vInd2; |
| Scl_Item_t * pItem, * pTable = NULL; |
| char * pThis, * pTempl = NULL; |
| int iPlace, i; |
| float Entry; |
| // find the table |
| Scl_ItemForEachChildName( p, pTiming, pTable, pName ) |
| break; |
| if ( pTable == NULL ) |
| return 0; |
| // find the template |
| pTempl = Scl_LibertyReadString(p, pTable->Head); |
| if ( pTempl == NULL || pTempl[0] == 0 ) |
| { |
| // read the numbers |
| Scl_ItemForEachChild( p, pTable, pItem ) |
| { |
| if ( !Scl_LibertyCompare(p, pItem->Key, "index_1") ) |
| assert(vIndex1 == NULL), vIndex1 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| else if ( !Scl_LibertyCompare(p, pItem->Key, "index_2") ) |
| assert(vIndex2 == NULL), vIndex2 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| else if ( !Scl_LibertyCompare(p, pItem->Key, "values") ) |
| assert(vValues == NULL), vValues = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| } |
| if ( vIndex1 == NULL || vIndex2 == NULL || vValues == NULL ) |
| { printf( "Incomplete table specification\n" ); return 0; } |
| // dump the table |
| vInd1 = vIndex1; |
| vInd2 = vIndex2; |
| // write entries |
| Vec_PtrPush( vOut, vInd1 ); |
| Vec_PtrPush( vOut, vInd2 ); |
| Vec_PtrPush( vOut, vValues ); |
| } |
| else if ( !strcmp(pTempl, "scalar") ) |
| { |
| Scl_ItemForEachChild( p, pTable, pItem ) |
| if ( !Scl_LibertyCompare(p, pItem->Key, "values") ) |
| { |
| assert(vValues == NULL); |
| vValues = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| assert( Vec_FltSize(vValues) == 1 ); |
| // write entries |
| Vec_PtrPush( vOut, Vec_IntStart(1) ); |
| Vec_PtrPush( vOut, Vec_IntStart(1) ); |
| Vec_PtrPush( vOut, vValues ); |
| break; |
| } |
| else |
| { printf( "Cannot read \"scalar\" template\n" ); return 0; } |
| } |
| else |
| { |
| // fetch the template |
| iPlace = -1; |
| Vec_PtrForEachEntry( char *, vTemples, pThis, i ) |
| if ( i % 4 == 0 && !strcmp(pTempl, pThis) ) |
| { |
| iPlace = i; |
| break; |
| } |
| if ( iPlace == -1 ) |
| { printf( "Template cannot be found in the template library\n" ); return 0; } |
| // read the numbers |
| Scl_ItemForEachChild( p, pTable, pItem ) |
| { |
| if ( !Scl_LibertyCompare(p, pItem->Key, "index_1") ) |
| assert(vIndex1 == NULL), vIndex1 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| else if ( !Scl_LibertyCompare(p, pItem->Key, "index_2") ) |
| assert(vIndex2 == NULL), vIndex2 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| else if ( !Scl_LibertyCompare(p, pItem->Key, "values") ) |
| assert(vValues == NULL), vValues = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| } |
| // check the template style |
| vInd1 = (Vec_Flt_t *)Vec_PtrEntry( vTemples, iPlace + 2 ); // slew |
| vInd2 = (Vec_Flt_t *)Vec_PtrEntry( vTemples, iPlace + 3 ); // load |
| if ( Vec_PtrEntry(vTemples, iPlace + 1) == NULL ) // normal order (vIndex1 is slew; vIndex2 is load) |
| { |
| assert( !vIndex1 || Vec_FltSize(vIndex1) == Vec_FltSize(vInd1) ); |
| assert( !vIndex2 || Vec_FltSize(vIndex2) == Vec_FltSize(vInd2) ); |
| vInd1 = vIndex1 ? vIndex1 : vInd1; |
| vInd2 = vIndex2 ? vIndex2 : vInd2; |
| // write entries |
| Vec_PtrPush( vOut, Vec_FltDup(vInd1) ); |
| Vec_PtrPush( vOut, Vec_FltDup(vInd2) ); |
| Vec_PtrPush( vOut, Vec_FltDup(vValues) ); |
| } |
| else // reverse order (vIndex2 is slew; vIndex1 is load) |
| { |
| Vec_Flt_t * vValues2 = Vec_FltAlloc( Vec_FltSize(vValues) ); |
| assert( !vIndex2 || Vec_FltSize(vIndex2) == Vec_FltSize(vInd1) ); |
| assert( !vIndex1 || Vec_FltSize(vIndex1) == Vec_FltSize(vInd2) ); |
| vInd1 = vIndex2 ? vIndex2 : vInd1; |
| vInd2 = vIndex1 ? vIndex1 : vInd2; |
| // write entries -- transpose |
| assert( Vec_FltSize(vInd1) * Vec_FltSize(vInd2) == Vec_FltSize(vValues) ); |
| Vec_FltForEachEntry( vValues, Entry, i ) |
| { |
| int x = i % Vec_FltSize(vInd2); |
| int y = i / Vec_FltSize(vInd2); |
| Entry = Vec_FltEntry( vValues, x * Vec_FltSize(vInd1) + y ); |
| Vec_FltPush( vValues2, Entry ); |
| } |
| assert( Vec_FltSize(vValues) == Vec_FltSize(vValues2) ); |
| // write entries |
| Vec_PtrPush( vOut, Vec_FltDup(vInd1) ); |
| Vec_PtrPush( vOut, Vec_FltDup(vInd2) ); |
| Vec_PtrPush( vOut, vValues2 ); |
| } |
| Vec_FltFreeP( &vIndex1 ); |
| Vec_FltFreeP( &vIndex2 ); |
| Vec_FltFreeP( &vValues ); |
| } |
| return 1; |
| } |
| int Scl_LibertyComputeWorstCase( Vec_Ptr_t * vTables, Vec_Flt_t ** pvInd0, Vec_Flt_t ** pvInd1, Vec_Flt_t ** pvValues ) |
| { |
| Vec_Flt_t * vInd0, * vInd1, * vValues; |
| Vec_Flt_t * vind0, * vind1, * vvalues; |
| int i, k, nTriples = Vec_PtrSize(vTables) / 3; |
| float Entry; |
| assert( Vec_PtrSize(vTables) > 0 && Vec_PtrSize(vTables) % 3 == 0 ); |
| if ( nTriples == 1 ) |
| { |
| *pvInd0 = (Vec_Flt_t *)Vec_PtrEntry(vTables, 0); |
| *pvInd1 = (Vec_Flt_t *)Vec_PtrEntry(vTables, 1); |
| *pvValues = (Vec_Flt_t *)Vec_PtrEntry(vTables, 2); |
| Vec_PtrShrink( vTables, 0 ); |
| return 1; |
| } |
| vInd0 = Vec_FltDup( (Vec_Flt_t *)Vec_PtrEntry(vTables, 0) ); |
| vInd1 = Vec_FltDup( (Vec_Flt_t *)Vec_PtrEntry(vTables, 1) ); |
| vValues = Vec_FltDup( (Vec_Flt_t *)Vec_PtrEntry(vTables, 2) ); |
| for ( i = 1; i < nTriples; i++ ) |
| { |
| vind0 = (Vec_Flt_t *)Vec_PtrEntry(vTables, i*3+0); |
| vind1 = (Vec_Flt_t *)Vec_PtrEntry(vTables, i*3+1); |
| vvalues = (Vec_Flt_t *)Vec_PtrEntry(vTables, i*3+2); |
| // check equality of indexes |
| if ( !Vec_FltEqual(vind0, vInd0) ) |
| continue;//return 0; |
| if ( !Vec_FltEqual(vind1, vInd1) ) |
| continue;//return 0; |
| // Vec_FltForEachEntry( vvalues, Entry, k ) |
| // Vec_FltAddToEntry( vValues, k, Entry ); |
| Vec_FltForEachEntry( vvalues, Entry, k ) |
| if ( Vec_FltEntry(vValues, k) < Entry ) |
| Vec_FltWriteEntry( vValues, k, Entry ); |
| } |
| // Vec_FltForEachEntry( vValues, Entry, k ) |
| // Vec_FltWriteEntry( vValues, k, Entry/nTriples ); |
| // return the result |
| *pvInd0 = vInd0; |
| *pvInd1 = vInd1; |
| *pvValues = vValues; |
| return 1; |
| } |
| |
| int Scl_LibertyReadTable( Scl_Tree_t * p, Vec_Str_t * vOut, Scl_Item_t * pTiming, char * pName, Vec_Ptr_t * vTemples ) |
| { |
| Vec_Flt_t * vIndex1 = NULL; |
| Vec_Flt_t * vIndex2 = NULL; |
| Vec_Flt_t * vValues = NULL; |
| Vec_Flt_t * vInd1, * vInd2; |
| Scl_Item_t * pItem, * pTable = NULL; |
| char * pThis, * pTempl = NULL; |
| int iPlace, i; |
| float Entry; |
| // find the table |
| Scl_ItemForEachChildName( p, pTiming, pTable, pName ) |
| break; |
| if ( pTable == NULL ) |
| return 0; |
| // find the template |
| pTempl = Scl_LibertyReadString(p, pTable->Head); |
| if ( pTempl == NULL || pTempl[0] == 0 ) |
| { |
| // read the numbers |
| Scl_ItemForEachChild( p, pTable, pItem ) |
| { |
| if ( !Scl_LibertyCompare(p, pItem->Key, "index_1") ) |
| assert(vIndex1 == NULL), vIndex1 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| else if ( !Scl_LibertyCompare(p, pItem->Key, "index_2") ) |
| assert(vIndex2 == NULL), vIndex2 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| else if ( !Scl_LibertyCompare(p, pItem->Key, "values") ) |
| assert(vValues == NULL), vValues = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| } |
| if ( vIndex1 == NULL || vIndex2 == NULL || vValues == NULL ) |
| { printf( "Incomplete table specification\n" ); return 0; } |
| // dump the table |
| vInd1 = vIndex1; |
| vInd2 = vIndex2; |
| // write entries |
| Vec_StrPutI_( vOut, Vec_FltSize(vInd1) ); |
| Vec_FltForEachEntry( vInd1, Entry, i ) |
| Vec_StrPutF_( vOut, Entry ); |
| Vec_StrPut_( vOut ); |
| // write entries |
| Vec_StrPutI_( vOut, Vec_FltSize(vInd2) ); |
| Vec_FltForEachEntry( vInd2, Entry, i ) |
| Vec_StrPutF_( vOut, Entry ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| // write entries |
| assert( Vec_FltSize(vInd1) * Vec_FltSize(vInd2) == Vec_FltSize(vValues) ); |
| Vec_FltForEachEntry( vValues, Entry, i ) |
| { |
| Vec_StrPutF_( vOut, Entry ); |
| if ( i % Vec_FltSize(vInd2) == Vec_FltSize(vInd2)-1 ) |
| Vec_StrPut_( vOut ); |
| } |
| } |
| else |
| { |
| // fetch the template |
| iPlace = -1; |
| Vec_PtrForEachEntry( char *, vTemples, pThis, i ) |
| if ( i % 4 == 0 && !strcmp(pTempl, pThis) ) |
| { |
| iPlace = i; |
| break; |
| } |
| if ( iPlace == -1 ) |
| { printf( "Template cannot be found in the template library\n" ); return 0; } |
| // read the numbers |
| Scl_ItemForEachChild( p, pTable, pItem ) |
| { |
| if ( !Scl_LibertyCompare(p, pItem->Key, "index_1") ) |
| assert(vIndex1 == NULL), vIndex1 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| else if ( !Scl_LibertyCompare(p, pItem->Key, "index_2") ) |
| assert(vIndex2 == NULL), vIndex2 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| else if ( !Scl_LibertyCompare(p, pItem->Key, "values") ) |
| assert(vValues == NULL), vValues = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| } |
| // check the template style |
| vInd1 = (Vec_Flt_t *)Vec_PtrEntry( vTemples, iPlace + 2 ); // slew |
| vInd2 = (Vec_Flt_t *)Vec_PtrEntry( vTemples, iPlace + 3 ); // load |
| if ( Vec_PtrEntry(vTemples, iPlace + 1) == NULL ) // normal order (vIndex1 is slew; vIndex2 is load) |
| { |
| assert( !vIndex1 || Vec_FltSize(vIndex1) == Vec_FltSize(vInd1) ); |
| assert( !vIndex2 || Vec_FltSize(vIndex2) == Vec_FltSize(vInd2) ); |
| vInd1 = vIndex1 ? vIndex1 : vInd1; |
| vInd2 = vIndex2 ? vIndex2 : vInd2; |
| // write entries |
| Vec_StrPutI_( vOut, Vec_FltSize(vInd1) ); |
| Vec_FltForEachEntry( vInd1, Entry, i ) |
| Vec_StrPutF_( vOut, Entry ); |
| Vec_StrPut_( vOut ); |
| // write entries |
| Vec_StrPutI_( vOut, Vec_FltSize(vInd2) ); |
| Vec_FltForEachEntry( vInd2, Entry, i ) |
| Vec_StrPutF_( vOut, Entry ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| // write entries |
| assert( Vec_FltSize(vInd1) * Vec_FltSize(vInd2) == Vec_FltSize(vValues) ); |
| Vec_FltForEachEntry( vValues, Entry, i ) |
| { |
| Vec_StrPutF_( vOut, Entry ); |
| if ( i % Vec_FltSize(vInd2) == Vec_FltSize(vInd2)-1 ) |
| Vec_StrPut_( vOut ); |
| } |
| } |
| else // reverse order (vIndex2 is slew; vIndex1 is load) |
| { |
| assert( !vIndex2 || Vec_FltSize(vIndex2) == Vec_FltSize(vInd1) ); |
| assert( !vIndex1 || Vec_FltSize(vIndex1) == Vec_FltSize(vInd2) ); |
| vInd1 = vIndex2 ? vIndex2 : vInd1; |
| vInd2 = vIndex1 ? vIndex1 : vInd2; |
| // write entries |
| Vec_StrPutI_( vOut, Vec_FltSize(vInd1) ); |
| Vec_FltForEachEntry( vInd1, Entry, i ) |
| Vec_StrPutF_( vOut, Entry ); |
| Vec_StrPut_( vOut ); |
| // write entries |
| Vec_StrPutI_( vOut, Vec_FltSize(vInd2) ); |
| Vec_FltForEachEntry( vInd2, Entry, i ) |
| Vec_StrPutF_( vOut, Entry ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| // write entries -- transpose |
| assert( Vec_FltSize(vInd1) * Vec_FltSize(vInd2) == Vec_FltSize(vValues) ); |
| Vec_FltForEachEntry( vValues, Entry, i ) |
| { |
| int x = i % Vec_FltSize(vInd2); |
| int y = i / Vec_FltSize(vInd2); |
| Entry = Vec_FltEntry( vValues, x * Vec_FltSize(vInd1) + y ); |
| Vec_StrPutF_( vOut, Entry ); |
| if ( i % Vec_FltSize(vInd2) == Vec_FltSize(vInd2)-1 ) |
| Vec_StrPut_( vOut ); |
| } |
| } |
| } |
| Vec_StrPut_( vOut ); |
| for ( i = 0; i < 3; i++ ) |
| Vec_StrPutF_( vOut, 0 ); |
| for ( i = 0; i < 4; i++ ) |
| Vec_StrPutF_( vOut, 0 ); |
| for ( i = 0; i < 6; i++ ) |
| Vec_StrPutF_( vOut, 0 ); |
| Vec_FltFreeP( &vIndex1 ); |
| Vec_FltFreeP( &vIndex2 ); |
| Vec_FltFreeP( &vValues ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| return 1; |
| } |
| void Scl_LibertyPrintTemplates( Vec_Ptr_t * vRes ) |
| { |
| Vec_Flt_t * vArray; int i; |
| assert( Vec_PtrSize(vRes) % 4 == 0 ); |
| printf( "There are %d slew/load templates\n", Vec_PtrSize(vRes) % 4 ); |
| Vec_PtrForEachEntry( Vec_Flt_t *, vRes, vArray, i ) |
| { |
| if ( i % 4 == 0 ) |
| printf( "%s\n", (char *)vArray ); |
| else if ( i % 4 == 1 ) |
| printf( "%d\n", (int)(vArray != NULL) ); |
| else if ( i % 4 == 2 || i % 4 == 3 ) |
| Vec_FltPrint( vArray ); |
| if ( i % 4 == 3 ) |
| printf( "\n" ); |
| } |
| } |
| Vec_Ptr_t * Scl_LibertyReadTemplates( Scl_Tree_t * p ) |
| { |
| Vec_Ptr_t * vRes = NULL; |
| Vec_Flt_t * vIndex1, * vIndex2; |
| Scl_Item_t * pTempl, * pItem; |
| char * pVar1, * pVar2; |
| int fFlag0, fFlag1; |
| vRes = Vec_PtrAlloc( 100 ); |
| Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pTempl, "lu_table_template" ) |
| { |
| pVar1 = pVar2 = NULL; |
| vIndex1 = vIndex2 = NULL; |
| Scl_ItemForEachChild( p, pTempl, pItem ) |
| { |
| if ( !Scl_LibertyCompare(p, pItem->Key, "index_1") ) |
| assert(vIndex1 == NULL), vIndex1 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| else if ( !Scl_LibertyCompare(p, pItem->Key, "index_2") ) |
| assert(vIndex2 == NULL), vIndex2 = Scl_LibertyReadFloatVec( Scl_LibertyReadString(p, pItem->Head) ); |
| else if ( !Scl_LibertyCompare(p, pItem->Key, "variable_1") ) |
| assert(pVar1 == NULL), pVar1 = Abc_UtilStrsav( Scl_LibertyReadString(p, pItem->Head) ); |
| else if ( !Scl_LibertyCompare(p, pItem->Key, "variable_2") ) |
| assert(pVar2 == NULL), pVar2 = Abc_UtilStrsav( Scl_LibertyReadString(p, pItem->Head) ); |
| } |
| if ( pVar1 == NULL || pVar2 == NULL ) |
| { |
| ABC_FREE( pVar1 ); |
| ABC_FREE( pVar2 ); |
| Vec_FltFreeP( &vIndex1 ); |
| Vec_FltFreeP( &vIndex2 ); |
| continue; |
| } |
| assert( pVar1 != NULL && pVar2 != NULL ); |
| fFlag0 = (!strcmp(pVar1, "input_net_transition") && !strcmp(pVar2, "total_output_net_capacitance")); |
| fFlag1 = (!strcmp(pVar2, "input_net_transition") && !strcmp(pVar1, "total_output_net_capacitance")); |
| ABC_FREE( pVar1 ); |
| ABC_FREE( pVar2 ); |
| if ( !fFlag0 && !fFlag1 ) |
| { |
| Vec_FltFreeP( &vIndex1 ); |
| Vec_FltFreeP( &vIndex2 ); |
| continue; |
| } |
| Vec_PtrPush( vRes, Abc_UtilStrsav( Scl_LibertyReadString(p, pTempl->Head) ) ); |
| Vec_PtrPush( vRes, fFlag0 ? NULL : (void *)(ABC_PTRINT_T)1 ); |
| Vec_PtrPush( vRes, fFlag0 ? vIndex1 : vIndex2 ); |
| Vec_PtrPush( vRes, fFlag0 ? vIndex2 : vIndex1 ); |
| } |
| if ( Vec_PtrSize(vRes) == 0 ) |
| Abc_Print( 0, "Templates are not defined.\n" ); |
| // print templates |
| // printf( "Found %d templates\n", Vec_PtrSize(vRes)/4 ); |
| // Scl_LibertyPrintTemplates( vRes ); |
| return vRes; |
| } |
| Vec_Str_t * Scl_LibertyReadSclStr( Scl_Tree_t * p, int fVerbose, int fVeryVerbose ) |
| { |
| int fUseFirstTable = 0; |
| Vec_Str_t * vOut; |
| Vec_Ptr_t * vNameIns, * vTemples = NULL; |
| Scl_Item_t * pCell, * pPin, * pTiming; |
| Vec_Wrd_t * vTruth; |
| char * pFormula, * pName; |
| int i, k, Counter, nOutputs, nCells; |
| int nSkipped[3] = {0}; |
| |
| // read delay-table templates |
| vTemples = Scl_LibertyReadTemplates( p ); |
| |
| // start the library |
| vOut = Vec_StrAlloc( 10000 ); |
| Vec_StrPutI_( vOut, ABC_SCL_CUR_VERSION ); |
| |
| // top level information |
| Vec_StrPut_( vOut ); |
| Vec_StrPutS_( vOut, Scl_LibertyReadString(p, Scl_LibertyRoot(p)->Head) ); |
| Vec_StrPutS_( vOut, Scl_LibertyReadDefaultWireLoad(p) ); |
| Vec_StrPutS_( vOut, Scl_LibertyReadDefaultWireLoadSel(p) ); |
| Vec_StrPutF_( vOut, Scl_LibertyReadDefaultMaxTrans(p) ); |
| Vec_StrPutI_( vOut, Scl_LibertyReadTimeUnit(p) ); |
| Scl_LibertyReadLoadUnit( p, vOut ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| |
| // read wire loads |
| Scl_LibertyReadWireLoad( p, vOut ); |
| Scl_LibertyReadWireLoadSelect( p, vOut ); |
| |
| // count cells |
| nCells = 0; |
| Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pCell, "cell" ) |
| { |
| if ( Scl_LibertyReadCellIsFlop(p, pCell) ) |
| { |
| if ( fVeryVerbose ) printf( "Scl_LibertyReadGenlib() skipped sequential cell \"%s\".\n", Scl_LibertyReadString(p, pCell->Head) ); |
| nSkipped[0]++; |
| continue; |
| } |
| if ( Scl_LibertyReadCellIsThreeState(p, pCell) ) |
| { |
| if ( fVeryVerbose ) printf( "Scl_LibertyReadGenlib() skipped three-state cell \"%s\".\n", Scl_LibertyReadString(p, pCell->Head) ); |
| nSkipped[1]++; |
| continue; |
| } |
| if ( (Counter = Scl_LibertyReadCellOutputNum(p, pCell)) == 0 ) |
| { |
| if ( fVeryVerbose ) printf( "Scl_LibertyReadGenlib() skipped cell \"%s\" without logic function.\n", Scl_LibertyReadString(p, pCell->Head) ); |
| nSkipped[2]++; |
| continue; |
| } |
| nCells++; |
| } |
| // read cells |
| Vec_StrPutI_( vOut, nCells ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| Scl_ItemForEachChildName( p, Scl_LibertyRoot(p), pCell, "cell" ) |
| { |
| if ( Scl_LibertyReadCellIsFlop(p, pCell) ) |
| continue; |
| if ( Scl_LibertyReadCellIsThreeState(p, pCell) ) |
| continue; |
| if ( (Counter = Scl_LibertyReadCellOutputNum(p, pCell)) == 0 ) |
| continue; |
| // top level information |
| Vec_StrPutS_( vOut, Scl_LibertyReadString(p, pCell->Head) ); |
| pName = Scl_LibertyReadCellArea(p, pCell); |
| Vec_StrPutF_( vOut, pName ? atof(pName) : 1 ); |
| pName = Scl_LibertyReadCellLeakage(p, pCell); |
| Vec_StrPutF_( vOut, pName ? atof(pName) : 0 ); |
| Vec_StrPutI_( vOut, Scl_LibertyReadDeriveStrength(p, pCell) ); |
| // pin count |
| nOutputs = Scl_LibertyReadCellOutputNum( p, pCell ); |
| Vec_StrPutI_( vOut, Scl_LibertyItemNum(p, pCell, "pin") - nOutputs ); |
| Vec_StrPutI_( vOut, nOutputs ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| |
| // input pins |
| vNameIns = Vec_PtrAlloc( 16 ); |
| Scl_ItemForEachChildName( p, pCell, pPin, "pin" ) |
| { |
| float CapOne, CapRise, CapFall; |
| if ( Scl_LibertyReadPinFormula(p, pPin) != NULL ) // skip output pin |
| continue; |
| assert( Scl_LibertyReadPinDirection(p, pPin) == 0 ); |
| pName = Scl_LibertyReadString(p, pPin->Head); |
| Vec_PtrPush( vNameIns, Abc_UtilStrsav(pName) ); |
| Vec_StrPutS_( vOut, pName ); |
| CapOne = Scl_LibertyReadPinCap( p, pPin, "capacitance" ); |
| CapRise = Scl_LibertyReadPinCap( p, pPin, "rise_capacitance" ); |
| CapFall = Scl_LibertyReadPinCap( p, pPin, "fall_capacitance" ); |
| if ( CapRise == 0 ) |
| CapRise = CapOne; |
| if ( CapFall == 0 ) |
| CapFall = CapOne; |
| Vec_StrPutF_( vOut, CapRise ); |
| Vec_StrPutF_( vOut, CapFall ); |
| Vec_StrPut_( vOut ); |
| } |
| Vec_StrPut_( vOut ); |
| // output pins |
| Scl_ItemForEachChildName( p, pCell, pPin, "pin" ) |
| { |
| if ( !Scl_LibertyReadPinFormula(p, pPin) ) // skip input pin |
| continue; |
| assert( Scl_LibertyReadPinDirection(p, pPin) == 1 ); |
| pName = Scl_LibertyReadString(p, pPin->Head); |
| Vec_StrPutS_( vOut, pName ); |
| Vec_StrPutF_( vOut, Scl_LibertyReadPinCap( p, pPin, "max_capacitance" ) ); |
| Vec_StrPutF_( vOut, Scl_LibertyReadPinCap( p, pPin, "max_transition" ) ); |
| Vec_StrPutI_( vOut, Vec_PtrSize(vNameIns) ); |
| pFormula = Scl_LibertyReadPinFormula(p, pPin); |
| Vec_StrPutS_( vOut, pFormula ); |
| // write truth table |
| vTruth = Mio_ParseFormulaTruth( pFormula, (char **)Vec_PtrArray(vNameIns), Vec_PtrSize(vNameIns) ); |
| if ( vTruth == NULL ) |
| return NULL; |
| for ( i = 0; i < Abc_Truth6WordNum(Vec_PtrSize(vNameIns)); i++ ) |
| Vec_StrPutW_( vOut, Vec_WrdEntry(vTruth, i) ); |
| Vec_WrdFree( vTruth ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| |
| // write the delay tables |
| if ( fUseFirstTable ) |
| { |
| Vec_PtrForEachEntry( char *, vNameIns, pName, i ) |
| { |
| pTiming = Scl_LibertyReadPinTiming( p, pPin, pName ); |
| Vec_StrPutS_( vOut, pName ); |
| Vec_StrPutI_( vOut, (int)(pTiming != NULL) ); |
| if ( pTiming == NULL ) // output does not depend on input |
| continue; |
| Vec_StrPutI_( vOut, Scl_LibertyReadTimingSense(p, pTiming) ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| // some cells only have 'rise' or 'fall' but not both - here we work around this |
| if ( !Scl_LibertyReadTable( p, vOut, pTiming, "cell_rise", vTemples ) ) |
| if ( !Scl_LibertyReadTable( p, vOut, pTiming, "cell_fall", vTemples ) ) |
| { printf( "Table cannot be found\n" ); return NULL; } |
| if ( !Scl_LibertyReadTable( p, vOut, pTiming, "cell_fall", vTemples ) ) |
| if ( !Scl_LibertyReadTable( p, vOut, pTiming, "cell_rise", vTemples ) ) |
| { printf( "Table cannot be found\n" ); return NULL; } |
| if ( !Scl_LibertyReadTable( p, vOut, pTiming, "rise_transition", vTemples ) ) |
| if ( !Scl_LibertyReadTable( p, vOut, pTiming, "fall_transition", vTemples ) ) |
| { printf( "Table cannot be found\n" ); return NULL; } |
| if ( !Scl_LibertyReadTable( p, vOut, pTiming, "fall_transition", vTemples ) ) |
| if ( !Scl_LibertyReadTable( p, vOut, pTiming, "rise_transition", vTemples ) ) |
| { printf( "Table cannot be found\n" ); return NULL; } |
| } |
| continue; |
| } |
| |
| // write the timing tables |
| Vec_PtrForEachEntry( char *, vNameIns, pName, i ) |
| { |
| Vec_Ptr_t * vTables[4]; |
| Vec_Ptr_t * vTimings; |
| vTimings = Scl_LibertyReadPinTimingAll( p, pPin, pName ); |
| Vec_StrPutS_( vOut, pName ); |
| Vec_StrPutI_( vOut, (int)(Vec_PtrSize(vTimings) != 0) ); |
| if ( Vec_PtrSize(vTimings) == 0 ) // output does not depend on input |
| { |
| Vec_PtrFree( vTimings ); |
| continue; |
| } |
| Vec_StrPutI_( vOut, Scl_LibertyReadTimingSense(p, (Scl_Item_t *)Vec_PtrEntry(vTimings, 0)) ); |
| Vec_StrPut_( vOut ); |
| Vec_StrPut_( vOut ); |
| // collect the timing tables |
| for ( k = 0; k < 4; k++ ) |
| vTables[k] = Vec_PtrAlloc( 16 ); |
| Vec_PtrForEachEntry( Scl_Item_t *, vTimings, pTiming, k ) |
| { |
| // some cells only have 'rise' or 'fall' but not both - here we work around this |
| if ( !Scl_LibertyScanTable( p, vTables[0], pTiming, "cell_rise", vTemples ) ) |
| if ( !Scl_LibertyScanTable( p, vTables[0], pTiming, "cell_fall", vTemples ) ) |
| { printf( "Table cannot be found\n" ); return NULL; } |
| if ( !Scl_LibertyScanTable( p, vTables[1], pTiming, "cell_fall", vTemples ) ) |
| if ( !Scl_LibertyScanTable( p, vTables[1], pTiming, "cell_rise", vTemples ) ) |
| { printf( "Table cannot be found\n" ); return NULL; } |
| if ( !Scl_LibertyScanTable( p, vTables[2], pTiming, "rise_transition", vTemples ) ) |
| if ( !Scl_LibertyScanTable( p, vTables[2], pTiming, "fall_transition", vTemples ) ) |
| { printf( "Table cannot be found\n" ); return NULL; } |
| if ( !Scl_LibertyScanTable( p, vTables[3], pTiming, "fall_transition", vTemples ) ) |
| if ( !Scl_LibertyScanTable( p, vTables[3], pTiming, "rise_transition", vTemples ) ) |
| { printf( "Table cannot be found\n" ); return NULL; } |
| } |
| Vec_PtrFree( vTimings ); |
| // compute worse case of the tables |
| for ( k = 0; k < 4; k++ ) |
| { |
| Vec_Flt_t * vInd0, * vInd1, * vValues; |
| if ( !Scl_LibertyComputeWorstCase( vTables[k], &vInd0, &vInd1, &vValues ) ) |
| { printf( "Table indexes have different values\n" ); return NULL; } |
| Vec_VecFree( (Vec_Vec_t *)vTables[k] ); |
| Scl_LibertyDumpTables( vOut, vInd0, vInd1, vValues ); |
| Vec_FltFree( vInd0 ); |
| Vec_FltFree( vInd1 ); |
| Vec_FltFree( vValues ); |
| } |
| } |
| } |
| Vec_StrPut_( vOut ); |
| Vec_PtrFreeFree( vNameIns ); |
| } |
| // free templates |
| if ( vTemples ) |
| { |
| Vec_Flt_t * vArray; |
| assert( Vec_PtrSize(vTemples) % 4 == 0 ); |
| Vec_PtrForEachEntry( Vec_Flt_t *, vTemples, vArray, i ) |
| { |
| if ( vArray == NULL ) |
| continue; |
| if ( i % 4 == 0 ) |
| ABC_FREE( vArray ); |
| else if ( i % 4 == 2 || i % 4 == 3 ) |
| Vec_FltFree( vArray ); |
| } |
| Vec_PtrFree( vTemples ); |
| } |
| if ( fVerbose ) |
| { |
| printf( "Library \"%s\" from \"%s\" has %d cells ", |
| Scl_LibertyReadString(p, Scl_LibertyRoot(p)->Head), p->pFileName, nCells ); |
| printf( "(%d skipped: %d seq; %d tri-state; %d no func). ", |
| nSkipped[0]+nSkipped[1]+nSkipped[2], nSkipped[0], nSkipped[1], nSkipped[2] ); |
| Abc_PrintTime( 1, "Time", Abc_Clock() - p->clkStart ); |
| } |
| return vOut; |
| } |
| SC_Lib * Abc_SclReadLiberty( char * pFileName, int fVerbose, int fVeryVerbose ) |
| { |
| SC_Lib * pLib; |
| Scl_Tree_t * p; |
| Vec_Str_t * vStr; |
| p = Scl_LibertyParse( pFileName, fVeryVerbose ); |
| if ( p == NULL ) |
| return NULL; |
| // Scl_LibertyParseDump( p, "temp_.lib" ); |
| // collect relevant data |
| vStr = Scl_LibertyReadSclStr( p, fVerbose, fVeryVerbose ); |
| Scl_LibertyStop( p, fVeryVerbose ); |
| if ( vStr == NULL ) |
| return NULL; |
| // construct SCL data-structure |
| pLib = Abc_SclReadFromStr( vStr ); |
| if ( pLib == NULL ) |
| return NULL; |
| pLib->pFileName = Abc_UtilStrsav( pFileName ); |
| Abc_SclLibNormalize( pLib ); |
| Vec_StrFree( vStr ); |
| // printf( "Average slew = %.2f ps\n", Abc_SclComputeAverageSlew(pLib) ); |
| return pLib; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Experiments with Liberty parsing.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| void Scl_LibertyTest() |
| { |
| char * pFileName = "bwrc.lib"; |
| int fVerbose = 1; |
| int fVeryVerbose = 0; |
| Scl_Tree_t * p; |
| Vec_Str_t * vStr; |
| // return; |
| p = Scl_LibertyParse( pFileName, fVeryVerbose ); |
| if ( p == NULL ) |
| return; |
| // Scl_LibertyParseDump( p, "temp_.lib" ); |
| vStr = Scl_LibertyReadSclStr( p, fVerbose, fVeryVerbose ); |
| Scl_LibertyStringDump( "test_scl.lib", vStr ); |
| Vec_StrFree( vStr ); |
| Scl_LibertyStop( p, fVerbose ); |
| } |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// END OF FILE /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| |
| ABC_NAMESPACE_IMPL_END |
| |
