13798777898

Committed 11 Mar 2025 08:20PM UTC coverage: 92.333% (+0.02%) from 92.318%

Build # 13798777898

Build Type

push

github

Committed by

nickg

Commit Message

Implement __FILE__ and __LINE__ in Verilog preprocessor

Run Details

3 of 3 new or added lines in 1 file covered. (100.0%)

68 existing lines in 2 files now uncovered.

68139 of 73797 relevant lines covered (92.33%)

432233.27 hits per line

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

95.86

/src/vlog/vlog-dump.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 "common.h"
#include "ident.h"
#include "vlog/vlog-node.h"
#include "vlog/vlog-number.h"
#include "vlog/vlog-phase.h"

#include <ctype.h>

static inline void tab(int indent)
{
   print_syntax("%*s", indent, "");
}

static void vlog_dump_paren(vlog_node_t v, int indent)
{
   switch (vlog_kind(v)) {
   case V_REF:
   case V_BIT_SELECT:
   case V_NUMBER:
      vlog_dump(v, indent);
      break;
   default:
      print_syntax("(");
      vlog_dump(v, indent);
      print_syntax(")");
   }
}

static void vlog_dump_module(vlog_node_t v, int indent)
{
   print_syntax("#module %s", istr(vlog_ident2(v)));

   const int nports = vlog_ports(v);
   if (nports > 0) {
      print_syntax(" (");
      for (int i = 0; i < nports; i++) {
         if (i > 0) print_syntax(", ");
         vlog_dump(vlog_port(v, i), 0);
      }
      print_syntax(")");
   }

   print_syntax(";\n");

   const int ndecls = vlog_decls(v);
   for (int i = 0; i < ndecls; i++)
      vlog_dump(vlog_decl(v, i), indent + 2);

   const int nstmts = vlog_stmts(v);
   for (int i = 0; i < nstmts; i++)
      vlog_dump(vlog_stmt(v, i), indent + 2);

   print_syntax("#endmodule // %s\n\n", istr(vlog_ident2(v)));
}

static void vlog_dump_primitive(vlog_node_t v, int indent)
{
   print_syntax("#primitive %s", istr(vlog_ident2(v)));

   const int nports = vlog_ports(v);
   if (nports > 0) {
      print_syntax(" (");
      for (int i = 0; i < nports; i++) {
         if (i > 0) print_syntax(", ");
         vlog_dump(vlog_port(v, i), 0);
      }
      print_syntax(")");
   }

   print_syntax(";\n");

   const int ndecls = vlog_decls(v);
   for (int i = 0; i < ndecls; i++)
      vlog_dump(vlog_decl(v, i), indent + 2);

   const int nstmts = vlog_stmts(v);
   for (int i = 0; i < nstmts; i++)
      vlog_dump(vlog_stmt(v, i), indent + 2);

   print_syntax("#endprimitive // %s\n\n", istr(vlog_ident2(v)));
}

static void vlog_dump_udp_entry(vlog_node_t v, int indent)
{
   tab(indent);
   print_syntax("%s;\n", vlog_text(v));
}

static void vlog_dump_udp_table(vlog_node_t v, int indent)
{
   tab(indent);
   print_syntax("#table\n");

   const int nparams = vlog_params(v);
   for (int i = 0; i < nparams; i++)
      vlog_dump(vlog_param(v, i), indent + 2);

   tab(indent);
   print_syntax("#endtable\n");
}

static void vlog_dump_port_decl(vlog_node_t v, int indent)
{
   tab(indent);

   switch (vlog_subkind(v)) {
   case V_PORT_INPUT: print_syntax("#input"); break;
   case V_PORT_INOUT: print_syntax("#inout"); break;
   case V_PORT_OUTPUT: print_syntax("#output"); break;
   }

   print_syntax(" %s;\n", istr(vlog_ident(v)));
}

static void vlog_dump_dimensions(vlog_node_t v, int indent)
{
   const int ndims = vlog_ranges(v);
   int dim = 0;
   for (; dim < ndims; dim++) {
      vlog_node_t d = vlog_range(v, dim);
      print_syntax(" [");
      vlog_dump(vlog_left(d), indent);
      print_syntax(":");
      vlog_dump(vlog_right(d), indent);
      print_syntax("]");
   }
}

static void vlog_dump_net_decl(vlog_node_t v, int indent)
{
   tab(indent);

   switch (vlog_subkind(v)) {
   case V_NET_WIRE: print_syntax("#wire "); break;
   }

   vlog_dump(vlog_type(v), indent);
   print_syntax(" %s", istr(vlog_ident(v)));
   vlog_dump_dimensions(v, indent);
   print_syntax(";\n");
}

static void vlog_dump_var_decl(vlog_node_t v, int indent)
{
   tab(indent);

   vlog_dump(vlog_type(v), indent);
   print_syntax(" %s", istr(vlog_ident(v)));
   vlog_dump_dimensions(v, indent);

   if (vlog_has_value(v)) {
      print_syntax(" = ");
      vlog_dump(vlog_value(v), indent);
   }

   print_syntax(";\n");
}

static void vlog_dump_always(vlog_node_t v, int indent)
{
   tab(indent);

   print_syntax("#always ");
   vlog_dump(vlog_stmt(v, 0), indent);
}

static void vlog_dump_initial(vlog_node_t v, int indent)
{
   tab(indent);

   print_syntax("#initial ");
   vlog_dump(vlog_stmt(v, 0), indent);
}

