TimeType
ghw_main(char *fname)
{
struct ghw_handler handle;
int i;
int rc;
if(!GLOBALS->hier_was_explicitly_set) /* set default hierarchy split char */
{
GLOBALS->hier_delimeter='.';
}
handle.flag_verbose = 0;
if ((rc=ghw_open (&handle, fname)) < 0)
{
fprintf (stderr, "Error opening ghw file '%s', rc=%d.\n", fname, rc);
return(LLDescriptor(0)); /* look at return code in caller for success status... */
}
GLOBALS->time_scale = 1;
GLOBALS->time_dimension = 'f';
GLOBALS->asbuf = malloc_2(4097);
if (ghw_read_base (&handle) < 0)
{
free_2(GLOBALS->asbuf);
GLOBALS->asbuf = NULL;
fprintf (stderr, "Error in ghw file '%s'.\n", fname);
return(LLDescriptor(0)); /* look at return code in caller for success status... */
}
GLOBALS->min_time = 0;
GLOBALS->max_time = 0;
GLOBALS->nbr_sig_ref_ghw_c_1 = 0;
GLOBALS->nxp_ghw_c_1 =(struct Node **)calloc_2(handle.nbr_sigs, sizeof(struct Node *));
for(i=0;i<handle.nbr_sigs;i++)
{
GLOBALS->nxp_ghw_c_1[i] = (struct Node *)calloc_2(1,sizeof(struct Node));
}
GLOBALS->treeroot = build_hierarchy (&handle, handle.hie);
/* GHW does not contains a 'top' name.
FIXME: should use basename of the file. */
create_facs (&handle);
read_traces (&handle);
add_tail (&handle);
set_fac_name (&handle);
free_2(GLOBALS->nxp_ghw_c_1); GLOBALS->nxp_ghw_c_1 = NULL;
/* fix up names on aliased nodes via cloning... */
for(i=0;i<GLOBALS->numfacs;i++)
{
if(strcmp(GLOBALS->facs[i]->name, GLOBALS->facs[i]->n->nname))
{
struct Node *n = malloc_2(sizeof(struct Node));
memcpy(n, GLOBALS->facs[i]->n, sizeof(struct Node));
GLOBALS->facs[i]->n = n;
n->nname = GLOBALS->facs[i]->name;
}
}
/* treeroot->name = "top"; */
{
const char *base_hier = "top";
struct tree *t = calloc_2(1, sizeof(struct tree) + strlen(base_hier) + 1);
memcpy(t, GLOBALS->treeroot, sizeof(struct tree));
strcpy(t->name, base_hier); /* scan-build false warning here, thinks name[1] is total length */
#ifndef WAVE_TALLOC_POOL_SIZE
free_2(GLOBALS->treeroot); /* if using tree alloc pool, can't deallocate this */
#endif
GLOBALS->treeroot = t;
}
ghw_close (&handle);
rechain_facs(); /* vectorize bitblasted nets */
ghw_sortfacs(); /* sort nets as ghw is unsorted ... also fix hier tree (it should really be built *after* facs are sorted!) */
#if 0
treedebug(GLOBALS->treeroot,"");
facs_debug();
#endif
GLOBALS->is_ghw = 1;
fprintf(stderr, "["TTFormat"] start time.\n["TTFormat"] end time.\n", GLOBALS->min_time*GLOBALS->time_scale, GLOBALS->max_time*GLOBALS->time_scale);
if(GLOBALS->num_glitches_ghw_c_1) fprintf(stderr, "Warning: encountered %d glitch%s across %d glitch region%s.\n",
GLOBALS->num_glitches_ghw_c_1, (GLOBALS->num_glitches_ghw_c_1!=1)?"es":"",
GLOBALS->num_glitch_regions_ghw_c_1, (GLOBALS->num_glitch_regions_ghw_c_1!=1)?"s":"");
return GLOBALS->max_time;
}
int
main (int argc, char **argv)
{
int i;
int flag_disp_types;
int flag_disp_hierarchy;
int flag_disp_time;
int flag_disp_signals;
int flag_list;
int flag_verbose;
int eof;
enum ghw_sm_type sm;
progname = argv[0];
flag_disp_types = 0;
flag_disp_hierarchy = 0;
flag_disp_time = 0;
flag_disp_signals = 0;
flag_list = 0;
flag_verbose = 0;
WAVE_LOCALE_FIX
while (1)
{
int c;
c = getopt (argc, argv, "thTslv");
if (c == -1)
break;
switch (c)
{
case 't':
flag_disp_types = 1;
break;
case 'h':
flag_disp_hierarchy = 1;
break;
case 'T':
flag_disp_time = 1;
break;
case 's':
flag_disp_signals = 1;
flag_disp_time = 1;
break;
case 'l':
flag_list = 1;
break;
case 'v':
flag_verbose++;
break;
default:
usage ();
exit (2);
}
}
if (optind >= argc)
{
usage ();
return 1;
}
for (i = optind; i < argc; i++)
{
struct ghw_handler h;
struct ghw_handler *hp = &h;
hp->flag_verbose = flag_verbose;
if (ghw_open (hp, argv[i]) != 0)
{
fprintf (stderr, "cannot open ghw file %s\n", argv[i]);
return 1;
}
if (flag_list)
{
while (1)
{
int section;
section = ghw_read_section (hp);
if (section == -2)
{
printf ("eof of file\n");
break;
}
else if (section < 0)
{
printf ("Error in file\n");
break;
}
else if (section == 0)
{
printf ("Unknown section\n");
break;
}
printf ("Section %s\n", ghw_sections[section].name);
if ((*ghw_sections[section].handler)(hp) < 0)
break;
}
}
else
{
if (ghw_read_base (hp) < 0)
{
fprintf (stderr, "cannot read ghw file\n");
return 2;
}
if (0)
{
int ix;
printf ("String table:\n");
for (ix = 1; ix < hp->nbr_str; ix++)
printf (" %s\n", hp->str_table[ix]);
}
if (flag_disp_types)
ghw_disp_types (hp);
if (flag_disp_hierarchy)
ghw_disp_hie (hp, hp->hie);
#if 1
sm = ghw_sm_init;
eof = 0;
while (!eof)
{
switch (ghw_read_sm (hp, &sm))
{
case ghw_res_snapshot:
case ghw_res_cycle:
if (flag_disp_time)
printf ("Time is "GHWLLD" fs\n", hp->snap_time);
if (flag_disp_signals)
ghw_disp_values (hp);
break;
case ghw_res_eof:
eof = 1;
break;
default:
abort ();
}
}
#else
if (ghw_read_dump (hp) < 0)
{
fprintf (stderr, "error in ghw dump\n");
return 3;
}
#endif
}
ghw_close (&h);
}
return 0;
}