Lower Verilog UDPs to MIR directly

Author: nickg

lib/nvc/verilog-body.vhd

@@ -377,6 +377,18 @@ package body verilog is
         end if;
     end function;
 
+    function "and" (l, r : t_logic_array) return t_logic is
+        variable result : t_logic := '0';
+    begin
+        for i in l'range loop
+            result := result and l(i);
+        end loop;
+        for i in r'range loop
+            result := result and r(i);
+        end loop;
+        return result;
+    end function;
+
     function "and" (l, r : t_logic_array) return t_logic_array is
         constant llen   : natural := l'length;
         constant rlen   : natural := r'length;

lib/nvc/verilog.vhd

@@ -72,6 +72,7 @@ package verilog is
     function resize (value : t_logic; length : natural) return t_logic_array;
 
     function "and" (l, r : t_logic) return t_logic;
+    function "and" (l, r : t_logic_array) return t_logic;
     function "and" (l, r : t_logic_array) return t_logic_array;
 
     function "nand" (l, r : t_logic) return t_logic;

src/cgen.c

@@ -30,7 +30,7 @@
 #include "phase.h"
 #include "thread.h"
 #include "type.h"
-#include "vcode.h"
+#include "vlog/vlog-node.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -110,6 +110,8 @@ static void cgen_find_dependencies(mir_context_t *mc, unit_registry_t *ur,
       ident_t link = mir_get_linkage(mu, i);
       if (hset_contains(seen, link))
          continue;
