HDLRuby 2.6.23 → 2.7.5

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. */
@@ -220,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
@@ -261,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
@@ -373,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();
 
@@ -383,6 +403,20 @@ 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 save_value_pos();
+#define PV push(get_value());save_value_pos();
+#define RV restore_value_pos();
+
+
+
+
 /** An HDLRuby object. */
 typedef struct ObjectS_ {
     Kind kind;          /* The kind of object. */
@@ -712,3 +746,86 @@ 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);
+
+/** Duplicates a value in the stack. */
+extern void dup();
+
+/** Pops a value.
+ *  @return the value. */
+extern Value pop();
+
+/** Access the top value of the stack without removing it.
+ *  @return the value. */
+extern Value peek();
+
+/** 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

@@ -2657,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
@@ -2790,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) {
@@ -2831,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

data/lib/HDLRuby/sim/hruby_sim_stack_calc.c

@@ -0,0 +1,250 @@
+#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);
+    }
+}
+
+/** Duplicates a value in the stack. */
+void dup() {
+    if (head > 0 && head < STACK_SIZE) {
+        Value val = stack[head];
+        stack[--head] = val;
+    } else {
+        perror("Cannot dup in computation stack.\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);
+    }
+}
+
+/** Access the top value of the stack without removing it.
+ *  @return the value. */
+Value peek() {
+    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;
+    return oper(pop(),peek());
+}
+
+/** 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;
+    Value r = pop();
+    Value l = pop();
+    return oper(l,r,peek());
+}
+
+/** 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;
+    return cast_value(pop(),typ,peek());
+}
+
+/* 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;
+    Value* vals = alloca(num*sizeof(Value));
+    int i;
+    // printf("sconcat\n");
+    /* Get the values to concat from the stack. */
+    for(i=1;i<=num;++i) vals[num-i] = pop();
+    return concat_valueP(num,dir,peek(),vals);
+}
+
+/* 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;
+    // printf("sreadI\n");
+    unsigned long long idx = value2integer(pop());
+    return read_range(pop(),idx,idx,typ,peek());
+}
+
+/* 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;
+    // printf("swriteI\n");
+    unsigned long long idx = value2integer(pop());
+    return write_range(pop(),idx,idx,typ,peek());
+}
+
+/* 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;
+    // printf("sreadR\n");
+    unsigned long long last = value2integer(pop());
+    unsigned long long first = value2integer(pop());
+    return read_range(pop(),first,last,typ,peek());
+}
+
+/* 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;
+    // printf("swriteR\n");
+    unsigned long long last = value2integer(pop());
+    unsigned long long first = value2integer(pop());
+    return write_range(pop(),first,last,typ,peek());
+}
+
+/** 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.23"
+  VERSION = "2.7.5"
 end