wlnWlc.c File Reference

#include "wln.h"
#include "base/wlc/wlc.h"

Include dependency graph for wlnWlc.c:

Go to the source code of this file.

Functions
ABC_NAMESPACE_IMPL_START int	Ndr_TypeWlc2Ndr (int Type)
	DECLARATIONS ///.
char *	Wln_ConstFromBits (int *pBits, int nBits)
	FUNCTION DEFINITIONS ///.
char *	Wln_ConstFromStr (char *pBits, int nBits)
int	Wln_TrasformNameId (Wln_Ntk_t *pNew, Wlc_Ntk_t *p, Wlc_Obj_t *pObj)
Wln_Ntk_t *	Wln_NtkFromWlc (Wlc_Ntk_t *p)
void	Wln_NtkFromWlcTest (Wlc_Ntk_t *p)

Function Documentation

Ndr_TypeWlc2Ndr()

ABC_NAMESPACE_IMPL_START int Ndr_TypeWlc2Ndr ( int Type )

extern

DECLARATIONS ///.

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

FileName [wlnWlc.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Word-level network.]

Synopsis [Network transformation.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

wlnWlc.c,v 1.00 2018/09/23 00:00:00 alanmi Exp

]

Definition at line 106 of file wlcNdr.c.

{
    if ( Type == WLC_OBJ_CONST )          return ABC_OPER_CONST;        // 06: constant
    if ( Type == WLC_OBJ_BUF )            return ABC_OPER_BIT_BUF;      // 07: buffer
    if ( Type == WLC_OBJ_MUX )            return ABC_OPER_BIT_MUX;      // 08: multiplexer
    if ( Type == WLC_OBJ_SHIFT_R )        return ABC_OPER_SHIFT_R;      // 09: shift right
    if ( Type == WLC_OBJ_SHIFT_RA )       return ABC_OPER_SHIFT_RA;     // 10: shift right (arithmetic)
    if ( Type == WLC_OBJ_SHIFT_L )        return ABC_OPER_SHIFT_L;      // 11: shift left
    if ( Type == WLC_OBJ_SHIFT_LA )       return ABC_OPER_SHIFT_LA;     // 12: shift left (arithmetic)
    if ( Type == WLC_OBJ_ROTATE_R )       return ABC_OPER_SHIFT_ROTR;   // 13: rotate right
    if ( Type == WLC_OBJ_ROTATE_L )       return ABC_OPER_SHIFT_ROTL;   // 14: rotate left
    if ( Type == WLC_OBJ_BIT_NOT )        return ABC_OPER_BIT_INV;      // 15: bitwise NOT
    if ( Type == WLC_OBJ_BIT_AND )        return ABC_OPER_BIT_AND;      // 16: bitwise AND
    if ( Type == WLC_OBJ_BIT_OR )         return ABC_OPER_BIT_OR;       // 17: bitwise OR
    if ( Type == WLC_OBJ_BIT_XOR )        return ABC_OPER_BIT_XOR;      // 18: bitwise XOR
    if ( Type == WLC_OBJ_BIT_NAND )       return ABC_OPER_BIT_NAND;     // 19: bitwise AND
    if ( Type == WLC_OBJ_BIT_NOR )        return ABC_OPER_BIT_NOR;      // 20: bitwise OR
    if ( Type == WLC_OBJ_BIT_NXOR )       return ABC_OPER_BIT_NXOR;     // 21: bitwise NXOR
    if ( Type == WLC_OBJ_BIT_SELECT )     return ABC_OPER_SLICE;        // 22: bit selection
    if ( Type == WLC_OBJ_BIT_CONCAT )     return ABC_OPER_CONCAT;       // 23: bit concatenation
    if ( Type == WLC_OBJ_BIT_ZEROPAD )    return ABC_OPER_ZEROPAD;      // 24: zero padding
    if ( Type == WLC_OBJ_BIT_SIGNEXT )    return ABC_OPER_SIGNEXT;      // 25: sign extension
    if ( Type == WLC_OBJ_LOGIC_NOT )      return ABC_OPER_LOGIC_NOT;    // 26: logic NOT
    if ( Type == WLC_OBJ_LOGIC_IMPL )     return ABC_OPER_LOGIC_IMPL;   // 27: logic implication
    if ( Type == WLC_OBJ_LOGIC_AND )      return ABC_OPER_LOGIC_AND;    // 28: logic AND
    if ( Type == WLC_OBJ_LOGIC_OR )       return ABC_OPER_LOGIC_OR;     // 29: logic OR
    if ( Type == WLC_OBJ_LOGIC_XOR )      return ABC_OPER_LOGIC_XOR;    // 30: logic XOR
    if ( Type == WLC_OBJ_SEL )            return ABC_OPER_SEL_SEL;      // 57: selector
    if ( Type == WLC_OBJ_DEC )            return ABC_OPER_SEL_DEC;      // 58: decoder
    if ( Type == WLC_OBJ_COMP_EQU )       return ABC_OPER_COMP_EQU;     // 31: compare equal
    if ( Type == WLC_OBJ_COMP_NOTEQU )    return ABC_OPER_COMP_NOTEQU;  // 32: compare not equal
    if ( Type == WLC_OBJ_COMP_LESS )      return ABC_OPER_COMP_LESS;    // 33: compare less
    if ( Type == WLC_OBJ_COMP_MORE )      return ABC_OPER_COMP_MORE;    // 34: compare more
    if ( Type == WLC_OBJ_COMP_LESSEQU )   return ABC_OPER_COMP_LESSEQU; // 35: compare less or equal
    if ( Type == WLC_OBJ_COMP_MOREEQU )   return ABC_OPER_COMP_MOREEQU; // 36: compare more or equal
    if ( Type == WLC_OBJ_REDUCT_AND )     return ABC_OPER_RED_AND;      // 37: reduction AND
    if ( Type == WLC_OBJ_REDUCT_OR )      return ABC_OPER_RED_OR;       // 38: reduction OR
    if ( Type == WLC_OBJ_REDUCT_XOR )     return ABC_OPER_RED_XOR;      // 39: reduction XOR
    if ( Type == WLC_OBJ_REDUCT_NAND )    return ABC_OPER_RED_NAND;     // 40: reduction NAND
    if ( Type == WLC_OBJ_REDUCT_NOR )     return ABC_OPER_RED_NOR;      // 41: reduction NOR
    if ( Type == WLC_OBJ_REDUCT_NXOR )    return ABC_OPER_RED_NXOR;     // 42: reduction NXOR
    if ( Type == WLC_OBJ_ARI_ADD )        return ABC_OPER_ARI_ADD;      // 43: arithmetic addition
    if ( Type == WLC_OBJ_ARI_SUB )        return ABC_OPER_ARI_SUB;      // 44: arithmetic subtraction
    if ( Type == WLC_OBJ_ARI_MULTI )      return ABC_OPER_ARI_MUL;      // 45: arithmetic multiplier
    if ( Type == WLC_OBJ_ARI_DIVIDE )     return ABC_OPER_ARI_DIV;      // 46: arithmetic division
    if ( Type == WLC_OBJ_ARI_REM )        return ABC_OPER_ARI_REM;      // 47: arithmetic remainder
    if ( Type == WLC_OBJ_ARI_MODULUS )    return ABC_OPER_ARI_MOD;      // 48: arithmetic modulus
    if ( Type == WLC_OBJ_ARI_POWER )      return ABC_OPER_ARI_POW;      // 49: arithmetic power
    if ( Type == WLC_OBJ_ARI_MINUS )      return ABC_OPER_ARI_MIN;      // 50: arithmetic minus
    if ( Type == WLC_OBJ_ARI_SQRT )       return ABC_OPER_ARI_SQRT;     // 51: integer square root
    if ( Type == WLC_OBJ_ARI_SQUARE )     return ABC_OPER_ARI_SQUARE;   // 52: integer square
    if ( Type == WLC_OBJ_ARI_ADDSUB )     return ABC_OPER_ARI_ADDSUB;   // 56: adder-subtractor
    if ( Type == WLC_OBJ_ARI_MULTI )      return ABC_OPER_ARI_SMUL;     // 45: signed multiplier
    if ( Type == WLC_OBJ_FO )             return ABC_OPER_DFFRSE;       // 03: flop
    if ( Type == WLC_OBJ_FF )             return ABC_OPER_DFFRSE;       // 05: flop
    if ( Type == WLC_OBJ_READ )           return ABC_OPER_RAMR;         // 54: read port
    if ( Type == WLC_OBJ_WRITE )          return ABC_OPER_RAMW;         // 55: write port
    if ( Type == WLC_OBJ_LUT )            return ABC_OPER_LUT;          // 59: LUT
    return -1;
}

Here is the caller graph for this function:

Wln_ConstFromBits()

char * Wln_ConstFromBits	(	int *	pBits,
		int	nBits )

FUNCTION DEFINITIONS ///.

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 47 of file wlnWlc.c.

{
    char * pBuffer = ABC_ALLOC( char, nBits+100 ); int i, Len;
    sprintf( pBuffer, "%d\'b", nBits );
    Len = strlen(pBuffer);
    for ( i = nBits-1; i >= 0; i-- )
        pBuffer[Len++] = '0' + Abc_InfoHasBit((unsigned *)pBits, i);
    pBuffer[Len] = 0;
    return pBuffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_ConstFromStr()

char * Wln_ConstFromStr	(	char *	pBits,
		int	nBits )

Definition at line 57 of file wlnWlc.c.

{
    char * pBuffer = ABC_ALLOC( char, nBits+100 ); int i, Len;
    sprintf( pBuffer, "%d\'b", nBits );
    Len = strlen(pBuffer);
    for ( i = 0; i < nBits; i++ )
        pBuffer[Len++] = pBits[i];
    pBuffer[Len] = 0;
    return pBuffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkFromWlc()

Wln_Ntk_t * Wln_NtkFromWlc

(

Wlc_Ntk_t *

p

)

Definition at line 71 of file wlnWlc.c.

{
    Wlc_Obj_t * pObj; 
    char Buffer[1000];
    int i, j, n, Type, iFanin, iOutId, iBit = 0;
    Vec_Int_t * vFanins = Vec_IntAlloc( 10 );
    Vec_Int_t * vInits = Vec_IntAlloc( Wlc_NtkFfNum(p) );
    Wln_Ntk_t * pNew = Wln_NtkAlloc( p->pName, Wlc_NtkObjNum(p)+Wlc_NtkCoNum(p)+Wlc_NtkFfNum(p) );
    pNew->pManName = Abc_NamStart( Abc_NamObjNumMax(p->pManName), 10 );
    if ( p->pSpec ) pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    pNew->fSmtLib = p->fSmtLib;
    Wlc_NtkCleanCopy( p );
    Wln_NtkCleanNameId( pNew );
    // add primary inputs
    Wlc_NtkForEachPi( p, pObj, i ) 
    {
        iOutId = Wln_ObjAlloc( pNew, ABC_OPER_CI, pObj->Signed, pObj->End, pObj->Beg );
        Wln_ObjSetNameId( pNew, iOutId, Wln_TrasformNameId(pNew, p, pObj) );
        Wlc_ObjSetCopy( p, Wlc_ObjId(p, pObj), iOutId );
    }
    // create initial state of the flops
    Wlc_NtkForEachCi( p, pObj, i ) 
    {
        assert( i == Wlc_ObjCiId(pObj) );
        if ( pObj->Type == WLC_OBJ_PI )
            continue;
        for ( j = 0; j < Wlc_ObjRange(pObj); j++ )
            if ( p->pInits[iBit+j] == 'x' )
                break;
        // print flop init state
        if ( 1 )
        {
            printf( "Flop %3d init state: %d\'b", i-Wlc_NtkPiNum(p), Wlc_ObjRange(pObj) );
            if ( j == Wlc_ObjRange(pObj) )
            {
                int Count = 0;
                for ( n = 0; n < Wlc_ObjRange(pObj); n++ )
                    Count += p->pInits[iBit+n] == '0';
                if ( Count == Wlc_ObjRange(pObj) )
                    printf( "0" );
                else
                    for ( n = 0; n < Wlc_ObjRange(pObj); n++ )
                        printf( "%c", p->pInits[iBit+n] );
            }
            else
            {
                int Count = 0;
                for ( n = 0; n < Wlc_ObjRange(pObj); n++ )
                    Count += p->pInits[iBit+n] == 'x';
                printf( "x" );
                if ( Count != Wlc_ObjRange(pObj) )
                    printf( " (range %d)", Wlc_ObjRange(pObj) );
            }
            printf( "\n" );
        }
        Type = j == Wlc_ObjRange(pObj) ? ABC_OPER_CONST : ABC_OPER_CI; 
        iOutId = Wln_ObjAlloc( pNew, Type, pObj->Signed, pObj->End, pObj->Beg );
        if ( j == Wlc_ObjRange(pObj) ) // constant
        {
            char * pString = Wln_ConstFromStr(p->pInits + iBit, Wlc_ObjRange(pObj));
            Wln_ObjSetConst( pNew, iOutId, Abc_NamStrFindOrAdd(pNew->pManName, pString, NULL) );
            ABC_FREE( pString );
        }
        sprintf( Buffer, "ff_init_%d", Vec_IntSize(vInits) );
        Wln_ObjSetNameId( pNew, iOutId, Abc_NamStrFindOrAdd(pNew->pManName, Buffer, NULL) );
        Vec_IntPush( vInits, iOutId );
        iBit += Wlc_ObjRange(pObj);
    }
    assert( p->pInits == NULL || iBit == (int)strlen(p->pInits) );
    // add flop outputs
    Wlc_NtkForEachCi( p, pObj, i ) 
    {
        assert( i == Wlc_ObjCiId(pObj) );
        if ( pObj->Type == WLC_OBJ_PI )
            continue;
        iOutId = Wln_ObjAlloc( pNew, ABC_OPER_DFFRSE, pObj->Signed, pObj->End, pObj->Beg );
        Wln_ObjSetNameId( pNew, iOutId, Wln_TrasformNameId(pNew, p, pObj) );
        Wlc_ObjSetCopy( p, Wlc_ObjId(p, pObj), iOutId );
    }
    // add internal nodes 
    Wlc_NtkForEachObj( p, pObj, i ) 
    {
        if ( Wlc_ObjIsCi(pObj) || pObj->Type == 0 )
            continue;
        iOutId = Wln_ObjAlloc( pNew, Ndr_TypeWlc2Ndr(pObj->Type), pObj->Signed, pObj->End, pObj->Beg );
        Vec_IntClear( vFanins );
        Wlc_ObjForEachFanin( pObj, iFanin, n )
            Vec_IntPush( vFanins, Wlc_ObjCopy(p, iFanin) );
        Wln_ObjAddFanins( pNew, iOutId, vFanins );
        if ( pObj->Type == WLC_OBJ_BIT_SELECT )
            Wln_ObjSetSlice( pNew, iOutId, Hash_Int2ManInsert(pNew->pRanges, pObj->End, pObj->Beg, 0) );
        else if ( pObj->Type == WLC_OBJ_CONST )
        {
            char * pString = Wln_ConstFromBits(Wlc_ObjConstValue(pObj), Wlc_ObjRange(pObj));
            Wln_ObjSetConst( pNew, iOutId, Abc_NamStrFindOrAdd(pNew->pManName, pString, NULL) );
            ABC_FREE( pString );
        }
//        else if ( Type == ABC_OPER_BIT_MUX && Vec_IntSize(vFanins) == 3 )
//            ABC_SWAP( int, Wln_ObjFanins(p, iObj)[1], Wln_ObjFanins(p, iObj)[2] );
        Wln_ObjSetNameId( pNew, iOutId, Wln_TrasformNameId(pNew, p, pObj) );
        Wlc_ObjSetCopy( p, i, iOutId );
    }
    Wlc_NtkForEachPo( p, pObj, i ) 
    {
        iOutId = Wln_ObjAlloc( pNew, ABC_OPER_CO, pObj->Signed, pObj->End, pObj->Beg );
        Wln_ObjAddFanin( pNew, iOutId, Wlc_ObjCopy(p, Wlc_ObjId(p, pObj)) );
        //Wln_ObjSetNameId( pNew, iOutId, Wln_TrasformNameId(pNew, p, pObj) );
    }
    assert( Vec_IntSize(vInits) == Wlc_NtkCoNum(p) - Wlc_NtkPoNum(p) );
    Wlc_NtkForEachCo( p, pObj, i ) 
    {
        if ( i < Wlc_NtkPoNum(p) )
            continue;
        //char * pInNames[8] = {"d", "clk", "reset", "set", "enable", "async", "sre", "init"};
        Vec_IntClear( vFanins );
        Vec_IntPush( vFanins, Wlc_ObjCopy(p, Wlc_ObjFaninId0(pObj)) );
        for ( n = 0; n < 6; n++ )
            Vec_IntPush( vFanins, 0 );
        Vec_IntPush( vFanins, Vec_IntEntry(vInits, i-Wlc_NtkPoNum(p)) );
        Wln_ObjAddFanins( pNew, Vec_IntEntry(&pNew->vFfs, i-Wlc_NtkPoNum(p)), vFanins );
    }
    Vec_IntFree( vFanins );
    Vec_IntFree( vInits );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkFromWlcTest()

void Wln_NtkFromWlcTest

(

Wlc_Ntk_t *

p

)

Definition at line 196 of file wlnWlc.c.

{
    Wln_Ntk_t * pNew = Wln_NtkFromWlc( p );
    Wln_WriteVer( pNew, "test_wlc2wln.v" );
    Wln_NtkFree( pNew );
}

Here is the call graph for this function:

Wln_TrasformNameId()

int Wln_TrasformNameId	(	Wln_Ntk_t *	pNew,
		Wlc_Ntk_t *	p,
		Wlc_Obj_t *	pObj )

Definition at line 67 of file wlnWlc.c.

{
    return Abc_NamStrFindOrAdd( pNew->pManName, Wlc_ObjName(p, Wlc_ObjId(p, pObj)), NULL );
}

Here is the call graph for this function:

Here is the caller graph for this function: