HDLRuby 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f491222adce0600f9d4ba58e748d4a72fd913adb50952fff71e5e67937f6b54
-  data.tar.gz: ffdb34990f8dabcb0e38c3a7189e7f99c07c351cd86de6411f7eaa64314147f9
+  metadata.gz: bc9fecc1e612564d0a491efb3b33d88897b35dc6d40fc8a67da4c55212fececd
+  data.tar.gz: 8fc2490cf24c3b1343ea8bdfe0ae6dcfa56ce6e055661a19b7bed2b0929ec432
 SHA512:
-  metadata.gz: 854a95c8b73d27c9673997cb138ebdceba87546bbd6d585d201110a9b8f0ae0be67f2c197a13a6e864c235fefb4a59ca99a4dc6f7311758becea639aadd3c0e6
-  data.tar.gz: 60d260809614010f31e484c85e907b575518670770e4069da9216ba00e3b0a8502ef173dd260cf773e47d5ebd20d343ef00b815a840efbf7346c86b7b5b8c0cd
+  metadata.gz: 33448731ae5e188eefdca0cb18205abb31eedf26b0a84d9a48c4f873bbf2a978831f47f172453a726555c0845145938082dbb9e32e75da64fbe71279a5cac665
+  data.tar.gz: 7e75b9e351501e1ae8d2ca81e5e9f442ac3d29f400b49c9813bf6cddff409e24fd57ea72773287163f7d11b1226736c35de2f44fa14f5028f8480cd94661661f

data/HDLRuby.gemspec

@@ -33,5 +33,6 @@ Gem::Specification.new do |spec|
   # spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "bundler", ">= 2.0.1"
   spec.add_development_dependency "rake", ">= 10.0"
+  spec.add_development_dependency "rake-compiler", ">= 1.0"
   # spec.add_development_dependency "minitest", "~> 5.0"
 end

data/README.md

@@ -11,6 +11,16 @@ If you are new to HDLRuby, it is recommended that you consult first the followin
 
 __What's new__
 
