mirror of
https://github.com/YosysHQ/yosys
synced 2026-07-25 16:42:35 +00:00
862 lines
No EOL
17 KiB
Text
862 lines
No EOL
17 KiB
Text
###################################################################
|
|
# Extract Reduce AND Gates Tests
|
|
###################################################################
|
|
|
|
log -header "Simple AND chain"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [3:0] a,
|
|
output wire x
|
|
);
|
|
assign x = a[0] & a[1] & a[2] & a[3];
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates and inputs
|
|
select -assert-count 0 t:$and
|
|
select -assert-count 1 t:$reduce_and
|
|
select -assert-count 1 t:$reduce_and r:A_WIDTH=4 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "AND chain with constants"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [2:0] a,
|
|
output wire x
|
|
);
|
|
assign x = a[0] & a[1] & a[2] & 1'b1;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates and inputs
|
|
select -assert-count 0 t:$and
|
|
select -assert-count 1 t:$reduce_and
|
|
select -assert-count 1 t:$reduce_and r:A_WIDTH=4 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "AND chain with multiple branches"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [5:0] a,
|
|
output wire x
|
|
);
|
|
wire w0, w1, w2, w3;
|
|
|
|
assign w0 = a[0] & a[1];
|
|
assign w1 = a[2] & a[3];
|
|
assign w2 = a[4] & a[5];
|
|
assign w3 = w0 & w1;
|
|
assign x = w2 & w3;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates and inputs
|
|
select -assert-count 0 t:$and
|
|
select -assert-count 1 t:$reduce_and
|
|
select -assert-count 1 t:$reduce_and r:A_WIDTH=6 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "No off-chain for AND"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [4:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0, w1, w2;
|
|
|
|
assign w0 = a[0] & a[1];
|
|
assign w1 = w0 & a[2];
|
|
assign w2 = w1 & a[3];
|
|
assign x = w2 & a[4];
|
|
|
|
// Off-chain use of w1
|
|
assign y = w1;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$and
|
|
select -assert-count 2 t:$reduce_and
|
|
select -assert-count 2 t:$reduce_and
|
|
|
|
# Check that both gates are 3 bits wide
|
|
select -assert-none t:$reduce_and r:A_WIDTH!=3 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "Allow off-chain for AND"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [4:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0, w1, w2;
|
|
|
|
assign w0 = a[0] & a[1];
|
|
assign w1 = w0 & a[2];
|
|
assign w2 = w1 & a[3];
|
|
assign x = w2 & a[4];
|
|
|
|
// Off-chain use of w1
|
|
assign y = w1;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce -allow-off-chain
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$and
|
|
select -assert-count 2 t:$reduce_and
|
|
|
|
# Check that only one gate has a width of 5 and one gate has a width of 3
|
|
select -assert-count 1 t:$reduce_and r:A_WIDTH=5 %i
|
|
select -assert-count 1 t:$reduce_and r:A_WIDTH=3 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "No off-chain with branches for AND"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [10:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0;
|
|
|
|
assign w0 = a[0] & a[1] & a[2] & (a[3] & a[4]) & a[5];
|
|
assign x = w0 & a[6] & a[7] & (a[8] & a[9]) & a[10];
|
|
|
|
// Off-chain use of w0
|
|
assign y = w0;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$and
|
|
select -assert-count 2 t:$reduce_and
|
|
|
|
# Check that both gates are 6 bits wide
|
|
select -assert-none t:$reduce_and r:A_WIDTH!=6 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "Allow off-chain with branches for AND"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [10:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0;
|
|
|
|
assign w0 = a[0] & a[1] & a[2] & (a[3] & a[4]) & a[5];
|
|
assign x = w0 & a[6] & a[7] & (a[8] & a[9]) & a[10];
|
|
|
|
// Off-chain use of w0
|
|
assign y = w0;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce -allow-off-chain
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$and
|
|
select -assert-count 2 t:$reduce_and
|
|
|
|
# Check that only one gate has a width of 11 and one gate has a width of 6
|
|
select -assert-count 1 t:$reduce_and r:A_WIDTH=11 %i
|
|
select -assert-count 1 t:$reduce_and r:A_WIDTH=6 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
###################################################################
|
|
# Extract Reduce OR Gates Tests
|
|
###################################################################
|
|
|
|
log -header "Simple OR chain"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [3:0] a,
|
|
output wire x
|
|
);
|
|
assign x = a[0] | a[1] | a[2] | a[3];
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates and inputs
|
|
select -assert-count 0 t:$or
|
|
select -assert-count 1 t:$reduce_or
|
|
select -assert-count 1 t:$reduce_or r:A_WIDTH=4 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "OR chain with constants"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [3:0] a,
|
|
output wire x
|
|
);
|
|
assign x = a[0] | a[1] | a[2] | 1'b1;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates and inputs
|
|
select -assert-count 0 t:$or
|
|
select -assert-count 1 t:$reduce_or
|
|
select -assert-count 1 t:$reduce_or r:A_WIDTH=4 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "OR chain with multiple branches"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [5:0] a,
|
|
output wire x
|
|
);
|
|
wire w0, w1, w2, w3;
|
|
|
|
assign w0 = a[0] | a[1];
|
|
assign w1 = a[2] | a[3];
|
|
assign w2 = a[4] | a[5];
|
|
assign w3 = w0 | w1;
|
|
assign x = w2 | w3;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates and inputs
|
|
select -assert-count 0 t:$or
|
|
select -assert-count 1 t:$reduce_or
|
|
select -assert-count 1 t:$reduce_or r:A_WIDTH=6 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "No off-chain OR"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [4:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0, w1, w2;
|
|
|
|
assign w0 = a[0] | a[1];
|
|
assign w1 = w0 | a[2];
|
|
assign w2 = w1 | a[3];
|
|
assign x = w2 | a[4];
|
|
|
|
// Off-chain use of w1
|
|
assign y = w1;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$or
|
|
select -assert-count 2 t:$reduce_or
|
|
|
|
# Check that both gates are 3 bits wide
|
|
select -assert-none t:$reduce_or r:A_WIDTH!=3 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "Allow off-chain for OR"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [4:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0, w1, w2;
|
|
|
|
assign w0 = a[0] | a[1];
|
|
assign w1 = w0 | a[2];
|
|
assign w2 = w1 | a[3];
|
|
assign x = w2 | a[4];
|
|
|
|
// Off-chain use of w1
|
|
assign y = w1;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce -allow-off-chain
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$or
|
|
select -assert-count 2 t:$reduce_or
|
|
|
|
# Check that only one gate has a width of 5 and one gate has a width of 3
|
|
select -assert-count 1 t:$reduce_or r:A_WIDTH=5 %i
|
|
select -assert-count 1 t:$reduce_or r:A_WIDTH=3 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "No off-chain with branches for OR"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [10:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0;
|
|
|
|
assign w0 = a[0] | a[1] | a[2] | (a[3] | a[4]) | a[5];
|
|
assign x = w0 | a[6] | a[7] | (a[8] | a[9]) | a[10];
|
|
|
|
// Off-chain use of w0
|
|
assign y = w0;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$and
|
|
select -assert-count 2 t:$reduce_or
|
|
|
|
# Check that both gates are 6 bits wide
|
|
select -assert-none t:$reduce_or r:A_WIDTH!=6 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "Allow off-chain with branches for OR"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [10:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0;
|
|
|
|
assign w0 = a[0] | a[1] | a[2] | (a[3] | a[4]) | a[5];
|
|
assign x = w0 | a[6] | a[7] | (a[8] | a[9]) | a[10];
|
|
|
|
// Off-chain use of w0
|
|
assign y = w0;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce -allow-off-chain
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$or
|
|
select -assert-count 2 t:$reduce_or
|
|
|
|
# Check that only one gate has a width of 11 and one gate has a width of 6
|
|
select -assert-count 1 t:$reduce_or r:A_WIDTH=11 %i
|
|
select -assert-count 1 t:$reduce_or r:A_WIDTH=6 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
###################################################################
|
|
# Extract Reduce XOR Gates Tests
|
|
###################################################################
|
|
|
|
log -header "Simple XOR chain"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [3:0] a,
|
|
output wire x
|
|
);
|
|
assign x = a[0] ^ a[1] ^ a[2] ^ a[3];
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates and inputs
|
|
select -assert-count 0 t:$xor
|
|
select -assert-count 1 t:$reduce_xor
|
|
select -assert-count 1 t:$reduce_xor r:A_WIDTH=4 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "XOR chain with constants"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [3:0] a,
|
|
output wire x
|
|
);
|
|
assign x = a[0] ^ a[1] ^ a[2] ^ 1'b1;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates and inputs
|
|
select -assert-count 0 t:$xor
|
|
select -assert-count 1 t:$reduce_xor
|
|
select -assert-count 1 t:$reduce_xor r:A_WIDTH=4 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "XOR chain with multiple branches"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [5:0] a,
|
|
output wire x
|
|
);
|
|
wire w0, w1, w2, w3;
|
|
|
|
assign w0 = a[0] ^ a[1];
|
|
assign w1 = a[2] ^ a[3];
|
|
assign w2 = a[4] ^ a[5];
|
|
assign w3 = w0 ^ w1;
|
|
assign x = w2 ^ w3;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates and inputs
|
|
select -assert-count 0 t:$xor
|
|
select -assert-count 1 t:$reduce_xor
|
|
select -assert-count 1 t:$reduce_xor r:A_WIDTH=6 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "No off-chain XOR"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [4:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0, w1, w2;
|
|
|
|
assign w0 = a[0] ^ a[1];
|
|
assign w1 = w0 ^ a[2];
|
|
assign w2 = w1 ^ a[3];
|
|
assign x = w2 ^ a[4];
|
|
|
|
// Off-chain use of w1
|
|
assign y = w1;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$xor
|
|
select -assert-count 2 t:$reduce_xor
|
|
|
|
# Check that both gates are 3 bits wide
|
|
select -assert-none t:$reduce_xor r:A_WIDTH!=3 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "Allow off-chain for XOR"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [4:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0, w1, w2;
|
|
|
|
assign w0 = a[0] ^ a[1];
|
|
assign w1 = w0 ^ a[2];
|
|
assign w2 = w1 ^ a[3];
|
|
assign x = w2 ^ a[4];
|
|
|
|
// Off-chain use of w1
|
|
assign y = w1;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce -allow-off-chain
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$xor
|
|
select -assert-count 2 t:$reduce_xor
|
|
|
|
# Check that only one gate has a width of 5 and one gate has a width of 3
|
|
select -assert-count 1 t:$reduce_xor r:A_WIDTH=5 %i
|
|
select -assert-count 1 t:$reduce_xor r:A_WIDTH=3 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "No off-chain with branches for XOR"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [10:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0;
|
|
|
|
assign w0 = a[0] ^ a[1] ^ a[2] ^ (a[3] ^ a[4]) ^ a[5];
|
|
assign x = w0 ^ a[6] ^ a[7] ^ (a[8] ^ a[9]) ^ a[10];
|
|
|
|
// Off-chain use of w0
|
|
assign y = w0;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$xor
|
|
select -assert-count 2 t:$reduce_xor
|
|
|
|
# Check that both gates are 6 bits wide
|
|
select -assert-none t:$reduce_xor r:A_WIDTH!=6 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
log -header "Allow off-chain with branches for XOR"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [10:0] a,
|
|
output wire x,
|
|
output wire y
|
|
);
|
|
wire w0;
|
|
|
|
assign w0 = a[0] ^ a[1] ^ a[2] ^ (a[3] ^ a[4]) ^ a[5];
|
|
assign x = w0 ^ a[6] ^ a[7] ^ (a[8] ^ a[9]) ^ a[10];
|
|
|
|
// Off-chain use of w0
|
|
assign y = w0;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce -allow-off-chain
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates
|
|
select -assert-count 0 t:$xor
|
|
select -assert-count 2 t:$reduce_xor
|
|
|
|
# Check that only one gate has a width of 11 and one gate has a width of 6
|
|
select -assert-count 1 t:$reduce_xor r:A_WIDTH=11 %i
|
|
select -assert-count 1 t:$reduce_xor r:A_WIDTH=6 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
###################################################################
|
|
# Edge Cases
|
|
###################################################################
|
|
|
|
log -header "Reconvergence"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire [7:0] a,
|
|
output wire y
|
|
);
|
|
wire w0, w1, w2, w3, w4, w5, w6;
|
|
|
|
assign w0 = a[0] & a[1];
|
|
assign w1 = a[2] & a[3];
|
|
assign w2 = w0 & w1;
|
|
assign w3 = w2 & a[4];
|
|
assign w4 = w2 & a[5];
|
|
assign w5 = w3 & a[6];
|
|
assign w6 = w4 & a[7];
|
|
assign y = w5 & w6;
|
|
endmodule
|
|
EOF
|
|
check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
equiv_opt -assert extract_reduce
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates and inputs
|
|
select -assert-count 0 t:$and
|
|
select -assert-count 2 t:$reduce_and
|
|
select -assert-count 1 t:$reduce_and r:A_WIDTH=4 %i
|
|
select -assert-count 1 t:$reduce_and r:A_WIDTH=6 %i
|
|
|
|
design -reset
|
|
log -pop
|
|
|
|
|
|
|
|
# TODO
|
|
log -header "Combinational feedback loop"
|
|
log -push
|
|
design -reset
|
|
read_verilog <<EOF
|
|
module top (
|
|
input wire a,
|
|
output wire y
|
|
);
|
|
wire w0, w1;
|
|
|
|
// Two AND gates feeding each other
|
|
assign w0 = a & w1;
|
|
assign w1 = a & w0;
|
|
|
|
assign y = w1;
|
|
endmodule
|
|
EOF
|
|
# check -assert
|
|
|
|
# Check equivalence after extract_reduce
|
|
# equiv_opt -assert extract_reduce
|
|
extract_reduce -allow-off-chain
|
|
|
|
# Load design and run opt_clean to remove unnecessary wires
|
|
design -load postopt
|
|
opt_clean
|
|
|
|
# Check final design has correct number of gates and inputs
|
|
select -assert-count 0 t:$and
|
|
select -assert-count 2 t:$reduce_and
|
|
select -assert-count 1 t:$reduce_and r:A_WIDTH=4 %i
|
|
select -assert-count 1 t:$reduce_and r:A_WIDTH=6 %i
|
|
|
|
design -reset
|
|
log -pop |