wlc.h File Reference

#include "aig/gia/gia.h"
#include "misc/extra/extra.h"
#include "misc/util/utilNam.h"
#include "misc/mem/mem.h"
#include "misc/util/utilTruth.h"

Go to the source code of this file.

Data Structures
struct	Wlc_Obj_t_
struct	Wlc_Ntk_t_

Macros
#define	Wlc_NtkForEachObj(p, pObj, i)   for ( i = 1; (i < Wlc_NtkObjNumMax(p)) && (((pObj) = Wlc_NtkObj(p, i)), 1); i++ )
	MACRO DEFINITIONS ///. More...
#define	Wlc_NtkForEachObjVec(vVec, p, pObj, i)   for ( i = 0; (i < Vec_IntSize(vVec)) && (((pObj) = Wlc_NtkObj(p, Vec_IntEntry(vVec, i))), 1); i++ )
#define	Wlc_NtkForEachPi(p, pPi, i)   for ( i = 0; (i < Wlc_NtkPiNum(p)) && (((pPi) = Wlc_NtkPi(p, i)), 1); i++ )
#define	Wlc_NtkForEachPo(p, pPo, i)   for ( i = 0; (i < Wlc_NtkPoNum(p)) && (((pPo) = Wlc_NtkPo(p, i)), 1); i++ )
#define	Wlc_NtkForEachCi(p, pCi, i)   for ( i = 0; (i < Wlc_NtkCiNum(p)) && (((pCi) = Wlc_NtkCi(p, i)), 1); i++ )
#define	Wlc_NtkForEachCo(p, pCo, i)   for ( i = 0; (i < Wlc_NtkCoNum(p)) && (((pCo) = Wlc_NtkCo(p, i)), 1); i++ )
#define	Wlc_NtkForEachFf(p, pFf, i)   for ( i = 0; (i < Vec_IntSize(&p->vFfs)) && (((pFf) = Wlc_NtkFf(p, i)), 1); i++ )
#define	Wlc_ObjForEachFanin(pObj, iFanin, i)   for ( i = 0; (i < Wlc_ObjFaninNum(pObj)) && (((iFanin) = Wlc_ObjFaninId(pObj, i)), 1); i++ )
#define	Wlc_ObjForEachFaninReverse(pObj, iFanin, i)   for ( i = Wlc_ObjFaninNum(pObj) - 1; (i >= 0) && (((iFanin) = Wlc_ObjFaninId(pObj, i)), 1); i-- )

Typedefs
typedef struct Wlc_Obj_t_	Wlc_Obj_t
	BASIC TYPES ///. More...
typedef struct Wlc_Ntk_t_	Wlc_Ntk_t

Enumerations
enum	Wlc_ObjType_t {   WLC_OBJ_NONE = 0, WLC_OBJ_PI, WLC_OBJ_PO, WLC_OBJ_FO,   WLC_OBJ_FI, WLC_OBJ_FF, WLC_OBJ_CONST, WLC_OBJ_BUF,   WLC_OBJ_MUX, WLC_OBJ_SHIFT_R, WLC_OBJ_SHIFT_RA, WLC_OBJ_SHIFT_L,   WLC_OBJ_SHIFT_LA, WLC_OBJ_ROTATE_R, WLC_OBJ_ROTATE_L, WLC_OBJ_BIT_NOT,   WLC_OBJ_BIT_AND, WLC_OBJ_BIT_OR, WLC_OBJ_BIT_XOR, WLC_OBJ_BIT_SELECT,   WLC_OBJ_BIT_CONCAT, WLC_OBJ_BIT_ZEROPAD, WLC_OBJ_BIT_SIGNEXT, WLC_OBJ_LOGIC_NOT,   WLC_OBJ_LOGIC_AND, WLC_OBJ_LOGIC_OR, WLC_OBJ_COMP_EQU, WLC_OBJ_COMP_NOTEQU,   WLC_OBJ_COMP_LESS, WLC_OBJ_COMP_MORE, WLC_OBJ_COMP_LESSEQU, WLC_OBJ_COMP_MOREEQU,   WLC_OBJ_REDUCT_AND, WLC_OBJ_REDUCT_OR, WLC_OBJ_REDUCT_XOR, WLC_OBJ_ARI_ADD,   WLC_OBJ_ARI_SUB, WLC_OBJ_ARI_MULTI, WLC_OBJ_ARI_DIVIDE, WLC_OBJ_ARI_MODULUS,   WLC_OBJ_ARI_POWER, WLC_OBJ_ARI_MINUS, WLC_OBJ_TABLE, WLC_OBJ_NUMBER }
	INCLUDES ///. More...

Functions
static int	Wlc_NtkObjNum (Wlc_Ntk_t *p)
static int	Wlc_NtkObjNumMax (Wlc_Ntk_t *p)
static int	Wlc_NtkPiNum (Wlc_Ntk_t *p)
static int	Wlc_NtkPoNum (Wlc_Ntk_t *p)
static int	Wlc_NtkCiNum (Wlc_Ntk_t *p)
static int	Wlc_NtkCoNum (Wlc_Ntk_t *p)
static int	Wlc_NtkFfNum (Wlc_Ntk_t *p)
static Wlc_Obj_t *	Wlc_NtkObj (Wlc_Ntk_t *p, int Id)
static Wlc_Obj_t *	Wlc_NtkPi (Wlc_Ntk_t *p, int i)
static Wlc_Obj_t *	Wlc_NtkPo (Wlc_Ntk_t *p, int i)
static Wlc_Obj_t *	Wlc_NtkCi (Wlc_Ntk_t *p, int i)
static Wlc_Obj_t *	Wlc_NtkCo (Wlc_Ntk_t *p, int i)
static Wlc_Obj_t *	Wlc_NtkFf (Wlc_Ntk_t *p, int i)
static int	Wlc_ObjIsPi (Wlc_Obj_t *p)
static int	Wlc_ObjIsPo (Wlc_Obj_t *p)
static int	Wlc_ObjIsCi (Wlc_Obj_t *p)
static int	Wlc_ObjIsCo (Wlc_Obj_t *p)
static int	Wlc_ObjId (Wlc_Ntk_t *p, Wlc_Obj_t *pObj)
static int	Wlc_ObjCiId (Wlc_Obj_t *p)
static int	Wlc_ObjFaninNum (Wlc_Obj_t *p)
static int	Wlc_ObjHasArray (Wlc_Obj_t *p)
static int *	Wlc_ObjFanins (Wlc_Obj_t *p)
static int	Wlc_ObjFaninId (Wlc_Obj_t *p, int i)
static int	Wlc_ObjFaninId0 (Wlc_Obj_t *p)
static int	Wlc_ObjFaninId1 (Wlc_Obj_t *p)
static int	Wlc_ObjFaninId2 (Wlc_Obj_t *p)
static Wlc_Obj_t *	Wlc_ObjFanin (Wlc_Ntk_t *p, Wlc_Obj_t *pObj, int i)
static Wlc_Obj_t *	Wlc_ObjFanin0 (Wlc_Ntk_t *p, Wlc_Obj_t *pObj)
static Wlc_Obj_t *	Wlc_ObjFanin1 (Wlc_Ntk_t *p, Wlc_Obj_t *pObj)
static Wlc_Obj_t *	Wlc_ObjFanin2 (Wlc_Ntk_t *p, Wlc_Obj_t *pObj)
static int	Wlc_ObjRange (Wlc_Obj_t *p)
static int	Wlc_ObjRangeEnd (Wlc_Obj_t *p)
static int	Wlc_ObjRangeBeg (Wlc_Obj_t *p)
static int	Wlc_ObjIsSigned (Wlc_Obj_t *p)
static int	Wlc_ObjIsSignedFanin01 (Wlc_Ntk_t *p, Wlc_Obj_t *pObj)
static int	Wlc_ObjSign (Wlc_Obj_t *p)
static int *	Wlc_ObjConstValue (Wlc_Obj_t *p)
static int	Wlc_ObjTableId (Wlc_Obj_t *p)
static word *	Wlc_ObjTable (Wlc_Ntk_t *p, Wlc_Obj_t *pObj)
static void	Wlc_NtkCleanCopy (Wlc_Ntk_t *p)
static int	Wlc_NtkHasCopy (Wlc_Ntk_t *p)
static void	Wlc_ObjSetCopy (Wlc_Ntk_t *p, int iObj, int i)
static int	Wlc_ObjCopy (Wlc_Ntk_t *p, int iObj)
static Wlc_Obj_t *	Wlc_ObjCopyObj (Wlc_Ntk_t *pNew, Wlc_Ntk_t *p, Wlc_Obj_t *pObj)
static void	Wlc_NtkCleanNameId (Wlc_Ntk_t *p)
static int	Wlc_NtkHasNameId (Wlc_Ntk_t *p)
static void	Wlc_ObjSetNameId (Wlc_Ntk_t *p, int iObj, int i)
static int	Wlc_ObjNameId (Wlc_Ntk_t *p, int iObj)
static Wlc_Obj_t *	Wlc_ObjFoToFi (Wlc_Ntk_t *p, Wlc_Obj_t *pObj)
int	Wlc_NtkPairIsUifable (Wlc_Ntk_t *p, Wlc_Obj_t *pObj, Wlc_Obj_t *pObj2)
	FUNCTION DECLARATIONS ///. More...
Vec_Int_t *	Wlc_NtkCollectMultipliers (Wlc_Ntk_t *p)
Vec_Int_t *	Wlc_NtkFindUifableMultiplierPairs (Wlc_Ntk_t *p)
Wlc_Ntk_t *	Wlc_NtkAbstractNodes (Wlc_Ntk_t *pNtk, Vec_Int_t *vNodes)
Wlc_Ntk_t *	Wlc_NtkUifNodePairs (Wlc_Ntk_t *pNtk, Vec_Int_t *vPairs)
Gia_Man_t *	Wlc_NtkBitBlast (Wlc_Ntk_t *p, Vec_Int_t *vBoxIds)
Wlc_Ntk_t *	Wlc_NtkAlloc (char *pName, int nObjsAlloc)
	FUNCTION DEFINITIONS ///. More...
int	Wlc_ObjAlloc (Wlc_Ntk_t *p, int Type, int Signed, int End, int Beg)
int	Wlc_ObjCreate (Wlc_Ntk_t *p, int Type, int Signed, int End, int Beg, Vec_Int_t *vFanins)
void	Wlc_ObjSetCi (Wlc_Ntk_t *p, Wlc_Obj_t *pObj)
void	Wlc_ObjSetCo (Wlc_Ntk_t *p, Wlc_Obj_t *pObj, int fFlopInput)
char *	Wlc_ObjName (Wlc_Ntk_t *p, int iObj)
void	Wlc_ObjUpdateType (Wlc_Ntk_t *p, Wlc_Obj_t *pObj, int Type)
void	Wlc_ObjAddFanins (Wlc_Ntk_t *p, Wlc_Obj_t *pObj, Vec_Int_t *vFanins)
void	Wlc_NtkFree (Wlc_Ntk_t *p)
void	Wlc_NtkPrintNodes (Wlc_Ntk_t *p, int Type)
void	Wlc_NtkPrintStats (Wlc_Ntk_t *p, int fDistrib, int fVerbose)
Wlc_Ntk_t *	Wlc_NtkDupDfs (Wlc_Ntk_t *p)
void	Wlc_NtkTransferNames (Wlc_Ntk_t *pNew, Wlc_Ntk_t *p)
Wlc_Ntk_t *	Wlc_ReadVer (char *pFileName)
void	Wlc_WriteVer (Wlc_Ntk_t *p, char *pFileName)

Macro Definition Documentation

#define Wlc_NtkForEachCi	(		p,
			pCi,
			i
	)		for ( i = 0; (i < Wlc_NtkCiNum(p)) && (((pCi) = Wlc_NtkCi(p, i)), 1); i++ )

Definition at line 214 of file wlc.h.

#define Wlc_NtkForEachCo	(		p,
			pCo,
			i
	)		for ( i = 0; (i < Wlc_NtkCoNum(p)) && (((pCo) = Wlc_NtkCo(p, i)), 1); i++ )

Definition at line 216 of file wlc.h.

#define Wlc_NtkForEachFf	(		p,
			pFf,
			i
	)		for ( i = 0; (i < Vec_IntSize(&p->vFfs)) && (((pFf) = Wlc_NtkFf(p, i)), 1); i++ )

Definition at line 218 of file wlc.h.

#define Wlc_NtkForEachObj	(		p,
			pObj,
			i
	)		for ( i = 1; (i < Wlc_NtkObjNumMax(p)) && (((pObj) = Wlc_NtkObj(p, i)), 1); i++ )

MACRO DEFINITIONS ///.

ITERATORS ///

Definition at line 206 of file wlc.h.

#define Wlc_NtkForEachObjVec	(		vVec,
			p,
			pObj,
			i
	)		for ( i = 0; (i < Vec_IntSize(vVec)) && (((pObj) = Wlc_NtkObj(p, Vec_IntEntry(vVec, i))), 1); i++ )

Definition at line 208 of file wlc.h.

#define Wlc_NtkForEachPi	(		p,
			pPi,
			i
	)		for ( i = 0; (i < Wlc_NtkPiNum(p)) && (((pPi) = Wlc_NtkPi(p, i)), 1); i++ )

Definition at line 210 of file wlc.h.

#define Wlc_NtkForEachPo	(		p,
			pPo,
			i
	)		for ( i = 0; (i < Wlc_NtkPoNum(p)) && (((pPo) = Wlc_NtkPo(p, i)), 1); i++ )

Definition at line 212 of file wlc.h.

#define Wlc_ObjForEachFanin	(		pObj,
			iFanin,
			i
	)		for ( i = 0; (i < Wlc_ObjFaninNum(pObj)) && (((iFanin) = Wlc_ObjFaninId(pObj, i)), 1); i++ )

Definition at line 221 of file wlc.h.

#define Wlc_ObjForEachFaninReverse	(		pObj,
			iFanin,
			i
	)		for ( i = Wlc_ObjFaninNum(pObj) - 1; (i >= 0) && (((iFanin) = Wlc_ObjFaninId(pObj, i)), 1); i-- )

Definition at line 223 of file wlc.h.

Typedef Documentation

typedef struct Wlc_Ntk_t_ Wlc_Ntk_t

Definition at line 114 of file wlc.h.

typedef struct Wlc_Obj_t_ Wlc_Obj_t

BASIC TYPES ///.

Definition at line 99 of file wlc.h.

Enumeration Type Documentation

enum Wlc_ObjType_t

INCLUDES ///.

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

FileName [wlc.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Verilog parser.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - August 22, 2014.]

Revision [

Id:

wlc.h,v 1.00 2014/09/12 00:00:00 alanmi Exp

]PARAMETERS ///

Enumerator
WLC_OBJ_NONE
WLC_OBJ_PI
WLC_OBJ_PO
WLC_OBJ_FO
WLC_OBJ_FI
WLC_OBJ_FF
WLC_OBJ_CONST
WLC_OBJ_BUF
WLC_OBJ_MUX
WLC_OBJ_SHIFT_R
WLC_OBJ_SHIFT_RA
WLC_OBJ_SHIFT_L
WLC_OBJ_SHIFT_LA
WLC_OBJ_ROTATE_R
WLC_OBJ_ROTATE_L
WLC_OBJ_BIT_NOT
WLC_OBJ_BIT_AND
WLC_OBJ_BIT_OR
WLC_OBJ_BIT_XOR
WLC_OBJ_BIT_SELECT
WLC_OBJ_BIT_CONCAT
WLC_OBJ_BIT_ZEROPAD
WLC_OBJ_BIT_SIGNEXT
WLC_OBJ_LOGIC_NOT
WLC_OBJ_LOGIC_AND
WLC_OBJ_LOGIC_OR
WLC_OBJ_COMP_EQU
WLC_OBJ_COMP_NOTEQU
WLC_OBJ_COMP_LESS
WLC_OBJ_COMP_MORE
WLC_OBJ_COMP_LESSEQU
WLC_OBJ_COMP_MOREEQU
WLC_OBJ_REDUCT_AND
WLC_OBJ_REDUCT_OR
WLC_OBJ_REDUCT_XOR
WLC_OBJ_ARI_ADD
WLC_OBJ_ARI_SUB
WLC_OBJ_ARI_MULTI
WLC_OBJ_ARI_DIVIDE
WLC_OBJ_ARI_MODULUS
WLC_OBJ_ARI_POWER
WLC_OBJ_ARI_MINUS
WLC_OBJ_TABLE
WLC_OBJ_NUMBER

Definition at line 43 of file wlc.h.

             { 
    WLC_OBJ_NONE = 0,      // 00: unknown
    WLC_OBJ_PI,            // 01: primary input 
    WLC_OBJ_PO,            // 02: primary output (unused)
    WLC_OBJ_FO,            // 03: flop output
    WLC_OBJ_FI,            // 04: flop input (unused)
    WLC_OBJ_FF,            // 05: flop (unused)
    WLC_OBJ_CONST,         // 06: constant
    WLC_OBJ_BUF,           // 07: buffer
    WLC_OBJ_MUX,           // 08: multiplexer
    WLC_OBJ_SHIFT_R,       // 09: shift right
    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_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;

Function Documentation

Wlc_Ntk_t* Wlc_NtkAbstractNodes	(	Wlc_Ntk_t *	p,
		Vec_Int_t *	vNodesInit
	)

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

Synopsis [Abstracts nodes by replacing their outputs with new PIs.]

Description [If array is NULL, abstract all multipliers.]

SideEffects []

SeeAlso []

Definition at line 137 of file wlcAbs.c.

{
    Vec_Int_t * vNodes = vNodesInit;
    Wlc_Ntk_t * pNew;
    Wlc_Obj_t * pObj;
    int i, k, iObj, iFanin;
    // get multipliers if not given
    if ( vNodes == NULL )
        vNodes = Wlc_NtkCollectMultipliers( p );
    if ( vNodes == NULL )
        return NULL;
    // mark nodes
    Wlc_NtkForEachObjVec( vNodes, p, pObj, i )
        pObj->Mark = 1;
    // iterate through the nodes in the DFS order
    Wlc_NtkCleanCopy( p );
    Wlc_NtkForEachObj( p, pObj, i )
    {
        if ( i == Vec_IntSize(&p->vCopies) )
            break;
        if ( pObj->Mark ) {
            // clean
            pObj->Mark = 0;
            // add fresh PI with the same number of bits
            iObj = Wlc_ObjAlloc( p, WLC_OBJ_PI, Wlc_ObjIsSigned(pObj), Wlc_ObjRange(pObj) - 1, 0 );
        }
        else {
            // update fanins 
            Wlc_ObjForEachFanin( pObj, iFanin, k )
                Wlc_ObjFanins(pObj)[k] = Wlc_ObjCopy(p, iFanin);
            // node to remain
            iObj = i;
        }
        Wlc_ObjSetCopy( p, i, iObj );
    }
    // POs do not change in this procedure
    if ( vNodes != vNodesInit )
        Vec_IntFree( vNodes );
    // reconstruct topological order
    pNew = Wlc_NtkDupDfs( p );
    Wlc_NtkTransferNames( pNew, p );
    return pNew;
}

Wlc_Ntk_t* Wlc_NtkAlloc	(	char *	pName,
		int	nObjsAlloc
	)

FUNCTION DEFINITIONS ///.

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

Synopsis [Working with models.]

Description []

SideEffects []

SeeAlso []

Definition at line 94 of file wlcNtk.c.

{
    Wlc_Ntk_t * p;
    p = ABC_CALLOC( Wlc_Ntk_t, 1 );
    p->pName = Extra_FileNameGeneric( pName );
    Vec_IntGrow( &p->vPis, 111 );
    Vec_IntGrow( &p->vPos, 111 );
    Vec_IntGrow( &p->vCis, 111 );
    Vec_IntGrow( &p->vCos, 111 );
    Vec_IntGrow( &p->vFfs, 111 );
    p->pMemFanin = Mem_FlexStart();
    p->nObjsAlloc = nObjsAlloc;  
    p->pObjs = ABC_CALLOC( Wlc_Obj_t, p->nObjsAlloc );
    p->iObj = 1;
    return p;
}

Gia_Man_t* Wlc_NtkBitBlast	(	Wlc_Ntk_t *	p,
		Vec_Int_t *	vBoxIds
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 405 of file wlcBlast.c.

{
    int fVerbose = 0;
    Tim_Man_t * pManTime = NULL;
    Gia_Man_t * pTemp, * pNew, * pExtra = NULL;
    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, iFanin, iLit, nAndPrev, * pFans0, * pFans1, * pFans2;
    int nFFins = 0, nFFouts = 0, curPi = 0, curPo = 0;
    int nBitCis = 0, nBitCos = 0;
    vBits  = Vec_IntAlloc( nBits );
    vTemp0 = Vec_IntAlloc( 1000 );
    vTemp1 = Vec_IntAlloc( 1000 );
    vTemp2 = Vec_IntAlloc( 1000 );
    vRes   = Vec_IntAlloc( 1000 );
    // clean AND-gate counters
    memset( p->nAnds, 0, sizeof(int) * WLC_OBJ_NUMBER );
    // create AIG manager
    pNew = Gia_ManStart( 5 * Wlc_NtkObjNum(p) + 1000 );
    pNew->pName = Abc_UtilStrsav( p->pName );
    Gia_ManHashAlloc( pNew );
    // prepare for AIG with boxes
    if ( vBoxIds )
    {
        int nNewCis = 0, nNewCos = 0;
        Wlc_NtkForEachObj( p, pObj, i )
            pObj->Mark = 0;
        // count bit-width of regular CIs/COs
        Wlc_NtkForEachCi( p, pObj, i )
            nBitCis += Wlc_ObjRange( pObj );
        Wlc_NtkForEachCo( p, pObj, i )
            nBitCos += Wlc_ObjRange( pObj );
        // count bit-width of additional CIs/COs due to selected multipliers
        assert( Vec_IntSize(vBoxIds) > 0 );
        Wlc_NtkForEachObjVec( vBoxIds, p, pObj, i )
        {
            // currently works only for multipliers
            assert( pObj->Type == WLC_OBJ_ARI_MULTI );
            nNewCis += Wlc_ObjRange( pObj );
            nNewCos += Wlc_ObjRange( Wlc_ObjFanin0(p, pObj) );
            nNewCos += Wlc_ObjRange( Wlc_ObjFanin1(p, pObj) );
            pObj->Mark = 1;
        }
        // create hierarchy manager
        pManTime = Tim_ManStart( nBitCis + nNewCis, nBitCos + nNewCos );
        curPi = nBitCis;
        curPo = 0;
        // create AIG manager for logic of the boxes
        pExtra = Gia_ManStart( Wlc_NtkObjNum(p) );
        Gia_ManHashAlloc( pExtra );
    }
    // blast in the topological order
    Wlc_NtkForEachObj( p, pObj, i )
    {
//        char * pName = Wlc_ObjName(p, i);
        nAndPrev = Gia_ManAndNum(pNew);
        nRange  = Wlc_ObjRange( pObj );
        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;
        Vec_IntClear( vRes );
        assert( nRange > 0 );
        if ( vBoxIds && pObj->Mark )
        {
            pObj->Mark = 0;

            // create new box
            Tim_ManCreateBox( pManTime, curPo, nRange0 + nRange1, curPi, nRange, -1 );
            curPi += nRange;
            curPo += nRange0 + nRange1;

            // create combinational outputs in the normal manager
            for ( k = 0; k < nRange0; k++ )
                Gia_ManAppendCo( pNew, pFans0[k] );
            for ( k = 0; k < nRange1; k++ )
                Gia_ManAppendCo( pNew, pFans1[k] );

            // make sure there is enough primary inputs in the manager
            for ( k = Gia_ManPiNum(pExtra); k < nRange0 + nRange1; k++ )
                Gia_ManAppendCi( pExtra );
            // create combinational inputs
            Vec_IntClear( vTemp0 );
            for ( k = 0; k < nRange0; k++ )
                Vec_IntPush( vTemp0, Gia_Obj2Lit(pExtra, Gia_ManPi(pExtra, k)) );
            Vec_IntClear( vTemp1 );
            for ( k = 0; k < nRange1; k++ )
                Vec_IntPush( vTemp1, Gia_Obj2Lit(pExtra, Gia_ManPi(pExtra, nRange0+k)) );
            // get new fanin arrays
            pFans0 = Vec_IntArray( vTemp0 );
            pFans1 = Vec_IntArray( vTemp1 );
            // bit-blast the multiplier in the external manager
            {
                int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
                int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
                int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
                Wlc_BlastMultiplier( pExtra, pArg0, pArg1, nRange, vTemp2, vRes );
                Vec_IntShrink( vRes, nRange );
            }
            // create outputs in the external manager
            for ( k = 0; k < nRange; k++ )
                Gia_ManAppendCo( pExtra, Vec_IntEntry(vRes, k) );

            // create combinational inputs in the normal manager
            Vec_IntClear( vRes );
            for ( k = 0; k < nRange; k++ )
                Vec_IntPush( vRes, Gia_ManAppendCi(pNew) );
        }
        else if ( Wlc_ObjIsCi(pObj) )
        {
            for ( k = 0; k < nRange; k++ )
                Vec_IntPush( vRes, Gia_ManAppendCi(pNew) );
            if ( pObj->Type == WLC_OBJ_FO )
                nFFouts += Vec_IntSize(vRes);
        }
        else if ( pObj->Type == WLC_OBJ_BUF )
        {
            int nRangeMax = Abc_MaxInt( nRange0, nRange );
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, Wlc_ObjFanin0(p, pObj)->Signed );
            for ( k = 0; k < nRange; k++ )
                Vec_IntPush( vRes, pArg0[k] );
        }
        else if ( pObj->Type == WLC_OBJ_CONST )
        {
            word * pTruth = (word *)Wlc_ObjFanins(pObj);
            for ( k = 0; k < nRange; k++ )
                Vec_IntPush( vRes, Abc_TtGetBit(pTruth, k) );
        }
        else if ( pObj->Type == WLC_OBJ_MUX )
        {
            assert( 1 + (1 << nRange0) == Wlc_ObjFaninNum(pObj) );
            for ( b = 0; b < nRange; b++ )
            {
                Vec_IntClear( vTemp0 );
                Wlc_ObjForEachFanin( pObj, iFanin, k )
                {
                    if ( !k ) continue;
                    //assert( nRange == Wlc_ObjRange(Wlc_NtkObj(p, iFanin)) );
                    pFans1 = Vec_IntEntryP( vBits, Wlc_ObjCopy(p, iFanin) );
                    Vec_IntPush( vTemp0, b < Wlc_ObjRange(Wlc_NtkObj(p, iFanin)) ? pFans1[b] : 0 );
                }
                Vec_IntPush( vRes, Wlc_NtkMuxTree_rec(pNew, pFans0, nRange0, vTemp0, 0) );
            }
        }
        else if ( pObj->Type == WLC_OBJ_SHIFT_R || pObj->Type == WLC_OBJ_SHIFT_RA ||
                  pObj->Type == WLC_OBJ_SHIFT_L || pObj->Type == WLC_OBJ_SHIFT_LA )
        {
            int nRangeMax = Abc_MaxInt( nRange, nRange0 );
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, Wlc_ObjFanin0(p, pObj)->Signed );
            if ( pObj->Type == WLC_OBJ_SHIFT_R || pObj->Type == WLC_OBJ_SHIFT_RA )
                Wlc_BlastShiftRight( pNew, pArg0, nRangeMax, pFans1, nRange1, Wlc_ObjFanin0(p, pObj)->Signed && pObj->Type == WLC_OBJ_SHIFT_RA, vRes );
            else
                Wlc_BlastShiftLeft( pNew, pArg0, nRangeMax, pFans1, nRange1, 0, vRes );
            Vec_IntShrink( vRes, nRange );
        }
        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 )
        {
            int nRangeMax = Abc_MaxInt( nRange, nRange0 );
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, Wlc_ObjFanin0(p, pObj)->Signed );
            for ( k = 0; k < nRange; k++ )
                Vec_IntPush( vRes, Abc_LitNot(pArg0[k]) );
        }
        else if ( pObj->Type == WLC_OBJ_BIT_AND )
        {
            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            for ( k = 0; k < nRange; k++ )
                Vec_IntPush( vRes, Gia_ManHashAnd(pNew, pArg0[k], pArg1[k]) );
        }
        else if ( pObj->Type == WLC_OBJ_BIT_OR )
        {
            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            for ( k = 0; k < nRange; k++ )
                Vec_IntPush( vRes, Gia_ManHashOr(pNew, pArg0[k], pArg1[k]) );
        }
        else if ( pObj->Type == WLC_OBJ_BIT_XOR )
        {
            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            for ( k = 0; k < nRange; k++ )
                Vec_IntPush( vRes, Gia_ManHashXor(pNew, pArg0[k], pArg1[k]) );
        }
        else if ( pObj->Type == WLC_OBJ_BIT_SELECT )
        {
            Wlc_Obj_t * pFanin = Wlc_ObjFanin0(p, pObj);
            int End = Wlc_ObjRangeEnd(pObj);
            int Beg = Wlc_ObjRangeBeg(pObj);
            assert( nRange == End - Beg + 1 );
            assert( (int)pFanin->Beg <= Beg && End <= (int)pFanin->End );
            for ( k = Beg; k <= End; k++ )
                Vec_IntPush( vRes, pFans0[k - pFanin->Beg] );
        }
        else if ( pObj->Type == WLC_OBJ_BIT_CONCAT )
        {
            int iFanin, nTotal = 0;
            Wlc_ObjForEachFanin( pObj, iFanin, k )
                nTotal += Wlc_ObjRange( Wlc_NtkObj(p, iFanin) );
            assert( nRange == nTotal );
            Wlc_ObjForEachFaninReverse( pObj, iFanin, k )
            {
                nRange0 = Wlc_ObjRange( Wlc_NtkObj(p, iFanin) );
                pFans0 = Vec_IntEntryP( vBits, Wlc_ObjCopy(p, iFanin) );
                for ( b = 0; b < nRange0; b++ )
                    Vec_IntPush( vRes, pFans0[b] );
            }
        }
        else if ( pObj->Type == WLC_OBJ_BIT_ZEROPAD || pObj->Type == WLC_OBJ_BIT_SIGNEXT )
        {
            int Pad = pObj->Type == WLC_OBJ_BIT_ZEROPAD ? 0 : pFans0[nRange0-1];
            assert( nRange0 < nRange );
            for ( k = 0; k < nRange0; k++ )
                Vec_IntPush( vRes, pFans0[k] );
            for (      ; k < nRange; k++ )
                Vec_IntPush( vRes, Pad );
        }
        else if ( pObj->Type == WLC_OBJ_LOGIC_NOT )
        {
            iLit = Wlc_BlastReduction( pNew, pFans0, nRange0, WLC_OBJ_REDUCT_OR );
            Vec_IntFill( vRes, 1, Abc_LitNot(iLit) );
            for ( k = 1; k < nRange; k++ )
                Vec_IntPush( vRes, 0 );
        }
        else if ( pObj->Type == WLC_OBJ_LOGIC_AND )
        {
            int iLit0 = Wlc_BlastReduction( pNew, pFans0, nRange0, WLC_OBJ_REDUCT_OR );
            int iLit1 = Wlc_BlastReduction( pNew, pFans1, nRange1, WLC_OBJ_REDUCT_OR );
            Vec_IntFill( vRes, 1, Gia_ManHashAnd(pNew, iLit0, iLit1) );
            for ( k = 1; k < nRange; k++ )
                Vec_IntPush( vRes, 0 );
        }
        else if ( pObj->Type == WLC_OBJ_LOGIC_OR )
        {
            int iLit0 = Wlc_BlastReduction( pNew, pFans0, nRange0, WLC_OBJ_REDUCT_OR );
            int iLit1 = Wlc_BlastReduction( pNew, pFans1, nRange1, WLC_OBJ_REDUCT_OR );
            Vec_IntFill( vRes, 1, Gia_ManHashOr(pNew, iLit0, iLit1) );
            for ( k = 1; k < nRange; k++ )
                Vec_IntPush( vRes, 0 );
        }
        else if ( pObj->Type == WLC_OBJ_COMP_EQU || pObj->Type == WLC_OBJ_COMP_NOTEQU )
        {
            int iLit = 0, nRangeMax = Abc_MaxInt( nRange0, nRange1 );
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            for ( k = 0; k < nRangeMax; k++ )
                iLit = Gia_ManHashOr( pNew, iLit, Gia_ManHashXor(pNew, pArg0[k], pArg1[k]) ); 
            Vec_IntFill( vRes, 1, Abc_LitNotCond(iLit, pObj->Type == WLC_OBJ_COMP_EQU) );
            for ( k = 1; k < nRange; k++ )
                Vec_IntPush( vRes, 0 );
        }
        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 nRangeMax = Abc_MaxInt( nRange0, nRange1 );
            int fSigned = Wlc_ObjIsSignedFanin01(p, pObj);
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, fSigned );
            int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRangeMax, fSigned );
            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);
            if ( fSwap ) ABC_SWAP( int *, pArg0, pArg1 );
            if ( fSigned )
                iLit = Wlc_BlastLessSigned( pNew, pArg0, pArg1, nRangeMax );
            else
                iLit = Wlc_BlastLess( pNew, pArg0, pArg1, nRangeMax );
            iLit = Abc_LitNotCond( iLit, fCompl );
            Vec_IntFill( vRes, 1, iLit );
            for ( k = 1; k < nRange; k++ )
                Vec_IntPush( vRes, 0 );
        }
        else if ( pObj->Type == WLC_OBJ_REDUCT_AND || pObj->Type == WLC_OBJ_REDUCT_OR || pObj->Type == WLC_OBJ_REDUCT_XOR )
        {
            Vec_IntPush( vRes, Wlc_BlastReduction( pNew, pFans0, nRange0, pObj->Type ) );
            for ( k = 1; k < nRange; k++ )
                Vec_IntPush( vRes, 0 );
        }
        else if ( pObj->Type == WLC_OBJ_ARI_ADD || pObj->Type == WLC_OBJ_ARI_SUB ) 
        {
            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
            int * pArg0 = Wlc_VecLoadFanins( vRes,   pFans0, nRange0, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            if ( pObj->Type == WLC_OBJ_ARI_ADD )
                Wlc_BlastAdder( pNew, pArg0, pArg1, nRange ); // result is in pFan0 (vRes)
            else 
                Wlc_BlastSubtract( pNew, pArg0, pArg1, nRange ); // result is in pFan0 (vRes)
            Vec_IntShrink( vRes, nRange );
        }
        else if ( pObj->Type == WLC_OBJ_ARI_MULTI )
        {
            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRangeMax, Wlc_ObjIsSignedFanin01(p, pObj) );
            Wlc_BlastMultiplier( pNew, pArg0, pArg1, nRange, vTemp2, vRes );
            Vec_IntShrink( vRes, nRange );
        }
        else if ( pObj->Type == WLC_OBJ_ARI_DIVIDE || pObj->Type == WLC_OBJ_ARI_MODULUS )
        {
            int nRangeMax = Abc_MaxInt( nRange, Abc_MaxInt(nRange0, nRange1) );
            int fSigned = Wlc_ObjIsSignedFanin01(p, pObj);
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, fSigned );
            int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRangeMax, fSigned );
            if ( fSigned )
                Wlc_BlastDividerSigned( pNew, pArg0, nRangeMax, pArg1, nRangeMax, pObj->Type == WLC_OBJ_ARI_DIVIDE, vRes );
            else
                Wlc_BlastDivider( pNew, pArg0, nRangeMax, pArg1, nRangeMax, pObj->Type == WLC_OBJ_ARI_DIVIDE, vRes );
            Vec_IntShrink( vRes, nRange );
            Wlc_BlastZeroCondition( pNew, pFans1, nRange1, vRes );
        }
        else if ( pObj->Type == WLC_OBJ_ARI_MINUS )
        {
            int nRangeMax = Abc_MaxInt( nRange0, nRange );
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, Wlc_ObjFanin0(p, pObj)->Signed );
            Wlc_BlastMinus( pNew, pArg0, nRangeMax, vRes );
            Vec_IntShrink( vRes, nRange );
        }
        else if ( pObj->Type == WLC_OBJ_ARI_POWER )
        {
            int nRangeMax = Abc_MaxInt(nRange0, nRange);
            int * pArg0 = Wlc_VecLoadFanins( vTemp0, pFans0, nRange0, nRangeMax, Wlc_ObjFanin0(p, pObj)->Signed );
            int * pArg1 = Wlc_VecLoadFanins( vTemp1, pFans1, nRange1, nRange1, Wlc_ObjFanin1(p, pObj)->Signed );
            Wlc_BlastPower( pNew, pArg0, nRangeMax, pArg1, nRange1, vTemp2, vRes );
            Vec_IntShrink( vRes, nRange );
        }
        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;
        p->nAnds[pObj->Type] += Gia_ManAndNum(pNew) - nAndPrev;
    }
    p->nAnds[0] = Gia_ManAndNum(pNew);
    assert( nBits == Vec_IntSize(vBits) );
    Vec_IntFree( vTemp0 );
    Vec_IntFree( vTemp1 );
    Vec_IntFree( vTemp2 );
    Vec_IntFree( vRes );
    // create COs
    Wlc_NtkForEachCo( p, pObj, i )
    {
        nRange = Wlc_ObjRange( pObj );
        pFans0 = Vec_IntEntryP( vBits, Wlc_ObjCopy(p, Wlc_ObjId(p, pObj)) );
        if ( fVerbose )
            printf( "%s(%d) ", Wlc_ObjName(p, Wlc_ObjId(p, pObj)), Gia_ManCoNum(pNew) );
        for ( k = 0; k < nRange; k++ )
            Gia_ManAppendCo( pNew, pFans0[k] );
        if ( pObj->fIsFi )
            nFFins += nRange;
    }
    if ( fVerbose )
        printf( "\n" );
    Vec_IntFree( vBits );
    Vec_IntErase( &p->vCopies );
    // set the number of registers
    assert( nFFins == nFFouts );
    Gia_ManSetRegNum( pNew, nFFins );
    // finalize AIG
    pNew = Gia_ManCleanup( pTemp = pNew );
    Gia_ManStop( pTemp );
    // finalize AIG with boxes
    if ( vBoxIds )
    {
        curPo += nBitCos;
        assert( curPi == Tim_ManCiNum(pManTime) );
        assert( curPo == Tim_ManCoNum(pManTime) );
        // finalize the extra AIG
        pExtra = Gia_ManCleanup( pTemp = pExtra );
        Gia_ManStop( pTemp );
        assert( Gia_ManPoNum(pExtra) == Gia_ManCiNum(pNew) - nBitCis );
        // attach
        pNew->pAigExtra = pExtra;
        pNew->pManTime = pManTime;
        // normalize AIG
        pNew = Gia_ManDupNormalize( pTemp = pNew );
        Gia_ManTransferTiming( pNew, pTemp );
        Gia_ManStop( pTemp );
        //Tim_ManPrint( pManTime );
    }
    return pNew;
}

static Wlc_Obj_t* Wlc_NtkCi ( Wlc_Ntk_t *  p, int  i  )

inlinestatic

Definition at line 152 of file wlc.h.

{ return Wlc_NtkObj( p, Vec_IntEntry(&p->vCis, i) );                       }

static int Wlc_NtkCiNum ( Wlc_Ntk_t *  p )

inlinestatic

Definition at line 145 of file wlc.h.

{ return Vec_IntSize(&p->vCis);                                            }

static void Wlc_NtkCleanCopy ( Wlc_Ntk_t *  p )

inlinestatic

Definition at line 185 of file wlc.h.

{ Vec_IntFill( &p->vCopies, p->nObjsAlloc, 0 );                            }

static void Wlc_NtkCleanNameId ( Wlc_Ntk_t *  p )

inlinestatic

Definition at line 191 of file wlc.h.

{ Vec_IntFill( &p->vNameIds, p->nObjsAlloc, 0 );                           }

static Wlc_Obj_t* Wlc_NtkCo ( Wlc_Ntk_t *  p, int  i  )

inlinestatic

Definition at line 153 of file wlc.h.

{ return Wlc_NtkObj( p, Vec_IntEntry(&p->vCos, i) );                       }

Vec_Int_t* Wlc_NtkCollectMultipliers

(

Wlc_Ntk_t *

p

)

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

Synopsis [Collect IDs of the multipliers.]

Description []

SideEffects []

SeeAlso []

Definition at line 76 of file wlcAbs.c.

{
    Wlc_Obj_t * pObj;  int i;
    Vec_Int_t * vBoxIds = Vec_IntAlloc( 100 );
    Wlc_NtkForEachObj( p, pObj, i )
        if ( pObj->Type == WLC_OBJ_ARI_MULTI )
            Vec_IntPush( vBoxIds, i );
    if ( Vec_IntSize( vBoxIds ) > 0 )
        return vBoxIds;
    Vec_IntFree( vBoxIds );
    return NULL;
}

static int Wlc_NtkCoNum ( Wlc_Ntk_t *  p )

inlinestatic

Definition at line 146 of file wlc.h.

{ return Vec_IntSize(&p->vCos);                                            }

Wlc_Ntk_t* Wlc_NtkDupDfs

(

Wlc_Ntk_t *

p

)

Definition at line 457 of file wlcNtk.c.

{
    Wlc_Ntk_t * pNew;
    Wlc_Obj_t * pObj;
    Vec_Int_t * vFanins;
    int i;
    Wlc_NtkCleanCopy( p );
    vFanins = Vec_IntAlloc( 100 );
    pNew = Wlc_NtkAlloc( p->pName, p->nObjsAlloc );
    Wlc_NtkForEachCi( p, pObj, i )
        Wlc_ObjDup( pNew, p, Wlc_ObjId(p, pObj), vFanins );
    Wlc_NtkForEachCo( p, pObj, i )
        Wlc_NtkDupDfs_rec( pNew, p, Wlc_ObjId(p, pObj), vFanins );
    Wlc_NtkForEachCo( p, pObj, i )
        Wlc_ObjSetCo( pNew, Wlc_ObjCopyObj(pNew, p, pObj), pObj->fIsFi );
    Vec_IntFree( vFanins );
    return pNew;
}

static Wlc_Obj_t* Wlc_NtkFf ( Wlc_Ntk_t *  p, int  i  )

inlinestatic

Definition at line 154 of file wlc.h.

{ return Wlc_NtkObj( p, Vec_IntEntry(&p->vFfs, i) );                       }

static int Wlc_NtkFfNum ( Wlc_Ntk_t *  p )

inlinestatic

Definition at line 147 of file wlc.h.

{ return Vec_IntSize(&p->vCis) - Vec_IntSize(&p->vPis);                    }

Vec_Int_t* Wlc_NtkFindUifableMultiplierPairs

(

Wlc_Ntk_t *

p

)

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

Synopsis [Returns all pairs of uifable multipliers.]

Description []

SideEffects []

SeeAlso []

Definition at line 100 of file wlcAbs.c.

{
    Vec_Int_t * vMultis = Wlc_NtkCollectMultipliers( p );
    Vec_Int_t * vPairs = Vec_IntAlloc( 2 );
    Wlc_Obj_t * pObj, * pObj2;  int i, k;
    // iterate through unique pairs
    Wlc_NtkForEachObjVec( vMultis, p, pObj, i )
        Wlc_NtkForEachObjVec( vMultis, p, pObj2, k )
        {
            if ( k == i )  
                break;
            if ( Wlc_NtkPairIsUifable( p, pObj, pObj2 ) )
            {
                Vec_IntPush( vPairs, Wlc_ObjId(p, pObj) );
                Vec_IntPush( vPairs, Wlc_ObjId(p, pObj2) );
            }
        }
    Vec_IntFree( vMultis );
    if ( Vec_IntSize( vPairs ) > 0 )
        return vPairs;
    Vec_IntFree( vPairs );
    return NULL;
}

void Wlc_NtkFree

(

Wlc_Ntk_t *

p

)

Definition at line 195 of file wlcNtk.c.

{
    if ( p->pManName )
        Abc_NamStop( p->pManName );
    if ( p->pMemFanin )
        Mem_FlexStop( p->pMemFanin, 0 );
    if ( p->pMemTable )
        Mem_FlexStop( p->pMemTable, 0 );
    Vec_PtrFreeP( &p->vTables );
    ABC_FREE( p->vPis.pArray );
    ABC_FREE( p->vPos.pArray );
    ABC_FREE( p->vCis.pArray );
    ABC_FREE( p->vCos.pArray );
    ABC_FREE( p->vFfs.pArray );
    ABC_FREE( p->vTravIds.pArray );
    ABC_FREE( p->vNameIds.pArray );
    ABC_FREE( p->vCopies.pArray );
    ABC_FREE( p->pObjs );
    ABC_FREE( p->pName );
    ABC_FREE( p );
}

static int Wlc_NtkHasCopy ( Wlc_Ntk_t *  p )

inlinestatic

Definition at line 186 of file wlc.h.

{ return Vec_IntSize( &p->vCopies ) > 0;                                   }

static int Wlc_NtkHasNameId ( Wlc_Ntk_t *  p )

inlinestatic

Definition at line 192 of file wlc.h.

{ return Vec_IntSize( &p->vNameIds ) > 0;                                  }

static Wlc_Obj_t* Wlc_NtkObj ( Wlc_Ntk_t *  p, int  Id  )

inlinestatic

Definition at line 149 of file wlc.h.

{ assert(Id > 0 && Id < p->nObjsAlloc); return p->pObjs + Id;              }

static int Wlc_NtkObjNum ( Wlc_Ntk_t *  p )

inlinestatic

Definition at line 141 of file wlc.h.

{ return p->iObj - 1;                                                      }

static int Wlc_NtkObjNumMax ( Wlc_Ntk_t *  p )

inlinestatic

Definition at line 142 of file wlc.h.

{ return p->iObj;                                                          }

int Wlc_NtkPairIsUifable	(	Wlc_Ntk_t *	p,
		Wlc_Obj_t *	pObj,
		Wlc_Obj_t *	pObj2
	)

FUNCTION DECLARATIONS ///.

FUNCTION DECLARATIONS ///.

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

FileName [wlcAbs.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Verilog parser.]

Synopsis [Abstraction for word-level networks.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - August 22, 2014.]

Revision [

Id:

wlcAbs.c,v 1.00 2014/09/12 00:00:00 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Check if two objects have the same input/output signatures.]

Description []

SideEffects []

SeeAlso []

Definition at line 44 of file wlcAbs.c.

{
    Wlc_Obj_t * pFanin, * pFanin2;  int k;
    if ( Wlc_ObjRange(pObj) != Wlc_ObjRange(pObj2) )
        return 0;
    if ( Wlc_ObjIsSigned(pObj) != Wlc_ObjIsSigned(pObj2) )
        return 0;
    if ( Wlc_ObjFaninNum(pObj) != Wlc_ObjFaninNum(pObj2) )
        return 0;
    for ( k = 0; k < Wlc_ObjFaninNum(pObj); k++ )
    {
        pFanin = Wlc_ObjFanin(p, pObj, k);
        pFanin2 = Wlc_ObjFanin(p, pObj2, k);
        if ( Wlc_ObjRange(pFanin) != Wlc_ObjRange(pFanin2) )
            return 0;
        if ( Wlc_ObjIsSigned(pFanin) != Wlc_ObjIsSigned(pFanin2) )
            return 0;
    }
    return 1;
}

static Wlc_Obj_t* Wlc_NtkPi ( Wlc_Ntk_t *  p, int  i  )

inlinestatic

Definition at line 150 of file wlc.h.

{ return Wlc_NtkObj( p, Vec_IntEntry(&p->vPis, i) );                       }

static int Wlc_NtkPiNum ( Wlc_Ntk_t *  p )

inlinestatic

Definition at line 143 of file wlc.h.

{ return Vec_IntSize(&p->vPis);                                            }

static Wlc_Obj_t* Wlc_NtkPo ( Wlc_Ntk_t *  p, int  i  )

inlinestatic

Definition at line 151 of file wlc.h.

{ return Wlc_NtkObj( p, Vec_IntEntry(&p->vPos, i) );                       }

static int Wlc_NtkPoNum ( Wlc_Ntk_t *  p )

inlinestatic

Definition at line 144 of file wlc.h.

{ return Vec_IntSize(&p->vPos);                                            }

void Wlc_NtkPrintNodes	(	Wlc_Ntk_t *	p,
		int	Type
	)

Definition at line 354 of file wlcNtk.c.

{
    Wlc_Obj_t * pObj; 
    int i, Counter = 0;
    printf( "Operation %s\n", Wlc_Names[Type] );
    Wlc_NtkForEachObj( p, pObj, i )
    {
        if ( (int)pObj->Type != Type )
            continue;
        printf( "%8d  :",      Counter++ );
        printf( "%8d  :  ",    i );
        printf( "%3d%s = ",    Wlc_ObjRange(pObj),                   Wlc_ObjIsSigned(pObj) ? "s" : " " );
        printf( "%3d%s  %s ",  Wlc_ObjRange(Wlc_ObjFanin0(p, pObj)), Wlc_ObjIsSigned(Wlc_ObjFanin0(p, pObj)) ? "s" : " ", Wlc_Names[Type] );
        printf( "%3d%s ",      Wlc_ObjRange(Wlc_ObjFanin1(p, pObj)), Wlc_ObjIsSigned(Wlc_ObjFanin1(p, pObj)) ? "s" : " " );
        printf( " :    " );
        printf( "%-12s =  ",   Wlc_ObjName(p, i) );
        printf( "%-12s  %s  ", Wlc_ObjName(p, Wlc_ObjFaninId0(pObj)), Wlc_Names[Type] );
        printf( "%-12s ",      Wlc_ObjName(p, Wlc_ObjFaninId1(pObj)) );
        printf( "\n" );
    }
}

void Wlc_NtkPrintStats	(	Wlc_Ntk_t *	p,
		int	fDistrib,
		int	fVerbose
	)

Definition at line 375 of file wlcNtk.c.

{
    int i;
    printf( "%-20s : ",        p->pName );
    printf( "PI = %4d  ",      Wlc_NtkPiNum(p) );
    printf( "PO = %4d  ",      Wlc_NtkPoNum(p) );
    printf( "FF = %4d  ",      Wlc_NtkFfNum(p) );
    printf( "Obj = %6d  ",     Wlc_NtkObjNum(p) );
    printf( "Mem = %.3f MB",   1.0*Wlc_NtkMemUsage(p)/(1<<20) );
    printf( "\n" );
    if ( fDistrib )
    {
        Wlc_NtkPrintDistrib( p, fVerbose );
        return;
    }
    if ( !fVerbose )
        return;
    printf( "Node type statistics:\n" );
    for ( i = 1; i < WLC_OBJ_NUMBER; i++ )
    {
        if ( !p->nObjs[i] )
            continue;
        if ( p->nAnds[0] && p->nAnds[i] )
            printf( "%2d  :  %-8s  %6d  %7.2f %%\n", i, Wlc_Names[i], p->nObjs[i], 100.0*p->nAnds[i]/p->nAnds[0] );
        else
            printf( "%2d  :  %-8s  %6d\n", i, Wlc_Names[i], p->nObjs[i] );
    }
}

void Wlc_NtkTransferNames	(	Wlc_Ntk_t *	pNew,
		Wlc_Ntk_t *	p
	)

Definition at line 475 of file wlcNtk.c.

{
    int i;
    assert( !Wlc_NtkHasCopy(pNew)   && Wlc_NtkHasCopy(p)   );
    assert( !Wlc_NtkHasNameId(pNew) && Wlc_NtkHasNameId(p) );
    assert( pNew->pManName  == NULL && p->pManName != NULL );
    Wlc_NtkCleanNameId( pNew );
    for ( i = 0; i < p->nObjsAlloc; i++ )
        if ( Wlc_ObjCopy(p, i) && i < Vec_IntSize(&p->vNameIds) && Wlc_ObjNameId(p, i) )
            Wlc_ObjSetNameId( pNew, Wlc_ObjCopy(p, i), Wlc_ObjNameId(p, i) );
    pNew->pManName = p->pManName; 
    p->pManName = NULL;
    Vec_IntErase( &p->vNameIds );
    // transfer table
    pNew->pMemTable = p->pMemTable;  p->pMemTable = NULL;
    pNew->vTables = p->vTables;      p->vTables = NULL;
}

Wlc_Ntk_t* Wlc_NtkUifNodePairs	(	Wlc_Ntk_t *	p,
		Vec_Int_t *	vPairsInit
	)

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

Synopsis [Adds UIF constraints to node pairs and updates POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 192 of file wlcAbs.c.

{
    Vec_Int_t * vPairs = vPairsInit;
    Wlc_Ntk_t * pNew;
    Wlc_Obj_t * pObj, * pObj2;
    Vec_Int_t * vUifConstrs, * vCompares, * vFanins;
    int i, k, iObj, iObj2, iObjNew, iObjNew2;
    int iFanin, iFanin2, iFaninNew;
    // get multiplier pairs if not given
    if ( vPairs == NULL )
        vPairs = Wlc_NtkFindUifableMultiplierPairs( p );
    if ( vPairs == NULL )
        return NULL;
    // sanity checks
    assert( Vec_IntSize(vPairs) > 0 && Vec_IntSize(vPairs) % 2 == 0 );
    // iterate through node pairs
    vFanins = Vec_IntAlloc( 100 );
    vCompares = Vec_IntAlloc( 100 );
    vUifConstrs = Vec_IntAlloc( 100 );
    Vec_IntForEachEntryDouble( vPairs, iObj, iObj2, i )
    {
        // get two nodes
        pObj  = Wlc_NtkObj( p, iObj );
        pObj2 = Wlc_NtkObj( p, iObj2 );
        assert( Wlc_NtkPairIsUifable(p, pObj, pObj2) );
        // create fanin comparator nodes
        Vec_IntClear( vCompares );
        Wlc_ObjForEachFanin( pObj, iFanin, k )
        {
            iFanin2 = Wlc_ObjFaninId( pObj2, k );
            Vec_IntFillTwo( vFanins, 2, iFanin, iFanin2 );
            iFaninNew = Wlc_ObjCreate( p, WLC_OBJ_COMP_NOTEQU, 0, 0, 0, vFanins );
            Vec_IntPush( vCompares, iFaninNew );
            // note that a pointer to Wlc_Obj_t (for example, pObj) can be invalidated after a call to 
            // Wlc_ObjCreate() due to a possible realloc of the internal array of objects...
            pObj = Wlc_NtkObj( p, iObj );
        }
        // concatenate fanin comparators
        iObjNew = Wlc_ObjCreate( p, WLC_OBJ_BIT_CONCAT, 0, Vec_IntSize(vCompares) - 1, 0, vCompares );
        // create reduction-OR node
        Vec_IntFill( vFanins, 1, iObjNew );
        iObjNew = Wlc_ObjCreate( p, WLC_OBJ_REDUCT_OR, 0, 0, 0, vFanins );
        // craete output comparator node
        Vec_IntFillTwo( vFanins, 2, iObj, iObj2 );
        iObjNew2 = Wlc_ObjCreate( p, WLC_OBJ_COMP_EQU, 0, 0, 0, vFanins );
        // create implication node (iObjNew is already complemented above)
        Vec_IntFillTwo( vFanins, 2, iObjNew, iObjNew2 );
        iObjNew = Wlc_ObjCreate( p, WLC_OBJ_LOGIC_OR, 0, 0, 0, vFanins );
        // save the constraint
        Vec_IntPush( vUifConstrs, iObjNew );
    }
    // derive the AND of the UIF contraints
    assert( Vec_IntSize(vUifConstrs) > 0 );
    if ( Vec_IntSize(vUifConstrs) == 1 )
        iObjNew = Vec_IntEntry( vUifConstrs, 0 );
    else
    {
        // concatenate
        iObjNew = Wlc_ObjCreate( p, WLC_OBJ_BIT_CONCAT, 0, Vec_IntSize(vUifConstrs) - 1, 0, vUifConstrs );
        // create reduction-AND node
        Vec_IntFill( vFanins, 1, iObjNew );
        iObjNew = Wlc_ObjCreate( p, WLC_OBJ_REDUCT_AND, 0, 0, 0, vFanins );
    }
    // update each PO to point to the new node
    Wlc_NtkForEachPo( p, pObj, i )
    {
        iObj = Wlc_ObjId(p, pObj);
        Vec_IntFillTwo( vFanins, 2, iObj, iObjNew );
        iObjNew = Wlc_ObjCreate( p, WLC_OBJ_LOGIC_AND, 0, 0, 0, vFanins );
        // note that a pointer to Wlc_Obj_t (for example, pObj) can be invalidated after a call to 
        // Wlc_ObjCreate() due to a possible realloc of the internal array of objects...
        pObj = Wlc_NtkObj( p, iObj );
        // update PO/CO arrays
        assert( Vec_IntEntry(&p->vPos, i) == iObj );
        assert( Vec_IntEntry(&p->vCos, i) == iObj );
        Vec_IntWriteEntry( &p->vPos, i, iObjNew );
        Vec_IntWriteEntry( &p->vCos, i, iObjNew );
        // transfer the PO attribute
        Wlc_NtkObj(p, iObjNew)->fIsPo = 1;
        assert( pObj->fIsPo );
        pObj->fIsPo = 0;
    }
    // cleanup
    Vec_IntFree( vUifConstrs );
    Vec_IntFree( vCompares );
    Vec_IntFree( vFanins );
    if ( vPairs != vPairsInit )
        Vec_IntFree( vPairs );
    // reconstruct topological order
    pNew = Wlc_NtkDupDfs( p );
    Wlc_NtkTransferNames( pNew, p );
    return pNew;
}

void Wlc_ObjAddFanins	(	Wlc_Ntk_t *	p,
		Wlc_Obj_t *	pObj,
		Vec_Int_t *	vFanins
	)

Definition at line 182 of file wlcNtk.c.

{
    assert( pObj->nFanins == 0 );
    pObj->nFanins = Vec_IntSize(vFanins);
    if ( Wlc_ObjHasArray(pObj) )
        pObj->pFanins[0] = (int *)Mem_FlexEntryFetch( p->pMemFanin, Vec_IntSize(vFanins) * sizeof(int) );
    memcpy( Wlc_ObjFanins(pObj), Vec_IntArray(vFanins), sizeof(int) * Vec_IntSize(vFanins) );
    // special treatment of CONST, SELECT and TABLE
    if ( pObj->Type == WLC_OBJ_CONST )
        pObj->nFanins = 0;
    else if ( pObj->Type == WLC_OBJ_BIT_SELECT || pObj->Type == WLC_OBJ_TABLE )
        pObj->nFanins = 1;
}

int Wlc_ObjAlloc	(	Wlc_Ntk_t *	p,
		int	Type,
		int	Signed,
		int	End,
		int	Beg
	)

Definition at line 141 of file wlcNtk.c.

{
    Wlc_Obj_t * pObj;
    assert( Type != WLC_OBJ_PO && Type != WLC_OBJ_FI );
    if ( p->iObj == p->nObjsAlloc )
    {
        p->pObjs = ABC_REALLOC( Wlc_Obj_t, p->pObjs, 2 * p->nObjsAlloc );
        memset( p->pObjs + p->nObjsAlloc, 0, sizeof(Wlc_Obj_t) * p->nObjsAlloc );
        p->nObjsAlloc *= 2;
    }
    pObj = Wlc_NtkObj( p, p->iObj );
    pObj->Type   = Type;
    pObj->Signed = Signed;
    pObj->End    = End;
    pObj->Beg    = Beg;
    if ( Wlc_ObjIsCi(pObj) )
        Wlc_ObjSetCi( p, pObj );
    p->nObjs[Type]++;
    return p->iObj++;
}

static int Wlc_ObjCiId ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 162 of file wlc.h.

{ assert( Wlc_ObjIsCi(p) ); return p->Fanins[1];                           }

static int* Wlc_ObjConstValue ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 181 of file wlc.h.

{ assert(p->Type == WLC_OBJ_CONST);      return Wlc_ObjFanins(p);          }

static int Wlc_ObjCopy ( Wlc_Ntk_t *  p, int  iObj  )

inlinestatic

Definition at line 188 of file wlc.h.

{ return Vec_IntEntry( &p->vCopies, iObj );                                }

static Wlc_Obj_t* Wlc_ObjCopyObj ( Wlc_Ntk_t *  pNew, Wlc_Ntk_t *  p, Wlc_Obj_t *  pObj  )

inlinestatic

Definition at line 189 of file wlc.h.

{return Wlc_NtkObj(pNew, Wlc_ObjCopy(p, Wlc_ObjId(p, pObj)));   }

int Wlc_ObjCreate	(	Wlc_Ntk_t *	p,
		int	Type,
		int	Signed,
		int	End,
		int	Beg,
		Vec_Int_t *	vFanins
	)

Definition at line 161 of file wlcNtk.c.

{
    int iFaninNew = Wlc_ObjAlloc( p, Type, Signed, End, Beg );
    Wlc_ObjAddFanins( p, Wlc_NtkObj(p, iFaninNew), vFanins );
    return iFaninNew;
}

static Wlc_Obj_t* Wlc_ObjFanin ( Wlc_Ntk_t *  p, Wlc_Obj_t *  pObj, int  i  )

inlinestatic

Definition at line 170 of file wlc.h.

{ return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, i) );                         }

static Wlc_Obj_t* Wlc_ObjFanin0 ( Wlc_Ntk_t *  p, Wlc_Obj_t *  pObj  )

inlinestatic

Definition at line 171 of file wlc.h.

{ return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, 0) );                         }

static Wlc_Obj_t* Wlc_ObjFanin1 ( Wlc_Ntk_t *  p, Wlc_Obj_t *  pObj  )

inlinestatic

Definition at line 172 of file wlc.h.

{ return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, 1) );                         }

static Wlc_Obj_t* Wlc_ObjFanin2 ( Wlc_Ntk_t *  p, Wlc_Obj_t *  pObj  )

