12966946246

Committed 25 Jan 2025 05:19PM UTC coverage: 92.172% (-0.01%) from 92.184%

Build # 12966946246

Build Type

push

github

Committed by

nickg

Commit Message

Only compact objects when writing to disk

Run Details

96 of 103 new or added lines in 13 files covered. (93.2%)

199 existing lines in 11 files now uncovered.

64134 of 69581 relevant lines covered (92.17%)

520717.44 hits per line

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

96.33

/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),

   // V_REF
   (I_IDENT | I_REF),

   // V_ALWAYS
   (I_IDENT | 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_SEQ_BLOCK
   (I_IDENT | I_STMTS),

   // V_SYS_TCALL
   (I_IDENT | I_PARAMS),

   // V_STRING
   (I_TEXT),

   // 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_SUBKIND | 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_IDENT2 | I_PARAMS),

   // V_BIT_SELECT
   (I_IDENT | I_REF | I_PARAMS),

   // V_SYS_FCALL
   (I_IDENT | I_PARAMS),

   // V_FOREVER
   (I_STMTS),

   // V_SPECIFY
   (0),

   // 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_TEXT),

   // V_DATA_TYPE
   (I_SUBKIND | I_RANGES),

   // 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),

   // 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_STMTS | I_DECLS),

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

   // 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),

   // 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),
};

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_SEQ_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",
};

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 },
   .gc_num_roots   = 2
};

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;
}

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)
{
   lookup_item(&vlog_object, v, I_REF)->object = &(d->object);
   object_write_barrier(&(v->object), &(d->object));
}

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);
   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)
{
   lookup_item(&vlog_object, v, I_DELAY)->object = &(d->object);
   object_write_barrier(&(v->object), &(d->object));
}

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)
{
   lookup_item(&vlog_object, v, I_TYPE)->object = &(t->object);
   object_write_barrier(&(v->object), &(t->object));
}

const char *vlog_text(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_TEXT);
   assert(item->text != NULL);
   return item->text;
}

void vlog_set_text(vlog_node_t v, const char *text)
{
   lookup_item(&vlog_object, v, I_TEXT)->text = xstrdup(text);
}

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;
}

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);
}

object_t *vlog_to_object(vlog_node_t v)
{
   return &(v->object);
}

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;
}

