HDLRuby 2.2.16 → 2.3.3

data/lib/HDLRuby/hruby_low_fix_types.rb

@@ -294,6 +294,8 @@ module HDLRuby::Low
             # Is there a type to match?
             if type then
                 # Yes, update the concat to the type.
+                # Get the real type in case of typedef.
+                type = type.def while type.is_a?(TypeDef)
                 # Is it an array type?
                 if type.is_a?(TypeVector) then
                     # Yes, update the concat without subcasting.
@@ -302,14 +304,16 @@ module HDLRuby::Low
                     end)
                 else
                     # No, it should be a tuple.
-                    return Concat.new(type,self.expressions.map.with_index do
+                    return Concat.new(type,
+                                      self.each_expression.map.with_index do
                         |expr,i|
                         expr.explicit_types(type.get_type(i))
                     end)
                 end
             else
                 # No, recurse on the sub expressions.
-                return Concat.new(self.type,self.expressions.map do |expr|
+                return Concat.new(self.type,
+                                  self.each_expression.map do |expr|
                     expr.explicit_types
                 end)
             end

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -91,7 +91,7 @@ module HDLRuby::Low
 
         ## Tells if it is a reference to a systemI signal.
         def from_systemI?
-            return self.ref.from_systemI
+            return self.ref.from_systemI?
         end
     end
 
@@ -103,7 +103,7 @@ module HDLRuby::Low
 
         ## Tells if it is a reference to a systemI signal.
         def from_systemI?
-            return self.ref.from_systemI
+            return self.ref.from_systemI?
         end
     end
 
@@ -119,11 +119,13 @@ module HDLRuby::Low
             if self.ref.is_a?(RefName) then
                 # Look in the parent hierachy for the sub reference name.
                 parent = self.parent
+                # puts "self.ref.name=#{self.ref.name}"
                 while parent
+                    # puts "parent=#{parent}"
                     if parent.respond_to?(:get_by_name) then
                         found = parent.get_by_name(self.ref.name)
                         # puts "found is a :#{found.class}"
-                        return found.is_a?(SystemI)
+                        return found.is_a?(SystemI) if found
                     end
                     parent = parent.parent
                 end

data/lib/HDLRuby/hruby_low_without_concat.rb

@@ -187,11 +187,13 @@ module HDLRuby::Low
                             # Generate the assignment.
                             block.add_statement(
                                 Transmit.new(ref.clone,
-                                RefIndex.new(aux.type.base, aux.clone, idx)))
+                                # RefIndex.new(aux.type.base, aux.clone, idx)))
+                                RefIndex.new(bit, aux.clone, idx)))
                         else
                             # Multi-bits.
                             # Compute the type of the right value.
-                            rtype = TypeVector.new(:"",aux.type.base,range)
+                            # rtype = TypeVector.new(:"",aux.type.base,range)
+                            rtype = TypeVector.new(:"",bit,range)
                             # Generate the range.
                             range = Value.new(Integer,range.first) ..
                                     Value.new(Integer,range.last)
@@ -272,11 +274,13 @@ module HDLRuby::Low
                             # Generate the assignment.
                             block.add_statement(
                                 Transmit.new(ref.clone,
-                                RefIndex.new(aux.type.base, aux.clone, idx)))
+                                # RefIndex.new(aux.type.base, aux.clone, idx)))
+                                RefIndex.new(bit, aux.clone, idx)))
                         else
                             # Multi-bits.
                             # Compute the type of the right value.
-                            rtype = TypeVector.new(:"",aux.type.base,range)
+                            # rtype = TypeVector.new(:"",aux.type.base,range)
+                            rtype = TypeVector.new(:"",bit,range)
                             # Generate the range.
                             range = Value.new(Integer,range.first) ..
                                     Value.new(Integer,range.last)

data/lib/HDLRuby/hruby_types.rb

@@ -76,19 +76,21 @@ module HDLRuby
 
         # Addition.
         def +(type)
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            # New type range: largest range + 1
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max + 1
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # # New type range: largest range + 1
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max + 1
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Subtraction
@@ -96,36 +98,40 @@ module HDLRuby
 
         # Multiplication
         def *(type)
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            # New type range: largest range * 2
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max * 2
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # # New type range: largest range * 2
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max * 2
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Division
         def /(type)
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            # New type range: largest range 
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max 
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # # New type range: largest range 
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max 
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Modulo
@@ -151,26 +157,28 @@ module HDLRuby
 
         # And
         def &(type)
-            # puts "compute types with=#{self} and #{type}"
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            
-            # Logical operation on non-vector types are kept as is.
-            return resolved unless resolved.is_a?(TypeVector)
-
-            # Otherwise the range is computed.
-            # New type range: largest range 
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            # puts "bounds=#{bounds}"
-            res_lsb =  bounds.min
-            res_msb = bounds.max 
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # puts "compute types with=#{self} and #{type}"
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # 
+            # # Logical operation on non-vector types are kept as is.
+            # return resolved unless resolved.is_a?(TypeVector)
+
+            # # Otherwise the range is computed.
+            # # New type range: largest range 
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # # puts "bounds=#{bounds}"
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max 
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Or
@@ -211,19 +219,21 @@ module HDLRuby
 
         # Shift left
         def <<(type)
-            # The result type is the type of left.
-            resolved = self
-            # New type range: 2**(type width) times self range
-            bounds = [ self.range.first.to_i, self.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max +
-                (2 ** ((type.range.last-type.range.first).abs))
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # The result type is the type of left.
+            # resolved = self
+            # # New type range: 2**(type width) times self range
+            # bounds = [ self.range.first.to_i, self.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max +
+            #     (2 ** ((type.range.last-type.range.first).abs))
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         alias_method :ls, :<<

data/lib/HDLRuby/hruby_verilog.rb

@@ -1630,12 +1630,20 @@ end
 # If it is signed, it outputs signed.
 # Enhance Type with generation of verilog code.
 class Type
-    # Converts the system to Verilog code.
+    # Converts the type to Verilog code.
     def to_verilog
         return self.name == :signed ? "#{self.name.to_s} " : ""
     end
 end
 
+# Replace type by refered type.
+class TypeDef
+    # Converts the type to verilog code.
+    def to_verilog
+        return self.def.to_verilog
+    end
+end
+
 # Use it when collecting.
 class Concat
     def to_verilog    

data/lib/HDLRuby/sim/hruby_sim.h

@@ -157,6 +157,13 @@ extern Value mul_value(Value src0, Value src1, Value dst);
  *  @return dst */
 extern Value div_value(Value src0, Value src1, Value dst);
 
+/** Computes the modulo of two general values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+extern Value mod_value(Value src0, Value src1, Value dst);
+
 /** Computes the not of a value.
  *  @param src the source value of the not
  *  @param dst the destination value

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -5,6 +5,10 @@
 #include <limits.h>
 #include "hruby_sim.h"
 
+#ifndef alloca
+#define alloca(x)  __builtin_alloca(x)
+#endif
+
 
 /**
  *  The HDLRuby simulation calculation engine, to be used with C code
@@ -393,6 +397,9 @@ static Value set_undefined_bitstring(Value dst) {
 
     /* set the type and size of the destination. */
     dst->numeric = 0;
+    /* Ensures the buffer of dst has the write size (in cas it was a fromer
+     * numeric for example). */
+    resize_value(dst,width);
 
     /* Get access to the destination data. */
     char* dst_data = dst->data_str;
@@ -600,7 +607,7 @@ static Value mul_value_defined_bitstring(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the addition. */
+    /* Perform the multiplication. */
     dst->data_int = value2integer(src0) * value2integer(src1);
     return dst;
 }
@@ -616,12 +623,29 @@ static Value div_value_defined_bitstring(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the addition. */
+    /* Perform the division. */
     dst->data_int = value2integer(src0) / value2integer(src1);
     return dst;
 }
 
 
+/** Computes the modulo of two defined bitstring values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+static Value mod_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the modulo. */
+    // printf("modulo with src0=%lld src1=%lld, result=%lld\n",value2integer(src0),value2integer(src1),value2integer(src0) % value2integer(src1));
+    dst->data_int = value2integer(src0) % value2integer(src1);
+    return dst;
+}
+
+
 /** Computes the lesser comparision of two defined bitstring values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
@@ -1411,7 +1435,10 @@ fix_numeric_type(Type type, unsigned long long val) {
     /* Get the width of the type. */
     int width = type_width(type);
     /* Compute the base mask. */
-    unsigned long long mask = ((unsigned long long)(-1)) << width;
+    // unsigned long long mask = ((unsigned long long)(-1)) << width;
+    /* NOTE: (ull)-1 << 64 becomes (ull)-1 on Intel processors, this is
+     * totally not what I expected (I expected 0). */
+    unsigned long long mask = width == 64 ? 0 : ((unsigned long long)(-1)) << width;
     // printf("width=%i val=%llu mask=%llx\n",width,val,mask);
 
     /* Is the type signed? */
@@ -1512,6 +1539,23 @@ static Value div_value_numeric(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the modulo of two numeric values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+static Value mod_value_numeric(Value src0, Value src1, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src0->type;
+    dst->numeric = 1;
+
+    /* Perform the division. */
+    // printf("modulo numeric with src0=%lld src1=%lld, result=%lld\n",src0->data_int, src1->data_int,src0->data_int % src1->data_int);
+    dst->data_int = fix_numeric_type(dst->type, src0->data_int % src1->data_int);
+    return dst;
+}
+
+
 /** Computes the NOT of a numeric value.
  *  @param src the source value of the not
  *  @param dst the destination value
@@ -1686,7 +1730,7 @@ static Value concat_value_numeric_array(int num, int dir,
     unsigned int i,pos;
     /* Compute the bit width of the destination. */
     unsigned int width = 0;
-    // printf("concat_value_numeric with dir=%d\n",dir);
+    // printf("concat_value_numeric with dir=%d and width=%llu\n",dir,type_width(args[0]->type));
     for(i=0; i<num; ++i) width += type_width(args[i]->type);
 
     /* Sets state of the destination using the bit width. */
@@ -1710,6 +1754,7 @@ static Value concat_value_numeric_array(int num, int dir,
         pos += arg_width;
     }
     /* Return the destination. */
+    // printf("Result is dst=%llx\n",dst->data_int);
     return dst;
 }
 
@@ -1720,6 +1765,7 @@ static Value concat_value_numeric_array(int num, int dir,
  *  @param dst the destination value
  *  @return dst */
 static Value cast_value_numeric(Value src, Type type, Value dst) {
+    // printf("cast_value_numeric with src=%llx",src->data_int);
     /* Copy the source to the destination. */
     dst->data_int = src->data_int;
     /* Update the destination type to the cast. */
@@ -1779,6 +1825,7 @@ static int same_content_value_range_numeric(Value value0,
  *  @return dst */
 Value read_range_numeric(Value value, long long first, long long last,
         Type base, Value dst) {
+    /* printf("read_range_numeric with value=%llx and first=%llu and last=%llu\n",value->data_int,first,last); */
     /* Ensure first is the smaller. */
     if (first > last) {
         long long tmp = last;
@@ -1791,15 +1838,18 @@ Value read_range_numeric(Value value, long long first, long long last,
     unsigned long long bw = type_width(base);
     /* Scale the range according to the base type. */
     first *= bw;
+    last  *= bw;
     length *= bw;
-    // printf("first=%lld last=%lld bw=%llu length=%lld\n",first,last,bw,length);
+    /* printf("first=%lld last=%lld bw=%llu length=%lld\n",first,last,bw,length); */
 
     /* Set the type and size of the destination from the type of the source.*/
     dst->type = make_type_vector(get_type_bit(),length);
     dst->numeric = 1;
 
     /* Compute the read mask. */
-    unsigned long long mask = ((-1LL) << first) & (~((-1LL) << (last+1)));
+    // unsigned long long mask = ((-1LL) << first) & (~((-1LL) << (last+1)));
+    /* NOTE: once again, << 64 does not work like expected. */
+    unsigned long long mask = mask+bw < 64 ? (~((-1LL) << (last+bw))) : -1LL;
     /* Performs the read. */
     unsigned long long data = (value->data_int & mask) >> first;
     /* Write it to the destination. */
@@ -1995,6 +2045,33 @@ Value div_value(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the modulo of two general values.
+ *  @param src0 the first source value of the addition
+ *  @param src1 the second source value of the addition
+ *  @param dst the destination value
+ *  @return dst */
+Value mod_value(Value src0, Value src1, Value dst) {
+    /* Might allocate a new value so save the current pool state. */
+    unsigned int pos = get_value_pos();
+    /* Do a numeric computation if possible, otherwise fallback to bitstring
+     * computation. */
+    if (src0->numeric && src1->numeric) {
+        /* Both sources are numeric. */
+        return mod_value_numeric(src0,src1,dst);
+    } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        /* Both sources can be converted to numeric values. */
+        return mod_value_defined_bitstring(src0,src1,dst);
+    } else {
+        /* Cannot compute (for now), simply undefines the destination. */
+        /* First ensure dst has the right shape. */
+        copy_value(src0,dst);
+        /* Then make it undefined. */
+        set_undefined_bitstring(dst);
+    }
+    return dst;
+}
+
+
 /** Computes the NOT of a general value.
  *  @param src the source value of the not
  *  @param dst the destination value