+      else if (ident_char(link, 0) == '$')
+         continue;   // TODO: handle VPI differently
       else if (preload || !cgen_is_preload(link)) {
          APUSH(*units, link);
          hset_insert(seen, link);
@@ -126,6 +128,9 @@ static void cgen_walk_hier(unit_list_t *units, hset_t *seen, tree_t block,
    APUSH(*units, unit_name);
    hset_insert(seen, unit_name);
 
+   tree_t hier = tree_decl(block, 0);
+   assert(tree_kind(hier) == T_HIER);
+
    const int nstmts = tree_stmts(block);
    for (int i = 0; i < nstmts; i++) {
       tree_t s = tree_stmt(block, i);
@@ -141,6 +146,17 @@ static void cgen_walk_hier(unit_list_t *units, hset_t *seen, tree_t block,
             hset_insert(seen, proc_name);
          }
          break;
+      case T_VERILOG:
+         {
+            vlog_node_t mod = tree_vlog(tree_ref(hier));
+            ident_t name = tree_ident(s);
+            ident_t suffix = well_known(W_SHAPE);
+            ident_t shape = ident_prefix(vlog_ident(mod), suffix, '.');
+            ident_t sym = ident_prefix(shape, name, '.');
+            APUSH(*units, sym);
+            hset_insert(seen, sym);
+         }
+         break;
       default:
          break;
       }

src/elab.c

@@ -64,6 +64,7 @@ typedef struct _elab_ctx {
    hash_t           *generics;
    jit_t            *jit;
    unit_registry_t  *registry;
+   mir_context_t    *mir;
    lower_unit_t     *lowered;
    cover_data_t     *cover;
    sdf_file_t       *sdf;
@@ -264,7 +265,7 @@ static mod_cache_t *elab_cached_module(vlog_node_t mod, const elab_ctx_t *ctx)
    if (mc == NULL) {
       mc = xcalloc(sizeof(mod_cache_t));
       mc->module = mod;
-      mc->shape  = vlog_lower(ctx->registry, mod);
+      mc->shape  = vlog_lower(ctx->registry, ctx->mir, mod);
 
       mc->block = tree_new(T_BLOCK);
       tree_set_loc(mc->block, vlog_loc(mod));
@@ -1315,6 +1316,7 @@ static void elab_inherit_context(elab_ctx_t *ctx, const elab_ctx_t *parent)
    ctx->parent    = parent;
    ctx->jit       = parent->jit;
    ctx->registry  = parent->registry;
+   ctx->mir       = parent->mir;
    ctx->root      = parent->root;
    ctx->dotted    = ctx->dotted ?: parent->dotted;
    ctx->inst_name = ctx->inst_name ?: parent->inst_name;
@@ -2218,8 +2220,8 @@ static void elab_verilog_root_cb(void *arg)
    elab_verilog_module(NULL, vlog_ident2(mc->module), mc, ctx);
 }
 
-tree_t elab(object_t *top, jit_t *jit, unit_registry_t *ur, cover_data_t *cover,
-            sdf_file_t *sdf, rt_model_t *m)
+tree_t elab(object_t *top, jit_t *jit, unit_registry_t *ur, mir_context_t *mc,
+            cover_data_t *cover, sdf_file_t *sdf, rt_model_t *m)
 {
    make_new_arena();
 
@@ -2251,6 +2253,7 @@ tree_t elab(object_t *top, jit_t *jit, unit_registry_t *ur, cover_data_t *cover,
       .jit       = jit,
       .sdf       = sdf,
       .registry  = ur,
+      .mir       = mc,
       .modcache  = hash_new(16),
       .dotted    = lib_name(work),
       .model     = m,

src/jit/jit-core.c

@@ -421,30 +421,23 @@ void jit_fill_irbuf(jit_func_t *f)
    if (f->jit->pack != NULL && jit_pack_fill(f->jit->pack, f->jit, f))
       goto done;
 
-   vcode_unit_t unit = NULL;
-   if (f->jit->registry != NULL) {
-      // Unit registry is not thread-safe
-      SCOPED_LOCK(f->jit->lock);
-      unit = unit_registry_get(f->jit->registry, f->name);
-   }
-
-   if (unit == NULL) {
-      store_release(&(f->state), JIT_FUNC_ERROR);
-      jit_missing_unit(f);
-   }
+   mir_unit_t *mu = mir_get_unit(f->jit->mir, f->name);
 
-   mir_unit_t *mu;
-   {
-      // MIR import is not thread-safe
+   if (mu == NULL && f->jit->registry != NULL) {
+      // Unit registry and MIR import is not thread-safe
       SCOPED_LOCK(f->jit->lock);
-
-      mu = mir_get_unit(f->jit->mir, f->name);
-      if (mu == NULL) {
+      vcode_unit_t unit = unit_registry_get(f->jit->registry, f->name);
+      if (unit != NULL) {
          mu = mir_import(f->jit->mir, unit);
          mir_put_unit(f->jit->mir, mu);
       }
    }
 
+   if (mu == NULL) {
+      store_release(&(f->state), JIT_FUNC_ERROR);
+      jit_missing_unit(f);
+   }
+
    jit_irgen(f, mu);
 
  done:

src/jit/jit-irgen.c

@@ -4047,6 +4047,8 @@ static void irgen_block(jit_irgen_t *g, mir_block_t block)
          fatal_trace("cannot generate JIT IR for MIR op %s", mir_op_string(op));
       }
    }
+
+   DEBUG_ONLY(if (nops == 0) j_trap(g));
 }
 
 static void irgen_locals(jit_irgen_t *g)

src/mir/mir-dump.c

@@ -627,7 +627,8 @@ void mir_annotate(mir_unit_t *mu, const mir_annotate_t *cb, void *ctx)
          color_printf("  $magenta$%s$$\n", istr(mu->linkage.items[i]));
    }
 
-   printf("Begin\n");
+   if (mu->blocks.count > 0)
+      printf("Begin\n");
 
    for (int i = 0; i < mu->blocks.count; i++) {
       const block_data_t *b = &(mu->blocks.items[i]);

src/mir/mir-node.c

@@ -39,6 +39,8 @@ block_data_t *mir_block_data(mir_unit_t *mu, mir_block_t block)
 
 mir_block_t mir_add_block(mir_unit_t *mu)
 {
+   assert(mu->kind != MIR_UNIT_PLACEHOLDER);
+
    mir_block_t b = { .tag = MIR_TAG_BLOCK, .id = mu->blocks.count };
 
    block_data_t bd = {
@@ -239,12 +241,24 @@ bool mir_is_terminator(mir_op_t op)
    case MIR_OP_JUMP:
    case MIR_OP_COND:
    case MIR_OP_WAIT:
+   case MIR_OP_CASE:
+   case MIR_OP_PCALL:
+   case MIR_OP_UNREACHABLE:
       return true;
    default:
       return false;
    }
 }
 
+bool mir_block_finished(mir_unit_t *mu, mir_block_t block)
+{
+   const block_data_t *bd = mir_block_data(mu, block);
+   if (bd->num_nodes == 0)
+      return false;
+
+   return mir_is_terminator(mu->nodes[bd->nodes[bd->num_nodes - 1]].op);
+}
+
 static inline node_id_t mir_node_id(mir_unit_t *mu, node_data_t *n)
 {
    assert(n >= mu->nodes && n < mu->nodes + mu->num_nodes);
@@ -254,6 +268,7 @@ static inline node_id_t mir_node_id(mir_unit_t *mu, node_data_t *n)
 static node_data_t *mir_alloc_node(mir_unit_t *mu)
 {
    assert(!mir_is_null(mu->cursor.block));
+   assert(mu->kind != MIR_UNIT_PLACEHOLDER);
 
    node_data_t *n;
    block_data_t *bd = mir_block_data(mu, mu->cursor.block);

src/mir/mir-node.h

@@ -379,6 +379,7 @@ mir_var_flags_t mir_get_var_flags(mir_unit_t *mu, mir_value_t value);
 mir_type_t mir_get_var_type(mir_unit_t *mu, mir_value_t value);
 void mir_set_input(mir_unit_t *mu, mir_value_t phi, unsigned nth,
                    mir_block_t block, mir_value_t value);
+bool mir_block_finished(mir_unit_t *mu, mir_block_t block);
 
 void mir_set_result(mir_unit_t *mu, mir_type_t type);
 mir_type_t mir_get_result(mir_unit_t *mu);

src/mir/mir-priv.h

@@ -70,6 +70,7 @@ bool mir_stamp_const(mir_unit_t *mu, mir_stamp_t stamp, int64_t *cval);
 bool mir_is_terminator(mir_op_t op);
 
 void mir_free_types(type_tab_t *tab);
-void *mir_malloc(mir_context_t *mc, size_t fixed, size_t nelems, size_t size);
+void *mir_global_malloc(mir_context_t *mc, size_t fixed, size_t nelems,
+                        size_t size);
 
 #endif  // _MIR_PRIV_H

src/mir/mir-structs.h

@@ -206,6 +206,8 @@ typedef struct _mir_unit {
    mir_unit_kind_t  kind;
    mir_shape_t     *parent;
    mir_shape_t     *shape;
+   mem_pool_t      *pool;
+   hash_t          *objmap;
    mir_type_t       result;
    known_types_t    types;
    mir_cursor_t     cursor;
@@ -267,14 +269,16 @@ typedef struct {
 typedef struct _mir_shape {
    ident_t         name;
    mir_shape_t    *parent;
+   hash_t         *objmap;
    mir_type_t      type;
    mir_unit_kind_t kind;
    unsigned        num_slots;
    shape_slot_t    slots[];
 } mir_shape_t;
 
 typedef struct {
-   mir_shape_t     *parent;
+   ident_t          name;
+   ident_t          parent;
    mir_lower_fn_t   fn;
    object_t        *object;
    mir_unit_kind_t  kind;

src/mir/mir-type.c

@@ -252,8 +252,8 @@ static void mir_install_type(mir_unit_t *mu, type_data_t *dst,
 
          dst_r->name   = src_r->name;
          dst_r->count  = src_r->count;
-         dst_r->fields = mir_malloc(mu->context, 0, src_r->count * 2,
-                                    sizeof(mir_type_t));
+         dst_r->fields = mir_global_malloc(mu->context, 0, src_r->count * 2,
+                                           sizeof(mir_type_t));
 
          for (int i = 0; i < src_r->count; i++) {
             mir_type_t pointer = mir_get_var_pointer(mu, src_r->fields[i]);