inlinestatic

Definition at line 173 of file wlc.h.

{ return Wlc_NtkObj( p, Wlc_ObjFaninId(pObj, 2) );                         }

static int Wlc_ObjFaninId ( Wlc_Obj_t *  p, int  i  )

inlinestatic

Definition at line 166 of file wlc.h.

{ return Wlc_ObjFanins(p)[i];                                              }

static int Wlc_ObjFaninId0 ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 167 of file wlc.h.

{ return Wlc_ObjFanins(p)[0];                                              }

static int Wlc_ObjFaninId1 ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 168 of file wlc.h.

{ return Wlc_ObjFanins(p)[1];                                              }

static int Wlc_ObjFaninId2 ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 169 of file wlc.h.

{ return Wlc_ObjFanins(p)[2];                                              }

static int Wlc_ObjFaninNum ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 163 of file wlc.h.

{ return p->nFanins;                                                       }

static int* Wlc_ObjFanins ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 165 of file wlc.h.

{ return Wlc_ObjHasArray(p) ? p->pFanins[0] : p->Fanins;                   }

static Wlc_Obj_t* Wlc_ObjFoToFi ( Wlc_Ntk_t *  p, Wlc_Obj_t *  pObj  )

inlinestatic

Definition at line 196 of file wlc.h.

{ assert( pObj->Type == WLC_OBJ_FO ); return Wlc_NtkCo(p, Wlc_NtkCoNum(p) - Wlc_NtkCiNum(p) + Wlc_ObjCiId(pObj)); } 

static int Wlc_ObjHasArray ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 164 of file wlc.h.

{ return p->nFanins > 2 || p->Type == WLC_OBJ_CONST;                       }

static int Wlc_ObjId ( Wlc_Ntk_t *  p, Wlc_Obj_t *  pObj  )

inlinestatic

Definition at line 161 of file wlc.h.

{ return pObj - p->pObjs;                                                  }

static int Wlc_ObjIsCi ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 158 of file wlc.h.

{ return p->Type == WLC_OBJ_PI || p->Type == WLC_OBJ_FO;                   }

static int Wlc_ObjIsCo ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 159 of file wlc.h.

{ return p->fIsPo || p->fIsFi;                                             }

static int Wlc_ObjIsPi ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 156 of file wlc.h.

{ return p->Type == WLC_OBJ_PI;                                            }

static int Wlc_ObjIsPo ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 157 of file wlc.h.

{ return p->fIsPo;                                                         }

static int Wlc_ObjIsSigned ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 178 of file wlc.h.

{ return p->Signed;                                                        }

static int Wlc_ObjIsSignedFanin01 ( Wlc_Ntk_t *  p, Wlc_Obj_t *  pObj  )

inlinestatic

Definition at line 179 of file wlc.h.

{ return Wlc_ObjFanin0(p, pObj)->Signed && Wlc_ObjFanin1(p, pObj)->Signed; }

char* Wlc_ObjName	(	Wlc_Ntk_t *	p,
		int	iObj
	)

Definition at line 167 of file wlcNtk.c.

{
    static char Buffer[100];
    if ( Wlc_NtkHasNameId(p) && Wlc_ObjNameId(p, iObj) )
        return Abc_NamStr( p->pManName, Wlc_ObjNameId(p, iObj) );
    sprintf( Buffer, "n%d", iObj );
    return Buffer;
}                          

static int Wlc_ObjNameId ( Wlc_Ntk_t *  p, int  iObj  )

inlinestatic

Definition at line 194 of file wlc.h.

{ return Vec_IntEntry( &p->vNameIds, iObj );                               }

static int Wlc_ObjRange ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 175 of file wlc.h.

{ return p->End - p->Beg + 1;                                              }

static int Wlc_ObjRangeBeg ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 177 of file wlc.h.

{ assert(p->Type == WLC_OBJ_BIT_SELECT); return p->Fanins[1] & 0xFFFF;     }

static int Wlc_ObjRangeEnd ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 176 of file wlc.h.

{ assert(p->Type == WLC_OBJ_BIT_SELECT); return p->Fanins[1] >> 16;        }

void Wlc_ObjSetCi	(	Wlc_Ntk_t *	p,
		Wlc_Obj_t *	pObj
	)

Definition at line 110 of file wlcNtk.c.

{
    assert( Wlc_ObjIsCi(pObj) );
    assert( Wlc_ObjFaninNum(pObj) == 0 );
    if ( Wlc_NtkPiNum(p) == Wlc_NtkCiNum(p) || pObj->Type != WLC_OBJ_PI )
    {
        pObj->Fanins[1] = Vec_IntSize(&p->vCis);
        Vec_IntPush( &p->vCis, Wlc_ObjId(p, pObj) );
    }
    else // insert in the array of CI at the end of PIs
    {
        Wlc_Obj_t * pTemp; int i;
        Vec_IntInsert( &p->vCis, Wlc_NtkPiNum(p), Wlc_ObjId(p, pObj) );
        // other CI IDs are invalidated... naive fix!
        Wlc_NtkForEachCi( p, pTemp, i )
            pTemp->Fanins[1] = i;
    }
    if ( pObj->Type == WLC_OBJ_PI )
        Vec_IntPush( &p->vPis, Wlc_ObjId(p, pObj) );
}

void Wlc_ObjSetCo	(	Wlc_Ntk_t *	p,
		Wlc_Obj_t *	pObj,
		int	fFlopInput
	)

Definition at line 130 of file wlcNtk.c.

{
//    pObj->Fanins[1] = Vec_IntSize(&p->vCos);
    Vec_IntPush( &p->vCos, Wlc_ObjId(p, pObj) );
    if ( !fFlopInput )
        Vec_IntPush( &p->vPos, Wlc_ObjId(p, pObj) );
    if ( fFlopInput )
        pObj->fIsFi = 1;
    else
        pObj->fIsPo = 1;
}

static void Wlc_ObjSetCopy ( Wlc_Ntk_t *  p, int  iObj, int  i  )

inlinestatic

Definition at line 187 of file wlc.h.

{ Vec_IntWriteEntry( &p->vCopies, iObj, i );                               }

static void Wlc_ObjSetNameId ( Wlc_Ntk_t *  p, int  iObj, int  i  )

inlinestatic

Definition at line 193 of file wlc.h.

{ Vec_IntWriteEntry( &p->vNameIds, iObj, i );                              }

static int Wlc_ObjSign ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 180 of file wlc.h.

{ return Abc_Var2Lit( Wlc_ObjRange(p), Wlc_ObjIsSigned(p) );               }

static word* Wlc_ObjTable ( Wlc_Ntk_t *  p, Wlc_Obj_t *  pObj  )

inlinestatic

Definition at line 183 of file wlc.h.

{ return (word *)Vec_PtrEntry( p->vTables, Wlc_ObjTableId(pObj) );         }

static int Wlc_ObjTableId ( Wlc_Obj_t *  p )

inlinestatic

Definition at line 182 of file wlc.h.

{ assert(p->Type == WLC_OBJ_TABLE);      return p->Fanins[1];              }

void Wlc_ObjUpdateType	(	Wlc_Ntk_t *	p,
		Wlc_Obj_t *	pObj,
		int	Type
	)

Definition at line 175 of file wlcNtk.c.

{
    assert( pObj->Type == WLC_OBJ_NONE );
    p->nObjs[pObj->Type]--;
    pObj->Type = Type;
    p->nObjs[pObj->Type]++;
}

Wlc_Ntk_t* Wlc_ReadVer

(

char *

pFileName

)

Definition at line 1080 of file wlcReadVer.c.

{
    Wlc_Prs_t * p;
    Wlc_Ntk_t * pNtk = NULL;
    // start the parser 
    p = Wlc_PrsStart( pFileName );
    if ( p == NULL )
        return NULL;
    // detect lines
    if ( !Wlc_PrsPrepare( p ) )
        goto finish;
    // parse models
    if ( !Wlc_PrsDerive( p ) )
        goto finish;
    // derive topological order
    pNtk = Wlc_NtkDupDfs( p->pNtk );
    Wlc_NtkTransferNames( pNtk, p->pNtk );
finish:
    Wlc_PrsPrintErrorMessage( p );
    Wlc_PrsStop( p );
    return pNtk;
}

void Wlc_WriteVer	(	Wlc_Ntk_t *	p,
		char *	pFileName
	)

Definition at line 354 of file wlcWriteVer.c.

{
    FILE * pFile;
    pFile = fopen( pFileName, "w" );
    if ( pFile == NULL )
    {
        fprintf( stdout, "Wlc_WriteVer(): Cannot open the output file \"%s\".\n", pFileName );
        return;
    }
    fprintf( pFile, "// Benchmark \"%s\" written by ABC on %s\n", p->pName, Extra_TimeStamp() );
    fprintf( pFile, "\n" );
    Wlc_WriteTables( pFile, p );
//    Wlc_WriteAddPos( p );
    Wlc_WriteVerInt( pFile, p );
    fprintf( pFile, "\n" );
    fclose( pFile );
}