+For HDLRuby version 3.2.0:
+
+ * Added component for declaring BRAM and BRAM-based stacks.
+   The goal is to efficiently allocate memories inside FPGAs.
+
+ * Inner code overhaul for preparing version 4.0.0
+
+ * Multiple bug fixes
+
+
 For HDLRuby version 3.1.0:
 
  * [Functions for sequencers](#sequencer-specific-function-std-sequencer_func-rb) supporting recursion;

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -1443,6 +1443,8 @@ void Init_hruby_sim() {
 
     /* Create the class that wraps C pointers. */
     RCSimPointer = rb_define_class("RCSimPointer",rb_cObject);
+    /* No allocator for C pointers. */
+    rb_undef_alloc_func(RCSimPointer);
 
     /* Add the interface methods. */
     /* Getting the C simulation type objects. */

data/ext/hruby_sim/hruby_sim_calc.c

@@ -50,6 +50,12 @@
 //     ({ __typeof__ (v) _v = (v); \
 //        _v->type->flags.sign ? (_v->data[_v->size-1] >> (INT_BIT-1)) ?  UINT_MAX : 0 : 0; })
 
+/** Fix the sign of a numeric value. */
+#define fix_numeric_sign(v) \
+    ({if ((v)->type->flags.sign && (type_width((v)->type) < 64) && ((v)->data_int & (1ULL << (type_width((v)->type)-1)))) {\
+        (v)->data_int |= (-1LL) << type_width((v)->type);\
+    }})
+
 /* The type engine: each type is simplified to a vector of X elements
  * of Y bits. */
 
@@ -900,6 +906,7 @@ static Value greater_equal_value_defined_bitstring(Value src0, Value src1, Value
     /* Converts the values to integers. */
     unsigned long long src0i = value2integer(src0);
     unsigned long long src1i = value2integer(src1);
+    // printf("src0i=%lld src1i=%lld, src0i.sign=%d src0i.width=%d, src1i.sign=%d src1i.width=%d\n",src0i,src1i,src0->type->flags.sign,type_width(src0->type),src1->type->flags.sign,type_width(src1->type));
     /* Perform the comparison. */
     if (src0->type->flags.sign) {
         if (src1->type->flags.sign)
@@ -1275,7 +1282,7 @@ static Value shift_left_value_bitstring_numeric(Value src0, Value src1, Value ds
         char d0 = src0_data[count];
         /* Set it to the destination at the right place. */
         unsigned long long pos = count + sh;
-        if ((pos>0) && (pos<width0)) {
+        if ((pos>=0) && (pos<width0)) {
             dst_data[pos] = d0;
         }
     }
@@ -1290,6 +1297,7 @@ static Value shift_left_value_bitstring_numeric(Value src0, Value src1, Value ds
  *  @param dst the destination
  *  @return dst */
 static Value shift_right_value_bitstring_numeric(Value src0, Value src1, Value dst) {
+    // printf("shift_right_value_bitstring_numeric with src0=%s src1=%lld\n",src0->data_str,src1->data_int);
     unsigned long long count;
     /* Get the widths of the first source. */
     unsigned long long width0 = type_width(src0->type);
@@ -1319,10 +1327,11 @@ static Value shift_right_value_bitstring_numeric(Value src0, Value src1, Value d
         char d0 = src0_data[count];
         /* Set it to the destination at the right place. */
         unsigned long long pos = count + sh;
-        if ((pos>0) && (pos<width0)) {
+        if ((pos>=0) && (pos<width0)) {
             dst_data[pos] = d0;
         }
     }
+    // printf("result=%s\n",dst_data);
     /* Return the destination value. */
     return dst;
 }
@@ -1683,6 +1692,7 @@ Value read_range_bitstring(Value src,
         unsigned long long first, unsigned long long last,
         Type base, Value dst) {
     // printf("read_range_bitstring with first=%lld last=%lld src=%s\n",first,last,src->data_str);
+    // printf("read_range_bitstring with first=%lld last=%lld\n",first,last);
     /* Ensure first is the smaller. */
     if (first > last) {
         long long tmp = last;
@@ -1705,6 +1715,7 @@ Value read_range_bitstring(Value src,
 
     /* Performs the read. */
     memcpy(dst->data_str,src->data_str + first, length);
+    // printf("result: %s\n",dst->data_str);
 
     /* Return the destination. */
     return dst;
@@ -1888,9 +1899,15 @@ static Value mul_value_numeric(Value src0, Value src1, Value dst) {
     /* Sets state of the destination using the first source. */
     dst->type = src0->type;
     dst->numeric = 1;
+    /* Fix the numeric signs since multiply is sensitive to it. */
+    // printf("src0 type_width=%d src1 type_width=%d (%d)\n",type_width(src0->type),type_width(src1->type),src1->type->flags.sign);
+    fix_numeric_sign(src0);
+    fix_numeric_sign(src1);
+    // printf("Then src0->data_int=%llx src1->data_int=%llx\n",src0->data_int,src1->data_int);
 
     /* Perform the multiplication. */
     dst->data_int = fix_numeric_type(dst->type, src0->data_int * src1->data_int);
+    // printf("result=%llx\n",dst->data_int);
     return dst;
 }
 
@@ -1905,6 +1922,10 @@ static Value div_value_numeric(Value src0, Value src1, Value dst) {
     dst->type = src0->type;
     dst->numeric = 1;
 
+    /* Fix the numeric signs since multiply is sensitive to it. */
+    fix_numeric_sign(src0);
+    fix_numeric_sign(src1);
+
     /* Perform the division. */
     dst->data_int = fix_numeric_type(dst->type, src0->data_int / src1->data_int);
     return dst;
@@ -3347,13 +3368,20 @@ RefRangeS make_ref_rangeS(SignalI signal, Type typ,
  *  @param value the value to convert
  *  @return the resulting int. */
 unsigned long long value2integer(Value value) {
+    // printf("value2integer\n");
     unsigned long long width = type_width(value->type);
-    /* If the value is numeric, just return its data as is. */
+    /* If the value is numeric, return it with its sign propoerly extended*/
     if (value->numeric) {
         // printf("width=%llu\n",width);
         if (width == 64)
+            /* Nothing to do. */
             return value->data_int;
+        else if (value->type->flags.sign &&
+                ((value->data_int >> (width-1))&1))
+            /* Sign extension. */
+            return value->data_int | (0xFFFFFFFFFFFFFFFFULL << width);
         else
+            /* Zero extension. */
             return value->data_int & ~(0xFFFFFFFFFFFFFFFFULL << width);
     }
     /* Otherwise convert the bitstring to an integer if possible,
@@ -3377,11 +3405,10 @@ unsigned long long value2integer(Value value) {
         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) {
+    if (value->type->flags.sign) {
+        unsigned long long bit0 = (data_str[width-1]-'0') << i;
         for(; i<LONG_LONG_BIT; ++i) {
-            // res = (res << 1) | bit;
             res |= bit0;
             bit0 <<= 1;
         }

data/ext/hruby_sim/hruby_sim_tree_calc.c

@@ -121,6 +121,9 @@ Value calc_expression(Expression expr, Value res) {
                 free_value();
                 /* Performs the access. */
                 res = read_range(value,index,index,rexpr->type,res);
+                /* Set the type to the one of the reference since it is
+                 * an index access and not a range one. */
+                res->type = rexpr->type;
                 free_value();
                 break;
             }
@@ -174,6 +177,82 @@ Value calc_expression(Expression expr, Value res) {
 }
 
 
+/** Calculates a range access from a reference.
+ *  Recurse over the multiple references.
+ *  @param ref the reference to work on.
+ *  @param first the first index of the access.
+ *  @param last the last index of the access.
+ *  @param sig the target signal. */
+void calc_ref_rangeS(Reference ref, long long* first, long long *last, 
+        SignalI* sig) {
+    // printf("calc_ref_rangeS with kind=%d\n",ref->kind);
+    if (ref->kind == CAST) {
+        /* Create a new reference for the computation that changes the type. */
+        Cast refc = (Cast)ref;
+        /* Compute the range for the child. */
+        long long cfirst, clast;
+        calc_ref_rangeS(refc->child,&cfirst,&clast,sig);
+        /* Update first and last using the cast. */
+        /* Both first and last should be equal since the type of the cast sets
+         * the width */
+        // printf("cfirst=%d clast=%d\n",cfirst,clast);
+        *first = *last = cfirst;
+    }
+    else if (ref->kind == REF_INDEX) {
+        RefIndex refi = (RefIndex)ref;
+        /* Compute the index of refi. */
+        Value indexV = get_value();
+        indexV = calc_expression(refi->index,indexV);
+        long long index = value2integer(indexV);
+        // printf("index=%d\n",index);
+        free_value();
+        /* Is the reference a signal? */
+        if (refi->ref->kind == SIGNALI) {
+            /* Yes, end here. */
+            *first = index;
+            *last  = index;
+            *sig   = (SignalI)(refi->ref);
+        } else {
+            /* No, need to recurse. */
+            long long pfirst, plast;
+            calc_ref_rangeS(refi->ref,&pfirst,&plast,sig);
+            // printf("pfirst=%d plast=%d\n",pfirst,plast);
+            /* Calculate the final first and last. */
+            *first = *last = pfirst + index;
+        }
+    } else if (ref->kind == REF_RANGE) {
+        RefRangeE refr = (RefRangeE)ref;
+        /* Compute the range of refr */
+        Value firstV = get_value();
+        firstV = calc_expression(refr->first,firstV);
+        long long firstR = value2integer(firstV);
+        free_value();
+        Value lastV = get_value();
+        lastV = calc_expression(refr->last,lastV);
+        long long lastR = value2integer(lastV);
+        free_value();
+        // printf("firstR=%d lastR=%d\n",firstR,lastR);
+        /* Is the reference a signal? */
+        if (refr->ref->kind == SIGNALI) {
+            /* Yes, end here. */
+            *first = firstR;
+            *last  = lastR;
+            *sig   = (SignalI)(refr->ref);
+        } else {
+            /* No, need to recurse. */
+            long long pfirst, plast;
+            calc_ref_rangeS(refr->ref,&pfirst,&plast,sig);
+            /* Calculate the final first and last. */
+            *first = pfirst + firstR;
+            *last = plast + lastR;
+        }
+    } else {
+        perror("Invalid reference for converting to range access.");
+        exit(1);
+    }
+}
+
+
 
 /** Executes a statement.
  *  @param stmnt the statement to execute.
@@ -205,15 +284,22 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                         {
                             /* Transmission to sub element. */
                             RefIndex refi = (RefIndex)(trans->left);
-                            /* Compute the index. */
-                            Value indexV = get_value();
-                            indexV = calc_expression(refi->index,indexV);
-                            long long index = value2integer(indexV);
-                            free_value();
-                            /* Generate the reference inside the left value. */
+                            // /* Compute the index. */
+                            // Value indexV = get_value();
+                            // indexV = calc_expression(refi->index,indexV);
+                            // long long index = value2integer(indexV);
+                            // free_value();
+                            // /* Generate the reference inside the left value. */
+                            // RefRangeS ref = 
+                            //     make_ref_rangeS((SignalI)(refi->ref),refi->type,
+                            //         index,index);
+                            /* Compute the range. */
+                            long long first,last;
+                            SignalI sig;
+                            calc_ref_rangeS((Reference)refi,&first,&last,&sig);
+                            /* Now can create the range. */
                             RefRangeS ref = 
-                                make_ref_rangeS((SignalI)(refi->ref),refi->type,
-                                    index,index);
+                                make_ref_rangeS(sig,refi->type,first,last);
                             /* Perform the transmit. */
                             if(mode)
                                 transmit_to_signal_range_seq(right,ref);
@@ -226,21 +312,24 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                             /* Transmission to range of sub elements. */
                             RefRangeE refr = (RefRangeE)(trans->left);
                             /* Compute the range. */
-                            // Value firstV = calc_expression(refr->first);
-                            Value firstV = get_value();
-                            firstV = calc_expression(refr->first,firstV);
-                            long long first = value2integer(firstV);
-                            free_value();
-                            // Value lastV = calc_expression(refr->last);
-                            Value lastV = get_value();
-                            lastV = calc_expression(refr->last,lastV);
-                            long long last = value2integer(lastV);
-                            free_value();
-                            // printf("firstV=%lld lastV=%lld right=%lld mode=%d\n",firstV->data_int,lastV->data_int,right->data_int,mode);
-                            /* Generate the reference inside the left value. */
+                            // Value firstV = get_value();
+                            // firstV = calc_expression(refr->first,firstV);
+                            // long long first = value2integer(firstV);
+                            // free_value();
+                            // Value lastV = get_value();
+                            // lastV = calc_expression(refr->last,lastV);
+                            // long long last = value2integer(lastV);
+                            // free_value();
+                            // /* Generate the reference inside the left value. */
+                            // RefRangeS ref = 
+                            //     make_ref_rangeS((SignalI)(refr->ref),refr->type,
+                            //         first,last);
+                            long long first,last;
+                            SignalI sig;
+                            calc_ref_rangeS((Reference)refr,&first,&last,&sig);
+                            /* Now can create the range. */
                             RefRangeS ref = 
-                                make_ref_rangeS((SignalI)(refr->ref),refr->type,
-                                    first,last);
+                                make_ref_rangeS(sig,refr->type,first,last);
                             /* Perform the transmit. */
                             if(mode)
                                 transmit_to_signal_range_seq(right,ref);

data/lib/HDLRuby/hdr_samples/comparison_bench.rb

@@ -1,7 +1,7 @@
 # Test the comparison operators.
 
-# A benchmark for the adder.
-system :adder_bench do
+# A benchmark for the comparators.
+system :comparison_bench do
     [8].inner :x, :y
     signed[8].inner :u,:v
     inner :ue, :ult, :ule, :ugt, :uge

data/lib/HDLRuby/hdr_samples/counter_bench.rb

@@ -19,8 +19,8 @@ system :counter do
     par do
         hif(rst) { [cc,qq] <= 0 }
         helse do
-            add.(q,1,[cc,qq])
             hif(ctrl == 1) { add.(q,-1,[cc,qq]) }
+            helse          { add.(q,1,[cc,qq]) }
         end
     end
 

data/lib/HDLRuby/hdr_samples/counter_dff_bench.rb

@@ -1,34 +1,35 @@
 # A simple D-FF
 system :dff do
-    input  :clk, :d
+    input  :clk, :rst, :d
     output :q
 
-    (q <= d).at(clk.posedge)
+    (q <= d & ~rst).at(clk.posedge)
 end
 
 # A benchmark for the dff.
 system :dff_bench do
-    inner :clk
+    inner :clk, :rst
     inner :d0, :q0, :d1, :q1
 
-    dff(:my_dff0).(clk,d0,q0)
-    dff(:my_dff1).(d0,d1,q1)
+    dff(:my_dff0).(clk,rst,d0,q0)
+    dff(:my_dff1).(d0,rst,d1,q1)
 
     d0 <= ~q0
     d1 <= ~q1
 
     timed do
-        d0 <= 0
-        d1 <= 0
         clk <= 0
+        rst <= 0
         !10.ns
         clk <= 1
         !10.ns
         clk <= 0
+        rst <= 1
         !10.ns
         clk <= 1
         !10.ns
         clk <= 0
+        rst <= 0
         !10.ns
         clk <= 1
         !10.ns

data/lib/HDLRuby/hdr_samples/dff_properties.rb

@@ -1,3 +1,5 @@
+raise "Properties are deprecated in HDLRuby."
+
 # A simple D-FF
 system :dff do
     input :clk, :rst, :d

data/lib/HDLRuby/hdr_samples/enum_as_param.rb

@@ -0,0 +1,52 @@
+# Check if an enum can be passed as generic parameter.
+
+
+system :machin do |vals|
+    input :clk,:rst
+    [8].output :res
+    sequencer(clk,rst) do
+        vals.seach { |val| res <= val }
+    end
+end
+
+system :truc do |sig|
+    [8].output :res
+
+    res <= sig
+end
+
+system :machin_bench do
+    inner :clk,:rst
+
+    bit[8][-4].inner vals: [ _h01,_h02,_h03,_h05 ]
+    [8].inner :res0
+
+    machin(vals).(:my_machin).(clk,rst,res0)
+    
+    [8].inner :val, :res1
+    truc(val).(:my_truc).(res1)
+
+    timed do
+        val <= 10
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        rst <= 0
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        repeat(15) do
+            clk <= 1
+            !10.ns
+            clk <= 0
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/linear_test.rb

@@ -1,6 +1,8 @@
 require 'std/memory.rb'
 require 'std/linear.rb'
 
+raise "std/memory.rb is deprecated."
+
 include HDLRuby::High::Std
 
 # Tries for matrix-vector product.

data/lib/HDLRuby/hdr_samples/logic_bench.rb

@@ -3,6 +3,8 @@
 system :logic_bench do
     [3].inner :x,:y
     [3].inner :s_not, :s_and, :s_or, :s_xor, :s_nxor
+    
+    signed[16].inner :a,:b,:shl,:shr
 
     timed do
         8.times do |i|
@@ -15,6 +17,10 @@ system :logic_bench do
                 s_xor  <= x ^ y
                 s_nxor <= (x == y)
                 !10.ns
+                a      <= i
+                b      <= j
+                shl    <= (a << b)
+                shr    <= (a >> b)
             end
         end
     end

data/lib/HDLRuby/hdr_samples/mei8.rb

@@ -54,7 +54,7 @@ system :mei8 do |prog_file = "./prog.obj"|
         end
 
         # The control part for choosing between 0, add, sub and neg.
-        par do
+        par(opr,x,y) do
             # Default computations
             cf <= 0; vf <= 0; zf <= (z == 0); sf <= z[7]
             add.(0,0,0)
@@ -148,14 +148,14 @@ system :mei8 do |prog_file = "./prog.obj"|
         end
     end
 
+    # Handling of the 3-state data bus
+    dbus <= mux(io_rwb,io_out,_bzzzzzzzz)
+    io_in <= dbus
+
     # The io unit.
     fsm(clk.posedge,rst,:async) do
         default       { io_done <= 0; req <= 0; rwb <= 0; addr <= 0
-                        io_r_done <= 0
-                        # Default handling of the 3-state data bus
-                        hif(io_rwb) { dbus <= _zzzzzzzz }
-                        helse       { dbus <= io_out }
-                        io_in <= dbus }
+                        io_r_done <= 0 }
         reset(:sync)  { data <= 0; }
         state(:wait)  { goto(io_req,:start,:wait) }        # Waiting for an IO
         state(:start) { req <= 1; rwb <= io_rwb; addr <= g # Start an IO

data/lib/HDLRuby/hdr_samples/mei8_bench.rb

@@ -56,7 +56,7 @@ system :mei8 do |prog_file = "./prog.obj"|
         end
 
         # The control part for choosing between 0, add, sub and neg.
-        par do
+        par(opr,x,y) do
             # Default computations
             cf <= 0; vf <= 0; zf <= (z == 0); sf <= z[7]
             add.(0,0,0)
@@ -150,14 +150,14 @@ system :mei8 do |prog_file = "./prog.obj"|
         end
     end
 
+    # Handling of the 3-state data bus
+    dbus <= mux(io_rwb,io_out,_bzzzzzzzz)
+    io_in <= dbus
+
     # The io unit.
     fsm(clk.posedge,rst,:async) do
         default       { io_done <= 0; req <= 0; rwb <= 0; addr <= 0
-                        io_r_done <= 0
-                        # Default handling of the 3-state data bus
-                        hif(io_rwb) { dbus <= _zzzzzzzz }
-                        helse       { dbus <= io_out }
-                        io_in <= dbus }
+                        io_r_done <= 0 }
         reset(:sync)  { data <= 0; }
         state(:wait)  { goto(io_req,:start,:wait) }        # Waiting for an IO
         state(:start) { req <= 1; rwb <= io_rwb; addr <= g # Start an IO

data/lib/HDLRuby/hdr_samples/memory_test.rb

@@ -1,5 +1,7 @@
 require 'std/memory.rb'
 
+raise "std/memory.rb is deprecated."
+
 include HDLRuby::High::Std
 
 

data/lib/HDLRuby/hdr_samples/named_sub.rb

@@ -4,9 +4,9 @@
 
 
 # A simple circuit with named sub
-system :named_sub do
-    input  :x, :y
-    output :s
+system :named_sub do |x|
+    input  :y
+    output :s, :z
 
     sub :somesub do
         inner :sig
@@ -17,13 +17,17 @@ system :named_sub do
         s <= ~somesub.sig
     end
 
+    z <= s
+
 end
 
 # A benchmark for the circuit.
 system :named_sub_bench do
-    inner :x, :y, :s
+    inner :x, :y, :s, :z
+
+    named_sub(x).(:my_named_sub).(y,s)
 
-    named_sub(:my_named_sub).(x,y,s)
+    z <= my_named_sub.z
 
     timed do
         x <= 0

data/lib/HDLRuby/hdr_samples/ram.rb

@@ -4,15 +4,16 @@ system :ram8_16 do
     [7..0].input :addr
     [7..0].inout :data
 
+    [7..0].inner :data_in
+
     bit[7..0][2**8].inner :content
 
-    # Memory enabled?
+    data <= mux(en & rwb, _bzzzzzzzz, content[addr])
+    data_in <= data
+
     par(clk.posedge) do
-        hif(en) do
-            # Read case
-            hif(rwb)   { data <= content[addr] }
-            helse      { content[addr] <= data }
+        hif(en & ~rwb) do
+            content[addr] <= data_in
         end
-        helse { data <= _bZZZZZZZZ }
     end
 end

data/lib/HDLRuby/hdr_samples/ruby_fir_hw.rb

@@ -2,6 +2,8 @@ require 'std/memory.rb'
 require 'std/linear.rb'
 # require 'std/timing.rb'
 
+raise "std/memory.rb is deprecated."
+
 include HDLRuby::High::Std
 
 

data/lib/HDLRuby/hdr_samples/struct.rb

@@ -8,6 +8,8 @@ system :my_system do
     inner :z
     { sub0: bit, sub1: bit[2]}.inner :sigA
     some_struct.inner :sigB, :sigC
+    # { sub4: bit[8], sub5: bit[8] }.to_type[-2].inner :sigs
+    { sub4: bit[8][-2], sub5: bit[8][-2] }.inner :sigs
 
     sigC <= sigA
 
@@ -15,9 +17,19 @@ system :my_system do
 
 
     timed do
-        z <= 0
-        x <= 1
-        y <= _b000
+        # z <= 0
+        # x <= 1
+        # y <= _b000
+
+        # sigs[0].sub4 <= 1
+        # sigs[0].sub5 <= 2
+        # sigs[1].sub4 <= 3
+        # sigs[1].sub5 <= 4
+        sigs.sub4[0] <= 1
+        sigs.sub5[0] <= 2
+        sigs.sub4[1] <= 3
+        sigs.sub5[1] <= 4
+
         !10.ns
         sigA.sub0 <= 0
         sigA.sub1 <= x

data/lib/HDLRuby/hdr_samples/with_bram.rb

@@ -10,7 +10,7 @@ system :bram_test do
     widthD = 8
 
 
-    input :clk,:rwb
+    inner :clk,:rwb
     [widthA].inner :addr
     [widthD].inner  :din,:dout