lxt.c File Reference

#include "assert.h"
#include "defines.h"
#include "lxt2_read.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <inttypes.h>
#include "symtable.h"
#include "db.h"
#include "util.h"

Functions
static char *	vcdid (int value)
static void	vcd_callback (struct lxt2_rd_trace **lt, lxtint64_t *pnt_time, lxtint32_t *pnt_facidx, char **pnt_value)
void	lxt_parse (const char *lxt_file)
	Parses and scores LXT-style dumpfile.
Variables
char	user_msg [USER_MSG_LENGTH]
symtable *	vcd_symtab
int	vcd_symtab_size
symtable **	timestep_tab
char **	curr_inst_scope
int	curr_inst_scope_size
static lxtint64_t	vcd_prevtime = 0
static bool	vcd_prevtime_valid = FALSE
static bool	vcd_blackout

---

Function Documentation

void lxt_parse

(

const char *

lxt_file

)

Parses and scores LXT-style dumpfile.

Exceptions:

anonymous

db_do_timestep Throw Throw Throw lxt2_rd_iter_blocks

Main LXT parsing function. Reads in an LXT-style dumpfile, tells Covered about signal information and simulation results.

Parameters:

lxt_file

Name of LXT file to read and score

References Catch_anonymous, curr_inst_scope, curr_inst_scope_size, db_assign_symbol(), db_check_dumpfile_scopes(), db_do_timestep(), db_sync_curr_instance(), FALSE, FATAL, lxt2_rd_geometry::flags, free_safe, lxt2_rd_geometry::len, lxt2_rd_geometry::lsb, lxt2_rd_close(), lxt2_rd_get_alias_root(), lxt2_rd_get_fac_geometry(), lxt2_rd_get_facname(), lxt2_rd_get_num_facs(), lxt2_rd_init(), lxt2_rd_iter_blocks(), lxt2_rd_set_fac_process_mask_all(), lxt2_rd_set_max_block_mem_usage(), LXT2_RD_SYM_F_DOUBLE, LXT2_RD_SYM_F_STRING, malloc_safe, malloc_safe_nolimit, lxt2_rd_geometry::msb, lxt2_rd_trace::numfacs, print_output(), PROFILE, PROFILE_END, scope_extract_back(), symtable_create(), symtable_dealloc(), Throw, Try, vcd_callback(), vcd_prevtime, vcd_prevtime_valid, vcd_symtab_size, and vcdid().

Referenced by parse_and_score_dumpfile().

  { PROFILE(LXT_PARSE);

  struct lxt2_rd_trace*    lt;             /* LXT read structure */
  int                      i;              /* Loop iterator */
  int                      numfacs;        /* Number of symbols in design */
  struct lxt2_rd_geometry* g;
  lxtint32_t               newindx;
  char                     netname[4096];  /* Name of current signal */

  /* Open LXT file for opening and extract members */
  if( (lt = lxt2_rd_init( lxt_file )) != NULL ) {

    numfacs = lxt2_rd_get_num_facs( lt );

    (void)lxt2_rd_set_fac_process_mask_all( lt );
    (void)lxt2_rd_set_max_block_mem_usage( lt, 0 ); /* no need to cache blocks */

    /* Create initial symbol table */
    vcd_symtab = symtable_create();

    /* Allocate memory for instance scope */
    curr_inst_scope      = (char**)malloc_safe( sizeof( char* ) );
    curr_inst_scope[0]   = (char*)malloc_safe( 4096 );
    curr_inst_scope_size = 1;

    Try {

      /* Get symbol information */
      for( i=0; i<numfacs; i++ ) {

        g       = lxt2_rd_get_fac_geometry( lt, i );
        newindx = lxt2_rd_get_alias_root( lt, i );

        /* Extract scope and net name from facility name */
        scope_extract_back( lxt2_rd_get_facname( lt, i ), netname, curr_inst_scope[0] );
        db_sync_curr_instance();

        if( g->flags & LXT2_RD_SYM_F_DOUBLE ) {

          db_assign_symbol( netname, vcdid( newindx ), 63, 0 );

        } else if( g->flags & LXT2_RD_SYM_F_STRING ) {

          /* We ignore string values at the moment */

        } else {

          if( g->len == 1 ) {
            if( g->msb != 0 ) {
              db_assign_symbol( netname, vcdid( newindx ), g->msb, g->msb );
            } else {
              db_assign_symbol( netname, vcdid( newindx ), 0, 0 );
            }
          } else {
            db_assign_symbol( netname, vcdid( newindx ), g->msb, g->lsb );
          }

        }

      }

      /* Check to see that at least one instance was found */
      db_check_dumpfile_scopes();

      /* Create timestep symbol table array */
      if( vcd_symtab_size > 0 ) {
        timestep_tab = malloc_safe_nolimit( sizeof( symtable*) * vcd_symtab_size );
      }

      /* Perform simulation */
      (void)lxt2_rd_iter_blocks( lt, vcd_callback, NULL );

      /* Perform last simulation if necessary */
      if( vcd_prevtime_valid ) {
        (void)db_do_timestep( vcd_prevtime, FALSE );
      }

    } Catch_anonymous {
      assert( curr_inst_scope_size == 1 );
      free_safe( curr_inst_scope[0], 4096 );
      free_safe( curr_inst_scope, sizeof( char* ) );
      curr_inst_scope      = NULL;
      curr_inst_scope_size = 0;
      symtable_dealloc( vcd_symtab );
      free_safe( timestep_tab, (sizeof( symtable* ) * vcd_symtab_size) );
      lxt2_rd_close( lt );
      Throw 0;
    }

    /* Deallocate memory */
    assert( curr_inst_scope_size == 1 );
    free_safe( curr_inst_scope[0], 4096 );
    free_safe( curr_inst_scope, sizeof( char* ) );
    curr_inst_scope      = NULL;
    curr_inst_scope_size = 0;
    symtable_dealloc( vcd_symtab );
    free_safe( timestep_tab, (sizeof( symtable* ) * vcd_symtab_size) );

    /* Close LXT file */
    lxt2_rd_close( lt );

  } else {

    print_output( "Unable to read data from LXT dumpfile.  Exiting without scoring.", FATAL, __FILE__, __LINE__ );
    Throw 0;

  }

  PROFILE_END;

}

static void vcd_callback	(	struct lxt2_rd_trace **	lt,
		lxtint64_t *	pnt_time,
		lxtint32_t *	pnt_facidx,
		char **	pnt_value
	)			[static]

Exceptions:

anonymous

db_do_timestep

References db_do_timestep(), db_set_symbol_char(), db_set_symbol_string(), FALSE, lxt2_rd_geometry::flags, lxt2_rd_geometry::len, lxt2_rd_get_fac_geometry(), LXT2_RD_SYM_F_DOUBLE, LXT2_RD_SYM_F_STRING, PROFILE, PROFILE_END, TRUE, vcd_blackout, vcd_prevtime, vcd_prevtime_valid, and vcdid().

Referenced by lxt_parse().

  { PROFILE(VCD_CALLBACK);

  struct lxt2_rd_geometry *g = lxt2_rd_get_fac_geometry( *lt, *pnt_facidx );

  /* If this is a new timestamp, perform a simulation */
  if( (vcd_prevtime != *pnt_time) || !vcd_prevtime_valid ) {
    if( vcd_prevtime_valid ) {
      (void)db_do_timestep( vcd_prevtime, FALSE );
    }
    vcd_prevtime       = *pnt_time;
    vcd_prevtime_valid = TRUE;
  }

  /* Handle dumpon/off information */
  if( !(*pnt_value)[0] ) {
    if( !vcd_blackout ) {
      vcd_blackout = TRUE;
    }
    return;
  } else {
    if( vcd_blackout ) {
      vcd_blackout = FALSE;
    }   
  }

  if( g->flags & LXT2_RD_SYM_F_DOUBLE ) {

    db_set_symbol_string( vcdid( *pnt_facidx ), *pnt_value );

  } else if( g->flags & LXT2_RD_SYM_F_STRING ) {

    /* We ignore string values for now */

  } else {

    if( g->len==1 ) {
      db_set_symbol_char( vcdid( *pnt_facidx ), (*pnt_value)[0] );
    } else {                        
      db_set_symbol_string( vcdid( *pnt_facidx ), *pnt_value );
    }

  }                               

  PROFILE_END;

}

static char* vcdid

(

int

value

)

[static]

Returns:

Returns a unique string ID for the given value

Parameters:

value

Unique ID for a specific signal

References PROFILE, and PROFILE_END.

Referenced by lxt_parse(), and vcd_callback().

  { PROFILE(VCDID);

  static char buf[16];
  int         i;

  for( i=0; i<15; i++ ) {
    buf[i] = (char)((value % 94) + 33); /* for range 33..126 */
    value  = value / 94;
    if( !value ) {
      buf[i+1] = 0;
      break;
    }
  }

  PROFILE_END;

  return( buf );

}

---

Variable Documentation

char** curr_inst_scope

Specifies the string Verilog scope that is currently specified in the VCD file.

int curr_inst_scope_size

Current size of curr_inst_scope array

symtable** timestep_tab

Pointer to the current timestep table array. Please see the file description for how this structure is used.

char user_msg[USER_MSG_LENGTH]

Parameters:

lxt.c

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

1/25/2006

Note:

This file is based on the lxt2vcd utility that comes with GtkWave-1.3.82

Holds some output that will be displayed via the print_output command. This is created globally so that memory does not need to be reallocated for each function that wishes to use it.

bool vcd_blackout [static]

Specifies when we are handling dumping

Referenced by vcd_callback().

lxtint64_t vcd_prevtime = 0 [static]

Specifies the last timestamp simulated

Referenced by lxt_parse(), and vcd_callback().

bool vcd_prevtime_valid = FALSE [static]

Specifies the vcd_prevtime value has been assigned by the simulator

Referenced by lxt_parse(), and vcd_callback().

symtable* vcd_symtab

Pointer to the VCD symbol table. Please see the file description for how this structure is used.

int vcd_symtab_size

Maintains current number of nodes in the VCD symbol table. This value is used to create the appropriately sized timestep_tab array.