21689761474

Committed 04 Feb 2026 09:50PM UTC coverage: 92.6% (-0.02%) from 92.618%

Build # 21689761474

Build Type

push

github

Committed by

nickg

Commit Message

Include call stack in JIT interpreter dumps

Coverage Stats

0 of 6 new or added lines in 1 file covered. (0.0%)

556 existing lines in 6 files now uncovered.

76616 of 82739 relevant lines covered (92.6%)

452583.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.84

/src/vlog/vlog-node.c

//
//  Copyright (C) 2022-2025  Nick Gasson
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

#include "util.h"
#include "vlog/vlog-node.h"
#include "vlog/vlog-number.h"
#include "object.h"

#include <string.h>
#include <inttypes.h>
#include <stdlib.h>

static const imask_t has_map[V_LAST_NODE_KIND] = {
   // V_MODULE
   (I_IDENT | I_PORTS | I_STMTS | I_DECLS | I_IDENT2),

   // V_PORT_DECL
   (I_IDENT | I_SUBKIND | I_IDENT2 | I_REF | I_RANGES | I_TYPE | I_VALUE),

   // V_REF
   (I_IDENT | I_REF),

   // V_ALWAYS
   (I_IDENT | I_SUBKIND | I_STMTS),

   // V_TIMING
   (I_VALUE | I_STMTS),

   // V_NBASSIGN
   (I_TARGET | I_VALUE | I_DELAY),

   // V_EVENT
   (I_SUBKIND | I_VALUE),

   // V_INITIAL
   (I_IDENT | I_STMTS),

   // V_BLOCK
   (I_IDENT | I_DECLS | I_STMTS),

   // V_SYS_TCALL
   (I_IDENT | I_PARAMS),

   // V_STRING
   (I_NUMBER),

   // V_NUMBER
   (I_NUMBER),

   // V_NET_DECL
   (I_IDENT | I_SUBKIND | I_TYPE | I_RANGES | I_VALUE),

   // V_ASSIGN
   (I_TARGET | I_VALUE | I_IDENT | I_DELAY),

   // V_DIMENSION
   (I_SUBKIND | I_LEFT | I_RIGHT),

   // V_IF
   (I_CONDS),

   // V_COND
   (I_VALUE | I_STMTS),

   // V_VAR_DECL
   (I_IDENT | I_TYPE | I_RANGES | I_VALUE),

   // V_DELAY_CONTROL
   (I_VALUE),

   // V_BINARY
   (I_LEFT | I_RIGHT | I_SUBKIND),

   // V_BASSIGN
   (I_TARGET | I_VALUE | I_DELAY),

   // V_UNARY
   (I_VALUE | I_SUBKIND),

   // V_GATE_INST
   (I_SUBKIND | I_PARAMS | I_IDENT | I_REF | I_TARGET),

   // V_STRENGTH
   (I_SUBKIND),

   // V_MOD_INST
   (I_IDENT | I_PARAMS),

   // V_BIT_SELECT
   (I_VALUE | I_PARAMS),

   // V_SYS_FCALL
   (I_IDENT | I_PARAMS),

   // V_FOREVER
   (I_STMTS),

   // V_SPECIFY
   (I_DECLS),

   // V_PRIMITIVE
   (I_IDENT | I_IDENT2 | I_PORTS | I_DECLS | I_STMTS),

   // V_UDP_TABLE
   (I_IDENT | I_PARAMS | I_SUBKIND | I_STMTS),

   // V_UDP_ENTRY
   (I_PARAMS),

   // V_DATA_TYPE
   (I_SUBKIND | I_RANGES | I_FLAGS),

   // V_TYPE_DECL
   (I_IDENT | I_TYPE),

   // V_ENUM_DECL
   (I_IDENT | I_TYPE | I_RANGES | I_DECLS),

   // V_ENUM_NAME
   (I_IDENT | I_TYPE | I_VALUE),

   // V_UNION_DECL
   (I_IDENT | I_DECLS),

   // V_STRUCT_DECL
   (I_IDENT | I_DECLS),

   // V_EVENT_CONTROL
   (I_PARAMS),

   // V_EMPTY
   (0),

   // V_REPEAT
   (I_VALUE | I_STMTS),

   // V_WHILE
   (I_VALUE | I_STMTS),

   // V_DO_WHILE
   (I_VALUE | I_STMTS),

   // V_TASK_DECL
   (I_IDENT | I_IDENT2 | I_STMTS | I_DECLS | I_PORTS),

   // V_FUNC_DECL
   (I_IDENT | I_IDENT2 | I_STMTS | I_DECLS | I_TYPE | I_PORTS),

   // V_WAIT
   (I_VALUE | I_STMTS),

   // V_PARAM_DECL
   (I_IDENT | I_VALUE | I_TYPE),

   // V_COND_EXPR
   (I_VALUE | I_LEFT | I_RIGHT),

   // V_REAL
   (I_DVAL),

   // V_CONCAT
   (I_PARAMS | I_VALUE),

   // V_FOR_LOOP
   (I_LEFT | I_VALUE | I_RIGHT | I_STMTS),

   // V_FOR_INIT
   (I_DECLS | I_STMTS),

   // V_FOR_STEP
   (I_STMTS),

   // V_PREFIX
   (I_TARGET | I_SUBKIND),

   // V_POSTFIX
   (I_TARGET | I_SUBKIND),

   // V_LOCALPARAM
   (I_IDENT | I_VALUE | I_TYPE),

   // V_CASE
   (I_SUBKIND | I_VALUE | I_STMTS),

   // V_CASE_ITEM
   (I_PARAMS | I_STMTS),

   // V_INST_LIST
   (I_PARAMS | I_STMTS | I_IDENT),

   // V_PARAM_ASSIGN
   (I_IDENT | I_VALUE),

   // V_INST_BODY
   (I_IDENT | I_IDENT2 | I_PORTS | I_STMTS | I_DECLS),

   // V_PORT_CONN
   (I_IDENT | I_VALUE),

   // V_PART_SELECT
   (I_SUBKIND | I_VALUE | I_LEFT | I_RIGHT),

   // V_IF_GENERATE
   (I_CONDS),

   // V_EVENT_TRIGGER
   (I_IDENT),

   // V_USER_FCALL
   (I_IDENT | I_REF | I_PARAMS),

   // V_UDP_LEVEL
   (I_SUBKIND | I_IVAL),

   // V_UDP_EDGE
   (I_SUBKIND | I_LEFT | I_RIGHT),

   // V_SPECPARAM
   (I_IDENT | I_VALUE),

   // V_FORK
   (I_IDENT | I_DECLS | I_STMTS),

   // V_ATTR_INST
   (0),

   // V_USER_TCALL
   (I_IDENT | I_REF | I_PARAMS),

   // V_VOID_CALL
   (I_VALUE),

   // V_GENVAR_DECL
   (I_IDENT | I_TYPE),

   // V_FOR_GENERATE
   (I_LEFT | I_VALUE | I_RIGHT | I_STMTS),

   // V_DEASSIGN
   (I_TARGET),

   // V_FORCE
   (I_TARGET | I_VALUE),

   // V_RELEASE
   (I_TARGET | I_VALUE),

   // V_DISABLE
   (I_IDENT),

   // V_HIER_REF
   (I_IDENT | I_IDENT2 | I_REF),

   // V_TF_PORT_DECL
   (I_IDENT | I_SUBKIND | I_RANGES | I_TYPE | I_VALUE | I_REF),

   // V_RETURN
   (I_REF | I_VALUE),

   // V_OP_ASSIGN
   (I_TARGET | I_SUBKIND | I_VALUE),

   // V_MEMBER_REF
   (I_VALUE | I_IDENT | I_REF),

   // V_PACKAGE
   (I_DECLS | I_IDENT | I_IDENT2),

   // V_MIN_TYP_MAX
   (I_LEFT | I_VALUE | I_RIGHT),

   // V_PROGRAM
   (I_IDENT | I_STMTS | I_DECLS | I_IDENT2),

   // V_CLASS_DECL
   (I_IDENT | I_IDENT2 | I_DECLS),

   // V_NULL
   (I_TYPE),

   // V_CLASS_NEW
   (I_TYPE | I_PARAMS),

   // V_CONSTRUCTOR
   (I_IDENT | I_PARAMS | I_STMTS | I_DECLS),

   // V_SUPER_CALL
   (I_PARAMS),

   // V_IMPORT_DECL
   (I_REF | I_IDENT),

   // V_NAMESPACE
   (I_DECLS),

   // V_DEFPARAM
   (I_TARGET | I_VALUE),
};

