mirror of https://github.com/YosysHQ/abc.git
469 lines
30 KiB
C
469 lines
30 KiB
C
/**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 $]
|
|
|
|
***********************************************************************/
|
|
|
|
#ifndef ABC__base__wlc__wlc_h
|
|
#define ABC__base__wlc__wlc_h
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// INCLUDES ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "aig/gia/gia.h"
|
|
#include "misc/extra/extra.h"
|
|
#include "misc/util/utilNam.h"
|
|
#include "misc/mem/mem.h"
|
|
#include "misc/extra/extra.h"
|
|
#include "misc/util/utilTruth.h"
|
|
#include "base/main/mainInt.h"
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// PARAMETERS ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
ABC_NAMESPACE_HEADER_START
|
|
|
|
// object types
|
|
typedef enum {
|
|
WLC_OBJ_NONE = 0, // 00: unknown
|
|
WLC_OBJ_PI, // 01: primary input
|
|
WLC_OBJ_PO, // 02: primary output
|
|
WLC_OBJ_FO, // 03: flop output
|
|
WLC_OBJ_FI, // 04: flop input (unused)
|
|
WLC_OBJ_FF, // 05: flop
|
|
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_NAND, // 19: bitwise NAND
|
|
WLC_OBJ_BIT_NOR, // 20: bitwise OR
|
|
WLC_OBJ_BIT_NXOR, // 21: bitwise NXOR
|
|
WLC_OBJ_BIT_SELECT, // 22: bit selection
|
|
WLC_OBJ_BIT_CONCAT, // 23: bit concatenation
|
|
WLC_OBJ_BIT_ZEROPAD, // 24: zero padding
|
|
WLC_OBJ_BIT_SIGNEXT, // 25: sign extension
|
|
WLC_OBJ_LOGIC_NOT, // 26: logic NOT
|
|
WLC_OBJ_LOGIC_IMPL, // 27: logic implication
|
|
WLC_OBJ_LOGIC_AND, // 28: logic AND
|
|
WLC_OBJ_LOGIC_OR, // 29: logic OR
|
|
WLC_OBJ_LOGIC_XOR, // 30: logic XOR
|
|
WLC_OBJ_COMP_EQU, // 31: compare equal
|
|
WLC_OBJ_COMP_NOTEQU, // 32: compare not equal
|
|
WLC_OBJ_COMP_LESS, // 33: compare less
|
|
WLC_OBJ_COMP_MORE, // 34: compare more
|
|
WLC_OBJ_COMP_LESSEQU, // 35: compare less or equal
|
|
WLC_OBJ_COMP_MOREEQU, // 36: compare more or equal
|
|
WLC_OBJ_REDUCT_AND, // 37: reduction AND
|
|
WLC_OBJ_REDUCT_OR, // 38: reduction OR
|
|
WLC_OBJ_REDUCT_XOR, // 39: reduction XOR
|
|
WLC_OBJ_REDUCT_NAND, // 40: reduction NAND
|
|
WLC_OBJ_REDUCT_NOR, // 41: reduction NOR
|
|
WLC_OBJ_REDUCT_NXOR, // 42: reduction NXOR
|
|
WLC_OBJ_ARI_ADD, // 43: arithmetic addition
|
|
WLC_OBJ_ARI_SUB, // 44: arithmetic subtraction
|
|
WLC_OBJ_ARI_MULTI, // 45: arithmetic multiplier
|
|
WLC_OBJ_ARI_DIVIDE, // 46: arithmetic division
|
|
WLC_OBJ_ARI_REM, // 47: arithmetic remainder
|
|
WLC_OBJ_ARI_MODULUS, // 48: arithmetic modulus
|
|
WLC_OBJ_ARI_POWER, // 49: arithmetic power
|
|
WLC_OBJ_ARI_MINUS, // 50: arithmetic minus
|
|
WLC_OBJ_ARI_SQRT, // 51: integer square root
|
|
WLC_OBJ_ARI_SQUARE, // 52: integer square
|
|
WLC_OBJ_TABLE, // 53: bit table
|
|
WLC_OBJ_READ, // 54: read port
|
|
WLC_OBJ_WRITE, // 55: write port
|
|
WLC_OBJ_ARI_ADDSUB, // 56: adder-subtractor
|
|
WLC_OBJ_SEL, // 57: positionally encoded selector
|
|
WLC_OBJ_DEC, // 58: decoder
|
|
WLC_OBJ_LUT, // 59: lookup table
|
|
WLC_OBJ_NUMBER // 59: unused
|
|
} Wlc_ObjType_t;
|
|
// when adding new types, remember to update table Wlc_Names in "wlcNtk.c"
|
|
|
|
|
|
// Unlike AIG managers and logic networks in ABC, this network treats POs and FIs
|
|
// as attributes of internal nodes and *not* as separate types of objects.
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// BASIC TYPES ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef struct Wlc_Obj_t_ Wlc_Obj_t;
|
|
struct Wlc_Obj_t_ // 24 bytes
|
|
{
|
|
unsigned Type : 6; // node type
|
|
unsigned Signed : 1; // signed
|
|
unsigned Mark : 1; // user mark
|
|
unsigned Mark2 : 1; // user mark
|
|
unsigned fIsPo : 1; // this is PO
|
|
unsigned fIsFi : 1; // this is FI
|
|
unsigned fXConst : 1; // this is X-valued constant
|
|
unsigned nFanins; // fanin count
|
|
int End; // range end
|
|
int Beg; // range begin
|
|
union { int Fanins[2]; // fanin IDs
|
|
int * pFanins[1]; };
|
|
};
|
|
|
|
typedef struct Wlc_Ntk_t_ Wlc_Ntk_t;
|
|
struct Wlc_Ntk_t_
|
|
{
|
|
char * pName; // model name
|
|
char * pSpec; // input file name
|
|
Vec_Int_t vPis; // primary inputs
|
|
Vec_Int_t vPos; // primary outputs
|
|
Vec_Int_t vCis; // combinational inputs
|
|
Vec_Int_t vCos; // combinational outputs
|
|
Vec_Int_t vFfs; // flops
|
|
Vec_Int_t vFfs2; // flops
|
|
Vec_Int_t * vArsts; // async resets
|
|
Vec_Int_t * vInits; // initial values
|
|
char * pInits; // initial values
|
|
int nObjs[WLC_OBJ_NUMBER]; // counter of objects of each type
|
|
int nAnds[WLC_OBJ_NUMBER]; // counter of AND gates after blasting
|
|
int fSmtLib; // the network comes from an SMT-LIB file
|
|
int fAsyncRst; // the network has asynchronous reset
|
|
int fMemPorts; // the network contains memory ports
|
|
int fEasyFfs; // the network contains simple flops
|
|
int nAssert; // the number of asserts
|
|
// memory for objects
|
|
Wlc_Obj_t * pObjs;
|
|
int iObj;
|
|
int nObjsAlloc;
|
|
Mem_Flex_t * pMemFanin;
|
|
Mem_Flex_t * pMemTable;
|
|
Vec_Ptr_t * vTables;
|
|
// object names
|
|
Abc_Nam_t * pManName; // object names
|
|
Vec_Int_t vNameIds; // object name IDs
|
|
Vec_Int_t vValues; // value objects
|
|
// object attributes
|
|
int nTravIds; // counter of traversal IDs
|
|
Vec_Int_t vTravIds; // trav IDs of the objects
|
|
Vec_Int_t vCopies; // object first bits
|
|
Vec_Int_t vBits; // object mapping into AIG nodes
|
|
Vec_Int_t vLevels; // object levels
|
|
Vec_Int_t vRefs; // object reference counters
|
|
Vec_Int_t vPoPairs; // pairs of primary outputs
|
|
};
|
|
|
|
typedef struct Wlc_Par_t_ Wlc_Par_t;
|
|
struct Wlc_Par_t_
|
|
{
|
|
int nBitsAdd; // adder bit-width
|
|
int nBitsMul; // multiplier bit-widht
|
|
int nBitsMux; // MUX bit-width
|
|
int nBitsFlop; // flop bit-width
|
|
int nIterMax; // the max number of iterations
|
|
int nLimit; // the max number of signals
|
|
int fXorOutput; // XOR outputs of word-level miter
|
|
int fCheckClauses; // Check clauses in the reloaded trace
|
|
int fPushClauses; // Push clauses in the reloaded trace
|
|
int fMFFC; // Refine the entire MFFC of a PPI
|
|
int fPdra; // Use pdr -nct
|
|
int fLoadTrace; // Load previous traces if any
|
|
int fProofRefine; // Use proof-based refinement
|
|
int fHybrid; // Use a hybrid of CBR and PBR
|
|
int fCheckCombUnsat; // Check if ABS becomes comb. unsat
|
|
int fAbs2; // Use UFAR style createAbs
|
|
int fProofUsePPI; // Use PPI values in PBR
|
|
int fUseBmc3; // Run BMC3 in parallel
|
|
int fShrinkAbs; // Shrink Abs with BMC
|
|
int fShrinkScratch; // Restart pdr from scratch after shrinking
|
|
int fVerbose; // verbose output
|
|
int fPdrVerbose; // verbose output
|
|
int RunId; // id in this run
|
|
int (*pFuncStop)(int); // callback to terminate
|
|
};
|
|
|
|
typedef struct Wlc_BstPar_t_ Wlc_BstPar_t;
|
|
struct Wlc_BstPar_t_
|
|
{
|
|
int iOutput;
|
|
int nOutputRange;
|
|
int nAdderLimit;
|
|
int nMultLimit;
|
|
int fGiaSimple;
|
|
int fAddOutputs;
|
|
int fMulti;
|
|
int fBooth;
|
|
int fCla;
|
|
int fNoCleanup;
|
|
int fCreateMiter;
|
|
int fCreateWordMiter;
|
|
int fDecMuxes;
|
|
int fSaveFfNames;
|
|
int fVerbose;
|
|
Vec_Int_t * vBoxIds;
|
|
};
|
|
|
|
static inline void Wlc_BstParDefault( Wlc_BstPar_t * pPar )
|
|
{
|
|
memset( pPar, 0, sizeof(Wlc_BstPar_t) );
|
|
pPar->iOutput = -1;
|
|
pPar->nOutputRange = 0;
|
|
pPar->nAdderLimit = 0;
|
|
pPar->nMultLimit = 0;
|
|
pPar->fGiaSimple = 0;
|
|
pPar->fAddOutputs = 0;
|
|
pPar->fMulti = 0;
|
|
pPar->fBooth = 0;
|
|
pPar->fCla = 0;
|
|
pPar->fCreateMiter = 0;
|
|
pPar->fCreateWordMiter = 0;
|
|
pPar->fDecMuxes = 0;
|
|
pPar->fVerbose = 0;
|
|
}
|
|
|
|
typedef struct Wla_Man_t_ Wla_Man_t;
|
|
struct Wla_Man_t_
|
|
{
|
|
Wlc_Ntk_t * p;
|
|
Wlc_Par_t * pPars;
|
|
Vec_Vec_t * vClauses;
|
|
Vec_Int_t * vBlacks;
|
|
Vec_Int_t * vSignals;
|
|
Abc_Cex_t * pCex;
|
|
Gia_Man_t * pGia;
|
|
Vec_Bit_t * vUnmark;
|
|
void * pPdrPars;
|
|
void * pThread;
|
|
|
|
int iCexFrame;
|
|
int fNewAbs;
|
|
|
|
int nIters;
|
|
int nTotalCla;
|
|
int nDisj;
|
|
int nNDisj;
|
|
|
|
abctime tPdr;
|
|
abctime tCbr;
|
|
abctime tPbr;
|
|
};
|
|
|
|
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->vCis) - Vec_IntSize(&p->vPis); }
|
|
|
|
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 Wlc_Obj_t * Wlc_NtkFf2( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj( p, Vec_IntEntry(&p->vFfs2, i) ); }
|
|
|
|
static inline int Wlc_ObjIsPi( Wlc_Obj_t * p ) { return p->Type == WLC_OBJ_PI; }
|
|
static inline int Wlc_ObjIsPo( Wlc_Obj_t * p ) { return p->fIsPo; }
|
|
static inline int Wlc_ObjIsCi( Wlc_Obj_t * p ) { return p->Type == WLC_OBJ_PI || p->Type == WLC_OBJ_FO; }
|
|
static inline int Wlc_ObjIsCo( Wlc_Obj_t * p ) { return p->fIsPo || p->fIsFi; }
|
|
static inline int Wlc_ObjIsRead( Wlc_Obj_t * p ) { return p->Type == WLC_OBJ_READ; }
|
|
static inline int Wlc_ObjIsWrite( Wlc_Obj_t * p ) { return p->Type == WLC_OBJ_WRITE; }
|
|
static inline int Wlc_ObjIsMux( Wlc_Obj_t * p ) { return p->Type == WLC_OBJ_MUX; }
|
|
static inline int Wlc_ObjIsBuf( Wlc_Obj_t * p ) { return p->Type == WLC_OBJ_BUF; }
|
|
static inline int Wlc_ObjIsFf( Wlc_Ntk_t * p, int i ) { return Wlc_NtkObj(p, i)->Type == WLC_OBJ_FF; }
|
|
|
|
static inline int Wlc_ObjId( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return pObj - p->pObjs; }
|
|
static inline int Wlc_ObjCiId( Wlc_Obj_t * p ) { assert( Wlc_ObjIsCi(p) ); return p->Fanins[1]; }
|
|
static inline int Wlc_ObjType( Wlc_Obj_t * pObj ) { return pObj->Type; }
|
|
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 || p->Type == WLC_OBJ_BIT_SELECT; }
|
|
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 1 + (p->End >= p->Beg ? p->End - p->Beg : p->Beg - p->End); }
|
|
static inline int Wlc_ObjRangeEnd( Wlc_Obj_t * p ) { assert(p->Type == WLC_OBJ_BIT_SELECT); return p->pFanins[0][1]; }
|
|
static inline int Wlc_ObjRangeBeg( Wlc_Obj_t * p ) { assert(p->Type == WLC_OBJ_BIT_SELECT); return p->pFanins[0][2]; }
|
|
static inline int Wlc_ObjRangeIsReversed( Wlc_Obj_t * p ) { return p->End < p->Beg; }
|
|
|
|
static inline int Wlc_ObjIsSigned( Wlc_Obj_t * p ) { return p->Signed; }
|
|
static inline int Wlc_ObjIsSignedFanin01( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ){ return p->fSmtLib ? Wlc_ObjIsSigned(pObj) : (Wlc_ObjFanin0(p, pObj)->Signed && Wlc_ObjFanin1(p, pObj)->Signed); }
|
|
static inline int Wlc_ObjIsSignedFanin0( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return p->fSmtLib ? Wlc_ObjIsSigned(pObj) : Wlc_ObjFanin0(p, pObj)->Signed; }
|
|
static inline int Wlc_ObjIsSignedFanin1( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return p->fSmtLib ? Wlc_ObjIsSigned(pObj) : Wlc_ObjFanin1(p, pObj)->Signed; }
|
|
static inline int Wlc_ObjSign( Wlc_Obj_t * p ) { return Abc_Var2Lit( Wlc_ObjRange(p), Wlc_ObjIsSigned(p) ); }
|
|
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 int Wlc_ObjLevelId( Wlc_Ntk_t * p, int iObj ) { return Vec_IntEntry( &p->vLevels, iObj ); }
|
|
static inline int Wlc_ObjLevel( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { return Wlc_ObjLevelId( p, Wlc_ObjId(p, 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 Wlc_Obj_t * Wlc_ObjCopyObj(Wlc_Ntk_t * pNew, Wlc_Ntk_t * p, Wlc_Obj_t * pObj) {return Wlc_NtkObj(pNew, Wlc_ObjCopy(p, Wlc_ObjId(p, pObj))); }
|
|
|
|
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 Wlc_Obj_t * Wlc_ObjFo2Fi( Wlc_Ntk_t * p, Wlc_Obj_t * pObj ) { assert( pObj->Type == WLC_OBJ_FO ); return Wlc_NtkCo(p, Wlc_NtkPoNum(p) + Wlc_ObjCiId(pObj) - Wlc_NtkPiNum(p)); }
|
|
static inline Wlc_Obj_t * Wlc_ObjCo2PoFo( Wlc_Ntk_t * p, int iCoId ) { return iCoId < Wlc_NtkPoNum(p) ? Wlc_NtkPo(p, iCoId) : Wlc_NtkCi(p, Wlc_NtkPiNum(p) + iCoId - Wlc_NtkPoNum(p)); }
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// MACRO DEFINITIONS ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// ITERATORS ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
#define Wlc_NtkForEachObj( p, pObj, i ) \
|
|
for ( i = 1; (i < Wlc_NtkObjNumMax(p)) && (((pObj) = Wlc_NtkObj(p, i)), 1); i++ )
|
|
#define Wlc_NtkForEachObjReverse( p, pObj, i ) \
|
|
for ( i = Wlc_NtkObjNumMax(p) - 1; (i > 0) && (((pObj) = Wlc_NtkObj(p, i)), 1); i-- )
|
|
#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_NtkForEachFf2( p, pFf, i ) \
|
|
for ( i = 0; (i < Vec_IntSize(&p->vFfs2)) && (((pFf) = Wlc_NtkFf2(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_ObjForEachFaninObj( p, pObj, pFanin, i ) \
|
|
for ( i = 0; (i < Wlc_ObjFaninNum(pObj)) && (((pFanin) = Wlc_NtkObj(p, 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-- )
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// FUNCTION DECLARATIONS ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
/*=== wlcAbs.c ========================================================*/
|
|
extern int Wlc_NtkAbsCore( Wlc_Ntk_t * p, Wlc_Par_t * pPars );
|
|
extern int Wlc_NtkPdrAbs( Wlc_Ntk_t * p, Wlc_Par_t * pPars );
|
|
/*=== wlcAbs2.c ========================================================*/
|
|
extern int Wlc_NtkAbsCore2( Wlc_Ntk_t * p, Wlc_Par_t * pPars );
|
|
/*=== wlcBlast.c ========================================================*/
|
|
extern Gia_Man_t * Wlc_NtkBitBlast( Wlc_Ntk_t * p, Wlc_BstPar_t * pPars );
|
|
/*=== wlcCom.c ========================================================*/
|
|
extern void Wlc_SetNtk( Abc_Frame_t * pAbc, Wlc_Ntk_t * pNtk );
|
|
/*=== wlcMem.c ========================================================*/
|
|
extern Vec_Int_t * Wlc_NtkCollectMemory( Wlc_Ntk_t * p, int fClean );
|
|
extern void Wlc_NtkPrintMemory( Wlc_Ntk_t * p );
|
|
extern Wlc_Ntk_t * Wlc_NtkMemAbstractTest( Wlc_Ntk_t * p );
|
|
extern int Wlc_NtkMemAbstract( Wlc_Ntk_t * p, int nIterMax, int fDumpAbs, int fPdrVerbose, int fVerbose );
|
|
extern Wlc_Ntk_t * Wlc_NtkAbstractMem( Wlc_Ntk_t * p, int nFrames, int fVerbose );
|
|
/*=== wlcNdr.c ========================================================*/
|
|
extern Wlc_Ntk_t * Wlc_ReadNdr( char * pFileName );
|
|
extern void Wlc_WriteNdr( Wlc_Ntk_t * pNtk, char * pFileName );
|
|
extern Wlc_Ntk_t * Wlc_NtkFromNdr( void * pData );
|
|
extern void * Wlc_NtkToNdr( Wlc_Ntk_t * pNtk );
|
|
/*=== wlcNtk.c ========================================================*/
|
|
extern void Wlc_ManSetDefaultParams( Wlc_Par_t * pPars );
|
|
extern char * Wlc_ObjTypeName( Wlc_Obj_t * p );
|
|
extern Wlc_Ntk_t * Wlc_NtkAlloc( char * pName, int nObjsAlloc );
|
|
extern int Wlc_ObjAlloc( Wlc_Ntk_t * p, int Type, int Signed, int End, int Beg );
|
|
extern int Wlc_ObjCreate( Wlc_Ntk_t * p, int Type, int Signed, int End, int Beg, Vec_Int_t * vFanins );
|
|
extern void Wlc_ObjSetCi( Wlc_Ntk_t * p, Wlc_Obj_t * pObj );
|
|
extern void Wlc_ObjSetCo( Wlc_Ntk_t * p, Wlc_Obj_t * pObj, int fFlopInput );
|
|
extern char * Wlc_ObjName( Wlc_Ntk_t * p, int iObj );
|
|
extern void Wlc_ObjUpdateType( Wlc_Ntk_t * p, Wlc_Obj_t * pObj, int Type );
|
|
extern void Wlc_ObjAddFanins( Wlc_Ntk_t * p, Wlc_Obj_t * pObj, Vec_Int_t * vFanins );
|
|
extern int Wlc_ObjDup( Wlc_Ntk_t * pNew, Wlc_Ntk_t * p, int iObj, Vec_Int_t * vFanins );
|
|
extern void Wlc_NtkFree( Wlc_Ntk_t * p );
|
|
extern int Wlc_NtkCreateLevels( Wlc_Ntk_t * p );
|
|
extern int Wlc_NtkCreateLevelsRev( Wlc_Ntk_t * p );
|
|
extern int Wlc_NtkRemapLevels( Wlc_Ntk_t * p, Vec_Int_t * vObjs, int nLevels );
|
|
extern int Wlc_NtkCountRealPis( Wlc_Ntk_t * p );
|
|
extern void Wlc_NtkPrintNode( Wlc_Ntk_t * p, Wlc_Obj_t * pObj );
|
|
extern void Wlc_NtkPrintNodeArray( Wlc_Ntk_t * p, Vec_Int_t * vArray );
|
|
extern void Wlc_NtkPrintNodes( Wlc_Ntk_t * p, int Type );
|
|
extern void Wlc_NtkPrintStats( Wlc_Ntk_t * p, int fDistrib, int fTwoSides, int fVerbose );
|
|
extern void Wlc_NtkPrintObjects( Wlc_Ntk_t * p );
|
|
extern void Wlc_NtkTransferNames( Wlc_Ntk_t * pNew, Wlc_Ntk_t * p );
|
|
extern char * Wlc_NtkNewName( Wlc_Ntk_t * p, int iCoId, int fSeq );
|
|
extern Wlc_Ntk_t * Wlc_NtkDupDfs( Wlc_Ntk_t * p, int fMarked, int fSeq );
|
|
extern Wlc_Ntk_t * Wlc_NtkDupDfsAbs( Wlc_Ntk_t * p, Vec_Int_t * vPisOld, Vec_Int_t * vPisNew, Vec_Int_t * vFlops );
|
|
extern Wlc_Ntk_t * Wlc_NtkDupDfsSimple( Wlc_Ntk_t * p );
|
|
extern void Wlc_NtkCleanMarks( Wlc_Ntk_t * p );
|
|
extern void Wlc_NtkMarkCone( Wlc_Ntk_t * p, int iCoId, int Range, int fSeq, int fAllPis );
|
|
extern void Wlc_NtkProfileCones( Wlc_Ntk_t * p );
|
|
extern Wlc_Ntk_t * Wlc_NtkDupSingleNodes( Wlc_Ntk_t * p );
|
|
extern void Wlc_NtkShortNames( Wlc_Ntk_t * p );
|
|
extern int Wlc_NtkDcFlopNum( Wlc_Ntk_t * p );
|
|
extern void Wlc_NtkSetRefs( Wlc_Ntk_t * p );
|
|
extern int Wlc_NtkCountObjBits( Wlc_Ntk_t * p, Vec_Int_t * vPisNew );
|
|
/*=== wlcReadSmt.c ========================================================*/
|
|
extern Wlc_Ntk_t * Wlc_ReadSmtBuffer( char * pFileName, char * pBuffer, char * pLimit, int fOldParser, int fPrintTree );
|
|
extern Wlc_Ntk_t * Wlc_ReadSmt( char * pFileName, int fOldParser, int fPrintTree );
|
|
/*=== wlcSim.c ========================================================*/
|
|
extern Vec_Ptr_t * Wlc_NtkSimulate( Wlc_Ntk_t * p, Vec_Int_t * vNodes, int nWords, int nFrames );
|
|
extern void Wlc_NtkDeleteSim( Vec_Ptr_t * p );
|
|
/*=== wlcStdin.c ========================================================*/
|
|
extern int Wlc_StdinProcessSmt( Abc_Frame_t * pAbc, char * pCmd );
|
|
/*=== wlcReadVer.c ========================================================*/
|
|
extern char * Wlc_PrsConvertInitValues( Wlc_Ntk_t * p );
|
|
extern Wlc_Ntk_t * Wlc_ReadVer( char * pFileName, char * pStr );
|
|
/*=== wlcUif.c ========================================================*/
|
|
extern Vec_Int_t * Wlc_NtkCollectAddMult( Wlc_Ntk_t * p, Wlc_BstPar_t * pPar, int * pCountA, int * CountM );
|
|
extern int Wlc_NtkPairIsUifable( Wlc_Ntk_t * p, Wlc_Obj_t * pObj, Wlc_Obj_t * pObj2 );
|
|
extern Vec_Int_t * Wlc_NtkCollectMultipliers( Wlc_Ntk_t * p );
|
|
extern Vec_Int_t * Wlc_NtkFindUifableMultiplierPairs( Wlc_Ntk_t * p );
|
|
extern Wlc_Ntk_t * Wlc_NtkAbstractNodes( Wlc_Ntk_t * pNtk, Vec_Int_t * vNodes );
|
|
extern Wlc_Ntk_t * Wlc_NtkUifNodePairs( Wlc_Ntk_t * pNtk, Vec_Int_t * vPairs );
|
|
/*=== wlcWin.c =============================================================*/
|
|
extern void Wlc_WinProfileArith( Wlc_Ntk_t * p );
|
|
/*=== wlcWriteVer.c ========================================================*/
|
|
extern void Wlc_WriteVer( Wlc_Ntk_t * p, char * pFileName, int fAddCos, int fNoFlops );
|
|
|
|
|
|
ABC_NAMESPACE_HEADER_END
|
|
|
|
#endif
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// END OF FILE ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|