From ffd77ffedda47d5ec5541c6a51bb9e80540fd3f7 Mon Sep 17 00:00:00 2001 From: Alan Mishchenko Date: Wed, 17 Sep 2014 15:14:17 -0700 Subject: Improvements to word-level Verilog parser. --- src/base/wlc/wlc.h | 141 ++++++++-------- src/base/wlc/wlcBlast.c | 401 +++++++++++++++++++++++++++++++-------------- src/base/wlc/wlcNtk.c | 59 +++---- src/base/wlc/wlcReadVer.c | 27 +-- src/base/wlc/wlcWriteVer.c | 90 +++++++++- 5 files changed, 488 insertions(+), 230 deletions(-) (limited to 'src/base') diff --git a/src/base/wlc/wlc.h b/src/base/wlc/wlc.h index 75fa11dd..a6d4553d 100644 --- a/src/base/wlc/wlc.h +++ b/src/base/wlc/wlc.h @@ -42,8 +42,8 @@ ABC_NAMESPACE_HEADER_START // object types typedef enum { WLC_OBJ_NONE = 0, // 00: unknown - WLC_OBJ_PI, // 01: primary input terminal - WLC_OBJ_PO, // 02: primary output terminal + WLC_OBJ_PI, // 01: primary input + WLC_OBJ_PO, // 02: primary output WLC_OBJ_BO, // 03: box output WLC_OBJ_BI, // 04: box input WLC_OBJ_FF, // 05: flop @@ -54,34 +54,37 @@ typedef enum { WLC_OBJ_SHIFT_RA, // 10: shift right (arithmetic) WLC_OBJ_SHIFT_L, // 11: shift left WLC_OBJ_SHIFT_LA, // 12: shift left (arithmetic) - WLC_OBJ_BIT_NOT, // 13: bitwise NOT - WLC_OBJ_BIT_AND, // 14: bitwise AND - WLC_OBJ_BIT_OR, // 15: bitwise OR - WLC_OBJ_BIT_XOR, // 16: bitwise XOR - WLC_OBJ_BIT_SELECT, // 17: bit selection - WLC_OBJ_BIT_CONCAT, // 18: bit concatenation - WLC_OBJ_BIT_ZEROPAD, // 19: zero padding - WLC_OBJ_BIT_SIGNEXT, // 20: sign extension - WLC_OBJ_LOGIC_NOT, // 21: logic NOT - WLC_OBJ_LOGIC_AND, // 22: logic AND - WLC_OBJ_LOGIC_OR, // 23: logic OR - WLC_OBJ_COMP_EQU, // 24: compare equal - WLC_OBJ_COMP_NOT, // 25: compare not equal - WLC_OBJ_COMP_LESS, // 26: compare less - WLC_OBJ_COMP_MORE, // 27: compare more - WLC_OBJ_COMP_LESSEQU, // 28: compare less or equal - WLC_OBJ_COMP_MOREEQU, // 29: compare more or equal - WLC_OBJ_REDUCT_AND, // 30: reduction AND - WLC_OBJ_REDUCT_OR, // 31: reduction OR - WLC_OBJ_REDUCT_XOR, // 32: reduction XOR - WLC_OBJ_ARI_ADD, // 33: arithmetic addition - WLC_OBJ_ARI_SUB, // 34: arithmetic subtraction - WLC_OBJ_ARI_MULTI, // 35: arithmetic multiplier - WLC_OBJ_ARI_DIVIDE, // 36: arithmetic division - WLC_OBJ_ARI_MODULUS, // 37: arithmetic modulus - WLC_OBJ_ARI_POWER, // 38: arithmetic power - WLC_OBJ_TABLE, // 39: arithmetic power - WLC_OBJ_NUMBER // 40: unused + WLC_OBJ_ROTATE_R, // 13: rotate right + WLC_OBJ_ROTATE_L, // 14: rotate left + WLC_OBJ_BIT_NOT, // 15: bitwise NOT + WLC_OBJ_BIT_AND, // 16: bitwise AND + WLC_OBJ_BIT_OR, // 17: bitwise OR + WLC_OBJ_BIT_XOR, // 18: bitwise XOR + WLC_OBJ_BIT_SELECT, // 19: bit selection + WLC_OBJ_BIT_CONCAT, // 20: bit concatenation + WLC_OBJ_BIT_ZEROPAD, // 21: zero padding + WLC_OBJ_BIT_SIGNEXT, // 22: sign extension + WLC_OBJ_LOGIC_NOT, // 23: logic NOT + WLC_OBJ_LOGIC_AND, // 24: logic AND + WLC_OBJ_LOGIC_OR, // 25: logic OR + WLC_OBJ_COMP_EQU, // 26: compare equal + WLC_OBJ_COMP_NOTEQU, // 27: compare not equal + WLC_OBJ_COMP_LESS, // 28: compare less + WLC_OBJ_COMP_MORE, // 29: compare more + WLC_OBJ_COMP_LESSEQU, // 30: compare less or equal + WLC_OBJ_COMP_MOREEQU, // 31: compare more or equal + WLC_OBJ_REDUCT_AND, // 32: reduction AND + WLC_OBJ_REDUCT_OR, // 33: reduction OR + WLC_OBJ_REDUCT_XOR, // 34: reduction XOR + WLC_OBJ_ARI_ADD, // 35: arithmetic addition + WLC_OBJ_ARI_SUB, // 36: arithmetic subtraction + WLC_OBJ_ARI_MULTI, // 37: arithmetic multiplier + WLC_OBJ_ARI_DIVIDE, // 38: arithmetic division + WLC_OBJ_ARI_MODULUS, // 39: arithmetic modulus + WLC_OBJ_ARI_POWER, // 40: arithmetic power + WLC_OBJ_ARI_MINUS, // 41: arithmetic minus + WLC_OBJ_TABLE, // 42: bit table + WLC_OBJ_NUMBER // 43: unused } Wlc_ObjType_t; @@ -89,9 +92,7 @@ typedef enum { /// BASIC TYPES /// //////////////////////////////////////////////////////////////////////// -typedef struct Wlc_Ntk_t_ Wlc_Ntk_t; typedef struct Wlc_Obj_t_ Wlc_Obj_t; - struct Wlc_Obj_t_ // 16 bytes { unsigned Type : 6; // node type @@ -104,6 +105,7 @@ struct Wlc_Obj_t_ // 16 bytes int * pFanins[1]; }; }; +typedef struct Wlc_Ntk_t_ Wlc_Ntk_t; struct Wlc_Ntk_t_ { char * pName; // model name @@ -129,50 +131,51 @@ struct Wlc_Ntk_t_ Vec_Int_t vCopies; // object first bits }; -static inline int Wlc_NtkObjNum( Wlc_Ntk_t * p ) { return p->iObj - 1; } -static inline int Wlc_NtkObjNumMax( Wlc_Ntk_t * p ) { return p->iObj; } -static inline int Wlc_NtkPiNum( Wlc_Ntk_t * p ) { return Vec_IntSize(&p->vPis); } -static inline int Wlc_NtkPoNum( Wlc_Ntk_t * p ) { return Vec_IntSize(&p->vPos); } -static inline int Wlc_NtkCiNum( Wlc_Ntk_t * p ) { return Vec_IntSize(&p->vCis); } -static inline int Wlc_NtkCoNum( Wlc_Ntk_t * p ) { return Vec_IntSize(&p->vCos); } -static inline int Wlc_NtkFfNum( Wlc_Ntk_t * p ) { return Vec_IntSize(&p->vFfs); } - -static inline Wlc_Obj_t * Wlc_NtkObj( Wlc_Ntk_t * p, int Id ) { assert(Id > 0 && Id < p->nObjsAlloc); return p->pObjs + Id; } -static inline Wlc_Obj_t * Wlc_NtkPi( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj( p, Vec_IntEntry(&p->vPis, i) ); } -static inline Wlc_Obj_t * Wlc_NtkPo( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj( p, Vec_IntEntry(&p->vPos, i) ); } -static inline Wlc_Obj_t * Wlc_NtkCi( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj( p, Vec_IntEntry(&p->vCis, i) ); } -static inline Wlc_Obj_t * Wlc_NtkCo( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj( p, Vec_IntEntry(&p->vCos, i) ); } -static inline Wlc_Obj_t * Wlc_NtkFf( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj( p, Vec_IntEntry(&p->vFfs, i) ); } - -static inline int Wlc_ObjId( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return pObj - p->pObjs; } +static inline int Wlc_NtkObjNum( Wlc_Ntk_t * p ) { return p->iObj - 1; } +static inline int Wlc_NtkObjNumMax( Wlc_Ntk_t * p ) { return p->iObj; } +static inline int Wlc_NtkPiNum( Wlc_Ntk_t * p ) { return Vec_IntSize(&p->vPis); } +static inline int Wlc_NtkPoNum( Wlc_Ntk_t * p ) { return Vec_IntSize(&p->vPos); } +static inline int Wlc_NtkCiNum( Wlc_Ntk_t * p ) { return Vec_IntSize(&p->vCis); } +static inline int Wlc_NtkCoNum( Wlc_Ntk_t * p ) { return Vec_IntSize(&p->vCos); } +static inline int Wlc_NtkFfNum( Wlc_Ntk_t * p ) { return Vec_IntSize(&p->vFfs); } + +static inline Wlc_Obj_t * Wlc_NtkObj( Wlc_Ntk_t * p, int Id ) { assert(Id > 0 && Id < p->nObjsAlloc); return p->pObjs + Id; } +static inline Wlc_Obj_t * Wlc_NtkPi( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj( p, Vec_IntEntry(&p->vPis, i) ); } +static inline Wlc_Obj_t * Wlc_NtkPo( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj( p, Vec_IntEntry(&p->vPos, i) ); } +static inline Wlc_Obj_t * Wlc_NtkCi( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj( p, Vec_IntEntry(&p->vCis, i) ); } +static inline Wlc_Obj_t * Wlc_NtkCo( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj( p, Vec_IntEntry(&p->vCos, i) ); } +static inline Wlc_Obj_t * Wlc_NtkFf( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj( p, Vec_IntEntry(&p->vFfs, i) ); } + +static inline int Wlc_ObjId( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return pObj - p->pObjs; } static inline int Wlc_ObjPioId( Wlc_Obj_t * p ) { assert(p->Type==WLC_OBJ_PI||p->Type==WLC_OBJ_PO);return p->Fanins[1]; } -static inline int Wlc_ObjFaninNum( Wlc_Obj_t * p ) { return p->nFanins; } -static inline int Wlc_ObjHasArray( Wlc_Obj_t * p ) { return p->nFanins > 2 || p->Type == WLC_OBJ_CONST; } -static inline int * Wlc_ObjFanins( Wlc_Obj_t * p ) { return Wlc_ObjHasArray(p) ? p->pFanins[0] : p->Fanins; } -static inline int Wlc_ObjFaninId( Wlc_Obj_t * p, int i ) { return Wlc_ObjFanins(p)[i]; } -static inline int Wlc_ObjFaninId0( Wlc_Obj_t * p ) { return Wlc_ObjFanins(p)[0]; } -static inline int Wlc_ObjFaninId1( Wlc_Obj_t * p ) { return Wlc_ObjFanins(p)[1]; } -static inline int Wlc_ObjFaninId2( Wlc_Obj_t * p ) { return Wlc_ObjFanins(p)[2]; } -static inline Wlc_Obj_t * Wlc_ObjFanin( Wlc_Ntk_t * p, Wlc_Obj_t * pObj, int i ) { return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, i) ); } -static inline Wlc_Obj_t * Wlc_ObjFanin0( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, 0) ); } -static inline Wlc_Obj_t * Wlc_ObjFanin1( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, 1) ); } -static inline Wlc_Obj_t * Wlc_ObjFanin2( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, 2) ); } - -static inline int Wlc_ObjRange( Wlc_Obj_t * p ) { return p->End - p->Beg + 1; } +static inline int Wlc_ObjFaninNum( Wlc_Obj_t * p ) { return p->nFanins; } +static inline int Wlc_ObjHasArray( Wlc_Obj_t * p ) { return p->nFanins > 2 || p->Type == WLC_OBJ_CONST; } +static inline int * Wlc_ObjFanins( Wlc_Obj_t * p ) { return Wlc_ObjHasArray(p) ? p->pFanins[0] : p->Fanins; } +static inline int Wlc_ObjFaninId( Wlc_Obj_t * p, int i ) { return Wlc_ObjFanins(p)[i]; } +static inline int Wlc_ObjFaninId0( Wlc_Obj_t * p ) { return Wlc_ObjFanins(p)[0]; } +static inline int Wlc_ObjFaninId1( Wlc_Obj_t * p ) { return Wlc_ObjFanins(p)[1]; } +static inline int Wlc_ObjFaninId2( Wlc_Obj_t * p ) { return Wlc_ObjFanins(p)[2]; } +static inline Wlc_Obj_t * Wlc_ObjFanin( Wlc_Ntk_t * p, Wlc_Obj_t * pObj, int i ) { return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, i) ); } +static inline Wlc_Obj_t * Wlc_ObjFanin0( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, 0) ); } +static inline Wlc_Obj_t * Wlc_ObjFanin1( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, 1) ); } +static inline Wlc_Obj_t * Wlc_ObjFanin2( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, 2) ); } + +static inline int Wlc_ObjRange( Wlc_Obj_t * p ) { return p->End - p->Beg + 1; } static inline int Wlc_ObjRangeEnd( Wlc_Obj_t * p ) { assert(p->Type == WLC_OBJ_BIT_SELECT); return p->Fanins[1] >> 16; } static inline int Wlc_ObjRangeBeg( Wlc_Obj_t * p ) { assert(p->Type == WLC_OBJ_BIT_SELECT); return p->Fanins[1] & 0xFFFF; } static inline int * Wlc_ObjConstValue( Wlc_Obj_t * p ) { assert(p->Type == WLC_OBJ_CONST); return Wlc_ObjFanins(p); } static inline int Wlc_ObjTableId( Wlc_Obj_t * p ) { assert(p->Type == WLC_OBJ_TABLE); return p->Fanins[1]; } +static inline word * Wlc_ObjTable( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return (word *)Vec_PtrEntry( p->vTables, Wlc_ObjTableId(pObj) ); } -static inline void Wlc_NtkCleanCopy( Wlc_Ntk_t * p ) { Vec_IntFill( &p->vCopies, p->nObjsAlloc, 0 ); } -static inline int Wlc_NtkHasCopy( Wlc_Ntk_t * p ) { return Vec_IntSize( &p->vCopies ) > 0; } -static inline void Wlc_ObjSetCopy( Wlc_Ntk_t * p, int iObj, int i ) { Vec_IntWriteEntry( &p->vCopies, iObj, i ); } -static inline int Wlc_ObjCopy( Wlc_Ntk_t * p, int iObj ) { return Vec_IntEntry( &p->vCopies, iObj ); } +static inline void Wlc_NtkCleanCopy( Wlc_Ntk_t * p ) { Vec_IntFill( &p->vCopies, p->nObjsAlloc, 0 ); } +static inline int Wlc_NtkHasCopy( Wlc_Ntk_t * p ) { return Vec_IntSize( &p->vCopies ) > 0; } +static inline void Wlc_ObjSetCopy( Wlc_Ntk_t * p, int iObj, int i ) { Vec_IntWriteEntry( &p->vCopies, iObj, i ); } +static inline int Wlc_ObjCopy( Wlc_Ntk_t * p, int iObj ) { return Vec_IntEntry( &p->vCopies, iObj ); } -static inline void Wlc_NtkCleanNameId( Wlc_Ntk_t * p ) { Vec_IntFill( &p->vNameIds, p->nObjsAlloc, 0 ); } -static inline int Wlc_NtkHasNameId( Wlc_Ntk_t * p ) { return Vec_IntSize( &p->vNameIds ) > 0; } -static inline void Wlc_ObjSetNameId( Wlc_Ntk_t * p, int iObj, int i ) { Vec_IntWriteEntry( &p->vNameIds, iObj, i ); } -static inline int Wlc_ObjNameId( Wlc_Ntk_t * p, int iObj ) { return Vec_IntEntry( &p->vNameIds, iObj ); } +static inline void Wlc_NtkCleanNameId( Wlc_Ntk_t * p ) { Vec_IntFill( &p->vNameIds, p->nObjsAlloc, 0 ); } +static inline int Wlc_NtkHasNameId( Wlc_Ntk_t * p ) { return Vec_IntSize( &p->vNameIds ) > 0; } +static inline void Wlc_ObjSetNameId( Wlc_Ntk_t * p, int iObj, int i ) { Vec_IntWriteEntry( &p->vNameIds, iObj, i ); } +static inline int Wlc_ObjNameId( Wlc_Ntk_t * p, int iObj ) { return Vec_IntEntry( &p->vNameIds, iObj ); } //////////////////////////////////////////////////////////////////////// /// MACRO DEFINITIONS /// diff --git a/src/base/wlc/wlcBlast.c b/src/base/wlc/wlcBlast.c index eb45773d..46947c55 100644 --- a/src/base/wlc/wlcBlast.c +++ b/src/base/wlc/wlcBlast.c @@ -33,7 +33,7 @@ ABC_NAMESPACE_IMPL_START /**Function************************************************************* - Synopsis [] + Synopsis [Helper functions.] Description [] @@ -54,7 +54,87 @@ int Wlc_NtkPrepareBits( Wlc_Ntk_t * p ) } return nBits; } -int Wlc_NtkComputeReduction( Gia_Man_t * pNew, int * pFans, int nFans, int Type ) +int * Wlc_VecCopy( Vec_Int_t * vOut, int * pArray, int nSize ) +{ + int i; Vec_IntClear( vOut ); + for( i = 0; i < nSize; i++) + Vec_IntPush( vOut, pArray[i] ); + return Vec_IntArray( vOut ); +} +int * Wlc_VecLoadFanins( Vec_Int_t * vOut, int * pFanins, int nFanins, int nTotal, int fSigned ) +{ + int Fill = fSigned ? pFanins[nFanins-1] : 0; + int i; Vec_IntClear( vOut ); + assert( nFanins <= nTotal ); + for( i = 0; i < nTotal; i++) + Vec_IntPush( vOut, i < nFanins ? pFanins[i] : Fill ); + return Vec_IntArray( vOut ); +} + +/**Function************************************************************* + + Synopsis [Bit blasting for specific operations.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Wlc_BlastShiftRight( Gia_Man_t * pNew, int * pNum, int nNum, int * pShift, int nShift, int fSticky, Vec_Int_t * vRes ) +{ + int * pRes = Wlc_VecCopy( vRes, pNum, nNum ); + int Fill = fSticky ? pNum[nNum-1] : 0; + int i, j, fShort = 0; + for( i = 0; i < nShift; i++ ) + for( j = 0; j < nNum - fSticky; j++ ) + { + if( fShort || j + (1<= nNum ) + { + pRes[j] = Gia_ManHashMux( pNew, pShift[i], Fill, pRes[j] ); + if ( (1< nNum ) + fShort = 1; + } + else + pRes[j] = Gia_ManHashMux( pNew, pShift[i], pRes[j+(1<= fSticky; j-- ) + { + if( fShort || (1< j ) + { + pRes[j] = Gia_ManHashMux( pNew, pShift[i], Fill, pRes[j] ); + if ( (1< nNum ) + fShort = 1; + } + else + pRes[j] = Gia_ManHashMux( pNew, pShift[i], pRes[j-(1<= 0; k-- ) + { + iTerm = Gia_ManHashAnd( pNew, Abc_LitNot(pArg0[k]), pArg1[k] ); + iTerm = Gia_ManHashAnd( pNew, iTerm, iEqu ); + if ( iTerm == 1 ) + return 1; + iLit = Gia_ManHashOr( pNew, iLit, iTerm ); + iEqu = Abc_LitNot( Gia_ManHashXor( pNew, pArg0[k], pArg1[k] ) ); + } + return iLit; } -void Wlc_NtkAdderChain( Gia_Man_t * pNew, int * pAdd0, int * pAdd1, int nBits ) +void Wlc_BlastAdder( Gia_Man_t * pNew, int * pAdd0, int * pAdd1, int nBits ) // result is in pAdd0 { int iCarry = 0, iTerm1, iTerm2, iTerm3, iSum, b; for ( b = 0; b < nBits; b++ ) @@ -102,11 +187,119 @@ void Wlc_NtkAdderChain( Gia_Man_t * pNew, int * pAdd0, int * pAdd1, int nBits ) pAdd0[b] = iSum; } } +void Wlc_BlastMultiplier( Gia_Man_t * pNew, int * pArg0, int * pArg1, int nBits, Vec_Int_t * vTemp, Vec_Int_t * vRes ) +{ + int i, j; + Vec_IntFill( vRes, nBits, 0 ); + for ( i = 0; i < nBits; i++ ) + { + Vec_IntFill( vTemp, i, 0 ); + for ( j = 0; Vec_IntSize(vTemp) < nBits; j++ ) + Vec_IntPush( vTemp, Gia_ManHashAnd(pNew, pArg0[j], pArg1[i]) ); + assert( Vec_IntSize(vTemp) == nBits ); + Wlc_BlastAdder( pNew, Vec_IntArray(vRes), Vec_IntArray(vTemp), nBits ); + } +} +void Wlc_BlastDivider( Gia_Man_t * pNew, int * pNum, int nNum, int * pDiv, int nDiv, int fQuo, Vec_Int_t * vRes ) +{ + int * pRes = Wlc_VecCopy( vRes, pNum, nNum ); + int * pQuo = ABC_ALLOC( int, nNum ); + int * pTemp = ABC_ALLOC( int, nNum ); + int i, j, known, borrow, y_bit, top_bit; + assert( nNum == nDiv ); + for ( j = nNum - 1; j >= 0; j-- ) + { + known = 0; + for ( i = nNum - 1; i > nNum - 1 - j; i-- ) + { + known = Gia_ManHashOr( pNew, known, pDiv[i] ); + if( known == 1 ) + break; + } + pQuo[j] = known; + for ( i = nNum - 1; i >= 0; i-- ) + { + if ( known == 1 ) + break; + y_bit = (i >= j) ? pDiv[i-j] : 0; + pQuo[j] = Gia_ManHashMux( pNew, known, pQuo[j], Gia_ManHashAnd( pNew, y_bit, Abc_LitNot(pRes[i]) ) ); + known = Gia_ManHashOr( pNew, known, Gia_ManHashXor(pNew, y_bit, pRes[i])); + } + pQuo[j] = Abc_LitNot(pQuo[j]); + if ( pQuo[j] == 0 ) + continue; + borrow = 0; + for ( i = 0; i < nNum; i++ ) + { + top_bit = Gia_ManHashMux( pNew, borrow, Abc_LitNot(pRes[i]), pRes[i] ); + y_bit = (i >= j) ? pDiv[i-j] : 0; + borrow = Gia_ManHashMux( pNew, pRes[i], Gia_ManHashAnd(pNew, borrow, y_bit), Gia_ManHashOr(pNew, borrow, y_bit) ); + pTemp[i] = Gia_ManHashXor( pNew, top_bit, y_bit ); + } + if ( pQuo[j] == 1 ) + Wlc_VecCopy( vRes, pTemp, nNum ); + else + for( i = 0; i < nNum; i++ ) + pRes[i] = Gia_ManHashMux( pNew, pQuo[j], pTemp[i], pRes[i] ); + } + ABC_FREE( pTemp ); + if ( fQuo ) + Wlc_VecCopy( vRes, pQuo, nNum ); + ABC_FREE( pQuo ); +} +void Wlc_BlastMinus( Gia_Man_t * pNew, int * pNum, int nNum, Vec_Int_t * vRes ) +{ + int i, * pRes, invert = 0; + Vec_IntFill( vRes, nNum, 0 ); + pRes = Vec_IntArray( vRes ); + for ( i = 0; i < nNum; i++ ) + { + pRes[i] = Gia_ManHashMux( pNew, invert, Abc_LitNot(pRes[i]), pRes[i] ); + invert = Gia_ManHashOr( pNew, invert, pNum[i] ); + } +} +void Wlc_BlastTable( Gia_Man_t * pNew, word * pTable, int * pFans, int nFans, int nOuts, Vec_Int_t * vRes ) +{ + extern int Kit_TruthToGia( Gia_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory, Vec_Int_t * vLeaves, int fHash ); + Vec_Int_t * vMemory = Vec_IntAlloc( 0 ); + Vec_Int_t vLeaves = { nFans, nFans, pFans }; + word * pTruth = ABC_ALLOC( word, Abc_TtWordNum(nFans) ); + int o, i, m, iLit, nMints = (1 << nFans); + Vec_IntClear( vRes ); + for ( o = 0; o < nOuts; o++ ) + { + // derive truth table + memset( pTruth, 0, sizeof(word) * Abc_TtWordNum(nFans) ); + for ( m = 0; m < nMints; m++ ) + for ( i = 0; i < nFans; i++ ) + if ( Abc_TtGetBit( pTable, m * nFans + i ) ) + Abc_TtSetBit( pTruth, m ); + // implement truth table + if ( nFans < 6 ) + pTruth[0] = Abc_Tt6Stretch( pTruth[0], nFans ); + iLit = Kit_TruthToGia( pNew, (unsigned *)pTruth, nFans, vMemory, &vLeaves, 1 ); + Vec_IntPush( vRes, iLit ); + } + Vec_IntFree( vMemory ); + ABC_FREE( pTruth ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ Gia_Man_t * Wlc_NtkBitBlast( Wlc_Ntk_t * p ) { Gia_Man_t * pTemp, * pNew; - Wlc_Obj_t * pObj; - Vec_Int_t * vBits, * vTemp0, * vTemp1, * vTemp2, * vTemp3; + Wlc_Obj_t * pObj, * pPrev = NULL; + Vec_Int_t * vBits, * vTemp0, * vTemp1, * vTemp2, * vRes; int nBits = Wlc_NtkPrepareBits( p ); int nRange, nRange0, nRange1, nRange2; int i, k, b, iLit, * pFans0, * pFans1, * pFans2; @@ -114,8 +307,8 @@ Gia_Man_t * Wlc_NtkBitBlast( Wlc_Ntk_t * p ) vTemp0 = Vec_IntAlloc( 1000 ); vTemp1 = Vec_IntAlloc( 1000 ); vTemp2 = Vec_IntAlloc( 1000 ); - vTemp3 = Vec_IntAlloc( 1000 ); - // craete AIG manager + vRes = Vec_IntAlloc( 1000 ); + // create AIG manager pNew = Gia_ManStart( 5 * Wlc_NtkObjNum(p) + 1000 ); pNew->pName = Abc_UtilStrsav( p->pName ); Gia_ManHashAlloc( pNew ); @@ -127,85 +320,79 @@ Gia_Man_t * Wlc_NtkBitBlast( Wlc_Ntk_t * p ) nRange0 = Wlc_ObjFaninNum(pObj) > 0 ? Wlc_ObjRange( Wlc_ObjFanin0(p, pObj) ) : -1; nRange1 = Wlc_ObjFaninNum(pObj) > 1 ? Wlc_ObjRange( Wlc_ObjFanin1(p, pObj) ) : -1; nRange2 = Wlc_ObjFaninNum(pObj) > 2 ? Wlc_ObjRange( Wlc_ObjFanin2(p, pObj) ) : -1; - pFans0 = Wlc_ObjFaninNum(pObj) > 0 ? Vec_IntEntryP( vBits, Wlc_ObjCopy(p, Wlc_ObjFaninId0(pObj)) ) : NULL; - pFans1 = Wlc_ObjFaninNum(pObj) > 1 ? Vec_IntEntryP( vBits, Wlc_ObjCopy(p, Wlc_ObjFaninId1(pObj)) ) : NULL; - pFans2 = Wlc_ObjFaninNum(pObj) > 2 ? Vec_IntEntryP( vBits, Wlc_ObjCopy(p, Wlc_ObjFaninId2(pObj)) ) : NULL; + pFans0 = Wlc_ObjFaninNum(pObj) > 0 ? Vec_IntEntryP( vBits, Wlc_ObjCopy(p, Wlc_ObjFaninId0(pObj)) ) : NULL; + pFans1 = Wlc_ObjFaninNum(pObj) > 1 ? Vec_IntEntryP( vBits, Wlc_ObjCopy(p, Wlc_ObjFaninId1(pObj)) ) : NULL; + pFans2 = Wlc_ObjFaninNum(pObj) > 2 ? Vec_IntEntryP( vBits, Wlc_ObjCopy(p, Wlc_ObjFaninId2(pObj)) ) : NULL; + Vec_IntClear( vRes ); if ( pObj->Type == WLC_OBJ_PI ) { for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vBits, Gia_ManAppendCi(pNew) ); + Vec_IntPush( vRes, Gia_ManAppendCi(pNew) ); } else if ( pObj->Type == WLC_OBJ_PO || pObj->Type == WLC_OBJ_BUF ) { // assert( nRange <= nRange0 ); for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vBits, k < nRange0 ? pFans0[k] : 0 ); + Vec_IntPush( vRes, k < nRange0 ? pFans0[k] : 0 ); } else if ( pObj->Type == WLC_OBJ_CONST ) { word * pTruth = (word *)Wlc_ObjFanins(pObj); for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vBits, Abc_TtGetBit(pTruth, k) ); + Vec_IntPush( vRes, Abc_TtGetBit(pTruth, k) ); } else if ( pObj->Type == WLC_OBJ_MUX ) { - assert( nRange0 == 1 ); - assert( nRange1 == nRange ); - assert( nRange2 == nRange ); + assert( nRange0 == 1 && nRange1 == nRange && nRange2 == nRange ); for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vBits, Gia_ManHashMux(pNew, pFans0[0], pFans1[k], pFans2[k]) ); + Vec_IntPush( vRes, Gia_ManHashMux(pNew, pFans0[0], pFans1[k], pFans2[k]) ); } else if ( pObj->Type == WLC_OBJ_SHIFT_R || pObj->Type == WLC_OBJ_SHIFT_RA ) { - // prepare data - int Fill = pObj->Type == WLC_OBJ_SHIFT_R ? 0 : pFans0[nRange0-1]; - int nTotal = nRange + (1 << nRange1); - Vec_IntClear( vTemp0 ); - for ( k = 0; k < nRange0; k++ ) - Vec_IntPush( vTemp0, pFans0[k] ); - for ( k = 0; k < nTotal; k++ ) - Vec_IntPush( vTemp0, Fill ); - // derive the result - for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vBits, Wlc_NtkMuxTree_rec(pNew, pFans1, nRange1, vTemp0, k) ); + assert( nRange0 >= nRange ); + Wlc_BlastShiftRight( pNew, pFans0, nRange0, pFans1, nRange1, pObj->Type == WLC_OBJ_SHIFT_RA, vRes ); + if ( nRange0 > nRange ) + Vec_IntShrink( vRes, nRange ); } else if ( pObj->Type == WLC_OBJ_SHIFT_L || pObj->Type == WLC_OBJ_SHIFT_LA ) { - // prepare data - int Fill = pObj->Type == WLC_OBJ_SHIFT_L ? 0 : pFans0[0]; - int nTotal = nRange + (1 << nRange1); - Vec_IntClear( vTemp0 ); - for ( k = 0; k < nRange0; k++ ) - Vec_IntPush( vTemp0, pFans0[k] ); - for ( k = 0; k < nTotal; k++ ) - Vec_IntPush( vTemp0, Fill ); - // derive the result - for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vBits, Wlc_NtkMuxTree_rec(pNew, pFans1, nRange1, vTemp0, k) ); + int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRange, Wlc_ObjFanin0(p, pObj)->Signed ); + assert( nRange0 <= nRange ); + Wlc_BlastShiftLeft( pNew, pArg0, nRange, pFans1, nRange1, pObj->Type == WLC_OBJ_SHIFT_LA, vRes ); + } + else if ( pObj->Type == WLC_OBJ_ROTATE_R ) + { + assert( nRange0 == nRange ); + Wlc_BlastRotateRight( pNew, pFans0, nRange0, pFans1, nRange1, vRes ); + } + else if ( pObj->Type == WLC_OBJ_ROTATE_L ) + { + assert( nRange0 == nRange ); + Wlc_BlastRotateLeft( pNew, pFans0, nRange0, pFans1, nRange1, vRes ); } else if ( pObj->Type == WLC_OBJ_BIT_NOT ) { assert( nRange == nRange0 ); for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vBits, Abc_LitNot(pFans0[k]) ); + Vec_IntPush( vRes, Abc_LitNot(pFans0[k]) ); } else if ( pObj->Type == WLC_OBJ_BIT_AND ) { assert( nRange0 == nRange && nRange1 == nRange ); for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vBits, Gia_ManHashAnd(pNew, pFans0[k], pFans1[k]) ); + Vec_IntPush( vRes, Gia_ManHashAnd(pNew, pFans0[k], pFans1[k]) ); } else if ( pObj->Type == WLC_OBJ_BIT_OR ) { assert( nRange0 == nRange && nRange1 == nRange ); for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vBits, Gia_ManHashOr(pNew, pFans0[k], pFans1[k]) ); + Vec_IntPush( vRes, Gia_ManHashOr(pNew, pFans0[k], pFans1[k]) ); } else if ( pObj->Type == WLC_OBJ_BIT_XOR ) { assert( nRange0 == nRange && nRange1 == nRange ); for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vBits, Gia_ManHashXor(pNew, pFans0[k], pFans1[k]) ); + Vec_IntPush( vRes, Gia_ManHashXor(pNew, pFans0[k], pFans1[k]) ); } else if ( pObj->Type == WLC_OBJ_BIT_SELECT ) { @@ -213,7 +400,7 @@ Gia_Man_t * Wlc_NtkBitBlast( Wlc_Ntk_t * p ) int Beg = Wlc_ObjRangeBeg(pObj); assert( nRange == End - Beg + 1 ); for ( k = Beg; k <= End; k++ ) - Vec_IntPush( vBits, pFans0[k] ); + Vec_IntPush( vRes, pFans0[k] ); } else if ( pObj->Type == WLC_OBJ_BIT_CONCAT ) { @@ -226,7 +413,7 @@ Gia_Man_t * Wlc_NtkBitBlast( Wlc_Ntk_t * p ) nRange0 = Wlc_ObjRange( Wlc_NtkObj(p, iFanin) ); pFans0 = Vec_IntEntryP( vBits, Wlc_ObjCopy(p, iFanin) ); for ( b = 0; b < nRange0; b++ ) - Vec_IntPush( vBits, pFans0[b] ); + Vec_IntPush( vRes, pFans0[b] ); } } else if ( pObj->Type == WLC_OBJ_BIT_ZEROPAD || pObj->Type == WLC_OBJ_BIT_SIGNEXT ) @@ -234,113 +421,89 @@ Gia_Man_t * Wlc_NtkBitBlast( Wlc_Ntk_t * p ) int Pad = pObj->Type == WLC_OBJ_BIT_ZEROPAD ? 0 : pFans0[nRange0-1]; assert( nRange0 < nRange ); for ( k = 0; k < nRange0; k++ ) - Vec_IntPush( vBits, pFans0[k] ); + Vec_IntPush( vRes, pFans0[k] ); for ( ; k < nRange; k++ ) - Vec_IntPush( vBits, Pad ); + Vec_IntPush( vRes, Pad ); } else if ( pObj->Type == WLC_OBJ_LOGIC_NOT ) { - iLit = Wlc_NtkComputeReduction( pNew, pFans0, nRange, WLC_OBJ_REDUCT_OR ); + iLit = Wlc_BlastReduction( pNew, pFans0, nRange, WLC_OBJ_REDUCT_OR ); assert( nRange == 1 ); - Vec_IntPush( vBits, Abc_LitNot(iLit) ); + Vec_IntFill( vRes, 1, Abc_LitNot(iLit) ); } else if ( pObj->Type == WLC_OBJ_LOGIC_AND ) { - int iLit0 = Wlc_NtkComputeReduction( pNew, pFans0, nRange, WLC_OBJ_REDUCT_OR ); - int iLit1 = Wlc_NtkComputeReduction( pNew, pFans0, nRange, WLC_OBJ_REDUCT_OR ); + int iLit0 = Wlc_BlastReduction( pNew, pFans0, nRange, WLC_OBJ_REDUCT_OR ); + int iLit1 = Wlc_BlastReduction( pNew, pFans0, nRange, WLC_OBJ_REDUCT_OR ); assert( nRange == 1 ); - Vec_IntPush( vBits, Gia_ManHashAnd(pNew, iLit0, iLit1) ); + Vec_IntFill( vRes, 1, Gia_ManHashAnd(pNew, iLit0, iLit1) ); } else if ( pObj->Type == WLC_OBJ_LOGIC_OR ) { - int iLit0 = Wlc_NtkComputeReduction( pNew, pFans0, nRange, WLC_OBJ_REDUCT_OR ); - int iLit1 = Wlc_NtkComputeReduction( pNew, pFans0, nRange, WLC_OBJ_REDUCT_OR ); + int iLit0 = Wlc_BlastReduction( pNew, pFans0, nRange, WLC_OBJ_REDUCT_OR ); + int iLit1 = Wlc_BlastReduction( pNew, pFans0, nRange, WLC_OBJ_REDUCT_OR ); assert( nRange == 1 ); - Vec_IntPush( vBits, Gia_ManHashOr(pNew, iLit0, iLit1) ); + Vec_IntFill( vRes, 1, Gia_ManHashOr(pNew, iLit0, iLit1) ); } - else if ( pObj->Type == WLC_OBJ_COMP_EQU || pObj->Type == WLC_OBJ_COMP_NOT ) + else if ( pObj->Type == WLC_OBJ_COMP_EQU || pObj->Type == WLC_OBJ_COMP_NOTEQU ) { int iLit = 0; - assert( nRange == 1 ); - assert( nRange0 == nRange1 ); + assert( nRange == 1 && nRange0 == nRange1 ); for ( k = 0; k < nRange0; k++ ) iLit = Gia_ManHashOr( pNew, iLit, Gia_ManHashXor(pNew, pFans0[k], pFans1[k]) ); - Vec_IntPush( vBits, Abc_LitNotCond(iLit, pObj->Type == WLC_OBJ_COMP_EQU) ); + Vec_IntFill( vRes, 1, Abc_LitNotCond(iLit, pObj->Type == WLC_OBJ_COMP_EQU) ); } else if ( pObj->Type == WLC_OBJ_COMP_LESS || pObj->Type == WLC_OBJ_COMP_MOREEQU || pObj->Type == WLC_OBJ_COMP_MORE || pObj->Type == WLC_OBJ_COMP_LESSEQU ) { - int iTerm, iEqu = 1, iLit = 0; + int fSwap = (pObj->Type == WLC_OBJ_COMP_MORE || pObj->Type == WLC_OBJ_COMP_LESSEQU); + int fCompl = (pObj->Type == WLC_OBJ_COMP_MOREEQU || pObj->Type == WLC_OBJ_COMP_LESSEQU); assert( nRange == 1 ); assert( nRange0 == nRange1 ); - if ( pObj->Type == WLC_OBJ_COMP_MORE || pObj->Type == WLC_OBJ_COMP_LESSEQU ) - ABC_SWAP( int *, pFans0, pFans1 ); - for ( k = nRange0 - 1; k >= 0; k-- ) - { - iTerm = Gia_ManHashAnd( pNew, Abc_LitNot(pFans0[k]), pFans1[k] ); - iTerm = Gia_ManHashAnd( pNew, iTerm, iEqu ); - iLit = Gia_ManHashOr( pNew, iLit, iTerm ); - iEqu = Abc_LitNot( Gia_ManHashXor( pNew, pFans0[k], pFans1[k] ) ); - } - Vec_IntPush( vBits, Abc_LitNotCond(iLit, pObj->Type == WLC_OBJ_COMP_MOREEQU) ); + if ( fSwap ) ABC_SWAP( int *, pFans0, pFans1 ); + iLit = Wlc_BlastLess( pNew, pFans0, pFans1, nRange0 ); + iLit = Abc_LitNotCond( iLit, fCompl ); + Vec_IntFill( vRes, 1, iLit ); } else if ( pObj->Type == WLC_OBJ_REDUCT_AND || pObj->Type == WLC_OBJ_REDUCT_OR || pObj->Type == WLC_OBJ_REDUCT_XOR ) - Vec_IntPush( vBits, Wlc_NtkComputeReduction( pNew, pFans0, nRange, pObj->Type ) ); - else if ( pObj->Type == WLC_OBJ_ARI_ADD ) + Vec_IntPush( vRes, Wlc_BlastReduction( pNew, pFans0, nRange, pObj->Type ) ); + else if ( pObj->Type == WLC_OBJ_ARI_ADD || pObj->Type == WLC_OBJ_ARI_SUB ) // SUBTRACT is not implemented! { - int Pad0 = Wlc_ObjFanin0(p, pObj)->Signed ? pFans0[nRange0-1] : 0; - int Pad1 = Wlc_ObjFanin1(p, pObj)->Signed ? pFans1[nRange1-1] : 0; - assert( nRange0 <= nRange && nRange1 <= nRange ); - Vec_IntClear( vTemp0 ); - for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vTemp0, k < nRange0 ? pFans0[k] : Pad0 ); - Vec_IntClear( vTemp1 ); - for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vTemp1, k < nRange1 ? pFans1[k] : Pad1 ); - Wlc_NtkAdderChain( pNew, Vec_IntArray(vTemp0), Vec_IntArray(vTemp1), nRange ); - Vec_IntAppend( vBits, vTemp0 ); + int * pArg0 = Wlc_VecLoadFanins( vRes, pFans0, nRange0, nRange, Wlc_ObjFanin0(p, pObj)->Signed ); + int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRange, Wlc_ObjFanin1(p, pObj)->Signed ); + Wlc_BlastAdder( pNew, pArg0, pArg1, nRange ); // result is in pFan0 (vRes) } else if ( pObj->Type == WLC_OBJ_ARI_MULTI ) { - int Pad0 = Wlc_ObjFanin0(p, pObj)->Signed ? pFans0[nRange0-1] : 0; - int Pad1 = Wlc_ObjFanin1(p, pObj)->Signed ? pFans1[nRange1-1] : 0; + int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRange, Wlc_ObjFanin0(p, pObj)->Signed ); + int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRange, Wlc_ObjFanin1(p, pObj)->Signed ); assert( nRange0 <= nRange && nRange1 <= nRange ); - Vec_IntClear( vTemp0 ); - for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vTemp0, k < nRange0 ? pFans0[k] : Pad0 ); - Vec_IntClear( vTemp1 ); - for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vTemp1, k < nRange1 ? pFans1[k] : Pad1 ); - // iterate - Vec_IntFill( vTemp3, nRange, 0 ); - for ( k = 0; k < nRange; k++ ) - { - Vec_IntFill( vTemp2, k, 0 ); - Vec_IntForEachEntry( vTemp0, iLit, b ) - { - Vec_IntPush( vTemp2, Gia_ManHashAnd(pNew, iLit, Vec_IntEntry(vTemp1, k)) ); - if ( Vec_IntSize(vTemp2) == nRange ) - break; - } - assert( Vec_IntSize(vTemp2) == nRange ); - Wlc_NtkAdderChain( pNew, Vec_IntArray(vTemp3), Vec_IntArray(vTemp2), nRange ); - } - assert( Vec_IntSize(vTemp3) == nRange ); - Vec_IntAppend( vBits, vTemp3 ); + Wlc_BlastMultiplier( pNew, pArg0, pArg1, nRange, vTemp2, vRes ); } - else if ( pObj->Type == WLC_OBJ_TABLE ) + else if ( pObj->Type == WLC_OBJ_ARI_DIVIDE || pObj->Type == WLC_OBJ_ARI_MODULUS ) { - assert( pObj->Type != WLC_OBJ_TABLE ); - for ( k = 0; k < nRange; k++ ) - Vec_IntPush( vBits, 0 ); + int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRange, Wlc_ObjFanin0(p, pObj)->Signed ); + int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRange, Wlc_ObjFanin1(p, pObj)->Signed ); + assert( nRange0 <= nRange && nRange1 <= nRange ); + Wlc_BlastDivider( pNew, pArg0, nRange0, pArg1, nRange1, pObj->Type == WLC_OBJ_ARI_DIVIDE, vRes ); } + else if ( pObj->Type == WLC_OBJ_ARI_MINUS ) + { + assert( nRange0 == nRange ); + Wlc_BlastMinus( pNew, pFans0, nRange0, vRes ); + } + else if ( pObj->Type == WLC_OBJ_TABLE ) + Wlc_BlastTable( pNew, Wlc_ObjTable(p, pObj), pFans0, nRange0, nRange, vRes ); else assert( 0 ); + assert( Vec_IntSize(vBits) == Wlc_ObjCopy(p, i) ); + Vec_IntAppend( vBits, vRes ); + pPrev = pObj; } assert( nBits == Vec_IntSize(vBits) ); Vec_IntFree( vTemp0 ); Vec_IntFree( vTemp1 ); Vec_IntFree( vTemp2 ); - Vec_IntFree( vTemp3 ); + Vec_IntFree( vRes ); // create POs Wlc_NtkForEachPo( p, pObj, i ) { diff --git a/src/base/wlc/wlcNtk.c b/src/base/wlc/wlcNtk.c index 2ca90d00..890432e3 100644 --- a/src/base/wlc/wlcNtk.c +++ b/src/base/wlc/wlcNtk.c @@ -42,34 +42,37 @@ static char * Wlc_Names[WLC_OBJ_NUMBER+1] = { ">>>", // 10: shift right (arithmetic) "<<", // 11: shift left "<<<", // 12: shift left (arithmetic) - "~", // 13: bitwise NOT - "&", // 14: bitwise AND - "|", // 15: bitwise OR - "^", // 16: bitwise XOR - "[:]", // 17: bit selection - "{,}", // 18: bit concatenation - "BitPad", // 19: zero padding - "SgnExt", // 20: sign extension - "!", // 21: logic NOT - "&&", // 22: logic AND - "||", // 23: logic OR - "==", // 24: compare equal - "!=", // 25: compare not equal - "<", // 26: compare less - ">", // 27: compare more - "<=", // 28: compare less or equal - ">=", // 29: compare more or equal - "&", // 30: reduction AND - "|", // 31: reduction OR - "^", // 32: reduction XOR - "+", // 33: arithmetic addition - "-", // 34: arithmetic subtraction - "*", // 35: arithmetic multiplier - "//", // 36: arithmetic division - "%%", // 37: arithmetic modulus - "**", // 38: arithmetic power - "table", // 39: lookup table - NULL // 40: unused + "rotateR", // 13: shift left (arithmetic) + "rotateL", // 14: shift left (arithmetic) + "~", // 15: bitwise NOT + "&", // 16: bitwise AND + "|", // 17: bitwise OR + "^", // 18: bitwise XOR + "[:]", // 19: bit selection + "{,}", // 20: bit concatenation + "bitPad", // 21: zero padding + "signExtend", // 22: sign extension + "!", // 23: logic NOT + "&&", // 24: logic AND + "||", // 25: logic OR + "==", // 26: compare equal + "!=", // 27: compare not equal + "<", // 28: compare less + ">", // 29: compare more + "<=", // 30: compare less or equal + ">=", // 31: compare more or equal + "&", // 32: reduction AND + "|", // 33: reduction OR + "^", // 34: reduction XOR + "+", // 35: arithmetic addition + "-", // 36: arithmetic subtraction + "*", // 37: arithmetic multiplier + "//", // 38: arithmetic division + "%%", // 39: arithmetic modulus + "**", // 40: arithmetic power + "-", // 41: arithmetic minus + "table", // 42: bit table + NULL // 43: unused }; //////////////////////////////////////////////////////////////////////// diff --git a/src/base/wlc/wlcReadVer.c b/src/base/wlc/wlcReadVer.c index 724699b7..9ee81844 100644 --- a/src/base/wlc/wlcReadVer.c +++ b/src/base/wlc/wlcReadVer.c @@ -409,6 +409,7 @@ static inline char * Wlc_PrsReadConstant( Wlc_Prs_t * p, char * pStr, Vec_Int_t *pRange = Abc_Base2Log( Number ); while ( Wlc_PrsIsDigit(pStr) ) pStr++; + Vec_IntFill( vFanins, 1, Number ); return pStr; } pStr = Wlc_PrsFindSymbol( pStr, '\'' ); @@ -424,7 +425,7 @@ static inline char * Wlc_PrsReadConstant( Wlc_Prs_t * p, char * pStr, Vec_Int_t if ( nDigits != (nBits + 3)/4 ) { // return (char *)(ABC_PTRINT_T)Wlc_PrsWriteErrorMessage( p, pStr, "The length of a constant does not match." ); - printf( "Warning: The length of a constant (%d hex digits) does not match the number of bits (%d).\n", nDigits, nBits ); +// printf( "Warning: The length of a constant (%d hex digits) does not match the number of bits (%d).\n", nDigits, nBits ); } *pRange = nBits; pStr += 2; @@ -452,7 +453,7 @@ static inline char * Wlc_PrsReadName( Wlc_Prs_t * p, char * pStr, Vec_Int_t * vF Wlc_ObjAddFanins( p->pNtk, Wlc_NtkObj(p->pNtk, iObj), vFanins ); Vec_IntFree( vFanins ); // add node's name - sprintf( Buffer, "const%d", p->nConsts++ ); + sprintf( Buffer, "_c%d_", p->nConsts++ ); NameId = Abc_NamStrFindOrAdd( p->pNtk->pManName, Buffer, &fFound ); if ( fFound ) return (char *)(ABC_PTRINT_T)Wlc_PrsWriteErrorMessage( p, pStr, "Name %s is already used.", Buffer ); @@ -530,7 +531,7 @@ static inline int Wlc_PrsFindDefinition( Wlc_Prs_t * p, char * pStr, Vec_Int_t * if ( !(pStr = Wlc_PrsReadName(p, pStr, vFanins)) ) return Wlc_PrsWriteErrorMessage( p, pStr, "Cannot read name after !." ); } - else if ( pStr[0] == '&' || pStr[0] == '|' || pStr[0] == '^' ) + else if ( pStr[0] == '&' || pStr[0] == '|' || pStr[0] == '^' || pStr[0] == '-' ) { if ( pStr[0] == '&' ) Type = WLC_OBJ_REDUCT_AND; @@ -538,9 +539,11 @@ static inline int Wlc_PrsFindDefinition( Wlc_Prs_t * p, char * pStr, Vec_Int_t * Type = WLC_OBJ_REDUCT_OR; else if ( pStr[0] == '^' ) Type = WLC_OBJ_REDUCT_XOR; + else if ( pStr[0] == '-' ) + Type = WLC_OBJ_ARI_MINUS; else assert( 0 ); if ( !(pStr = Wlc_PrsReadName(p, pStr+1, vFanins)) ) - return Wlc_PrsWriteErrorMessage( p, pStr, "Cannot read name after reduction operator." ); + return Wlc_PrsWriteErrorMessage( p, pStr, "Cannot read name after a unary operator." ); } else if ( pStr[0] == '{' ) { @@ -603,9 +606,9 @@ static inline int Wlc_PrsFindDefinition( Wlc_Prs_t * p, char * pStr, Vec_Int_t * } else { - if ( pStr[0] == '>' && pStr[1] == '>' && pStr[2] != '>' ) pStr += 2, Type = WLC_OBJ_SHIFT_R; + if ( pStr[0] == '>' && pStr[1] == '>' && pStr[2] != '>' ) pStr += 2, Type = fRotating ? WLC_OBJ_ROTATE_R : WLC_OBJ_SHIFT_R; else if ( pStr[0] == '>' && pStr[1] == '>' && pStr[2] == '>' ) pStr += 3, Type = WLC_OBJ_SHIFT_RA; - else if ( pStr[0] == '<' && pStr[1] == '<' && pStr[2] != '<' ) pStr += 2, Type = WLC_OBJ_SHIFT_L; + else if ( pStr[0] == '<' && pStr[1] == '<' && pStr[2] != '<' ) pStr += 2, Type = fRotating ? WLC_OBJ_ROTATE_L : WLC_OBJ_SHIFT_L; else if ( pStr[0] == '<' && pStr[1] == '<' && pStr[2] == '<' ) pStr += 3, Type = WLC_OBJ_SHIFT_LA; else if ( pStr[0] == '&' && pStr[1] != '&' ) pStr += 1, Type = WLC_OBJ_BIT_AND; else if ( pStr[0] == '|' && pStr[1] != '|' ) pStr += 1, Type = WLC_OBJ_BIT_OR; @@ -613,7 +616,7 @@ static inline int Wlc_PrsFindDefinition( Wlc_Prs_t * p, char * pStr, Vec_Int_t * else if ( pStr[0] == '&' && pStr[1] == '&' ) pStr += 2, Type = WLC_OBJ_LOGIC_AND; else if ( pStr[0] == '|' && pStr[1] == '|' ) pStr += 2, Type = WLC_OBJ_LOGIC_OR; else if ( pStr[0] == '=' && pStr[1] == '=' ) pStr += 2, Type = WLC_OBJ_COMP_EQU; - else if ( pStr[0] == '!' && pStr[1] == '=' ) pStr += 2, Type = WLC_OBJ_COMP_NOT; + else if ( pStr[0] == '!' && pStr[1] == '=' ) pStr += 2, Type = WLC_OBJ_COMP_NOTEQU; else if ( pStr[0] == '<' && pStr[1] != '=' ) pStr += 1, Type = WLC_OBJ_COMP_LESS; else if ( pStr[0] == '>' && pStr[1] != '=' ) pStr += 1, Type = WLC_OBJ_COMP_MORE; else if ( pStr[0] == '<' && pStr[1] == '=' ) pStr += 2, Type = WLC_OBJ_COMP_LESSEQU; @@ -702,6 +705,7 @@ int Wlc_PrsDerive( Wlc_Prs_t * p ) if ( Wlc_PrsStrCmp( pName, "table" ) ) { // THIS IS A HACK TO DETECT tables + int Width1, Width2; int v, b, Value, nBits, nInts, * pTable; Vec_Int_t * vValues = Vec_IntAlloc( 256 ); Wlc_PrsForEachLineStart( p, pStart, i, i+1 ) @@ -711,9 +715,11 @@ int Wlc_PrsDerive( Wlc_Prs_t * p ) pStart = Wlc_PrsFindSymbol( pStart, '\'' ); if ( pStart == NULL ) continue; + Width1 = atoi(pStart-1); pStart = Wlc_PrsFindSymbol( pStart+2, '\'' ); if ( pStart == NULL ) continue; + Width2 = atoi(pStart-1); Value = 0; Abc_TtReadHexNumber( (word *)&Value, pStart+2 ); Vec_IntPush( vValues, Value ); @@ -725,14 +731,15 @@ int Wlc_PrsDerive( Wlc_Prs_t * p ) Vec_IntFree( vValues ); return Wlc_PrsWriteErrorMessage( p, pStart, "Cannot read module \"%s\".", pName ); } + assert( Width1 == nBits ); // create bitmap - nInts = Abc_BitWordNum( nBits * Vec_IntSize(vValues) ); + nInts = Abc_BitWordNum( Width2 * Vec_IntSize(vValues) ); pTable = (unsigned *)Mem_FlexEntryFetch( p->pMemTable, nInts * sizeof(unsigned) ); memset( pTable, 0, nInts * sizeof(unsigned) ); Vec_IntForEachEntry( vValues, Value, v ) - for ( b = 0; b < nBits; b++ ) + for ( b = 0; b < Width2; b++ ) if ( (Value >> b) & 1 ) - Abc_InfoSetBit( pTable, v * nBits + b ); + Abc_InfoSetBit( pTable, v * Width2 + b ); Vec_PtrPush( p->vTables, pTable ); Vec_IntFree( vValues ); continue; diff --git a/src/base/wlc/wlcWriteVer.c b/src/base/wlc/wlcWriteVer.c index 3086011a..6899d462 100644 --- a/src/base/wlc/wlcWriteVer.c +++ b/src/base/wlc/wlcWriteVer.c @@ -31,6 +31,60 @@ ABC_NAMESPACE_IMPL_START /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Wlc_WriteTableOne( FILE * pFile, int nFans, int nOuts, word * pTable, int Id ) +{ + int m, nMints = (1< 0 && nOuts <= 64 && (64 % nOuts) == 0 ); + fprintf( pFile, "module table%d(ind, val);\n", Id ); + fprintf( pFile, " input [%d:0] ind;\n", nFans-1 ); + fprintf( pFile, " output [%d:0] val;\n", nOuts-1 ); + fprintf( pFile, " reg [%d:0] val;\n", nOuts-1 ); + fprintf( pFile, " always @(ind)\n" ); + fprintf( pFile, " begin\n" ); + fprintf( pFile, " case (ind)\n" ); + for ( m = 0; m < nMints; m++ ) + fprintf( pFile, " %d\'h%x: val = %d\'h%x;\n", nFans, m, nOuts, (pTable[(nOuts * m) >> 6] >> ((nOuts * m) & 63)) & Abc_Tt6Mask(nOuts) ); + fprintf( pFile, " endcase\n" ); + fprintf( pFile, " end\n" ); + fprintf( pFile, "endmodule\n" ); + fprintf( pFile, "\n" ); +} +void Wlc_WriteTables( FILE * pFile, Wlc_Ntk_t * p ) +{ + Vec_Int_t * vNodes; + Wlc_Obj_t * pObj, * pFanin; + word * pTable; + int i; + if ( p->vTables == NULL || Vec_PtrSize(p->vTables) == 0 ) + return; + // map tables into their nodes + vNodes = Vec_IntStart( Vec_PtrSize(p->vTables) ); + Wlc_NtkForEachObj( p, pObj, i ) + if ( pObj->Type == WLC_OBJ_TABLE ) + Vec_IntWriteEntry( vNodes, Wlc_ObjTableId(pObj), i ); + // write tables + Vec_PtrForEachEntry( word *, p->vTables, pTable, i ) + { + pObj = Wlc_NtkObj( p, Vec_IntEntry(vNodes, i) ); + assert( pObj->Type == WLC_OBJ_TABLE ); + pFanin = Wlc_ObjFanin0( p, pObj ); + Wlc_WriteTableOne( pFile, Wlc_ObjRange(pFanin), Wlc_ObjRange(pObj), pTable, i ); + } + Vec_IntFree( vNodes ); +} + /**Function************************************************************* Synopsis [] @@ -80,23 +134,50 @@ void Wlc_WriteVerInt( FILE * pFile, Wlc_Ntk_t * p ) if ( Wlc_NtkPoNum(p) > 0 ) Wlc_WriteVerIntVec( pFile, p, &p->vPos, 3 ); fprintf( pFile, " );\n" ); + // mark fanins of rotation shifts + Wlc_NtkForEachObj( p, pObj, i ) + if ( pObj->Type == WLC_OBJ_ROTATE_R || pObj->Type == WLC_OBJ_ROTATE_L ) + Wlc_ObjFanin1(p, pObj)->Mark = 1; Wlc_NtkForEachObj( p, pObj, i ) { char * pName = Wlc_ObjName(p, i); char * pName0 = Wlc_ObjFaninNum(pObj) ? Wlc_ObjName(p, Wlc_ObjFaninId0(pObj)) : NULL; int nDigits = Abc_Base10Log(pObj->End+1) + Abc_Base10Log(pObj->Beg+1); + if ( pObj->Mark ) + { + pObj->Mark = 0; + continue; + } sprintf( Range, "%s[%d:%d]%*s", pObj->Signed ? "signed ":" ", pObj->End, pObj->Beg, 8-nDigits, "" ); fprintf( pFile, " " ); - assert( pObj->Type != WLC_OBJ_TABLE ); if ( pObj->Type == WLC_OBJ_PI ) - fprintf( pFile, "input wire %s %-16s", Range, pName ); + fprintf( pFile, "input wire %s %s", Range, pName ); else if ( pObj->Type == WLC_OBJ_PO ) fprintf( pFile, "output wire %s %-16s = %s", Range, pName, pName0 ); + else if ( pObj->Type == WLC_OBJ_TABLE ) + { + // wire [3:0] s4972; table0 s4972_Index(s4971, s4972); + fprintf( pFile, " wire %s %s ; table%d s%d_Index(%s, %s)", Range, pName, Wlc_ObjTableId(pObj), i, pName0, pName ); + } else if ( pObj->Type == WLC_OBJ_CONST ) { fprintf( pFile, " wire %s %-16s = %d\'%sh", Range, pName, Wlc_ObjRange(pObj), pObj->Signed ? "s":"" ); Abc_TtPrintHexArrayRev( pFile, (word *)Wlc_ObjConstValue(pObj), (Wlc_ObjRange(pObj) + 3) / 4 ); } + else if ( pObj->Type == WLC_OBJ_ROTATE_R || pObj->Type == WLC_OBJ_ROTATE_L ) + { + // wire [27:0] s4960 = (s57 >> 17) | (s57 << 11); + Wlc_Obj_t * pShift = Wlc_ObjFanin1(p, pObj); + int Num0 = *Wlc_ObjConstValue(pShift); + int Num1 = Wlc_ObjRange(pObj) - Num0; + assert( pShift->Type == WLC_OBJ_CONST ); + assert( Num0 > 0 && Num0 < Wlc_ObjRange(pObj) ); + fprintf( pFile, " wire %s %-16s = ", Range, Wlc_ObjName(p, i) ); + if ( pObj->Type == WLC_OBJ_ROTATE_R ) + fprintf( pFile, "(%s >> %d) | (%s << %d)", pName0, Num0, pName0, Num1 ); + else + fprintf( pFile, "(%s << %d) | (%s >> %d)", pName0, Num0, pName0, Num1 ); + } else { fprintf( pFile, " wire %s %-16s = ", Range, Wlc_ObjName(p, i) ); @@ -127,7 +208,7 @@ void Wlc_WriteVerInt( FILE * pFile, Wlc_Ntk_t * p ) fprintf( pFile, " %s%s", Wlc_ObjName(p, Wlc_ObjFaninId(pObj, k)), k == Wlc_ObjFaninNum(pObj)-1 ? "":"," ); fprintf( pFile, " }" ); } - else + else { fprintf( pFile, "%s ", Wlc_ObjName(p, Wlc_ObjFaninId(pObj, 0)) ); if ( pObj->Type == WLC_OBJ_SHIFT_R ) @@ -150,7 +231,7 @@ void Wlc_WriteVerInt( FILE * pFile, Wlc_Ntk_t * p ) fprintf( pFile, "||" ); else if ( pObj->Type == WLC_OBJ_COMP_EQU ) fprintf( pFile, "==" ); - else if ( pObj->Type == WLC_OBJ_COMP_NOT ) + else if ( pObj->Type == WLC_OBJ_COMP_NOTEQU ) fprintf( pFile, "!=" ); else if ( pObj->Type == WLC_OBJ_COMP_LESS ) fprintf( pFile, "<" ); @@ -191,6 +272,7 @@ void Wlc_WriteVer( Wlc_Ntk_t * p, char * pFileName ) } fprintf( pFile, "// Benchmark \"%s\" written by ABC on %s\n", p->pName, Extra_TimeStamp() ); fprintf( pFile, "\n" ); + Wlc_WriteTables( pFile, p ); Wlc_WriteVerInt( pFile, p ); fprintf( pFile, "\n" ); fclose( pFile ); -- cgit v1.2.3