HDLRuby 2.3.8 → 2.4.10

data/lib/HDLRuby/hdrcc.rb

@@ -269,6 +269,9 @@ $optparse = OptionParser.new do |opts|
         $options[:multiple] = v
         $options[:sim] = v
     end
+    opts.on("--vcd", "The simulator will generate a vcd file") do |v|
+        $options[:vcd] = v
+    end
     opts.on("-v", "--verilog","Output in Verlog HDL format") do |v|
         $options[:verilog] = v
         $options[:multiple] = v
@@ -515,9 +518,15 @@ elsif $options[:clang] then
         # Generate the code for it.
         $main = File.open($name,"w")
 
+        # Select the vizualizer depending on the options.
+        init_visualizer = $options[:vcd] ? "init_vcd_visualizer" :
+                                           "init_default_visualizer"
+
         # Generate the code of the main function.
         # HDLRuby start code
-        $main << HDLRuby::Low::Low2C.main($top_system,
+        $main << HDLRuby::Low::Low2C.main("hruby_simulator",
+                                         init_visualizer,
+                                         $top_system,
                                          $top_system.each_systemT_deep.to_a.reverse,$hnames)
         $main.close
 

data/lib/HDLRuby/hruby_bstr.rb

@@ -32,13 +32,17 @@ module HDLRuby
         #   and negative when "1".
         # * when not present it is assumed to be within str.
         def initialize(str,sign = nil)
+            # puts "str=#{str}"
             # Maybe str is an numeric.
             if str.is_a?(Numeric) then
                 # Yes, convert it to a binary string.
-                str = str.to_s(2)
+                num = str
+                str = num.to_s(2)
                 # And fix the sign.
                 if str[0] == "-" then
-                    str = str[1..-1]
+                    # str = str[1..-1]
+                    str = (2**str.size+num).to_s(2)
+                    puts "str=#{str}"
                     sign = "-"
                 else
                     sign = "+"
@@ -71,6 +75,7 @@ module HDLRuby
                 end.reverse.join
             end
             @str += str.to_s.downcase
+            # puts "@str=#{@str}"
             unless @str.match(/^[0-1zx]+$/) then
                 raise "Invalid value for creating a bit string: #{str}"
             end

data/lib/HDLRuby/hruby_high.rb

@@ -2791,6 +2791,14 @@ module HDLRuby::High
             return RefObject.new(@base,@object)
         end
 
+        # Comparison for hash: structural comparison.
+        def eql?(obj)
+            return false unless obj.is_a?(RefObject)
+            return false unless @base.eql?(obj.base)
+            return false unless @object.eql?(obj.object)
+            return true
+        end
+
         # Converts the name reference to a HDLRuby::Low::RefName.
         def to_low
             # return HDLRuby::Low::RefName.new(@base.to_ref.to_low,@object.name)

data/lib/HDLRuby/hruby_low.rb

@@ -1978,14 +1978,6 @@ module HDLRuby::Low
 
         include Hparent
 
-        # # Creates a new behavior.
-        # def initialize
-        #     # Initialize the sensitivity list.
-        #     @events = []
-        #     # Initialize the block list.
-        #     @blocks = []
-        # end
-
         # The block executed by the behavior.
         attr_reader :block
 
@@ -2074,6 +2066,11 @@ module HDLRuby::Low
             return !@events.empty?
         end
 
+        # Tells if it is activated on one of +events+.
+        def on_event?(*events)
+            @events.any? { |ev0| events.any? { |ev1| ev0.eql?(ev1) } }
+        end
+
         # Tells if there is a positive or negative edge event.
         def on_edge?
             @events.each do |event|
@@ -2619,6 +2616,15 @@ module HDLRuby::Low
             end
         end
 
+        # Gets the behavior the statement is in.
+        def behavior
+            if self.parent.is_a?(Behavior) then
+                return self.parent
+            else
+                return self.parent.behavior
+            end
+        end
+
         # Gets the top block, i.e. the first block of the current behavior.
         def top_block
             return self.parent.is_a?(Behavior) ? self : self.parent.top_block
@@ -4368,7 +4374,7 @@ module HDLRuby::Low
             # Recurse on the select.
             return true if @select.use_name?(*names)
             # Recurse on the choices.
-            return @choices.include? { |choice| choice.use_name?(*names) }
+            return @choices.any? { |choice| choice.use_name?(*names) }
         end
 
         # Clones the select (deeply)
@@ -4453,7 +4459,7 @@ module HDLRuby::Low
         # Tell if the expression includes a signal whose name is one of +names+.
         def use_name?(*names)
             # Recurse on the expressions.
-            return @expressions.include? { |expr| expr.use_name?(*names) }
+            return @expressions.any? { |expr| expr.use_name?(*names) }
         end
 
         # Clones the concatenated expression (deeply)
@@ -4601,7 +4607,7 @@ module HDLRuby::Low
         # Tell if the expression includes a signal whose name is one of +names+.
         def use_name?(*names)
             # Recurse on the references.
-            return @refs.include? { |expr| expr.use_name?(*names) }
+            return @refs.any? { |expr| expr.use_name?(*names) }
         end
 
         # Clones the concatenated references (deeply)

data/lib/HDLRuby/hruby_low2c.rb

@@ -106,13 +106,15 @@ module HDLRuby::Low
 
         ## Generates the main for making the objects of +objs+ and
         #  for starting the simulation and including the files from +hnames+
-        def self.main(top,objs,hnames)
+        def self.main(name,init_visualizer,top,objs,hnames)
             res = Low2C.includes(*hnames)
             res << "int main(int argc, char* argv[]) {\n"
             # Build the objects.
             objs.each { |obj| res << "   #{Low2C.make_name(obj)}();\n" }
+            # Sets the top systemT.
+            res << "   top_system = #{Low2C.obj_name(top)};\n"
             # Starts the simulation.
-            res << "   hruby_sim_core(-1);\n"
+            res<< "   hruby_sim_core(\"#{name}\",#{init_visualizer},-1);\n"
             # Close the main.
             res << "}\n"
             return res
@@ -1329,6 +1331,10 @@ module HDLRuby::Low
                 res << "block->owner = NULL;\n"
             end
 
+            # The name
+            res << " " * (level+1)*3
+            res << "block->name = \"#{self.name}\";\n"
+
             # Add the inner signals declaration.
             res << " " * (level+1)*3
             res << "block->num_inners = #{self.each_inner.to_a.size};\n"
@@ -1439,8 +1445,18 @@ module HDLRuby::Low
                 str = self.content.is_a?(BitString) ?
                     self.content.to_s : self.content.to_s(2).rjust(32,"0")
             else
-                sign = self.content>=0 ? "0" : "1"
-                str = self.content.abs.to_s(2).rjust(width,sign).upcase
+                # sign = self.content>=0 ? "0" : "1"
+                # str = self.content.abs.to_s(2).rjust(width,sign).upcase
+                if self.content >= 0 then
+                    str = self.content.to_s(2).rjust(width,"0").upcase
+                else
+                    # Compute the extension to the next multiple
+                    # of int_width
+                    ext_width = (((width-1) / Low2C.int_width)+1)*Low2C.int_width
+                    # Convert the string.
+                    str = (2**ext_width+self.content).to_s(2).upcase
+                end
+                # puts "content=#{self.content} str=#{str}"
             end
             # Is it a fully defined number?
             if str =~ /^[01]+$/ then
@@ -1453,13 +1469,14 @@ module HDLRuby::Low
                 res << " };\n"
                 # Create the value.
                 res << " " * (level+1)*3
-                # puts "str=#{str} type width=#{self.type.width}"
+                # puts "str=#{str} type width=#{self.type.width} signed? #{type.signed?}"
                 res << "return make_set_value(#{self.type.to_c(level+1)},1," +
                        "data);\n" 
             else
                 # No, generate a bit string value.
                 res << " " * (level+1)*3
-                res << "static unsigned char data[] = \"#{str}\";\n"
+                # res << "static unsigned char data[] = \"#{str}\";\n"
+                res << "static unsigned char data[] = \"#{str.reverse}\";\n"
                 # Create the value.
                 res << " " * (level+1)*3
                 res << "return make_set_value(#{self.type.to_c(level+1)},0," +
@@ -1612,7 +1629,9 @@ module HDLRuby::Low
         #         return "equal_value(#{self.left.to_c(level)}," +
         #                "#{self.right.to_c(level)})"
         #     when :!= then
-        #         return "not_equal_value(#{self.left.to_c(level)}," +
+        #         # return "not_equal_value(#{self.left.to_c(level)}," +
+        #         #        "#{self.right.to_c(level)})"
+        #         return "xor_value(#{self.left.to_c(level)}," +
         #                "#{self.right.to_c(level)})"
         #     when :> then
         #         return "greater_value(#{self.left.to_c(level)}," +
@@ -1681,9 +1700,12 @@ module HDLRuby::Low
             when :rr then
                 res += "dst = rotate_right_value(src0,src1,dst);\n"
             when :== then
-                res += "dst = equal_value(src0,src1,dst);\n"
+                res += "dst = equal_value(src0,src1,dst);\n" +
+                       "dst = reduce_or_value(dst,dst);"
             when :!= then
-                res += "dst = not_equal_value(src0,src1,dst);\n"
+                # res += "dst = not_equal_value(src0,src1,dst);\n"
+                res += "dst = xor_value(src0,src1,dst);\n" +
+                       "dst = reduce_or_value(dst,dst);"
             when :> then
                 res += "dst = greater_value(src0,src1,dst);\n"
             when :< then

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -145,6 +145,7 @@ module HDLRuby::Low
             # puts "Resolve with #{self} and name=#{self.name}"
             # First resolve the sub reference if possible.
             if self.ref.is_a?(RefName) then
+                # puts "ref name=#{self.ref.name}"
                 obj = self.ref.resolve
                 # Look into the object for the name.
                 return obj.get_by_name(self.name)

data/lib/HDLRuby/hruby_low_without_connection.rb

@@ -31,6 +31,7 @@ module HDLRuby::Low
                     outputs_blk = Block.new(:par)
                     timed_blk = TimeBlock.new(:seq)
                     scope.each_connection do |connection|
+                        # puts "For connection: #{connection}"
                         # Check the left and right of the connection
                         # for input or output port.
                         left = connection.left

data/lib/HDLRuby/sim/hruby_sim.h

@@ -50,8 +50,9 @@ typedef enum {
 
 /* The interface to the type engine. */
 typedef struct FlagsS_ {
-    unsigned int all;
-    unsigned int sign : 1; /* Tells if the type is signed or not. */
+    // unsigned int all;
+    // unsigned int sign : 1; /* Tells if the type is signed or not. */
+    unsigned int sign; /* Tells if the type is signed or not. */
 } FlagsS;
 
 /** The type structure. */
@@ -170,6 +171,12 @@ extern Value mod_value(Value src0, Value src1, Value dst);
  *  @return dst */
 extern Value not_value(Value src, Value dst);
 
+/** Compute the or of the bits a a value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+extern Value reduce_or_value(Value src, Value dst);
+
 /** Computes the AND of two values.
  *  @param src0 the first source value of the and
  *  @param src1 the second source value of the and
@@ -185,43 +192,43 @@ extern Value and_value(Value src0, Value src1, Value dst);
 extern Value or_value(Value src0, Value src1, Value dst);
 
 /** Computes the XOR of two values.
- *  @param src0 the first source value of the or
- *  @param src1 the second source value of the or
+ *  @param src0 the first source value of the xor
+ *  @param src1 the second source value of the xor
  *  @param dst the destination value
  *  @return dst */
 extern Value xor_value(Value src0, Value src1, Value dst);
 
 /** Computes the left shift of two general values.
- *  @param src0 the first source value of the addition
- *  @param src1 the second source value of the addition
+ *  @param src0 the first source value of the shift
+ *  @param src1 the second source value of the shift
  *  @param dst the destination
  *  @return dst */
 Value shift_left_value(Value src0, Value src1, Value dst);
 
 /** Computes the right shift of two general values.
- *  @param src0 the first source value of the addition
- *  @param src1 the second source value of the addition
+ *  @param src0 the first source value of the shift
+ *  @param src1 the second source value of the shift
  *  @param dst the destination
  *  @return dst */
 Value shift_right_value(Value src0, Value src1, Value dst);
 
 /** Computes the equal (NXOR) of two values.
- *  @param src0 the first source value of the addition
- *  @param src1 the second source value of the addition
+ *  @param src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
  *  @param dst the destination value
  *  @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 src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
  *  @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 src0 the first source value of the comparison
+ *  @param src1 the second source value of the comparison
  *  @param dst the destination value
  *  @return dst */
 extern Value greater_value(Value src0, Value src1, Value dst);
@@ -468,6 +475,7 @@ typedef struct BlockS_ {
     Kind kind;          /* The kind of object. */
     Object owner;       /* The owner if any. */
 
+    char* name;         /* The name of the block. */
     int num_inners;     /* The number of inners. */
     SignalI* inners;    /* The inners of the scope. */
     void (*function)(); /* The function to execute for the block. */
@@ -490,6 +498,9 @@ typedef struct EventS_ {
 /* The time units. */
 typedef enum { S, MS, US, NS, PS, FS } Unit;
 
+/** The top system. */
+extern SystemT top_system;
+
 /** Adds a timed behavior for processing. 
  *  @param behavior the timed behavior to register */
 extern void register_timed_behavior(Behavior behavior);
@@ -555,39 +566,71 @@ extern unsigned long long make_delay(int value, Unit unit);
 
 
 
+/* Iterate over all the signals.
+ * @param func function to applie on each signal. */
+extern void each_all_signal(void (*func)(SignalI));
 
 /* Interface to the visualization engine. */
 
-/** Prints the time.
- *  @param time the time to show. */
-extern void print_time(unsigned long long time);
-
-/** Prints the time and goes to the next line.
- *  @param time the time to show. */
-extern void println_time(unsigned long long time);
-
-/** Prints the name of an object.
- *  @param object the object to print the name. */
-extern void print_name(Object object);
-
-/** Prints a value.
- *  @param value the value to print */
-extern void print_value(Value value);
-
-/** Prints a signal.
- *  @param signal the signal to show */
-extern void print_signal(SignalI signal);
-
-/** Prints a signal and goes to the next line.
- *  @param signal the signal to show */
-extern void println_signal(SignalI signal);
-
+typedef struct {
+    void (*print_time)(unsigned long long);
+    void (*print_name)(Object);
+    void (*print_value)(Value);
+    void (*print_signal)(SignalI);
+} PrinterS;
+
+extern PrinterS printer;
+
+/** Initializes the visualization printer engine.
+ *  @param print_time the time printer
+ *  @param print_name the name printer
+ *  @param print_value the value printer
+ *  @param print_signal the signal state printer. */
+extern void init_visualizer(void (*print_time)(unsigned long long), 
+                            void (*print_name)(Object),
+                            void (*print_value)(Value),
+                            void (*print_signal)(SignalI));
+
+// /** Prints the time.
+//  *  @param time the time to show. */
+// extern void print_time(unsigned long long time);
+// 
+// // /** Prints the time and goes to the next line.
+// //  *  @param time the time to show. */
+// // extern void println_time(unsigned long long time);
+// 
+// /** Prints the name of an object.
+//  *  @param object the object to print the name. */
+// extern void print_name(Object object);
+// 
+// /** Prints a value.
+//  *  @param value the value to print */
+// extern void print_value(Value value);
+// 
+// /** Prints a signal.
+//  *  @param signal the signal to show */
+// extern void print_signal(SignalI signal);
+// 
+// // /** Prints a signal and goes to the next line.
+// //  *  @param signal the signal to show */
+// // extern void println_signal(SignalI signal);
+
+/** Sets up the default vizualization engine.
+ *  @param name the name of the vizualization. */
+extern void init_default_visualizer(char* name);
+
+/** Sets up the vcd vizualization engine.
+ *  @param name the name of the vizualization. */
+extern void init_vcd_visualizer(char* name);
 
 /* The interface to the simulator core. */
 
 /** The simulation core function.
+ *  @param name the name of the simulation.
+ *  @param init_vizualizer the vizualizer engine initializer.
  *  @param limit the time limit in fs. */
-extern void hruby_sim_core(unsigned long long limit);
+extern void hruby_sim_core(char* name, void (*init_vizualizer)(char*),
+                           unsigned long long limit);
 
 
 

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -70,7 +70,8 @@ static List hash_type[HASH_TYPE_SIZE] = {};
  *  @return the resulting type. */
 static int hash_value(unsigned long long base, unsigned long long number,
                       FlagsS flags) {
-    return ((base+flags.all)^(number)) & 1023;
+    // return ((base+flags.all)^(number)) & 1023;
+    return ((base+flags.sign)^(number)) & 1023;
 }
 
 /** Adds a type to the hash of types.
@@ -109,7 +110,8 @@ static Type get_hash_type(Type base, unsigned long long number) {
         while(elem) {
             Type type = elem->data;
             if ((type->base == bw) && (type->number == number) &&
-                (type->flags.all == flags.all)) {
+                // (type->flags.all == flags.all)) {
+                (type->flags.sign == flags.sign)) {
                 /* The type is found. */
                 return type;
             }
@@ -243,8 +245,10 @@ void resize_value(Value value, int size) {
 void set_value(Value value, int numeric, void* data) {
     value->numeric = numeric;
     if (numeric) {
+    // printf("set_value with data=%llx\n",*(unsigned long long*)data);
         value->data_int = *((unsigned long long*)data);
     } else  {
+        // printf("data=%s\n",(char*)data);
         memcpy(value->data_str,data,type_width(value->type)*sizeof(char));
     }
 }
@@ -254,6 +258,7 @@ void set_value(Value value, int numeric, void* data) {
  *  @param numeric tell if the value is in numeric form or in bitstring form
  *  @param data the source data */
 Value make_set_value(Type type, int numeric, void* data) {
+    // printf("make_set_value with type->flags.sign=%x\n",type->flags.sign);
     Value value = make_value(type,numeric);
     set_value(value,numeric,data);
     return value;
@@ -307,6 +312,7 @@ Value copy_value(Value src, Value dst) {
         /* Numeric copy. */
         dst->data_int = fix_numeric_type(dst->type,src->data_int);
     } else {
+        // printf("copy_value with bit string: %s\n",src->data_str);
         /* Resize the destination if required. */
         resize_value(dst,type_width(dst->type));
         /* Bitstring copy up to the end of dst or src. */
@@ -603,12 +609,14 @@ static Value sub_value_bitstring(Value src0, Value src1, Value dst) {
  *  @param dst the destination value
  *  @return dst */
 static Value mul_value_defined_bitstring(Value src0, Value src1, Value dst) {
+    // printf("mul_value_defined_bitstring with src0=%llx src1=%llx\n",value2integer(src0),value2integer(src1));
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
 
     /* Perform the multiplication. */
     dst->data_int = value2integer(src0) * value2integer(src1);
+    // printf("dst->data_int=%llx\n",dst->data_int);
     return dst;
 }
 
@@ -714,6 +722,45 @@ static Value not_value_bitstring(Value src, Value dst) {
     return dst;
 }
 
+/** Compute the or of the bits a bitstring value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+Value reduce_or_value_bitstring(Value src, Value dst) {
+    /* Compute the width of the result in bits. */
+    unsigned long long width = type_width(src->type);
+
+    /* Update the destination capacity if required. */
+    resize_value(dst,width);
+    /* Set the type and size of the destination from the type of the source.*/
+    dst->type = src->type;
+    dst->numeric = 0;
+
+    /* Get access to the source and destination data. */
+    char* src_data = src->data_str;
+    char* dst_data = dst->data_str;
+
+    /* Performs the reduce or. */
+    unsigned long long count;
+    char res;
+    for(count = 0; count < width; ++count) {
+        /* Performs the reduce or. */
+        char d = src_data[count] - '0'; /* Get and convert to bit. */
+        if ((d == (d&1)) && (res != 'x'-'0')) { /* d is defined. */
+            res |= d;
+        } else {
+            /* res is undefined. */
+            res = 'x' - '0';
+        }
+        /* Apart for the first bit, there are only 0, still we are in
+         * the loop, set it. */
+        dst_data[count] = '0';
+    }
+    dst_data[0] = res + '0';
+    /* Return the destination. */
+    return dst;
+}
+
 
 /** Computes the and of two bitstring values.
  *  @param src0 the first source value of the and
@@ -1133,7 +1180,7 @@ static Value equal_value_bitstring(Value src0, Value src1, Value dst) {
 static Value select_value_bitstring(Value cond, Value dst, unsigned int num,
         va_list args) 
 {
-    printf("select_value_bitstring with cond=%s\n",cond->data_str);
+    // printf("select_value_bitstring with cond=%s\n",cond->data_str);
     /* Get the first alternative for sizing the result. */
     Value src = va_arg(args,Value);
     /* Compute the width of the result in bits. */
@@ -1517,6 +1564,7 @@ static Value sub_value_numeric(Value src0, Value src1, Value dst) {
  *  @param dst the destination value
  *  @return dst */
 static Value mul_value_numeric(Value src0, Value src1, Value dst) {
+    // printf("mul_value_numeric with src0->data_int=%llx src1->data_int=%llx\n",src0->data_int, src1->data_int);
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
@@ -1575,6 +1623,21 @@ static Value not_value_numeric(Value src, Value dst) {
 }
 
 
+/** Compute the or of the bits a numeric value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+Value reduce_or_value_numeric(Value src, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src->type;
+    dst->numeric = 1;
+
+    /* Perform the reduce or. */
+    dst->data_int = fix_numeric_type(dst->type, src->data_int != 0);
+    return dst;
+}
+
+
 /** Computes the AND of two numeric values.
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
@@ -1769,7 +1832,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);
+    // printf("cast_value_numeric with src=%llx\n",src->data_int);
     /* Copy the source to the destination. */
     dst->data_int = src->data_int;
     /* Update the destination type to the cast. */
@@ -2093,6 +2156,21 @@ Value not_value(Value src, Value dst) {
 }
 
 
+/** Compute the or of the bits a value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+Value reduce_or_value(Value src, Value dst) {
+    if (src->numeric) {
+        /* The source is numeric. */
+        return reduce_or_value_numeric(src,dst);
+    } else {
+        /* The source cannot be numeric, compute bitsitrings. */
+        return reduce_or_value_bitstring(src,dst);
+    }
+}
+
+
 /** Computes the AND of two general values. 
  *  @param src0 the first source value of the addition
  *  @param src1 the second source value of the addition
@@ -2596,6 +2674,7 @@ unsigned long long value2integer(Value value) {
     char bit;
     /* Access the bitstring data. */
     char* data_str = value->data_str;
+    // printf("value2integer with data_str=%s\n",data_str);
     /* Copy the bits. */
     for (i=0; i<width && i<LONG_LONG_BIT; ++i) {
         /* Get the bit. */
@@ -2607,12 +2686,17 @@ unsigned long long value2integer(Value value) {
         /* Write the bit. */
         res = (res << 1) | bit;
     }
+    // printf("first res=%llx\n",res);
+    unsigned long long bit0 = (data_str[width-1]-'0') << i;
     /* Perform the sign extension if required. */
     if (i>=width && value->type->flags.sign) {
         for(; i<LONG_LONG_BIT; ++i) {
-            res = (res << 1) | bit;
+            // res = (res << 1) | bit;
+            res |= bit0;
+            bit0 <<= 1;
         }
     }
+    // printf("then res=%llx\n",res);
     return res;
 }