HDLRuby 2.6.19 → 2.6.25

data/lib/HDLRuby/sim/hruby_sim.h

@@ -4,6 +4,7 @@
  **/
 
 #include <pthread.h>
+#include <stdarg.h>
 
 
 /* The interface to the HDLRuby objects C models. */
@@ -101,6 +102,7 @@ typedef struct ValueS_ {
 /* The tructure of a reference to a range in a value. */
 typedef struct RefRangeS_ {
     SignalI signal;           /* The refered signal. */
+    Type type;                /* The tyep of the elements. */
     unsigned long long first; /* The first index in the range. */
     unsigned long long last;  /* The last index in the range. */
 } RefRangeS;
@@ -219,6 +221,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 C equal 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 the destination value */
+extern Value equal_value_c(Value src0, Value src1, Value dst);
+
+/** Computes the C not equal 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 the destination value */
+extern Value not_equal_value_c(Value src0, Value src1, Value dst);
+
 /** Computes the greater comparision of two values.
  *  @param src0 the first source value of the comparison
  *  @param src1 the second source value of the comparison
@@ -260,6 +276,8 @@ extern Value select_value(Value cond, Value dst, unsigned int num, ...);
  *  @param dst the destination value
  *  @return dst */
 extern Value concat_value(int num, int dir, Value dst, ...);
+extern Value concat_valueV(int num, int dir, Value dst, va_list args);
+extern Value concat_valueP(int num, int dir, Value dst, Value* args);
 
 /** Casts a value to another type.
  *  @param src the source value
@@ -308,11 +326,12 @@ extern int same_content_value_range(Value value0, unsigned long long first,
 
 /** Creates a reference to a range inside a signal.
  *  @param signal the signal to refer
+ *  @param typ the type of the elements.
  *  @param first the start index of the range
  *  @param last the end index of the range
  *  @return the resulting reference */
-extern RefRangeS make_ref_rangeS(SignalI signal, unsigned long long first,
-        unsigned long long last);
+extern RefRangeS make_ref_rangeS(SignalI signal, Type typ, 
+        unsigned long long first, unsigned long long last);
 
 
 /* The interface for the lists. */
@@ -371,6 +390,9 @@ extern Elem remove_list(List list);
 /** Get a fresh value. */
 extern Value get_value();
 
+/** Get the current top value. */
+Value get_top_value();
+
 /** Frees the last value of the pool. */
 extern void free_value();
 
@@ -381,6 +403,19 @@ extern unsigned int get_value_pos();
  *  @param pos the new position in the pool */
 extern void set_value_pos(unsigned int pos);
 
+/** Saves the current state+1 of the value pool to the pool state stack. */
+extern void save_value_pos();
+
+/** Restores the state of the value pool from the state stack. */
+extern void restore_value_pos();
+
+/** Macros for short control of the pool of values. */
+#define SV get_value();save_value_pos();
+#define RV restore_value_pos();
+
+
+
+
 /** An HDLRuby object. */
 typedef struct ObjectS_ {
     Kind kind;          /* The kind of object. */
@@ -710,3 +745,79 @@ extern Value write_range(Value src, long long first, long long last,
  *  @return dst */
 extern Value write_range_no_z(Value src, long long first, long long last,
         Type base, Value dst);
+
+
+/** Stack-based computations. */
+
+/** Push a value.
+ *  @param val the value to push. */
+extern void push(Value val);
+
+/** Pops a value.
+ *  @return the value. */
+extern Value pop();
+
+/** Unary calculation.
+ *  @param oper the operator function
+ *  @return the destination
+ **/
+extern Value unary(Value (*oper)(Value,Value));
+
+/** Binary calculation.
+ *  @param oper the operator function
+ *  @return the destination
+ **/
+extern Value binary(Value (*oper)(Value,Value,Value));
+
+/** Cast calculation.
+ *  @param typ the type to cast to.
+ *  @return the destination.
+ **/
+extern Value cast(Type typ);
+
+/* Concat values.
+ * @param num the number of values to concat.
+ * @param dir the direction. */
+extern Value sconcat(int num, int dir);
+
+/* Index read calculation.
+ * @param typ the data type of the access. */
+extern Value sreadI(Type typ);
+
+/* Index write calculation.
+ * @param typ the data type of the access. */
+extern Value swriteI(Type typ);
+
+/* Range read calculation.
+ * @param typ the data type of the access. */
+extern Value sreadR(Type typ);
+
+/* Range write calculation.
+ * @param typ the data type of the access. */
+extern Value swriteR(Type typ);
+
+/** Check if the top value is defined. */
+extern int is_defined();
+
+/** Convert the top value to an integer. */
+extern unsigned long long to_integer();
+
+/** Check if a value is true.
+ *  Actually check if it is defined and convert it to integer. */
+extern unsigned long long is_true();
+
+/* Transmit the top value to a signal in parallel. 
+ * @param sig the signal to transmit to. */
+extern void transmit(SignalI sig);
+
+/* Transmit the top value to a signal in sequence.
+ * @param sig the signal to transmit to. */
+extern void transmit_seq(SignalI sig);
+
+/* Transmit the top value to a range in a signal in parallel. 
+ * @param ref the ref to the range of the signal to transmit to. */
+extern void transmitR(RefRangeS ref);
+
+/* Transmit the top value to a range in a signal in sequence. 
+ * @param ref the ref to the range of the signal to transmit to. */
+extern void transmitR_seq(RefRangeS ref);

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -2171,7 +2171,8 @@ Value read_range_numeric(Value value, long long first, long long last,
     /* Compute the read mask. */
     // 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;
+    unsigned long long mask = last+bw < 64 ? (~((-1LL) << (last+bw))) : -1LL;
+    // printf("mask=%llx\n",mask);
     /* Performs the read. */
     unsigned long long data = (value->data_int & mask) >> first;
     /* Write it to the destination. */
@@ -2216,7 +2217,9 @@ Value write_range_numeric(Value src, long long first, long long last,
     /* Copy from the source. */
     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+1)));
+    unsigned long long mask;
+    if (last<63) mask = ~(((-1LL) << first) & ~((-1LL) << (last+1)));
+    else         mask = ~((-1LL)<<first);
     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. */
@@ -2654,6 +2657,28 @@ Value equal_value(Value src0, Value src1, Value dst) {
 }
 
 
+/** Computes the C equal 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 the destination value */
+Value equal_value_c(Value src0, Value src1, Value dst) {
+    dst = equal_value(src0,src1,dst);
+    return reduce_or_value(dst,dst);
+}
+
+
+/** Computes the C not equal 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 the destination value */
+Value not_equal_value_c(Value src0, Value src1, Value dst) {
+    dst = xor_value(src0,src1,dst);
+    return reduce_or_value(dst,dst);
+}
+
+
 
 /** Computes the greater comparision of two general values.
  *  @param src0 the first source value of the addition
@@ -2787,16 +2812,9 @@ Value select_value(Value cond, Value dst, unsigned int num, ...) {
  *  @param num the number of values to concat
  *  @param dst the destination value
  *  @return dst */
-Value concat_value(int num, int dir, Value dst, ...) {
+Value concat_valueP(int num, int dir, Value dst, Value* values) {
     unsigned long long width = 0;
     int numeric = 1, i;
-    va_list args;
-    Value* values = alloca(num*sizeof(Value)); /* The values to concatenate. */
-    va_start(args,dst);
-    /* Copy the arguments to values for easier processing. */
-    for(i=0; i<num; ++i) {
-        values[i] = va_arg(args,Value);
-    }
     /* check if all the sub values are numeric. */
     for(i=0; i<num; ++i) {
         if (!values[i]->numeric) {
@@ -2828,11 +2846,25 @@ Value concat_value(int num, int dir, Value dst, ...) {
         /* The sub values are now all bitstrings. */
         concat_value_bitstring_array(num,dir,dst,values);
     }
+    return dst;
+}
+Value concat_valueV(int num, int dir, Value dst, va_list args) {
+    int i;
+    Value* values = alloca(num*sizeof(Value)); /* The values to concatenate. */
+    /* Copy the arguments to values for easier processing. */
+    for(i=0; i<num; ++i) {
+        values[i] = va_arg(args,Value);
+    }
+    return concat_valueP(num,dir,dst,values);
+}
+Value concat_value(int num, int dir, Value dst, ...) {
+    va_list args;
+    va_start(args,dst);
+    dst = concat_valueV(num,dir,dst,args);
     va_end(args);
     return dst;
 }
 
-
 /** Casts a value to another type.
  *  @param src the source value
  *  @param type the type to cast to
@@ -2947,12 +2979,13 @@ int same_content_value_range(Value value0,
 
 /** Creates a reference to a range inside a signal.
  *  @param signal the signal to refer
+ *  @param typ the type of the elements
  *  @param first the start index of the range
  *  @param last the end index of the range
  *  @return the resulting reference */
-RefRangeS make_ref_rangeS(SignalI signal, unsigned long long first,
+RefRangeS make_ref_rangeS(SignalI signal, Type typ, unsigned long long first,
         unsigned long long last) {
-    RefRangeS result = { signal, first, last };
+    RefRangeS result = { signal, typ, first, last };
     return result;
 }
 

data/lib/HDLRuby/sim/hruby_sim_core.c

@@ -586,12 +586,14 @@ void transmit_to_signal_range_seq(Value value, RefRangeS ref) {
     SignalI signal = ref.signal;
     unsigned long long first = ref.first;
     unsigned long long last = ref.last;
-    // printf("Tansmit to signal range: %s(%p)\n",signal->name,signal);
+    // printf("Tansmit to signal range: %s(%p) [%llu,%llu]\n",signal->name,signal,first,last);
     /* Can transmit, copy the content. */
     if (signal->fading)
-        write_range(value,first,last,signal->f_value->type,signal->f_value);
+        // write_range(value,first,last,signal->f_value->type,signal->f_value);
+        write_range(value,first,last,ref.type,signal->f_value);
     else
-        write_range_no_z(value,first,last,signal->f_value->type,signal->f_value);
+        // write_range_no_z(value,first,last,signal->f_value->type,signal->f_value);
+        write_range_no_z(value,first,last,ref.type,signal->f_value);
     /* And touch the signal. */
     touch_signal_seq(signal);
 }

data/lib/HDLRuby/sim/hruby_sim_stack_calc.c

@@ -0,0 +1,203 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include "hruby_sim.h"
+
+
+/**
+ *  The HDLRuby simulation stack calculation engine, to be used with C code
+ *  generated by hruby_low2c. 
+ **/
+
+/* The stack variables. */
+#define STACK_SIZE 0x10000
+static Value stack[STACK_SIZE];
+static int head = STACK_SIZE;
+
+/** Push a value.
+ *  @param val the value to push. */
+void push(Value val) {
+    if (head > 0) {
+        stack[--head] = val;
+    } else {
+        perror("Computation stack full.\n");
+        exit(1);
+    }
+}
+
+/** Pops a value.
+ *  @return the value. */
+Value pop() {
+    if (head < STACK_SIZE) {
+        return stack[head++];
+    } else {
+        perror("Computation stack empty.\n");
+        exit(1);
+    }
+}
+
+/** Pops multiple values.
+ *  @param num the number of values to pop.
+ *  @return a pointer on the first value (in heap order!). */
+static Value* popn(int num) {
+    if (head+num <= STACK_SIZE) {
+        head += num;
+        return &stack[head-num];
+    } else {
+        perror("Not enough values in computation stack.\n");
+        exit(1);
+    }
+}
+
+
+/** Unary calculation.
+ *  @param oper the operator function
+ *  @return the destination
+ **/
+Value unary(Value (*oper)(Value,Value)) {
+    // printf("unary\n");
+    Value dst = get_top_value();
+    dst = oper(pop(),dst);
+    push(dst);
+    return dst;
+}
+
+/** Binary calculation.
+ *  @param oper the operator function
+ *  @return the destination
+ **/
+Value binary(Value (*oper)(Value,Value,Value)) {
+    // printf("binary\n");
+    Value dst = get_top_value();
+    Value r = pop();
+    Value l = pop();
+    dst = oper(l,r,dst);
+    push(dst);
+    return dst;
+}
+
+/** Cast calculation.
+ *  @param typ the type to cast to.
+ *  @return the destination.
+ **/
+Value cast(Type typ) {
+    // printf("cast\n"); 
+    Value dst = get_top_value();
+    Value src = pop();
+    dst = cast_value(src,typ,dst);
+    push(dst);
+    return dst;
+}
+
+/* Concat values.
+ * @param num the number of values to concat.
+ * @param dir the direction. */
+Value sconcat(int num, int dir) {
+    Value* vals = alloca(num*sizeof(Value));
+    Value dst = get_top_value();
+    int i;
+    // printf("sconcat\n");
+    /* Get the values to concat from the stack. */
+    for(i=1;i<=num;++i) vals[num-i] = pop();
+    dst = concat_valueP(num,dir,dst,vals);
+    push(dst);
+    return dst;
+}
+
+/* Index read calculation.
+ * @param typ the data type of the access. */
+Value sreadI(Type typ) {
+    // printf("sreadI\n");
+    Value dst = get_top_value();
+    unsigned long long idx = value2integer(pop());
+    dst = read_range(pop(),idx,idx,typ,dst);
+    push(dst);
+    return dst;
+}
+
+/* Index write calculation.
+ * @param typ the data type of the access. */
+Value swriteI(Type typ) {
+    // printf("swriteI\n");
+    Value dst = get_top_value();
+    unsigned long long idx = value2integer(pop());
+    dst = write_range(pop(),idx,idx,typ,dst);
+    push(dst);
+    return dst;
+}
+
+/* Range read calculation.
+ * @param typ the data type of the access. */
+Value sreadR(Type typ) {
+    // printf("sreadR\n");
+    Value dst = get_top_value();
+    unsigned long long last = value2integer(pop());
+    unsigned long long first = value2integer(pop());
+    dst = read_range(pop(),first,last,typ,dst);
+    push(dst);
+    return dst;
+}
+
+/* Range write calculation.
+ * @param typ the data type of the access. */
+Value swriteR(Type typ) {
+    // printf("swriteR\n");
+    Value dst = get_top_value();
+    unsigned long long last = value2integer(pop());
+    unsigned long long first = value2integer(pop());
+    dst = write_range(pop(),first,last,typ,dst);
+    push(dst);
+    return dst;
+}
+
+/** Check if the top value is defined. */
+int is_defined() {
+    return is_defined_value(pop());
+}
+
+/** Convert the top value to an integer. */
+unsigned long long to_integer() {
+    return value2integer(pop());
+}
+
+/** Check if a value is true.
+ *  Actually check if it is defined and convert it to integer. */
+unsigned long long is_true() {
+    Value val = pop();
+    if (is_defined_value(val)) {
+        return value2integer(val);
+    } else {
+        return 0;
+    }
+}
+
+/** Transmit the top value to a signal in parallel. 
+ *  @param sig the signal to transmit to. */
+void transmit(SignalI sig) {
+    // printf("transmit\n");
+    transmit_to_signal(pop(),sig);
+}
+
+/** Transmit the top value to a signal in sequence.
+ *  @param sig the signal to transmit to. */
+void transmit_seq(SignalI sig) {
+    // printf("transmit_seq\n");
+    transmit_to_signal_seq(pop(),sig);
+}
+
+/** Transmit a value to a range in a signal in parallel. 
+ *  @param ref the ref to the range of the signal to transmit to. */
+void transmitR(RefRangeS ref) {
+    // printf("transmitR\n");
+    transmit_to_signal_range(pop(),ref);
+}
+
+/** Transmit a value to a range in a signal in sequence. 
+ *  @param ref the ref to the range of the signal to transmit to. */
+void transmitR_seq(RefRangeS ref) {
+    // printf("transmitR_seq\n");
+    transmit_to_signal_range_seq(pop(),ref);
+}
+

data/lib/HDLRuby/sim/hruby_sim_stack_calc.c.sav

@@ -0,0 +1,100 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include "hruby_sim.h"
+
+#ifndef alloca
+#define alloca(x)  __builtin_alloca(x)
+#endif
+
+
+/**
+ *  The HDLRuby simulation stack calculation engine, to be used with C code
+ *  generated by hruby_low2c. 
+ **/
+
+
+/** Unary calculation.
+ *  @param src0 the left value
+ *  @param oper the operator function
+ *  @return the destination
+ **/
+Value unary(Value src0, Value (*oper)(Value,Value)) {
+    Value dst = get_value();
+    unsigned int pool_state = get_value_pos();
+    dst = oper(src0,dst);
+    set_value_pos(pool_state);
+    return dst;
+}
+
+/** Binary calculation.
+ *  @param src0 the left value
+ *  @param src1 the right value
+ *  @param oper the operator function
+ *  @return the destination
+ **/
+Value binary(Value src0, Value src1, Value (*oper)(Value,Value,Value)) {
+    Value dst = get_value();
+    unsigned int pool_state = get_value_pos();
+    dst = oper(src0,src1,dst);
+    set_value_pos(pool_state);
+    return dst;
+}
+
+/** Cast calculation.
+ *  @param src0 the value to cast.
+ *  @param typ the type to cast to.
+ *  @return the destination.
+ **/
+Value cast(Value src0, Type typ) {
+    Value dst = get_value();
+    unsigned int pool_state = get_value_pos();
+    dst = cast_value(src0,typ,dst);
+    set_value_pos(pool_state);
+    return dst;
+}
+
+/* Concat values.
+ * @param num the number of values to concat.
+ * @param dir the direction.
+ * @param vals the values to concat. */
+Value sconcat(int num, int dir, ...) {
+    Value dst = get_value();
+    unsigned int pool_state = get_value_pos();
+    va_list args;
+    va_start(args,dir);
+    dst = concat_valueV(num,dir,dst,args);
+    va_end(args);
+    set_value_pos(pool_state);
+    return dst;
+}
+
+/* Read access calculation.
+ * @param src0  the value to access in.
+ * @param first the start index.
+ * @param last  the end index.
+ * @param typ   the data type of the access. */
+Value sread(Value src0, unsigned long long first,
+                         unsigned long long last, Type typ) {
+    Value dst = get_value();
+    unsigned int pool_state = get_value_pos();
+    dst = read_range(src0,first,last,typ,dst);
+    set_value_pos(pool_state);
+    return dst;
+}
+
+/* Write access calculation.
+ * @param src0  the value to access in.
+ * @param first the start index.
+ * @param last  the end index.
+ * @param typ   the data type of the access. */
+Value swrite(Value src0, unsigned long long first,
+                         unsigned long long last, Type typ) {
+    Value dst = get_value();
+    unsigned int pool_state = get_value_pos();
+    dst = write_range(src0,first,last,typ,dst);
+    set_value_pos(pool_state);
+    return dst;
+}

data/lib/HDLRuby/sim/hruby_value_pool.c

@@ -47,6 +47,16 @@ Value get_value() {
     return pool_values[pool_pos++];
 }
 
+/** Get the current top value. */
+Value get_top_value() {
+    if (pool_pos > 0)
+        return pool_values[pool_pos-1];
+    else {
+        perror("Pool of values is empty.");
+        exit(1);
+    }
+}
+
 /** Frees the last value of the pool. */
 void free_value() {
     if (pool_pos > 0) pool_pos--;
@@ -62,3 +72,29 @@ unsigned int get_value_pos() {
 void set_value_pos(unsigned int pos) {
     pool_pos = pos;
 }
+
+
+#define POOL_STATE_STACK_SIZE 0x10000
+/* The stack of pool states. */
+static unsigned int pool_state_stack[POOL_STATE_STACK_SIZE];
+static int pool_state_head = POOL_STATE_STACK_SIZE;
+
+/** Saves to current state of the value pool to the pool state stack. */
+extern void save_value_pos() {
+    if (pool_state_head > 0) {
+        pool_state_stack[--pool_state_head] = get_value_pos();
+    } else {
+        perror("Pool state stack full.");
+        exit(1);
+    }
+}
+
+/** Restores the state of the value pool from the state stack. */
+extern void restore_value_pos() {
+    if (pool_state_head < POOL_STATE_STACK_SIZE) {
+        set_value_pos(pool_state_stack[pool_state_head++]);
+    } else {
+        perror("Pool state stack empty.");
+        exit(1);
+    }
+}

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "2.6.19"
+  VERSION = "2.6.25"
 end