From 9ec35a2348c7a426ef08fd3cacc19f7b30274383 Mon Sep 17 00:00:00 2001 From: Wilson Snyder Date: Sun, 23 Nov 2014 21:06:10 -0500 Subject: [PATCH] New verilator_coverage and infrastructure to replace SystemPerl's vcoverage. --- .gitignore | 1 + Changes | 2 + MANIFEST.SKIP | 1 + Makefile.in | 17 +- TODO | 17 -- bin/verilator | 8 +- bin/verilator_coverage | 290 +++++++++++++++++++ include/verilated_cov.cpp | 451 ++++++++++++++++++++++++++++++ include/verilated_cov.h | 146 ++++++++++ include/verilated_cov_key.h | 147 ++++++++++ src/Makefile.in | 8 +- src/Makefile_obj.in | 25 +- src/V3EmitC.cpp | 6 +- src/V3EmitMk.cpp | 6 +- src/V3File.h | 1 - src/V3Options.cpp | 12 +- src/VlcBucket.h | 133 +++++++++ src/VlcMain.cpp | 202 +++++++++++++ src/VlcOptions.h | 87 ++++++ src/VlcPoint.h | 152 ++++++++++ src/VlcSource.h | 145 ++++++++++ src/VlcTest.h | 137 +++++++++ src/VlcTop.cpp | 263 +++++++++++++++++ src/VlcTop.h | 69 +++++ src/astgen | 8 +- src/vlcovgen | 173 ++++++++++++ test_regress/driver.pl | 4 +- test_regress/t/t_cover_line.out | 170 +++++++++++ test_regress/t/t_cover_line_cc.pl | 9 +- test_regress/t/t_help.pl | 1 + test_regress/t/t_vlcov_data_a.dat | 5 + test_regress/t/t_vlcov_data_b.dat | 5 + test_regress/t/t_vlcov_data_c.dat | 2 + test_regress/t/t_vlcov_data_d.dat | 2 + test_regress/t/t_vlcov_merge.out | 8 + test_regress/t/t_vlcov_merge.pl | 21 ++ test_regress/t/t_vlcov_rank.out | 6 + test_regress/t/t_vlcov_rank.pl | 23 ++ test_regress/t/t_vlcov_rewrite.pl | 25 ++ test_sp/Makefile | 10 +- 40 files changed, 2737 insertions(+), 61 deletions(-) create mode 100755 bin/verilator_coverage create mode 100644 include/verilated_cov.cpp create mode 100644 include/verilated_cov.h create mode 100644 include/verilated_cov_key.h create mode 100644 src/VlcBucket.h create mode 100644 src/VlcMain.cpp create mode 100644 src/VlcOptions.h create mode 100644 src/VlcPoint.h create mode 100644 src/VlcSource.h create mode 100644 src/VlcTest.h create mode 100644 src/VlcTop.cpp create mode 100644 src/VlcTop.h create mode 100755 src/vlcovgen create mode 100644 test_regress/t/t_cover_line.out create mode 100644 test_regress/t/t_vlcov_data_a.dat create mode 100644 test_regress/t/t_vlcov_data_b.dat create mode 100644 test_regress/t/t_vlcov_data_c.dat create mode 100644 test_regress/t/t_vlcov_data_d.dat create mode 100644 test_regress/t/t_vlcov_merge.out create mode 100755 test_regress/t/t_vlcov_merge.pl create mode 100644 test_regress/t/t_vlcov_rank.out create mode 100755 test_regress/t/t_vlcov_rank.pl create mode 100755 test_regress/t/t_vlcov_rewrite.pl diff --git a/.gitignore b/.gitignore index 9b7b2e82d..7fc9bdb2c 100644 --- a/.gitignore +++ b/.gitignore @@ -23,3 +23,4 @@ gdbrun* internals.txt verilator.txt verilator_bin* +verilator_coverage_bin* diff --git a/Changes b/Changes index 2142d647e..8b9254628 100644 --- a/Changes +++ b/Changes @@ -5,6 +5,8 @@ indicates the contributor was also the author of the fix; Thanks! * Verilator 3.867 devel +** New verilator_coverage program added to replace SystemPerl's vcoverage. + ** PSL support was removed, please use System Verilog assertions. diff --git a/MANIFEST.SKIP b/MANIFEST.SKIP index 8ff54eaa7..ca6161f03 100644 --- a/MANIFEST.SKIP +++ b/MANIFEST.SKIP @@ -28,6 +28,7 @@ config.status$ verilator.log verilator.tex verilator_bin.* +verilator_coverage_bin.* .vcsmx_rebuild$ autom4te\.cache/ nodist/ diff --git a/Makefile.in b/Makefile.in index d7cf4c9dd..3c9c0ad38 100644 --- a/Makefile.in +++ b/Makefile.in @@ -122,6 +122,7 @@ DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \ .*attributes */.*attributes */*/.*attributes \ src/.*ignore src/*.in src/*.cpp src/*.[chly] \ src/astgen src/bisonpre src/*fix src/cppcheck_filtered \ + src/vlcovgen \ src/.gdbinit \ src/*.pl src/*.pod \ test_*/.*ignore test_*/Makefile* test_*/*.cpp \ @@ -140,6 +141,7 @@ DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \ INST_PROJ_FILES = \ bin/verilator \ + bin/verilator_coverage \ bin/verilator_includer \ bin/verilator_profcfunc \ include/verilated.mk \ @@ -149,6 +151,7 @@ INST_PROJ_FILES = \ INST_PROJ_BIN_FILES = \ verilator_bin \ verilator_bin_dbg \ + verilator_coverage_bin_dbg \ DISTFILES := $(DISTFILES_INC) @@ -165,7 +168,8 @@ all_nomsg: verilator_exe $(VL_INST_MAN_FILES) .PHONY:verilator_exe .PHONY:verilator_bin .PHONY:verilator_bin_dbg -verilator_exe verilator_bin verilator_bin_dbg: +.PHONY:verilator_coverage_bin_dbg +verilator_exe verilator_bin verilator_bin_dbg verilator_coverage_bin_dbg: @echo ------------------------------------------------------------ @echo "making verilator in src" ; \ (cd src && $(MAKE) $(OBJCACHE_JOBS) ) @@ -261,8 +265,8 @@ internals.pdf: internals.pod Makefile -rm -f internals.toc internals.aux internals.idx internals.out # See uninstall also - don't put wildcards in this variable, it might uninstall other stuff -VL_INST_BIN_FILES = verilator verilator_bin verilator_bin_dbg \ - verilator_includer verilator_profcfunc +VL_INST_BIN_FILES = verilator verilator_bin verilator_bin_dbg verilator_coverage_bin_dbg \ + verilator_coverage verilator_includer verilator_profcfunc # Some scripts go into both the search path and pkgdatadir, # so they can be found by the user, and under $VERILATOR_ROOT. @@ -286,9 +290,11 @@ VL_INST_DATA_SRCDIR_FILES = \ installbin: $(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(bindir) ( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator $(DESTDIR)$(bindir)/verilator ) + ( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_coverage $(DESTDIR)$(bindir)/verilator_coverage ) ( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_profcfunc $(DESTDIR)$(bindir)/verilator_profcfunc ) ( $(INSTALL_PROGRAM) verilator_bin $(DESTDIR)$(bindir)/verilator_bin ) ( $(INSTALL_PROGRAM) verilator_bin_dbg $(DESTDIR)$(bindir)/verilator_bin_dbg ) + ( $(INSTALL_PROGRAM) verilator_coverage_bin_dbg $(DESTDIR)$(bindir)/verilator_coverage_bin_dbg ) $(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/bin ( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_includer $(DESTDIR)$(pkgdatadir)/bin/verilator_includer ) @@ -351,6 +357,7 @@ INST_PROJ_CVS = cp_if_cvs_diff install-project: dist @echo "Install-project to $(DIRPROJECT)" strip verilator_bin* + strip verilator_coverage_bin* $(MAKE) install-project-quick for p in $(VL_INST_MAN_FILES) ; do \ $(INSTALL_DATA) $$p $(DIRPROJECT_PREFIX)/man/man1/$$p; \ @@ -374,6 +381,7 @@ endif install-cadtools: dist @echo "Install-project to $(CAD_DIR)" strip verilator_bin* + strip verilator_coverage_bin* $(MAKE) install-cadtools-quick $(SHELL) ${srcdir}/mkinstalldirs $(VERILATOR_CAD_DIR)/man/man1 for p in $(VL_INST_MAN_FILES) ; do \ @@ -459,7 +467,8 @@ clean mostlyclean distclean maintainer-clean:: rm -f *.tex distclean maintainer-clean:: - rm -f Makefile config.status config.cache config.log verilator_bin* TAGS + rm -f Makefile config.status config.cache config.log TAGS + rm -f verilator_bin* verilator_coverage_bin* rm -f include/verilated.mk include/verilated_config.h TAGFILES=${srcdir}/*/*.cpp ${srcdir}/*/*.h ${srcdir}/*/*.in \ diff --git a/TODO b/TODO index 15410b544..5c84ebe08 100755 --- a/TODO +++ b/TODO @@ -30,23 +30,6 @@ Configure/Make/Install * Full MSVC++ compilation (does scons support this?) (4.000?) * Distribute with flex/bison already expanded? Flex library not needed. Probably too difficult to be worth it. - * Integrate SystemPerl coverage - see the SystemPerl git branch coverage_only - (Note in /usr/include there are no upper cased include files.) - Coverage.pm -- Need all functionality, but in C? - Coverage/Item.pm -- Need all functionality, but in C? - Coverage/ItemKey.pm -- Need all functionality, but in C? - sp_preproc -- Some steps in here need to be moved to generated C - -- -- note uses Verilog::Getopt - src/Sp.cpp -- n/a - src/SpCommon.h -- mostly overlaps verilatedos.h - src/SpCoverage.cpp/h -- All needed - src/SpFunctor.cpp/h -- No longer used - src/SpTraceVcd.cpp/h -- MOVED - src/SpTraceVcdC.cpp/h -- MOVED - src/sp_log.cpp/h -- Not needed - src/systemperl.h -- some stuff may be cut - vcoverage -- Need all functionality, but in C? Testing: * Move test_c/sp/v/verilated into test_regress format (4.000?) diff --git a/bin/verilator b/bin/verilator index 2ddd82646..1e0475cf6 100755 --- a/bin/verilator +++ b/bin/verilator @@ -3528,9 +3528,9 @@ Verilator's, it will do this for you.) Run your tests in different directories. Each test will create a logs/coverage.pl file. -After running all of your tests, the vcoverage utility (from the SystemPerl -package) is executed. Vcoverage reads the logs/coverage.pl file(s), and -creates an annotated source code listing showing code coverage details. +After running all of your tests, verilator_coverage is executed. +Verilator_coverage reads the logs/coverage.pl file(s), and creates an +annotated source code listing showing code coverage details. For an example, after running 'make test' in the Verilator distribution, see the test_sp/logs/coverage_source directory. Grep for lines starting @@ -3825,7 +3825,7 @@ Major concepts by Paul Wasson and Duane Galbi. =head1 SEE ALSO -L, L, L, L, +L, L, L, L which is the source for this document, diff --git a/bin/verilator_coverage b/bin/verilator_coverage new file mode 100755 index 000000000..c9aa7409f --- /dev/null +++ b/bin/verilator_coverage @@ -0,0 +1,290 @@ +: # -*-Mode: perl;-*- use perl, wherever it is +eval 'exec perl -wS $0 ${1+"$@"}' + if 0; +###################################################################### +# +# Copyright 2003-2014 by Wilson Snyder. This program is free software; you +# can redistribute it and/or modify it under the terms of either the GNU +# Lesser General Public License Version 3 or the Perl Artistic License +# Version 2.0. +# +# 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. +# +###################################################################### + +require 5.006_001; +use warnings; +BEGIN { + if ($ENV{DIRPROJECT} && $ENV{DIRPROJECT_PERL_BOOT}) { + # Magic to allow author testing of perl packages in local directory + require $ENV{DIRPROJECT}."/".$ENV{DIRPROJECT_PERL_BOOT}; + } +} + +use Getopt::Long; +use FindBin qw($RealBin $RealScript); +use Pod::Usage; +use Cwd qw(abs_path getcwd); + +use strict; +use vars qw ($Debug @Opt_Verilator_Sw); + +####################################################################### +####################################################################### +# main + +autoflush STDOUT 1; +autoflush STDERR 1; + +$Debug = 0; + +# No arguments can't do anything useful. Give help +if ($#ARGV < 0) { + pod2usage(-exitstatus=>2, -verbose=>0); +} + +# We sneak a look at the flags so we can do some pre-environment checks +# All flags will hit verilator... +foreach my $sw (@ARGV) { + $sw = "'$sw'" if $sw =~ m![^---a-zA-Z0-9_/\\:.+]!; + push @Opt_Verilator_Sw, $sw; +} + +Getopt::Long::config ("no_auto_abbrev","pass_through"); +if (! GetOptions ( + # Major operating modes + "help" => \&usage, + "debug:s" => \&debug, + # "version!" => \&version, # Also passthru'ed + # Additional parameters + "<>" => sub {}, # Ignored + )) { + pod2usage(-exitstatus=>2, -verbose=>0); +} + +# Normal, non gdb +run (verilator_coverage_bin() + ." ".join(' ',@Opt_Verilator_Sw)); + +#---------------------------------------------------------------------- + +sub usage { + pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT); +} + +sub debug { + shift; + my $level = shift; + $Debug = $level||3; +} + +####################################################################### +####################################################################### +# Builds + +sub verilator_coverage_bin { + my $bin = ""; + # Use VERILATOR_ROOT if defined, else assume verilator_bin is in the search path + my $basename = ($ENV{VERILATOR_COVERAGE_BIN} + || "verilator_coverage_bin_dbg"); + if (defined($ENV{VERILATOR_ROOT})) { + my $dir = $ENV{VERILATOR_ROOT}; + if (-x "$dir/bin/$basename") { # From a "make install" into VERILATOR_ROOT + $bin = "$dir/bin/$basename"; + } else { + $bin = "$dir/$basename"; # From pointing to kit directory + } + } else { + if (-x "$RealBin/$basename") { + $bin = "$RealBin/$basename"; # From path/to/verilator with verilator_bin installed + } else { + $bin = $basename; # Find in PATH + } + # Note we don't look under bin/$basename which would be right if running + # in the kit dir. Running that would likely break, since + # VERILATOR_ROOT wouldn't be set and Verilator won't find internal files. + } + return $bin; +} + +####################################################################### +####################################################################### +# Utilities + +sub run { + # Run command, check errors + my $command = shift; + $! = undef; # Cleanup -x + print "\t$command\n" if $Debug>=3; + system($command); + my $status = $?; + if ($status) { + if ($! =~ /no such file or directory/i) { + warn "%Error: verilator_coverage: Misinstalled, or VERILATOR_ROOT might need to be in environment\n"; + } + if ($Debug) { # For easy rerunning + warn "%Error: export VERILATOR_ROOT=".($ENV{VERILATOR_ROOT}||"")."\n"; + warn "%Error: $command\n"; + } + if ($status & 127) { + if (($status & 127) == 8 || ($status & 127) == 11) { # SIGFPA or SIGSEGV + warn "%Error: Verilator_coverage internal fault, sorry.\n" if !$Debug; + } elsif (($status & 127) == 6) { # SIGABRT + warn "%Error: Verilator_coverage aborted.\n" if !$Debug; + } else { + warn "%Error: Verilator_coverage threw signal $status.\n" if !$Debug; + } + } + die "%Error: Command Failed $command\n"; + } +} + +####################################################################### +####################################################################### +package main; +__END__ + +=pod + +=head1 NAME + +verilator_coverage - Verilator coverage analyzer + +=head1 SYNOPSIS + + verilator_coverage --help + verilator_coverage --version + + verilator_coverage --annotate + + verilator_coverage -write merged.dat -read ... + +Verilator_coverage processes Verilator coverage reports. + +With --anotate, it reads the specified data file and generates annotated +source code with coverage metrics annotated. If multiple coverage points +exist on the same line, additional lines will be inserted to report the +additional points. + +Additional Verilog-standard arguments specify the search paths necessary to +find the source code that the coverage analysis was performed on. + +To get correct coverage percentages, you may wish to read logs/coverage.pl +into Emacs and do a M-x keep-lines to include only those statistics of +interest. + +For Verilog conditions that should never occur, you should add a $stop +statement. This will remove the coverage during the next build. + +=head1 ARGUMENTS + +=over 4 + +=item I + +Specify input data file, may be repeated to read multiple inputs. If no +data file is specified, by default coverage.dat is read. + +=item --annotate I + +Sprcifies the directory name that source files with annotated coverage data +should be written to. + +=item --annotate-all + +Specifies all files should be shown. By default, only those source files +which have low coverage are written to the output directory. + +=item --annotate-min I + +Specifies the minimum occurrence count that should be flagged if the +coverage point does not include a specified threshold. Defaults to 10. + +=item --help + +Displays this message and program version and exits. + +=item --rank + +Print an experimental report listing the relative importance of each test +in covering all of the coverage points. The report shows "Covered" which +indicates the number of points that test covers; a test is considered to +cover a point if it has a bucket count of at least 1. The "rank" column has +a higher number t indicate the test is more important, and rank 0 means the +test does not need to be run to cover the points. "RankPts" indicates the +number of coverage points this test will contribute to overall coverage if +all tests are run in the order of highest to lowest rank. + +=item --unlink + +When using --write to combine coverage data, unlink all input files after +the output has been created. + +=item --version + +Displays program version and exits. + +=item --write I + +Specifies the aggregate coverage results, summed across all the files, +should be written to the given filename. This is useful in scripts to +combine many sequential runs into one master coverage file. + +=back + +=head1 VERILOG ARGUMENTS + +The following arguments are compatible with GCC, VCS and most Verilog +programs. + +=over 4 + +=item +libext+I+I... + +Defines the extensions for Verilog files. + +=item +define+I+I +=item -DI=I + +Defines the given variable. + +=item +incdir+I +=item -II + +Specifies a directory for finding include files. + +=item -f I + +Specifies a file containing additional command line arguments. + +=item -y I + +Specifies a module search directory. + +=back + +=head1 DISTRIBUTION + +The latest version is available from L. + +Copyright 2003-2014 by Wilson Snyder. Verilator is free software; you can +redistribute it and/or modify the Verilator internals under the terms of +either the GNU Lesser General Public License Version 3 or the Perl Artistic +License Version 2.0. + +=head1 AUTHORS + +Wilson Snyder + +=head1 SEE ALSO + +C + +L which is the source for this document. + +=cut + +###################################################################### diff --git a/include/verilated_cov.cpp b/include/verilated_cov.cpp new file mode 100644 index 000000000..9091277fc --- /dev/null +++ b/include/verilated_cov.cpp @@ -0,0 +1,451 @@ +// -*- mode: C++; c-file-style: "cc-mode" -*- +//============================================================================= +// +// THIS MODULE IS PUBLICLY LICENSED +// +// Copyright 2001-2014 by Wilson Snyder. This program is free software; +// you can redistribute it and/or modify it under the terms of either the GNU +// Lesser General Public License Version 3 or the Perl Artistic License Version 2.0. +// +// This 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. +// +//============================================================================= +/// +/// \file +/// \brief Verilator coverage analysis +/// +/// AUTHOR: Wilson Snyder +/// +//============================================================================= + +#include "verilatedos.h" +#include "verilated.h" +#include "verilated_cov.h" +#include "verilated_cov_key.h" + +#include +#include +#include + +//============================================================================= +// VerilatedCovImpBase +/// Implementation base class for constants + +struct VerilatedCovImpBase { + // TYPES + enum { MAX_KEYS = 33 }; /// Maximum user arguments + filename+lineno + enum { KEY_UNDEF = 0 }; /// Magic key # for unspecified values +}; + +//============================================================================= +// VerilatedCovImpItem +/// Implementation class for a VerilatedCov item + +class VerilatedCovImpItem : VerilatedCovImpBase { +public: // But only local to this file + // MEMBERS + int m_keys[MAX_KEYS]; ///< Key + int m_vals[MAX_KEYS]; ///< Value for specified key + // CONSTRUCTORS + // Derived classes should call zero() in their constructor + VerilatedCovImpItem() { + for (int i=0; i class VerilatedCoverItemSpec : public VerilatedCovImpItem { +private: + // MEMBERS + T* m_countp; ///< Count value +public: + // METHODS + virtual vluint64_t count() const { return *m_countp; } + virtual void zero() const { *m_countp = 0; } + // CONSTRUCTORS + VerilatedCoverItemSpec(T* countp) : m_countp(countp) { zero(); } + virtual ~VerilatedCoverItemSpec() {} +}; + +//============================================================================= +// VerilatedCovImp +/// Implementation class for VerilatedCov. See that class for public method information. +/// All value and keys are indexed into a unique number. Thus we can greatly reduce +/// the storage requirements for otherwise identical keys. + +class VerilatedCovImp : VerilatedCovImpBase { +private: + // TYPES + typedef map ValueIndexMap; + typedef map IndexValueMap; + typedef deque ItemList; + +private: + // MEMBERS + ValueIndexMap m_valueIndexes; ///< For each key/value a unique arbitrary index value + IndexValueMap m_indexValues; ///< For each key/value a unique arbitrary index value + ItemList m_items; ///< List of all items + + VerilatedCovImpItem* m_insertp; ///< Item about to insert + const char* m_insertFilenamep; ///< Filename about to insert + int m_insertLineno; ///< Line number about to insert + + // CONSTRUCTORS + VerilatedCovImp() { + m_insertp = NULL; + m_insertFilenamep = NULL; + m_insertLineno = 0; + } +public: + ~VerilatedCovImp() { clear(); } + static VerilatedCovImp& imp() { + static VerilatedCovImp s_singleton; + return s_singleton; + } + +private: + // PRIVATE METHODS + int valueIndex(const string& value) { + static int nextIndex = KEY_UNDEF+1; + ValueIndexMap::iterator iter = m_valueIndexes.find(value); + if (iter != m_valueIndexes.end()) return iter->second; + nextIndex++; assert(nextIndex>0); + m_valueIndexes.insert(make_pair(value, nextIndex)); + m_indexValues.insert(make_pair(nextIndex, value)); + return nextIndex; + } + string dequote(const string& text) { + // Quote any special characters + string rtn; + for (const char* pos = text.c_str(); *pos; pos++) { + if (!isprint(*pos) || *pos=='%' || *pos=='"') { + char hex[10]; sprintf(hex,"%%%02X",pos[0]); + rtn += hex; + } else { + rtn += *pos; + } + } + return rtn; + } + bool legalKey(const string& key) { + // Because we compress long keys to a single letter, and + // don't want applications to either get confused if they use + // a letter differently, nor want them to rely on our compression... + // (Considered using numeric keys, but will remain back compatible.) + if (key.length()<2) return false; + if (key.length()==2 && isdigit(key[1])) return false; + return true; + } + string keyValueFormatter (const string& key, const string& value) { + string name; + if (key.length()==1 && isalpha(key[0])) { + name += string("\001")+key; + } else { + name += string("\001")+dequote(key); + } + name += string("\002")+dequote(value); + return name; + } + string combineHier (const string& old, const string& add) { + // (foo.a.x, foo.b.x) => foo.*.x + // (foo.a.x, foo.b.y) => foo.* + // (foo.a.x, foo.b) => foo.* + if (old == add) return add; + if (old == "") return add; + if (add == "") return old; + + const char* a = old.c_str(); + const char* b = add.c_str(); + + // Scan forward to first mismatch + const char* apre = a; + const char* bpre = b; + while (*apre == *bpre) { apre++; bpre++; } + + // We used to backup and split on only .'s but it seems better to be verbose + // and not assume . is the separator + string prefix = string(a,apre-a); + + // Scan backward to last mismatch + const char* apost = a+strlen(a)-1; + const char* bpost = b+strlen(b)-1; + while (*apost == *bpost + && apost>apre && bpost>bpre) { apost--; bpost--; } + + // Forward to . so we have a whole word + string suffix = *bpost ? string(bpost+1) : ""; + + string out = prefix+"*"+suffix; + + //cout << "\nch pre="<zero(); + } + } + + // We assume there's always call to i/f/p in that order + void inserti (VerilatedCovImpItem* itemp) { + assert(!m_insertp); + m_insertp = itemp; + } + void insertf (const char* filenamep, int lineno) { + m_insertFilenamep = filenamep; + m_insertLineno = lineno; + } + void insertp (const char* ckeyps[MAX_KEYS], + const char* valps[MAX_KEYS]) { + assert(m_insertp); + // First two key/vals are filename + ckeyps[0]="filename"; valps[0]=m_insertFilenamep; + VlCovCvtToCStr linestrp (m_insertLineno); + ckeyps[1]="lineno"; valps[1]=linestrp; + // Default page if not specified + const char* fnstartp = m_insertFilenamep; + while (const char* foundp = strchr(fnstartp,'/')) fnstartp=foundp+1; + const char* fnendp = fnstartp; + while (*fnendp && *fnendp!='.') fnendp++; + string page_default = "sp_user/"+string(fnstartp,fnendp-fnstartp); + ckeyps[2]="page"; valps[2]=page_default.c_str(); + + // Keys -> strings + string keys[MAX_KEYS]; + for (int i=0; i > EventMap; + EventMap eventCounts; + for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) { + VerilatedCovImpItem* itemp = *(it); + string name; + string hier; + bool per_instance = false; + + for (int i=0; im_keys[i] != KEY_UNDEF) { + string key = VerilatedCovKey::shortKey(m_indexValues[itemp->m_keys[i]]); + string val = m_indexValues[itemp->m_vals[i]]; + if (key == VL_CIK_PER_INSTANCE) { + if (val != "0") per_instance = true; + } + if (key == VL_CIK_HIER) { + hier = val; + } else { + // Print it + name += keyValueFormatter(key,val); + } + } + } + if (per_instance) { // Not collapsing hierarchies + name += keyValueFormatter(VL_CIK_HIER,hier); + hier = ""; + } + + // Group versus point labels don't matter here, downstream + // deals with it. Seems bad for sizing though and doesn't + // allow easy addition of new group codes (would be + // inefficient) + + // Find or insert the named event + EventMap::iterator cit = eventCounts.find(name); + if (cit != eventCounts.end()) { + const string& oldhier = cit->second.first; + cit->second.second += itemp->count(); + cit->second.first = combineHier(oldhier, hier); + } else { + eventCounts.insert(make_pair(name, make_pair(hier,itemp->count()))); + } + } + + // Output body + for (EventMap::iterator it=eventCounts.begin(); it!=eventCounts.end(); ++it) { + os<<"C '"<first; + if (it->second.first != "") os<second.first); + os<<"' "<second.second; + os<(itemp)); +} +void VerilatedCov::_inserti (vluint64_t* itemp) { + VerilatedCovImp::imp().inserti(new VerilatedCoverItemSpec(itemp)); +} +void VerilatedCov::_insertf (const char* filename, int lineno) { + VerilatedCovImp::imp().insertf(filename,lineno); +} + +#define K(n) const char* key ## n +#define A(n) const char* key ## n, const char* val ## n // Argument list +#define C(n) key ## n, val ## n // Calling argument list +#define N(n) "","" // Null argument list +void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9), + A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19), + A(20),A(21),A(22),A(23),A(24),A(25),A(26),A(27),A(28),A(29)) { + const char* keyps[VerilatedCovImpBase::MAX_KEYS] + = {NULL,NULL,NULL, // filename,lineno,page + key0,key1,key2,key3,key4,key5,key6,key7,key8,key9, + key10,key11,key12,key13,key14,key15,key16,key17,key18,key19, + key20,key21,key22,key23,key24,key25,key26,key27,key28,key29}; + const char* valps[VerilatedCovImpBase::MAX_KEYS] + = {NULL,NULL,NULL, // filename,lineno,page + val0,val1,val2,val3,val4,val5,val6,val7,val8,val9, + val10,val11,val12,val13,val14,val15,val16,val17,val18,val19, + val20,val21,val22,val23,val24,val25,val26,val27,val28,val29}; + VerilatedCovImp::imp().insertp(keyps, valps); +} + +// And versions with fewer arguments (oh for a language with named parameters!) +void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)) { + _insertp(C(0),C(1),C(2),C(3),C(4),C(5),C(6),C(7),C(8),C(9), + N(10),N(11),N(12),N(13),N(14),N(15),N(16),N(17),N(18),N(19), + N(20),N(21),N(22),N(23),N(24),N(25),N(26),N(27),N(28),N(29)); +} +void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9), + A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19)) { + _insertp(C(0),C(1),C(2),C(3),C(4),C(5),C(6),C(7),C(8),C(9), + C(10),C(11),C(12),C(13),C(14),C(15),C(16),C(17),C(18),C(19), + N(20),N(21),N(22),N(23),N(24),N(25),N(26),N(27),N(28),N(29)); +} +// Backward compatibility for Verilator +void VerilatedCov::_insertp (A(0), A(1), K(2),int val2, K(3),int val3, + K(4),const string& val4, A(5),A(6)) { + _insertp(C(0),C(1), + key2,VlCovCvtToCStr(val2), key3,VlCovCvtToCStr(val3), key4, val4.c_str(), + C(5),C(6),N(7),N(8),N(9), + N(10),N(11),N(12),N(13),N(14),N(15),N(16),N(17),N(18),N(19), + N(20),N(21),N(22),N(23),N(24),N(25),N(26),N(27),N(28),N(29)); +} +#undef A +#undef C +#undef N +#undef K diff --git a/include/verilated_cov.h b/include/verilated_cov.h new file mode 100644 index 000000000..7a721b0bc --- /dev/null +++ b/include/verilated_cov.h @@ -0,0 +1,146 @@ +// -*- mode: C++; c-file-style: "cc-mode" -*- +//============================================================================= +// +// THIS MODULE IS PUBLICLY LICENSED +// +// Copyright 2001-2014 by Wilson Snyder. This program is free software; +// you can redistribute it and/or modify it under the terms of either the GNU +// Lesser General Public License Version 3 or the Perl Artistic License Version 2.0. +// +// This 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. +// +//============================================================================= +/// +/// \file +/// \brief Coverage analysis support +/// +/// AUTHOR: Wilson Snyder +/// +//============================================================================= + +#ifndef _VERILATED_COV_H_ +#define _VERILATED_COV_H_ 1 + +#include "verilatedos.h" + +#include +#include +#include +using namespace std; + +//============================================================================= +/// Conditionally compile coverage code + +#ifdef VM_COVERAGE +# define VL_IF_COVER(stmts) do { stmts ; } while(0) +#else +# define VL_IF_COVER(stmts) do { if(0) { stmts ; } } while(0) +#endif + +//============================================================================= +/// Insert a item for coverage analysis. +/// The first argument is a pointer to the count to be dumped. +/// The remaining arguments occur in pairs: A string key, and a value. +/// The value may be a string, or another type which will be auto-converted to a string. +/// +/// Some typical keys: +/// filename File the recording occurs in. Defaults to __FILE__ +/// lineno Line number the recording occurs in. Defaults to __LINE__ +/// column Column number (or occurrence# for dup file/lines). Defaults to undef. +/// hier Hierarchical name. Defaults to name() +/// type Type of coverage. Defaults to "user" +/// Other types are 'block', 'fsm', 'toggle'. +/// comment Description of the coverage event. Should be set by the user. +/// Comments for type==block: 'if', 'else', 'elsif', 'case' +/// thresh Threshold to consider fully covered. +/// If unspecified, downstream tools will determine it. +/// +/// Examples: +/// +/// vluint32_t m_cases[10]; +/// constructor { +/// for (int i=0; i<10; i++) { m_cases[i]=0; } +/// } +/// for (int i=0; i<10; i++) { +/// VL_COVER_INSERT(&m_cases[i], "comment", "Coverage Case", "i", cvtToNumStr(i)); +/// } + +#define VL_COVER_INSERT(countp,args...) \ + VL_IF_COVER(VerilatedCov::_inserti(countp); \ + VerilatedCov::_insertf(__FILE__,__LINE__); \ + VerilatedCov::_insertp("hier", name(), args)) + +//============================================================================= +/// Convert VL_COVER_INSERT value arguments to strings + +template< class T> std::string vlCovCvtToStr (const T& t) { + ostringstream os; os< VlCovCvtToCStr (const T& t) { + ostringstream os; os< +using namespace std; + +//============================================================================= +// Data used to edit below file, using vlcovgen + +#define VLCOVGEN_ITEM(string_parsed_by_vlcovgen) + +VLCOVGEN_ITEM("name=>'col0_name', short=>'C0', group=>1, default=>undef, descr=>'The column title for the header line of this column'") +VLCOVGEN_ITEM("name=>'col1_name', short=>'C1', group=>1, default=>undef, ") +VLCOVGEN_ITEM("name=>'col2_name', short=>'C2', group=>1, default=>undef, ") +VLCOVGEN_ITEM("name=>'col3_name', short=>'C3', group=>1, default=>undef, ") +VLCOVGEN_ITEM("name=>'column', short=>'n', group=>1, default=>0, descr=>'Column number for the item. Used to disambiguate multiple coverage points on the same line number'") +VLCOVGEN_ITEM("name=>'filename', short=>'f', group=>1, default=>undef, descr=>'Filename of the item'") +VLCOVGEN_ITEM("name=>'groupdesc', short=>'d', group=>1, default=>'', descr=>'Description of the covergroup this item belongs to'") +VLCOVGEN_ITEM("name=>'groupname', short=>'g', group=>1, default=>'', descr=>'Group name of the covergroup this item belongs to'") +VLCOVGEN_ITEM("name=>'groupcmt', short=>'O', group=>1, default=>'', ") +VLCOVGEN_ITEM("name=>'per_instance',short=>'P', group=>1, default=>0, descr=>'True if every hierarchy is independently counted; otherwise all hierarchies will be combined into a single count'") +VLCOVGEN_ITEM("name=>'row0_name', short=>'R0', group=>1, default=>undef, descr=>'The row title for the header line of this row'") +VLCOVGEN_ITEM("name=>'row1_name', short=>'R1', group=>1, default=>undef, ") +VLCOVGEN_ITEM("name=>'row2_name', short=>'R2', group=>1, default=>undef, ") +VLCOVGEN_ITEM("name=>'row3_name', short=>'R3', group=>1, default=>undef, ") +VLCOVGEN_ITEM("name=>'table', short=>'T', group=>1, default=>undef, descr=>'The name of the table for automatically generated tables'") +VLCOVGEN_ITEM("name=>'thresh', short=>'s', group=>1, default=>undef, ") +VLCOVGEN_ITEM("name=>'type', short=>'t', group=>1, default=>'', descr=>'Type of coverage (block, line, fsm, etc)'") +// Bin attributes +VLCOVGEN_ITEM("name=>'col0', short=>'c0', group=>0, default=>undef, descr=>'The (enumeration) value name for this column in a table cross' ") +VLCOVGEN_ITEM("name=>'col1', short=>'c1', group=>0, default=>undef, ") +VLCOVGEN_ITEM("name=>'col2', short=>'c2', group=>0, default=>undef, ") +VLCOVGEN_ITEM("name=>'col3', short=>'c3', group=>0, default=>undef, ") +VLCOVGEN_ITEM("name=>'comment', short=>'o', group=>0, default=>'', descr=>'Textual description for the item'") +VLCOVGEN_ITEM("name=>'hier', short=>'h', group=>0, default=>'', descr=>'Hierarchy path name for the item'") +VLCOVGEN_ITEM("name=>'limit', short=>'L', group=>0, default=>undef, ") +VLCOVGEN_ITEM("name=>'lineno', short=>'l', group=>0, default=>0, descr=>'Line number for the item'") +VLCOVGEN_ITEM("name=>'row0', short=>'r0', group=>0, default=>undef, descr=>'The (enumeration) value name for this row in a table cross'") +VLCOVGEN_ITEM("name=>'row1', short=>'r1', group=>0, default=>undef, ") +VLCOVGEN_ITEM("name=>'row2', short=>'r2', group=>0, default=>undef, ") +VLCOVGEN_ITEM("name=>'row3', short=>'r3', group=>0, default=>undef, ") +VLCOVGEN_ITEM("name=>'weight', short=>'w', group=>0, default=>undef, descr=>'For totaling items, weight of this item'") + +//============================================================================= +// VerilatedCovKey +/// SystemPerl coverage global class +//// +/// Global class with methods affecting all coverage data. + +// VLCOVGEN_CIK_AUTO_EDIT_BEGIN +#define VL_CIK_COL0 "c0" +#define VL_CIK_COL0_NAME "C0" +#define VL_CIK_COL1 "c1" +#define VL_CIK_COL1_NAME "C1" +#define VL_CIK_COL2 "c2" +#define VL_CIK_COL2_NAME "C2" +#define VL_CIK_COL3 "c3" +#define VL_CIK_COL3_NAME "C3" +#define VL_CIK_COLUMN "n" +#define VL_CIK_COMMENT "o" +#define VL_CIK_FILENAME "f" +#define VL_CIK_GROUPCMT "O" +#define VL_CIK_GROUPDESC "d" +#define VL_CIK_GROUPNAME "g" +#define VL_CIK_HIER "h" +#define VL_CIK_LIMIT "L" +#define VL_CIK_LINENO "l" +#define VL_CIK_PER_INSTANCE "P" +#define VL_CIK_ROW0 "r0" +#define VL_CIK_ROW0_NAME "R0" +#define VL_CIK_ROW1 "r1" +#define VL_CIK_ROW1_NAME "R1" +#define VL_CIK_ROW2 "r2" +#define VL_CIK_ROW2_NAME "R2" +#define VL_CIK_ROW3 "r3" +#define VL_CIK_ROW3_NAME "R3" +#define VL_CIK_TABLE "T" +#define VL_CIK_THRESH "s" +#define VL_CIK_TYPE "t" +#define VL_CIK_WEIGHT "w" +// VLCOVGEN_CIK_AUTO_EDIT_END + +class VerilatedCovKey { +public: + static string shortKey(const string& key) { + // VLCOVGEN_SHORT_AUTO_EDIT_BEGIN + if (key == "col0") return VL_CIK_COL0; + if (key == "col0_name") return VL_CIK_COL0_NAME; + if (key == "col1") return VL_CIK_COL1; + if (key == "col1_name") return VL_CIK_COL1_NAME; + if (key == "col2") return VL_CIK_COL2; + if (key == "col2_name") return VL_CIK_COL2_NAME; + if (key == "col3") return VL_CIK_COL3; + if (key == "col3_name") return VL_CIK_COL3_NAME; + if (key == "column") return VL_CIK_COLUMN; + if (key == "comment") return VL_CIK_COMMENT; + if (key == "filename") return VL_CIK_FILENAME; + if (key == "groupcmt") return VL_CIK_GROUPCMT; + if (key == "groupdesc") return VL_CIK_GROUPDESC; + if (key == "groupname") return VL_CIK_GROUPNAME; + if (key == "hier") return VL_CIK_HIER; + if (key == "limit") return VL_CIK_LIMIT; + if (key == "lineno") return VL_CIK_LINENO; + if (key == "per_instance") return VL_CIK_PER_INSTANCE; + if (key == "row0") return VL_CIK_ROW0; + if (key == "row0_name") return VL_CIK_ROW0_NAME; + if (key == "row1") return VL_CIK_ROW1; + if (key == "row1_name") return VL_CIK_ROW1_NAME; + if (key == "row2") return VL_CIK_ROW2; + if (key == "row2_name") return VL_CIK_ROW2_NAME; + if (key == "row3") return VL_CIK_ROW3; + if (key == "row3_name") return VL_CIK_ROW3_NAME; + if (key == "table") return VL_CIK_TABLE; + if (key == "thresh") return VL_CIK_THRESH; + if (key == "type") return VL_CIK_TYPE; + if (key == "weight") return VL_CIK_WEIGHT; + // VLCOVGEN_SHORT_AUTO_EDIT_END + return key; + } +}; + +#endif // guard diff --git a/src/Makefile.in b/src/Makefile.in index efdd7b44c..4fdd7ee82 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -46,7 +46,7 @@ obj_opt: obj_dbg: mkdir $@ -.PHONY: ../verilator_bin ../verilator_bin_dbg +.PHONY: ../verilator_bin ../verilator_bin_dbg ../verilator_coverage_bin_dbg opt: ../verilator_bin ifeq ($(VERILATOR_NO_OPT_BUILD),1) # Faster laptop development... One build @@ -59,11 +59,15 @@ else cd obj_opt && $(MAKE) TGT=../$@ -f ../Makefile_obj endif -dbg: ../verilator_bin_dbg +dbg: ../verilator_bin_dbg ../verilator_coverage_bin_dbg ../verilator_bin_dbg: obj_dbg prefiles cd obj_dbg && $(MAKE) -j 1 TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj serial cd obj_dbg && $(MAKE) TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj +../verilator_coverage_bin_dbg: obj_dbg prefiles + cd obj_dbg && $(MAKE) TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj serial_vlcov + cd obj_dbg && $(MAKE) TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj + prefiles:: prefiles:: config_rev.h ifneq ($(UNDER_GIT),) # If local git tree... Else don't burden users diff --git a/src/Makefile_obj.in b/src/Makefile_obj.in index 96e8638ff..786030e6a 100644 --- a/src/Makefile_obj.in +++ b/src/Makefile_obj.in @@ -127,6 +127,7 @@ HEADERS = $(wildcard V*.h v*.h) ASTGEN = $(srcdir)/astgen BISONPRE = $(srcdir)/bisonpre FLEXFIX = $(srcdir)/flexfix +VLCOVGEN = $(srcdir)/vlcovgen ###################################################################### #### Top level @@ -234,26 +235,30 @@ RAW_OBJS = \ V3WidthSel.o \ # Non-concatable -OBJS += \ +NC_OBJS += \ V3ParseImp.o \ V3ParseGrammar.o \ V3ParseLex.o \ V3PreProc.o \ +# verilator_coverage +VLCOV_OBJS = \ + VlcMain.o \ + #### Linking -ifeq ($(VL_DEBUG),) -# Building with fewer objects to better optimize -#OBJS += V3__CONCAT.o -OBJS += $(RAW_OBJS) +ifeq ($(VL_VLCOV),) +PREDEP_H = V3Ast__gen_classes.h +OBJS += $(RAW_OBJS) $(NC_OBJS) else -OBJS += $(RAW_OBJS) +PREDEP_H = +OBJS += $(VLCOV_OBJS) endif V3__CONCAT.cpp: $(addsuffix .cpp, $(basename $(RAW_OBJS))) $(PERL) $(srcdir)/../bin/verilator_includer $^ > $@ -$(TGT): V3Ast__gen_classes.h $(OBJS) +$(TGT): $(PREDEP_H) $(OBJS) @echo " Linking $@..." -rm -rf $@ $@.exe ${LINK} ${LDFLAGS} -o $@ $(OBJS) $(CCMALLOC) ${LIBS} @@ -288,6 +293,12 @@ V3PreProc.o: V3PreProc.cpp V3PreLex.yy.cpp # Target rule called before parallel build to make generated files serial:: V3Ast__gen_classes.h V3ParseBison.c +serial_vlcov:: vlcovgen.d + +vlcovgen.d: $(VLCOVGEN) $(srcdir)/include/verilated_cov_key.h + $(PERL) $(VLCOVGEN) --srcdir $(srcdir) + touch $@ + V3Ast__gen_classes.h : $(ASTGEN) V3Ast.h V3AstNodes.h $(PERL) $(ASTGEN) -I$(srcdir) --classes diff --git a/src/V3EmitC.cpp b/src/V3EmitC.cpp index 3d3d69a89..9f9fef375 100644 --- a/src/V3EmitC.cpp +++ b/src/V3EmitC.cpp @@ -1508,7 +1508,7 @@ void EmitCImp::emitConfigureImp(AstNodeModule* modp) { void EmitCImp::emitCoverageImp(AstNodeModule* modp) { if (v3Global.opt.coverage() ) { puts("\n// Coverage\n"); - // Rather than putting out SP_COVER_INSERT calls directly, we do it via this function + // Rather than putting out VL_COVER_INSERT calls directly, we do it via this function // This gets around gcc slowness constructing all of the template arguments // SystemPerl 1.301 is much faster, but it's nice to remain back // compatible, and have a common wrapper. @@ -1517,7 +1517,7 @@ void EmitCImp::emitCoverageImp(AstNodeModule* modp) { puts( "static uint32_t fake_zero_count = 0;\n"); // static doesn't need save-restore as constant puts( "if (!enable) countp = &fake_zero_count;\n"); // Used for second++ instantiation of identical bin puts( "*countp = 0;\n"); - puts( "SP_COVER_INSERT(countp,"); + puts( "VL_COVER_INSERT(countp,"); puts( " \"filename\",filenamep,"); puts( " \"lineno\",lineno,"); puts( " \"column\",column,\n"); @@ -1827,7 +1827,7 @@ void EmitCImp::emitInt(AstNodeModule* modp) { puts("#include \"verilated_save.h\"\n"); } if (v3Global.opt.coverage()) { - puts("#include \"SpCoverage.h\"\n"); + puts("#include \"verilated_cov.h\"\n"); if (v3Global.opt.savable()) v3error("--coverage and --savable not supported together"); } if (v3Global.needHInlines()) { // Set by V3EmitCInlines; should have been called before us diff --git a/src/V3EmitMk.cpp b/src/V3EmitMk.cpp index 272b00757..1c7a8279f 100644 --- a/src/V3EmitMk.cpp +++ b/src/V3EmitMk.cpp @@ -83,13 +83,13 @@ public: if (v3Global.opt.savable()) { putMakeClassEntry(of, "verilated_save.cpp"); } + if (v3Global.opt.coverage()) { + putMakeClassEntry(of, "verilated_cov.cpp"); + } if (v3Global.opt.systemPerl()) { putMakeClassEntry(of, "Sp.cpp"); // Note Sp.cpp includes SpTraceVcdC } else { - if (v3Global.opt.coverage()) { - putMakeClassEntry(of, "SpCoverage.cpp"); - } if (v3Global.opt.trace()) { putMakeClassEntry(of, "verilated_vcd_c.cpp"); if (v3Global.opt.systemC()) { diff --git a/src/V3File.h b/src/V3File.h index e95f82245..c64db803d 100644 --- a/src/V3File.h +++ b/src/V3File.h @@ -23,7 +23,6 @@ #include "config_build.h" #include "verilatedos.h" #include "V3Error.h" -#include "V3FileLine.h" #include #include #include diff --git a/src/V3Options.cpp b/src/V3Options.cpp index 8a33690d4..e470377cd 100644 --- a/src/V3Options.cpp +++ b/src/V3Options.cpp @@ -275,18 +275,18 @@ bool V3Options::filenameIsRel(const string& filename) { } bool V3Options::fileStatDir(const string& filename) { - struct stat m_stat; // Stat information - int err = stat(filename.c_str(), &m_stat); + struct stat sstat; // Stat information + int err = stat(filename.c_str(), &sstat); if (err!=0) return false; - if (!S_ISDIR(m_stat.st_mode)) return false; + if (!S_ISDIR(sstat.st_mode)) return false; return true; } bool V3Options::fileStatNormal(const string& filename) { - struct stat m_stat; // Stat information - int err = stat(filename.c_str(), &m_stat); + struct stat sstat; // Stat information + int err = stat(filename.c_str(), &sstat); if (err!=0) return false; - if (S_ISDIR(m_stat.st_mode)) return false; + if (S_ISDIR(sstat.st_mode)) return false; return true; } diff --git a/src/VlcBucket.h b/src/VlcBucket.h new file mode 100644 index 000000000..1dd9bf1c0 --- /dev/null +++ b/src/VlcBucket.h @@ -0,0 +1,133 @@ +// -*- mode: C++; c-file-style: "cc-mode" -*- +//************************************************************************* +// DESCRIPTION: verilator_coverage: Bucket container +// +// Code available from: http://www.veripool.org/verilator +// +//************************************************************************* +// +// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can +// redistribute it and/or modify it under the terms of either the GNU +// Lesser General Public License Version 3 or the Perl Artistic License +// Version 2.0. +// +// Verilator 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. +// +//************************************************************************* + +#ifndef _VLCBUCKET_H_ +#define _VLCBUCKET_H_ 1 + +#include "config_build.h" +#include "verilatedos.h" + +//******************************************************************** +// VlcBuckets - Container of all coverage point hits for a given test +// This is a bitmap array - we store a single bit to indicate a test +// has hit that point with sufficient coverage. + +class VlcBuckets { +private: + // MEMBERS + vluint64_t* m_datap; ///< Pointer to first bucket (dynamically allocated) + vluint64_t m_dataSize; ///< Current entries in m_datap + vluint64_t m_bucketsCovered; ///< Num buckets with sufficient coverage + +private: + static inline vluint64_t covBit(vluint64_t point) { return 1ULL<<(point & 63); } + inline vluint64_t allocSize() const { return sizeof(vluint64_t) * m_dataSize / 64; } + void allocate(vluint64_t point) { + vluint64_t oldsize = m_dataSize; + if (m_dataSize= sufficient()) { + //UINFO(9," addData "< +#include + +//###################################################################### +// VlcOptions + +void VlcOptions::addReadFile(const string& filename) { + if (m_readFiles.find(filename) == m_readFiles.end()) { + m_readFiles.insert(filename); + } +} + +string VlcOptions::version() { + string ver = DTVERSION; + ver += " rev "+cvtToStr(DTVERSION_rev); + return ver; +} + +bool VlcOptions::onoff(const char* sw, const char* arg, bool& flag) { + // if sw==arg, then return true (found it), and flag=true + // if sw=="-no-arg", then return true (found it), and flag=false + // if sw=="-noarg", then return true (found it), and flag=false + // else return false + if (arg[0]!='-') v3fatalSrc("OnOff switches must have leading dash.\n"); + if (0==strcmp(sw,arg)) { flag=true; return true; } + else if (0==strncmp(sw,"-no",3) && (0==strcmp(sw+3,arg+1))) { flag=false; return true; } + else if (0==strncmp(sw,"-no-",4) && (0==strcmp(sw+4,arg+1))) { flag=false; return true; } + return false; +} + +void VlcOptions::parseOptsList(int argc, char** argv) { + // Parse parameters + // Note argc and argv DO NOT INCLUDE the filename in [0]!!! + // May be called recursively when there are -f files. +#define shift { ++i; } + for (int i=0; i= 9) { + top.tests().dump(true); + top.points().dump(); + } + + V3Error::abortIfWarnings(); + if (top.opt.annotateOut() != "") { + top.annotate(top.opt.annotateOut()); + } + + if (top.opt.rank()) { + top.rank(); + top.tests().dump(false); + } + + if (top.opt.writeFile() != "") { + top.writeCoverage(top.opt.writeFile()); + V3Error::abortIfWarnings(); + if (top.opt.unlink()) { + const VlStringSet& readFiles = top.opt.readFiles(); + for (VlStringSet::iterator it = readFiles.begin(); it != readFiles.end(); ++it) { + string filename = *it; + unlink(filename.c_str()); + } + } + } + + // Final writing shouldn't throw warnings, but... + V3Error::abortIfWarnings(); + + UINFO(1,"Done, Exiting...\n"); +} + +// Local Variables: +// compile-command: "v4make bin/verilator_coverage --debugi 9 test_regress/t/t_vlcov_data_*.dat" +// End: + diff --git a/src/VlcOptions.h b/src/VlcOptions.h new file mode 100644 index 000000000..d64408538 --- /dev/null +++ b/src/VlcOptions.h @@ -0,0 +1,87 @@ +// -*- mode: C++; c-file-style: "cc-mode" -*- +//************************************************************************* +// DESCRIPTION: verilator_coverage: Command line options +// +// Code available from: http://www.veripool.org/verilator +// +//************************************************************************* +// +// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can +// redistribute it and/or modify it under the terms of either the GNU +// Lesser General Public License Version 3 or the Perl Artistic License +// Version 2.0. +// +// Verilator 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. +// +//************************************************************************* + +#ifndef _VLCOPTIONS_H_ +#define _VLCOPTIONS_H_ 1 + +#include "config_build.h" +#include "verilatedos.h" +#include +#include +#include +#include + +#include "config_rev.h" + +//###################################################################### +// V3Options - Command line options + +typedef vector VlStringList; +typedef set VlStringSet; + +class VlcOptions { + // MEMBERS (general options) + string m_annotateOut; // main switch: --annotate I + bool m_annotateAll; // main switch: --annotate-all + int m_annotateMin; // main switch: --annotate-min I + VlStringSet m_readFiles; // main switch: --read + bool m_rank; // main switch: --rank + bool m_unlink; // main switch: --unlink + string m_writeFile; // main switch: --write + +private: + // METHODS + void showVersion(bool verbose); + bool onoff(const char* sw, const char* arg, bool& flag); + +public: + // CREATORS + VlcOptions() { + m_annotateAll = false; + m_annotateMin = 10; + m_rank = false; + m_unlink = false; + } + ~VlcOptions() {} + void setDebugMode(int level); + + // METHODS + void parseOptsList(int argc, char** argv); + void addReadFile(const string& filename); + + // ACCESSORS (options) + const VlStringSet& readFiles() const { return m_readFiles; } + string annotateOut() const { return m_annotateOut; } + bool annotateAll() const { return m_annotateAll; } + int annotateMin() const { return m_annotateMin; } + bool rank() const { return m_rank; } + bool unlink() const { return m_unlink; } + string writeFile() const { return m_writeFile; } + + // METHODS (from main) + static string version(); + + // METHODS (file searching) + static string filenameNonDir(const string& filename); +}; + +//###################################################################### + +#endif // guard diff --git a/src/VlcPoint.h b/src/VlcPoint.h new file mode 100644 index 000000000..a2aabb3e9 --- /dev/null +++ b/src/VlcPoint.h @@ -0,0 +1,152 @@ +// -*- mode: C++; c-file-style: "cc-mode" -*- +//************************************************************************* +// DESCRIPTION: verilator_coverage: Coverage points +// +// Code available from: http://www.veripool.org/verilator +// +//************************************************************************* +// +// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can +// redistribute it and/or modify it under the terms of either the GNU +// Lesser General Public License Version 3 or the Perl Artistic License +// Version 2.0. +// +// Verilator 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. +// +//************************************************************************* + +#ifndef _VLCPOINT_H_ +#define _VLCPOINT_H_ 1 + +#include "config_build.h" +#include "verilatedos.h" +#include "verilated_cov_key.h" +#include +#include +#include + +//******************************************************************** +// VlcPoint - A coverage point (across all tests) + +class VlcPoint { +private: + // MEMBERS + string m_name; //< Name of the point + vluint64_t m_pointNum; //< Point number + vluint64_t m_testsCovering;//< Number tests with non-zero coverage of this point + vluint64_t m_count; //< Count of hits across all tests + +public: + // CONSTRUCTORS + VlcPoint(const string& name, int pointNum) { + m_name = name; + m_pointNum = pointNum; + m_testsCovering = 0; + m_count = 0; + } + ~VlcPoint() {} + // ACCESSORS + const string& name() const { return m_name; } + vluint64_t pointNum() const { return m_pointNum; } + vluint64_t testsCovering() const { return m_testsCovering; } + void countInc(vluint64_t inc) { m_count += inc; } + vluint64_t count() const { return m_count; } + void testsCoveringInc() { m_testsCovering++; } + // KEY ACCESSORS + string filename() const { return keyExtract(VL_CIK_FILENAME); } + string comment() const { return keyExtract(VL_CIK_COMMENT); } + string type() const { return keyExtract(VL_CIK_TYPE); } + string thresh() const { return keyExtract(VL_CIK_THRESH); } // string as maybe "" + int lineno() const { return atoi(keyExtract(VL_CIK_LINENO).c_str()); } + int column() const { return atoi(keyExtract(VL_CIK_COLUMN).c_str()); } + // METHODS + string keyExtract(const char* shortKey) const { + // Hot function + size_t shortLen = strlen(shortKey); + const string namestr = name(); + for (const char* cp = namestr.c_str(); *cp; ++cp) { + if (*cp == '\001') { + if (0==strncmp(cp+1, shortKey, shortLen) + && cp[shortLen+1] == '\002') { + cp += shortLen+2; // Skip \001+short+\002 + const char* ep = cp; + while (*ep && *ep != '\001') ++ep; + return string(cp, ep-cp); + } + } + } + return ""; + } + static void dumpHeader() { + cout<<"Points:\n"; + cout<<" Num, TestsCover, Count, Name"< NameMap; + NameMap m_nameMap; //< Name to point-number + vector m_points; //< List of all points + vluint64_t m_numPoints; //< Total unique points + +public: + // ITERATORS + typedef NameMap ByName; + typedef ByName::iterator iterator; + ByName::iterator begin() { return m_nameMap.begin(); } + ByName::iterator end() { return m_nameMap.end(); } + +public: + // CONSTRUCTORS + VlcPoints() { + m_numPoints = 0; + } + ~VlcPoints() {} + + // METHODS + void dump() { + UINFO(2,"dumpPoints...\n"); + VlcPoint::dumpHeader(); + for (VlcPoints::ByName::iterator it=begin(); it!=end(); ++it) { + const VlcPoint& point = pointNumber(it->second); + point.dump(); + } + } + VlcPoint& pointNumber(vluint64_t num) { + return m_points[num]; + } + vluint64_t findAddPoint(const string& name, vluint64_t count) { + vluint64_t pointnum; + NameMap::iterator iter = m_nameMap.find(name); + if (iter != m_nameMap.end()) { + pointnum = iter->second; + m_points[pointnum].countInc(count); + } + else { + pointnum = m_numPoints++; + VlcPoint point (name, pointnum); + point.countInc(count); + m_points.push_back(point); + m_nameMap.insert(make_pair(point.name(), point.pointNum())); + } + return pointnum; + } +}; + +//###################################################################### + +#endif // guard diff --git a/src/VlcSource.h b/src/VlcSource.h new file mode 100644 index 000000000..fc7e34441 --- /dev/null +++ b/src/VlcSource.h @@ -0,0 +1,145 @@ +// -*- mode: C++; c-file-style: "cc-mode" -*- +//************************************************************************* +// DESCRIPTION: verilator_coverage: Source file to annotate with line coverage +// +// Code available from: http://www.veripool.org/verilator +// +//************************************************************************* +// +// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can +// redistribute it and/or modify it under the terms of either the GNU +// Lesser General Public License Version 3 or the Perl Artistic License +// Version 2.0. +// +// Verilator 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. +// +//************************************************************************* + +#ifndef _VLCSOURCE_H_ +#define _VLCSOURCE_H_ 1 + +#include "config_build.h" +#include "verilatedos.h" +#include +#include + +//******************************************************************** +// VlcColumnCount - count at specific source file, line and column + +class VlcSourceCount { +private: + // MEMBERS + int m_lineno; ///< Line number + int m_column; ///< Column number + vluint64_t m_count; ///< Count + bool m_ok; ///< Coverage is above threshold + +public: + // CONSTRUCTORS + VlcSourceCount(int lineno, int column) { + m_lineno = lineno; + m_column = column; + m_count = 0; + m_ok = false; + } + ~VlcSourceCount() {} + + // ACCESSORS + int lineno() const { return m_lineno; } + int column() const { return m_column; } + vluint64_t count() const { return m_count; } + bool ok() const { return m_ok; } + + // METHODS + void incCount(vluint64_t count, bool ok) { + m_count += count; + if (ok) m_ok = true; + } +}; + +//******************************************************************** +// VlcSource - source file to annotate + +class VlcSource { +public: + // TYPES + typedef map ColumnMap; // Map of {column} + typedef map LinenoMap; // Map of {lineno}{column} + +private: + // MEMBERS + string m_name; //< Name of the source file + bool m_needed; //< Need to annotate; has low coverage + LinenoMap m_lines; //< Map of each annotated line + +public: + // CONSTRUCTORS + VlcSource(const string& name) { + m_name = name; + m_needed = false; + } + ~VlcSource() {} + + // ACCESSORS + const string& name() const { return m_name; } + void needed(bool flag) { m_needed = flag; } + bool needed() const { return m_needed; } + LinenoMap& lines() { return m_lines; } + + // METHODS + void incCount(int lineno, int column, vluint64_t count, bool ok) { + LinenoMap::iterator lit = m_lines.find(lineno); + if (lit == m_lines.end()) { + lit = m_lines.insert(make_pair(lineno,ColumnMap())).first; + } + ColumnMap& cmap = lit->second; + ColumnMap::iterator cit = cmap.find(column); + if (cit == cmap.end()) { + cit = cmap.insert(make_pair(column,VlcSourceCount(lineno, column))).first; + } + VlcSourceCount& sc = cit->second; + sc.incCount(count,ok); + } +}; + +//******************************************************************** +// VlcSources - Container of all source files + +class VlcSources { +public: + // TYPES + typedef map NameMap; +private: + // MEMBERS + NameMap m_sources; //< List of all sources + +public: + // ITERATORS + typedef NameMap::iterator iterator; + NameMap::iterator begin() { return m_sources.begin(); } + NameMap::iterator end() { return m_sources.end(); } + +public: + // CONSTRUCTORS + VlcSources() {} + ~VlcSources() {} + + // METHODS + VlcSource& findNewSource(const string& name) { + NameMap::iterator iter = m_sources.find(name); + if (iter != m_sources.end()) { + return iter->second; + } + else { + iter = m_sources.insert(make_pair(name, VlcSource(name))).first; + return iter->second; + } + } +}; + +//###################################################################### + +#endif // Guard diff --git a/src/VlcTest.h b/src/VlcTest.h new file mode 100644 index 000000000..63675de8e --- /dev/null +++ b/src/VlcTest.h @@ -0,0 +1,137 @@ +// -*- mode: C++; c-file-style: "cc-mode" -*- +//************************************************************************* +// DESCRIPTION: verilator_coverage: Test/coverage file container +// +// Code available from: http://www.veripool.org/verilator +// +//************************************************************************* +// +// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can +// redistribute it and/or modify it under the terms of either the GNU +// Lesser General Public License Version 3 or the Perl Artistic License +// Version 2.0. +// +// Verilator 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. +// +//************************************************************************* + +#ifndef _VLCTEST_H_ +#define _VLCTEST_H_ 1 + +#include "config_build.h" +#include "verilatedos.h" +#include "VlcPoint.h" +#include "VlcBucket.h" +#include +#include + +//******************************************************************** +// VlcTest - a single testrun i.e. a file containing coverage data + +class VlcTest { +private: + // MEMBERS + string m_name; //< Name of the test + double m_computrons; //< Runtime for the test + vluint64_t m_testrun; //< Test run number, for database use + vluint64_t m_rank; //< Execution rank suggestion + vluint64_t m_rankPoints; //< Ranked additional points + vluint64_t m_user; //< User data for algorithms (not persisted in .dat file) + VlcBuckets m_buckets; //< Coverage data for each coverage point + +public: + // CONSTRUCTORS + VlcTest(const string& name, vluint64_t testrun, double comp) { + m_name = name; + m_computrons = comp; + m_testrun = testrun; + m_rank = 0; + m_rankPoints = 0; + m_user = 0; + } + ~VlcTest() {} + + // ACCESSORS + const string& name() const { return m_name; } + double computrons() const { return m_computrons; } + vluint64_t testrun() const { return m_testrun; } + VlcBuckets& buckets() { return m_buckets; } + vluint64_t bucketsCovered() const { return m_buckets.bucketsCovered(); } + vluint64_t rank() const { return m_rank; } + void rank(vluint64_t flag) { m_rank = flag; } + vluint64_t rankPoints() const { return m_rankPoints; } + void rankPoints(vluint64_t flag) { m_rankPoints = flag; } + vluint64_t user() const { return m_user; } + void user(vluint64_t flag) { m_user = flag; } + + // METHODS + static void dumpHeader() { + cout<<"Tests:\n"; + //cout<<" Testrun, Computrons,"; // Currently not loaded + cout<<" Covered, Rank, RankPts, Filename"< ByName; +private: + // MEMBERS + ByName m_tests; //< List of all tests + +public: + // ITERATORS + typedef ByName::iterator iterator; + ByName::iterator begin() { return m_tests.begin(); } + ByName::iterator end() { return m_tests.end(); } + +public: + // CONSTRUCTORS + VlcTests() {} + ~VlcTests() { + for (VlcTests::ByName::iterator it=begin(); it!=end(); ++it) { + delete *it; *it=NULL; + } + } + + // METHODS + void dump(bool bucketsToo) { + UINFO(2,"dumpTests...\n"); + VlcTest::dumpHeader(); + for (VlcTests::ByName::iterator it=begin(); it!=end(); ++it) { + (*it)->dump(bucketsToo); + } + } + VlcTest* newTest(const string& name, vluint64_t testrun, double comp) { + VlcTest* testp = new VlcTest(name, testrun, comp); + m_tests.push_back(testp); + return testp; + } + void clearUser() { + for (ByName::iterator it = m_tests.begin(); it != m_tests.end(); ++it) { + (*it)->user(0); + } + } +}; + +//###################################################################### + +#endif // Guard diff --git a/src/VlcTop.cpp b/src/VlcTop.cpp new file mode 100644 index 000000000..b71be0d6c --- /dev/null +++ b/src/VlcTop.cpp @@ -0,0 +1,263 @@ +// -*- mode: C++; c-file-style: "cc-mode" -*- +//************************************************************************* +// DESCRIPTION: verilator_coverage: top implementation +// +// Code available from: http://www.veripool.org/verilator +// +//************************************************************************* +// +// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can +// redistribute it and/or modify it under the terms of either the GNU +// Lesser General Public License Version 3 or the Perl Artistic License +// Version 2.0. +// +// Verilator 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. +// +//************************************************************************* + +// Cheat for speed and compile .cpp files into one object +#include "V3Error.h" +#include "VlcOptions.h" +#include "VlcTop.h" + +#include +#include +#include + +//###################################################################### + +void VlcTop::readCoverage(const string& filename, bool nonfatal) { + UINFO(2,"readCoverage "<= VlcBuckets::sufficient()) { + points().pointNumber(pointnum).testsCoveringInc(); + testp->buckets().addData(pointnum, hits); + } + } + } + } +} + +void VlcTop::writeCoverage(const string& filename) { + UINFO(2,"writeCoverage "<second); + os <<"C '"<computrons() != rhsp->computrons()) { + return lhsp->computrons() < rhsp->computrons(); + } + return lhsp->bucketsCovered() > rhsp->bucketsCovered(); + } +}; + +void VlcTop::rank() { + UINFO(2,"rank...\n"); + vluint64_t nextrank=1; + + // Sort by computrons, so fast tests get selected first + vector bytime; + for (VlcTests::ByName::iterator it=m_tests.begin(); it!=m_tests.end(); ++it) { + VlcTest* testp = *it; + if (testp->bucketsCovered()) { // else no points, so can't help us + bytime.push_back(*it); + } + } + sort(bytime.begin(), bytime.end(), CmpComputrons()); // Sort the vector + + VlcBuckets remaining; + for (VlcPoints::ByName::iterator it=m_points.begin(); it!=m_points.end(); ++it) { + VlcPoint* pointp = &points().pointNumber(it->second); + // If any tests hit this point, then we'll need to cover it. + if (pointp->testsCovering()) { remaining.addData(pointp->pointNum(), 1); } + } + + // Additional Greedy algorithm + // O(n^2) Ouch. Probably the thing to do is randomize the order of data + // then hierarchically solve a small subset of tests, and take resulting + // solution and move up to larger subset of tests. (Aka quick sort.) + while (1) { + if (debug()) { UINFO(9,"Left on iter"<::iterator it=bytime.begin(); it!=bytime.end(); ++it) { + VlcTest* testp = *it; + if (!testp->rank()) { + vluint64_t remain = testp->buckets().dataPopCount(remaining); + if (remain > bestRemain) { + bestTestp = testp; + bestRemain = remain; + } + } + } + if (VlcTest* testp = bestTestp) { + testp->rank(nextrank++); + testp->rankPoints(bestRemain); + remaining.orData(bestTestp->buckets()); + } else { + break; // No test covering more stuff found + } + } +} + +//###################################################################### + +void VlcTop::annotateCalc() { + // Calculate per-line information into filedata structure + for (VlcPoints::ByName::iterator it=m_points.begin(); it!=m_points.end(); ++it) { + const VlcPoint& point = m_points.pointNumber(it->second); + string filename = point.filename(); + int lineno = point.lineno(); + if (filename!="" && lineno!=0) { + int column = point.column(); + VlcSource& source = sources().findNewSource(filename); + string threshStr = point.thresh(); + unsigned thresh = (threshStr!="") ? atoi(threshStr.c_str()) : opt.annotateMin(); + bool ok = (point.count() >= thresh); + UINFO(9, "AnnoCalc count "<second; + //UINFO(1,"Source "<second; + for (VlcSource::ColumnMap::iterator cit=cmap.begin(); cit!=cmap.end(); ++cit) { + VlcSourceCount& col = cit->second; + //UINFO(0,"Source "<second; + if (!source.needed()) continue; + string filename = source.name(); + string outfilename = dirname+"/"+VlcOptions::filenameNonDir(filename); + + UINFO(1,"annotateOutputFile "< "<second; + for (VlcSource::ColumnMap::iterator cit=cmap.begin(); cit!=cmap.end(); ++cit) { + VlcSourceCount& col = cit->second; + //UINFO(0,"Source "< \&report, - "debug" => \&debug, + "help" => \&usage, + "debug" => sub { $Debug = 1; }, "classes!" => \$opt_classes, "report!" => \$opt_report, "<>" => \¶meter, @@ -54,10 +54,6 @@ sub usage { exit (1); } -sub debug { - $Debug = 1; -} - sub parameter { my $param = shift; if ($param =~ /^-+I(\S+)/) { diff --git a/src/vlcovgen b/src/vlcovgen new file mode 100755 index 000000000..533505f32 --- /dev/null +++ b/src/vlcovgen @@ -0,0 +1,173 @@ +#!/usr/bin/perl -w +# See copyright, etc in below POD section. +###################################################################### + +#require 5.006_001; +use Getopt::Long; +use IO::File; +use Pod::Usage; +use strict; +use vars qw ($Debug); + +our @Items; + +#====================================================================== +# main + +$Debug = 0; +my $Opt_Srcdir = "."; +Getopt::Long::config ("pass_through", "no_auto_abbrev"); +if (! GetOptions ( + "help" => \&usage, + "debug" => sub { $Debug = 1; }, + "srcdir=s" => \$Opt_Srcdir, + "<>" => sub { die "%Error: Unknown parameter: $_[0],"; }, + )) { + usage(); +} + +read_keys("$Opt_Srcdir/../include/verilated_cov_key.h"); +lint(); +write_keys("$Opt_Srcdir/../include/verilated_cov_key.h"); + +#---------------------------------------------------------------------- + +sub usage { + pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT); + exit (1); +} + +####################################################################### + +sub read_keys { + my $filename = shift; + + my $fh = IO::File->new("<$filename") or die "%Error: $! $filename,"; + while (defined (my $line = $fh->getline())) { + $line =~ s/\/\/.*$//; + next if $line =~ /^\s*$/; + if ($line =~ /^\s*VLCOVGEN_ITEM/) { + $line =~ /^\s*VLCOVGEN_ITEM *\( *"([^"]+)" *\)/ + or die "%Error: $filename:$.: Misformed VLCOVGEN_ITEM line,"; + my @data; + my $code = "\@data = ($1);"; + eval $code; + die "%Error: $filename:$.: Parsing '$code': $@," if $@; + push @Items, {@data}; + } + } +} + +####################################################################### + +sub lint { + my %shorts; + my $ok = 1; + foreach my $itemref (@Items) { + if ($shorts{$itemref->{short}}) { + warn "%Error: Duplicate short code: $itemref->{short},"; + $ok = 0; + } + $shorts{$itemref->{short}} = 1; + } + return $ok; +} + +sub write_keys { + my $filename = shift; + + my $fh = IO::File->new("<$filename") or die "%Error: $! $filename\n"; + + my @in; + my @out; + my $deleting; + while (defined(my $line = $fh->getline)) { + push @in, $line; + if ($line =~ /VLCOVGEN_CIK_AUTO_EDIT_BEGIN/) { + $deleting = 1; + push @out, $line; + foreach my $keyref (sort {$a->{name} cmp $b->{name}} @Items) { + push @out, sprintf("#define VL_CIK_%s \"%s\"\n", + uc $keyref->{name}, $keyref->{short}); + } + } + elsif ($line =~ /VLCOVGEN_SHORT_AUTO_EDIT_BEGIN/) { + $deleting = 1; + push @out, $line; + foreach my $keyref (sort {$a->{name} cmp $b->{name}} @Items) { + push @out, sprintf("\tif (key == \"%s\") return VL_CIK_%s;\n", + $keyref->{name}, uc $keyref->{name}); + } + } + elsif ($line =~ /VLCOVGEN_.*AUTO_EDIT_END/) { + $deleting = 0; + push @out, $line; + } + elsif ($deleting) { + } + else { + push @out, $line; + } + } + $fh->close; + + my $ok = join("", @out) eq join("", @in); + if (!$ok) { + my $fh = IO::File->new(">$filename") or die "%Error: $! writing $filename\n"; + $fh->print(join "", @out); + $fh->close; + } +} + + +####################################################################### +__END__ + +=pod + +=head1 NAME + +vlcovgen - Generate verilated_cov headers to reduce C++ code duplication + +=head1 SYNOPSIS + + (called from make rules) + vlcovgen + +=head1 DESCRIPTION + +Generates several files for Verilator compilations. + +=head1 ARGUMENTS + +=over 4 + +=item --help + +Displays this message and program version and exits. + +=back + +=head1 DISTRIBUTION + +Copyright 2002-2014 by Wilson Snyder. Verilator is free software; you can +redistribute it and/or modify it under the terms of either the GNU Lesser +General Public License Version 3 or the Perl Artistic License Version 2.0. + +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. + +=head1 AUTHORS + +Wilson Snyder + +=head1 SEE ALSO + +=cut + +###################################################################### +### Local Variables: +### compile-command: "./vlcovgen --srcdir ." +### End: diff --git a/test_regress/driver.pl b/test_regress/driver.pl index abee28ca9..5d4f6c4a6 100755 --- a/test_regress/driver.pl +++ b/test_regress/driver.pl @@ -388,7 +388,7 @@ sub new { $self->{stats} ||= "$self->{obj_dir}/V".$self->{name}."__stats.txt"; $self->{status_filename} ||= "$self->{obj_dir}/V".$self->{name}.".status"; $self->{run_log_filename} ||= "$self->{obj_dir}/vlt_sim.log"; - $self->{coverage_filename} ||= "$self->{obj_dir}/vlt_coverage.pl"; + $self->{coverage_filename} ||= "$self->{obj_dir}/coverage.dat"; $self->{vcd_filename} ||= "$self->{obj_dir}/sim.vcd"; $self->{main_filename} ||= "$self->{obj_dir}/$self->{VM_PREFIX}__main.cpp"; ($self->{top_filename} = $self->{pl_filename}) =~ s/\.pl$//; @@ -1143,7 +1143,7 @@ sub _make_main { if ($self->{coverage}) { $fh->print("#if VM_COVERAGE\n"); - $fh->print(" SpCoverage::write(\"",$self->{coverage_filename},"\");\n"); + $fh->print(" VerilatedCov::write(\"",$self->{coverage_filename},"\");\n"); $fh->print("#endif //VM_COVERAGE\n"); } if ($self->{trace}) { diff --git a/test_regress/t/t_cover_line.out b/test_regress/t/t_cover_line.out new file mode 100644 index 000000000..c6840d21a --- /dev/null +++ b/test_regress/t/t_cover_line.out @@ -0,0 +1,170 @@ + // verilator_coverage annotation + // DESCRIPTION: Verilator: Verilog Test module + // + // This file ONLY is placed into the Public Domain, for any use, + // without warranty, 2008 by Wilson Snyder. + + module t (/*AUTOARG*/ + // Inputs + clk + ); + + input clk; + + reg toggle; initial toggle=0; + + integer cyc; initial cyc=1; + wire [7:0] cyc_copy = cyc[7:0]; + + alpha a1 (/*AUTOINST*/ + // Inputs + .clk (clk), + .toggle (toggle)); + alpha a2 (/*AUTOINST*/ + // Inputs + .clk (clk), + .toggle (toggle)); + beta b1 (/*AUTOINST*/ + // Inputs + .clk (clk), + .toggle (toggle)); + beta b2 (/*AUTOINST*/ + // Inputs + .clk (clk), + .toggle (toggle)); + tsk t1 (/*AUTOINST*/ + // Inputs + .clk (clk), + .toggle (toggle)); + off o1 (/*AUTOINST*/ + // Inputs + .clk (clk), + .toggle (toggle)); + + always @ (posedge clk) begin + 000010 if (cyc!=0) begin + cyc <= cyc + 1; + toggle <= '0; +%000001 if (cyc==3) begin + toggle <= '1; + end +%000001 else if (cyc==5) begin + `ifdef VERILATOR + $c("call_task();"); + `else + call_task(); + `endif + end +%000001 else if (cyc==10) begin + $write("*-* All Finished *-*\n"); + $finish; + end + end + end + + task call_task; + /* verilator public */ + t1.center_task(1'b1); + endtask + + endmodule + + module alpha (/*AUTOARG*/ + // Inputs + clk, toggle + ); + input clk; + input toggle; + always @ (posedge clk) begin +%000002 if (toggle) begin + // CHECK_COVER(-1,"top.v.a*",2) + // t.a1 and t.a2 collapse to a count of 2 + end + if (toggle) begin + // CHECK_COVER_MISSING(-1) + // This doesn't even get added + // verilator coverage_block_off + $write(""); + end + end + endmodule + + module beta (/*AUTOARG*/ + // Inputs + clk, toggle + ); + input clk; + input toggle; + + /* verilator public_module */ + + always @ (posedge clk) begin +%000000 if (0) begin + // CHECK_COVER(-1,"top.v.b*",0) + // Make sure that we don't optimize away zero buckets + end +%000002 if (toggle) begin + // CHECK_COVER(-1,"top.v.b*",2) + // t.b1 and t.b2 collapse to a count of 2 + end + if (toggle) begin + // CHECK_COVER_MISSING(-1) + // This doesn't + // verilator coverage_block_off + $write(""); + end + end + endmodule + + module tsk (/*AUTOARG*/ + // Inputs + clk, toggle + ); + input clk; + input toggle; + + /* verilator public_module */ + + always @ (posedge clk) begin + center_task(1'b0); + end + + task center_task; + input external; + begin +%000001 if (toggle) begin + // CHECK_COVER(-1,"top.v.t1",1) + end +%000001 if (external) begin + // CHECK_COVER(-1,"top.v.t1",1) + $write("[%0t] Got external pulse\n", $time); + end + end + endtask + + endmodule + + module off (/*AUTOARG*/ + // Inputs + clk, toggle + ); + input clk; + input toggle; + + // verilator coverage_off + always @ (posedge clk) begin + if (toggle) begin + // CHECK_COVER_MISSING(-1) + // because under coverage_module_off + end + end + // verilator coverage_on + always @ (posedge clk) begin +%000001 if (toggle) begin + // CHECK_COVER(-1,"top.v.o1",1) + // because under coverage_module_off + end + end + + endmodule + diff --git a/test_regress/t/t_cover_line_cc.pl b/test_regress/t/t_cover_line_cc.pl index 0b803ddc1..af024c48d 100755 --- a/test_regress/t/t_cover_line_cc.pl +++ b/test_regress/t/t_cover_line_cc.pl @@ -20,5 +20,12 @@ execute ( # Read the input .v file and do any CHECK_COVER requests inline_checks(); -ok(1); +$Self->_run(cmd=>["../bin/verilator_coverage", + "--annotate", "$Self->{obj_dir}/annotated", + "$Self->{obj_dir}/coverage.dat", + ], + ); + +ok(files_identical("$Self->{obj_dir}/annotated/t_cover_line.v", "t/t_cover_line.out")); + 1; diff --git a/test_regress/t/t_help.pl b/test_regress/t/t_help.pl index 0dde31c06..5324df14f 100755 --- a/test_regress/t/t_help.pl +++ b/test_regress/t/t_help.pl @@ -11,6 +11,7 @@ $Self->{vlt} or $Self->skip("Verilator only test"); foreach my $prog ( "../bin/verilator", + "../bin/verilator_coverage", "../bin/verilator_difftree", "../bin/verilator_profcfunc", ) { diff --git a/test_regress/t/t_vlcov_data_a.dat b/test_regress/t/t_vlcov_data_a.dat new file mode 100644 index 000000000..5acd5df2c --- /dev/null +++ b/test_regress/t/t_vlcov_data_a.dat @@ -0,0 +1,5 @@ +# SystemC::Coverage-3 +C 'CoverPoint0ffile1.sphl159' 0 +C 'CoverPoint1ffile1.sphl159' 1 +C 'CoverPoint2ffile1.sphl159' 10 +C 'CoverPoint3ffile1.sphl159' 0 diff --git a/test_regress/t/t_vlcov_data_b.dat b/test_regress/t/t_vlcov_data_b.dat new file mode 100644 index 000000000..d06b1290f --- /dev/null +++ b/test_regress/t/t_vlcov_data_b.dat @@ -0,0 +1,5 @@ +# SystemC::Coverage-3 +C 'CoverPoint2ffile1.sphl159' 10 +C 'CoverPoint3ffile1.sphl159' 0 +C 'CoverPoint4ffile1.sphl159' 1 +C 'CoverPoint5ffile1.sphl159' 9 diff --git a/test_regress/t/t_vlcov_data_c.dat b/test_regress/t/t_vlcov_data_c.dat new file mode 100644 index 000000000..73f5bb1a5 --- /dev/null +++ b/test_regress/t/t_vlcov_data_c.dat @@ -0,0 +1,2 @@ +# SystemC::Coverage-3 +C 'CoverPoint6ffile1.sphl159' 10 diff --git a/test_regress/t/t_vlcov_data_d.dat b/test_regress/t/t_vlcov_data_d.dat new file mode 100644 index 000000000..d9e06d07d --- /dev/null +++ b/test_regress/t/t_vlcov_data_d.dat @@ -0,0 +1,2 @@ +# SystemC::Coverage-3 +C 'CoverPoint6ffile1.sphl159' 12 diff --git a/test_regress/t/t_vlcov_merge.out b/test_regress/t/t_vlcov_merge.out new file mode 100644 index 000000000..7ac2caba5 --- /dev/null +++ b/test_regress/t/t_vlcov_merge.out @@ -0,0 +1,8 @@ +# SystemC::Coverage-3 +C 'CoverPoint0ffile1.sphl159' 0 +C 'CoverPoint1ffile1.sphl159' 1 +C 'CoverPoint2ffile1.sphl159' 20 +C 'CoverPoint3ffile1.sphl159' 0 +C 'CoverPoint4ffile1.sphl159' 1 +C 'CoverPoint5ffile1.sphl159' 9 +C 'CoverPoint6ffile1.sphl159' 22 diff --git a/test_regress/t/t_vlcov_merge.pl b/test_regress/t/t_vlcov_merge.pl new file mode 100755 index 000000000..e7143abc2 --- /dev/null +++ b/test_regress/t/t_vlcov_merge.pl @@ -0,0 +1,21 @@ +#!/usr/bin/perl +if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; } +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# Copyright 2003-2009 by Wilson Snyder. This program is free software; you can +# redistribute it and/or modify it under the terms of either the GNU +# Lesser General Public License Version 3 or the Perl Artistic License +# Version 2.0. + +$Self->{vlt} or $Self->skip("Verilator only test"); + +$Self->_run(cmd=>["../bin/verilator_coverage", + "--write", "$Self->{obj_dir}/coverage.dat", + "t/t_vlcov_data_a.dat", + "t/t_vlcov_data_b.dat", + "t/t_vlcov_data_c.dat", + "t/t_vlcov_data_d.dat", + ], + ); +ok(files_identical("$Self->{obj_dir}/coverage.dat", "t/$Self->{name}.out")); +1; diff --git a/test_regress/t/t_vlcov_rank.out b/test_regress/t/t_vlcov_rank.out new file mode 100644 index 000000000..4439fcb19 --- /dev/null +++ b/test_regress/t/t_vlcov_rank.out @@ -0,0 +1,6 @@ +Tests: + Covered, Rank, RankPts, Filename + 2, 2, 1, "t/t_vlcov_data_a.dat" + 3, 1, 3, "t/t_vlcov_data_b.dat" + 1, 3, 1, "t/t_vlcov_data_c.dat" + 1, 0, 0, "t/t_vlcov_data_d.dat" diff --git a/test_regress/t/t_vlcov_rank.pl b/test_regress/t/t_vlcov_rank.pl new file mode 100755 index 000000000..febe59c0e --- /dev/null +++ b/test_regress/t/t_vlcov_rank.pl @@ -0,0 +1,23 @@ +#!/usr/bin/perl +if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; } +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# Copyright 2003-2009 by Wilson Snyder. This program is free software; you can +# redistribute it and/or modify it under the terms of either the GNU +# Lesser General Public License Version 3 or the Perl Artistic License +# Version 2.0. + +$Self->{vlt} or $Self->skip("Verilator only test"); + +$Self->_run(cmd=>["../bin/verilator_coverage", + "--rank", + "t/t_vlcov_data_a.dat", + "t/t_vlcov_data_b.dat", + "t/t_vlcov_data_c.dat", + "t/t_vlcov_data_d.dat", + ], + logfile=>"$Self->{obj_dir}/vlcov.log", + tee => 0, + ); +ok(files_identical("$Self->{obj_dir}/vlcov.log", "t/$Self->{name}.out")); +1; diff --git a/test_regress/t/t_vlcov_rewrite.pl b/test_regress/t/t_vlcov_rewrite.pl new file mode 100755 index 000000000..c538a9470 --- /dev/null +++ b/test_regress/t/t_vlcov_rewrite.pl @@ -0,0 +1,25 @@ +#!/usr/bin/perl +if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; } +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# Copyright 2003-2009 by Wilson Snyder. This program is free software; you can +# redistribute it and/or modify it under the terms of either the GNU +# Lesser General Public License Version 3 or the Perl Artistic License +# Version 2.0. + +$Self->{vlt} or $Self->skip("Verilator only test"); + +foreach my $basename ("t_vlcov_data_a.dat", + "t_vlcov_data_b.dat", + "t_vlcov_data_c.dat", + "t_vlcov_data_d.dat", + ) { + $Self->_run(cmd=>["../bin/verilator_coverage", + "t/${basename}", + "--write", "$Self->{obj_dir}/${basename}" + ], + tee=>0, + ); + ok(files_identical("$Self->{obj_dir}/${basename}", "t/${basename}")); +} +1; diff --git a/test_sp/Makefile b/test_sp/Makefile index 78dbffbf4..500c4a56e 100644 --- a/test_sp/Makefile +++ b/test_sp/Makefile @@ -25,9 +25,9 @@ DEBUG_ON = --debug --trace-dups ###################################################################### ifneq ($(SYSTEMPERL),) -test_default: precopy prep preproc compile run coverage -test_debug: precopy prep_dbg preproc compile_dbg run coverage -test_nopublic: precopy prep_dbg_np preproc compile_dbg run coverage +test_default: precopy prep preproc compile run +test_debug: precopy prep_dbg preproc compile_dbg run +test_nopublic: precopy prep_dbg_np preproc compile_dbg run else test_default: nosp test_debug: nosp @@ -39,7 +39,7 @@ V_FLAGS = -f $(VERILATOR_ROOT)/test_v/input.vc # Note the --public --output-split-cfunc is here for testing only, # Avoid using these settings in real application Makefiles! VERILATOR_FLAGS = --public --output-split-cfuncs 1000 --output-split 1000 \ - --sp --coverage --stats --trace $(V_FLAGS) top.v + --sp --stats --trace $(V_FLAGS) top.v precopy: obj_dir obj_dir/sc_main.cpp obj_dir/sc_main.cpp: ../test_sc/sc_main.cpp @@ -66,7 +66,7 @@ run: obj_dir/simx coverage: - vcoverage $(V_FLAGS) + $(VERILATOR_ROOT)/bin/verilator_coverage $(V_FLAGS) ######################################################################