static const char *kind_text_map[V_LAST_NODE_KIND] = {
   "V_MODULE",        "V_PORT_DECL",   "V_REF",           "V_ALWAYS",
   "V_TIMING",        "V_NBASSIGN",    "V_EVENT",         "V_INITIAL",
   "V_BLOCK",         "V_SYS_TCALL",   "V_STRING",        "V_NUMBER",
   "V_NET_DECL",      "V_ASSIGN",      "V_DIMENSION",     "V_IF",
   "V_COND",          "V_VAR_DECL",    "V_DELAY_CONTROL", "V_BINARY",
   "V_BASSIGN",       "V_UNARY",       "V_GATE_INST",     "V_STRENGTH",
   "V_MOD_INST",      "V_BIT_SELECT",  "V_SYS_FCALL",     "V_FOREVER",
   "V_SPECIFY",       "V_PRIMITIVE",   "V_UDP_TABLE",     "V_UDP_ENTRY",
   "V_DATA_TYPE",     "V_TYPE_DECL",   "V_ENUM_DECL",     "V_ENUM_NAME",
   "V_UNION_DECL",    "V_STRUCT_DECL", "V_EVENT_CONTROL", "V_EMPTY",
   "V_REPEAT",        "V_WHILE",       "V_DO_WHILE",      "V_TASK_DECL",
   "V_FUNC_DECL",     "V_WAIT",        "V_PARAM_DECL",    "V_COND_EXPR",
   "V_REAL",          "V_CONCAT",      "V_FOR_LOOP",      "V_FOR_INIT",
   "V_FOR_STEP",      "V_PREFIX",      "V_POSTFIX",       "V_LOCALPARAM",
   "V_CASE",          "V_CASE_ITEM",   "V_INST_LIST",     "V_PARAM_ASSIGN",
   "V_INST_BODY",     "V_PORT_CONN",   "V_PART_SELECT",   "V_IF_GENERATE",
   "V_EVENT_TRIGGER", "V_USER_FCALL",  "V_UDP_LEVEL",     "V_UDP_EDGE",
   "V_SPECPARAM",     "V_FORK",        "V_ATTR_INST",     "V_USER_TCALL",
   "V_VOID_CALL",     "V_GENVAR_DECL", "V_FOR_GENERATE",  "V_DEASSIGN",
   "V_FORCE",         "V_RELEASE",     "V_DISABLE",       "V_HIER_REF",
   "V_TF_PORT_DECL",  "V_RETURN",      "V_OP_ASSIGN",     "V_MEMBER_REF",
   "V_PACKAGE",       "V_MIN_TYP_MAX", "V_PROGRAM",       "V_CLASS_DECL",
   "V_NULL",          "V_CLASS_NEW",   "V_CONSTRUCTOR",   "V_SUPER_CALL",
   "V_IMPORT_DECL",   "V_NAMESPACE",   "V_DEFPARAM",
};

static const change_allowed_t change_allowed[] = {
   { -1, -1 }
};

object_class_t vlog_object = {
   .name           = "vlog",
   .change_allowed = change_allowed,
   .has_map        = has_map,
   .kind_text_map  = kind_text_map,
   .tag            = OBJECT_TAG_VLOG,
   .last_kind      = V_LAST_NODE_KIND,
   .has_loc        = true,
   .gc_roots       = { V_MODULE, V_PRIMITIVE, V_PROGRAM, V_PACKAGE },
   .gc_num_roots   = 4,
};

struct _vlog_node {
   object_t object;
};

static inline vlog_node_t vlog_array_nth(item_t *item, unsigned n)
{
   object_t *o = obj_array_nth(item->obj_array, n);
   return container_of(o, struct _vlog_node, object);
}

static inline void vlog_array_add(item_t *item, vlog_node_t v)
{
   obj_array_add(&(item->obj_array), &(v->object));
}

vlog_node_t vlog_new(vlog_kind_t kind)
{
   object_t *o = object_new(NULL, &vlog_object, kind);
   return container_of(o, struct _vlog_node, object);
}

vlog_kind_t vlog_kind(vlog_node_t v)
{
   return v->object.kind;
}

const char *vlog_kind_str(vlog_kind_t kind)
{
   return kind_text_map[kind];
}

ident_t vlog_ident(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_IDENT);
   assert(item->ident != NULL);
   return item->ident;
}

void vlog_set_ident(vlog_node_t v, ident_t i)
{
   lookup_item(&vlog_object, v, I_IDENT)->ident = i;
}

bool vlog_has_ident(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_IDENT)->ident != NULL;
}

ident_t vlog_ident2(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_IDENT2);
   assert(item->ident != NULL);
   return item->ident;
}

bool vlog_has_ident2(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_IDENT2)->ident != NULL;
}

void vlog_set_ident2(vlog_node_t v, ident_t i)
{
   lookup_item(&vlog_object, v, I_IDENT2)->ident = i;
}

