RTLIL Namespace Reference

Data Structures
struct	IdString
struct	sort_by_name_id
struct	sort_by_name_str
struct	sort_by_id_str
struct	ObjIterator
struct	ObjRange
struct	Const
struct	Selection
struct	Monitor
struct	Design
struct	Module
struct	Wire
struct	Memory
struct	Cell
struct	SigChunk
struct	SigBit
struct	SigSpecIterator
struct	SigSpecConstIterator
struct	SigSpec
struct	CaseRule
struct	SwitchRule
struct	SyncRule
struct	Process

Typedefs
typedef std::pair< SigSpec, SigSpec >	SigSig

Enumerations
enum	State : unsigned char {   S0 = 0, S1 = 1, Sx = 2, Sz = 3,   Sa = 4, Sm = 5 }
enum	SyncType : unsigned char {   ST0 = 0, ST1 = 1, STp = 2, STn = 3,   STe = 4, STa = 5, STi = 6 }
enum	ConstFlags : unsigned char { CONST_FLAG_NONE = 0, CONST_FLAG_STRING = 1, CONST_FLAG_SIGNED = 2, CONST_FLAG_REAL = 4 }

Functions
static std::string	escape_id (std::string str)
static std::string	unescape_id (std::string str)
static std::string	unescape_id (RTLIL::IdString str)
static const char *	id2cstr (const RTLIL::IdString &str)
RTLIL::Const	const_not (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_and (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_or (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_xor (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_xnor (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_reduce_and (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_reduce_or (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_reduce_xor (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_reduce_xnor (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_reduce_bool (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_logic_not (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_logic_and (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_logic_or (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_shl (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_shr (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_sshl (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_sshr (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_shift (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_shiftx (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_lt (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_le (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_eq (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_ne (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_eqx (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_nex (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_ge (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_gt (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_add (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_sub (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_mul (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_div (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_mod (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_pow (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_pos (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)
RTLIL::Const	const_neg (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len)

Typedef Documentation

typedef std::pair<SigSpec, SigSpec> RTLIL::SigSig

Definition at line 71 of file rtlil.h.

Enumeration Type Documentation

enum RTLIL::ConstFlags : unsigned char

Enumerator
CONST_FLAG_NONE
CONST_FLAG_STRING
CONST_FLAG_SIGNED
CONST_FLAG_REAL

Definition at line 48 of file rtlil.h.

                    : unsigned char {
        CONST_FLAG_NONE   = 0,
        CONST_FLAG_STRING = 1,
        CONST_FLAG_SIGNED = 2,  // only used for parameters
        CONST_FLAG_REAL   = 4   // unused -- to be used for parameters
    };

enum RTLIL::State : unsigned char

Enumerator
S0
S1
Sx
Sz
Sa
Sm

Definition at line 29 of file rtlil.h.

               : unsigned char {
        S0 = 0,
        S1 = 1,
        Sx = 2, // undefined value or conflict
        Sz = 3, // high-impedance / not-connected
        Sa = 4, // don't care (used only in cases)
        Sm = 5  // marker (used internally by some passes)
    };

enum RTLIL::SyncType : unsigned char

Enumerator
ST0
ST1
STp
STn
STe
STa
STi

Definition at line 38 of file rtlil.h.

                  : unsigned char {
        ST0 = 0, // level sensitive: 0
        ST1 = 1, // level sensitive: 1
        STp = 2, // edge sensitive: posedge
        STn = 3, // edge sensitive: negedge
        STe = 4, // edge sensitive: both edges
        STa = 5, // always active
        STi = 6  // init
    };

Function Documentation

RTLIL::Const RTLIL::const_add	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 464 of file calc.cc.

{
    int undef_bit_pos = -1;
    BigInteger y = const2big(arg1, signed1, undef_bit_pos) + const2big(arg2, signed2, undef_bit_pos);
    return big2const(y, result_len >= 0 ? result_len : std::max(arg1.bits.size(), arg2.bits.size()), undef_bit_pos);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_and	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 165 of file calc.cc.

{
    return logic_wrapper(logic_and, arg1, arg2, signed1, signed2, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_div	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 485 of file calc.cc.

{
    int undef_bit_pos = -1;
    BigInteger a = const2big(arg1, signed1, undef_bit_pos);
    BigInteger b = const2big(arg2, signed2, undef_bit_pos);
    if (b.isZero())
        return RTLIL::Const(RTLIL::State::Sx, result_len);
    bool result_neg = (a.getSign() == BigInteger::negative) != (b.getSign() == BigInteger::negative);
    a = a.getSign() == BigInteger::negative ? -a : a;
    b = b.getSign() == BigInteger::negative ? -b : b;
    return big2const(result_neg ? -(a / b) : (a / b), result_len >= 0 ? result_len : std::max(arg1.bits.size(), arg2.bits.size()), std::min(undef_bit_pos, 0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_eq	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 379 of file calc.cc.

{
    RTLIL::Const arg1_ext = arg1;
    RTLIL::Const arg2_ext = arg2;
    RTLIL::Const result(RTLIL::State::S0, result_len);

    int width = std::max(arg1_ext.bits.size(), arg2_ext.bits.size());
    extend_u0(arg1_ext, width, signed1 && signed2);
    extend_u0(arg2_ext, width, signed1 && signed2);

    RTLIL::State matched_status = RTLIL::State::S1;
    for (size_t i = 0; i < arg1_ext.bits.size(); i++) {
        if (arg1_ext.bits.at(i) == RTLIL::State::S0 && arg2_ext.bits.at(i) == RTLIL::State::S1)
            return result;
        if (arg1_ext.bits.at(i) == RTLIL::State::S1 && arg2_ext.bits.at(i) == RTLIL::State::S0)
            return result;
        if (arg1_ext.bits.at(i) > RTLIL::State::S1 || arg2_ext.bits.at(i) > RTLIL::State::S1)
            matched_status = RTLIL::State::Sx;
    }

    result.bits.front() = matched_status;
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_eqx	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 413 of file calc.cc.

{
    RTLIL::Const arg1_ext = arg1;
    RTLIL::Const arg2_ext = arg2;
    RTLIL::Const result(RTLIL::State::S0, result_len);

    int width = std::max(arg1_ext.bits.size(), arg2_ext.bits.size());
    extend_u0(arg1_ext, width, signed1 && signed2);
    extend_u0(arg2_ext, width, signed1 && signed2);

    for (size_t i = 0; i < arg1_ext.bits.size(); i++) {
        if (arg1_ext.bits.at(i) != arg2_ext.bits.at(i))
            return result;
    }

    result.bits.front() = RTLIL::State::S1;
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_ge	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 442 of file calc.cc.

{
    int undef_bit_pos = -1;
    bool y = const2big(arg1, signed1, undef_bit_pos) >= const2big(arg2, signed2, undef_bit_pos);
    RTLIL::Const result(undef_bit_pos >= 0 ? RTLIL::State::Sx : y ? RTLIL::State::S1 : RTLIL::State::S0);

    while (int(result.bits.size()) < result_len)
        result.bits.push_back(RTLIL::State::S0);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_gt	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 453 of file calc.cc.

{
    int undef_bit_pos = -1;
    bool y = const2big(arg1, signed1, undef_bit_pos) > const2big(arg2, signed2, undef_bit_pos);
    RTLIL::Const result(undef_bit_pos >= 0 ? RTLIL::State::Sx : y ? RTLIL::State::S1 : RTLIL::State::S0);

    while (int(result.bits.size()) < result_len)
        result.bits.push_back(RTLIL::State::S0);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_le	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 368 of file calc.cc.

{
    int undef_bit_pos = -1;
    bool y = const2big(arg1, signed1, undef_bit_pos) <= const2big(arg2, signed2, undef_bit_pos);
    RTLIL::Const result(undef_bit_pos >= 0 ? RTLIL::State::Sx : y ? RTLIL::State::S1 : RTLIL::State::S0);

    while (int(result.bits.size()) < result_len)
        result.bits.push_back(RTLIL::State::S0);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_logic_and	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 241 of file calc.cc.

{
    int undef_bit_pos_a = -1, undef_bit_pos_b = -1;
    BigInteger a = const2big(arg1, signed1, undef_bit_pos_a);
    BigInteger b = const2big(arg2, signed2, undef_bit_pos_b);

    RTLIL::State bit_a = a.isZero() ? undef_bit_pos_a >= 0 ? RTLIL::State::Sx : RTLIL::State::S0 : RTLIL::State::S1;
    RTLIL::State bit_b = b.isZero() ? undef_bit_pos_b >= 0 ? RTLIL::State::Sx : RTLIL::State::S0 : RTLIL::State::S1;
    RTLIL::Const result(logic_and(bit_a, bit_b));

    while (int(result.bits.size()) < result_len)
        result.bits.push_back(RTLIL::State::S0);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_logic_not	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 230 of file calc.cc.

{
    int undef_bit_pos_a = -1;
    BigInteger a = const2big(arg1, signed1, undef_bit_pos_a);
    RTLIL::Const result(a.isZero() ? undef_bit_pos_a >= 0 ? RTLIL::State::Sx : RTLIL::State::S1 : RTLIL::State::S0);

    while (int(result.bits.size()) < result_len)
        result.bits.push_back(RTLIL::State::S0);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_logic_or	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 256 of file calc.cc.

{
    int undef_bit_pos_a = -1, undef_bit_pos_b = -1;
    BigInteger a = const2big(arg1, signed1, undef_bit_pos_a);
    BigInteger b = const2big(arg2, signed2, undef_bit_pos_b);

    RTLIL::State bit_a = a.isZero() ? undef_bit_pos_a >= 0 ? RTLIL::State::Sx : RTLIL::State::S0 : RTLIL::State::S1;
    RTLIL::State bit_b = b.isZero() ? undef_bit_pos_b >= 0 ? RTLIL::State::Sx : RTLIL::State::S0 : RTLIL::State::S1;
    RTLIL::Const result(logic_or(bit_a, bit_b));

    while (int(result.bits.size()) < result_len)
        result.bits.push_back(RTLIL::State::S0);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_lt	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 357 of file calc.cc.

{
    int undef_bit_pos = -1;
    bool y = const2big(arg1, signed1, undef_bit_pos) < const2big(arg2, signed2, undef_bit_pos);
    RTLIL::Const result(undef_bit_pos >= 0 ? RTLIL::State::Sx : y ? RTLIL::State::S1 : RTLIL::State::S0);

    while (int(result.bits.size()) < result_len)
        result.bits.push_back(RTLIL::State::S0);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_mod	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 498 of file calc.cc.

{
    int undef_bit_pos = -1;
    BigInteger a = const2big(arg1, signed1, undef_bit_pos);
    BigInteger b = const2big(arg2, signed2, undef_bit_pos);
    if (b.isZero())
        return RTLIL::Const(RTLIL::State::Sx, result_len);
    bool result_neg = a.getSign() == BigInteger::negative;
    a = a.getSign() == BigInteger::negative ? -a : a;
    b = b.getSign() == BigInteger::negative ? -b : b;
    return big2const(result_neg ? -(a % b) : (a % b), result_len >= 0 ? result_len : std::max(arg1.bits.size(), arg2.bits.size()), std::min(undef_bit_pos, 0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_mul	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 478 of file calc.cc.

{
    int undef_bit_pos = -1;
    BigInteger y = const2big(arg1, signed1, undef_bit_pos) * const2big(arg2, signed2, undef_bit_pos);
    return big2const(y, result_len >= 0 ? result_len : std::max(arg1.bits.size(), arg2.bits.size()), std::min(undef_bit_pos, 0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_ne	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 403 of file calc.cc.

{
    RTLIL::Const result = RTLIL::const_eq(arg1, arg2, signed1, signed2, result_len);
    if (result.bits.front() == RTLIL::State::S0)
        result.bits.front() = RTLIL::State::S1;
    else if (result.bits.front() == RTLIL::State::S1)
        result.bits.front() = RTLIL::State::S0;
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_neg	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 570 of file calc.cc.

{
    RTLIL::Const arg1_ext = arg1;
    RTLIL::Const zero(RTLIL::State::S0, 1);

    return RTLIL::const_sub(zero, arg1_ext, true, signed1, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_nex	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 432 of file calc.cc.

{
    RTLIL::Const result = RTLIL::const_eqx(arg1, arg2, signed1, signed2, result_len);
    if (result.bits.front() == RTLIL::State::S0)
        result.bits.front() = RTLIL::State::S1;
    else if (result.bits.front() == RTLIL::State::S1)
        result.bits.front() = RTLIL::State::S0;
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_not	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 125 of file calc.cc.

{
    if (result_len < 0)
        result_len = arg1.bits.size();

    RTLIL::Const arg1_ext = arg1;
    extend_u0(arg1_ext, result_len, signed1);

    RTLIL::Const result(RTLIL::State::Sx, result_len);
    for (size_t i = 0; i < size_t(result_len); i++) {
        if (i >= arg1_ext.bits.size())
            result.bits[i] = RTLIL::State::S0;
        else if (arg1_ext.bits[i] == RTLIL::State::S0)
            result.bits[i] = RTLIL::State::S1;
        else if (arg1_ext.bits[i] == RTLIL::State::S1)
            result.bits[i] = RTLIL::State::S0;
    }

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_or	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 170 of file calc.cc.

{
    return logic_wrapper(logic_or, arg1, arg2, signed1, signed2, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_pos	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 562 of file calc.cc.

{
    RTLIL::Const arg1_ext = arg1;
    extend_u0(arg1_ext, result_len, signed1);

    return arg1_ext;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_pow	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 511 of file calc.cc.

{
    int undef_bit_pos = -1;

    BigInteger a = const2big(arg1, signed1, undef_bit_pos);
    BigInteger b = const2big(arg2, signed2, undef_bit_pos);
    BigInteger y = 1;

    if (a == 0 && b < 0)
        return RTLIL::Const(RTLIL::State::Sx, result_len);

    if (a == 0 && b > 0)
        return RTLIL::Const(RTLIL::State::S0, result_len);

    if (b < 0)
    {
        if (a < -1 || a > 1)
            y = 0;
        if (a == -1)
            y = (-b % 2) == 0 ? 1 : -1;
    }

    if (b > 0)
    {
        // Power-modulo with 2^result_len as modulus
        BigInteger modulus = 1;
        int modulus_bits = (result_len >= 0 ? result_len : 1024);
        for (int i = 0; i < modulus_bits; i++)
            modulus *= 2;

        bool flip_result_sign = false;
        if (a < 0) {
            a *= -1;
            if (b % 2 == 1)
                flip_result_sign = true;
        }

        while (b > 0) {
            if (b % 2 == 1)
                y = (y * a) % modulus;
            b = b / 2;
            a = (a * a) % modulus;
        }

        if (flip_result_sign)
            y *= -1;
    }

    return big2const(y, result_len >= 0 ? result_len : std::max(arg1.bits.size(), arg2.bits.size()), std::min(undef_bit_pos, 0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_reduce_and	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 198 of file calc.cc.

{
    return logic_reduce_wrapper(RTLIL::State::S1, logic_and, arg1, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_reduce_bool	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 225 of file calc.cc.

{
    return logic_reduce_wrapper(RTLIL::State::S0, logic_or, arg1, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_reduce_or	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 203 of file calc.cc.

{
    return logic_reduce_wrapper(RTLIL::State::S0, logic_or, arg1, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_reduce_xnor	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 213 of file calc.cc.

{
    RTLIL::Const buffer = logic_reduce_wrapper(RTLIL::State::S0, logic_xor, arg1, result_len);
    if (!buffer.bits.empty()) {
        if (buffer.bits.front() == RTLIL::State::S0)
            buffer.bits.front() = RTLIL::State::S1;
        else if (buffer.bits.front() == RTLIL::State::S1)
            buffer.bits.front() = RTLIL::State::S0;
    }
    return buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_reduce_xor	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 208 of file calc.cc.

{
    return logic_reduce_wrapper(RTLIL::State::S0, logic_xor, arg1, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_shift	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 347 of file calc.cc.

{
    return const_shift_shiftx(arg1, arg2, signed1, signed2, result_len, RTLIL::State::S0);
}

Here is the call graph for this function:

RTLIL::Const RTLIL::const_shiftx	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 352 of file calc.cc.

{
    return const_shift_shiftx(arg1, arg2, signed1, signed2, result_len, RTLIL::State::Sx);
}

Here is the call graph for this function:

RTLIL::Const RTLIL::const_shl	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 296 of file calc.cc.

{
    RTLIL::Const arg1_ext = arg1;
    extend_u0(arg1_ext, result_len, signed1);
    return const_shift_worker(arg1_ext, arg2, false, -1, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_shr	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 303 of file calc.cc.

{
    RTLIL::Const arg1_ext = arg1;
    extend_u0(arg1_ext, std::max(result_len, GetSize(arg1)), signed1);
    return const_shift_worker(arg1_ext, arg2, false, +1, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_sshl	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 310 of file calc.cc.

{
    if (!signed1)
        return const_shl(arg1, arg2, signed1, signed2, result_len);
    return const_shift_worker(arg1, arg2, true, -1, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_sshr	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 317 of file calc.cc.

{
    if (!signed1)
        return const_shr(arg1, arg2, signed1, signed2, result_len);
    return const_shift_worker(arg1, arg2, true, +1, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_sub	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 471 of file calc.cc.

{
    int undef_bit_pos = -1;
    BigInteger y = const2big(arg1, signed1, undef_bit_pos) - const2big(arg2, signed2, undef_bit_pos);
    return big2const(y, result_len >= 0 ? result_len : std::max(arg1.bits.size(), arg2.bits.size()), undef_bit_pos);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_xnor	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 180 of file calc.cc.

{
    return logic_wrapper(logic_xnor, arg1, arg2, signed1, signed2, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Const RTLIL::const_xor	(	const RTLIL::Const &	arg1,
		const RTLIL::Const &	arg2,
		bool	signed1,
		bool	signed2,
		int	result_len
	)

Definition at line 175 of file calc.cc.

{
    return logic_wrapper(logic_xor, arg1, arg2, signed1, signed2, result_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static std::string RTLIL::escape_id ( std::string  str )

inlinestatic

Definition at line 251 of file rtlil.h.

                                                     {
        if (str.size() > 0 && str[0] != '\\' && str[0] != '$')
            return "\\" + str;
        return str;
    }

Here is the caller graph for this function:

static const char* RTLIL::id2cstr ( const RTLIL::IdString &  str )

inlinestatic

Definition at line 267 of file rtlil.h.

                                                                {
        return log_id(str);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static std::string RTLIL::unescape_id ( std::string  str )

inlinestatic

Definition at line 257 of file rtlil.h.

                                                       {
        if (str.size() > 1 && str[0] == '\\' && str[1] != '$')
            return str.substr(1);
        return str;
    }

Here is the caller graph for this function:

static std::string RTLIL::unescape_id ( RTLIL::IdString  str )

inlinestatic

Definition at line 263 of file rtlil.h.

                                                           {
        return unescape_id(str.str());
    }

Here is the call graph for this function: