HDLRuby 2.6.8 → 2.6.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/lib/HDLRuby/hdr_samples/neg_arith_bench.rb +11 -0
- data/lib/HDLRuby/hruby_high.rb +16 -0
- data/lib/HDLRuby/hruby_low2c.rb +3 -1
- data/lib/HDLRuby/hruby_verilog_name.rb +50 -32
- data/lib/HDLRuby/sim/hruby_sim_calc.c +168 -8
- data/lib/HDLRuby/version.rb +1 -1
- metadata +2 -2
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA256:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 219077a50d543c3ecdb964a7bd7571f5c0db02ece82a0efb7670e5531acf437d
|
|
4
|
+
data.tar.gz: 2bbff4911a6c7ff9ec3c33287b61d4a1b7efd5c7dc789975d89e53b3f42638c1
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: c95ef3fa229c2e9283cd78f86c9f6fa4ad4f80d0e3f6153ee444e2c75d754dc7098a5547ce623f8aa85b1860e24522f8404a6e654849d0250897acca26134f9a
|
|
7
|
+
data.tar.gz: '023502192d5189e2a85a4d69d3f63bb81d58d38496812be03b8c7c5c92791309412e21cbb4d68aa79f03372d296635cafe55264e5483d12d8eef56236b188aeb'
|
|
@@ -2,6 +2,7 @@
|
|
|
2
2
|
# A benchmark for testing the arithmetic with signed values.
|
|
3
3
|
system :neg_arith_bench do
|
|
4
4
|
signed[11..0].inner :x,:y,:z
|
|
5
|
+
inner :cmp
|
|
5
6
|
|
|
6
7
|
timed do
|
|
7
8
|
x <= 10
|
|
@@ -9,41 +10,51 @@ system :neg_arith_bench do
|
|
|
9
10
|
z <= 0
|
|
10
11
|
!10.ns
|
|
11
12
|
z <= 10 * 10
|
|
13
|
+
cmp <= (10 < 10)
|
|
12
14
|
!10.ns
|
|
13
15
|
z <= x * y
|
|
16
|
+
cmp <= (x < y)
|
|
14
17
|
!10.ns
|
|
15
18
|
x <= 10
|
|
16
19
|
y <= -10
|
|
17
20
|
!10.ns
|
|
18
21
|
z <= 10 * (-10)
|
|
22
|
+
cmp <= (10 < -10)
|
|
19
23
|
!10.ns
|
|
20
24
|
z <= x * y
|
|
25
|
+
cmp <= (x < y)
|
|
21
26
|
!10.ns
|
|
22
27
|
x <= -10
|
|
23
28
|
y <= 10
|
|
24
29
|
!10.ns
|
|
25
30
|
z <= (-10) * 10
|
|
31
|
+
cmp <= (-10 < 10)
|
|
26
32
|
!10.ns
|
|
27
33
|
z <= x * y
|
|
34
|
+
cmp <= (x < y)
|
|
28
35
|
!10.ns
|
|
29
36
|
x <= -10
|
|
30
37
|
y <= -10
|
|
31
38
|
!10.ns
|
|
32
39
|
z <= (-10) * (-10)
|
|
40
|
+
cmp <= (-10 < -10)
|
|
33
41
|
!10.ns
|
|
34
42
|
z <= x * y
|
|
43
|
+
cmp <= (x < y)
|
|
35
44
|
!10.ns
|
|
36
45
|
x <= _000000011010
|
|
37
46
|
y <= _000011111010
|
|
38
47
|
z <= 0
|
|
39
48
|
!10.ns
|
|
40
49
|
z <= x * y
|
|
50
|
+
cmp <= (x < y)
|
|
41
51
|
!10.ns
|
|
42
52
|
x <= _000000011010
|
|
43
53
|
y <= _111111111010
|
|
44
54
|
z <= 0
|
|
45
55
|
!10.ns
|
|
46
56
|
z <= x * y
|
|
57
|
+
cmp <= (x < y)
|
|
47
58
|
!10.ns
|
|
48
59
|
end
|
|
49
60
|
end
|
data/lib/HDLRuby/hruby_high.rb
CHANGED
|
@@ -4237,6 +4237,22 @@ module HDLRuby::High
|
|
|
4237
4237
|
# end
|
|
4238
4238
|
# end
|
|
4239
4239
|
|
|
4240
|
+
# Extends the TrueClass class for computing for conversion to expression.
|
|
4241
|
+
class ::TrueClass
|
|
4242
|
+
# Converts to a new high-level expression.
|
|
4243
|
+
def to_expr
|
|
4244
|
+
return Value.new(Integer,1)
|
|
4245
|
+
end
|
|
4246
|
+
end
|
|
4247
|
+
|
|
4248
|
+
# Extends the FalseClass class for computing for conversion to expression.
|
|
4249
|
+
class ::FalseClass
|
|
4250
|
+
# Converts to a new high-level expression.
|
|
4251
|
+
def to_expr
|
|
4252
|
+
return Value.new(Integer,0)
|
|
4253
|
+
end
|
|
4254
|
+
end
|
|
4255
|
+
|
|
4240
4256
|
# Extends the Integer class for computing for conversion to expression.
|
|
4241
4257
|
class ::Integer
|
|
4242
4258
|
# Converts to a new high-level expression.
|
data/lib/HDLRuby/hruby_low2c.rb
CHANGED
|
@@ -1570,7 +1570,9 @@ module HDLRuby::Low
|
|
|
1570
1570
|
# puts "content=#{self.content} str=#{str}"
|
|
1571
1571
|
end
|
|
1572
1572
|
# Is it a fully defined number?
|
|
1573
|
-
|
|
1573
|
+
# NOTE: bignum values are not supported by the simulation engine
|
|
1574
|
+
# yet, therefore numeric values are limited to 64 max.
|
|
1575
|
+
if str =~ /^[01]+$/ && str.length <= 64 then
|
|
1574
1576
|
# Yes, generate a numeral value.
|
|
1575
1577
|
res << " " * (level+1)*3
|
|
1576
1578
|
res << "static unsigned long long data[] = { "
|
|
@@ -10,41 +10,59 @@ module HDLRuby::Verilog
|
|
|
10
10
|
|
|
11
11
|
# Since it is possible to use $ and numbers other than the beginning of the character string, it is divided.
|
|
12
12
|
def name_to_verilog(name)
|
|
13
|
-
ref = "" # For storing the converted character.
|
|
14
|
-
name = name.to_s # Ensure name is a string
|
|
15
|
-
|
|
16
|
-
if (name[0] =~ /[a-zA-Z]/) then
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
elsif (name[0] == "_") then
|
|
20
|
-
|
|
21
|
-
# If it does not satisfy the above, it is another character.
|
|
22
|
-
# In that case, convert it to UTF-8 and convert it to a usable character string.
|
|
23
|
-
else
|
|
24
|
-
|
|
13
|
+
# ref = "" # For storing the converted character.
|
|
14
|
+
# name = name.to_s # Ensure name is a string
|
|
15
|
+
#
|
|
16
|
+
# if (name[0] =~ /[a-zA-Z]/) then
|
|
17
|
+
# ref << name[0]
|
|
18
|
+
# # _ To convert it to __.
|
|
19
|
+
# elsif (name[0] == "_") then
|
|
20
|
+
# ref << "__"
|
|
21
|
+
# # If it does not satisfy the above, it is another character.
|
|
22
|
+
# # In that case, convert it to UTF-8 and convert it to a usable character string.
|
|
23
|
+
# else
|
|
24
|
+
# l = name[0].bytes.map{|v| v.to_s(16)}.join # Conversion to UTF-8 hexadecimal number.
|
|
25
25
|
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
end
|
|
26
|
+
# ref << "_" + l.rjust(6,"0") # Add an underscore indicating conversion.
|
|
27
|
+
# # The remainder of 6 digits is filled with 0.
|
|
28
|
+
# end
|
|
29
|
+
#
|
|
30
|
+
# name[1..-1].each_char do |c|
|
|
31
|
+
# # Confirmation of characters in array.
|
|
32
|
+
# # If it is a-zA-Z 0 - 9, it is added to ref as it is.
|
|
33
|
+
# if (c =~ /[a-zA-Z0-9]|\$/) then
|
|
34
|
+
# ref << c
|
|
35
|
+
# # _ To convert it to __.
|
|
36
|
+
# elsif (c == "_") then
|
|
37
|
+
# ref << "__"
|
|
38
|
+
# # If it does not satisfy the above, it is another character.
|
|
39
|
+
# # In that case, convert it to UTF-8 and convert it to a usable character string.
|
|
40
|
+
# else
|
|
41
|
+
# l = c.bytes.map{|v| v.to_s(16)}.join # Conversion to UTF-8 hexadecimal number.
|
|
42
|
+
#
|
|
43
|
+
# ref << "_" + l.rjust(6,"0") # Add an underscore indicating conversion.
|
|
44
|
+
# # The remainder of 6 digits is filled with 0.
|
|
45
|
+
# end
|
|
46
|
+
# end
|
|
47
|
+
# return ref
|
|
48
|
+
|
|
29
49
|
|
|
30
|
-
|
|
31
|
-
#
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
# The remainder of 6 digits is filled with 0.
|
|
50
|
+
name = name.to_s
|
|
51
|
+
# Convert special characters.
|
|
52
|
+
name = name.each_char.map do |c|
|
|
53
|
+
if c=~ /[a-z0-9]/ then
|
|
54
|
+
c
|
|
55
|
+
elsif c == "_" then
|
|
56
|
+
"__"
|
|
57
|
+
else
|
|
58
|
+
"_" + c.ord.to_s
|
|
59
|
+
end
|
|
60
|
+
end.join
|
|
61
|
+
# First character: only letter is possible.
|
|
62
|
+
unless name[0] =~ /[a-z_]/ then
|
|
63
|
+
name = "_" + name
|
|
45
64
|
end
|
|
46
|
-
|
|
47
|
-
return ref
|
|
65
|
+
return name
|
|
48
66
|
end
|
|
49
67
|
|
|
50
68
|
#puts ref
|
|
@@ -697,7 +697,27 @@ static Value greater_value_defined_bitstring(Value src0, Value src1, Value dst)
|
|
|
697
697
|
dst->numeric = 1;
|
|
698
698
|
|
|
699
699
|
/* Perform the comparison. */
|
|
700
|
-
|
|
700
|
+
if (src0->type->flags.sign) {
|
|
701
|
+
if (src1->type->flags.sign) {
|
|
702
|
+
dst->data_int =
|
|
703
|
+
((signed long long)value2integer(src0) >
|
|
704
|
+
(signed long long)value2integer(src1));
|
|
705
|
+
} else {
|
|
706
|
+
dst->data_int =
|
|
707
|
+
((signed long long)value2integer(src0) >
|
|
708
|
+
(unsigned long long)value2integer(src1));
|
|
709
|
+
}
|
|
710
|
+
} else {
|
|
711
|
+
if (src1->type->flags.sign) {
|
|
712
|
+
dst->data_int =
|
|
713
|
+
((unsigned long long)value2integer(src0) >
|
|
714
|
+
(signed long long)value2integer(src1));
|
|
715
|
+
} else {
|
|
716
|
+
dst->data_int =
|
|
717
|
+
((unsigned long long)value2integer(src0) >
|
|
718
|
+
(unsigned long long)value2integer(src1));
|
|
719
|
+
}
|
|
720
|
+
}
|
|
701
721
|
return dst;
|
|
702
722
|
}
|
|
703
723
|
|
|
@@ -712,7 +732,27 @@ static Value lesser_value_defined_bitstring(Value src0, Value src1, Value dst) {
|
|
|
712
732
|
dst->numeric = 1;
|
|
713
733
|
|
|
714
734
|
/* Perform the comparison. */
|
|
715
|
-
|
|
735
|
+
if (src0->type->flags.sign) {
|
|
736
|
+
if (src1->type->flags.sign) {
|
|
737
|
+
dst->data_int =
|
|
738
|
+
((signed long long)value2integer(src0) <
|
|
739
|
+
(signed long long)value2integer(src1));
|
|
740
|
+
} else {
|
|
741
|
+
dst->data_int =
|
|
742
|
+
((signed long long)value2integer(src0) <
|
|
743
|
+
(unsigned long long)value2integer(src1));
|
|
744
|
+
}
|
|
745
|
+
} else {
|
|
746
|
+
if (src1->type->flags.sign) {
|
|
747
|
+
dst->data_int =
|
|
748
|
+
((unsigned long long)value2integer(src0) <
|
|
749
|
+
(signed long long)value2integer(src1));
|
|
750
|
+
} else {
|
|
751
|
+
dst->data_int =
|
|
752
|
+
((unsigned long long)value2integer(src0) <
|
|
753
|
+
(unsigned long long)value2integer(src1));
|
|
754
|
+
}
|
|
755
|
+
}
|
|
716
756
|
return dst;
|
|
717
757
|
}
|
|
718
758
|
|
|
@@ -727,7 +767,27 @@ static Value greater_equal_value_defined_bitstring(Value src0, Value src1, Value
|
|
|
727
767
|
dst->numeric = 1;
|
|
728
768
|
|
|
729
769
|
/* Perform the comparison. */
|
|
730
|
-
|
|
770
|
+
if (src0->type->flags.sign) {
|
|
771
|
+
if (src1->type->flags.sign) {
|
|
772
|
+
dst->data_int =
|
|
773
|
+
((signed long long)value2integer(src0) >=
|
|
774
|
+
(signed long long)value2integer(src1));
|
|
775
|
+
} else {
|
|
776
|
+
dst->data_int =
|
|
777
|
+
((signed long long)value2integer(src0) >=
|
|
778
|
+
(unsigned long long)value2integer(src1));
|
|
779
|
+
}
|
|
780
|
+
} else {
|
|
781
|
+
if (src1->type->flags.sign) {
|
|
782
|
+
dst->data_int =
|
|
783
|
+
((unsigned long long)value2integer(src0) >=
|
|
784
|
+
(signed long long)value2integer(src1));
|
|
785
|
+
} else {
|
|
786
|
+
dst->data_int =
|
|
787
|
+
((unsigned long long)value2integer(src0) >=
|
|
788
|
+
(unsigned long long)value2integer(src1));
|
|
789
|
+
}
|
|
790
|
+
}
|
|
731
791
|
return dst;
|
|
732
792
|
}
|
|
733
793
|
|
|
@@ -742,7 +802,27 @@ static Value lesser_equal_value_defined_bitstring(Value src0, Value src1, Value
|
|
|
742
802
|
dst->numeric = 1;
|
|
743
803
|
|
|
744
804
|
/* Perform the comparison. */
|
|
745
|
-
|
|
805
|
+
if (src0->type->flags.sign) {
|
|
806
|
+
if (src1->type->flags.sign) {
|
|
807
|
+
dst->data_int =
|
|
808
|
+
((signed long long)value2integer(src0) <=
|
|
809
|
+
(signed long long)value2integer(src1));
|
|
810
|
+
} else {
|
|
811
|
+
dst->data_int =
|
|
812
|
+
((signed long long)value2integer(src0) <=
|
|
813
|
+
(unsigned long long)value2integer(src1));
|
|
814
|
+
}
|
|
815
|
+
} else {
|
|
816
|
+
if (src1->type->flags.sign) {
|
|
817
|
+
dst->data_int =
|
|
818
|
+
((unsigned long long)value2integer(src0) <=
|
|
819
|
+
(signed long long)value2integer(src1));
|
|
820
|
+
} else {
|
|
821
|
+
dst->data_int =
|
|
822
|
+
((unsigned long long)value2integer(src0) <=
|
|
823
|
+
(unsigned long long)value2integer(src1));
|
|
824
|
+
}
|
|
825
|
+
}
|
|
746
826
|
return dst;
|
|
747
827
|
}
|
|
748
828
|
|
|
@@ -1810,7 +1890,27 @@ static Value greater_value_numeric(Value src0, Value src1, Value dst) {
|
|
|
1810
1890
|
dst->numeric = 1;
|
|
1811
1891
|
|
|
1812
1892
|
/* Perform the greater. */
|
|
1813
|
-
|
|
1893
|
+
if (src0->type->flags.sign) {
|
|
1894
|
+
if (src1->type->flags.sign) {
|
|
1895
|
+
dst->data_int =
|
|
1896
|
+
((signed long long)src0->data_int >
|
|
1897
|
+
(signed long long)src1->data_int);
|
|
1898
|
+
} else {
|
|
1899
|
+
dst->data_int =
|
|
1900
|
+
((signed long long)src0->data_int >
|
|
1901
|
+
(unsigned long long)src1->data_int);
|
|
1902
|
+
}
|
|
1903
|
+
} else {
|
|
1904
|
+
if (src1->type->flags.sign) {
|
|
1905
|
+
dst->data_int =
|
|
1906
|
+
((unsigned long long)src0->data_int >
|
|
1907
|
+
(signed long long)src1->data_int);
|
|
1908
|
+
} else {
|
|
1909
|
+
dst->data_int =
|
|
1910
|
+
((unsigned long long)src0->data_int >
|
|
1911
|
+
(unsigned long long)src1->data_int);
|
|
1912
|
+
}
|
|
1913
|
+
}
|
|
1814
1914
|
return dst;
|
|
1815
1915
|
}
|
|
1816
1916
|
|
|
@@ -1825,7 +1925,27 @@ static Value lesser_value_numeric(Value src0, Value src1, Value dst) {
|
|
|
1825
1925
|
dst->numeric = 1;
|
|
1826
1926
|
|
|
1827
1927
|
/* Perform the lesser. */
|
|
1828
|
-
|
|
1928
|
+
if (src0->type->flags.sign) {
|
|
1929
|
+
if (src1->type->flags.sign) {
|
|
1930
|
+
dst->data_int =
|
|
1931
|
+
((signed long long)src0->data_int <
|
|
1932
|
+
(signed long long)src1->data_int);
|
|
1933
|
+
} else {
|
|
1934
|
+
dst->data_int =
|
|
1935
|
+
((signed long long)src0->data_int <
|
|
1936
|
+
(unsigned long long)src1->data_int);
|
|
1937
|
+
}
|
|
1938
|
+
} else {
|
|
1939
|
+
if (src1->type->flags.sign) {
|
|
1940
|
+
dst->data_int =
|
|
1941
|
+
((unsigned long long)src0->data_int <
|
|
1942
|
+
(signed long long)src1->data_int);
|
|
1943
|
+
} else {
|
|
1944
|
+
dst->data_int =
|
|
1945
|
+
((unsigned long long)src0->data_int <
|
|
1946
|
+
(unsigned long long)src1->data_int);
|
|
1947
|
+
}
|
|
1948
|
+
}
|
|
1829
1949
|
return dst;
|
|
1830
1950
|
}
|
|
1831
1951
|
|
|
@@ -1840,7 +1960,27 @@ static Value greater_equal_value_numeric(Value src0, Value src1, Value dst) {
|
|
|
1840
1960
|
dst->numeric = 1;
|
|
1841
1961
|
|
|
1842
1962
|
/* Perform the greater or equal. */
|
|
1843
|
-
|
|
1963
|
+
if (src0->type->flags.sign) {
|
|
1964
|
+
if (src1->type->flags.sign) {
|
|
1965
|
+
dst->data_int =
|
|
1966
|
+
((signed long long)src0->data_int >=
|
|
1967
|
+
(signed long long)src1->data_int);
|
|
1968
|
+
} else {
|
|
1969
|
+
dst->data_int =
|
|
1970
|
+
((signed long long)src0->data_int >=
|
|
1971
|
+
(unsigned long long)src1->data_int);
|
|
1972
|
+
}
|
|
1973
|
+
} else {
|
|
1974
|
+
if (src1->type->flags.sign) {
|
|
1975
|
+
dst->data_int =
|
|
1976
|
+
((unsigned long long)src0->data_int >=
|
|
1977
|
+
(signed long long)src1->data_int);
|
|
1978
|
+
} else {
|
|
1979
|
+
dst->data_int =
|
|
1980
|
+
((unsigned long long)src0->data_int >=
|
|
1981
|
+
(unsigned long long)src1->data_int);
|
|
1982
|
+
}
|
|
1983
|
+
}
|
|
1844
1984
|
return dst;
|
|
1845
1985
|
}
|
|
1846
1986
|
|
|
@@ -1855,7 +1995,27 @@ static Value lesser_equal_value_numeric(Value src0, Value src1, Value dst) {
|
|
|
1855
1995
|
dst->numeric = 1;
|
|
1856
1996
|
|
|
1857
1997
|
/* Perform the lesser or equal. */
|
|
1858
|
-
|
|
1998
|
+
if (src0->type->flags.sign) {
|
|
1999
|
+
if (src1->type->flags.sign) {
|
|
2000
|
+
dst->data_int =
|
|
2001
|
+
((signed long long)src0->data_int <=
|
|
2002
|
+
(signed long long)src1->data_int);
|
|
2003
|
+
} else {
|
|
2004
|
+
dst->data_int =
|
|
2005
|
+
((signed long long)src0->data_int <=
|
|
2006
|
+
(unsigned long long)src1->data_int);
|
|
2007
|
+
}
|
|
2008
|
+
} else {
|
|
2009
|
+
if (src1->type->flags.sign) {
|
|
2010
|
+
dst->data_int =
|
|
2011
|
+
((unsigned long long)src0->data_int <=
|
|
2012
|
+
(signed long long)src1->data_int);
|
|
2013
|
+
} else {
|
|
2014
|
+
dst->data_int =
|
|
2015
|
+
((unsigned long long)src0->data_int <=
|
|
2016
|
+
(unsigned long long)src1->data_int);
|
|
2017
|
+
}
|
|
2018
|
+
}
|
|
1859
2019
|
return dst;
|
|
1860
2020
|
}
|
|
1861
2021
|
|
data/lib/HDLRuby/version.rb
CHANGED
metadata
CHANGED
|
@@ -1,14 +1,14 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: HDLRuby
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 2.6.
|
|
4
|
+
version: 2.6.10
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Lovic Gauthier
|
|
8
8
|
autorequire:
|
|
9
9
|
bindir: exe
|
|
10
10
|
cert_chain: []
|
|
11
|
-
date: 2021-
|
|
11
|
+
date: 2021-08-16 00:00:00.000000000 Z
|
|
12
12
|
dependencies:
|
|
13
13
|
- !ruby/object:Gem::Dependency
|
|
14
14
|
name: bundler
|