static void vlog_dump_seq_block(vlog_node_t v, int indent)
{
   print_syntax("#begin\n");

   const int nstmts = vlog_stmts(v);
   for (int i = 0; i < nstmts; i++)
      vlog_dump(vlog_stmt(v, i), indent + 2);

   tab(indent);
   print_syntax("#end\n");
}

static void vlog_dump_timing(vlog_node_t v, int indent)
{
   vlog_dump(vlog_value(v), indent);

   if (vlog_stmts(v) > 0)
      vlog_dump(vlog_stmt(v, 0), 0);
   else
      print_syntax(";\n");
}

static void vlog_dump_event(vlog_node_t v)
{
   switch (vlog_subkind(v)) {
   case V_EVENT_POSEDGE: print_syntax("#posedge "); break;
   case V_EVENT_NEGEDGE: print_syntax("#negedge "); break;
   }

   vlog_dump(vlog_value(v), 0);
}

static void vlog_dump_event_control(vlog_node_t v)
{
   print_syntax("@(");

   const int nparams = vlog_params(v);
   for (int i = 0; i < nparams; i++)
      vlog_dump(vlog_param(v, i), 0);

   print_syntax(") ");
}

static void vlog_dump_nbassign(vlog_node_t v, int indent)
{
   tab(indent);
   vlog_dump(vlog_target(v), 0);
   print_syntax(" <= ");
   if (vlog_has_delay(v))
      vlog_dump(vlog_delay(v), 0);
   vlog_dump(vlog_value(v), 0);
   print_syntax(";\n");
}

static void vlog_dump_bassign(vlog_node_t v, int indent)
{
   tab(indent);
   vlog_dump(vlog_target(v), 0);

   switch (vlog_subkind(v)) {
   case V_ASSIGN_EQUALS:
      print_syntax(" = ");
      break;
   }

   if (vlog_has_delay(v))
      vlog_dump(vlog_delay(v), 0);

   vlog_dump(vlog_value(v), 0);
   print_syntax(";\n");
}

static void vlog_dump_assign(vlog_node_t v, int indent)
{
   tab(indent);
   print_syntax("#assign ");
   vlog_dump(vlog_target(v), 0);
   print_syntax(" = ");
   vlog_dump(vlog_value(v), 0);
   print_syntax(";\n");
}

static void vlog_dump_stmt_or_null(vlog_node_t v, int indent)
{
   const int nstmts = vlog_stmts(v);
   if (nstmts == 0)
      print_syntax(";\n");
   else {
      print_syntax("\n");
      for (int i = 0; i < nstmts; i++)
         vlog_dump(vlog_stmt(v, i), indent + 2);
   }
}

static void vlog_dump_if(vlog_node_t v, int indent)
{
   tab(indent);
   print_syntax("#if ");

   const int nconds = vlog_conds(v);
   for (int i = 0; i < nconds; i++) {
      if (i > 0) {
         tab(indent);
         print_syntax("#else ");
      }

      vlog_node_t c = vlog_cond(v, i);
      if (vlog_has_value(c)) {
         print_syntax("(");
         vlog_dump(vlog_value(c), 0);
         print_syntax(")");
      }

      vlog_dump_stmt_or_null(c, indent);
   }
}

static void vlog_dump_sys_tcall(vlog_node_t v, int indent)
{
   tab(indent);
   print_syntax("%s", istr(vlog_ident(v)));

   const int nparams = vlog_params(v);
   if (nparams > 0) {
      print_syntax("(");
      for (int i = 0; i < nparams; i++) {
         if (i > 0) print_syntax(", ");
         vlog_dump(vlog_param(v, i), 0);
      }
      print_syntax(")");
   }

   print_syntax(";\n");
}

static void vlog_dump_sys_fcall(vlog_node_t v)
{
   print_syntax("%s", istr(vlog_ident(v)));

   const int nparams = vlog_params(v);
   if (nparams > 0) {
      print_syntax("(");
      for (int i = 0; i < nparams; i++) {
         if (i > 0) print_syntax(", ");
         vlog_dump(vlog_param(v, i), 0);
      }
      print_syntax(")");
   }
}

static void vlog_dump_string(vlog_node_t v)
{
   print_syntax("\"%s\"", vlog_text(v));
}

static void vlog_dump_number(vlog_node_t v)
{
   LOCAL_TEXT_BUF tb = tb_new();
   number_print(vlog_number(v), tb);

   print_syntax("%s", tb_get(tb));
}

static void vlog_dump_real(vlog_node_t v)
{
   print_syntax("%g", vlog_dval(v));
}

static void vlog_dump_binary(vlog_node_t v)
{
   vlog_dump_paren(vlog_left(v), 0);

   switch (vlog_subkind(v)) {
   case V_BINARY_OR: print_syntax(" | "); break;
   case V_BINARY_AND: print_syntax(" & "); break;
   case V_BINARY_CASE_EQ: print_syntax(" === "); break;
   case V_BINARY_CASE_NEQ: print_syntax(" !== "); break;
   case V_BINARY_LOG_EQ: print_syntax(" == "); break;
   case V_BINARY_LOG_NEQ: print_syntax(" != "); break;
   case V_BINARY_LOG_OR: print_syntax(" || "); break;
   case V_BINARY_LOG_AND: print_syntax(" && "); break;
   case V_BINARY_PLUS: print_syntax(" + "); break;
   }

   vlog_dump_paren(vlog_right(v), 0);
}

static void vlog_dump_unary(vlog_node_t v)
{
   switch (vlog_subkind(v)) {
   case V_UNARY_NOT: print_syntax("!"); break;
   case V_UNARY_BITNEG: print_syntax("~~"); break;
   }

   vlog_dump(vlog_value(v), 0);
}

static void vlog_dump_delay_control(vlog_node_t v, int indent)
{
   tab(indent);
   print_syntax("##");
   vlog_dump(vlog_value(v), 0);
   print_syntax(" ");
}

static void vlog_dump_gate_inst(vlog_node_t v, int indent)
{
   tab(indent);

   switch (vlog_subkind(v)) {
   case V_GATE_PULLUP: print_syntax("#pullup "); break;
   case V_GATE_PULLDOWN: print_syntax("#pulldown "); break;
   }

   const int nparams = vlog_params(v);
   if (nparams > 0) {
      print_syntax("(");
      for (int i = 0; i < nparams; i++) {
         if (i > 0) print_syntax(",");
         vlog_dump(vlog_param(v, i), 0);
      }
      print_syntax(") ");
   }

   if (vlog_has_ident(v))
      print_syntax("%s ", istr(vlog_ident(v)));

   print_syntax("(");
   vlog_dump(vlog_target(v), 0);
   print_syntax(");\n");
}

static void vlog_dump_mod_inst(vlog_node_t v, int indent)
{
   tab(indent);

   print_syntax("%s ", istr(vlog_ident2(v)));

   print_syntax("%s ", istr(vlog_ident(v)));

   const int nparams = vlog_params(v);
   if (nparams > 0) {
      print_syntax("(");
      for (int i = 0; i < nparams; i++) {
         if (i > 0) print_syntax(",");
         vlog_dump(vlog_param(v, i), 0);
      }
      print_syntax(")");
   }

   print_syntax(";\n");
}

static void vlog_dump_strength(vlog_node_t v, int indent)
{
   static const char *map[] = {
      "highz", "small", "medium", "weak", "large", "pull", "strong", "supply"
   };

   const unsigned level = vlog_subkind(v);
   print_syntax("%s0,%s1", map[STRENGTH0(level)], map[STRENGTH1(level)]);
}

static void vlog_dump_bit_select(vlog_node_t v, int indent)
{
   print_syntax("%s", istr(vlog_ident(v)));

   const int nparams = vlog_params(v);
   for (int i = 0; i < nparams; i++) {
      print_syntax("[");
      vlog_dump(vlog_param(v, i), 0);
      print_syntax("]");
   }
}

static void vlog_dump_data_type(vlog_node_t v, int indent)
{
   switch (vlog_subkind(v)) {
   case DT_LOGIC: print_syntax("#logic"); break;
   case DT_REAL: print_syntax("#real"); break;
   case DT_REALTIME: print_syntax("#realtime"); break;
   case DT_SHORTREAL: print_syntax("#shortreal"); break;
   case DT_INTEGER: print_syntax("#integer"); break;
   default: should_not_reach_here();
   }

   vlog_dump_dimensions(v, indent);
}

static void vlog_dump_do_while(vlog_node_t v, int indent)
{
   tab(indent);
   print_syntax("#do");

   vlog_dump_stmt_or_null(v, indent);

   tab(indent);
   print_syntax("#while (");
   vlog_dump(vlog_value(v), indent);
   print_syntax(");\n");
}

static void vlog_dump_while(vlog_node_t v, int indent)
{
   tab(indent);
   print_syntax("#while (");
   vlog_dump(vlog_value(v), indent);
   print_syntax(")");

   vlog_dump_stmt_or_null(v, indent);
}

static void vlog_dump_repeat(vlog_node_t v, int indent)
{
   tab(indent);
   print_syntax("#repeat (");
   vlog_dump(vlog_value(v), indent);
   print_syntax(")");

   vlog_dump_stmt_or_null(v, indent);
}

static void vlog_dump_cond_expr(vlog_node_t v, int indent)
{
   vlog_dump(vlog_value(v), 0);
   print_syntax(" ? ");
   vlog_dump(vlog_left(v), 0);
   print_syntax(" : ");
   vlog_dump(vlog_right(v), 0);
}

static void vlog_dump_concat(vlog_node_t v, int indent)
{
   print_syntax("{");

   const bool multiple = vlog_has_value(v);
   if (multiple) {
      vlog_dump(vlog_value(v), 0);
      print_syntax("{");
   }

   const int nparams = vlog_params(v);
   for (int i = 0; i < nparams; i++) {
      if (i > 0) print_syntax(", ");
      vlog_dump(vlog_param(v, i), 0);
   }

   if (multiple)
      print_syntax("}");

   print_syntax("}");
}

void vlog_dump(vlog_node_t v, int indent)
{
   switch (vlog_kind(v)) {
   case V_MODULE:
      vlog_dump_module(v, indent);
      break;
   case V_PRIMITIVE:
      vlog_dump_primitive(v, indent);
      break;
   case V_REF:
      print_syntax("%s", istr(vlog_ident(v)));
      break;
   case V_PORT_DECL:
      vlog_dump_port_decl(v, indent);
      break;
   case V_NET_DECL:
      vlog_dump_net_decl(v, indent);
      break;
   case V_VAR_DECL:
      vlog_dump_var_decl(v, indent);
      break;
   case V_ALWAYS:
      vlog_dump_always(v, indent);
      break;
   case V_INITIAL:
      vlog_dump_initial(v, indent);
      break;
   case V_TIMING:
      vlog_dump_timing(v, indent);
      break;
   case V_EVENT:
      vlog_dump_event(v);
      break;
   case V_EVENT_CONTROL:
      vlog_dump_event_control(v);
      break;
   case V_NBASSIGN:
      vlog_dump_nbassign(v, indent);
      break;
   case V_BASSIGN:
      vlog_dump_bassign(v, indent);
      break;
   case V_ASSIGN:
      vlog_dump_assign(v, indent);
      break;
   case V_SEQ_BLOCK:
      vlog_dump_seq_block(v, indent);
      break;
   case V_SYS_TCALL:
      vlog_dump_sys_tcall(v, indent);
      break;
   case V_SYS_FCALL:
      vlog_dump_sys_fcall(v);
      break;
   case V_STRING:
      vlog_dump_string(v);
      break;
   case V_NUMBER:
      vlog_dump_number(v);
      break;
   case V_REAL:
      vlog_dump_real(v);
      break;
   case V_IF:
      vlog_dump_if(v, indent);
      break;
   case V_BINARY:
      vlog_dump_binary(v);
      break;
   case V_UNARY:
      vlog_dump_unary(v);
      break;
   case V_DELAY_CONTROL:
      vlog_dump_delay_control(v, indent);
      break;
   case V_GATE_INST:
      vlog_dump_gate_inst(v, indent);
      break;
   case V_MOD_INST:
      vlog_dump_mod_inst(v, indent);
      break;
   case V_STRENGTH:
      vlog_dump_strength(v, indent);
      break;
   case V_BIT_SELECT:
      vlog_dump_bit_select(v, indent);
      break;
   case V_UDP_ENTRY:
      vlog_dump_udp_entry(v, indent);
      break;
   case V_UDP_TABLE:
      vlog_dump_udp_table(v, indent);
      break;
   case V_DATA_TYPE:
      vlog_dump_data_type(v, indent);
      break;
   case V_EMPTY:
      break;
   case V_DO_WHILE:
      vlog_dump_do_while(v, indent);
      break;
   case V_WHILE:
      vlog_dump_while(v, indent);
      break;
   case V_REPEAT:
      vlog_dump_repeat(v, indent);
      break;
   case V_COND_EXPR:
      vlog_dump_cond_expr(v, indent);
      break;
   case V_CONCAT:
      vlog_dump_concat(v, indent);
      break;
   default:
      print_syntax("\n");
      fflush(stdout);
      fatal_trace("cannot dump %s", vlog_kind_str(vlog_kind(v)));
   }
}

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 "common.h"
20	#include "ident.h"
21	#include "vlog/vlog-node.h"
22	#include "vlog/vlog-number.h"
23	#include "vlog/vlog-phase.h"
24
25	#include <ctype.h>
26
27	static inline void tab(int indent)	57✔
28	{
29	print_syntax("%*s", indent, "");	57✔
30	}	57✔
31
32	static void vlog_dump_paren(vlog_node_t v, int indent)	30✔
33	{
34	switch (vlog_kind(v)) {	30✔
35	case V_REF:	22✔
36	case V_BIT_SELECT:
37	case V_NUMBER:
38	vlog_dump(v, indent);	22✔
39	break;	22✔
40	default:	8✔
41	print_syntax("(");	8✔
42	vlog_dump(v, indent);	8✔
43	print_syntax(")");	8✔
44	}
45	}	30✔
46
47	static void vlog_dump_module(vlog_node_t v, int indent)	3✔
48	{
49	print_syntax("#module %s", istr(vlog_ident2(v)));	3✔
50
51	const int nports = vlog_ports(v);	3✔
52	if (nports > 0) {	3✔
53	print_syntax(" (");	1✔
54	for (int i = 0; i < nports; i++) {	5✔
55	if (i > 0) print_syntax(", ");	4✔
56	vlog_dump(vlog_port(v, i), 0);	4✔
57	}
58	print_syntax(")");	1✔
59	}
60
61	print_syntax(";\n");	3✔
62
63	const int ndecls = vlog_decls(v);	3✔
64	for (int i = 0; i < ndecls; i++)	16✔
65	vlog_dump(vlog_decl(v, i), indent + 2);	13✔
66
67	const int nstmts = vlog_stmts(v);	3✔
68	for (int i = 0; i < nstmts; i++)	12✔
69	vlog_dump(vlog_stmt(v, i), indent + 2);	9✔
70
71	print_syntax("#endmodule // %s\n\n", istr(vlog_ident2(v)));	3✔
72	}	3✔
73
74	static void vlog_dump_primitive(vlog_node_t v, int indent)	1✔
75	{
76	print_syntax("#primitive %s", istr(vlog_ident2(v)));	1✔
77
78	const int nports = vlog_ports(v);	1✔
79	if (nports > 0) {	1✔
80	print_syntax(" (");	1✔
81	for (int i = 0; i < nports; i++) {	5✔
82	if (i > 0) print_syntax(", ");	4✔
83	vlog_dump(vlog_port(v, i), 0);	4✔
84	}
85	print_syntax(")");	1✔
86	}
87
88	print_syntax(";\n");	1✔
89
90	const int ndecls = vlog_decls(v);	1✔
91	for (int i = 0; i < ndecls; i++)	5✔
92	vlog_dump(vlog_decl(v, i), indent + 2);	4✔
93
94	const int nstmts = vlog_stmts(v);	1✔
95	for (int i = 0; i < nstmts; i++)	2✔
96	vlog_dump(vlog_stmt(v, i), indent + 2);	1✔
97
98	print_syntax("#endprimitive // %s\n\n", istr(vlog_ident2(v)));	1✔
99	}	1✔
100
101	static void vlog_dump_udp_entry(vlog_node_t v, int indent)	4✔
102	{
103	tab(indent);	4✔
104	print_syntax("%s;\n", vlog_text(v));	4✔
105	}	4✔
106
107	static void vlog_dump_udp_table(vlog_node_t v, int indent)	1✔
108	{
109	tab(indent);	1✔
110	print_syntax("#table\n");	1✔
111
112	const int nparams = vlog_params(v);	1✔
113	for (int i = 0; i < nparams; i++)	5✔
114	vlog_dump(vlog_param(v, i), indent + 2);	4✔
115
116	tab(indent);	1✔
117	print_syntax("#endtable\n");	1✔
118	}	1✔
119
120	static void vlog_dump_port_decl(vlog_node_t v, int indent)	8✔
121	{
122	tab(indent);	8✔
123
124	switch (vlog_subkind(v)) {	8✔
125	case V_PORT_INPUT: print_syntax("#input"); break;	6✔
126	case V_PORT_INOUT: print_syntax("#inout"); break;	×
127	case V_PORT_OUTPUT: print_syntax("#output"); break;	2✔
128	}
129
130	print_syntax(" %s;\n", istr(vlog_ident(v)));	8✔
131	}	8✔
132
133	static void vlog_dump_dimensions(vlog_node_t v, int indent)	18✔
134	{
135	const int ndims = vlog_ranges(v);	18✔
136	int dim = 0;	18✔
137	for (; dim < ndims; dim++) {	19✔
138	vlog_node_t d = vlog_range(v, dim);	1✔
139	print_syntax(" [");	1✔
140	vlog_dump(vlog_left(d), indent);	1✔
141	print_syntax(":");	1✔
142	vlog_dump(vlog_right(d), indent);	1✔
143	print_syntax("]");	1✔
144	}
145	}	18✔
146
147	static void vlog_dump_net_decl(vlog_node_t v, int indent)	5✔
148	{
149	tab(indent);	5✔
150
151	switch (vlog_subkind(v)) {	5✔
152	case V_NET_WIRE: print_syntax("#wire "); break;	5✔
153	}
154
155	vlog_dump(vlog_type(v), indent);	5✔
156	print_syntax(" %s", istr(vlog_ident(v)));	5✔
157	vlog_dump_dimensions(v, indent);	5✔
158	print_syntax(";\n");	5✔
159	}	5✔
160
161	static void vlog_dump_var_decl(vlog_node_t v, int indent)	4✔
162	{
163	tab(indent);	4✔
164
165	vlog_dump(vlog_type(v), indent);	4✔
166	print_syntax(" %s", istr(vlog_ident(v)));	4✔
167	vlog_dump_dimensions(v, indent);	4✔
168
169	if (vlog_has_value(v)) {	4✔
170	print_syntax(" = ");	2✔
171	vlog_dump(vlog_value(v), indent);	2✔
172	}
173
174	print_syntax(";\n");	4✔
175	}	4✔
176
177	static void vlog_dump_always(vlog_node_t v, int indent)	1✔
178	{
179	tab(indent);	1✔
180
181	print_syntax("#always ");	1✔
182	vlog_dump(vlog_stmt(v, 0), indent);	1✔
183	}	1✔
184
185	static void vlog_dump_initial(vlog_node_t v, int indent)	2✔
186	{
187	tab(indent);	2✔
188
189	print_syntax("#initial ");	2✔
190	vlog_dump(vlog_stmt(v, 0), indent);	2✔
191	}	2✔
192
193	static void vlog_dump_seq_block(vlog_node_t v, int indent)	2✔
194	{
195	print_syntax("#begin\n");	2✔
196
197	const int nstmts = vlog_stmts(v);	2✔
198	for (int i = 0; i < nstmts; i++)	17✔
199	vlog_dump(vlog_stmt(v, i), indent + 2);	15✔
200
201	tab(indent);	2✔
202	print_syntax("#end\n");	2✔
203	}	2✔
204
205	static void vlog_dump_timing(vlog_node_t v, int indent)	2✔
206	{
207	vlog_dump(vlog_value(v), indent);	2✔
208
209	if (vlog_stmts(v) > 0)	2✔
210	vlog_dump(vlog_stmt(v, 0), 0);	2✔
211	else
212	print_syntax(";\n");	×
213	}	2✔
214
215	static void vlog_dump_event(vlog_node_t v)	1✔
216	{
217	switch (vlog_subkind(v)) {	1✔
218	case V_EVENT_POSEDGE: print_syntax("#posedge "); break;	1✔
219	case V_EVENT_NEGEDGE: print_syntax("#negedge "); break;	×
220	}
221
222	vlog_dump(vlog_value(v), 0);	1✔
223	}	1✔
224
225	static void vlog_dump_event_control(vlog_node_t v)	1✔
226	{
227	print_syntax("@(");	1✔
228
229	const int nparams = vlog_params(v);	1✔
230	for (int i = 0; i < nparams; i++)	2✔
231	vlog_dump(vlog_param(v, i), 0);	1✔
232
233	print_syntax(") ");	1✔
234	}	1✔
235
236	static void vlog_dump_nbassign(vlog_node_t v, int indent)	4✔
237	{
238	tab(indent);	4✔
239	vlog_dump(vlog_target(v), 0);	4✔
240	print_syntax(" <= ");	4✔
241	if (vlog_has_delay(v))	4✔
242	vlog_dump(vlog_delay(v), 0);	1✔
243	vlog_dump(vlog_value(v), 0);	4✔
244	print_syntax(";\n");	4✔
245	}	4✔
246
247	static void vlog_dump_bassign(vlog_node_t v, int indent)	5✔
248	{
249	tab(indent);	5✔
250	vlog_dump(vlog_target(v), 0);	5✔
251
252	switch (vlog_subkind(v)) {	5✔
253	case V_ASSIGN_EQUALS:	5✔
254	print_syntax(" = ");	5✔
255	break;	5✔
256	}
257
258	if (vlog_has_delay(v))	5✔
259	vlog_dump(vlog_delay(v), 0);	1✔
260
261	vlog_dump(vlog_value(v), 0);	5✔
262	print_syntax(";\n");	5✔
263	}	5✔
264
265	static void vlog_dump_assign(vlog_node_t v, int indent)	4✔
266	{
267	tab(indent);	4✔
268	print_syntax("#assign ");	4✔
269	vlog_dump(vlog_target(v), 0);	4✔
270	print_syntax(" = ");	4✔
271	vlog_dump(vlog_value(v), 0);	4✔
272	print_syntax(";\n");	4✔
273	}	4✔
274
275	static void vlog_dump_stmt_or_null(vlog_node_t v, int indent)	8✔
276	{
277	const int nstmts = vlog_stmts(v);	8✔
278	if (nstmts == 0)	8✔
279	print_syntax(";\n");	5✔
280	else {
281	print_syntax("\n");	3✔
282	for (int i = 0; i < nstmts; i++)	6✔
283	vlog_dump(vlog_stmt(v, i), indent + 2);	3✔
284	}
285	}	8✔
286
287	static void vlog_dump_if(vlog_node_t v, int indent)	5✔
288	{
289	tab(indent);	5✔
290	print_syntax("#if ");	5✔
291
292	const int nconds = vlog_conds(v);	5✔
293	for (int i = 0; i < nconds; i++) {	10✔
294	if (i > 0) {	5✔
295	tab(indent);	×
296	print_syntax("#else ");	×
297	}
298
299	vlog_node_t c = vlog_cond(v, i);	5✔
300	if (vlog_has_value(c)) {	5✔
301	print_syntax("(");	5✔
302	vlog_dump(vlog_value(c), 0);	5✔
303	print_syntax(")");	5✔
304	}
305
306	vlog_dump_stmt_or_null(c, indent);	5✔
307	}
308	}	5✔
309
310	static void vlog_dump_sys_tcall(vlog_node_t v, int indent)	2✔
311	{
312	tab(indent);	2✔
313	print_syntax("%s", istr(vlog_ident(v)));	2✔
314
315	const int nparams = vlog_params(v);	2✔
316	if (nparams > 0) {	2✔
317	print_syntax("(");	1✔
318	for (int i = 0; i < nparams; i++) {	3✔
319	if (i > 0) print_syntax(", ");	2✔
320	vlog_dump(vlog_param(v, i), 0);	2✔
321	}
322	print_syntax(")");	1✔
323	}
324
325	print_syntax(";\n");	2✔
326	}	2✔
327
328	static void vlog_dump_sys_fcall(vlog_node_t v)	1✔
329	{
330	print_syntax("%s", istr(vlog_ident(v)));	1✔
331
332	const int nparams = vlog_params(v);	1✔
333	if (nparams > 0) {	1✔
334	print_syntax("(");	×
335	for (int i = 0; i < nparams; i++) {	×
336	if (i > 0) print_syntax(", ");	×
337	vlog_dump(vlog_param(v, i), 0);	×
338	}
339	print_syntax(")");	×
340	}
341	}	1✔
342
343	static void vlog_dump_string(vlog_node_t v)	1✔
344	{
345	print_syntax("\"%s\"", vlog_text(v));	1✔
346	}	1✔
347
348	static void vlog_dump_number(vlog_node_t v)	19✔
349	{
350	LOCAL_TEXT_BUF tb = tb_new();	38✔
351	number_print(vlog_number(v), tb);	19✔
352
353	print_syntax("%s", tb_get(tb));	19✔
354	}	19✔
355
356	static void vlog_dump_real(vlog_node_t v)	1✔
357	{
358	print_syntax("%g", vlog_dval(v));	1✔
359	}	1✔
360
361	static void vlog_dump_binary(vlog_node_t v)	15✔
362	{
363	vlog_dump_paren(vlog_left(v), 0);	15✔
364
365	switch (vlog_subkind(v)) {	15✔
366	case V_BINARY_OR: print_syntax(" \| "); break;	2✔
367	case V_BINARY_AND: print_syntax(" & "); break;	3✔
368	case V_BINARY_CASE_EQ: print_syntax(" === "); break;	2✔
369	case V_BINARY_CASE_NEQ: print_syntax(" !== "); break;	×
370	case V_BINARY_LOG_EQ: print_syntax(" == "); break;	3✔
371	case V_BINARY_LOG_NEQ: print_syntax(" != "); break;	×
372	case V_BINARY_LOG_OR: print_syntax(" \|\| "); break;	2✔
373	case V_BINARY_LOG_AND: print_syntax(" && "); break;	1✔
374	case V_BINARY_PLUS: print_syntax(" + "); break;	2✔
375	}
376
377	vlog_dump_paren(vlog_right(v), 0);	15✔
378	}	15✔
379
380	static void vlog_dump_unary(vlog_node_t v)	1✔
381	{
382	switch (vlog_subkind(v)) {	1✔
383	case V_UNARY_NOT: print_syntax("!"); break;	×
384	case V_UNARY_BITNEG: print_syntax("~~"); break;	1✔
385	}
386
387	vlog_dump(vlog_value(v), 0);	1✔
388	}	1✔
389
390	static void vlog_dump_delay_control(vlog_node_t v, int indent)	3✔
391	{
392	tab(indent);	3✔
393	print_syntax("##");	3✔
394	vlog_dump(vlog_value(v), 0);	3✔
395	print_syntax(" ");	3✔
396	}	3✔
397
398	static void vlog_dump_gate_inst(vlog_node_t v, int indent)	1✔
399	{
400	tab(indent);	1✔
401
402	switch (vlog_subkind(v)) {	1✔
403	case V_GATE_PULLUP: print_syntax("#pullup "); break;	1✔
404	case V_GATE_PULLDOWN: print_syntax("#pulldown "); break;	×
405	}
406
407	const int nparams = vlog_params(v);	1✔
408	if (nparams > 0) {	1✔
409	print_syntax("(");	1✔
410	for (int i = 0; i < nparams; i++) {	2✔
411	if (i > 0) print_syntax(",");	1✔
412	vlog_dump(vlog_param(v, i), 0);	1✔
413	}
414	print_syntax(") ");	1✔
415	}
416
417	if (vlog_has_ident(v))	1✔
418	print_syntax("%s ", istr(vlog_ident(v)));	1✔
419
420	print_syntax("(");	1✔
421	vlog_dump(vlog_target(v), 0);	1✔
422	print_syntax(");\n");	1✔
423	}	1✔
424
425	static void vlog_dump_mod_inst(vlog_node_t v, int indent)	1✔
426	{
427	tab(indent);	1✔
428
429	print_syntax("%s ", istr(vlog_ident2(v)));	1✔
430
431	print_syntax("%s ", istr(vlog_ident(v)));	1✔
432
433	const int nparams = vlog_params(v);	1✔
434	if (nparams > 0) {	1✔
435	print_syntax("(");	1✔
436	for (int i = 0; i < nparams; i++) {	2✔
437	if (i > 0) print_syntax(",");	1✔
438	vlog_dump(vlog_param(v, i), 0);	1✔
439	}
440	print_syntax(")");	1✔
441	}
442
443	print_syntax(";\n");	1✔
444	}	1✔
445
446	static void vlog_dump_strength(vlog_node_t v, int indent)	1✔
447	{
448	static const char *map[] = {	1✔
449	"highz", "small", "medium", "weak", "large", "pull", "strong", "supply"
450	};
451
452	const unsigned level = vlog_subkind(v);	1✔
453	print_syntax("%s0,%s1", map[STRENGTH0(level)], map[STRENGTH1(level)]);	1✔
454	}	1✔
455
456	static void vlog_dump_bit_select(vlog_node_t v, int indent)	1✔
457	{
458	print_syntax("%s", istr(vlog_ident(v)));	1✔
459
460	const int nparams = vlog_params(v);	1✔
461	for (int i = 0; i < nparams; i++) {	2✔
462	print_syntax("[");	1✔
463	vlog_dump(vlog_param(v, i), 0);	1✔
464	print_syntax("]");	1✔
465	}
466	}	1✔
467
468	static void vlog_dump_data_type(vlog_node_t v, int indent)	9✔
469	{
470	switch (vlog_subkind(v)) {	9✔
471	case DT_LOGIC: print_syntax("#logic"); break;	7✔
472	case DT_REAL: print_syntax("#real"); break;	1✔
473	case DT_REALTIME: print_syntax("#realtime"); break;	×
474	case DT_SHORTREAL: print_syntax("#shortreal"); break;	×
475	case DT_INTEGER: print_syntax("#integer"); break;	1✔
476	default: should_not_reach_here();
477	}
478
479	vlog_dump_dimensions(v, indent);	9✔
480	}	9✔
481
482	static void vlog_dump_do_while(vlog_node_t v, int indent)	1✔
483	{
484	tab(indent);	1✔
485	print_syntax("#do");	1✔
486
487	vlog_dump_stmt_or_null(v, indent);	1✔
488
489	tab(indent);	1✔
490	print_syntax("#while (");	1✔
491	vlog_dump(vlog_value(v), indent);	1✔
492	print_syntax(");\n");	1✔
493	}	1✔
494
495	static void vlog_dump_while(vlog_node_t v, int indent)	1✔
496	{
497	tab(indent);	1✔
498	print_syntax("#while (");	1✔
499	vlog_dump(vlog_value(v), indent);	1✔
500	print_syntax(")");	1✔
501
502	vlog_dump_stmt_or_null(v, indent);	1✔
503	}	1✔
504
505	static void vlog_dump_repeat(vlog_node_t v, int indent)	1✔
506	{
507	tab(indent);	1✔
508	print_syntax("#repeat (");	1✔
509	vlog_dump(vlog_value(v), indent);	1✔
510	print_syntax(")");	1✔
511
512	vlog_dump_stmt_or_null(v, indent);	1✔
513	}	1✔
514
515	static void vlog_dump_cond_expr(vlog_node_t v, int indent)	1✔
516	{
517	vlog_dump(vlog_value(v), 0);	1✔
518	print_syntax(" ? ");	1✔
519	vlog_dump(vlog_left(v), 0);	1✔
520	print_syntax(" : ");	1✔
521	vlog_dump(vlog_right(v), 0);	1✔
522	}	1✔
523
524	static void vlog_dump_concat(vlog_node_t v, int indent)	2✔
525	{
526	print_syntax("{");	2✔
527
528	const bool multiple = vlog_has_value(v);	2✔
529	if (multiple) {	2✔
530	vlog_dump(vlog_value(v), 0);	1✔
531	print_syntax("{");	1✔
532	}
533
534	const int nparams = vlog_params(v);	2✔
535	for (int i = 0; i < nparams; i++) {	5✔
536	if (i > 0) print_syntax(", ");	3✔
537	vlog_dump(vlog_param(v, i), 0);	3✔
538	}
539
540	if (multiple)	2✔
541	print_syntax("}");	1✔
542
543	print_syntax("}");	2✔
544	}	2✔
545
546	void vlog_dump(vlog_node_t v, int indent)	166✔
547	{
548	switch (vlog_kind(v)) {	166✔
549	case V_MODULE:	3✔
550	vlog_dump_module(v, indent);	3✔
551	break;	3✔
552	case V_PRIMITIVE:	1✔
553	vlog_dump_primitive(v, indent);	1✔
554	break;	1✔
555	case V_REF:	51✔
556	print_syntax("%s", istr(vlog_ident(v)));	51✔
557	break;	51✔
558	case V_PORT_DECL:	8✔
559	vlog_dump_port_decl(v, indent);	8✔
560	break;	8✔
561	case V_NET_DECL:	5✔
562	vlog_dump_net_decl(v, indent);	5✔
563	break;	5✔
564	case V_VAR_DECL:	4✔
565	vlog_dump_var_decl(v, indent);	4✔
566	break;	4✔
567	case V_ALWAYS:	1✔
568	vlog_dump_always(v, indent);	1✔
569	break;	1✔
570	case V_INITIAL:	2✔
571	vlog_dump_initial(v, indent);	2✔
572	break;	2✔
573	case V_TIMING:	2✔
574	vlog_dump_timing(v, indent);	2✔
575	break;	2✔
576	case V_EVENT:	1✔
577	vlog_dump_event(v);	1✔
578	break;	1✔
579	case V_EVENT_CONTROL:	1✔
580	vlog_dump_event_control(v);	1✔
581	break;	1✔
582	case V_NBASSIGN:	4✔
583	vlog_dump_nbassign(v, indent);	4✔
584	break;	4✔
585	case V_BASSIGN:	5✔
586	vlog_dump_bassign(v, indent);	5✔
587	break;	5✔
588	case V_ASSIGN:	4✔
589	vlog_dump_assign(v, indent);	4✔
590	break;	4✔
591	case V_SEQ_BLOCK:	2✔
592	vlog_dump_seq_block(v, indent);	2✔
593	break;	2✔
594	case V_SYS_TCALL:	2✔
595	vlog_dump_sys_tcall(v, indent);	2✔
596	break;	2✔
597	case V_SYS_FCALL:	1✔
598	vlog_dump_sys_fcall(v);	1✔
599	break;	1✔
600	case V_STRING:	1✔
601	vlog_dump_string(v);	1✔
602	break;	1✔
603	case V_NUMBER:	19✔
604	vlog_dump_number(v);	19✔
605	break;	19✔
606	case V_REAL:	1✔
607	vlog_dump_real(v);	1✔
608	break;	1✔
609	case V_IF:	5✔
610	vlog_dump_if(v, indent);	5✔
611	break;	5✔
612	case V_BINARY:	15✔
613	vlog_dump_binary(v);	15✔
614	break;	15✔
615	case V_UNARY:	1✔
616	vlog_dump_unary(v);	1✔
617	break;	1✔
618	case V_DELAY_CONTROL:	3✔
619	vlog_dump_delay_control(v, indent);	3✔
620	break;	3✔
621	case V_GATE_INST:	1✔
622	vlog_dump_gate_inst(v, indent);	1✔
623	break;	1✔
624	case V_MOD_INST:	1✔
625	vlog_dump_mod_inst(v, indent);	1✔
626	break;	1✔
627	case V_STRENGTH:	1✔
628	vlog_dump_strength(v, indent);	1✔
629	break;	1✔
630	case V_BIT_SELECT:	1✔
631	vlog_dump_bit_select(v, indent);	1✔
632	break;	1✔
633	case V_UDP_ENTRY:	4✔
634	vlog_dump_udp_entry(v, indent);	4✔
635	break;	4✔
636	case V_UDP_TABLE:	1✔
637	vlog_dump_udp_table(v, indent);	1✔
638	break;	1✔
639	case V_DATA_TYPE:	9✔
640	vlog_dump_data_type(v, indent);	9✔
641	break;	9✔
642	case V_EMPTY:
643	break;
644	case V_DO_WHILE:	1✔
645	vlog_dump_do_while(v, indent);	1✔
646	break;	1✔
647	case V_WHILE:	1✔
648	vlog_dump_while(v, indent);	1✔
649	break;	1✔
650	case V_REPEAT:	1✔
651	vlog_dump_repeat(v, indent);	1✔
652	break;	1✔
653	case V_COND_EXPR:	1✔
654	vlog_dump_cond_expr(v, indent);	1✔
655	break;	1✔
656	case V_CONCAT:	2✔
657	vlog_dump_concat(v, indent);	2✔
658	break;	2✔
UNCOV 659	default:	×
UNCOV 660	print_syntax("\n");	×
UNCOV 661	fflush(stdout);	×
662	fatal_trace("cannot dump %s", vlog_kind_str(vlog_kind(v)));
663	}
664	}	166✔

nickg / nvc / 13798777898

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