HDLRuby 2.2.14 → 2.3.1

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -39,6 +39,7 @@ module HDLRuby::Low
         ## Find an inner object by +name+.
         #  NOTE: return nil if not found.
         def get_by_name(name)
+            # puts "getbyname for name=#{name} with self=#{self}"
             # Ensure the name is a symbol.
             name = name.to_sym
             # Look in the signals.
@@ -90,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
 
@@ -102,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
 
@@ -114,16 +115,17 @@ module HDLRuby::Low
 
         ## Tells if it is a reference to a systemI signal.
         def from_systemI?
-            # puts "from_systemI? for #{self.name}"
             # Look for the owner from the name hierarchy.
             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
@@ -151,6 +153,7 @@ module HDLRuby::Low
                 parent = self.parent
                 # puts "parent=#{parent}"
                 while parent
+                    # puts "parent=#{parent}"
                     if parent.respond_to?(:get_by_name) then
                         found = parent.get_by_name(self.name)
                         return found if found

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
@@ -205,6 +212,20 @@ Value shift_right_value(Value src0, Value src1, Value dst);
  *  @return dst */
 extern Value equal_value(Value src0, Value src1, Value dst);
 
+/** Computes the lesser comparision of two 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 lesser_value(Value src0, Value src1, Value dst);
+
+/** Computes the greater comparision of two 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 greater_value(Value src0, Value src1, Value dst);
+
 /** Selects a value depending on a condition.
  *  @param cond   the condition to use for selecting a value
  *  @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
@@ -284,6 +288,11 @@ Value make_set_value(Type type, int numeric, void* data) {
 //     }
 // }
 
+/* Defined after.*/
+static unsigned long long
+fix_numeric_type(Type type, unsigned long long val);
+
+
 /** Copies a value to another, the type of the destination is preserved.
  *  @param src the source value
  *  @param dst the destination value
@@ -296,7 +305,7 @@ Value copy_value(Value src, Value dst) {
     /* Copy the data. */
     if (src->numeric) {
         /* Numeric copy. */
-        dst->data_int = src->data_int;
+        dst->data_int = fix_numeric_type(dst->type,src->data_int);
     } else {
         /* Resize the destination if required. */
         resize_value(dst,type_width(dst->type));
@@ -388,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;
@@ -595,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;
 }
@@ -611,12 +623,61 @@ 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
+ *  @param dst the destination value
+ *  @return dst */
+static Value lesser_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 comparison. */
+    dst->data_int = (value2integer(src0) < value2integer(src1));
+    return dst;
+}
+
+
+/** Computes the greater comparision 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 greater_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 comparison. */
+    dst->data_int = (value2integer(src0) > value2integer(src1));
+    return dst;
+}
+
+
 /** Computes the NOT of a bitstring value.
  *  @param src the source value of the not
  *  @param dst the destination value
@@ -1364,6 +1425,40 @@ Value write_range_bitstring_no_z(Value src, long long first, long long last,
 
 /* ############# Start of the computation of numeric values. ############## */
 
+/** Fix the content of a numeric value according to its type so that
+ *  it can be used for C numeric computation. 
+ *  @param type the type to fix the value to
+ *  @param val the value to fix 
+ *  @return the rsulting value */
+static unsigned long long
+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;
+    /* 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? */
+    if (type->flags.sign) {
+        /* Yes, perform sign extension. */
+        int is_neg = (val >> (width-1)) & 1;
+        // printf("is_neg=%i\n",is_neg);
+        if (is_neg) {
+            /* Negative sign extension. */
+            return val | mask;
+        } else {
+            /* Positive sign extension. */
+            return val & ~mask;
+        }
+    } else {
+        /* No, perform a zero extension. */
+        return val & ~mask;
+    }
+}
+
 
 /** Computes the neg of a numeric value.
  *  @param src the source value of the not
@@ -1375,7 +1470,7 @@ static Value neg_value_numeric(Value src, Value dst) {
     dst->numeric = 1;
 
     /* Perform the negation. */
-    dst->data_int = -src->data_int;
+    dst->data_int = fix_numeric_type(dst->type,-src->data_int);
     return dst;
 }
 
@@ -1391,7 +1486,7 @@ static Value add_value_numeric(Value src0, Value src1, Value dst) {
     dst->numeric = 1;
 
     /* Perform the addition. */
-    dst->data_int = src0->data_int + src1->data_int;
+    dst->data_int = fix_numeric_type(dst->type,src0->data_int + src1->data_int);
     return dst;
 }
 
@@ -1407,7 +1502,7 @@ static Value sub_value_numeric(Value src0, Value src1, Value dst) {
     dst->numeric = 1;
 
     /* Perform the subtraction. */
-    dst->data_int = src0->data_int - src1->data_int;
+    dst->data_int = fix_numeric_type(dst->type,src0->data_int - src1->data_int);
     return dst;
 }
 
@@ -1422,8 +1517,8 @@ static Value mul_value_numeric(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the addition. */
-    dst->data_int = src0->data_int * src1->data_int;
+    /* Perform the multiplication. */
+    dst->data_int = fix_numeric_type(dst->type, src0->data_int * src1->data_int);
     return dst;
 }
 
@@ -1438,8 +1533,25 @@ static Value div_value_numeric(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
-    /* Perform the addition. */
-    dst->data_int = src0->data_int / src1->data_int;
+    /* Perform the division. */
+    dst->data_int = fix_numeric_type(dst->type, src0->data_int / src1->data_int);
+    return 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;
 }
 
@@ -1454,7 +1566,7 @@ static Value not_value_numeric(Value src, Value dst) {
     dst->numeric = 1;
 
     /* Perform the not. */
-    dst->data_int = !src->data_int;
+    dst->data_int = fix_numeric_type(dst->type,!src->data_int);
     return dst;
 }
 
@@ -1518,7 +1630,7 @@ static Value shift_left_value_numeric(Value src0, Value src1, Value dst) {
     dst->numeric = 1;
 
     /* Perform the left shift. */
-    dst->data_int = src0->data_int << src1->data_int;
+    dst->data_int = fix_numeric_type(dst->type,src0->data_int << src1->data_int);
     return dst;
 }
 
@@ -1534,7 +1646,7 @@ static Value shift_right_value_numeric(Value src0, Value src1, Value dst) {
     dst->numeric = 1;
 
     /* Perform the right shift. */
-    dst->data_int = src0->data_int >> src1->data_int;
+    dst->data_int = fix_numeric_type(dst->type,src0->data_int >> src1->data_int);
     return dst;
 }
 
@@ -1555,6 +1667,37 @@ static Value equal_value_numeric(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the lesser comparision 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 the destination value */
+static Value lesser_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 lesser. */
+    dst->data_int = (src0->data_int < src1->data_int);
+    return dst;
+}
+
+/** Computes the greater comparision 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 the destination value */
+static Value greater_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 lesser. */
+    dst->data_int = (src0->data_int > src1->data_int);
+    return dst;
+}
+
+
 /** Selects a value depending on a numeric condition.
  *  @param cond   the condition to use for selecting a value
  *  @param dst    the destination value (used only if new value is created).
@@ -1587,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. */
@@ -1611,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;
 }
 
@@ -1621,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. */
@@ -1680,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;
@@ -1692,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. */
@@ -1719,6 +1868,7 @@ Value read_range_numeric(Value value, long long first, long long last,
  *  @return dst */
 Value write_range_numeric(Value src, long long first, long long last,
         Value dst) {
+    // printf("write_range_numeric\n");
     /* Ensure first is the smaller. */
     if (first > last) {
         long long tmp = last;
@@ -1730,6 +1880,7 @@ Value write_range_numeric(Value src, long long first, long long last,
     unsigned long long dst_width = type_width(dst->type);
     /* scale the range according to the base type of the destination. */
     unsigned long long bw = dst->type->base;
+    // printf("src_width=%llu dst_wdith=%llu bw=%llu\n",src_width,dst_width,bw);
     first *= bw;
     last *= bw;
     /* If first is too large, end here. */
@@ -1737,11 +1888,13 @@ Value write_range_numeric(Value src, long long first, long long last,
     /* Adjust the last to fit the source and destination range. */
     if (last >= dst_width) last = dst_width-1;
     if (last-first >= src_width) last = src_width + first - 1;
+    // printf("first=%lld last=%lld\n",first,last);
     /* Copy from the source. */
-    unsigned long long src_data = src->data_int & ~((-1LL) << (last-first));
+    unsigned long long src_data = src->data_int & ~((-1LL) << (last-first+1));
     /* Cleans the destination where to place the data. */
-    unsigned long long mask = ((-1LL) << first) & ~((-1LL) << last);
+    unsigned long long mask = ~(((-1LL) << first) & ~((-1LL) << (last+1)));
     unsigned long long dst_data = dst->data_int & mask;
+    // printf("src_data=%llx  mask=%llx dst_data=%llx\n",src_data,mask,dst_data);
     /* Write the data. */
     dst_data |= src_data << first;
     dst->data_int = dst_data;
@@ -1892,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
@@ -2111,6 +2291,60 @@ Value equal_value(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the lesser comparision 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 lesser_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 lesser_value_numeric(src0,src1,dst);
+    } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        /* Both sources can be converted to numeric values. */
+        return lesser_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 greater comparision 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 greater_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 greater_value_numeric(src0,src1,dst);
+    } else if (is_defined_value(src0) && is_defined_value(src1)) {
+        /* Both sources can be converted to numeric values. */
+        return greater_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;
+}
+
+
 /** Selects a value depending on a general condition.
  *  @param cond   the condition to use for selecting a value
  *  @param dst    the destination value (used only if new value is created).
@@ -2460,6 +2694,7 @@ Value read_range(Value value, long long first, long long last, Type base,
  *  @param dst the destination value
  *  @return dst */
 Value write_range(Value src, long long first, long long last, Value dst) {
+    // printf("write_range\n");
     /* Is the value numeric? */
     if ((src->numeric) && (dst->numeric)) {
         /* Yes, do a numeric range read. */
@@ -2485,6 +2720,7 @@ Value write_range(Value src, long long first, long long last, Value dst) {
  *  @param dst the destination value
  *  @return dst */
 Value write_range_no_z(Value src, long long first, long long last, Value dst) {
+    // printf("write_range_no_z\n");
     /* Is the value numeric? */
     if ((src->numeric) && (dst->numeric)) {
         /* Yes, do a numeric range read. */