const loc_t *vlog_loc(vlog_node_t v)
{
   assert(v != NULL);
   return &(v->object.loc);
}

void vlog_set_loc(vlog_node_t v, const loc_t *loc)
{
   assert(v != NULL);
   assert(loc != NULL);
   v->object.loc = *loc;
}

vlog_node_t vlog_ref(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_REF);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

bool vlog_has_ref(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_REF)->object != NULL;
}

void vlog_set_ref(vlog_node_t v, vlog_node_t d)
{
   object_t *d_obj = vlog_to_object(d);
   lookup_item(&vlog_object, v, I_REF)->object = d_obj;
   object_write_barrier(&(v->object), d_obj);
}

unsigned vlog_stmts(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_STMTS);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_stmt(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_STMTS);
   return vlog_array_nth(item, n);
}

void vlog_add_stmt(vlog_node_t v, vlog_node_t s)
{
   assert(s != NULL);
   vlog_array_add(lookup_item(&vlog_object, v, I_STMTS), s);
   object_write_barrier(&(v->object), &(s->object));
}

unsigned vlog_ports(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_PORTS);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_port(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_PORTS);
   return vlog_array_nth(item, n);
}

void vlog_add_port(vlog_node_t v, vlog_node_t p)
{
   assert(p != NULL);
   assert(p->object.kind == V_REF || p->object.kind == V_PORT_DECL
          || p->object.kind == V_TF_PORT_DECL);
   vlog_array_add(lookup_item(&vlog_object, v, I_PORTS), p);
   object_write_barrier(&(v->object), &(p->object));
}

unsigned vlog_params(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_PARAMS);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_param(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_PARAMS);
   return vlog_array_nth(item, n);
}

void vlog_add_param(vlog_node_t v, vlog_node_t p)
{
   assert(p != NULL);
   vlog_array_add(lookup_item(&vlog_object, v, I_PARAMS), p);
   object_write_barrier(&(v->object), &(p->object));
}

unsigned vlog_ranges(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_RANGES);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_range(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_RANGES);
   return vlog_array_nth(item, n);
}

void vlog_add_range(vlog_node_t v, vlog_node_t r)
{
   assert(r != NULL);
   assert(r->object.kind == V_DIMENSION);
   vlog_array_add(lookup_item(&vlog_object, v, I_RANGES), r);
   object_write_barrier(&(v->object), &(r->object));
}

unsigned vlog_decls(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_DECLS);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_decl(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_DECLS);
   return vlog_array_nth(item, n);
}

void vlog_add_decl(vlog_node_t v, vlog_node_t d)
{
   assert(d != NULL);
   vlog_array_add(lookup_item(&vlog_object, v, I_DECLS), d);
   object_write_barrier(&(v->object), &(d->object));
}

unsigned vlog_conds(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_CONDS);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_cond(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_CONDS);
   return vlog_array_nth(item, n);
}

void vlog_add_cond(vlog_node_t v, vlog_node_t c)
{
   assert(c != NULL && c->object.kind == V_COND);
   vlog_array_add(lookup_item(&vlog_object, v, I_CONDS), c);
   object_write_barrier(&(v->object), &(c->object));
}

unsigned vlog_subkind(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_SUBKIND)->ival;
}

void vlog_set_subkind(vlog_node_t v, unsigned sub)
{
   lookup_item(&vlog_object, v, I_SUBKIND)->ival = sub;
}

vlog_node_t vlog_value(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_VALUE);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

bool vlog_has_value(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_VALUE)->object != NULL;
}

void vlog_set_value(vlog_node_t v, vlog_node_t e)
{
   lookup_item(&vlog_object, v, I_VALUE)->object = &(e->object);
   object_write_barrier(&(v->object), &(e->object));
}

vlog_node_t vlog_target(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_TARGET);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

void vlog_set_target(vlog_node_t v, vlog_node_t e)
{
   lookup_item(&vlog_object, v, I_TARGET)->object = &(e->object);
   object_write_barrier(&(v->object), &(e->object));
}

vlog_node_t vlog_delay(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_DELAY);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

bool vlog_has_delay(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_DELAY)->object != NULL;
}

void vlog_set_delay(vlog_node_t v, vlog_node_t d)
{
   object_t *d_obj = vlog_to_object(d);
   lookup_item(&vlog_object, v, I_DELAY)->object = d_obj;
   object_write_barrier(&(v->object), d_obj);
}

vlog_node_t vlog_type(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_TYPE);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

bool vlog_has_type(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_TYPE)->object != NULL;
}

void vlog_set_type(vlog_node_t v, vlog_node_t t)
{
   object_t *t_obj = vlog_to_object(t);
   lookup_item(&vlog_object, v, I_TYPE)->object = t_obj;
   object_write_barrier(&(v->object), t_obj);
}

number_t vlog_number(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_NUMBER)->number;
}

void vlog_set_number(vlog_node_t v, number_t n)
{
   lookup_item(&vlog_object, v, I_NUMBER)->number = n;
}

vlog_node_t vlog_left(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_LEFT);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

void vlog_set_left(vlog_node_t v, vlog_node_t e)
{
   lookup_item(&vlog_object, v, I_LEFT)->object = &(e->object);
   object_write_barrier(&(v->object), &(e->object));
}

vlog_node_t vlog_right(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_RIGHT);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

void vlog_set_right(vlog_node_t v, vlog_node_t e)
{
   lookup_item(&vlog_object, v, I_RIGHT)->object = &(e->object);
   object_write_barrier(&(v->object), &(e->object));
}

double vlog_dval(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_DVAL)->dval;
}

void vlog_set_dval(vlog_node_t v, double d)
{
   lookup_item(&vlog_object, v, I_DVAL)->dval = d;
}

int64_t vlog_ival(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_IVAL)->ival;
}

void vlog_set_ival(vlog_node_t v, int64_t i)
{
   lookup_item(&vlog_object, v, I_IVAL)->ival = i;
}

vlog_flags_t vlog_flags(vlog_node_t t)
{
   return lookup_item(&vlog_object, t, I_FLAGS)->ival;
}

void vlog_set_flags(vlog_node_t v, vlog_flags_t mask)
{
   lookup_item(&vlog_object, v, I_FLAGS)->ival |= mask;
}

void vlog_visit(vlog_node_t v, vlog_visit_fn_t fn, void *context)
{
   vlog_visit_only(v, fn, context, V_LAST_NODE_KIND);
}

void vlog_visit_only(vlog_node_t v, vlog_visit_fn_t fn, void *context,
                     vlog_kind_t kind)
{
   assert(v != NULL);

   object_visit_ctx_t ctx = {
      .count      = 0,
      .postorder  = (object_visit_fn_t)fn,
      .preorder   = NULL,
      .context    = context,
      .kind       = kind,
      .tag        = OBJECT_TAG_VLOG,
      .generation = object_next_generation(),
      .deep       = false
   };

   object_visit(&(v->object), &ctx);
}