void vlog_locus(vlog_node_t v, ident_t *unit, ptrdiff_t *offset)
{
   assert(v != NULL);
   object_locus(&(v->object), unit, offset);
}

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),
33
34	// V_REF
35	(I_IDENT \| I_REF),
36
37	// V_ALWAYS
38	(I_IDENT \| 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_SEQ_BLOCK
53	(I_IDENT \| I_STMTS),
54
55	// V_SYS_TCALL
56	(I_IDENT \| I_PARAMS),
57
58	// V_STRING
59	(I_TEXT),
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_SUBKIND \| 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_IDENT2 \| I_PARAMS),
102
103	// V_BIT_SELECT
104	(I_IDENT \| I_REF \| I_PARAMS),
105
106	// V_SYS_FCALL
107	(I_IDENT \| I_PARAMS),
108
109	// V_FOREVER
110	(I_STMTS),
111
112	// V_SPECIFY
113	(0),
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_TEXT),
123
124	// V_DATA_TYPE
125	(I_SUBKIND \| I_RANGES),
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),
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_STMTS \| I_DECLS),
159
160	// V_FUNC_DECL
161	(I_IDENT \| I_STMTS \| I_DECLS \| I_TYPE),
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),
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
194	static const char *kind_text_map[V_LAST_NODE_KIND] = {
195	"V_MODULE", "V_PORT_DECL", "V_REF", "V_ALWAYS",
196	"V_TIMING", "V_NBASSIGN", "V_EVENT", "V_INITIAL",
197	"V_SEQ_BLOCK", "V_SYS_TCALL", "V_STRING", "V_NUMBER",
198	"V_NET_DECL", "V_ASSIGN", "V_DIMENSION", "V_IF",
199	"V_COND", "V_VAR_DECL", "V_DELAY_CONTROL", "V_BINARY",
200	"V_BASSIGN", "V_UNARY", "V_GATE_INST", "V_STRENGTH",
201	"V_MOD_INST", "V_BIT_SELECT", "V_SYS_FCALL", "V_FOREVER",
202	"V_SPECIFY", "V_PRIMITIVE", "V_UDP_TABLE", "V_UDP_ENTRY",
203	"V_DATA_TYPE", "V_TYPE_DECL", "V_ENUM_DECL", "V_ENUM_NAME",
204	"V_UNION_DECL", "V_STRUCT_DECL", "V_EVENT_CONTROL", "V_EMPTY",
205	"V_REPEAT", "V_WHILE", "V_DO_WHILE", "V_TASK_DECL",
206	"V_FUNC_DECL", "V_WAIT", "V_PARAM_DECL", "V_COND_EXPR",
207	"V_REAL", "V_CONCAT", "V_FOR_LOOP", "V_FOR_INIT",
208	"V_FOR_STEP", "V_PREFIX", "V_POSTFIX",
209	};
210
211	static const change_allowed_t change_allowed[] = {
212	{ -1, -1 }
213	};
214
215	object_class_t vlog_object = {
216	.name = "vlog",
217	.change_allowed = change_allowed,
218	.has_map = has_map,
219	.kind_text_map = kind_text_map,
220	.tag = OBJECT_TAG_VLOG,
221	.last_kind = V_LAST_NODE_KIND,
222	.has_loc = true,
223	.gc_roots = { V_MODULE, V_PRIMITIVE },
224	.gc_num_roots = 2
225	};
226
227	struct _vlog_node {
228	object_t object;
229	};
230
231	static inline vlog_node_t vlog_array_nth(item_t *item, unsigned n)	7,731✔
232	{
233	object_t *o = obj_array_nth(item->obj_array, n);	7,731✔
234	return container_of(o, struct _vlog_node, object);	7,731✔
235	}
236
237	static inline void vlog_array_add(item_t *item, vlog_node_t v)	3,302✔
238	{
239	obj_array_add(&(item->obj_array), &(v->object));	3,302✔
240	}	3,302✔
241
242	vlog_node_t vlog_new(vlog_kind_t kind)	5,885✔
243	{
244	object_t *o = object_new(NULL, &vlog_object, kind);	5,885✔
245	return container_of(o, struct _vlog_node, object);	5,885✔
246	}
247
248	vlog_kind_t vlog_kind(vlog_node_t v)	26,003✔
249	{
250	return v->object.kind;	26,003✔
251	}
252
253	const char *vlog_kind_str(vlog_kind_t kind)	×
254	{
255	return kind_text_map[kind];	×
256	}
257
258	ident_t vlog_ident(vlog_node_t v)	4,541✔
259	{
260	item_t *item = lookup_item(&vlog_object, v, I_IDENT);	4,541✔
261	assert(item->ident != NULL);	4,541✔
262	return item->ident;	4,541✔
263	}
264
265	void vlog_set_ident(vlog_node_t v, ident_t i)	2,664✔
266	{
267	lookup_item(&vlog_object, v, I_IDENT)->ident = i;	2,664✔
268	}	2,664✔
269
270	bool vlog_has_ident(vlog_node_t v)	32✔
271	{
272	return lookup_item(&vlog_object, v, I_IDENT)->ident != NULL;	32✔
273	}
274
275	ident_t vlog_ident2(vlog_node_t v)	205✔
276	{
277	item_t *item = lookup_item(&vlog_object, v, I_IDENT2);	205✔
278	assert(item->ident != NULL);	205✔
279	return item->ident;	205✔
280	}
281
282	void vlog_set_ident2(vlog_node_t v, ident_t i)	312✔
283	{
284	lookup_item(&vlog_object, v, I_IDENT2)->ident = i;	312✔
285	}	312✔
286
287	const loc_t *vlog_loc(vlog_node_t v)	4,266✔
288	{
289	assert(v != NULL);	4,266✔
290	return &(v->object.loc);	4,266✔
291	}
292
293	void vlog_set_loc(vlog_node_t v, const loc_t *loc)	6,386✔
294	{
295	assert(v != NULL);	6,386✔
296	assert(loc != NULL);	6,386✔
297	v->object.loc = *loc;	6,386✔
298	}	6,386✔
299
300	vlog_node_t vlog_ref(vlog_node_t v)	2,545✔
301	{
302	item_t *item = lookup_item(&vlog_object, v, I_REF);	2,545✔
303	assert(item->object != NULL);	2,545✔
304	return container_of(item->object, struct _vlog_node, object);	2,545✔
305	}
306
307	bool vlog_has_ref(vlog_node_t v)	919✔
308	{
309	return lookup_item(&vlog_object, v, I_REF)->object != NULL;	919✔
310	}
311
312	void vlog_set_ref(vlog_node_t v, vlog_node_t d)	1,330✔
313	{
314	lookup_item(&vlog_object, v, I_REF)->object = &(d->object);	1,330✔
315	object_write_barrier(&(v->object), &(d->object));	1,330✔
316	}	1,330✔
317
318	unsigned vlog_stmts(vlog_node_t v)	1,628✔
319	{
320	item_t *item = lookup_item(&vlog_object, v, I_STMTS);	1,628✔
321	return obj_array_count(item->obj_array);	1,628✔
322	}
323
324	vlog_node_t vlog_stmt(vlog_node_t v, unsigned n)	3,048✔
325	{
326	item_t *item = lookup_item(&vlog_object, v, I_STMTS);	3,048✔
327	return vlog_array_nth(item, n);	3,048✔
328	}
329
330	void vlog_add_stmt(vlog_node_t v, vlog_node_t s)	1,497✔
331	{
332	assert(s != NULL);	1,497✔
333	vlog_array_add(lookup_item(&vlog_object, v, I_STMTS), s);	1,497✔
334	object_write_barrier(&(v->object), &(s->object));	1,497✔
335	}	1,497✔
336
337	unsigned vlog_ports(vlog_node_t v)	325✔
338	{
339	item_t *item = lookup_item(&vlog_object, v, I_PORTS);	325✔
340	return obj_array_count(item->obj_array);	325✔
341	}
342
343	vlog_node_t vlog_port(vlog_node_t v, unsigned n)	410✔
344	{
345	item_t *item = lookup_item(&vlog_object, v, I_PORTS);	410✔
346	return vlog_array_nth(item, n);	410✔
347	}
348
349	void vlog_add_port(vlog_node_t v, vlog_node_t p)	172✔
350	{
351	assert(p != NULL);	172✔
352	assert(p->object.kind == V_REF);	172✔
353	vlog_array_add(lookup_item(&vlog_object, v, I_PORTS), p);	172✔
354	object_write_barrier(&(v->object), &(p->object));	172✔
355	}	172✔
356
357	unsigned vlog_params(vlog_node_t v)	1,448✔
358	{
359	item_t *item = lookup_item(&vlog_object, v, I_PARAMS);	1,448✔
360	return obj_array_count(item->obj_array);	1,448✔
361	}
362
363	vlog_node_t vlog_param(vlog_node_t v, unsigned n)	2,223✔
364	{
365	item_t *item = lookup_item(&vlog_object, v, I_PARAMS);	2,223✔
366	return vlog_array_nth(item, n);	2,223✔
367	}
368
369	void vlog_add_param(vlog_node_t v, vlog_node_t p)	890✔
370	{
371	assert(p != NULL);	890✔
372	vlog_array_add(lookup_item(&vlog_object, v, I_PARAMS), p);	890✔
373	object_write_barrier(&(v->object), &(p->object));	890✔
374	}	890✔
375
376	unsigned vlog_ranges(vlog_node_t v)	2,907✔
377	{
378	item_t *item = lookup_item(&vlog_object, v, I_RANGES);	2,907✔
379	return obj_array_count(item->obj_array);	2,907✔
380	}
381
382	vlog_node_t vlog_range(vlog_node_t v, unsigned n)	289✔
383	{
384	item_t *item = lookup_item(&vlog_object, v, I_RANGES);	289✔
385	return vlog_array_nth(item, n);	289✔
386	}
387
388	void vlog_add_range(vlog_node_t v, vlog_node_t r)	46✔
389	{
390	assert(r != NULL);	46✔
391	assert(r->object.kind == V_DIMENSION);	46✔
392	vlog_array_add(lookup_item(&vlog_object, v, I_RANGES), r);	46✔
393	object_write_barrier(&(v->object), &(r->object));	46✔
394	}	46✔
395
396	unsigned vlog_decls(vlog_node_t v)	356✔
397	{
398	item_t *item = lookup_item(&vlog_object, v, I_DECLS);	356✔
399	return obj_array_count(item->obj_array);	356✔
400	}
401
402	vlog_node_t vlog_decl(vlog_node_t v, unsigned n)	1,450✔
403	{
404	item_t *item = lookup_item(&vlog_object, v, I_DECLS);	1,450✔
405	return vlog_array_nth(item, n);	1,450✔
406	}
407
408	void vlog_add_decl(vlog_node_t v, vlog_node_t d)	534✔
409	{
410	assert(d != NULL);	534✔
411	vlog_array_add(lookup_item(&vlog_object, v, I_DECLS), d);	534✔
412	object_write_barrier(&(v->object), &(d->object));	534✔
413	}	534✔
414
415	unsigned vlog_conds(vlog_node_t v)	236✔
416	{
417	item_t *item = lookup_item(&vlog_object, v, I_CONDS);	236✔
418	return obj_array_count(item->obj_array);	236✔
419	}
420
421	vlog_node_t vlog_cond(vlog_node_t v, unsigned n)	311✔
422	{
423	item_t *item = lookup_item(&vlog_object, v, I_CONDS);	311✔
424	return vlog_array_nth(item, n);	311✔
425	}
426
427	void vlog_add_cond(vlog_node_t v, vlog_node_t c)	163✔
428	{
429	assert(c != NULL && c->object.kind == V_COND);	163✔
430	vlog_array_add(lookup_item(&vlog_object, v, I_CONDS), c);	163✔
431	object_write_barrier(&(v->object), &(c->object));	163✔
432	}	163✔
433
434	unsigned vlog_subkind(vlog_node_t v)	838✔
435	{
436	return lookup_item(&vlog_object, v, I_SUBKIND)->ival;	838✔
437	}
438
439	void vlog_set_subkind(vlog_node_t v, unsigned sub)	1,236✔
440	{
441	lookup_item(&vlog_object, v, I_SUBKIND)->ival = sub;	1,236✔
442	}	1,236✔
443
444	vlog_node_t vlog_value(vlog_node_t v)	2,055✔
445	{
446	item_t *item = lookup_item(&vlog_object, v, I_VALUE);	2,055✔
447	assert(item->object != NULL);	2,055✔
448	return container_of(item->object, struct _vlog_node, object);	2,055✔
449	}
450
451	bool vlog_has_value(vlog_node_t v)	468✔
452	{
453	return lookup_item(&vlog_object, v, I_VALUE)->object != NULL;	468✔
454	}
455
456	void vlog_set_value(vlog_node_t v, vlog_node_t e)	1,036✔
457	{
458	lookup_item(&vlog_object, v, I_VALUE)->object = &(e->object);	1,036✔
459	object_write_barrier(&(v->object), &(e->object));	1,036✔
460	}	1,036✔
461
462	vlog_node_t vlog_target(vlog_node_t v)	814✔
463	{
464	item_t *item = lookup_item(&vlog_object, v, I_TARGET);	814✔
465	assert(item->object != NULL);	814✔
466	return container_of(item->object, struct _vlog_node, object);	814✔
467	}
468
469	void vlog_set_target(vlog_node_t v, vlog_node_t e)	389✔
470	{
471	lookup_item(&vlog_object, v, I_TARGET)->object = &(e->object);	389✔
472	object_write_barrier(&(v->object), &(e->object));	389✔
473	}	389✔
474
475	vlog_node_t vlog_delay(vlog_node_t v)	74✔
476	{
477	item_t *item = lookup_item(&vlog_object, v, I_DELAY);	74✔
478	assert(item->object != NULL);	74✔
479	return container_of(item->object, struct _vlog_node, object);	74✔
480	}
481
482	bool vlog_has_delay(vlog_node_t v)	557✔
483	{
484	return lookup_item(&vlog_object, v, I_DELAY)->object != NULL;	557✔
485	}
486
487	void vlog_set_delay(vlog_node_t v, vlog_node_t d)	38✔
488	{
489	lookup_item(&vlog_object, v, I_DELAY)->object = &(d->object);	38✔
490	object_write_barrier(&(v->object), &(d->object));	38✔
491	}	38✔
492
493	vlog_node_t vlog_type(vlog_node_t v)	2,019✔
494	{
495	item_t *item = lookup_item(&vlog_object, v, I_TYPE);	2,019✔
496	assert(item->object != NULL);	2,019✔
497	return container_of(item->object, struct _vlog_node, object);	2,019✔
498	}
499
500	bool vlog_has_type(vlog_node_t v)	×
501	{
502	return lookup_item(&vlog_object, v, I_TYPE)->object != NULL;	×
503	}
504
505	void vlog_set_type(vlog_node_t v, vlog_node_t t)	533✔
506	{
507	lookup_item(&vlog_object, v, I_TYPE)->object = &(t->object);	533✔
508	object_write_barrier(&(v->object), &(t->object));	533✔
509	}	533✔
510
511	const char *vlog_text(vlog_node_t v)	543✔
512	{
513	item_t *item = lookup_item(&vlog_object, v, I_TEXT);	543✔
514	assert(item->text != NULL);	543✔
515	return item->text;	543✔
516	}
517
518	void vlog_set_text(vlog_node_t v, const char *text)	397✔
519	{
520	lookup_item(&vlog_object, v, I_TEXT)->text = xstrdup(text);	397✔
521	}	397✔
522
523	number_t vlog_number(vlog_node_t v)	1,097✔
524	{
525	return lookup_item(&vlog_object, v, I_NUMBER)->number;	1,097✔
526	}
527
528	void vlog_set_number(vlog_node_t v, number_t n)	720✔
529	{
530	lookup_item(&vlog_object, v, I_NUMBER)->number = n;	720✔
531	}	720✔
532
533	vlog_node_t vlog_left(vlog_node_t v)	676✔
534	{
535	item_t *item = lookup_item(&vlog_object, v, I_LEFT);	676✔
536	assert(item->object != NULL);	676✔
537	return container_of(item->object, struct _vlog_node, object);	676✔
538	}
539
540	void vlog_set_left(vlog_node_t v, vlog_node_t e)	265✔
541	{
542	lookup_item(&vlog_object, v, I_LEFT)->object = &(e->object);	265✔
543	object_write_barrier(&(v->object), &(e->object));	265✔
544	}	265✔
545
546	vlog_node_t vlog_right(vlog_node_t v)	676✔
547	{
548	item_t *item = lookup_item(&vlog_object, v, I_RIGHT);	676✔
549	assert(item->object != NULL);	676✔
550	return container_of(item->object, struct _vlog_node, object);	676✔
551	}
552
553	void vlog_set_right(vlog_node_t v, vlog_node_t e)	265✔
554	{
555	lookup_item(&vlog_object, v, I_RIGHT)->object = &(e->object);	265✔
556	object_write_barrier(&(v->object), &(e->object));	265✔
557	}	265✔
558
559	double vlog_dval(vlog_node_t v)	1✔
560	{
561	return lookup_item(&vlog_object, v, I_DVAL)->dval;	1✔
562	}
563
564	void vlog_set_dval(vlog_node_t v, double d)	6✔
565	{
566	lookup_item(&vlog_object, v, I_DVAL)->dval = d;	6✔
567	}	6✔
568
569	void vlog_visit(vlog_node_t v, vlog_visit_fn_t fn, void *context)	171✔
570	{
571	vlog_visit_only(v, fn, context, V_LAST_NODE_KIND);	171✔
572	}	171✔
573
574	void vlog_visit_only(vlog_node_t v, vlog_visit_fn_t fn, void *context,	171✔
575	vlog_kind_t kind)
576	{
577	assert(v != NULL);	171✔
578
579	object_visit_ctx_t ctx = {	171✔
580	.count = 0,
581	.postorder = (object_visit_fn_t)fn,
582	.preorder = NULL,
583	.context = context,
584	.kind = kind,
585	.tag = OBJECT_TAG_VLOG,
586	.generation = object_next_generation(),	171✔
587	.deep = false
588	};
589
590	object_visit(&(v->object), &ctx);	171✔
591	}	171✔
592
593	vlog_node_t vlog_rewrite(vlog_node_t v, vlog_rewrite_fn_t fn, void *context)	92✔
594	{
595	object_arena_t *arena = object_arena(&(v->object));	92✔
596	if (arena_frozen(arena))	92✔
597	return v;
598
599	object_rewrite_ctx_t ctx = {	92✔
600	.generation = object_next_generation(),	92✔
601	.context = context,
602	.arena = arena,
603	};
604
605	ctx.post_fn[OBJECT_TAG_VLOG] = (object_rewrite_post_fn_t)fn;	92✔
606
607	object_t *result = object_rewrite(&(v->object), &ctx);	92✔
608	free(ctx.cache);	92✔
609	return container_of(result, struct _vlog_node, object);	92✔
610	}
611
612	object_t *vlog_to_object(vlog_node_t v)	818✔
613	{
614	return &(v->object);	818✔
615	}
616
617	vlog_node_t vlog_from_object(object_t *obj)	4,301✔
618	{
619	if (obj != NULL && obj->tag == OBJECT_TAG_VLOG)	4,301✔
620	return container_of(obj, struct _vlog_node, object);
621	else
622	return NULL;	4,114✔
623	}
624
UNCOV 625	void vlog_locus(vlog_node_t v, ident_t unit, ptrdiff_t offset)	×
626	{
UNCOV 627	assert(v != NULL);	×
UNCOV 628	object_locus(&(v->object), unit, offset);	×
UNCOV 629	}	×

nickg / nvc / 12966946246

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