luke
/
iverilog
mirror of https://github.com/steveicarus/iverilog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add LXT dumper support. (Anthony Bybell)

This commit is contained in:
steve 2002-03-09 21:54:48 +00:00
parent eae9153b40
commit 0dc5e5e29d
5 changed files with 2477 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
vpi/Makefile.in
View File

@ -18,7 +18,7 @@
# 59 Temple Place - Suite 330 # 59 Temple Place - Suite 330
# Boston, MA 02111-1307, USA # Boston, MA 02111-1307, USA
# #
#ident "$Id: Makefile.in,v 1.29 2001/09/20 03:21:02 steve Exp $" #ident "$Id: Makefile.in,v 1.30 2002/03/09 21:54:48 steve Exp $"
# #
# #
SHELL = /bin/sh SHELL = /bin/sh
@ -57,6 +57,7 @@ all: system.vpi
O = sys_table.o sys_deposit.o sys_display.o sys_finish.o sys_random.o \ O = sys_table.o sys_deposit.o sys_display.o sys_finish.o sys_random.o \
sys_readmem.o sys_readmem_lex.o sys_time.o sys_vcd.o \ sys_readmem.o sys_readmem_lex.o sys_time.o sys_vcd.o \
sys_lxt.o lxt_write.o \
mt19937int.o mt19937int.o
SYSTEM_VPI_LDFLAGS = -L.. -lvpi SYSTEM_VPI_LDFLAGS = -L.. -lvpi

1528
vpi/lxt_write.c Normal file
View File

File diff suppressed because it is too large Load Diff

156
vpi/lxt_write.h Normal file
View File

@ -0,0 +1,156 @@
/*
* Copyright (c) 2001 Tony Bybell.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#ifndef DEFS_LXT_H
#define DEFS_LXT_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#define LT_HDRID (0x0138)
#define LT_VERSION (0x0001)
#define LT_TRLID (0xB4)
#define LT_CLKPACK (4)
#define LT_MVL_2 (1<<0)
#define LT_MVL_4 (1<<1)
#define LT_MVL_9 (1<<2)
struct lt_timetrail
{
struct lt_timetrail *next;
int timeval;
unsigned int position;
};
#define LT_SYMPRIME 65519
#define LT_SECTION_END (0)
#define LT_SECTION_CHG (1)
#define LT_SECTION_SYNC_TABLE (2)
#define LT_SECTION_FACNAME (3)
#define LT_SECTION_FACNAME_GEOMETRY (4)
#define LT_SECTION_TIMESCALE (5)
#define LT_SECTION_TIME_TABLE (6)
#define LT_SECTION_INITIAL_VALUE (7)
#define LT_SECTION_DOUBLE_TEST (8)
struct lt_trace
{
FILE *handle;
unsigned int position;
struct lt_symbol *sym[LT_SYMPRIME];
struct lt_symbol **sorted_facs;
struct lt_symbol *symchain;
int numfacs;
int numfacbytes;
int longestname;
int mintime, maxtime;
int timescale;
int initial_value;
struct lt_timetrail *timehead, *timecurr, *timebuff;
int timechangecount;
char double_used;
char do_strip_brackets;
char clock_compress;
unsigned int change_field_offset;
unsigned int facname_offset;
unsigned int facgeometry_offset;
unsigned int time_table_offset;
unsigned int sync_table_offset;
unsigned int initial_value_offset;
unsigned int timescale_offset;
unsigned int double_test_offset;
char *compress_fac_str;
int compress_fac_len;
int timeval; /* for clock induction */
};
struct lt_symbol
{
struct lt_symbol *next;
struct lt_symbol *symchain;
char *name;
int namlen;
int facnum;
struct lt_symbol *aliased_to;
unsigned int rows;
int msb, lsb;
int len;
int flags;
unsigned int last_change;
int clk_delta;
int clk_prevtrans;
int clk_numtrans;
char clk_prevval;
};
#define LT_SYM_F_BITS (0)
#define LT_SYM_F_INTEGER (1<<0)
#define LT_SYM_F_DOUBLE (1<<1)
#define LT_SYM_F_STRING (1<<2)
#define LT_SYM_F_ALIAS (1<<3)
struct lt_trace * lt_init(const char *name);
void lt_close(struct lt_trace *lt);
struct lt_symbol * lt_symbol_find(struct lt_trace *lt, const char *name);
struct lt_symbol * lt_symbol_add(struct lt_trace *lt, const char *name, unsigned int rows, int msb, int lsb, int flags);
struct lt_symbol * lt_symbol_alias(struct lt_trace *lt, const char *existing_name, const char *alias, int msb, int lsb);
void lt_symbol_bracket_stripping(struct lt_trace *lt, int doit);
void lt_set_timescale(struct lt_trace *lt, int timescale);
void lt_set_initial_value(struct lt_trace *lt, char value);
int lt_set_time(struct lt_trace *lt, int timeval);
void lt_set_clock_compress(struct lt_trace *lt);
/*
* value change functions..note that if the value string len for
* lt_emit_value_bit_string() is shorter than the symbol length
* it will be left justified with the rightmost character used as
* a repeat value that will be propagated to pad the value string out:
*
* "10x" for 8 bits becomes "10xxxxxx"
* "z" for 8 bits becomes "zzzzzzzz"
*/
int lt_emit_value_int(struct lt_trace *lt, struct lt_symbol *s, unsigned int row, int value);
int lt_emit_value_double(struct lt_trace *lt, struct lt_symbol *s, unsigned int row, double value);
int lt_emit_value_string(struct lt_trace *lt, struct lt_symbol *s, unsigned int row, char *value);
int lt_emit_value_bit_string(struct lt_trace *lt, struct lt_symbol *s, unsigned int row, char *value);
#endif

785
vpi/sys_lxt.c Normal file
View File

@ -0,0 +1,785 @@
/*
* Copyright (c) 2002 Stephen Williams (steve@icarus.com)
*
* This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU
* General Public License as published by the Free Software
* Foundation; either version 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/
#if !defined(WINNT) && !defined(macintosh)
#ident "$Id: sys_lxt.c,v 1.1 2002/03/09 21:54:49 steve Exp $"
#endif
# include "config.h"
# include "lxt_write.h"
/*
* This file contains the implementations of the VCD related
* funcitons.
*/
# include "vpi_user.h"
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <assert.h>
# include <time.h>
#ifdef HAVE_MALLOC_H
# include <malloc.h>
#endif
struct lxt_scope
{
struct lxt_scope *next, *prev;
char *name;
int len;
};
struct lxt_scope *lxt_scope_head=NULL, *lxt_scope_current=NULL;
static void push_scope(const char *name)
{
struct lxt_scope *t = (struct lxt_scope *)calloc(1, sizeof(struct lxt_scope));
t->name = strdup(name);
t->len = strlen(name);
if(!lxt_scope_head)
{
lxt_scope_head = lxt_scope_current = t;
}
else
{
lxt_scope_current->next = t;
t->prev = lxt_scope_current;
lxt_scope_current = t;
}
}
static void pop_scope(void)
{
struct lxt_scope *t;
assert(lxt_scope_current);
t=lxt_scope_current->prev;
free(lxt_scope_current->name);
free(lxt_scope_current);
lxt_scope_current = t;
if(!t) lxt_scope_head = t;
}
static char *create_full_name(const char *name)
{
char *n, *n2;
int len = 0;
struct lxt_scope *t = lxt_scope_head;
while(t)
{
len+=t->len+1;
t=t->next;
}
len += strlen(name) + 1;
n = n2 = malloc(len);
t = lxt_scope_head;
while(t)
{
strcpy(n2, t->name);
n2 += t->len;
*n2 = '.';
n2++;
t=t->next;
}
strcpy(n2, name);
return(n);
}
static struct lt_trace *dump_file = 0;
struct vcd_info {
vpiHandle item;
vpiHandle cb;
struct t_vpi_time time;
struct lt_symbol *sym;
struct vcd_info*next;
};
static struct vcd_info*vcd_list = 0;
static unsigned long vcd_cur_time = 0;
static int dump_is_off = 0;
static void show_this_item(struct vcd_info*info)
{
s_vpi_value value;
value.format = vpiBinStrVal;
vpi_get_value(info->item, &value);
lt_emit_value_bit_string(dump_file, info->sym, 0 /* array row */, value.value.str);
}
static void show_this_item_x(struct vcd_info*info)
{
lt_emit_value_bit_string(dump_file, info->sym, 0 /* array row */, "x");
}
/*
* managed qsorted list of scope names for duplicates bsearching
*/
struct vcd_names_s {
const char *name;
struct vcd_names_s *next;
};
static struct vcd_names_s *vcd_names_list;
static const char **vcd_names_sorted;
static int listed_names, sorted_names;
inline static void vcd_names_add(const char *name)
{
struct vcd_names_s *nl = (struct vcd_names_s *)
malloc(sizeof(struct vcd_names_s));
assert(nl);
nl->name = name;
nl->next = vcd_names_list;
vcd_names_list = nl;
listed_names ++;
}
static int vcd_names_compare(const void *s1, const void *s2)
{
const char *v1 = *(const char **) s1;
const char *v2 = *(const char **) s2;
return strcmp(v1, v2);
}
static const char *vcd_names_search(const char *key)
{
const char **v = (const char **)
bsearch(&key,
vcd_names_sorted, sorted_names,
sizeof(const char *), vcd_names_compare );
return(v ? *v : NULL);
}
static void vcd_names_sort(void)
{
if (listed_names) {
struct vcd_names_s *r;
const char **l;
sorted_names += listed_names;
vcd_names_sorted = (const char **)
realloc(vcd_names_sorted,
sorted_names*(sizeof(const char *)));
assert(vcd_names_sorted);
l = vcd_names_sorted + sorted_names - listed_names;
listed_names = 0;
r = vcd_names_list;
vcd_names_list = 0x0;
while (r) {
struct vcd_names_s *rr = r;
r = rr->next;
*(l++) = rr->name;
free(rr);
}
qsort(vcd_names_sorted, sorted_names,
sizeof(const char **), vcd_names_compare);
}
}
static int dumpvars_status = 0; /* 0:fresh 1:cb installed, 2:callback done */
static unsigned long dumpvars_time;
inline static int dump_header_pending(void)
{
return dumpvars_status != 2;
}
/*
* This function writes out all the traced variables, whether they
* changed or not.
*/
static void vcd_checkpoint()
{
struct vcd_info*cur;
for (cur = vcd_list ; cur ; cur = cur->next)
show_this_item(cur);
}
static void vcd_checkpoint_x()
{
struct vcd_info*cur;
for (cur = vcd_list ; cur ; cur = cur->next)
show_this_item_x(cur);
}
static int variable_cb(p_cb_data cause)
{
unsigned long now = cause->time->low;
struct t_cb_data cb;
struct vcd_info*info = (struct vcd_info*)cause->user_data;
/* Reschedule this event so that it happens for the next
trigger on this variable. */
cb = *cause;
vpi_register_cb(&cb);
if (dump_is_off)
return 0;
if (dump_header_pending())
return 0;
if (now != vcd_cur_time) {
lt_set_time(dump_file, now);
vcd_cur_time = now;
}
show_this_item(info);
return 0;
}
static int dumpvars_cb(p_cb_data cause)
{
if (dumpvars_status != 1)
return 0;
dumpvars_status = 2;
dumpvars_time = cause->time->low;
vcd_cur_time = dumpvars_time;
if (!dump_is_off) {
lt_set_time(dump_file, dumpvars_time);
vcd_checkpoint();
}
return 0;
}
inline static int install_dumpvars_callback(void)
{
struct t_cb_data cb;
static struct t_vpi_time time;
if (dumpvars_status == 1)
return 0;
if (dumpvars_status == 2) {
vpi_mcd_printf(6, "VCD Error:"
" $dumpvars ignored,"
" previously called at simtime %lu\n",
dumpvars_time);
return 1;
}
time.type = vpiSimTime;
cb.time = &time;
cb.reason = cbReadOnlySynch;
cb.cb_rtn = dumpvars_cb;
cb.user_data = 0x0;
cb.obj = 0x0;
vpi_register_cb(&cb);
dumpvars_status = 1;
return 0;
}
static int sys_dumpoff_calltf(char*name)
{
s_vpi_time now;
if (dump_is_off)
return 0;
dump_is_off = 1;
if (dump_file == 0)
return 0;
if (dump_header_pending())
return 0;
vpi_get_time(0, &now);
if (now.low > vcd_cur_time)
lt_set_time(dump_file, now.low);
vcd_cur_time = now.low;
vcd_checkpoint_x();
return 0;
}
static int sys_dumpon_calltf(char*name)
{
s_vpi_time now;
if (!dump_is_off)
return 0;
dump_is_off = 0;
if (dump_file == 0)
return 0;
if (dump_header_pending())
return 0;
vpi_get_time(0, &now);
if (now.low > vcd_cur_time)
lt_set_time(dump_file, now.low);
vcd_cur_time = now.low;
vcd_checkpoint();
return 0;
}
static int sys_dumpall_calltf(char*name)
{
s_vpi_time now;
if (dump_file == 0)
return 0;
if (dump_header_pending())
return 0;
vpi_get_time(0, &now);
if (now.low > vcd_cur_time)
lt_set_time(dump_file, now.low);
vcd_cur_time = now.low;
vcd_checkpoint();
return 0;
}
static void *close_dumpfile(void)
{
lt_close(dump_file);
return(dump_file = NULL);
}
static void open_dumpfile(const char*path)
{
dump_file = lt_init(path);
if (dump_file == 0) {
vpi_mcd_printf(6,
"LXT Error: Unable to open %s for output.\n",
path);
return;
} else {
int prec = vpi_get(vpiTimePrecision, 0);
vpi_mcd_printf(4,
"LXT info: dumpfile %s opened for output.\n",
path);
assert(prec >= -15);
lt_set_timescale(dump_file, prec);
lt_set_initial_value(dump_file, 'x');
lt_set_clock_compress(dump_file);
atexit((void(*)(void))close_dumpfile);
}
}
static int sys_dumpfile_calltf(char*name)
{
char*path;
vpiHandle sys = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv = vpi_iterate(vpiArgument, sys);
vpiHandle item;
if (argv && (item = vpi_scan(argv))) {
s_vpi_value value;
if (vpi_get(vpiType, item) != vpiConstant
|| vpi_get(vpiConstType, item) != vpiStringConst) {
vpi_mcd_printf(6,
"LXT Error:"
" %s parameter must be a string constant\n",
name);
return 0;
}
value.format = vpiStringVal;
vpi_get_value(item, &value);
path = strdup(value.value.str);
vpi_free_object(argv);
} else {
path = strdup("dumpfile.lxt");
}
assert(dump_file == 0);
open_dumpfile(path);
free(path);
return 0;
}
/*
Nexus Id cache
In structural models, many signals refer to the same nexus.
Some structural models also have very many signals. This cache
saves nexus_id - vcd_id pairs, and reuses the vcd_id when a signal
refers to a nexus that is already dumped.
The new signal will be listed as a $var, but no callback
will be installed. This saves considerable CPU time and leads
to smalle VCD files.
The _vpiNexusId is a private (int) property of IVL simulators.
*/
struct vcd_id_s
{
const char *id;
struct vcd_id_s *next;
int nex;
};
static inline unsigned ihash(int nex)
{
unsigned a = nex;
a ^= a>>16;
a ^= a>>8;
return a & 0xff;
}
static struct vcd_id_s **vcd_ids;
inline static const char *find_nexus_ident(int nex)
{
struct vcd_id_s *bucket;
if (!vcd_ids) {
vcd_ids = (struct vcd_id_s **)
calloc(256, sizeof(struct vcd_id_s*));
assert(vcd_ids);
}
bucket = vcd_ids[ihash(nex)];
while (bucket) {
if (nex == bucket->nex)
return bucket->id;
bucket = bucket->next;
}
return 0;
}
inline static void set_nexus_ident(int nex, const char *id)
{
struct vcd_id_s *bucket;
assert(vcd_ids);
bucket = (struct vcd_id_s *) malloc(sizeof(struct vcd_id_s));
bucket->next = vcd_ids[ihash(nex)];
bucket->id = id;
bucket->nex = nex;
vcd_ids[ihash(nex)] = bucket;
}
static void scan_item(unsigned depth, vpiHandle item, int skip)
{
struct t_cb_data cb;
struct vcd_info* info;
const char* type;
const char* name;
const char* ident;
int nexus_id;
switch (vpi_get(vpiType, item)) {
case vpiNet: type = "wire"; if(0){
case vpiReg: type = "reg"; }
if (skip)
break;
name = vpi_get_str(vpiName, item);
nexus_id = vpi_get(_vpiNexusId, item);
if (nexus_id) {
ident = find_nexus_ident(nexus_id);
} else {
ident = 0;
}
if (!ident) {
ident = create_full_name(name);
if (nexus_id)
set_nexus_ident(nexus_id, ident);
info = malloc(sizeof(*info));
info->time.type = vpiSimTime;
info->item = item;
info->sym = lt_symbol_add(dump_file, ident, 0 /* array rows */, vpi_get(vpiSize, item)-1, 0, LT_SYM_F_BITS);
cb.time = &info->time;
cb.user_data = (char*)info;
cb.value = NULL;
cb.obj = item;
cb.reason = cbValueChange;
cb.cb_rtn = variable_cb;
info->next = vcd_list;
vcd_list = info;
info->cb = vpi_register_cb(&cb);
}
else
{
char *n = create_full_name(name);
lt_symbol_alias(dump_file, ident, n, vpi_get(vpiSize, item)-1, 0);
free(n);
}
break;
case vpiModule: type = "module"; if(0){
case vpiNamedBegin: type = "begin"; }if(0){
case vpiTask: type = "task"; }if(0){
case vpiFunction: type = "function"; }if(0){
case vpiNamedFork: type = "fork"; }
if (depth > 0) {
int nskip;
vpiHandle argv;
const char* fullname =
vpi_get_str(vpiFullName, item);
vpi_mcd_printf(4,
"LXT info:"
" scanning scope %s, %u levels\n",
fullname, depth);
nskip = sorted_names && fullname
&& vcd_names_search(fullname);
if (!nskip)
vcd_names_add(fullname);
else
vpi_mcd_printf(6,
"LXT warning:"
" ignoring signals"
" in previously scanned scope %s\n",
fullname);
name = vpi_get_str(vpiName, item);
push_scope(name); /* keep in type info determination for possible future usage */
argv = vpi_iterate(vpiInternalScope, item);
if (argv) {
for (item = vpi_scan(argv) ;
item ;
item = vpi_scan(argv)) {
scan_item(depth-1, item, nskip);
}
}
pop_scope();
}
break;
default:
vpi_mcd_printf(6,
"LXT Error: $lxtdumpvars: Unsupported parameter "
"type (%d)\n", vpi_get(vpiType, item));
}
}
static int draw_scope(vpiHandle item)
{
int depth;
const char *name;
char *type;
vpiHandle scope = vpi_handle(vpiScope, item);
if (!scope)
return 0;
depth = 1 + draw_scope(scope);
name = vpi_get_str(vpiName, scope);
switch (vpi_get(vpiType, item)) {
case vpiNamedBegin: type = "begin"; break;
case vpiTask: type = "task"; break;
case vpiFunction: type = "function"; break;
case vpiNamedFork: type = "fork"; break;
default: type = "module"; break;
}
push_scope(name); /* keep in type info determination for possible future usage */
return depth;
}
static int sys_dumpvars_calltf(char*name)
{
unsigned depth;
s_vpi_value value;
vpiHandle item = 0;
vpiHandle sys = vpi_handle(vpiSysTfCall, 0);
vpiHandle argv;
if (dump_file == 0) {
open_dumpfile("dumpfile.lxt");
if (dump_file == 0)
return 0;
}
if (install_dumpvars_callback()) {
return 0;
}
argv = vpi_iterate(vpiArgument, sys);
depth = 0;
if (argv && (item = vpi_scan(argv)))
switch (vpi_get(vpiType, item)) {
case vpiConstant:
case vpiNet:
case vpiReg:
case vpiMemoryWord:
value.format = vpiIntVal;
vpi_get_value(item, &value);
depth = value.value.integer;
break;
}
if (!depth)
depth = 10000;
if (!argv) {
// $dumpvars;
// search for the toplevel module
vpiHandle parent = vpi_handle(vpiScope, sys);
while (parent) {
item = parent;
parent = vpi_handle(vpiScope, item);
}
} else if (!item || !(item = vpi_scan(argv))) {
// $dumpvars(level);
// $dumpvars();
// dump the current scope
item = vpi_handle(vpiScope, sys);
argv = 0x0;
}
for ( ; item; item = argv ? vpi_scan(argv) : 0x0) {
int dep = draw_scope(item);
vcd_names_sort();
scan_item(depth, item, 0);
while (dep--) {
pop_scope();
}
}
return 0;
}
void sys_lxt_register()
{
s_vpi_systf_data tf_data;
tf_data.type = vpiSysTask;
tf_data.tfname = "$lxtdumpall";
tf_data.calltf = sys_dumpall_calltf;
tf_data.compiletf = 0;
tf_data.sizetf = 0;
tf_data.user_data = "$lxtdumpall";
vpi_register_systf(&tf_data);
tf_data.type = vpiSysTask;
tf_data.tfname = "$lxtdumpoff";
tf_data.calltf = sys_dumpoff_calltf;
tf_data.compiletf = 0;
tf_data.sizetf = 0;
tf_data.user_data = "$lxtdumpoff";
vpi_register_systf(&tf_data);
tf_data.type = vpiSysTask;
tf_data.tfname = "$lxtdumpon";
tf_data.calltf = sys_dumpon_calltf;
tf_data.compiletf = 0;
tf_data.sizetf = 0;
tf_data.user_data = "$lxtdumpon";
vpi_register_systf(&tf_data);
tf_data.type = vpiSysTask;
tf_data.tfname = "$lxtdumpfile";
tf_data.calltf = sys_dumpfile_calltf;
tf_data.compiletf = 0;
tf_data.sizetf = 0;
tf_data.user_data = "$lxtdumpfile";
vpi_register_systf(&tf_data);
tf_data.type = vpiSysTask;
tf_data.tfname = "$lxtdumpvars";
tf_data.calltf = sys_dumpvars_calltf;
tf_data.compiletf = 0;
tf_data.sizetf = 0;
tf_data.user_data = "$lxtdumpvars";
vpi_register_systf(&tf_data);
}
/*
* $Log: sys_lxt.c,v $
* Revision 1.1 2002/03/09 21:54:49 steve
* Add LXT dumper support. (Anthony Bybell)
*
*/

7
vpi/sys_table.c
View File

@ -17,7 +17,7 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/ */
#if !defined(WINNT) && !defined(macintosh) #if !defined(WINNT) && !defined(macintosh)
#ident "$Id: sys_table.c,v 1.13 2001/09/30 16:45:10 steve Exp $" #ident "$Id: sys_table.c,v 1.14 2002/03/09 21:54:49 steve Exp $"
#endif #endif
# include "config.h" # include "config.h"
@ -30,6 +30,7 @@ extern void sys_random_register();
extern void sys_readmem_register(); extern void sys_readmem_register();
extern void sys_time_register(); extern void sys_time_register();
extern void sys_vcd_register(); extern void sys_vcd_register();
extern void sys_lxt_register();
void (*vlog_startup_routines[])() = { void (*vlog_startup_routines[])() = {
sys_finish_register, sys_finish_register,
@ -39,12 +40,16 @@ void (*vlog_startup_routines[])() = {
sys_readmem_register, sys_readmem_register,
sys_time_register, sys_time_register,
sys_vcd_register, sys_vcd_register,
sys_lxt_register,
0 0
}; };
/* /*
* $Log: sys_table.c,v $ * $Log: sys_table.c,v $
* Revision 1.14 2002/03/09 21:54:49 steve
* Add LXT dumper support. (Anthony Bybell)
*
* Revision 1.13 2001/09/30 16:45:10 steve * Revision 1.13 2001/09/30 16:45:10 steve
* Fix some Cygwin DLL handling. (Venkat Iyer) * Fix some Cygwin DLL handling. (Venkat Iyer)
* *