vlog_node_t vlog_rewrite(vlog_node_t v, vlog_rewrite_fn_t fn, void *context)
{
   object_arena_t *arena = object_arena(&(v->object));
   if (arena_frozen(arena))
      return v;

   object_rewrite_ctx_t ctx = {
      .generation = object_next_generation(),
      .context    = context,
      .arena      = arena,
   };

   ctx.post_fn[OBJECT_TAG_VLOG] = (object_rewrite_post_fn_t)fn;

   object_t *result = object_rewrite(&(v->object), &ctx);
   free(ctx.cache);
   return container_of(result, struct _vlog_node, object);
}

vlog_node_t vlog_copy(vlog_node_t v, vlog_copy_pred_t pred, void *ctx)
{
   object_copy_ctx_t *copy LOCAL = xcalloc_flex(sizeof(object_copy_ctx_t),
                                                1, sizeof(object_t *));
   copy->generation   = object_next_generation();
   copy->pred_context = ctx;
   copy->nroots       = 1;
   copy->roots[0]     = &(v->object);

   copy->should_copy[OBJECT_TAG_VLOG] = (object_copy_pred_t)pred;

   object_copy(copy);

   return container_of(copy->roots[0], struct _vlog_node, object);
}

object_t *vlog_to_object(vlog_node_t v)
{
   return v != NULL ? &(v->object) : NULL;
}

vlog_node_t vlog_from_object(object_t *obj)
{
   if (obj != NULL && obj->tag == OBJECT_TAG_VLOG)
      return container_of(obj, struct _vlog_node, object);
   else
      return NULL;
}

1	//
2	// Copyright (C) 2022-2025 Nick Gasson
3	//
4	// This program is free software: you can redistribute it and/or modify
5	// it under the terms of the GNU General Public License as published by
6	// the Free Software Foundation, either version 3 of the License, or
7	// (at your option) any later version.
8	//
9	// This program is distributed in the hope that it will be useful,
10	// but WITHOUT ANY WARRANTY; without even the implied warranty of
11	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	// GNU General Public License for more details.
13	//
14	// You should have received a copy of the GNU General Public License
15	// along with this program. If not, see <http://www.gnu.org/licenses/>.
16	//
17
18	#include "util.h"
19	#include "vlog/vlog-node.h"
20	#include "vlog/vlog-number.h"
21	#include "object.h"
22
23	#include <string.h>
24	#include <inttypes.h>
25	#include <stdlib.h>
26
27	static const imask_t has_map[V_LAST_NODE_KIND] = {
28	// V_MODULE
29	(I_IDENT \| I_PORTS \| I_STMTS \| I_DECLS \| I_IDENT2),
30
31	// V_PORT_DECL
32	(I_IDENT \| I_SUBKIND \| I_IDENT2 \| I_REF \| I_RANGES \| I_TYPE \| I_VALUE),
33
34	// V_REF
35	(I_IDENT \| I_REF),
36
37	// V_ALWAYS
38	(I_IDENT \| I_SUBKIND \| I_STMTS),
39
40	// V_TIMING
41	(I_VALUE \| I_STMTS),
42
43	// V_NBASSIGN
44	(I_TARGET \| I_VALUE \| I_DELAY),
45
46	// V_EVENT
47	(I_SUBKIND \| I_VALUE),
48
49	// V_INITIAL
50	(I_IDENT \| I_STMTS),
51
52	// V_BLOCK
53	(I_IDENT \| I_DECLS \| I_STMTS),
54
55	// V_SYS_TCALL
56	(I_IDENT \| I_PARAMS),
57
58	// V_STRING
59	(I_NUMBER),
60
61	// V_NUMBER
62	(I_NUMBER),
63
64	// V_NET_DECL
65	(I_IDENT \| I_SUBKIND \| I_TYPE \| I_RANGES \| I_VALUE),
66
67	// V_ASSIGN
68	(I_TARGET \| I_VALUE \| I_IDENT \| I_DELAY),
69
70	// V_DIMENSION
71	(I_SUBKIND \| I_LEFT \| I_RIGHT),
72
73	// V_IF
74	(I_CONDS),
75
76	// V_COND
77	(I_VALUE \| I_STMTS),
78
79	// V_VAR_DECL
80	(I_IDENT \| I_TYPE \| I_RANGES \| I_VALUE),
81
82	// V_DELAY_CONTROL
83	(I_VALUE),
84
85	// V_BINARY
86	(I_LEFT \| I_RIGHT \| I_SUBKIND),
87
88	// V_BASSIGN
89	(I_TARGET \| I_VALUE \| I_DELAY),
90
91	// V_UNARY
92	(I_VALUE \| I_SUBKIND),
93
94	// V_GATE_INST
95	(I_SUBKIND \| I_PARAMS \| I_IDENT \| I_REF \| I_TARGET),
96
97	// V_STRENGTH
98	(I_SUBKIND),
99
100	// V_MOD_INST
101	(I_IDENT \| I_PARAMS),
102
103	// V_BIT_SELECT
104	(I_VALUE \| I_PARAMS),
105
106	// V_SYS_FCALL
107	(I_IDENT \| I_PARAMS),
108
109	// V_FOREVER
110	(I_STMTS),
111
112	// V_SPECIFY
113	(I_DECLS),
114
115	// V_PRIMITIVE
116	(I_IDENT \| I_IDENT2 \| I_PORTS \| I_DECLS \| I_STMTS),
117
118	// V_UDP_TABLE
119	(I_IDENT \| I_PARAMS \| I_SUBKIND \| I_STMTS),
120
121	// V_UDP_ENTRY
122	(I_PARAMS),
123
124	// V_DATA_TYPE
125	(I_SUBKIND \| I_RANGES \| I_FLAGS),
126
127	// V_TYPE_DECL
128	(I_IDENT \| I_TYPE),
129
130	// V_ENUM_DECL
131	(I_IDENT \| I_TYPE \| I_RANGES \| I_DECLS),
132
133	// V_ENUM_NAME
134	(I_IDENT \| I_TYPE \| I_VALUE),
135
136	// V_UNION_DECL
137	(I_IDENT \| I_DECLS),
138
139	// V_STRUCT_DECL
140	(I_IDENT \| I_DECLS),
141
142	// V_EVENT_CONTROL
143	(I_PARAMS),
144
145	// V_EMPTY
146	(0),
147
148	// V_REPEAT
149	(I_VALUE \| I_STMTS),
150
151	// V_WHILE
152	(I_VALUE \| I_STMTS),
153
154	// V_DO_WHILE
155	(I_VALUE \| I_STMTS),
156
157	// V_TASK_DECL
158	(I_IDENT \| I_IDENT2 \| I_STMTS \| I_DECLS \| I_PORTS),
159
160	// V_FUNC_DECL
161	(I_IDENT \| I_IDENT2 \| I_STMTS \| I_DECLS \| I_TYPE \| I_PORTS),
162
163	// V_WAIT
164	(I_VALUE \| I_STMTS),
165
166	// V_PARAM_DECL
167	(I_IDENT \| I_VALUE \| I_TYPE),
168
169	// V_COND_EXPR
170	(I_VALUE \| I_LEFT \| I_RIGHT),
171
172	// V_REAL
173	(I_DVAL),
174
175	// V_CONCAT
176	(I_PARAMS \| I_VALUE),
177
178	// V_FOR_LOOP
179	(I_LEFT \| I_VALUE \| I_RIGHT \| I_STMTS),
180
181	// V_FOR_INIT
182	(I_DECLS \| I_STMTS),
183
184	// V_FOR_STEP
185	(I_STMTS),
186
187	// V_PREFIX
188	(I_TARGET \| I_SUBKIND),
189
190	// V_POSTFIX
191	(I_TARGET \| I_SUBKIND),
192
193	// V_LOCALPARAM
194	(I_IDENT \| I_VALUE \| I_TYPE),
195
196	// V_CASE
197	(I_SUBKIND \| I_VALUE \| I_STMTS),
198
199	// V_CASE_ITEM
200	(I_PARAMS \| I_STMTS),
201
202	// V_INST_LIST
203	(I_PARAMS \| I_STMTS \| I_IDENT),
204
205	// V_PARAM_ASSIGN
206	(I_IDENT \| I_VALUE),
207
208	// V_INST_BODY
209	(I_IDENT \| I_IDENT2 \| I_PORTS \| I_STMTS \| I_DECLS),
210
211	// V_PORT_CONN
212	(I_IDENT \| I_VALUE),
213
214	// V_PART_SELECT
215	(I_SUBKIND \| I_VALUE \| I_LEFT \| I_RIGHT),
216
217	// V_IF_GENERATE
218	(I_CONDS),
219
220	// V_EVENT_TRIGGER
221	(I_IDENT),
222
223	// V_USER_FCALL
224	(I_IDENT \| I_REF \| I_PARAMS),
225
226	// V_UDP_LEVEL
227	(I_SUBKIND \| I_IVAL),
228
229	// V_UDP_EDGE
230	(I_SUBKIND \| I_LEFT \| I_RIGHT),
231
232	// V_SPECPARAM
233	(I_IDENT \| I_VALUE),
234
235	// V_FORK
236	(I_IDENT \| I_DECLS \| I_STMTS),
237
238	// V_ATTR_INST
239	(0),
240
241	// V_USER_TCALL
242	(I_IDENT \| I_REF \| I_PARAMS),
243
244	// V_VOID_CALL
245	(I_VALUE),
246
247	// V_GENVAR_DECL
248	(I_IDENT \| I_TYPE),
249
250	// V_FOR_GENERATE
251	(I_LEFT \| I_VALUE \| I_RIGHT \| I_STMTS),
252
253	// V_DEASSIGN
254	(I_TARGET),
255
256	// V_FORCE
257	(I_TARGET \| I_VALUE),
258
259	// V_RELEASE
260	(I_TARGET \| I_VALUE),
261
262	// V_DISABLE
263	(I_IDENT),
264
265	// V_HIER_REF
266	(I_IDENT \| I_IDENT2 \| I_REF),
267
268	// V_TF_PORT_DECL
269	(I_IDENT \| I_SUBKIND \| I_RANGES \| I_TYPE \| I_VALUE \| I_REF),
270
271	// V_RETURN
272	(I_REF \| I_VALUE),
273
274	// V_OP_ASSIGN
275	(I_TARGET \| I_SUBKIND \| I_VALUE),
276
277	// V_MEMBER_REF
278	(I_VALUE \| I_IDENT \| I_REF),
279
280	// V_PACKAGE
281	(I_DECLS \| I_IDENT \| I_IDENT2),
282
283	// V_MIN_TYP_MAX
284	(I_LEFT \| I_VALUE \| I_RIGHT),
285
286	// V_PROGRAM
287	(I_IDENT \| I_STMTS \| I_DECLS \| I_IDENT2),
288
289	// V_CLASS_DECL
290	(I_IDENT \| I_IDENT2 \| I_DECLS),
291
292	// V_NULL
293	(I_TYPE),
294
295	// V_CLASS_NEW
296	(I_TYPE \| I_PARAMS),
297
298	// V_CONSTRUCTOR
299	(I_IDENT \| I_PARAMS \| I_STMTS \| I_DECLS),
300
301	// V_SUPER_CALL
302	(I_PARAMS),
303
304	// V_IMPORT_DECL
305	(I_REF \| I_IDENT),
306
307	// V_NAMESPACE
308	(I_DECLS),
309
310	// V_DEFPARAM
311	(I_TARGET \| I_VALUE),
312	};
313
314	static const char *kind_text_map[V_LAST_NODE_KIND] = {
315	"V_MODULE", "V_PORT_DECL", "V_REF", "V_ALWAYS",
316	"V_TIMING", "V_NBASSIGN", "V_EVENT", "V_INITIAL",
317	"V_BLOCK", "V_SYS_TCALL", "V_STRING", "V_NUMBER",
318	"V_NET_DECL", "V_ASSIGN", "V_DIMENSION", "V_IF",
319	"V_COND", "V_VAR_DECL", "V_DELAY_CONTROL", "V_BINARY",
320	"V_BASSIGN", "V_UNARY", "V_GATE_INST", "V_STRENGTH",
321	"V_MOD_INST", "V_BIT_SELECT", "V_SYS_FCALL", "V_FOREVER",
322	"V_SPECIFY", "V_PRIMITIVE", "V_UDP_TABLE", "V_UDP_ENTRY",
323	"V_DATA_TYPE", "V_TYPE_DECL", "V_ENUM_DECL", "V_ENUM_NAME",
324	"V_UNION_DECL", "V_STRUCT_DECL", "V_EVENT_CONTROL", "V_EMPTY",
325	"V_REPEAT", "V_WHILE", "V_DO_WHILE", "V_TASK_DECL",
326	"V_FUNC_DECL", "V_WAIT", "V_PARAM_DECL", "V_COND_EXPR",
327	"V_REAL", "V_CONCAT", "V_FOR_LOOP", "V_FOR_INIT",
328	"V_FOR_STEP", "V_PREFIX", "V_POSTFIX", "V_LOCALPARAM",
329	"V_CASE", "V_CASE_ITEM", "V_INST_LIST", "V_PARAM_ASSIGN",
330	"V_INST_BODY", "V_PORT_CONN", "V_PART_SELECT", "V_IF_GENERATE",
331	"V_EVENT_TRIGGER", "V_USER_FCALL", "V_UDP_LEVEL", "V_UDP_EDGE",
332	"V_SPECPARAM", "V_FORK", "V_ATTR_INST", "V_USER_TCALL",
333	"V_VOID_CALL", "V_GENVAR_DECL", "V_FOR_GENERATE", "V_DEASSIGN",
334	"V_FORCE", "V_RELEASE", "V_DISABLE", "V_HIER_REF",
335	"V_TF_PORT_DECL", "V_RETURN", "V_OP_ASSIGN", "V_MEMBER_REF",
336	"V_PACKAGE", "V_MIN_TYP_MAX", "V_PROGRAM", "V_CLASS_DECL",
337	"V_NULL", "V_CLASS_NEW", "V_CONSTRUCTOR", "V_SUPER_CALL",
338	"V_IMPORT_DECL", "V_NAMESPACE", "V_DEFPARAM",
339	};
340
341	static const change_allowed_t change_allowed[] = {
342	{ -1, -1 }
343	};
344
345	object_class_t vlog_object = {
346	.name = "vlog",
347	.change_allowed = change_allowed,
348	.has_map = has_map,
349	.kind_text_map = kind_text_map,
350	.tag = OBJECT_TAG_VLOG,
351	.last_kind = V_LAST_NODE_KIND,
352	.has_loc = true,
353	.gc_roots = { V_MODULE, V_PRIMITIVE, V_PROGRAM, V_PACKAGE },
354	.gc_num_roots = 4,
355	};
356
357	struct _vlog_node {
358	object_t object;
359	};
360
361	static inline vlog_node_t vlog_array_nth(item_t *item, unsigned n)	49,742✔
362	{
363	object_t *o = obj_array_nth(item->obj_array, n);	49,742✔
364	return container_of(o, struct _vlog_node, object);	49,742✔
365	}
366
367	static inline void vlog_array_add(item_t *item, vlog_node_t v)	19,324✔
368	{
369	obj_array_add(&(item->obj_array), &(v->object));	19,324✔
370	}	19,324✔
371
372	vlog_node_t vlog_new(vlog_kind_t kind)	35,485✔
373	{
374	object_t *o = object_new(NULL, &vlog_object, kind);	35,485✔
375	return container_of(o, struct _vlog_node, object);	35,485✔
376	}
377
378	vlog_kind_t vlog_kind(vlog_node_t v)	252,611✔
379	{
380	return v->object.kind;	252,611✔
381	}
382
383	const char *vlog_kind_str(vlog_kind_t kind)	×
384	{
385	return kind_text_map[kind];	×
386	}
387
388	ident_t vlog_ident(vlog_node_t v)	28,827✔
389	{
390	item_t *item = lookup_item(&vlog_object, v, I_IDENT);	28,827✔
391	assert(item->ident != NULL);	28,827✔
392	return item->ident;	28,827✔
393	}
394
395	void vlog_set_ident(vlog_node_t v, ident_t i)	15,434✔
396	{
397	lookup_item(&vlog_object, v, I_IDENT)->ident = i;	15,434✔
398	}	15,434✔
399
400	bool vlog_has_ident(vlog_node_t v)	709✔
401	{
402	return lookup_item(&vlog_object, v, I_IDENT)->ident != NULL;	709✔
403	}
404
405	ident_t vlog_ident2(vlog_node_t v)	1,740✔
406	{
407	item_t *item = lookup_item(&vlog_object, v, I_IDENT2);	1,740✔
408	assert(item->ident != NULL);	1,740✔
409	return item->ident;	1,740✔
410	}
411
412	bool vlog_has_ident2(vlog_node_t v)	40✔
413	{
414	return lookup_item(&vlog_object, v, I_IDENT2)->ident != NULL;	40✔
415	}
416
417	void vlog_set_ident2(vlog_node_t v, ident_t i)	1,440✔
418	{
419	lookup_item(&vlog_object, v, I_IDENT2)->ident = i;	1,440✔
420	}	1,440✔
421
422	const loc_t *vlog_loc(vlog_node_t v)	40,008✔
423	{
424	assert(v != NULL);	40,008✔
425	return &(v->object.loc);	40,008✔
426	}
427
428	void vlog_set_loc(vlog_node_t v, const loc_t *loc)	37,191✔
429	{
430	assert(v != NULL);	37,191✔
431	assert(loc != NULL);	37,191✔
432	v->object.loc = *loc;	37,191✔
433	}	37,191✔
434
435	vlog_node_t vlog_ref(vlog_node_t v)	33,664✔
436	{
437	item_t *item = lookup_item(&vlog_object, v, I_REF);	33,664✔
438	assert(item->object != NULL);	33,664✔
439	return container_of(item->object, struct _vlog_node, object);	33,664✔
440	}
441
442	bool vlog_has_ref(vlog_node_t v)	10,735✔
443	{
444	return lookup_item(&vlog_object, v, I_REF)->object != NULL;	10,735✔
445	}
446
447	void vlog_set_ref(vlog_node_t v, vlog_node_t d)	8,157✔
448	{
449	object_t *d_obj = vlog_to_object(d);	8,157✔
450	lookup_item(&vlog_object, v, I_REF)->object = d_obj;	8,157✔
451	object_write_barrier(&(v->object), d_obj);	8,157✔
452	}	8,157✔
453
454	unsigned vlog_stmts(vlog_node_t v)	8,652✔
455	{
456	item_t *item = lookup_item(&vlog_object, v, I_STMTS);	8,652✔
457	return obj_array_count(item->obj_array);	8,652✔
458	}
459
460	vlog_node_t vlog_stmt(vlog_node_t v, unsigned n)	16,493✔
461	{
462	item_t *item = lookup_item(&vlog_object, v, I_STMTS);	16,493✔
463	return vlog_array_nth(item, n);	16,493✔
464	}
465
466	void vlog_add_stmt(vlog_node_t v, vlog_node_t s)	8,546✔
467	{
468	assert(s != NULL);	8,546✔
469	vlog_array_add(lookup_item(&vlog_object, v, I_STMTS), s);	8,546✔
470	object_write_barrier(&(v->object), &(s->object));	8,546✔
471	}	8,546✔
472
473	unsigned vlog_ports(vlog_node_t v)	2,272✔
474	{
475	item_t *item = lookup_item(&vlog_object, v, I_PORTS);	2,272✔
476	return obj_array_count(item->obj_array);	2,272✔
477	}
478
479	vlog_node_t vlog_port(vlog_node_t v, unsigned n)	3,833✔
480	{
481	item_t *item = lookup_item(&vlog_object, v, I_PORTS);	3,833✔
482	return vlog_array_nth(item, n);	3,833✔
483	}
484
485	void vlog_add_port(vlog_node_t v, vlog_node_t p)	734✔
486	{
487	assert(p != NULL);	734✔
488	assert(p->object.kind == V_REF \|\| p->object.kind == V_PORT_DECL	734✔
489	\|\| p->object.kind == V_TF_PORT_DECL);
490	vlog_array_add(lookup_item(&vlog_object, v, I_PORTS), p);	734✔
491	object_write_barrier(&(v->object), &(p->object));	734✔
492	}	734✔
493
494	unsigned vlog_params(vlog_node_t v)	8,359✔
495	{
496	item_t *item = lookup_item(&vlog_object, v, I_PARAMS);	8,359✔
497	return obj_array_count(item->obj_array);	8,359✔
498	}
499
500	vlog_node_t vlog_param(vlog_node_t v, unsigned n)	10,451✔
501	{
502	item_t *item = lookup_item(&vlog_object, v, I_PARAMS);	10,451✔
503	return vlog_array_nth(item, n);	10,451✔
504	}
505
506	void vlog_add_param(vlog_node_t v, vlog_node_t p)	4,482✔
507	{
508	assert(p != NULL);	4,482✔
509	vlog_array_add(lookup_item(&vlog_object, v, I_PARAMS), p);	4,482✔
510	object_write_barrier(&(v->object), &(p->object));	4,482✔
511	}	4,482✔
512
513	unsigned vlog_ranges(vlog_node_t v)	10,368✔
514	{
515	item_t *item = lookup_item(&vlog_object, v, I_RANGES);	10,368✔
516	return obj_array_count(item->obj_array);	10,368✔
517	}
518
519	vlog_node_t vlog_range(vlog_node_t v, unsigned n)	3,970✔
520	{
521	item_t *item = lookup_item(&vlog_object, v, I_RANGES);	3,970✔
522	return vlog_array_nth(item, n);	3,970✔
523	}
524
525	void vlog_add_range(vlog_node_t v, vlog_node_t r)	823✔
526	{
527	assert(r != NULL);	823✔
528	assert(r->object.kind == V_DIMENSION);	823✔
529	vlog_array_add(lookup_item(&vlog_object, v, I_RANGES), r);	823✔
530	object_write_barrier(&(v->object), &(r->object));	823✔
531	}	823✔
532
533	unsigned vlog_decls(vlog_node_t v)	3,652✔
534	{
535	item_t *item = lookup_item(&vlog_object, v, I_DECLS);	3,652✔
536	return obj_array_count(item->obj_array);	3,652✔
537	}
538
539	vlog_node_t vlog_decl(vlog_node_t v, unsigned n)	13,131✔
540	{
541	item_t *item = lookup_item(&vlog_object, v, I_DECLS);	13,131✔
542	return vlog_array_nth(item, n);	13,131✔
543	}
544
545	void vlog_add_decl(vlog_node_t v, vlog_node_t d)	3,814✔
546	{
547	assert(d != NULL);	3,814✔
548	vlog_array_add(lookup_item(&vlog_object, v, I_DECLS), d);	3,814✔
549	object_write_barrier(&(v->object), &(d->object));	3,814✔
550	}	3,814✔
551
552	unsigned vlog_conds(vlog_node_t v)	1,488✔
553	{
554	item_t *item = lookup_item(&vlog_object, v, I_CONDS);	1,488✔
555	return obj_array_count(item->obj_array);	1,488✔
556	}
557
558	vlog_node_t vlog_cond(vlog_node_t v, unsigned n)	1,864✔
559	{
560	item_t *item = lookup_item(&vlog_object, v, I_CONDS);	1,864✔
561	return vlog_array_nth(item, n);	1,864✔
562	}
563
564	void vlog_add_cond(vlog_node_t v, vlog_node_t c)	925✔
565	{
566	assert(c != NULL && c->object.kind == V_COND);	925✔
567	vlog_array_add(lookup_item(&vlog_object, v, I_CONDS), c);	925✔
568	object_write_barrier(&(v->object), &(c->object));	925✔
569	}	925✔
570
571	unsigned vlog_subkind(vlog_node_t v)	20,637✔
572	{
573	return lookup_item(&vlog_object, v, I_SUBKIND)->ival;	20,637✔
574	}
575
576	void vlog_set_subkind(vlog_node_t v, unsigned sub)	7,036✔
577	{
578	lookup_item(&vlog_object, v, I_SUBKIND)->ival = sub;	7,036✔
579	}	7,036✔
580
581	vlog_node_t vlog_value(vlog_node_t v)	15,615✔
582	{
583	item_t *item = lookup_item(&vlog_object, v, I_VALUE);	15,615✔
584	assert(item->object != NULL);	15,615✔
585	return container_of(item->object, struct _vlog_node, object);	15,615✔
586	}
587
588	bool vlog_has_value(vlog_node_t v)	6,001✔
589	{
590	return lookup_item(&vlog_object, v, I_VALUE)->object != NULL;	6,001✔
591	}
592
593	void vlog_set_value(vlog_node_t v, vlog_node_t e)	6,640✔
594	{
595	lookup_item(&vlog_object, v, I_VALUE)->object = &(e->object);	6,640✔
596	object_write_barrier(&(v->object), &(e->object));	6,640✔
597	}	6,640✔
598
599	vlog_node_t vlog_target(vlog_node_t v)	5,171✔
600	{
601	item_t *item = lookup_item(&vlog_object, v, I_TARGET);	5,171✔
602	assert(item->object != NULL);	5,171✔
603	return container_of(item->object, struct _vlog_node, object);	5,171✔
604	}
605
606	void vlog_set_target(vlog_node_t v, vlog_node_t e)	2,633✔
607	{
608	lookup_item(&vlog_object, v, I_TARGET)->object = &(e->object);	2,633✔
609	object_write_barrier(&(v->object), &(e->object));	2,633✔
610	}	2,633✔
611
612	vlog_node_t vlog_delay(vlog_node_t v)	47✔
613	{
614	item_t *item = lookup_item(&vlog_object, v, I_DELAY);	47✔
615	assert(item->object != NULL);	47✔
616	return container_of(item->object, struct _vlog_node, object);	47✔
617	}
618
619	bool vlog_has_delay(vlog_node_t v)	2,310✔
620	{
621	return lookup_item(&vlog_object, v, I_DELAY)->object != NULL;	2,310✔
622	}
623
624	void vlog_set_delay(vlog_node_t v, vlog_node_t d)	291✔
625	{
626	object_t *d_obj = vlog_to_object(d);	291✔
627	lookup_item(&vlog_object, v, I_DELAY)->object = d_obj;	291✔
628	object_write_barrier(&(v->object), d_obj);	291✔
629	}	291✔
630
631	vlog_node_t vlog_type(vlog_node_t v)	23,454✔
632	{
633	item_t *item = lookup_item(&vlog_object, v, I_TYPE);	23,454✔
634	assert(item->object != NULL);	23,454✔
635	return container_of(item->object, struct _vlog_node, object);	23,454✔
636	}
637
638	bool vlog_has_type(vlog_node_t v)	1✔
639	{
640	return lookup_item(&vlog_object, v, I_TYPE)->object != NULL;	1✔
641	}
642
643	void vlog_set_type(vlog_node_t v, vlog_node_t t)	2,383✔
644	{
645	object_t *t_obj = vlog_to_object(t);	2,383✔
646	lookup_item(&vlog_object, v, I_TYPE)->object = t_obj;	2,383✔
647	object_write_barrier(&(v->object), t_obj);	2,383✔
648	}	2,383✔
649
650	number_t vlog_number(vlog_node_t v)	15,113✔
651	{
652	return lookup_item(&vlog_object, v, I_NUMBER)->number;	15,113✔
653	}
654
655	void vlog_set_number(vlog_node_t v, number_t n)	7,608✔
656	{
657	lookup_item(&vlog_object, v, I_NUMBER)->number = n;	7,608✔
658	}	7,608✔
659
660	vlog_node_t vlog_left(vlog_node_t v)	11,944✔
661	{
662	item_t *item = lookup_item(&vlog_object, v, I_LEFT);	11,944✔
663	assert(item->object != NULL);	11,944✔
664	return container_of(item->object, struct _vlog_node, object);	11,944✔
665	}
666
667	void vlog_set_left(vlog_node_t v, vlog_node_t e)	3,205✔
668	{
669	lookup_item(&vlog_object, v, I_LEFT)->object = &(e->object);	3,205✔
670	object_write_barrier(&(v->object), &(e->object));	3,205✔
671	}	3,205✔
672
673	vlog_node_t vlog_right(vlog_node_t v)	11,713✔
674	{
675	item_t *item = lookup_item(&vlog_object, v, I_RIGHT);	11,713✔
676	assert(item->object != NULL);	11,713✔
677	return container_of(item->object, struct _vlog_node, object);	11,713✔
678	}
679
680	void vlog_set_right(vlog_node_t v, vlog_node_t e)	3,205✔
681	{
682	lookup_item(&vlog_object, v, I_RIGHT)->object = &(e->object);	3,205✔
683	object_write_barrier(&(v->object), &(e->object));	3,205✔
684	}	3,205✔
685
686	double vlog_dval(vlog_node_t v)	19✔
687	{
688	return lookup_item(&vlog_object, v, I_DVAL)->dval;	19✔
689	}
690
691	void vlog_set_dval(vlog_node_t v, double d)	48✔
692	{
693	lookup_item(&vlog_object, v, I_DVAL)->dval = d;	48✔
694	}	48✔
695
696	int64_t vlog_ival(vlog_node_t v)	472✔
697	{
698	return lookup_item(&vlog_object, v, I_IVAL)->ival;	472✔
699	}
700
701	void vlog_set_ival(vlog_node_t v, int64_t i)	483✔
702	{
703	lookup_item(&vlog_object, v, I_IVAL)->ival = i;	483✔
704	}	483✔
705
706	vlog_flags_t vlog_flags(vlog_node_t t)	3,208✔
707	{
708	return lookup_item(&vlog_object, t, I_FLAGS)->ival;	3,208✔
709	}
710
711	void vlog_set_flags(vlog_node_t v, vlog_flags_t mask)	261✔
712	{
713	lookup_item(&vlog_object, v, I_FLAGS)->ival \|= mask;	261✔
714	}	261✔
715
UNCOV 716	void vlog_visit(vlog_node_t v, vlog_visit_fn_t fn, void *context)	×
717	{
718	vlog_visit_only(v, fn, context, V_LAST_NODE_KIND);	×
UNCOV 719	}	×
720
721	void vlog_visit_only(vlog_node_t v, vlog_visit_fn_t fn, void *context,	4✔
722	vlog_kind_t kind)
723	{
724	assert(v != NULL);	4✔
725
726	object_visit_ctx_t ctx = {	4✔
727	.count = 0,
728	.postorder = (object_visit_fn_t)fn,
729	.preorder = NULL,
730	.context = context,
731	.kind = kind,
732	.tag = OBJECT_TAG_VLOG,
733	.generation = object_next_generation(),	4✔
734	.deep = false
735	};
736
737	object_visit(&(v->object), &ctx);	4✔
738	}	4✔
739
740	vlog_node_t vlog_rewrite(vlog_node_t v, vlog_rewrite_fn_t fn, void *context)	1,257✔
741	{
742	object_arena_t *arena = object_arena(&(v->object));	1,257✔
743	if (arena_frozen(arena))	1,257✔
744	return v;
745
746	object_rewrite_ctx_t ctx = {	1,257✔
747	.generation = object_next_generation(),	1,257✔
748	.context = context,
749	.arena = arena,
750	};
751
752	ctx.post_fn[OBJECT_TAG_VLOG] = (object_rewrite_post_fn_t)fn;	1,257✔
753
754	object_t *result = object_rewrite(&(v->object), &ctx);	1,257✔
755	free(ctx.cache);	1,257✔
756	return container_of(result, struct _vlog_node, object);	1,257✔
757	}
758
759	vlog_node_t vlog_copy(vlog_node_t v, vlog_copy_pred_t pred, void *ctx)	441✔
760	{
761	object_copy_ctx_t *copy LOCAL = xcalloc_flex(sizeof(object_copy_ctx_t),	441✔
762	1, sizeof(object_t *));
763	copy->generation = object_next_generation();	441✔
764	copy->pred_context = ctx;	441✔
765	copy->nroots = 1;	441✔
766	copy->roots[0] = &(v->object);	441✔
767
768	copy->should_copy[OBJECT_TAG_VLOG] = (object_copy_pred_t)pred;	441✔
769
770	object_copy(copy);	441✔
771
772	return container_of(copy->roots[0], struct _vlog_node, object);	441✔
773	}
774
775	object_t *vlog_to_object(vlog_node_t v)	14,509✔
776	{
777	return v != NULL ? &(v->object) : NULL;	14,509✔
778	}
779
780	vlog_node_t vlog_from_object(object_t *obj)	14,998✔
781	{
782	if (obj != NULL && obj->tag == OBJECT_TAG_VLOG)	14,998✔
783	return container_of(obj, struct _vlog_node, object);
784	else
785	return NULL;	11,819✔
786	}

nickg / nvc / 21689761474

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous