Version bump

Signed-off-by: Wilson Snyder <[email protected]>

.clang-tidy

@@ -0,0 +1,9 @@
+Checks:          'clang-diagnostic-*,clang-analyzer-*,*,-modernize*,-hicpp*,-android-cloexec-fopen,-cert-dcl50-cpp,-cert-env33-c,-cert-err34-c,-cert-err58-cpp,-clang-analyzer-core.UndefinedBinaryOperatorResult,-clang-analyzer-security*,-cppcoreguidelines-no-malloc,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-union-access,-cppcoreguidelines-pro-type-vararg,-cppcoreguidelines-special-member-functions,-fuchsia-default-arguments,-fuchsia-overloaded-operator,-google-default-arguments,-google-readability-todo,-google-runtime-references,-llvm-header-guard,-llvm-include-order,-misc-string-integer-assignment,-misc-string-literal-with-embedded-nul,-readability-braces-around-statements,-readability-container-size-empty,-readability-delete-null-pointer,-readability-else-after-return,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-static-accessed-through-instance'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
+FormatStyle:     none
+CheckOptions:
+  - key:             google-readability-braces-around-statements.ShortStatementLines
+    value:           '2'
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'

.gitattributes

@@ -0,0 +1,4 @@
+*.v linguist-language=SystemVerilog
+*.vh linguist-language=SystemVerilog
+*.sv linguist-language=SystemVerilog
+nodist linguist-detectable=false

.gitignore

@@ -1,4 +1,7 @@
+\#*
+.#*
 *~
+*.tidy
 *.old
 *.gz
 *.gz.uu
@@ -20,8 +23,11 @@ configure
 dddrun*
 doxygen-doc
 gdbrun*
+gmon.out
+ncverilog.history
 internals.txt
 verilator.txt
 verilator_bin*
 verilator_coverage_bin*
 verilator.pc
+**/obj_dir/*

.travis.yml

@@ -0,0 +1,111 @@
+# DESCRIPTION: Travis-CI config
+#
+# Copyright 2003-2019 by Todd Strader. 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.
+
+language: cpp
+
+matrix:
+  include:
+# Non-cron build will just run on whatever linux flavor we get
+    - if: type != cron
+      os: linux
+      compiler: gcc
+      env:
+        - SCENARIOS=--dist
+    - if: type != cron
+      os: linux
+      compiler: gcc
+      env:
+        - SCENARIOS=--vlt
+    - if: type != cron
+      os: linux
+      compiler: gcc
+      env:
+        - SCENARIOS=--vltmt
+# Cron builds try different OS/compiler combinations
+    - if: type = cron
+      dist: xenial
+      compiler: gcc
+      env:
+        - SCENARIOS=--dist
+    - if: type = cron
+      dist: xenial
+      compiler: gcc
+      env:
+        - SCENARIOS=--vlt
+    - if: type = cron
+      dist: xenial
+      compiler: gcc
+      env:
+        - SCENARIOS=--vltmt
+    - if: type = cron
+      dist: xenial
+      compiler: clang
+      env:
+        - SCENARIOS=--dist
+    - if: type = cron
+      dist: xenial
+      compiler: clang
+      env:
+        - SCENARIOS=--vlt
+    - if: type = cron
+      dist: xenial
+      compiler: clang
+      env:
+        - SCENARIOS=--vltmt
+#    - if: type = cron
+#      os: osx
+#      compiler: gcc
+#      env:
+#        - SCENARIOS=--dist
+#    - if: type = cron
+#      os: osx
+#      compiler: gcc
+#      env:
+#        - SCENARIOS=--vlt
+#    - if: type = cron
+#      os: osx
+#      compiler: gcc
+#      env:
+#        - SCENARIOS=--vltmt
+    - if: type = cron
+      dist: trusty
+      compiler: gcc
+      env:
+        - SCENARIOS=--dist
+    - if: type = cron
+      dist: trusty
+      compiler: gcc
+      env:
+        - SCENARIOS=--vlt
+    - if: type = cron
+      dist: trusty
+      compiler: gcc
+      env:
+        - SCENARIOS=--vltmt
+
+cache: ccache
+
+# Some tests require gdb
+addons:
+  apt:
+    packages:
+      - gdb
+
+before_install:
+# Perl modules needed for testing
+  - yes yes | sudo cpan -fi Unix::Processors Parallel::Forker Bit::Vector
+before_script:
+  - export VLT_JOBS=$((`nproc` + 1))
+  - export OBJCACHE=ccache
+  - export VERILATOR_ROOT=`pwd`
+  - autoconf
+script:
+  - >
+    ./configure --enable-maintainer-mode --enable-longtests &&
+    make -j $VLT_JOBS &&
+    make test_regress DRIVER_FLAGS="-j 0 --quiet --rerun"
+after_script:
+  - ccache -s

COPYING

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.

Changes

@@ -1,9 +1,753 @@
 Revision history for Verilator
 
-The contributors that suggested a given feature are shown in [].  [by ...]
-indicates the contributor was also the author of the fix; Thanks!
+The contributors that suggested a given feature are shown in []. Thanks!
 
-* Verilator 3.873 2015-06-06
+* Verilator 4.018 2019-08-29
+
+**    When showing an error, show source code and offer suggestions of replacements.
+
+**    When showing an error, show the instance location, bug1305. [Todd Strader]
+
+***   Add --rr, bug1481. [Todd Strader]
+
+***   Change MULTITOP to warning to help linting, see manual.
+
+***   Add XSim support to driver.pl, bug1493. [Todd Strader]
+
+****  Show included-from filenames in warnings, bug1439. [Todd Strader]
+
+****  Fix elaboration time errors, bug1429. [Udi Finkelstein]
+
+****  Fix not reporting some duplicate signals/ports, bug1462. [Peter Gerst]
+
+****  Fix not in array context on non-power-of-two slices, msg2946. [Yu Sheng Lin]
+
+****  Fix system compile flags injection. [Gianfranco Costamagna]
+
+****  Fix enum values not being sized based on parent, bug1442. [Dan Petrisko]
+
+****  Fix internal error on gate optimization of assign, bug1475. [Oyvind Harboe]
+
+****  Add --dpi-hdr-only, bug1491. [Todd Strader]
+
+
+* Verilator 4.016 2019-06-16
+
+***   Add --quiet-exit, bug1436. [Todd Strader]
+
+****  Error continuation lines no longer have %Error prefix.
+
+****  Support logical equivalence operator <->.
+
+****  Support VerilatedFstC set_time_unit, bug1433. [Pieter Kapsenberg]
+
+****  Support deferred assertions, bug1449. [Charles Eddleston]
+
+****  Mark infrequently called functions with GCC cold attribute.
+
+****  Fix sign-compare warning in verilated.cpp, bug1437. [Sergey Kvachonok]
+
+****  Fix fault on $realtime with %t, bug1443. [Julien Margetts]
+
+****  Fix $display with string without %s, bug1441. [Denis Rystsov]
+
+****  Fix parameter function string returns, bug1441. [Denis Rystsov]
+
+****  Fix invalid XML output due to special chars, bug1444. [Kanad Kanhere]
+
+****  Fix performance when mulithreaded on 1 CPU, bug1455. [Stefan Wallentowitz]
+
+****  Fix type and real parameter issues, bug1427, bug1456, bug1458. [Todd Strader]
+
+****  Fix build error on MinGW, bug1460. [Richard Myers]
+
+****  Fix not reporting some duplicate signals, bug1462. [Peter Gerst]
+
+****  Fix --savable invalid C++ on packed arrays, bug1465. [Alex Chadwick]
+
+****  Fix constant function return of function var, bug1467. [Roman Popov]
+
+
+* Verilator 4.014 2019-05-08
+
+***   Add --trace-fst-thread.
+
+****  Support '#' comments in $readmem, bug1411. [Frederick Requin]
+
+****  Support "'dx" constants, bug1423. [Udi Finkelstein]
+
+****  For FST tracing use LZ4 compression. [Tony Bybell]
+
+****  Add error when use parameters without value, bug1424. [Peter Gerst]
+
+****  Auto-extend and WIDTH warn on unsized X/Zs, bug1423. [Udi Finkelstein]
+
+****  Fix missing VL_SHIFTL_ errors, bug1412, bug1415. [Larry Lee]
+
+****  Fix MinGW GCC 6 printf formats, bug1413. [Sergey Kvachonok]
+
+****  Fix test problems when missing fst2vcd, bug1417. [Todd Strader]
+
+****  Fix GTKWave register warning, bug1421. [Pieter Kapsenberg]
+
+****  Fix FST enums not displaying, bug1426. [Danilo Ramos]
+
+****  Fix table compile error with multiinterfaces, bug1431. [Bogdan Vukobratovic]
+
+
+* Verilator 4.012 2019-3-23
+
+***   Add +verilator+seed, bug1396. [Stan Sokorac]
+
+***   Support $fread.  [Leendert van Doorn]
+
+***   Support void' cast on functions called as tasks, bug1383. [Al Grant]
+
+***   Add IGNOREDRETURN warning, bug1383.
+
+****  Report PORTSHORT errors on concat constants, bug 1400. [Will Korteland]
+
+****  Fix VERILATOR_GDB being ignored, msg2860. [Yu Sheng Lin]
+
+****  Fix $value$plus$args missing verilated_heavy.h. [Yi-Chung Chen]
+
+****  Fix MSVC compile error, bug1406. [Benjamin Gartner]
+
+****  Fix maintainer test when no Parallel::Forker, msg2630. [Enzo Chi]
+
+****  Fix +1364-1995ext flags applying too late, bug1384. [Al Grant]
+
+
+* Verilator 4.010 2019-01-27
+
+***   Removed --trace-lxt2, use --trace-fst instead.
+
+****  For --xml, add additional information, bug1372. [Jonathan Kimmitt]
+
+****  Add circular typedef error, bug1388.  [Al Grant]
+
+****  Add unsupported for loops error, msg2692. [Yu Sheng Lin]
+
+****  Fix FST tracing of wide arrays, bug1376. [Aleksander Osman]
+
+****  Fix error when pattern assignment has too few elements, bug1378. [Viktor Tomov]
+
+****  Fix error when no modules in $unit, bug1381. [Al Grant]
+
+****  Fix missing too many digits warning, bug1380. [Jonathan Kimmitt]
+
+****  Fix uninitialized data in verFiles and unroller, bug1385. bug1386. [Al Grant]
+
+****  Fix internal error on xrefs into unrolled functions, bug1387. [Al Grant]
+
+****  Fix DPI export void compiler error, bug1391. [Stan Sokorac]
+
+
+* Verilator 4.008 2018-12-01
+
+***   Support "ref" and "const ref" pins and functions, bug1360. [Jake Longo]
+
+***   In --xml-only show the original unmodified names, and add module_files
+      and cells similar to Verilog-Perl, msg2719. [Kanad Kanhere]
+
+****  Add CONTASSREG error on continuous assignments to regs, bug1369. [Peter Gerst]
+
+****  Add PROCASSWIRE error on behavioral assignments to wires, msg2737. [Neil Turton]
+
+****  Add IMPORTSTAR warning on import::* inside $unit scope.
+
+****  Fix --trace-lxt2 compile error on MinGW, msg2711. [HyungKi Jeong]
+
+****  Fix hang on bad pattern keys, bug1364. [Matt Myers]
+
+****  Fix crash due to cygwin bug in getline, bug1349. [Affe Mao]
+
+****  Fix __Slow files getting compiled with OPT_FAST, bug1370. [Thomas Watts]
+
+
+* Verilator 4.006 2018-10-27
+
+**    Add --pp-comments, msg2700. [Robert Henry]
+
+**    Add --dump-defines.
+
+***   For --trace-fst, save enum decoding information, bug1358. [Sergi Granell]
+      (To visualize enumeration data you must use GTKwave 3.3.95 or newer.)
+
+***   For --trace-fst, instead of *.fst.hier, put data into *.fst. [Tony Bybell]
+
+****  Fix --trace-lxt2 compile error on MinGW, msg2667. [HyungKi Jeong]
+
+****  Fix Windows .exe not found, bug1361. [Patrick Stewart]
+
+
+* Verilator 4.004 2018-10-6
+
+**    Add GTKWave FST native tracing, bug1356. [Sergi Granell]
+      (Verilator developers need to pull the latest vcddiff.)
+
+***   Support $past. [Dan Gisselquist]
+
+***   Support restrict, bug1350. [Clifford Wolf]
+
+***   Rename include/lxt2 to include/gtkwave.
+
+****  Fix replication of 64-bit signal change detects.
+
+****  Fix Mac OSX 10.13.6 / LLVM 9.1 compile issues, bug1348. [Kevin Kiningham]
+
+****  Fix MinGW compile issues, msg2636. [HyungKi Jeong]
+
+
+* Verilator 4.002 2018-09-16
+
+**    This is a major release.  Any patches may require major rework to apply.
+      [Thanks everyone]
+
+**    Add multithreaded model generation.
+
+**    Add runtime arguments.
+
+**    Add GTKWave LXT2 native tracing, bug1333. [Yu Sheng Lin]
+
+**    Note $random has new algorithm; results may vary vs. previous versions.
+
+***   Better optimize large always block splitting, bug1244. [John Coiner]
+
+***   Add new reloop optimization for repetitive assignment compression.
+
+***   Support string.atoi and similar methods, bug1289. [Joel Holdsworth]
+
+****  Fix internals to be C++ null-pointer-check clean.
+
+****  Fix internals to avoid 'using namespace std'.
+
+****  Fix Verilation performance issues, bug1316. [John Coiner]
+
+****  Fix clocker attributes to not propagate on concats. [John Coiner]
+
+****  Fix first clock edge and --x-initial-edge, bug1327. [Rupert Swarbrick]
+
+****  Fix compile error on tracing of string arrays, bug1338. [Iztok Jeras]
+
+****  Fix number parsing with newline after radix, bug1340. [George Cuan]
+
+****  Fix string ?: conditional type resolution, bug1345. [Iztok Jeras]
+
+****  Fix duplicate symbol error on generate tri, bug1347. [Tomas Dzetkulic]
+
+
+* Verilator 3.926 2018-08-22
+
+****  Add OBJCACHE envvar support to examples and generated Makefiles.
+
+****  Change MODDUP errors to warnings, msg2588. [Marshal Qiao]
+
+****  Fix define argument stringification (`"), broke since 3.914. [Joe DErrico]
+
+****  Fix to ignore Unicode UTF-8 BOM sequences, msg2576. [HyungKi Jeong]
+
+****  Fix std:: build error, bug1322.
+
+****  Fix function inlining inside certain while loops, bug1330. [Julien Margetts]
+
+
+* Verilator 3.924 2018-06-12
+
+***   Renamed --profile-cfuncs to --prof-cfuncs.
+
+****  Report interface ports connected to wrong interface, bug1294. [Todd Strader]
+
+****  When tracing, use scalars on single bit arrays to appease vcddiff.
+
+****  Fix parsing "output signed" in V2K port list, msg2540. [James Jung]
+
+****  Fix parsing error on bad missing #, bug1308. [Dan Kirkham]
+
+****  Fix $clog2 to be in verilog 2005, bug1319. [James Hutchinson]
+
+
+* Verilator 3.922 2018-03-17
+
+**    Support IEEE 1800-2017 as default language.
+
+***   Support trig functions ($sin() etc), bug1281. [Patrick Stewart]
+
+***   Support calling system functions as tasks, bug1285. [Joel Holdsworth]
+
+***   Support assert properties, bug785, bug1290. [John Coiner, et al]
+
+***   Support $writememh. [John Coiner]
+
+***   Add --no-debug-leak to reduce memory use under debug. [John Coiner]
+
+****  Fix severe runtime performance bug in certain foreach loops. [John Coiner]
+
+****  On convergence errors, show activity. [John Coiner]
+
+****  Fix GCC 8.0 issues, bug1273.
+
+****  Fix pullup/pulldowns on bit selects, bug1274. [Rob Stoddard]
+
+****  Fix verilator_coverage --annotate-min, bug1284. [Tymoteusz Blazejczyk]
+
+****  Fix quoting of quoted arguments. [John Coiner]
+
+
+* Verilator 3.920 2018-02-01
+
+**    Moving forward, use the git "stable" branch to track the latest release,
+      and git "v#.###" tags for specific releases.
+
+***   Support 'assume' similar to 'assert', bug1269. [Dan Gisselquist]
+
+****  Fix tracing example file output, bug1268. [Enzo Chi]
+
+****  Fix gate optimization out of memory, add --gate-stmts, bug1260. [Alex Solomatnikov]
+
+****  Fix compile error on public real parameters by suppressing, bug1261. [Alex Solomatnikov]
+
+****  Fix input-only tristate comparisons, bug1267. [Alexis G]
+
+****  Fix missing edge type in xml output, msg2480. [Alexis G]
+
+****  Fix compile error with --public and interface bind, bug1264. [Alexis G]
+
+****  Remove c++filt, bug1265. [Stefan Wallentowitz]
+
+
+* Verilator 3.918 2018-01-02
+
+***   Workaround GCC/clang bug with huge compile times, bug1248.
+
+***   Support DPI open arrays, bug909, bug1245. [David Pierce, Victor Besyakov]
+
+***   Add INFINITELOOP warning, bug1254. [Alex Solomatnikov]
+
+****  Support > 64 bit decimal $display.
+
+****  Support DPI time and svLogicVal. [Victor Besyakov]
+      Note older version incorrectly assumed svBitVal even for logicals.
+
+****  Support string len() method. [Victor Besyakov]
+
+****  Add error if always_comb has sensitivity list. [Arjen Roodselaar]
+
+****  Fix SystemC 2.3.2 compile error, bug1251. [Tymoteusz Blazejczyk]
+
+****  Fix modport outputs being treated as inputs, bug1246. [Jeff Bush]
+
+****  Fix false ALWCOMBORDER on interface references, bug1247. [Josh Redford]
+
+****  Fix constant propagation across DPI imports of inout strings. [Victor Besyakov]
+
+****  Fix resolving inline nested interface names, bug1250. [Arjen Roodselaar]
+
+
+* Verilator 3.916 2017-11-25
+
+***   Support self-recursive modules, bug659. [Sean Moore, et al]
+
+***   Support $error/$warning in elaboration time blocks.
+
+***   Support $size/$bits/etc on type references.
+
+***   Add error when driving input-only modport, bug1110. [Trevor Elbourne]
+
+***   Add BSSPACE and COLONPLUS lint warnings.
+
+****  Detect MSB overflow when under VL_DEBUG, bug1238. [Junyi Xi]
+
+****  Add data types to --xml. [Rui Terra]
+
+****  Fix partial slicing with pattern assignments, bug991. [Johan Bjork]
+
+****  Fix false unused warning on interfaces, bug1241. [Laurens van Dam]
+
+****  Fix error on "unique case" with no cases.
+
+****  Fix MacOS portability, bug1232. [Jeff Bush]
+
+
+* Verilator 3.914 2017-10-14
+
+**    Added new examples/ directory with appropriate examples. This replaces the
+      old test_c and test_sc directories.
+
+***   Add --getenv option for simplifying Makefiles.
+
+***   Add --x-initial option for specifying initial value assignment behavior.
+
+***   Add --no-relative-cfuncs and related default optimization, bug1224. [John Coiner]
+
+***   Add /*verilator tag*/ for XML extraction applications. [Chris Randall]
+
+****  The internal test_verilated test directory is moved to be part of test_regress.
+
+****  The experimental VL_THREADED setting (only, not normal mode) now requires C++11.
+
+****  Fix over-aggressive inlining, bug1223. [John Coiner]
+
+****  Fix Ubuntu 17.10 issues, bug1223 partial. [John Coiner]
+
+****  Fix compiler warning when WIDTH warning ignored on large compare.
+
+****  Fix memory leak in VerilatedVcd dumps, bug1222 partial. [Shareef Jalloq]
+
+****  Fix unnecessary Vdly variables, bug1224 partial. [John Coiner]
+
+****  Fix conditional slices and add related optimizations.
+
+****  Fix `` expansion of `defines, bug1225, bug1227, bug1228. [Odd Magne Reitan]
+
+****  Fix -E duplicating output, bug1226. [Odd Magne Reitan]
+
+****  Fix float-conversion warning, bug1229. [Robert Henry]
+
+****  Fix MacOS portability, bug1230, bug1231. [Jeff Bush]
+
+
+* Verilator 3.912 2017-09-23
+
+**    Verilated headers no longer "use namespace std;"
+      User's code without "std::" prefixes may need "use namespace std;" to compile.
+
+***   Support or/and/xor array intrinsic methods, bug1210. [Mike Popoloski]
+
+***   Support package export, bug1217. [Usuario Eda]
+
+***   Fix ordering of arrayed cell wide connections, bug1202 partial. [Mike Popoloski]
+
+****  Support module port parameters without defaults, bug 1213. [Mike Popoloski]
+
+****  Add performance information to --stats file.
+
+****  Simplify VL_CONST_W macro generation for faster compiles.
+
+****  Fix LITENDIAN warning on arrayed cells, bug1202. [Mike Popoloski]
+
+****  Fix enum ranges without colons, bug1204. [Mike Popoloski]
+
+****  Fix GCC noreturn compile error, bug1209. [Mike Popoloski]
+
+****  Fix constant function default parameters, bug1211. [Mike Popoloski]
+
+****  Fix non-colon array of interface modports, bug1212. [Mike Popoloski]
+
+****  Fix .name connections on interfaces, bug1214. [Mike Popoloski]
+
+****  Fix wide array indices causing compile error.
+
+****  Better optimize Shift-And, and replication constructs.
+
+
+* Verilator 3.910 2017-09-07
+
+***   SystemPerl mode (-sp-deprecated) has been removed.
+
+****  Update keyword warnings to include C++11 and others.
+
+
+* Verilator 3.908 2017-08-28
+
+****  Support x in $readmem, bug1180. [Arthur Kahlich]
+
+****  Support packed struct DPI imports, bug1190. [Rob Stoddard]
+
+****  Fix GCC 6 warnings.
+
+****  Fix compile error on unused VL_VALUEPLUSARGS_IW, bug1181. [Thomas J Whatson]
+
+****  Fix undefined VL_POW_WWI. [Clifford Wolf]
+
+****  Fix internal error on unconnected inouts, bug1187. [Rob Stoddard]
+
+
+* Verilator 3.906 2017-06-22
+
+***   Support set_time_unit/set_time_precision in C traces, msg2261.
+
+***   Fix extract of packed array with non-zero LSB, bug1172. [James Pallister]
+
+***   Fix shifts by more than 32-bit numbers, bug1174. [Clifford Wolf]
+
+***   Fix power operator on wide constants, bug761. [Clifford Wolf]
+
+***   Fix .* on interface pins, bug1176. [Maciej Piechotka]
+
+
+* Verilator 3.904 2017-05-30
+
+***   Fix non-cutable ordering loops on clock arrays, bug1009. [Todd Strader]
+
+***   Support ports of array of reals, bug1154. [J Briquet]
+
+***   Support arrayed parameter overrides, bug1153. [John Stevenson]
+
+***   Support $value$plusargs with variables, bug1165. [Wesley Terpstra]
+
+****  Support modport access to un-modport objects, bug1161. [Todd Strader]
+
+****  Add stack trace when can't optimize function, bug1158. [Todd Strader]
+
+****  Add warning on mis-sized literal, bug1156. [Todd Strader]
+
+****  Fix interface functions returning wrong parameters, bug996. [Todd Strader]
+
+****  Fix non-arrayed cells with interface arrays, bug1153. [John Stevenson]
+
+****  Fix --assert with complex case statements, bug1164. [Enzo Chi]
+
+
+* Verilator 3.902 2017-04-02
+
+**    Add -FI option to force includes,msg2146. [Amir Gonnen]
+
+**    Add --relative-includes. [Rob Stoddard]
+
+***   Add error on duplicate pattern assignments, bug1145. [Johan Bjork]
+
+****  Fix error on improperly widthed default function, bug984. [Todd Strader]
+
+****  Fix 2009 localparam syntax, msg2139. [Galen Seitz]
+
+****  Fix ugly interface-to-non-interface errors, bug1112. [Johan Bjork]
+
+****  Fix LDFLAGS and CFLAGS not preserving order, bug1130. [Olof Kindgren]
+
+****  Fix internal error on initializing parameter array, bug1131. [Jie Xu]
+
+****  Fix internal error on interface arrays, bug1135. [John Stevenson]
+
+****  Fix calling sformatf to display, and elab $displays, bug1139. [Johan Bjork]
+
+****  Fix realpath compile issue on MSVC++, bug1141. [Miodrag Milanovic]
+
+****  Fix missing error on interface size mismatch, bug1143.  [Johan Bjork]
+
+****  Fix error on parameters with dotted references, bug1146. [Johan Bjork]
+
+****  Fix wreal not handling continuous assign, bug1150. [J Briquet]
+
+****  Fix nested structure parameter selects, bug1150. [J Briquet]
+
+
+* Verilator 3.900 2017-01-15
+
+**    Internal code changes for improved compatibility and performance.
+
+***   Support old-style $display($time), bug467. [John Demme]
+
+****  With --bbox-unsup, suppress desassign and mixed edges, bug1120. [Galen Seitz]
+
+****  Fix parsing sensitivity with &&, bug934. [Luke Yang]
+
+****  Fix internal error on double-for loop unrolling, bug1044. [Jan Egil Ruud]
+
+****  Fix internal error on unique casez with --assert, bug1117. [Enzo Chi]
+
+****  Fix bad code when tracing array of structs, bug1122. [Andrew Bardsley]
+
+
+* Verilator 3.890 2016-11-25
+
+***   Honor --output-split on coverage constructors, bug1098. [Johan Bjork]
+
+****  Fix various issues when making outside of the kit.
+
+****  Fix flex 2.6.2 bug, bug1103. [Sergey Kvachonok]
+
+****  Fix error on bad interface name, bug1097. [Todd Strader]
+
+****  Fix error on referencing variable in parent, bug1099. [Ian Thompson]
+
+****  Fix type parameters with low optimization, bug1101. [Stefan Wallentowitz]
+
+
+* Verilator 3.888 2016-10-14
+
+**    Support foreach, bug1078. [Xuan Guo]
+
+***   Add --no-decoration to remove output comments, msg2015. [Frederic Requin]
+
+***   If VM_PARALLEL_BUILDS=1, use OPT_FAST and OPT_SLOW. [Frederic Requin]
+      Set VM_DEFAULT_RULES=0 for old behavior.
+
+****  Add error on DPI functions > 32 bits, msg1995. [Elliot Mednick]
+
+****  Fix SystemC compiles with VPI, bug1081. [Arthur Kahlich]
+
+****  Fix error on wide numbers that represent shifts, msg1991, bug1088. [Mandy Xu]
+
+****  Improve Verilation performance on internal strings, msg1975. [Johan Bjork]
+
+****  Improve Verilation performance on trace duplicates, bug1090. [Johan Bjork]
+
+
+* Verilator 3.886 2016-07-30
+
+****  Fix enum values of 11-16 bits wide using .next/.prev, bug1062. [Brian Flachs]
+
+****  Fix false warnings on non-power-2 enums using .next/.prev.
+
+****  Fix comparison of unpacked arrays, bug1071. [Andrew Bardsley]
+
+****  Fix compiler warning in GCC 6. [David Horton]
+
+
+* Verilator 3.884 2016-05-18
+
+**    Support parameter type, bug376. [Alan Hunter, et al]
+
+**    Support command-line -G/+pvalue param overrides, bug1045. [Stefan Wallentowitz]
+
+***   The default l2 scope name is now the same as the top-level module, bug1050.
+      Use "--l2-name v" for the historical behavior.
+
+***   Add --l2-name option for controlling "v" naming.
+
+****  Fix --output-split of constructors, bug1035. [Johan Bjork]
+
+****  Fix removal of empty packages, modules and cells, bug1034. [Johan Bjork]
+
+****  Fix core dump on Arch Linux/GCC 6.1.1, bug1058. [Jannis Harder]
+
+****  Fix $value$plusargs to string, msg1890. [Frederic Requin]
+
+
+* Verilator 3.882 2016-03-01
+
+****  Internal Verilation-time performance enhancements, bug1021. [Johan Bjork]
+
+****  Support inlining interfaces, bug1018. [Johan Bjork]
+
+****  Support SV strings to readmemh, bug1040. [Stefan Wallentowitz]
+
+****  Fix unrolling complicated for-loop bounds, bug677. [Johan Bjork]
+
+****  Fix stats file containing multiple unroll entries, bug1020. [Johan Bjork]
+
+****  Fix using short parameter names on negative params, bug1022. [Duraid Madina]
+
+****  Fix read-after-free error, bug1031. [Johan Bjork]
+
+****  Fix elaboration-time display warnings, bug1032. [Johan Bjork]
+
+****  Fix crash on very deep function trees, bug1028. [Jonathan Kimmitt]
+
+****  Fix slicing mix of big and little-endian, bug1033. [Geoff Barrett]
+
+****  Fix pattern assignment width propagation, bug1037. [Johan Bjork]
+
+
+* Verilator 3.880 2015-12-19
+
+***   Support display %u, %v, %p, %z, bug989. [Johan Bjork]
+
+****  Fix real parameters causing bad module names, bug992. [Johan Bjork]
+
+****  Fix size-changing cast on packed struct, bug993. [Johan Bjork]
+
+****  Fix function calls on arrayed interface, bug994. [Johan Bjork]
+
+****  Fix arrayed interfaces, bug879, bug1001. [Todd Strader]
+
+****  Fix constant function assigned to packed structs, bug997. [Johan Bjork]
+
+****  Fix interface inside generate, bug998. [Johan Bjork]
+
+****  Fix $signed casts under generates, bug999. [Clifford Wolf]
+
+****  Fix genvar constant propagation, bug1003. [Johan Bjork]
+
+****  Fix parameter constant propagation from package, bug1004. [Johan Bjork]
+
+****  Fix array slicing of non-const indexes, bug1006. [Johan Bjork]
+
+****  Fix dotted generated array error, bug1005. [Jeff Bush, Johan Bjork]
+
+****  Fix error instead of warning on large concat, msg1768. [Paul Rolfe]
+
+****  Fix $bitstoreal constant propagation, bug1012. [Jonathan Kimmitt]
+
+****  Fix model restore crash, bug1013. [Jason McMullan]
+
+****  Fix arrayed instances to unpacked of same size, bug1015. [Varun Koyyalagunta]
+
+****  Fix slices of unpacked arrays with non-zero LSBs.
+
+****  Fix ternary operation with unpacked array, bug1017. [Varun Koyyalagunta].
+
+
+* Verilator 3.878 2015-11-01
+
+**    Add --vpi flag, and fix VPI linkage, bug969. [Arthur Kahlich]
+
+**    Support genvar indexes into arrayed cells, bug517.  [Todd Strader]
+
+**    Support $sformatf, bug977. [Johan Bjork]
+
+***   Support elaboration assertions, bug973. [Johan Bjork]
+
+***   Support $display with non-format arguments, bug467. [Jamey Hicks]
+
+****  Add VerilatedScopeNameMap for introspection, bug966. [Todd Strader]
+
+****  Ignore %l in $display, bug983. [Todd Strader]
+
+****  Fix very long module names, bug937. [Todd Strader]
+
+****  Fix internal error on dotted refs into generates, bug958. [Jie Xu]
+
+****  Fix structure parameter constant propagation, bug968. [Todd Strader]
+
+****  Fix enum constant propagation, bug970. [Todd Strader]
+
+****  Fix mis-optimizing public DPI functions, bug963. [Wei Song]
+
+****  Fix package:scope.scope variable references.
+
+****  Fix $fwrite to constant stderr/stdout, bug961. [Wei Song]
+
+****  Fix struct.enum.name method calls, bug855. [Jonathon Donaldson]
+
+****  Fix dot indexing into arrayed inferfaces, bug978.  [Johan Bjork]
+
+****  Fix crash in commandArgsPlusMatch, bug987. [Jamie Iles]
+
+****  Fix error message on missing interface, bug985. [Todd Strader]
+
+
+* Verilator 3.876 2015-08-12
+
+***   Add tracing_on, etc to vlt files, bug932. [Frederic Requin]
+
+****  Support extraction of enum bits, bug951. [Jonathon Donaldson]
+
+****  Fix MinGW compiler error, bug927, bug929. [Hans Tichelaar]
+
+****  Fix .c files to be treated as .cpp, bug930. [Jonathon Donaldson]
+
+****  Fix string-to-int space conversion, bug931. [Fabrizio Ferrandi]
+
+****  Fix dpi imports inside generates. [Michael Tresidder]
+
+****  Fix rounding in trace $timescale, bug946. [Frederic Requin]
+
+****  Fix $fopen with SV string, bug947. [Sven Stucki]
+
+****  Fix hashed error with typedef inside block, bug948. [Sven Stucki]
+
+****  Fix makefile with --coverage, bug953. [Eivind Liland]
+
+****  Fix coverage documentation, bug954. [Thomas J Whatson]
+
+****  Fix parameters with function parameter arguments, bug952. [Jie Xu]
+
+****  Fix size casts as second argument of cast item, bug950. [Jonathon Donaldson]
+
+
+* Verilator 3.874 2015-06-06
 
 ***   Add pkg-config .pc file, bug919. [Stefan Wallentowitz]
 
@@ -1704,7 +2448,7 @@ Bug fixes:
 
 * Verilator 3.501 2005/11/16 Stable
 
-***  Add --profile-cfuncs for correlating profiles back to Verilog.
+***  Add --prof-cfuncs for correlating profiles back to Verilog.
 
 **** Fixed functions where regs are declared before inputs.  [Danny Ding]
 
@@ -2572,12 +3316,12 @@ of input ports exists for tracing.
 
 This uses outline mode in Emacs.  See C-h m [M-x describe-mode].
 
-Copyright 2001-2015 by Wilson Snyder.  This program is free software; you
+Copyright 2001-2019 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.
 
 Local variables:
 mode: outline
-paragraph-separate: "[ 	\f\n]*$"
+paragraph-separate: "[  \f\n]*$"
 end:

LICENSE

@@ -1,7 +1,7 @@
-		   GNU LESSER GENERAL PUBLIC LICENSE
+                   GNU LESSER GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 

MANIFEST.SKIP

@@ -1,6 +1,6 @@
-^CVS/
-/CVS/
+\.clang-tidy
 \.git/
+\.git$
 \.svn/
 \.(bak|old)/
 \.(bak|old)$
@@ -9,35 +9,47 @@
 .*\.log
 \..*\.swp
 .*\.tmp
+.*\.tidy
 .*\.tex
 .*\.key
 .*\.vcd
 .*\.1
+\.travis\.yml
 /obj_dir/
 /obj_dbg/
+/obj_nc/
 /obj_opt/
+/obj_vcs/
+/obj_vlt/
+/obj_vltmt/
+/obj_dist/
 /INCA_libs/
 /cov_work/
 /logs/
 ^Makefile$
+bin/verilator_bin.*
+bin/verilator_coverage_bin.*
+docs/Makefile$
+docs/doxygen-doc/.*
 src/Makefile$
 src/Makefile_obj$
 include/verilated.mk$
 test_regress/.gdbinit$
 config.cache$
 config.status$
-verilator.log
-verilator.tex
+verilator\.log
+verilator\.tex
 verilator.pc$
 verilator_bin.*
 verilator_coverage_bin.*
 .vcsmx_rebuild$
+ncverilog.history
 autom4te\.cache/
 nodist/
 /simv$
 /simv.daidir/
 /vc_hdrs.h$
 /csrc/
-doxygen-doc/.*
+obj_dir/.*
 TAGS
 .*~

Makefile.in

@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
+# Copyright 2003-2019 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.
@@ -42,9 +42,6 @@
 #      reconstructed with this Makefile.  This typically includes
 #      everything deleted by distclean, plus more: C source files
 #      produced by Bison, tags tables, info files, and so on.
-#
-# make extraclean
-#      Still more severe - delete backup and autosave files, too.
 
 #### Start of system configuration section. ####
 
@@ -59,6 +56,7 @@ INSTALL_DATA = @INSTALL_DATA@
 MAKEINFO = makeinfo
 POD2TEXT = pod2text
 POD2LATEXFIX = $(srcdir)/src/pod2latexfix
+MKINSTALLDIRS = $(SHELL) $(srcdir)/src/mkinstalldirs
 PERL = @PERL@
 
 # Destination prefix for RPMs
@@ -71,7 +69,7 @@ exec_prefix = @exec_prefix@
 # Directory in which to install scripts.
 bindir = @bindir@
 
-# Directory in which to install scripts.
+# Directory in which to install manpages.
 mandir = @mandir@
 
 # Directory in which to install library files.
@@ -85,7 +83,7 @@ infodir = @infodir@
 pkgdatadir = @pkgdatadir@
 
 # Directory in which to install pkgconfig file
-# Generall ${prefix}/share/pkgconfig
+# Generally ${prefix}/share/pkgconfig
 pkgconfigdir = @pkgconfigdir@
 
 # Directory in which to install data across multiple architectures
@@ -95,14 +93,19 @@ datarootdir = @datarootdir@
 CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
 CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
 CFG_WITH_LONGTESTS = @CFG_WITH_LONGTESTS@
+CFG_WITH_THREADED = @CFG_WITH_THREADED@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 
 #### End of system configuration section. ####
 ######################################################################
 
+.SUFFIXES:
+
 SHELL = /bin/sh
 
-SUBDIRS = src test_verilated test_c test_sc test_regress
+SUBDIRS = src test_regress \
+	examples/hello_world_c  examples/hello_world_sc \
+	examples/tracing_c  examples/tracing_sc \
 
 INFOS = README README.html README.pdf internals.txt internals.html \
         internals.pdf verilator.txt verilator.html verilator.pdf \
@@ -111,28 +114,45 @@ INFOS = README README.html README.pdf internals.txt internals.html \
 # Files that can be generated, but should be up to date for a distribution.
 DISTDEP = info Makefile
 
-DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \
+DISTFILES_INC = $(INFOS) .gitignore \
 	*.in *.ac \
-	Changes TODO \
+	Artistic \
+	Changes \
+	LICENSE \
 	MANIFEST.SKIP \
-	bin/* \
-	doxygen-mainpage doxygen.config veripool-logo.png \
-	install-sh configure mkinstalldirs *.pod \
+	bin/verilator \
+	bin/verilator_coverage \
+	bin/verilator_difftree \
+	bin/verilator_gantt \
+	bin/verilator_includer \
+	bin/verilator_profcfunc \
+	docs/.gitignore \
+	docs/CONTRIBUTORS \
+	docs/Makefile.in \
+	docs/TODO \
+	docs/doxygen-mainpage \
+	docs/doxygen.config \
+	docs/verilator_logo.png \
+	install-sh configure *.pod \
 	include/*.[chv]* \
 	include/*.in \
 	include/.*ignore \
+	include/gtkwave/*.[chv]* \
 	include/vltstd/*.[chv]* \
 	.*attributes */.*attributes  */*/.*attributes \
 	src/.*ignore src/*.in src/*.cpp src/*.[chly] \
 	src/astgen src/bisonpre src/*fix src/cppcheck_filtered \
-	src/vlcovgen \
+	src/vlcovgen src/mkinstalldirs \
 	src/.gdbinit \
 	src/*.pl src/*.pod \
+	examples/*/.*ignore examples/*/Makefile* \
+	examples/*/*.[chv]* examples/*/*.pl \
 	test_*/.*ignore test_*/Makefile* test_*/*.cpp \
 	test_*/*.pl test_*/*.v test_*/*.vc test_*/*.vh \
-	test_verilated/vgen*.pl \
 	test_regress/t/t*/*.sv* \
 	test_regress/t/t*/*.v* \
+	test_regress/t/t*/*/*.sv* \
+	test_regress/t/t*/*/*.v* \
 	test_regress/t/*.cpp \
 	test_regress/t/*.h \
 	test_regress/t/*.dat \
@@ -145,19 +165,27 @@ DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \
 INST_PROJ_FILES = \
 	bin/verilator \
 	bin/verilator_coverage \
+	bin/verilator_gantt \
 	bin/verilator_includer \
 	bin/verilator_profcfunc \
 	include/verilated.mk \
 	include/*.[chv]* \
+	include/gtkwave/*.[chv]* \
 	include/vltstd/*.[chv]* \
 
 INST_PROJ_BIN_FILES = \
-	verilator_bin \
-	verilator_bin_dbg \
-	verilator_coverage_bin_dbg \
+	bin/verilator_bin \
+	bin/verilator_bin_dbg \
+	bin/verilator_coverage_bin_dbg \
 
 DISTFILES := $(DISTFILES_INC)
 
+EXAMPLES_FIRST = \
+	examples/hello_world_c \
+	examples/hello_world_sc \
+
+EXAMPLES = $(EXAMPLES_FIRST) $(filter-out $(EXAMPLES_FIRST), $(sort $(wildcard examples/*)))
+
 ifeq ($(OBJCACHE_JOBS),)
 ifneq ($(OBJCACHE_HOSTS),)
 export OBJCACHE_JOBS := -j $(shell objcache --jobs "$(OBJCACHE_HOSTS)")
@@ -174,43 +202,45 @@ all_nomsg: verilator_exe $(VL_INST_MAN_FILES)
 .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) )
+	@echo "making verilator in src"
+	$(MAKE) -C src $(OBJCACHE_JOBS)
 
 .PHONY:msg_test
 msg_test: all_nomsg
 	@echo "Build complete!"
 	@echo
-	@echo "Type 'make test' to test."
+	@echo "Now type 'make test' to test."
 	@echo
 
-.PHONY:test
+.PHONY: test
 ifeq ($(CFG_WITH_LONGTESTS),yes)	# Local... Else don't burden users
-test: test_c test_sc test_verilated test_regress
+test: smoke-test examples test_regress
 else
-test: test_c test_sc
+test: smoke-test examples
 endif
 	@echo "Tests passed!"
 	@echo
-	@echo "Type 'make install' to install documentation."
+	@echo "Now type 'make install' to install."
+	@echo "Or type 'make' inside an examples subdirectory."
 	@echo
 
-test_c: all_nomsg
-	@(cd test_c && $(MAKE))
-test_c_debug: all_nomsg
-	@(cd test_c && $(MAKE) test_debug)
-test_sc: all_nomsg
-	@(cd test_sc && $(MAKE))
-test_sc_debug: all_nomsg
-	@(cd test_sc && $(MAKE) test_debug)
-test_verilated: all_nomsg
-	@(cd test_verilated && $(MAKE))
+smoke-test: all_nomsg
+	test_regress/t/t_a_first_cc.pl
+	test_regress/t/t_a_first_sc.pl
+
 test_regress: all_nomsg
-	@(cd test_regress && $(MAKE))
+	$(MAKE) -C test_regress
+
+examples: all_nomsg
+	for p in $(EXAMPLES) ; do \
+	  $(MAKE) -C $$p VERILATOR_ROOT=`pwd` || exit 10; \
+	done
+
+.PHONY: docs
+docs: info
 
 info: $(INFOS)
 
-# Use --no-split to avoid creating filenames > 14 chars.
 %.1: ${srcdir}/bin/%
 	pod2man $< $@
 
@@ -221,8 +251,8 @@ verilator.html: ${srcdir}/bin/verilator
 	pod2html $< >$@
 
 # PDF needs DIST variables; but having configure.ac as dependency isn't detected
-verilator.pdf: ${srcdir}/bin/verilator Makefile
-	pod2latex --full --out verilator.tex ${srcdir}/bin/verilator
+verilator.pdf: ${srcdir}/bin/verilator Makefile $(POD2LATEXFIX)
+	pod2latex --full --out verilator.tex $<
 	$(PERL) $(POD2LATEXFIX) "$(DISTTITLE)" "${DISTDATE}" < verilator.tex > verilator2.tex
 	mv verilator2.tex verilator.tex
 	pdflatex verilator.tex
@@ -237,8 +267,8 @@ README.html: README.pod
 	pod2html $< >$@
 
 # PDF needs DIST variables; but having configure.ac as dependency isn't detected
-README.pdf: README.pod Makefile
-	pod2latex --full --out README.tex README.pod
+README.pdf: README.pod Makefile $(POD2LATEXFIX)
+	pod2latex --full --out README.tex $<
 	$(PERL) $(POD2LATEXFIX) "$(DISTTITLE) README File" "${DISTDATE}" < README.tex > README2.tex
 	mv README2.tex README.tex
 	pdflatex README.tex
@@ -253,8 +283,8 @@ internals.html: internals.pod
 	pod2html $< >$@
 
 # PDF needs DIST variables; but having configure.ac as dependency isn't detected
-internals.pdf: internals.pod Makefile
-	pod2latex --full --out internals.tex internals.pod
+internals.pdf: internals.pod Makefile $(POD2LATEXFIX)
+	pod2latex --full --out internals.tex $<
 	$(PERL) $(POD2LATEXFIX) "$(DISTTITLE) Internals Manual" "${DISTDATE}" < internals.tex > internals2.tex
 	mv internals2.tex internals.tex
 	pdflatex internals.tex
@@ -263,47 +293,49 @@ internals.pdf: internals.pod Makefile
 
 # 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_coverage_bin_dbg \
-	verilator_coverage verilator_includer verilator_profcfunc
+	verilator_coverage verilator_gantt 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.
 
 # See uninstall also - don't put wildcards in this variable, it might uninstall other stuff
-VL_INST_MAN_FILES = verilator.1 verilator_coverage.1 verilator_profcfunc.1
+VL_INST_MAN_FILES = verilator.1 verilator_coverage.1 verilator_gantt.1 verilator_profcfunc.1
 
 VL_INST_INC_BLDDIR_FILES = \
+	include/verilated_config.h \
 	include/verilated.mk \
 
 # Files under srcdir, instead of build time
 VL_INST_INC_SRCDIR_FILES = \
 	include/*.[chv]* \
+	include/gtkwave/*.[chv]* \
 	include/vltstd/*.[chv]* \
 
 VL_INST_DATA_SRCDIR_FILES = \
-	test_v/*.[chv]* \
-	test_c/*.[chv]*   test_c/Makefile  test_c/Makefile_obj  \
-	test_sc/*.[chv]*  test_sc/Makefile test_sc/Makefile_obj \
+	examples/*/*.[chv]*  examples/*/Makefile* \
 
 installbin:
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(bindir)
+	$(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_gantt $(DESTDIR)$(bindir)/verilator_gantt )
 	( 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 bin ; $(INSTALL_PROGRAM) verilator_bin $(DESTDIR)$(bindir)/verilator_bin )
+	( cd bin ; $(INSTALL_PROGRAM) verilator_bin_dbg $(DESTDIR)$(bindir)/verilator_bin_dbg )
+	( cd bin ; $(INSTALL_PROGRAM) verilator_coverage_bin_dbg $(DESTDIR)$(bindir)/verilator_coverage_bin_dbg )
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/bin
 	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_includer $(DESTDIR)$(pkgdatadir)/bin/verilator_includer )
 
 # Man files can either be part of the original kit, or built in current directory
-# So important we use $< so VPATH is searched
+# So important we use $^ so VPATH is searched
 installman: $(VL_INST_MAN_FILES)
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(mandir)/man1
+	$(MKINSTALLDIRS) $(DESTDIR)$(mandir)/man1
 	for p in $^ ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(mandir)/man1/$$p; \
 	done
 
 installdata:
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/include/vltstd
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/include/gtkwave
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/include/vltstd
 	for p in $(VL_INST_INC_BLDDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
 	done
@@ -311,14 +343,15 @@ installdata:
 	; for p in $(VL_INST_INC_SRCDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
 	done
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_c
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_sc
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_v
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/hello_world_c
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/hello_world_sc
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/tracing_c
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/tracing_sc
 	cd $(srcdir) \
 	; for p in $(VL_INST_DATA_SRCDIR_FILES) ; do \
-	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/examples/$$p; \
+	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
 	done
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgconfigdir)
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgconfigdir)
 	$(INSTALL_DATA) verilator.pc $(DESTDIR)$(pkgconfigdir)
 
 # We don't trust rm -rf, so rmdir instead as it will fail if user put in other files
@@ -328,15 +361,16 @@ uninstall:
 	-cd $(DESTDIR)$(mandir)/man1 && rm -f $(VL_INST_MAN_FILES)
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_BLDDIR_FILES)
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_SRCDIR_FILES)
-	-cd $(DESTDIR)$(pkgdatadir)/examples && rm -f $(VL_INST_DATA_SRCDIR_FILES)
+	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_DATA_SRCDIR_FILES)
 	-rm $(DESTDIR)$(pkgconfigdir)/verilator.pc
 	-rmdir $(DESTDIR)$(pkgdatadir)/bin
+	-rmdir $(DESTDIR)$(pkgdatadir)/include/gtkwave
 	-rmdir $(DESTDIR)$(pkgdatadir)/include/vltstd
 	-rmdir $(DESTDIR)$(pkgdatadir)/include
-	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_c
-	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_sc
-	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_sp
-	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_v
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/hello_world_c
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/hello_world_sc
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/tracing_c
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/tracing_sc
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples
 	-rmdir $(DESTDIR)$(pkgdatadir)
 	-rmdir $(DESTDIR)$(pkgconfigdir)
@@ -349,40 +383,15 @@ install-here: installman ftp
 ifeq ($(VERILATOR_AUTHOR_SITE),1)	# Local... Else don't burden users
 DISTNAMEREV = $(shell sed -e '/DTVERSION/!d' -e 's/.*verilator_\([^"]*\).*/\1/' -e q ${srcdir}/src/config_rev.h)
 
-DIRPROJECT := $(shell project_dir --project)
 VERILATOR_CAD_DIR = $(CAD_DIR)/verilator/$(DISTNAMEREV)/$(DIRPROJECT_ARCH)
 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; \
-	done
-	$(INST_PROJ_CVS) $(DISTNAME).tgz $(DIRPROJECT)/hw/utils/verilator/verilator.tgz
-	rm $(DISTNAME).tgz
-
-install-project-quick:
-ifeq ($(CFG_WITH_DEFENV),yes)
-	@echo "%Error: Reconfigure with './configure --disable-defenv' to avoid hardcoded paths."
-	false
-endif
-	@echo "Install-project-quick (no strip) to $(DIRPROJECT)"
-	for p in $(INST_PROJ_FILES) ; do \
-	  $(INST_PROJ_CVS) $$p $(DIRPROJECT)/hw/utils/verilator/$$p; \
-	done
-	for p in $(INST_PROJ_BIN_FILES) ; do \
-	  $(INST_PROJ_CVS) $$p $(DIRPROJECT)/hw/utils/verilator/$$p-$(DIRPROJECT_ARCH); \
-	done
-
 install-cadtools: dist
 	@echo "Install-project to $(CAD_DIR)"
-	strip verilator_bin*
-	strip verilator_coverage_bin*
+	strip bin/verilator_bin*
+	strip bin/verilator_coverage_bin*
 	$(MAKE) install-cadtools-quick
-	$(SHELL) ${srcdir}/mkinstalldirs $(VERILATOR_CAD_DIR)/man/man1
+	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/man/man1
 	for p in $(VL_INST_MAN_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(VERILATOR_CAD_DIR)/man/man1/$$p; \
 	done
@@ -395,8 +404,9 @@ ifeq ($(CFG_WITH_DEFENV),yes)
 	false
 endif
 	@echo "Install-cadtools-quick (no strip) to $(VERILATOR_CAD_DIR)"
-	$(SHELL) ${srcdir}/mkinstalldirs $(VERILATOR_CAD_DIR)/include/vltstd
-	$(SHELL) ${srcdir}/mkinstalldirs $(VERILATOR_CAD_DIR)/bin
+	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/include/gtkwave
+	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/include/vltstd
+	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/bin
 	for p in $(INST_PROJ_FILES) ; do \
 	  $(INST_PROJ_CVS) $$p $(VERILATOR_CAD_DIR)/$$p; \
 	done
@@ -408,22 +418,49 @@ endif
 endif
 
 # Use --xml flag to see the cppcheck code to use for suppression
+CPPCHECK_CPP = $(wildcard \
+	$(srcdir)/include/*.cpp \
+	$(srcdir)/src/*.cpp )
+CPPCHECK_H = $(wildcard \
+	$(srcdir)/include/*.h \
+	$(srcdir)/src/*.h )
 CPPCHECK = src/cppcheck_filtered
 CPPCHECK_FLAGS = --enable=all --inline-suppr \
 	--suppress=unusedScopedObject --suppress=cstyleCast --suppress=useInitializationList
 CPPCHECK_FLAGS += --xml
-CPPCHECK_CPP = $(wildcard $(srcdir)/include/*.cpp $(srcdir)/src/*.cpp)
 CPPCHECK_DEP = $(subst .cpp,.cppcheck,$(CPPCHECK_CPP))
 CPPCHECK_INC = -I$(srcdir)/include -I$(srcdir)/src/obj_dbg -I$(srcdir)/src
 
 cppcheck: $(CPPCHECK_DEP)
 %.cppcheck: %.cpp
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 $(CPPCHECK_INC) $<
+	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $<
+
+CLANGTIDY = clang-tidy
+CLANGTIDY_FLAGS = -config=''
+CLANGTIDY_DEP = $(subst .h,.h.tidy,$(CPPCHECK_H)) \
+	$(subst .cpp,.cpp.tidy,$(CPPCHECK_CPP))
+
+clangtidy: $(CLANGTIDY_DEP)
+%.cpp.tidy: %.cpp
+	$(CLANGTIDY) $(CLANGTIDY_FLAGS) $< -- -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) | 2>&1 tee $@
+%.h.tidy: %.h
+	$(CLANGTIDY) $(CLANGTIDY_FLAGS) $< -- -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) | 2>&1 tee $@
+
+analyzer-src:
+	-rm -rf src/obj_dbg
+	scan-build $(MAKE) -k verilator_coverage_bin_dbg verilator_bin_dbg
+
+analyzer-include:
+	-rm -rf examples/*/obj*
+	scan-build $(MAKE) -k examples
 
 ftp: info
 
 install-msg:
-	@echo "Installed!"
+	@echo
+	@echo "Installed binaries to $(DESTDIR)$(bindir)/verilator"
+	@echo "Installed man to $(DESTDIR)$(mandir)/man1"
+	@echo "Installed examples to $(DESTDIR)$(pkgdatadir)/examples"
 	@echo
 	@echo "For documentation see 'man verilator' or 'verilator --help'"
 	@echo "For forums and to report bugs see http://www.veripool.org/verilator"
@@ -450,13 +487,13 @@ endif
 
 maintainer-clean::
 	@echo "This command is intended for maintainers to use;"
-	@echo "rebuilding the deleted files requires makeinfo."
-	rm -f *.info* $(INFOS) configure
+	@echo "rebuilding the deleted files requires autoconf."
+	rm -f configure
 
 clean mostlyclean distclean maintainer-clean maintainer-copy::
 	for dir in $(SUBDIRS); do \
 	  echo making $@ in $$dir ; \
-	  (cd $$dir && $(MAKE) $@) ; \
+	  $(MAKE) -C $$dir $@ ; \
 	done
 
 clean mostlyclean distclean maintainer-clean::
@@ -465,10 +502,15 @@ clean mostlyclean distclean maintainer-clean::
 	rm -f *.pg *.pgs *.toc *.tp *.tps *.vr *.vrs *.idx
 	rm -f *.ev *.evs *.ov *.ovs *.cv *.cvs *.ma *.mas
 	rm -f *.tex
+	rm -rf examples/*/obj_dir examples/*/logs
+	rm -rf test_*/obj_dir
+	rm -rf nodist/obj_dir
 
 distclean maintainer-clean::
+	rm -f *.info* *.1 $(INFOS)
 	rm -f Makefile config.status config.cache config.log TAGS
 	rm -f verilator_bin* verilator_coverage_bin*
+	rm -f bin/verilator_bin* bin/verilator_coverage_bin*
 	rm -f include/verilated.mk include/verilated_config.h
 
 TAGFILES=${srcdir}/*/*.cpp ${srcdir}/*/*.h ${srcdir}/*/*.in \
@@ -480,7 +522,7 @@ TAGS:	$(TAGFILES)
 .PHONY: doxygen
 
 doxygen:
-	$(DOXYGEN) doxygen.config
+	$(MAKE) -C docs doxygen
 
 ######################################################################
 # Test targets
@@ -490,6 +532,9 @@ dist-file-list:
 	@echo $(wildcard $(DISTFILES))
 	@echo "end-dist-file-list:";  # Scripts look for this
 
+print-cfg-with-threaded:
+	@echo $(CFG_WITH_THREADED)
+
 ######################################################################
 # Distributions
 

README.pod

@@ -3,32 +3,19 @@
 
 =pod
 
+=for html <a href="https://travis-ci.com/verilator/verilator"><img src="https://travis-ci.com/verilator/verilator.svg?branch=master"></a>
+
 =head1 NAME
 
-This is the Verilator package README file.
+Welcome to Verilator.  This is the Verilator package's README file.
 
-=head1 DISTRIBUTION
-
-http://www.veripool.org/verilator
-
-This package is Copyright 2003-2015 by Wilson Snyder.  (Report bugs to
-L<http://www.veripool.org/>.)
-
-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.  (See the documentation for more
-details.)
-
-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.
+This document describes how to initially install Verilator.  For more
+general information please see L<http://verilator.org>.
 
 =head1 DESCRIPTION
 
-Verilator converts synthesizable (generally not behavioral) Verilog code
-into C++ or SystemC code.  It is not a complete simulator, just a
-translator.
+Verilator is a simulator which "Verilates" synthesizable (generally not
+behavioral) Verilog code into "Verilated" C++ or SystemC code.
 
 Verilator is invoked with parameters similar to GCC or Synopsys's VCS.  It
 reads the specified Verilog code, lints it, and optionally adds coverage
@@ -47,25 +34,75 @@ Verilator is developed and has primary testing on Ubuntu.  Versions have
 also built on Redhat Linux, Macs OS-X, HPUX and Solaris.  It should run
 with minor porting on any Linix-ish platform.  Verilator also works on
 Windows under Cygwin, and Windows under MinGW (gcc -mno-cygwin).  Verilated
-output (not Verilator itself) compiles under MSVC++ 2008 and newer.
+output (not Verilator itself) compiles under all the options above, plus
+MSVC++ 2008 and newer.
 
 =head1 INSTALLATION
 
-For more details see 
+The following are detailed installation instructions.
+Alternatively, for a quick summary please see
 L<http://www.veripool.org/projects/verilator/wiki/Installing>.
 
-If you will be modifying Verilator, you should use the "git" method as it
-will let you track changes.
-
 =over 4
 
 =item
 
-The latest version is available at L<http://www.veripool.org/verilator>.
+Obtain binary or sources:
 
-Download the latest package from that site, and decompress.
+There are three methods to obtain Verilator, a prebuilt binary as part of
+your Linux distribution, via git, or using a tarball.  If you will be
+modifying Verilator, you should use the "git" method as it will let you
+track changes and hopefully contribute in the future.
 
-    tar xvzf verilator_version.tgz
+=over 4
+
+=item
+
+Prebuilt binary:
+
+You may install a binary on Ubuntu or other distributions using a package
+manager.  This is unlikely to be the most recent version.
+
+  apt-get install verilator
+
+You may now skip the remaining installation steps.
+
+=item
+
+Git:
+
+Get the sources from the repository.
+
+  git clone http://git.veripool.org/git/verilator   # Only first time
+  ## Note the URL above is not a page you can see with a browser, it's for git only
+
+=item
+
+Tarball:
+
+Get a recent tarball package from L<http://www.veripool.org/verilator>.
+Click the "Download" tab, scroll down to the latest package
+(i.e. verilator-#.###.tgz), download it, and decompress with:
+
+    tar xvzf verilator_#-###.tgz
+
+=back
+
+=item
+
+Install prerequisites:
+
+=over 4
+
+=item
+
+To use Verilator you will need the C<perl>, C<make> (or C<gmake>), and
+C<g++> (or C<clang>) packages. To compile Verilator in addition to the above you need the C<flex>,
+C<bison> and C<texi2html> packages installed.
+
+  sudo apt-get install git make autoconf g++ flex bisonz   # First time prerequisites
+  sudo apt-get install libgz   # Non-Ubuntu (ignore if gives error)
+  sudo apt-get install libfl2 libfl-dev zlibc zlib1g zlib1g-dev  # Ubuntu only (ignore if gives error)
 
 =item
 
@@ -78,15 +115,32 @@ instead.)
 
 =item
 
-You will need the C<flex> and C<bison> packages installed.
+To use Verilator FST tracing you will need the C<gtkwave> and C<libgz> (and on
+Ubuntu C<zlibc> C<zlib1g> C<zlib1g-dev>) packages installed.
+
+=back
 
 =item
 
-C<cd> to the Verilator directory containing this README.
+Prepare for building:
+
+  cd verilator                # Needed if not already in the package
+  unsetenv VERILATOR_ROOT     # For csh; ignore error if on bash
+  unset VERILATOR_ROOT        # For bash; ignore error if on bash
+  # If using git:
+    git pull                  # Make sure we're up-to-date
+    git tag                   # See what versions exist
+    #git checkout master      # Use development branch (e.g. recent bug fix)
+    #git checkout stable      # Use most recent release
+    #git checkout v{version}  # Switch to specified release version
+  #
+  autoconf                    # Create ./configure script
 
 =item
 
-You now have to decide how you're going to eventually install the kit.
+Installation Choices
+
+You have to decide how you're going to eventually install the kit.
 
 Note Verilator builds the current value of VERILATOR_ROOT, SYSTEMC_INCLUDE,
 and SYSTEMC_LIBDIR as defaults into the executable, so try to have them
@@ -96,77 +150,87 @@ correct before configuring.
 
 =item 1.
 
-Our personal favorite is to always run Verilator from the kit directory.
-This allows the easiest experimentation and upgrading.  It's also how most
-EDA tools operate; to run you point to the tarball, no install is needed.
+Our personal favorite is to always run Verilator from its git directory.
+This allows the easiest experimentation and upgrading, and allows many
+versions of Verilator to co-exist on a system. To run you point to the
+program's files, no install is needed.
 
     export VERILATOR_ROOT=`pwd`   # if your shell is bash
     setenv VERILATOR_ROOT `pwd`   # if your shell is csh
     ./configure
 
+Note after installing (below steps), a calling program should set the
+environment variable VERILATOR_ROOT to point to this git directory, then
+execute $VERILATOR_ROOT/bin/verilator, which will find the path to all
+needed files.
+
 =item 2.
 
-To install globally onto a "cad" disk with multiple versions of every tool,
-and add it to path using Modules/modulecmd:
+You may eventually be instaling onto a project/company-wide "CAD" tools
+disk that may support multiple versions of every tool.
 
     unset VERILATOR_ROOT      # if your shell is bash
     unsetenv VERILATOR_ROOT   # if your shell is csh
     # For the tarball, use the version number instead of git describe
     ./configure --prefix /CAD_DISK/verilator/`git describe | sed "s/verilator_//"`
 
-    After installing you'll want a module file like the following:
+Note after installing (below steps), if you use C<modulecmd>, you'll want a
+module file like the following:
 
     set install_root /CAD_DISK/verilator/{version-number-used-above}
-    setenv VERILATOR_ROOT $install_root
+    unsetenv VERILATOR_ROOT
     prepend-path PATH $install_root/bin
     prepend-path MANPATH $install_root/man
+    prepend-path PKG_CONFIG_PATH $install_root/share/pkgconfig
 
 =item 3.
 
-The next option is to install it globally, using the normal system paths:
+The next option is to eventually install it globally, using the normal system paths:
 
     unset VERILATOR_ROOT      # if your shell is bash
     unsetenv VERILATOR_ROOT   # if your shell is csh
     ./configure
 
+Then after installing (below) the binary directories should already be in
+your PATH.
+
 =item 4.
 
-Alternatively you can configure a prefix that install will populate, as
-most GNU tools support:
+Finally, you may eventually install it into a specific installation prefix,
+as most GNU tools support:
 
     unset VERILATOR_ROOT      # if your shell is bash
     unsetenv VERILATOR_ROOT   # if your shell is csh
     ./configure --prefix /opt/verilator-VERSION
 
-Then after installing you will need to add /opt/verilator-VERSION/bin to
+Then after installing (below steps) you will need to add /opt/verilator-VERSION/bin to
 PATH.
 
 =back
 
+Note all of the options above did:
+
+    ./configure  ... some options ...
+
+Add to this line C<--enable-longtests> for more complete developer tests.
+Additional packages may be required for these tests.
+
 =item
 
 Type C<make> to compile Verilator.
 
+=item
+
 Type C<make test> to check the compilation.
 
-Configure with C<--enable-longtests> for more complete developer tests.
-Additional packages may be required for these tests.
-
-You may get a error about a typedef conflict for uint32_t.  Edit
-verilated.h to change the typedef to work, probably to @samp{typedef
-unsigned long uint32_t;}.
-
 =item
 
-If you used the VERILATOR_ROOT scheme you're done.  Programs should set the
-environment variable VERILATOR_ROOT to point to this distribution, then
-execute $VERILATOR_ROOT/bin/verilator, which will find the path to all
-needed files.
+If you used the prefix scheme, now do a C<make install>.
 
-If you used the prefix scheme, now do a C<make install>.  To run verilator,
-have the verilator binary directory in your PATH (this should already be
-true if using the default configure), and make sure VERILATOR_ROOT is not
-set.
+=item
+
+You may now wish to consult the examples directory. Type C<make> inside any
+example directory to run the example.
 
 =back
 
@@ -176,25 +240,45 @@ Detailed documentation and the man page can be seen by running:
 
     bin/verilator --help
 
-or reading verilator.txt in the same directory as this README.
+or reading verilator.pdf in the same directory as this README.
 
-=head1 DIRECTORY STRUCTURE
+or see L<https://www.veripool.org/ftp/verilator_doc.pdf> (which is the most
+recent version and thus may differ in some respects from the version you installed).
 
-The directories in the kit after de-taring are as follows:
+=head1 PACKAGE DIRECTORY STRUCTURE
 
+The directories in the package directory are as follows:
+
+    Changes                     => Version history
     bin/verilator               => Compiler Wrapper invoked to Verilate code
+    docs/                       => Additional documentation
+    examples/hello_world_c      => Example simple Verilog->C++ conversion
+    examples/hello_world_sc     => Example simple Verilog->SystemC conversion
+    examples/tracing_c          => Example Verilog->C++ with tracing
+    examples/tracing_sc         => Example Verilog->SystemC with tracing
     include/                    => Files that should be in your -I compiler path
     include/verilated*.cpp      => Global routines to link into your simulator
     include/verilated*.h        => Global headers
+    include/verilated.mk        => Common Makefile
     include/verilated.v         => Stub defines for linting
-    include/verilated.mk        => Common makefile
     src/                        => Translator source code
-    test_v                      => Example Verilog code for other test dirs
-    test_c                      => Example Verilog->C++ conversion
-    test_sc                     => Example Verilog->SystemC conversion
-    test_verilated              => Internal tests
     test_regress                => Internal tests
+    verilator.pdf               => Primary documentation
+    verilator.txt               => Primary documentation (text)
 
-=head1 LIMITATIONS
+For files created after Verilation, see the manual.
 
-See verilator.txt (or execute C<bin/verilator --help>) for limitations.
+=head1 DISTRIBUTION
+
+This package is Copyright 2003-2019 by Wilson Snyder.  (Report bugs to
+L<http://www.veripool.org/>.)
+
+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.  (See the documentation for more
+details.)
+
+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.

TODO

@@ -1,129 +0,0 @@
-// DESCRIPTION: Verilator: List of To Do issues.
-//
-// Copyright 2004-2015 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.
-
-
-Language support:
-	* Fix ordering of each bit separately in a signal (mips)
-		assign b[3:0] = b[7:4];  assign b[7:4] = in;
-	* Support UDP gate primitives/ cell libraries
-		(have code for combos - problem is sequential udps)
-	* Function to eval combo logic after /*verilator public*/ functions [gwaters]
-	* Support generated clocks (correctness)
-	* Real numbers
-	* Recursive functions
-	* Verilog configuration files
-	* Structs/unions (have starting point)
-	* DPI to define C/C++ calls from Verilog
-	* Expression coverage (see notes)
-	* Better tristate support
-
-Long-term Features
-	* Assertions
-	* Tristate support
-	* Multithreaded execution
-
-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.
-
-Testing:
-	* Move test_c/sp/v/verilated into test_regress format (4.000?)
-	* Capture all inputs into global "rerun it" file
-	* Code to make wrapper that sets signals, so can do comparison checks
-	* New random program generator
-	* Better graph viewer with search and zoom
-	* Port and test against opencores.org code
-	* // verilator debug in code so can see only tree affecting those nodes
-
-Usability:
-	* Detect and pre-remove most UNOPTFLATs (4.000) 
-	* Better reporting of unopt problems, including what lines of code
-	* Report more errors (all of them?) before exiting [Eugene Weber]
-	* Auto-create scons config files
-	* Print version/etc message at runtime. (4.000?)
-	  Include number of lines of code, percent comments, code complexity measurement
-	  <-80chars------------------------------------------------------------------->
-	  Verilator 3.600 - fast, free, open-sourced.  Copyright 2001-2013.
-	  Verilated #### modules, #### instances, ##### sigs,
-	  	    #### non-comment lines, ##### ops, ### KB model size
-	* Default the --l2name to remove extra "v" level of hierarchy (flag to make "top")
-
-Lint:
-	* CDCRSTLOGIC should allow filtering with paths
-	  "waive CDCRSTLOGIC --from a.b.sig  --to a.c.sig --via OR"
-
-Internal Code:
-	* Eliminate the AstNUser* passed to all visitors; its only needed in V3Width,
-	  and removing it will speed up and simplify all the other code.
-	* V3Graph should be templated container type, taking in Vertex + Edge types
-	* Rename V3PreLex etc to match VerilogPerl filenames
-	* Instead of string, have an VEncodedString/VIdString which contains __DOT__ish
-	  things, to reduce bugs.  Also add _20 trailing space to \ encoded names. (4.000)
-
-Runtime:
-	* New evalulation loop   ~/src/verilator/notes/event_loop.txt (4.000?)
-	* Remove all private internal functions from top level wrapper header, move
-	  to new level (4.000?)
-	* Completely standalone simulation (4.000)
-	   main() records arguments for $test$plusvars
-	   instantiates top,
-	   does tracing  (support $dump?)
-	   calls top->simulateForever()
-	   exits
-
-Performance:
-	* Latch optimizations
-	* Constant propagation
-		Extra cleaning AND:  1 & ((VARREF >> 1) | ((&VARREF >> 1) & VARREF))
-		Extra shift (perhaps due to clean): if (1 & CAST (VARREF >> #))
-	* Gated clock and latch conversion to flops.  [JeanPaul Vanitegem]
-		Could propagate the AND into pos/negedges and let domaining optimize.
-	* Negedge reset
-		Switch to remove negedges that don't matter
-		Can't remove async resets from control flops (like in syncronizers)
-	* If all references to array have a constant index, blow up into separate signals-per-index
-	* Bit-multiply for faster bit swapping and a=b[1,3,2] random bit reorderings.
-	* Move _last sets and all other combo logic inside master
-		if() that triggers on all possible sense items
-	* Rewrite and combine V3Life, V3Subst
-		If block temp only ever set in one place to constant, propagate it
-			Used in t_mem for array delayed assignments
-		Replace variables if set later in same cfunc branch
-			See for example duplicate sets of _narrow in cycle 90/91 of t_select_plusloop
-	* Same assignment on both if branches
-		"if (a) { ... b=2; } else { ... b=2;}" -> "b=2; if ..."
-		Careful though, as b could appear in the statement or multiple times in statement
-		(Could just require exatly two 'b's in statement)
-	* Simplify XOR/XNOR/AND/OR bit selection trees
-		Foo = A[1] ^ A[2] ^ A[3] etc are better as ^ ( A & 32'b...1110 )
-	* Combine variables into wider elements
-		Parallel statements on different bits should become single signal
-		Variables that are always consumed in "parallel" can be joined
-	* Duplicate assignments in gate optimization
-		Common to have many separate posedge blocks, each with identical
-		reset_r <= rst_in
-	* If signal is used only once (not counting trace), always gate substitute
-		Don't merge if any combining would form circ logic (out goes back to in)
-	* Multiple assignments each bit can become single assign with concat
-		Make sure a SEL of a CONCAT can get the single bit back.
-	* Usually blocks/values
-		Enable only after certain time, so VL_TIME_I(32) > 0x1e gets eliminated out
-	* Better ordering of a<=b, b<=c, put all refs to 'b' next to each other to optimize caching
-	* Allow Split of case statements without a $display/$stop
-	* I-cache packing improvements (what/how?)
-	* Data cache organization (order of vars in class)
-		First have clocks,
-		then bools instead of uint32_t's
-		then based on what sense list they come from, all outputs, then all inputs
-		finally have any signals part of a "usually" block, or constant.
-	* Rather then tracking widths, have a MSB...LSB of this expression
-		(or better, a bitmask of bits relevant in this expression)
-	* Track recirculation and convert into clock-enables
-	* Clock enables should become new clocking domains for speed
-	* If floped(a) & flopped(b) and no other a&b, then instead flop(a&b).
-	* Sort by output bitselects so can combine more assignments (see DDP example dx_dm signal)

bin/verilator_coverage

@@ -3,7 +3,7 @@ eval 'exec perl -wS $0 ${1+"$@"}'
   if 0;
 ######################################################################
 #
-# Copyright 2003-2015 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2019 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.
@@ -17,13 +17,6 @@ eval 'exec perl -wS $0 ${1+"$@"}'
 
 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 IO::File;
@@ -31,7 +24,7 @@ use Pod::Usage;
 use Cwd qw(abs_path getcwd);
 
 use strict;
-use vars qw ($Debug @Opt_Verilator_Sw);
+use vars qw($Debug @Opt_Verilator_Sw);
 
 #######################################################################
 #######################################################################
@@ -54,21 +47,21 @@ foreach my $sw (@ARGV) {
     push @Opt_Verilator_Sw, $sw;
 }
 
-Getopt::Long::config ("no_auto_abbrev","pass_through");
+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
+          # 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));
+run(verilator_coverage_bin()
+    ." ".join(' ',@Opt_Verilator_Sw));
 
 #----------------------------------------------------------------------
 
@@ -90,23 +83,25 @@ 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");
+                    || "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
-	}
+        my $dir = $ENV{VERILATOR_ROOT};
+        if (-x "$dir/bin/$basename"
+            || -x "$dir/bin/$basename.exe") {  # 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.
+        if (-x "$RealBin/$basename"
+            || -x "$RealBin/$basename.exe") {
+            $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;
 }
@@ -123,23 +118,23 @@ sub run {
     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";
+        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";
     }
 }
 
@@ -173,7 +168,7 @@ 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
+To get correct coverage percentages, you may wish to read logs/coverage.dat
 into Emacs and do a M-x keep-lines to include only those statistics of
 interest.
 
@@ -271,7 +266,7 @@ Specifies a module search directory.
 
 The latest version is available from L<http://www.veripool.org/>.
 
-Copyright 2003-2015 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2003-2019 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.

bin/verilator_difftree

@@ -10,7 +10,7 @@ use Getopt::Long;
 use IO::File;
 use Pod::Usage;
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);
 
 #======================================================================
 
@@ -37,12 +37,12 @@ my $Opt_B;
 my $Opt_Lineno = 1;
 autoflush STDOUT 1;
 autoflush STDERR 1;
-Getopt::Long::config ("no_auto_abbrev");
-if (! GetOptions (
-	  "help"	=> \&usage,
-	  "debug"	=> \&debug,
-	  "<>"		=> \&parameter,
-	  "lineno!"	=> \$Opt_Lineno,
+Getopt::Long::config("no_auto_abbrev");
+if (! GetOptions(
+          "help"        => \&usage,
+          "debug"       => \&debug,
+          "<>"          => \&parameter,
+          "lineno!"     => \$Opt_Lineno,
     )) {
     die "%Error: Bad usage, try 'verilator_difftree --help'\n";
 }
@@ -54,9 +54,9 @@ defined $Opt_B or die "%Error: No new diff filename\n";
 -e $Opt_B or die "%Error: No new diff filename found: $Opt_B\n";
 
 if (-d $Opt_A && -d $Opt_B) {
-    diff_dir ($Opt_A, $Opt_B);
+    diff_dir($Opt_A, $Opt_B);
 } elsif (-f $Opt_A && -f $Opt_B) {
-    diff_file ($Opt_A, $Opt_B);
+    diff_file($Opt_A, $Opt_B);
 } else {
     die "%Error: Mix of files and dirs\n";
 }
@@ -68,24 +68,25 @@ sub diff_dir {
     my %files;
 
     foreach my $fn (glob("$a/*.tree")) {
-	(my $base = $fn) =~ s!.*/!!;
-	$files{$base}{a} = $fn;
+        (my $base = $fn) =~ s!.*/!!;
+        $files{$base}{a} = $fn;
     }
     foreach my $fn (glob("$b/*.tree")) {
-	(my $base = $fn) =~ s!.*/!!;
-	$files{$base}{b} = $fn;
+        (my $base = $fn) =~ s!.*/!!;
+        $files{$base}{b} = $fn;
     }
     my $any;
     foreach my $base (sort (keys %files)) {
-	my $a = $files{$base}{a};
-	my $b = $files{$base}{b};
-	next if !$a || !$b;
-	print "="x70,"\n";
-	print "= $a <-> $b\n";
-	diff_file($a,$b);
-	$any = 1;
+        my $a = $files{$base}{a};
+        my $b = $files{$base}{b};
+        next if !$a || !$b;
+        print "="x70,"\n";
+        print "= $a <-> $b\n";
+        diff_file($a,$b);
+        $any = 1;
     }
-    $any or warn "%Warning: No .tree files found\n";
+    $any or warn("%Warning: No .tree files found that have similar base names:\n    "
+                 .join("\n    ", sort keys %files),"\n");
 }
 
 sub diff_file {
@@ -100,10 +101,10 @@ sub diff_file {
     my $vera = version_from($a);
     my $verb = version_from($b);
     my $verCvt = (($vera < 0x3900 && $verb >= 0x3900)
-		  || ($vera >= 0x3900 && $verb < 0x3900));
+                  || ($vera >= 0x3900 && $verb < 0x3900));
 
-    filter ($a, $tmp_a, $verCvt);
-    filter ($b, $tmp_b, $verCvt);
+    filter($a, $tmp_a, $verCvt);
+    filter($b, $tmp_b, $verCvt);
     system("diff -u $tmp_a $tmp_b");
     unlink $tmp_a;
     unlink $tmp_b;
@@ -114,8 +115,8 @@ sub version_from {
     # Return dump format
     my $f1 = IO::File->new ($fn) or die "%Error: $! $fn,";
     while (defined (my $line=$f1->getline())) {
-	last if $. > 10;
-	return hex $1 if $line =~ /\(format (0x[0-9.]+)\)/;
+        last if $. > 10;
+        return hex $1 if $line =~ /\(format (0x[0-9.]+)\)/;
     }
     return 1.0;
 }
@@ -129,36 +130,36 @@ sub filter {
     my $f2 = IO::File->new ($fn2,"w") or die "%Error: $! $fn2,";
     while (defined (my $line=$f1->getline())) {
       same_line:
-	next if $line =~ / This=/;
-	$line =~ s/0x[a-f0-9]+/0x/g;
-	$line =~ s/<e[0-9]+\#?>/<e>/g;
-	$line =~ s/{[a-z]*\d+}/{}/g if !$Opt_Lineno;
-	if ($verCvt) {
-	    next if $line =~ /^     NETLIST/;
-	    $line =~ s!\@dt=0x\(G?/?([^)]+)\)!$1!g;  # NEW: @dt -> OLD: non @dt format
-	    #					     # Below Ver1_Non_Dtyped may replace above further
-	    if ($line =~ /: ([A-Z]+) /) {
-		my $type = $1;
-		next if $type =~ 'DTYPE';
-		if ($type eq 'TYPETABLE' || $type eq 'RANGE') {
-		    $line =~ /^(\s+\S+:) /; my $prefix = $1;
-		    while (defined ($line=$f1->getline())) {
-			next if $line =~ /^\s+[a-z]/;  # Table body
-			next if $line =~ /^${prefix}[0-9]:/;
-			goto same_line;
-		    }
-		    next;
-		}
-		if ($Ver1_Non_Dtyped{$type}) {
-		    $line =~ s! w[0-9]+!!g;
-		}
-	    }
-	    $line =~ s!\@dt=0$!NoW!g;   # NEW: dt=null -> common format
-	    $line =~ s!\@dt=0 !NoW !g;  # NEW: dt=null -> common format
-	    $line =~ s! s?w0$! NoW!g;   # OLD: no width -> common format
-	    $line =~ s! s?w0 ! NoW !g;  # OLD: no width -> common format
-	}
-	print $f2 $line;
+        next if $line =~ / This=/;
+        $line =~ s/0x[a-f0-9]+/0x/g;
+        $line =~ s/<e[0-9]+\#?>/<e>/g;
+        $line =~ s/{[a-z]*\d+}/{}/g if !$Opt_Lineno;
+        if ($verCvt) {
+            next if $line =~ /^     NETLIST/;
+            $line =~ s!\@dt=0x\(G?/?([^)]+)\)!$1!g;  # NEW: @dt -> OLD: non @dt format
+            #                                        # Below Ver1_Non_Dtyped may replace above further
+            if ($line =~ /: ([A-Z]+) /) {
+                my $type = $1;
+                next if $type =~ 'DTYPE';
+                if ($type eq 'TYPETABLE' || $type eq 'RANGE') {
+                    $line =~ /^(\s+\S+:) /; my $prefix = $1;
+                    while (defined ($line=$f1->getline())) {
+                        next if $line =~ /^\s+[a-z]/;  # Table body
+                        next if $line =~ /^${prefix}[0-9]:/;
+                        goto same_line;
+                    }
+                    next;
+                }
+                if ($Ver1_Non_Dtyped{$type}) {
+                    $line =~ s! w[0-9]+!!g;
+                }
+            }
+            $line =~ s!\@dt=0$!NoW!g;   # NEW: dt=null -> common format
+            $line =~ s!\@dt=0 !NoW !g;  # NEW: dt=null -> common format
+            $line =~ s! s?w0$! NoW!g;   # OLD: no width -> common format
+            $line =~ s! s?w0 ! NoW !g;  # OLD: no width -> common format
+        }
+        print $f2 $line;
     }
     $f1->close;
     $f2->close;
@@ -168,7 +169,7 @@ sub filter {
 
 sub usage {
     pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
-    exit (1);
+    exit(1);
 }
 
 sub debug {
@@ -178,11 +179,11 @@ sub debug {
 sub parameter {
     my $param = shift;
     if (!defined $Opt_A) {
-	$Opt_A = $param;
+        $Opt_A = $param;
     } elsif (!defined $Opt_B) {
-	$Opt_B = $param;
+        $Opt_B = $param;
     } else {
-	die "%Error: Unknown parameter: $param\n";
+        die "%Error: Unknown parameter: $param\n";
     }
 }
 
@@ -235,7 +236,7 @@ Do not show differences in line numbering.
 
 The latest version is available from L<http://www.veripool.org/verilator>.
 
-Copyright 2005-2015 by Wilson Snyder.  This package is free software; you can
+Copyright 2005-2019 by Wilson Snyder.  This package 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.
 

bin/verilator_gantt

@@ -0,0 +1,560 @@
+: # -*-Mode: perl;-*- use perl, wherever it is
+eval 'exec perl -wS $0 ${1+"$@"}'
+  if 0;
+# See copyright, etc in below POD section.
+######################################################################
+
+use strict;
+use warnings;
+use Getopt::Long;
+use IO::File;
+use Pod::Usage;
+use vars qw($Debug);
+
+$Debug = 0;
+my $Opt_File;
+my $Opt_Time_Per_Char = 0;  # rdtsc ticks per char in gantt chart, 0=auto
+my $opt_vcd = "profile_threads.vcd";
+
+our %Threads;
+our %Mtasks;
+our %Global;
+
+autoflush STDOUT 1;
+autoflush STDERR 1;
+Getopt::Long::config("no_auto_abbrev");
+if (! GetOptions(
+          "help"        => \&usage,
+          "scale=i"     => \$Opt_Time_Per_Char,
+          "debug"       => sub { $Debug = 1; },
+          "vcd=s"       => \$opt_vcd,
+          "no-vcd!"     => sub { $opt_vcd = undef; },
+          "<>"          => \&parameter,
+    )) {
+    die "%Error: Bad usage, try 'verilator_gantt --help'\n";
+}
+
+$Opt_File = "profile_threads.dat" if !defined $Opt_File;
+
+process($Opt_File);
+write_vcd($opt_vcd) if defined $opt_vcd;
+exit(0);
+
+#######################################################################
+
+sub usage {
+    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
+    exit(1);
+}
+
+sub parameter {
+    my $param = shift;
+    if (!defined $Opt_File) {
+        $Opt_File = $param;
+    } else {
+        die "%Error: Unknown parameter: $param\n";
+    }
+}
+
+#######################################################################
+
+sub process {
+    my $filename = shift;
+
+    read_data($filename);
+    report();
+}
+
+#######################################################################
+
+sub read_data {
+    my $filename = shift;
+
+    %Global = (rdtsc_cycle_time => 0);
+
+    my $fh = IO::File->new ($filename) or die "%Error: $! $filename,";
+    while (my $line = $fh->getline) {
+        if ($line =~ m/VLPROF mtask\s(\d+)\sstart\s(\d+)\send\s(\d+)\selapsed\s(\d+)\spredict_time\s(\d+)\scpu\s(\d+)\son thread (\d+)/) {
+            my $mtask = $1;
+            my $start = $2;
+            my $end = $3;
+            my $elapsed_time = $4;
+            my $predict_time = $5;
+            my $cpu = $6;
+            my $thread = $7;
+            $Threads{$thread}{$start}{mtask} = $mtask;
+            $Threads{$thread}{$start}{end} = $end;
+            $Threads{$thread}{$start}{cpu} = $cpu;
+
+            if (!exists $Mtasks{$mtask}{elapsed}) {
+                $Mtasks{$mtask}{elapsed} = 0;
+            }
+            $Mtasks{$mtask}{elapsed} += $elapsed_time;
+            $Mtasks{$mtask}{predict} = $predict_time;
+            $Mtasks{$mtask}{end} = max($Mtasks{$mtask}{end}, $end);
+        }
+        elsif ($line =~ /^VLPROFTHREAD/) {}
+        elsif ($line =~ m/VLPROF arg\s+(\S+)\+([0-9.])\s*$/
+               || $line =~ m/VLPROF arg\s+(\S+)\s+([0-9.])\s*$/) {
+            $Global{args}{$1} = $2;
+        }
+        elsif ($line =~ m/VLPROF stat\s+(\S+)\s+([0-9.]+)/) {
+            $Global{stats}{$1} = $2;
+        }
+        elsif ($line =~ /^#/) {}
+        elsif ($Debug) {
+            chomp $line;
+            print "Unk: $line\n";
+        }
+        # TODO -- this is parsing text printed by a client.
+        # Really, verilator proper should generate this
+        # if it's useful...
+        if ($line =~ m/rdtsc time = (\d+) ticks/) {
+            $Global{rdtsc_cycle_time} = $1;
+        }
+    }
+}
+
+sub report {
+    print "Verilator Gantt report\n";
+
+    print "\nArgument settings:\n";
+    foreach my $arg (sort keys %{$Global{args}}) {
+        my $plus = ($arg =~ /^\+/) ? "+" : " ";
+        printf "  %s%s%d\n", $arg, $plus, $Global{args}{$arg};
+    }
+
+    my $nthreads = scalar keys %Threads;
+    $Global{cpus}{cpu_time} = {};
+    foreach my $thread (keys %Threads) {
+        # Make potentially multiple characters per column
+        foreach my $start (keys %{$Threads{$thread}}) {
+            my $cpu = $Threads{$thread}{$start}{cpu};
+            my $elapsed = $Threads{$thread}{$start}{end} - $start;
+            $Global{cpus}{cpu_time}{$cpu} += $elapsed;
+        }
+    }
+
+    my $mt_mtask_time = 0;
+    my $long_mtask_time = 0;
+    my $last_end = 0;
+    foreach my $mtask (keys %Mtasks) {
+        $mt_mtask_time += $Mtasks{$mtask}{elapsed};
+        $last_end = max($last_end, $Mtasks{$mtask}{end});
+        $long_mtask_time = max($long_mtask_time, $Mtasks{$mtask}{elapsed});
+    }
+    $Global{last_end} = $last_end;
+
+    report_graph();
+
+    # If we know cycle time in the same (rdtsc) units,
+    # this will give us an actual utilization number,
+    # (how effectively we keep the cores busy.)
+    #
+    # It also gives us a number we can compare against
+    # serial mode, to estimate the overhead of data sharing,
+    # which will show up in the total elapsed time. (Overhead
+    # of synchronization and scheduling should not.)
+    print "\nAnalysis:\n";
+    printf "  Total threads             = %d\n", $nthreads;
+    printf "  Total mtasks              = %d\n", scalar(keys %Mtasks);
+    printf "  Total cpus used           = %d\n", scalar(keys %{$Global{cpus}});
+    printf "  Total yields              = %d\n", $Global{stats}{yields};
+    printf "  Total eval time           = %d rdtsc ticks\n", $Global{last_end};
+    printf "  Longest mtask time        = %d rdtsc ticks\n", $long_mtask_time;
+    printf "  All-thread mtask time     = %d rdtsc ticks\n", $mt_mtask_time;
+    my $long_efficiency = $long_mtask_time/($Global{last_end});
+    printf "  Longest-thread efficiency = %0.1f%%\n", $long_efficiency*100;
+    my $mt_efficiency = $mt_mtask_time/($Global{last_end}*$nthreads);
+    printf "  All-thread efficiency     = %0.1f%%\n", $mt_efficiency*100;
+    printf "  All-thread speedup        = %0.1f\n", $mt_efficiency*$nthreads;
+    if ($Global{rdtsc_cycle_time} > 0) {
+        my $ut = $mt_mtask_time / $Global{rdtsc_cycle_time};
+        print "tot_mtask_cpu=$mt_mtask_time cyc=$Global{rdtsc_cycle_time} ut=$ut\n";
+    }
+
+    my @p2e_ratios;
+    my $min_p2e = 1000000;
+    my $min_mtask;
+    my $max_p2e = -1000000;
+    my $max_mtask;
+    foreach my $mtask (sort keys %Mtasks) {
+        if ($Mtasks{$mtask}{elapsed} > 0) {
+            if ($Mtasks{$mtask}{predict} == 0) {
+                $Mtasks{$mtask}{predict} = 1;  # don't log(0) below
+            }
+            my $p2e_ratio = log( $Mtasks{$mtask}{predict} / $Mtasks{$mtask}{elapsed} );
+            #print "log(p2e $mtask) = $p2e_ratio   (predict $Mtasks{$mtask}{predict}, elapsed $Mtasks{$mtask}{elapsed})\n";
+            push @p2e_ratios, $p2e_ratio;
+
+            if ($p2e_ratio > $max_p2e) {
+                $max_p2e = $p2e_ratio;
+                $max_mtask = $mtask;
+            }
+            if ($p2e_ratio < $min_p2e) {
+                $min_p2e = $p2e_ratio;
+                $min_mtask = $mtask;
+            }
+        }
+    }
+
+    print "\nStatistics:\n";
+    print "  min log(p2e) = $min_p2e  from mtask $min_mtask (predict $Mtasks{$min_mtask}{predict}, elapsed $Mtasks{$min_mtask}{elapsed})\n";
+    print "  max log(p2e) = $max_p2e  from mtask $max_mtask (predict $Mtasks{$max_mtask}{predict}, elapsed $Mtasks{$max_mtask}{elapsed})\n";
+
+    my $stddev = stddev(\@p2e_ratios);
+    my $mean = mean(\@p2e_ratios);
+    print "  mean = " . ($mean) . "\n";
+    print "  stddev = " . ($stddev) . "\n";
+    print "  e ^ stddev = " . exp($stddev). "\n";
+    print "\n";
+}
+
+sub report_graph {
+    my $time_per = $Opt_Time_Per_Char;
+    if ($time_per == 0) {
+        $time_per = ($Global{last_end} / 40);  # Start with 40 columns
+        while ($time_per > 10) {
+            my ($graph, $conflicts) = _make_graph($time_per);
+            last if !$conflicts;
+            $time_per = int($time_per/2);
+        }
+        # One more step so we can fit more labels
+        $time_per = int($time_per/2);
+    }
+
+    my ($graph, $conflicts) = _make_graph($time_per);
+
+    print "\nThread gantt graph:\n";
+    print "  Legend: One character width = $time_per rdtsc ticks\n";
+    print "  Legend: '&' = multiple mtasks in this period (character width)\n";
+
+    my $scale = "   <-".$Global{last_end}." rdtsc total";
+    for (my $col = length($scale);  # -2 for '->' below
+         $col < ($Global{last_end}/$time_per); ++$col) {
+        $scale .= "-";
+    }
+    print "  $scale->\n";
+
+    foreach my $thread (sort keys %{$graph}) {
+        print "  t: ";
+        _print_graph_line($graph->{$thread}, '');
+    }
+}
+
+sub _make_graph {
+    my $time_per = shift;
+
+    my $graph = {};  # {thread}{column}{char=>'x' or chars=>#}
+    my $conflicts = 0;
+    foreach my $thread (keys %Threads) {
+        # Make potentially multiple characters per column
+        foreach my $start (sort {$a <=> $b} keys %{$Threads{$thread}}) {
+            my $end = $Threads{$thread}{$start}{end};
+            my $mtask = $Threads{$thread}{$start}{mtask};
+            my $cpu = $Threads{$thread}{$start}{cpu};
+
+            my $startcol = _time_col($time_per, $start);
+            my $endcol = _time_col($time_per, $end);
+
+            my $label = "[";
+            $label .= "$cpu";  # Maybe make optional in future
+            my $width = $endcol - $startcol + 1;
+            while (length($label) < ($width-1)) {  # -1 for ']'
+                $label .= "-";
+            }
+            $label .= "]";
+            $graph->{$thread}[$startcol]{char} .= $label;
+        }
+        if ($Debug) {
+            print "# Multicol: "; _print_graph_line($graph->{$thread}, '|');
+        }
+        # Expand line to one char per column
+        for (my $col = 0; $col <= $#{$graph->{$thread}}; ++$col) {
+            if (my $chars = $graph->{$thread}[$col]{char}) {
+                my $ok = 1;
+                for (my $coladd = 1; $coladd<length($chars); ++$coladd) {
+                    if ($graph->{$thread}[$col + $coladd]{char}) {
+                        $ok = 0; last;
+                    }
+                }
+                if (!$ok) {
+                    if ($chars =~ /\[.*\[/) {  # Two begins or more
+                        $conflicts++;
+                        $graph->{$thread}[$col]{char} = "&";
+                    } else {
+                        $graph->{$thread}[$col]{char} = "[";
+                    }
+                    for (my $coladd = 1; $coladd<length($chars); ++$coladd) {
+                        if ($graph->{$thread}[$col + $coladd]{char}) {
+                            last;
+                        } else {
+                            $graph->{$thread}[$col + $coladd]{char} = 'x';
+                        }
+                    }
+                } else {
+                    my $coladd = 0;
+                    foreach my $char (split //, $chars) {
+                        $graph->{$thread}[$col+$coladd]{char} = $char;
+                        ++$coladd;
+                    }
+                }
+            }
+        }
+        if ($Debug) {
+            print "# Singlcol: "; _print_graph_line($graph->{$thread}, '|');
+        }
+    }
+    print "# Conflicts $conflicts\n" if $Debug;
+    return ($graph, $conflicts);
+}
+
+sub _print_graph_line {
+    my $graph_thread = shift;
+    my $sep = shift;
+    for (my $col = 0; $col <= $#{$graph_thread}; ++$col) {
+        my $c = $graph_thread->[$col]{char}; $c=' ' if !defined $c;
+        print $c, $sep;
+    }
+    print "\n";
+}
+
+sub _time_col {
+    my $time_per = shift;
+    my $time = shift;
+    return int($time/$time_per);
+}
+
+#######################################################################
+
+sub write_vcd {
+    my $filename = shift;
+    print "Writing $filename\n";
+    my $fh = IO::File->new(">$filename") or die "%Error: $! $filename,";
+    my $vcd = {values => {},  # {<time>}{<code>} = value
+               sigs => {},  # {<module>}{<sig}} = code
+               code => 0,
+    };
+
+    my %parallelism;
+    foreach my $thread (keys %Threads) {
+        my $mcode = ($vcd->{sigs}{threads}{"thread${thread}_mtask"} ||= $vcd->{code}++);
+        foreach my $start (sort {$a <=> $b} keys %{$Threads{$thread}}) {
+            my $end = $Threads{$thread}{$start}{end};
+            my $mtask = $Threads{$thread}{$start}{mtask};
+            my $cpu = $Threads{$thread}{$start}{cpu};
+            $vcd->{values}{$start}{$mcode} = $mtask;
+            $vcd->{values}{$end}{$mcode} = undef;
+            $parallelism{$start}++;
+            $parallelism{$end}--;
+
+            my $ccode = $vcd->{sigs}{cpus}{"cpu${cpu}_thread"} ||= $vcd->{code}++;
+            $vcd->{values}{$start}{$ccode} = $thread;
+            $vcd->{values}{$end}{$ccode} = undef;
+
+            my $mcode = $vcd->{sigs}{mtasks}{"mtask${mtask}_cpu"} ||= $vcd->{code}++;
+            $vcd->{values}{$start}{$mcode} = $cpu;
+            $vcd->{values}{$end}{$mcode} = undef;
+        }
+    }
+    {
+        my $pcode = ($vcd->{sigs}{Stats}{"parallelism"} ||= $vcd->{code}++);
+        my $value = 0;
+        foreach my $time (sort {$a<=>$b} keys %parallelism) {
+            $value += $parallelism{$time};
+            $vcd->{values}{$time}{$pcode} = $value;
+        }
+    }
+
+    $fh->print('$version Generated by verilator_gantt $end'."\n");
+    $fh->print('$timescale 1ns $end'."\n");
+    $fh->print("\n");
+
+    my %all_codes;
+    $fh->print(' $scope module gantt $end'."\n");
+    foreach my $module (sort keys %{$vcd->{sigs}}) {
+        $fh->printf('  $scope module %s $end'."\n", $module);
+        foreach my $sig (sort keys %{$vcd->{sigs}{$module}}) {
+            my $code = $vcd->{sigs}{$module}{$sig};
+            $fh->printf('   $var wire 32 v%x %s [31:0] $end'."\n",
+                        $code, $sig);
+            $all_codes{$code} = 1;
+        }
+        $fh->print('  $upscope $end'."\n");
+    }
+    $fh->print(' $upscope $end'."\n");
+    $fh->print('$enddefinitions $end'."\n");
+    $fh->print("\n");
+
+    my $first = 1;
+    foreach my $time (sort {$a <=> $b} keys %{$vcd->{values}}) {
+        if ($first) {
+            $first = 0;
+            # Start with Z for any signals without time zero data
+            foreach my $code (keys %all_codes) {
+                if (!defined $vcd->{values}{$time}{$code}) {
+                    $vcd->{values}{$time}{$code} = undef;
+                }
+            }
+        }
+        $fh->printf("#%d\n", $time);
+        foreach my $code (sort keys %{$vcd->{values}{$time}}) {
+            my $value = $vcd->{values}{$time}{$code};
+            if (defined $value) {
+                $fh->printf("b%b v%x\n", $value, $code);
+            } else {
+                $fh->printf("bz v%x\n", $code);
+            }
+        }
+    }
+}
+
+#######################################################################
+# Similar to Statistics::Basic functions, but avoid a package dependency
+
+sub max {
+    my $n = $_[0]; shift;
+    while (defined $_[0]) {
+        $n = $_[0] if !defined $n || $_[0] > $n;
+        shift;
+    }
+    return $n;
+}
+
+sub mean {
+    my $arrayref = shift;
+    my $n = 0;
+    my $sum = 0;
+    foreach my $v (@$arrayref) {
+        $sum += $v;
+        $n++;
+    }
+    return undef if !$n;
+    return $sum/$n;
+}
+
+sub stddev {
+    my $arrayref = shift;
+    my $n = 0;
+    my $sum = 0;
+    my $sumsq = 0;
+    foreach my $v (@$arrayref) {
+        $sum += $v;
+        $sumsq += $v**2;
+        $n++;
+    }
+    return undef if !$n;
+    return sqrt(($sumsq/$n) - ($sum/$n)**2);
+}
+
+#######################################################################
+__END__
+
+=pod
+
+=head1 NAME
+
+verilator_gantt - Create Gantt chart of multi-threaded execution
+
+=head1 SYNOPSIS
+
+Creates a visual representation to help analyze Verilator multithreaded
+simulation performance, by showing when each macro-task starts and ends,
+and showing when each thread is busy or idle.
+
+The generated Gantt chart has time on the X-axis. Times shown are to the
+scale printed, i.e. a certain about of time for each character width.  The
+Y-axis shows threads, each thread's execution is shown on one line.  That
+line shows "[" at the position in time when it executes.
+
+Following the "[" is the cpu number the task executed on, followed by zero
+or more "-" to make the width of the characters match the scaled execution
+time, followed by a "]".  If the scale is too small, the cpu number and
+mtask number will not be printed.  If the scale is very small, a "&"
+indicates multiple mtasks started at that time position.
+
+Also creates a value change dump (VCD) format dump file which may be viewed
+in a waveform viewer (e.g. C<GTKWave>).  See below.
+
+=head1 USAGE
+
+  Build with --prof-threads.
+
+  Run a sim with +verilator+prof+threads+window 2.
+
+  This will create profile_threads.dat.
+
+  Then run:
+
+  verilator_gantt profile_threads.dat
+
+  The report will be printed on standard output, this also generates
+  profile_threads.vcd
+
+  View profile_threads.vcd in a waveform viewer.
+
+=head1 VCD SIGNALS
+
+In waveforms there are the following signals. Most signals the "decimal"
+format will remove the leading zeros and make the traces easier to read.
+
+parallelism: The number of mtasks active at this time, for best performance
+this will match the thread count. You may want to use an "analog step"
+format to view this signal.
+
+cpu#_thread: For the given CPU number, the thread number executing.
+
+mtask#_cpu; For the given mtask id, the CPU it is executing on.
+
+thread#_mtask: For the given thread number, the mtask id executing.
+
+=head1 ARGUMENTS
+
+=over 4
+
+=item I<filename>
+
+The filename to read data from, defaults to "profile_threads.dat".
+
+=item --help
+
+Displays this message and program version and exits.
+
+=item --scale I<n>
+
+On the X-axis of the generated Gantt chart, each character represents this
+many time units. (On x86, time units are rdtsc ticks.)  Defaults to 0,
+which will automatically compute a reasonable scale where no two mtasks
+need to fit into same character width's worth of scaled time.
+
+=item --no-vcd
+
+=item --vcd I<filename>
+
+Set output filename for vcd dump, or disable. Default is
+verilator_gantt.vcd.
+
+=back
+
+=head1 DISTRIBUTION
+
+The latest version is available from L<http://www.veripool.org/>.
+
+Copyright 2018-2019 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.
+
+=head1 AUTHORS
+
+Wilson Snyder <[email protected]>
+
+=head1 SEE ALSO
+
+C<verilator>
+
+=cut
+
+######################################################################
+### Local Variables:
+### compile-command: "$V4/bin/verilator_gantt $V4/test_regress/obj_vltmt/t_gantt/vlt_sim.log"
+### End:

bin/verilator_includer

@@ -3,7 +3,7 @@ eval 'exec perl -wS $0 ${1+"$@"}'
   if 0;
 # DESCRIPTION: Print include statements for each ARGV
 #
-# Copyright 2003-2015 by Wilson Snyder. This package is free software; you can
+# Copyright 2003-2019 by Wilson Snyder. This package 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.
 ######################################################################
@@ -13,8 +13,8 @@ use warnings;
 print "// DESCR"."IPTION: Generated by verilator_includer via makefile\n";
 foreach my $param (@ARGV) {
     if ($param =~ /^-D([^=]+)=(.*)/) {
-	print "#define $1 $2\n"
+        print "#define $1 $2\n"
     } else {
-	print "#include \"$param\"\n"
+        print "#include \"$param\"\n"
     }
 }

bin/verilator_profcfunc

@@ -11,7 +11,7 @@ use IO::File;
 use Pod::Usage;
 eval { use Data::Dumper;  $Data::Dumper::Indent = 1; }; # Debug, ok if missing
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);
 
 #======================================================================
 
@@ -23,12 +23,12 @@ $Debug = 0;
 my $Opt_File;
 autoflush STDOUT 1;
 autoflush STDERR 1;
-Getopt::Long::config ("no_auto_abbrev");
-if (! GetOptions (
-		  "help"	=> \&usage,
-		  "debug"	=> \&debug,
-		  "<>"		=> \&parameter,
-		  )) {
+Getopt::Long::config("no_auto_abbrev");
+if (! GetOptions(
+          "help"        => \&usage,
+          "debug"       => \&debug,
+          "<>"          => \&parameter,
+    )) {
     die "%Error: Bad usage, try 'verilator_profcfunc --help'\n";
 }
 
@@ -40,7 +40,7 @@ profcfunc($Opt_File);
 
 sub usage {
     pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
-    exit (1);
+    exit(1);
 }
 
 sub debug {
@@ -50,9 +50,9 @@ sub debug {
 sub parameter {
     my $param = shift;
     if (!defined $Opt_File) {
-	$Opt_File = $param;
+        $Opt_File = $param;
     } else {
-	die "%Error: Unknown parameter: $param\n";
+        die "%Error: Unknown parameter: $param\n";
     }
 }
 
@@ -66,13 +66,21 @@ sub profcfunc {
     my %funcs;
 
     while (defined (my $line=$fh->getline())) {
-	#                  %time      cumesec   selfsec     calls     {stuff}   name
-	if ($line =~ /^\s*([0-9.]+)\s+[0-9.]+\s+([0-9.]+)\s+([0-9.]+)\s+[^a-zA-Z_]*([a-zA-Z_].*)$/) {
-	    my $pct=$1; my $sec=$2; my $calls=$3; my $func=$4;
-	    $funcs{$func}{pct} += $pct;
-	    $funcs{$func}{sec} += $sec;
-	    $funcs{$func}{calls} += $calls;
-	}
+        #                  %time      cumesec   selfsec     calls     {stuff}   name
+        if ($line =~ /^\s*([0-9.]+)\s+[0-9.]+\s+([0-9.]+)\s+([0-9.]+)\s+[^a-zA-Z_]*([a-zA-Z_].*)$/) {
+            my $pct=$1; my $sec=$2; my $calls=$3; my $func=$4;
+            $funcs{$func}{pct} += $pct;
+            $funcs{$func}{sec} += $sec;
+            $funcs{$func}{calls} += $calls;
+        }
+        # Older gprofs have no call column for single-call functions
+        #                  %time      cumesec   selfsec      {stuff}   name
+        elsif ($line =~ /^\s*([0-9.]+)\s+[0-9.]+\s+([0-9.]+)\s+[^a-zA-Z_]*([a-zA-Z_].*)$/) {
+            my $pct=$1; my $sec=$2; my $calls=1; my $func=$3;
+            $funcs{$func}{pct} += $pct;
+            $funcs{$func}{sec} += $sec;
+            $funcs{$func}{calls} += $calls;
+        }
     }
     $fh->close;
 
@@ -80,10 +88,10 @@ sub profcfunc {
     my %pointer_mods;
     my %verilated_mods;
     foreach my $func (keys %funcs) {
-	if ($func =~ /(.*)::_eval\(([a-zA-Z_0-9]+__Syms).*\)$/) {
-	    $verilated_mods{$1} = qr/^$1/;
-	    $pointer_mods{$2} = $1;
-	}
+        if ($func =~ /(.*)::_eval\(([a-zA-Z_0-9]+__Syms).*\)$/) {
+            $verilated_mods{$1} = qr/^$1/;
+            $pointer_mods{$2} = $1;
+        }
     }
     #print Dumper(\%pointer_mods, \%verilated_mods);
 
@@ -91,72 +99,72 @@ sub profcfunc {
     my %vfuncs;
     my %groups;
     foreach my $func (keys %funcs) {
-	my $pct = $funcs{$func}{pct};
-	my $vfunc = $func;
-	my $design;
+        my $pct = $funcs{$func}{pct};
+        my $vfunc = $func;
+        my $design;
 
-	if ($func =~ /\(([a-zA-Z_0-9]+__Syms)/) {
-	    $design = $pointer_mods{$1};
-	}
+        if ($func =~ /\(([a-zA-Z_0-9]+__Syms)/) {
+            $design = $pointer_mods{$1};
+        }
 
-	foreach my $vde (keys %verilated_mods) {
-	    last if $design;
-	    if ($func =~ /$verilated_mods{$vde}/) {
-		$design=$vde;
-		last;
-	    }
-	}
+        foreach my $vde (keys %verilated_mods) {
+            last if $design;
+            if ($func =~ /$verilated_mods{$vde}/) {
+                $design=$vde;
+                last;
+            }
+        }
 
-	if ($vfunc =~ /__PROF__([a-zA-Z_0-9]+)__l?([0-9]+)\(/) {
-	    $vfunc     = sprintf("VBlock    %s:%d", $1, $2);
-	    $groups{type}{"Verilog Blocks under $design"} += $pct;
-	    $groups{design}{$design} += $pct;
-	    $groups{module}{$1} += $pct;
-	} else {
-	    if ($design) {
-		$vfunc = sprintf("VCommon   %s", $func);
-		$groups{type}{"Common code under $design"} += $pct;
-		$groups{design}{$design} += $pct;
-		$groups{module}{$design." common code"} += $pct;
-	    } elsif ($func =~ /^VL_[A-Z0-9_]+/
-		     || $func =~ /^_?vl_[a-zA-Z0-9_]+/
-		     || $func =~ /^verilated/i) {
-		$vfunc = sprintf("VLib      %s", $func);
-		$groups{type}{'VLib'} += $pct;
-		$groups{design}{'VLib'} += $pct;
-		$groups{module}{'VLib'} += $pct;
-	    } elsif ($func =~ /^_mcount_private/) {
-		$vfunc = sprintf("Prof      %s", $func);
-		$groups{type}{'Prof'} += $pct;
-		$groups{design}{'Prof'} += $pct;
-		$groups{module}{'Prof'} += $pct;
-	    } else {
-		$vfunc = sprintf("C++       %s", $func);
-		$groups{type}{'C++'} += $pct;
-		$groups{design}{'C++'} += $pct;
-		$groups{module}{'C++'} += $pct;
-	    }
-	}
-	$vfuncs{$vfunc} = $funcs{$func};
+        if ($vfunc =~ /__PROF__([a-zA-Z_0-9]+)__l?([0-9]+)\(/) {
+            $vfunc     = sprintf("VBlock    %s:%d", $1, $2);
+            $groups{type}{"Verilog Blocks under $design"} += $pct;
+            $groups{design}{$design} += $pct;
+            $groups{module}{$1} += $pct;
+        } else {
+            if ($design) {
+                $vfunc = sprintf("VCommon   %s", $func);
+                $groups{type}{"Common code under $design"} += $pct;
+                $groups{design}{$design} += $pct;
+                $groups{module}{$design." common code"} += $pct;
+            } elsif ($func =~ /^VL_[A-Z0-9_]+/
+                     || $func =~ /^_?vl_[a-zA-Z0-9_]+/
+                     || $func =~ /^verilated/i) {
+                $vfunc = sprintf("VLib      %s", $func);
+                $groups{type}{'VLib'} += $pct;
+                $groups{design}{'VLib'} += $pct;
+                $groups{module}{'VLib'} += $pct;
+            } elsif ($func =~ /^_mcount_private/) {
+                $vfunc = sprintf("Prof      %s", $func);
+                $groups{type}{'Prof'} += $pct;
+                $groups{design}{'Prof'} += $pct;
+                $groups{module}{'Prof'} += $pct;
+            } else {
+                $vfunc = sprintf("C++       %s", $func);
+                $groups{type}{'C++'} += $pct;
+                $groups{design}{'C++'} += $pct;
+                $groups{module}{'C++'} += $pct;
+            }
+        }
+        $vfuncs{$vfunc} = $funcs{$func};
     }
 
 
     foreach my $type (qw(type design module)) {
-	my $missing = 100;
-	foreach (sort (keys %{$groups{$type}})) {
-	    $missing -= $groups{$type}{$_};
-	}
-	if ($missing) {
-	    $groups{$type}{"\377Unaccounted for/rounding error"} = $missing;
-	}
+        my $missing = 100;
+        foreach (sort (keys %{$groups{$type}})) {
+            $missing -= $groups{$type}{$_};
+        }
+        if ($missing) {
+            $groups{$type}{"\377Unaccounted for/rounding error"} = $missing;
+        }
 
-	print("Overall summary by $type:\n");
-	printf("  %-6s  %s\n","% time",$type);
-	foreach my $what (sort (keys %{$groups{$type}})) {
-	    (my $pwhat = $what) =~ s/^\377//;  # Just used to establish sort order
-	    printf("  %6.2f  %s\n", $groups{$type}{$what}, $pwhat);
-	}
-	print("\n");
+        print("Overall summary by $type:\n");
+        printf("  %-6s  %s\n","% time",$type);
+        foreach my $what (sort (keys %{$groups{$type}})) {
+            (my $pwhat = $what) =~ s/^\377//;  # Just used to establish sort order
+            printf("  %6.2f  %s\n", $groups{$type}{$what}, $pwhat);
+        }
+        print("\n");
     }
 
     print("Verilog code profile:\n");
@@ -173,14 +181,14 @@ sub profcfunc {
 
     my $cume = 0;
     foreach my $func (sort {$vfuncs{$b}{sec} <=> $vfuncs{$a}{sec}
-			    || $a cmp $b}
-		      (keys %vfuncs)) {
-	$cume += $vfuncs{$func}{sec};
-	printf +("%6.2f %9.2f %8.2f %8d   %s\n",
-		 $vfuncs{$func}{pct},
-		 $cume, $vfuncs{$func}{sec},
-		 $vfuncs{$func}{calls},
-		 $func);
+                            || $a cmp $b}
+                      (keys %vfuncs)) {
+        $cume += $vfuncs{$func}{sec};
+        printf +("%6.2f %9.2f %8.2f %8d   %s\n",
+                 $vfuncs{$func}{pct},
+                 $cume, $vfuncs{$func}{sec},
+                 $vfuncs{$func}{calls},
+                 $func);
     }
 }
 
@@ -191,11 +199,11 @@ __END__
 
 =head1 NAME
 
-verilator_profcfunc - Read gprof report created with --profile-cfuncs
+verilator_profcfunc - Read gprof report created with --prof-cfuncs
 
 =head1 SYNOPSIS
 
-  verilator --profile-cfuncs ....
+  verilator --prof-cfuncs ....
   gcc --ggdb -pg ....
   {run executable}
   gprof
@@ -204,8 +212,8 @@ verilator_profcfunc - Read gprof report created with --profile-cfuncs
 =head1 DESCRIPTION
 
 Verilator_profcfunc reads a profile report created by gprof.  The names of
-the functions are then transformed, assuming the user used verilator's
---profile-cfuncs, and a report printed showing the percentage of time, etc,
+the functions are then transformed, assuming the user used Verilator's
+--prof-cfuncs, and a report printed showing the percentage of time, etc,
 in each Verilog block.
 
 =head1 ARGUMENTS
@@ -222,7 +230,7 @@ Displays this message and program version and exits.
 
 The latest version is available from L<http://www.veripool.org/>.
 
-Copyright 2007-2015 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2007-2019 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.
 

configure.ac

@@ -1,19 +1,32 @@
 # DESCRIPTION: Process this file with autoconf to produce a configure script.
 #
-# Copyright 2003-2015 by Wilson Snyder. Verilator is free software; you can
+# Copyright 2003-2019 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.
 
 #AC_INIT([Verilator],[#.### YYYY-MM-DD])
 #AC_INIT([Verilator],[#.### devel])
-AC_INIT([Verilator],[3.874 2015-06-06])
+AC_INIT([Verilator],[4.018 2019-08-29],
+        [https://www.veripool.org/verilator],
+        [verilator],[https://www.veripool.org/verilator])
+# When releasing, also update header of Changes file
+# and commit using "devel release" or "Version bump" message
+
 AC_CONFIG_HEADER(src/config_build.h)
-AC_CONFIG_FILES(Makefile src/Makefile src/Makefile_obj include/verilated.mk include/verilated_config.h verilator.pc)
+AC_CONFIG_FILES(Makefile docs/Makefile src/Makefile src/Makefile_obj include/verilated.mk include/verilated_config.h verilator.pc)
 
 AC_MSG_RESULT([configuring for $PACKAGE_STRING])
 
+# Ignore automake flags passed by Ubuntu builds
+AC_ARG_ENABLE([dependency-tracking],
+              [AS_HELP_STRING([--disable-dependency-tracking], [ignored])])
+AC_ARG_ENABLE([maintainer-mode],
+              [AS_HELP_STRING([--enable-maintainer-mode], [ignored])])
+AC_ARG_ENABLE([silent-rules],
+              [AS_HELP_STRING([--disable-silent-rules], [ignored])])
+
 # Special Substitutions - CFG_WITH_DEFENV
-AC_MSG_CHECKING(whether to disable hardcoded paths)
+AC_MSG_CHECKING(whether to use hardcoded paths)
 AC_ARG_ENABLE([defenv],
               [AS_HELP_STRING([--disable-defenv],
                               [disable using some hardcoded data paths extracted from some default environment variables (the default is to use hardcoded paths)])],
@@ -40,7 +53,7 @@ AC_ARG_ENABLE([ccwarn],
                 x)   CFG_WITH_CCWARN=no ;;
                 *)   CFG_WITH_CCWARN=yes ;;
                esac]
-	      )
+              )
 AC_SUBST(CFG_WITH_CCWARN)
 AC_MSG_RESULT($CFG_WITH_CCWARN)
 
@@ -58,15 +71,30 @@ AC_ARG_ENABLE([longtests],
                 x)   CFG_WITH_LONGTESTS=no ;;
                 *)   CFG_WITH_LONGTESTS=yes ;;
                esac]
-	      )
+              )
 AC_SUBST(CFG_WITH_LONGTESTS)
 AC_MSG_RESULT($CFG_WITH_LONGTESTS)
 
+# CFG_WITH_PREC11
+AC_MSG_CHECKING(whether allow pre-C++11)
+AC_ARG_ENABLE([prec11],
+              [AS_HELP_STRING([--enable-prec11],
+                              [enable pre-C++11 compilers])],
+              [case "${enableval}" in
+                yes) CFG_WITH_PREC11=yes ;;
+                no)  CFG_WITH_PREC11=no ;;
+                *)   AC_MSG_ERROR([bad value ${enableval} for --enable-prec11]) ;;
+               esac],
+              [CFG_WITH_PREC11=no;]
+              )
+AC_SUBST(CFG_WITH_PREC11)
+AC_MSG_RESULT($CFG_WITH_PREC11)
+
 # Compiler flags
-CFLAGS=-I${includedir}
-CPPFLAGS=-I${includedir}
-CXXFLAGS=-I${includedir}
-LDFLAGS=-L${libdir}
+CFLAGS+=" -I${includedir}"
+CPPFLAGS+=" -I${includedir}"
+CXXFLAGS+=" -I${includedir}"
+LDFLAGS+=" -L${libdir}"
 
 # Checks for programs.
 AC_PROG_CC
@@ -74,12 +102,14 @@ AC_PROG_CXX
 AC_PROG_INSTALL
 
 AC_LANG_PUSH(C++)
+cxx_version=$($CXX --version | head -1)
+AC_MSG_RESULT([compiler is $CXX --version = $cxx_version])
 AC_MSG_CHECKING([that C++ compiler can compile simple program])
 AC_RUN_IFELSE(
-           [AC_LANG_SOURCE([int main() { return 0; }])],
-           AC_MSG_RESULT(yes),
-           AC_MSG_RESULT(no);AC_MSG_ERROR([a working C++ compiler is required]),
-	   AC_MSG_RESULT(yes))
+   [AC_LANG_SOURCE([int main() { return 0; }])],
+    AC_MSG_RESULT(yes),
+    AC_MSG_RESULT(no);AC_MSG_ERROR([a working C++ compiler is required]),
+    AC_MSG_RESULT(yes))
 
 AC_PATH_PROG(PERL,perl)
 if test "x$PERL" = "x" ; then
@@ -103,58 +133,205 @@ AC_TYPE_SIZE_T
 # Checks for compiler characteristics.
 AC_C_INLINE
 
-AC_DEFUN([_MY_CXX_CHECK_OPT],
-   [# _MY_CXX_CHECK_OPT(flag) -- Check if compiler supports specific options
+AC_LINK_IFELSE(
+     [AC_LANG_PROGRAM([#include <new>], [[int* a=new int; delete a; ]])],
+     [], [AC_MSG_ERROR([$CXX does not seem to successfully compile a simple C++ program])])
+
+AC_DEFUN([_MY_CXX_CHECK_FLAG],
+   [# _MY_CXX_CHECK_FLAG(flag) -- Check if compiler supports specific options
+    # Set $_my_result appropriately
     ACO_SAVE_CXXFLAGS="$CXXFLAGS"
     # -Werror needed otherwise unknown -Wno-div-by-zero won't report problems
-    CXXFLAGS="$CXXFLAGS $2 -Werror"
-    AC_MSG_CHECKING([whether $CXX accepts $2])
+    # new/delete is needed to find -faligned-new link problem on Darwin
+    CXXFLAGS="$CXXFLAGS $1 -Werror"
+    AC_MSG_CHECKING([whether $CXX accepts $1])
+    AC_LINK_IFELSE(
+         [AC_LANG_PROGRAM([#include <new>], [[int* a=new int; delete a; ]])],
+         [_my_result=yes
+          if test -s conftest.err; then
+            if grep -e "$1" conftest.err >/dev/null; then
+              _my_result=no
+            fi
+          fi],
+         [_my_result=no])
+    # GCC is annoying, trying to be helpful, it postpones unknown -Wno-
+    # options if there's no error We want to see them regardless, so try
+    # forcing an error and see if we get a gcc warning
     AC_COMPILE_IFELSE(
-         [AC_LANG_PROGRAM([],[])],
-	 [_my_result=yes
-	  if test -s conftest.err; then
-	    if grep -e "$2" conftest.err >/dev/null; then
-	      _my_result=no
-	    fi
-	  fi],
-	 [_my_result=no])
+         [AC_LANG_PROGRAM([[an_error "intentional-error-for-test.h"
+                          ]],[])],
+         [], # Ignore ok exit
+         [if test -s conftest.err; then
+            if grep -e "$1" conftest.err >/dev/null; then
+              _my_result=no
+            fi
+          fi])
     AC_MSG_RESULT($_my_result)
+    CXXFLAGS="$ACO_SAVE_CXXFLAGS"
+   ])
+
+AC_DEFUN([_MY_CXX_CHECK_SET],
+   [# _MY_CXX_CHECK_SET(variable,flag) -- Check if compiler supports specific options
+    # If it does, set variable to flag, only if not previously set
+    if test "$$1" = ""; then
+       _MY_CXX_CHECK_FLAG($2)
+       if test "$_my_result" = "yes" ; then
+          $1="$2"
+       fi
+    fi
+   ])
+
+AC_DEFUN([_MY_CXX_CHECK_OPT],
+   [# _MY_CXX_CHECK_OPT(flag) -- Check if compiler supports specific options
+    # If it does, append flag to variable
+    _MY_CXX_CHECK_FLAG($2)
     if test "$_my_result" = "yes" ; then
        $1="$$1 $2"
     fi
-    CXXFLAGS="$ACO_SAVE_CXXFLAGS"
-   ])# _MY_CXX_CHECK_OPT
+   ])
 
-# Flags for compiling Verilator internals including parser
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-unused-parameter)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-char-subscripts)
+AC_DEFUN([_MY_LDLIBS_CHECK_FLAG],
+   [# _MY_LDLIBS_CHECK_FLAG(flag) -- Check if linker supports specific options
+    # Set $_my_result appropriately
+    ACO_SAVE_LIBS="$LIBS"
+    LIBS="$LIBS $1"
+    AC_MSG_CHECKING([whether $CXX linker accepts $1])
+    AC_LINK_IFELSE(
+         [AC_LANG_PROGRAM([[]])],
+         [_my_result=yes
+          if test -s conftest.err; then
+            if grep -e "$1" conftest.err >/dev/null; then
+              _my_result=no
+            fi
+          fi],
+         [_my_result=no])
+    AC_MSG_RESULT($_my_result)
+    LIBS="$ACO_SAVE_LIBS"
+   ])
+
+AC_DEFUN([_MY_LDLIBS_CHECK_OPT],
+   [# _MY_LDLIBS_CHECK_OPT(flag) -- Check if linker supports specific options
+    # If it does, append flag to variable
+    _MY_LDLIBS_CHECK_FLAG($2)
+    if test "$_my_result" = "yes" ; then
+       $1="$$1 $2"
+    fi
+   ])
+
+# Flag to select newest language standard supported
+# Macros work such that first option that passes is the one we take
+# gnu++17 code is clean, but SystemC in 2018 doesn't link with it (bug1339)
+# gnu++14 is the newest that Verilator supports
+# std++03 is the oldest that Verilator supports
+#_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++17)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++14)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++11)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++03)
+#_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++17)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++14)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++11)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++03)
+AC_SUBST(CFG_CXXFLAGS_STD_NEWEST)
+# And likewise oldest standard (same list above, backwards)
+# This is used for internal testing
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=c++03)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=c++11)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=c++14)
+#_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++17)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++03)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++11)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++14)
+#_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++17)
+AC_SUBST(CFG_CXXFLAGS_STD_OLDEST)
+
+# Flags for compiling Verilator internals including parser, and Verilated files
+# These turn on extra warnings and are only used with 'configure --enable-ccwarn'
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_WEXTRA,-Wextra)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_WEXTRA,-Wfloat-conversion)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_WEXTRA,-Wlogical-op)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_WEXTRA,-Wthread-safety)
+AC_SUBST(CFG_CXXFLAGS_WEXTRA)
+
+# Flags for compiling Verilator internals including parser always
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Qunused-arguments)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-faligned-new)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-unused-parameter)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-undefined-bool-conversion)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-shadow)
 AC_SUBST(CFG_CXXFLAGS_SRC)
 
-# Flags for compiling Verilator parser
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-unused)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-parentheses-equality)
+# Flags for compiling Verilator parser always (in addition to above CFG_CXXFLAGS_SRC)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-char-subscripts)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-null-conversion)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-parentheses-equality)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-unused)
 AC_SUBST(CFG_CXXFLAGS_PARSER)
 
 # Flags for Verilated makefile
 # For example, -Wno-div-by-zero isn't in 4.1.2
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-char-subscripts)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-parentheses-equality)
 # Random code often does / 0.  Unfortunately VL_DIV_I(0,0) will warn
 # without this flag, even though there's a conditional to prevent the divide.
 # We still don't add no-div-by-zero as it throws message to stdout, though doesn't die.
 #_MY_CXX_CHECK_OPT(-Wno-div-by-zero)
+# For some reason -faligned-new does not work under Travis w/ clang but the
+# configure test doesn't catch this either
+AS_IF([test "x$TRAVIS_COMPILER" != xclang], [_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-faligned-new)])
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-fbracket-depth=4096)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Qunused-arguments)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-bool-operation)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-parentheses-equality)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-sign-compare)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-uninitialized)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-but-set-variable)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-parameter)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-variable)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-fbracket-depth=4096)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Qunused-arguments)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-shadow)
 AC_SUBST(CFG_CXXFLAGS_NO_UNUSED)
 
+# Find multithread linker flags
+_MY_LDLIBS_CHECK_OPT(CFG_LDLIBS_THREADS,-mt)
+_MY_LDLIBS_CHECK_OPT(CFG_LDLIBS_THREADS,-pthread)
+_MY_LDLIBS_CHECK_OPT(CFG_LDLIBS_THREADS,-lpthread)
+_MY_LDLIBS_CHECK_OPT(CFG_LDLIBS_THREADS,-latomic)
+AC_SUBST(CFG_LDLIBS_THREADS)
+
+# Set CFG_WITH_THREADED if can support threading
+AC_MSG_CHECKING(whether $CXX supports Verilated threads)
+ACO_SAVE_CXXFLAGS="$CXXFLAGS"
+CXXFLAGS="$CXXFLAGS $CFG_CXXFLAGS_STD_NEWEST $CFG_CXXFLAGS_NO_UNUSED"
+AC_LINK_IFELSE(
+     [AC_LANG_PROGRAM([#include <thread>], [[ ]])],
+     [_my_result=yes
+      if test -s conftest.err; then
+        if grep -e "$1" conftest.err >/dev/null; then
+          _my_result=no
+        fi
+      fi],
+     [_my_result=no])
+CFG_WITH_THREADED=$_my_result
+AC_SUBST(CFG_WITH_THREADED)
+AC_MSG_RESULT($CFG_WITH_THREADED)
+
+# Check compiler flag
+if test "$CFG_WITH_THREADED" = "no" ; then
+   if test "$CFG_WITH_PREC11" = "no" ; then
+      AC_MSG_NOTICE([[]])
+      AC_MSG_ERROR([[the $CXX compiler appears to not support C++11.
+
+Verilator plans to require a C++11 or newer compiler in a future release,
+unless sufficient people report problems. Therefore, if you do not have a
+C++11 compiler, please post a message to
+https://www.veripool.org/boards/3/topics/2580-Verilator-Requiring-C-11-compiler
+indicating your OS and when you think C++11 might be ok, and then rerun
+configure with the --enable-prec11 argument. Thanks.]])
+
+   fi
+fi
+
 # Checks for library functions.
+AC_CHECK_MEMBER([struct stat.st_mtim.tv_nsec],
+    [AC_DEFINE([HAVE_STAT_NSEC],[1],[Defined if struct stat has st_mtim.tv_nsec])],
+    [], [#include <sys/stat.h>])
 
 # Checks for system services
 

docs/.gitignore

@@ -0,0 +1 @@
+Makefile

docs/CONTRIBUTORS

@@ -0,0 +1,17 @@
+The contributors listed below have certified their Verilator contributions
+under the Developer Certificate of Origin
+(https://developercertificate.org/).
+
+Please see the Verilator manual for additional contributors.
+
+Alex Chadwick
+Gianfranco Costamagna
+Jeremy Bennett
+John Coiner
+Kanad Kanhere
+Maarten De Braekeleer
+Philipp Wagner
+Richard Myers
+Sebastien Van Cauwenberghe
+Stefan Wallentowitz
+Wilson Snyder

docs/Makefile.in

@@ -0,0 +1,50 @@
+#*****************************************************************************
+# DESCRIPTION: Verilator documentation: Makefile pre-configure version
+#
+# This file is part of Verilator.
+#
+# Code available from: http://www.veripool.org/verilator
+#
+#*****************************************************************************
+#
+# Copyright 2003-2019 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.
+#
+#****************************************************************************/
+#
+# This file is intended only to be called from the top-level Verilator Makefile.
+
+#### Start of system configuration section. ####
+
+DOXYGEN = doxygen
+
+#### End of system configuration section. ####
+######################################################################
+
+.SUFFIXES:
+
+default:
+	@echo "error: make not supported here, run 'make docs' from Verilator top-level"
+
+clean mostlyclean distclean maintainer-clean::
+	rm -f $(SCRIPTS) *.tmp
+	rm -f *.aux *.cp *.cps *.dvi *.fn *.fns *.ky *.kys *.log
+	rm -f *.pg *.pgs *.toc *.tp *.tps *.vr *.vrs *.idx
+	rm -f *.ev *.evs *.ov *.ovs *.cv *.cvs *.ma *.mas
+	rm -f *.tex
+
+distclean maintainer-clean::
+	rm -f *.info* *.1 $(INFOS)
+	rm -f Makefile
+
+.PHONY: doxygen
+
+doxygen:
+	$(DOXYGEN) doxygen.config

docs/TODO

@@ -0,0 +1,119 @@
+// DESCRIPTION: Verilator: List of To Do issues.
+//
+// Copyright 2004-2019 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.
+
+* Language support:
+** Fix ordering of each bit separately in a signal (mips)
+   assign b[3:0] = b[7:4];  assign b[7:4] = in;
+** Support UDP gate primitives/ cell libraries
+   (have code for combos - problem is sequential udps)
+** Function to eval combo logic after /*verilator public*/ functions [gwaters]
+** Support generated clocks (correctness)
+** Recursive functions
+** Verilog configuration files
+** Expression coverage (see notes)
+** Better tristate support
+** UVM
+
+* Long-term Features
+** Assertions
+** Tristate support
+
+* Configure/Make/Install
+** Distribute with flex/bison already expanded?
+   Flex library not needed.  Probably too difficult to be worth it.
+
+* Testing:
+** Capture all inputs into global "rerun it" file
+** Code to make wrapper that sets signals, so can do comparison checks
+** New random program generator
+** Better graph viewer with search and zoom
+** Port and test against opencores.org code
+** // verilator debug in code so can see only tree affecting those nodes
+
+* Usability:
+** Detect and pre-remove most UNOPTFLATs
+** Better reporting of unopt problems, including what lines of code
+** Report more errors (all of them?) before exiting [Eugene Weber]
+** Auto-create scons config files
+** Print version/etc message at runtime. (4.000?)
+   Include number of lines of code, percent comments, code complexity measurement
+   <-80chars------------------------------------------------------------------->
+   Verilator 3.600 - The fast free open-sourced simulator.  Copyright 2001-2013.
+   Verilated #### modules, #### instances, ##### sigs,
+         #### non-comment lines, ##### ops, ### KB model size
+
+* Lint:
+** CDCRSTLOGIC should allow filtering with paths
+   "waive CDCRSTLOGIC --from a.b.sig  --to a.c.sig --via OR"
+
+* Internal Code:
+** A Visitor class that understands how to traverse data types
+** V3Graph should be templated container type, taking in Vertex + Edge types
+** Instead of string, have an VEncodedString/VIdString which contains __DOT__ish
+   things, to reduce bugs.  Also add _20 trailing space to \ encoded names.
+
+* Runtime:
+** New evalulation loop   ~/src/verilator/notes/event_loop.txt (4.000?)
+** Remove all private internal functions from top level wrapper header, move
+   to new level
+** Completely standalone simulation
+    main() records arguments for $test$plusvars
+    instantiates top,
+    does tracing  (support $dump?)
+    calls top->simulateForever()
+    exits
+
+* Performance:
+** Latch optimizations
+** Constant propagation
+   Extra cleaning AND:  1 & ((VARREF >> 1) | ((&VARREF >> 1) & VARREF))
+   Extra shift (perhaps due to clean): if (1 & CAST (VARREF >> #))
+** Gated clock and latch conversion to flops.  [JeanPaul Vanitegem]
+   Could propagate the AND into pos/negedges and let domaining optimize.
+** Negedge reset
+   Switch to remove negedges that don't matter
+   Can't remove async resets from control flops (like in syncronizers)
+** If all references to array have a constant index, blow up into separate signals-per-index
+** Bit-multiply for faster bit swapping and a=b[1,3,2] random bit reorderings.
+** Move _last sets and all other combo logic inside master
+   if() that triggers on all possible sense items
+** Rewrite and combine V3Life, V3Subst
+   If block temp only ever set in one place to constant, propagate it
+     Used in t_mem for array delayed assignments
+   Replace variables if set later in same cfunc branch
+     See for example duplicate sets of _narrow in cycle 90/91 of t_select_plusloop
+** Same assignment on both if branches
+   "if (a) { ... b=2; } else { ... b=2;}" -> "b=2; if ..."
+   Careful though, as b could appear in the statement or multiple times in statement
+   (Could just require exatly two 'b's in statement)
+** Simplify XOR/XNOR/AND/OR bit selection trees
+   Foo = A[1] ^ A[2] ^ A[3] etc are better as ^ ( A & 32'b...1110 )
+** Combine variables into wider elements
+   Parallel statements on different bits should become single signal
+   Variables that are always consumed in "parallel" can be joined
+** Duplicate assignments in gate optimization
+   Common to have many separate posedge blocks, each with identical
+   reset_r <= rst_in
+** If signal is used only once (not counting trace), always gate substitute
+   Don't merge if any combining would form circ logic (out goes back to in)
+** Multiple assignments each bit can become single assign with concat
+   Make sure a SEL of a CONCAT can get the single bit back.
+** Usually blocks/values
+   Enable only after certain time, so VL_TIME_I(32) > 0x1e gets eliminated out
+** Better ordering of a<=b, b<=c, put all refs to 'b' next to each other to optimize caching
+** I-cache packing improvements (what/how?)
+** Data cache organization (order of vars in class)
+   First have clocks,
+   then bools instead of uint32_t's
+   then based on what sense list they come from, all outputs, then all inputs
+   finally have any signals part of a "usually" block, or constant.
+** Rather then tracking widths, have a MSB...LSB of this expression
+   (or better, a bitmask of bits relevant in this expression)
+** Track recirculation and convert into clock-enables
+** Clock enables should become new clocking domains for speed
+** If floped(a) & flopped(b) and no other a&b, then instead flop(a&b).
+** Sort by output bitselects so can combine more assignments (see DDP example dx_dm signal)

docs/doxygen.config

@@ -45,7 +45,7 @@ PROJECT_BRIEF          = "Verilog to C translator"
 # exceed 55 pixels and the maximum width should not exceed 200 pixels.
 # Doxygen will copy the logo to the output directory.
 
-PROJECT_LOGO           = veripool-logo.png
+PROJECT_LOGO           = verilator_logo.png
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
 # base path where the generated documentation will be put.
@@ -630,13 +630,8 @@ WARN_LOGFILE           =
 # with spaces.
 
 INPUT                  = doxygen-mainpage \
-		         include \
+                         include \
                          src \
-                         test_c \
-                         test_regress \
-                         test_sc \
-                         test_v \
-                         test_verilated
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is

examples/hello_world_c/.gitignore

@@ -3,4 +3,4 @@
 *.csrc
 *.vcd
 obj_*
-project
+logs

examples/hello_world_c/Makefile

@@ -0,0 +1,52 @@
+######################################################################
+#
+# DESCRIPTION: Verilator Example: Small Makefile
+#
+# This calls the object directory makefile.  That allows the objects to
+# be placed in the "current directory" which simplifies the Makefile.
+#
+# Copyright 2003-2019 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.
+#
+######################################################################
+# Check for sanity to avoid later confusion
+
+ifneq ($(words $(CURDIR)),1)
+ $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+endif
+
+######################################################################
+
+# This is intended to be a minimal example.  Before copying this to start a
+# real project, it is better to start with a more complete example,
+# e.g. examples/tracing_c.
+
+# If $VERILATOR_ROOT isn't in the environment, we assume it is part of a
+# package install, and verilator is in your path. Otherwise find the
+# binary relative to $VERILATOR_ROOT (such as when inside the git sources).
+ifeq ($(VERILATOR_ROOT),)
+VERILATOR = verilator
+else
+export VERILATOR_ROOT
+VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+endif
+
+default:
+	@echo "-- Verilator hello-world simple example"
+	@echo "-- VERILATE ----------------"
+	$(VERILATOR) -cc --exe top.v sim_main.cpp
+	@echo "-- COMPILE -----------------"
+	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
+	@echo "-- RUN ---------------------"
+	obj_dir/Vtop
+	@echo "-- DONE --------------------"
+	@echo "Note: Once this example is understood, see examples/tracing_c."
+	@echo "Note: Also see the EXAMPLE section in the verilator manpage/document."
+
+######################################################################
+
+maintainer-copy::
+clean mostlyclean distclean maintainer-clean::
+	-rm -rf obj_dir *.log *.dmp *.vpd core

examples/hello_world_c/sim_main.cpp

@@ -0,0 +1,41 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+//======================================================================
+
+// Include common routines
+#include <verilated.h>
+
+// Include model header, generated from Verilating "top.v"
+#include "Vtop.h"
+
+int main(int argc, char** argv, char** env) {
+    // See a similar example walkthrough in the verilator manpage.
+
+    // This is intended to be a minimal example.  Before copying this to start a
+    // real project, it is better to start with a more complete example,
+    // e.g. examples/c_tracing.
+
+    // Prevent unused variable warnings
+    if (0 && argc && argv && env) {}
+
+    // Construct the Verilated model, from Vtop.h generated from Verilating "top.v"
+    Vtop* top = new Vtop;
+
+    // Simulate until $finish
+    while (!Verilated::gotFinish()) {
+
+        // Evaluate model
+        top->eval();
+    }
+
+    // Final model cleanup
+    top->final();
+
+    // Destroy model
+    delete top;
+
+    // Fin
+    exit(0);
+}

examples/hello_world_c/top.v

@@ -0,0 +1,12 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+
+// See also the EXAMPLE section in the verilator manpage/document.
+module top;
+   initial begin
+      $display("Hello World!");
+      $finish;
+   end
+endmodule

examples/hello_world_sc/.gitignore

@@ -1,8 +1,6 @@
-*.old
 *.dmp
 *.log
 *.csrc
 *.vcd
 obj_*
 logs
-project

examples/hello_world_sc/Makefile

@@ -0,0 +1,67 @@
+######################################################################
+#
+# DESCRIPTION: Verilator Example: Small Makefile
+#
+# This calls the object directory makefile.  That allows the objects to
+# be placed in the "current directory" which simplifies the Makefile.
+#
+# Copyright 2003-2019 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.
+#
+######################################################################
+# Check for sanity to avoid later confusion
+
+ifneq ($(words $(CURDIR)),1)
+ $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+endif
+
+######################################################################
+
+# This is intended to be a minimal example.  Before copying this to start a
+# real project, it is better to start with a more complete example,
+# e.g. examples/tracing_sc.
+
+# If $VERILATOR_ROOT isn't in the environment, we assume it is part of a
+# package install, and verilator is in your path. Otherwise find the
+# binary relative to $VERILATOR_ROOT (such as when inside the git sources).
+ifeq ($(VERILATOR_ROOT),)
+VERILATOR = verilator
+else
+export VERILATOR_ROOT
+VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+endif
+
+# Check if SC exists via a verilator call (empty if not)
+SYSTEMC_EXISTS := $(shell $(VERILATOR) --getenv SYSTEMC_INCLUDE)
+
+ifneq ($(SYSTEMC_EXISTS),)
+default: run
+else
+default: nosc
+endif
+
+run:
+	@echo "-- Verilator hello-world simple example"
+	@echo "-- VERILATE ----------------"
+	$(VERILATOR) -sc --exe top.v sc_main.cpp
+	@echo "-- COMPILE -----------------"
+	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
+	@echo "-- RUN ---------------------"
+	obj_dir/Vtop
+	@echo "-- DONE --------------------"
+	@echo "Note: Once this example is understood, see examples/tracing_sc."
+	@echo "Note: Also see the EXAMPLE section in the verilator manpage/document."
+
+######################################################################
+
+nosc:
+	@echo
+	@echo "%Skip: SYSTEMC_INCLUDE not in environment"
+	@echo "(If you have SystemC see the README, and rebuild Verilator)"
+	@echo
+
+maintainer-copy::
+clean mostlyclean distclean maintainer-clean::
+	-rm -rf obj_dir *.log *.dmp *.vpd core

examples/hello_world_sc/sc_main.cpp

@@ -0,0 +1,51 @@
+// -*- SystemC -*-
+// DESCRIPTION: Verilator Example: Top level main for invoking SystemC model
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+//======================================================================
+
+// SystemC global header
+#include <systemc.h>
+
+// Include common routines
+#include <verilated.h>
+
+// Include model header, generated from Verilating "top.v"
+#include "Vtop.h"
+
+int sc_main(int argc, char* argv[]) {
+    // See a similar example walkthrough in the verilator manpage.
+
+    // This is intended to be a minimal example.  Before copying this to start a
+    // real project, it is better to start with a more complete example,
+    // e.g. examples/c_tracing.
+
+    // Prevent unused variable warnings
+    if (0 && argc && argv) {}
+
+    // Construct the Verilated model, from Vtop.h generated from Verilating "top.v"
+    Vtop* top = new Vtop("top");
+
+    // Initialize SC model
+#if (SYSTEMC_VERSION>=20070314)
+    sc_start(1,SC_NS);
+#else
+    sc_start(1);
+#endif
+
+    // Simulate until $finish
+    while (!Verilated::gotFinish()) {
+#if (SYSTEMC_VERSION>=20070314)
+        sc_start(1,SC_NS);
+#else
+        sc_start(1);
+#endif
+    }
+
+    // Final model cleanup
+    top->final();
+
+    // Fin
+    return 0;
+}

examples/hello_world_sc/top.v

@@ -0,0 +1,12 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+
+// See also the EXAMPLE section in the verilator manpage/document.
+module top;
+   initial begin
+      $display("Hello World!");
+      $finish;
+   end
+endmodule

examples/tracing_c/.gitignore

@@ -0,0 +1,6 @@
+*.dmp
+*.log
+*.csrc
+*.vcd
+obj_*
+logs

examples/tracing_c/Makefile

@@ -0,0 +1,96 @@
+######################################################################
+#
+# DESCRIPTION: Verilator Example: Small Makefile
+#
+# This calls the object directory makefile.  That allows the objects to
+# be placed in the "current directory" which simplifies the Makefile.
+#
+# Copyright 2003-2019 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.
+#
+######################################################################
+# Check for sanity to avoid later confusion
+
+ifneq ($(words $(CURDIR)),1)
+ $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+endif
+
+######################################################################
+# Set up variables
+
+# If $VERILATOR_ROOT isn't in the environment, we assume it is part of a
+# package install, and verilator is in your path. Otherwise find the
+# binary relative to $VERILATOR_ROOT (such as when inside the git sources).
+ifeq ($(VERILATOR_ROOT),)
+VERILATOR = verilator
+VERILATOR_COVERAGE = verilator_coverage
+else
+export VERILATOR_ROOT
+VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
+endif
+
+VERILATOR_FLAGS =
+# Generate C++ in executable form
+VERILATOR_FLAGS += -cc --exe
+# Generate makefile dependencies (not shown as complicates the Makefile)
+#VERILATOR_FLAGS += -MMD
+# Optimize
+VERILATOR_FLAGS += -O2 -x-assign 0
+# Warn abount lint issues; may not want this on less solid designs
+VERILATOR_FLAGS += -Wall
+# Make waveforms
+VERILATOR_FLAGS += --trace
+# Check SystemVerilog assertions
+VERILATOR_FLAGS += --assert
+# Generate coverage analysis
+VERILATOR_FLAGS += --coverage
+# Run Verilator in debug mode
+#VERILATOR_FLAGS += --debug
+# Add this trace to get a backtrace in gdb
+#VERILATOR_FLAGS += --gdbbt
+
+######################################################################
+default: run
+
+run:
+	@echo
+	@echo "-- Verilator tracing example"
+
+	@echo
+	@echo "-- VERILATE ----------------"
+	$(VERILATOR) $(VERILATOR_FLAGS) -f input.vc top.v sim_main.cpp
+
+	@echo
+	@echo "-- COMPILE -----------------"
+# To compile, we can either just do what Verilator asks,
+# or call a submakefile where we can override the rules ourselves
+#	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
+	$(MAKE) -j 4 -C obj_dir -f ../Makefile_obj
+
+	@echo
+	@echo "-- RUN ---------------------"
+	@mkdir -p logs
+	obj_dir/Vtop +trace
+
+	@echo
+	@echo "-- COVERAGE ----------------"
+	$(VERILATOR_COVERAGE) --annotate logs/annotated logs/coverage.dat
+
+	@echo
+	@echo "-- DONE --------------------"
+	@echo "To see waveforms, open vlt_dump.vcd in a waveform viewer"
+	@echo
+
+
+######################################################################
+# Other targets
+
+show-config:
+	$(VERILATOR) -V
+
+maintainer-copy::
+clean mostlyclean distclean maintainer-clean::
+	-rm -rf obj_dir logs *.log *.dmp *.vpd coverage.dat core

examples/tracing_c/Makefile_obj

@@ -0,0 +1,58 @@
+# -*- Makefile -*-
+#######################################################################
+#
+# DESCRIPTION: Verilator Example: Makefile for inside object directory
+#
+# This is executed in the object directory, and called by ../Makefile
+#
+# Copyright 2003-2019 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.
+#
+#######################################################################
+
+default: Vtop
+
+# Include the rules made by Verilator
+include Vtop.mk
+
+# Use OBJCACHE (ccache) if using gmake and its installed
+COMPILE.cc = $(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c
+
+#######################################################################
+# Compile flags
+
+# Override some default compile flags
+CPPFLAGS += -MMD -MP
+CPPFLAGS += -DVL_DEBUG=1
+# Turn on some more flags (when configured appropriately)
+# For testing inside Verilator, "configure --enable-ccwarn" will do this
+# automatically; otherwise you may want this unconditionally enabled
+ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
+USER_CPPFLAGS_WALL += -W -Werror -Wall
+endif
+
+# See the benchmarking section of bin/verilator.
+# Support class optimizations.  This includes the tracing and symbol table.
+# SystemC takes minutes to optimize, thus it is off by default.
+OPT_SLOW =
+# Fast path optimizations.  Most time is spent in these classes.
+OPT_FAST = -O2 -fstrict-aliasing
+#OPT_FAST = -O
+#OPT_FAST =
+
+#######################################################################
+# Linking final exe -- presumes have a sim_main.cpp
+
+# Special compile rule
+sim_main.o: sim_main.cpp $(VM_PREFIX).h
+
+######################################################################
+######################################################################
+# Automatically understand dependencies
+
+DEPS := $(wildcard *.d)
+ifneq ($(DEPS),)
+include $(DEPS)
+endif

examples/tracing_c/input.vc

@@ -0,0 +1,2 @@
+// This file typically lists flags required by a large project, e.g. include directories
++librescan +libext+.v+.sv+.vh+.svh -y .

examples/tracing_c/sim_main.cpp

@@ -0,0 +1,126 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+//======================================================================
+
+// Include common routines
+#include <verilated.h>
+
+// Include model header, generated from Verilating "top.v"
+#include "Vtop.h"
+
+// If "verilator --trace" is used, include the tracing class
+#if VM_TRACE
+# include <verilated_vcd_c.h>
+#endif
+
+// Current simulation time (64-bit unsigned)
+vluint64_t main_time = 0;
+// Called by $time in Verilog
+double sc_time_stamp() {
+    return main_time;  // Note does conversion to real, to match SystemC
+}
+
+int main(int argc, char** argv, char** env) {
+    // This is a more complicated example, please also see the simpler examples/hello_world_c.
+
+    // Prevent unused variable warnings
+    if (0 && argc && argv && env) {}
+
+    // Set debug level, 0 is off, 9 is highest presently used
+    // May be overridden by commandArgs
+    Verilated::debug(0);
+
+    // Randomization reset policy
+    // May be overridden by commandArgs
+    Verilated::randReset(2);
+
+    // Pass arguments so Verilated code can see them, e.g. $value$plusargs
+    // This needs to be called before you create any model
+    Verilated::commandArgs(argc, argv);
+
+    // Construct the Verilated model, from Vtop.h generated from Verilating "top.v"
+    Vtop* top = new Vtop;  // Or use a const unique_ptr, or the VL_UNIQUE_PTR wrapper
+
+#if VM_TRACE
+    // If verilator was invoked with --trace argument,
+    // and if at run time passed the +trace argument, turn on tracing
+    VerilatedVcdC* tfp = NULL;
+    const char* flag = Verilated::commandArgsPlusMatch("trace");
+    if (flag && 0==strcmp(flag, "+trace")) {
+        Verilated::traceEverOn(true);  // Verilator must compute traced signals
+        VL_PRINTF("Enabling waves into logs/vlt_dump.vcd...\n");
+        tfp = new VerilatedVcdC;
+        top->trace(tfp, 99);  // Trace 99 levels of hierarchy
+        Verilated::mkdir("logs");
+        tfp->open("logs/vlt_dump.vcd");  // Open the dump file
+    }
+#endif
+
+    // Set some inputs
+    top->reset_l = !0;
+    top->fastclk = 0;
+    top->clk = 0;
+    top->in_small = 1;
+    top->in_quad = 0x1234;
+    top->in_wide[0] = 0x11111111;
+    top->in_wide[1] = 0x22222222;
+    top->in_wide[2] = 0x3;
+
+    // Simulate until $finish
+    while (!Verilated::gotFinish()) {
+        main_time++;  // Time passes...
+
+        // Toggle clocks and such
+        top->fastclk = !top->fastclk;
+        if ((main_time % 10) == 3) {
+            top->clk = 1;
+        }
+        if ((main_time % 10) == 8) {
+            top->clk = 0;
+        }
+        if (main_time > 1 && main_time < 10) {
+            top->reset_l = !1;  // Assert reset
+        } else {
+            top->reset_l = !0;  // Deassert reset
+        }
+
+        // Assign some other inputs
+        top->in_quad += 0x12;
+
+        // Evaluate model
+        top->eval();
+
+#if VM_TRACE
+        // Dump trace data for this cycle
+        if (tfp) tfp->dump(main_time);
+#endif
+
+        // Read outputs
+        VL_PRINTF("[%" VL_PRI64 "d] clk=%x rstl=%x iquad=%" VL_PRI64 "x"
+                  " -> oquad=%" VL_PRI64"x owide=%x_%08x_%08x\n",
+                  main_time, top->clk, top->reset_l, top->in_quad,
+                  top->out_quad, top->out_wide[2], top->out_wide[1], top->out_wide[0]);
+    }
+
+    // Final model cleanup
+    top->final();
+
+    // Close trace if opened
+#if VM_TRACE
+    if (tfp) { tfp->close(); tfp = NULL; }
+#endif
+
+    //  Coverage analysis (since test passed)
+#if VM_COVERAGE
+    Verilated::mkdir("logs");
+    VerilatedCov::write("logs/coverage.dat");
+#endif
+
+    // Destroy model
+    delete top; top = NULL;
+
+    // Fin
+    exit(0);
+}

examples/tracing_c/sub.v

@@ -0,0 +1,58 @@
+// DESCRIPTION: Verilator: Verilog Test module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2003 by Wilson Snyder.
+// ======================================================================
+
+module sub
+  (
+   input clk,
+   input fastclk,
+   input reset_l
+   );
+
+   // Example counter/flop
+   reg [31:0] count_f;
+   always_ff @ (posedge fastclk) begin
+      if (!reset_l) begin
+         /*AUTORESET*/
+         // Beginning of autoreset for uninitialized flops
+         count_f <= 32'h0;
+         // End of automatics
+      end
+      else begin
+         count_f <= count_f + 1;
+      end
+   end
+
+   // Another example flop
+   reg [31:0] count_c;
+   always_ff @ (posedge clk) begin
+      if (!reset_l) begin
+         /*AUTORESET*/
+         // Beginning of autoreset for uninitialized flops
+         count_c <= 32'h0;
+         // End of automatics
+      end
+      else begin
+         count_c <= count_c + 1;
+         if (count_c >= 3) begin
+            $display("[%0t] fastclk is %0d times faster than clk\n",
+                     $time, count_f/count_c);
+            // This write is a magic value the Makefile uses to make sure the
+            // test completes successfully.
+            $write("*-* All Finished *-*\n");
+            $finish;
+         end
+      end
+   end
+
+   // An example assertion
+   always_ff @ (posedge clk) begin
+      AssertionExample: assert (!reset_l || count_c<100);
+   end
+
+   // And example coverage analysis
+   cover property (@(posedge clk) count_c==3);
+
+endmodule

examples/tracing_c/top.v

@@ -0,0 +1,42 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2003 by Wilson Snyder.
+// ======================================================================
+
+// This is intended to be a complex example of several features, please also
+// see the simpler examples/hello_world_c.
+
+module top
+  (
+   // Declare some signals so we can see how I/O works
+   input         clk,
+   input         fastclk,
+   input         reset_l,
+
+   output wire [1:0]  out_small,
+   output wire [39:0] out_quad,
+   output wire [69:0] out_wide,
+   input [1:0]   in_small,
+   input [39:0]  in_quad,
+   input [69:0]  in_wide
+   );
+
+   // Connect up the outputs, using some trivial logic
+   assign out_small = ~reset_l ? '0 : (in_small + 2'b1);
+   assign out_quad  = ~reset_l ? '0 : (in_quad + 40'b1);
+   assign out_wide  = ~reset_l ? '0 : (in_wide + 70'b1);
+
+   // And an example sub module. The submodule will print stuff.
+   sub sub (/*AUTOINST*/
+            // Inputs
+            .clk                        (clk),
+            .fastclk                    (fastclk),
+            .reset_l                    (reset_l));
+
+   // Print some stuff as an example
+   initial begin
+      $display("[%0t] Model running...\n", $time);
+   end
+
+endmodule

examples/tracing_sc/.gitignore

@@ -0,0 +1,6 @@
+*.dmp
+*.log
+*.csrc
+*.vcd
+obj_*
+logs

examples/tracing_sc/Makefile

@@ -0,0 +1,109 @@
+######################################################################
+#
+# DESCRIPTION: Verilator Example: Small Makefile
+#
+# This calls the object directory makefile.  That allows the objects to
+# be placed in the "current directory" which simplifies the Makefile.
+#
+# Copyright 2003-2019 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.
+#
+######################################################################
+# Check for sanity to avoid later confusion
+
+ifneq ($(words $(CURDIR)),1)
+ $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+endif
+
+######################################################################
+# Set up variables
+
+# If $VERILATOR_ROOT isn't in the environment, we assume it is part of a
+# package install, and verilator is in your path. Otherwise find the
+# binary relative to $VERILATOR_ROOT (such as when inside the git sources).
+ifeq ($(VERILATOR_ROOT),)
+VERILATOR = verilator
+VERILATOR_COVERAGE = verilator_coverage
+else
+export VERILATOR_ROOT
+VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
+endif
+
+VERILATOR_FLAGS =
+# Generate SystemC in executable form
+VERILATOR_FLAGS += -sc --exe
+# Generate makefile dependencies (not shown as complicates the Makefile)
+#VERILATOR_FLAGS += -MMD
+# Optimize
+VERILATOR_FLAGS += -O2 -x-assign 0
+# Warn abount lint issues; may not want this on less solid designs
+VERILATOR_FLAGS += -Wall
+# Make waveforms
+VERILATOR_FLAGS += --trace
+# Check SystemVerilog assertions
+VERILATOR_FLAGS += --assert
+# Generate coverage analysis
+VERILATOR_FLAGS += --coverage
+# Run Verilator in debug mode
+#VERILATOR_FLAGS += --debug
+# Add this trace to get a backtrace in gdb
+#VERILATOR_FLAGS += --gdbbt
+
+# Check if SC exists via a verilator call (empty if not)
+SYSTEMC_EXISTS := $(shell $(VERILATOR) --getenv SYSTEMC_INCLUDE)
+
+######################################################################
+
+ifneq ($(SYSTEMC_EXISTS),)
+default: run
+else
+default: nosc
+endif
+
+run:
+	@echo
+	@echo "-- Verilator tracing example"
+
+	@echo
+	@echo "-- VERILATE ----------------"
+	$(VERILATOR) $(VERILATOR_FLAGS) -f input.vc top.v sc_main.cpp
+
+	@echo
+	@echo "-- COMPILE ----------------="
+# To compile, we can either just do what Verilator asks,
+# or call a submakefile where we can override the rules ourselves
+#	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
+	$(MAKE) -j 4 -C obj_dir -f ../Makefile_obj
+
+	@echo
+	@echo "-- RUN ---------------------"
+	@mkdir -p logs
+	obj_dir/Vtop +trace
+
+	@echo
+	@echo "-- COVERAGE ----------------"
+	$(VERILATOR_COVERAGE) --annotate logs/annotated logs/coverage.dat
+
+	@echo
+	@echo "-- DONE --------------------"
+	@echo "To see waveforms, open vlt_dump.vcd in a waveform viewer"
+	@echo
+
+######################################################################
+# Other targets
+
+nosc:
+	@echo
+	@echo "%Skip: SYSTEMC_INCLUDE not in environment"
+	@echo "(If you have SystemC see the README, and rebuild Verilator)"
+	@echo
+
+show-config:
+	$(VERILATOR) -V
+
+maintainer-copy::
+clean mostlyclean distclean maintainer-clean::
+	-rm -rf obj_dir logs *.log *.dmp *.vpd coverage.dat core

examples/tracing_sc/Makefile_obj

@@ -0,0 +1,66 @@
+# -*- Makefile -*-
+#######################################################################
+#
+# DESCRIPTION: Verilator Example: Makefile for inside object directory
+#
+# This is executed in the object directory, and called by ../Makefile
+#
+# Copyright 2003-2019 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.
+#
+#######################################################################
+
+default: Vtop
+
+# Include the rules made by Verilator
+include Vtop.mk
+
+# Use OBJCACHE (ccache) if using gmake and its installed
+COMPILE.cc = $(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c
+
+#######################################################################
+# Compile flags
+
+# Override some default compile flags
+CPPFLAGS += -MMD -MP
+CPPFLAGS += -DVL_DEBUG=1
+# SystemC isn't too clean
+CPPFLAGS += -Wno-deprecated
+# Turn on some more flags (when configured appropriately)
+# For testing inside Verilator, "configure --enable-ccwarn" will do this
+# automatically; otherwise you may want this unconditionally enabled
+ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
+USER_CPPFLAGS_WALL += -W -Werror -Wall
+endif
+
+# If you build your own rules from scratch, note you need to include
+# SystemC as follows (Vtop.mk file includes verilated.mk with these
+# already).
+# CPPFLAGS += $(SYSTEMC_CXX_FLAGS) -I$(SYSTEMC_INCLUDE)
+# LDFLAGS  += $(SYSTEMC_CXX_FLAGS) -L$(SYSTEMC_LIBDIR)
+
+# See the benchmarking section of bin/verilator.
+# Support class optimizations.  This includes the tracing and symbol table.
+# SystemC takes minutes to optimize, thus it is off by default.
+OPT_SLOW =
+# Fast path optimizations.  Most time is spent in these classes.
+OPT_FAST = -O2 -fstrict-aliasing
+#OPT_FAST = -O
+#OPT_FAST =
+
+#######################################################################
+# Linking final exe -- presumes have a sim_main.cpp
+
+# Special compile rule
+sim_main.o: sim_main.cpp $(VM_PREFIX).h
+
+######################################################################
+######################################################################
+# Automatically understand dependencies
+
+DEPS := $(wildcard *.d)
+ifneq ($(DEPS),)
+include $(DEPS)
+endif

examples/tracing_sc/input.vc

@@ -0,0 +1,2 @@
+// This file typically lists flags required by a large project, e.g. include directories
++librescan +libext+.v+.sv+.vh+.svh -y .

examples/tracing_sc/sc_main.cpp

@@ -0,0 +1,150 @@
+// -*- SystemC -*-
+// DESCRIPTION: Verilator Example: Top level main for invoking SystemC model
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+//======================================================================
+
+// SystemC global header
+#include <systemc.h>
+
+// Include common routines
+#include <verilated.h>
+#if VM_TRACE
+#include <verilated_vcd_sc.h>
+#endif
+
+#include <sys/stat.h>  // mkdir
+
+// Include model header, generated from Verilating "top.v"
+#include "Vtop.h"
+
+int sc_main(int argc, char* argv[]) {
+    // This is a more complicated example, please also see the simpler examples/hello_world_c.
+
+    // Prevent unused variable warnings
+    if (0 && argc && argv) {}
+
+    // Set debug level, 0 is off, 9 is highest presently used
+    // May be overridden by commandArgs
+    Verilated::debug(0);
+
+    // Randomization reset policy
+    // May be overridden by commandArgs
+    Verilated::randReset(2);
+
+    // Pass arguments so Verilated code can see them, e.g. $value$plusargs
+    // This needs to be called before you create any model
+    Verilated::commandArgs(argc, argv);
+
+    // General logfile
+    ios::sync_with_stdio();
+
+    // Defaults time
+#if (SYSTEMC_VERSION>20011000)
+#else
+    sc_time dut(1.0, sc_ns);
+    sc_set_default_time_unit(dut);
+#endif
+
+    // Define clocks
+#if (SYSTEMC_VERSION>=20070314)
+    sc_clock clk     ("clk",    10,SC_NS, 0.5, 3,SC_NS, true);
+    sc_clock fastclk ("fastclk", 2,SC_NS, 0.5, 2,SC_NS, true);
+#else
+    sc_clock clk     ("clk",    10, 0.5, 3, true);
+    sc_clock fastclk ("fastclk", 2, 0.5, 2, true);
+#endif
+
+    // Define interconnect
+    sc_signal<bool> reset_l;
+    sc_signal<vluint32_t> in_small;
+    sc_signal<vluint64_t> in_quad;
+    sc_signal<sc_bv<70> > in_wide;
+    sc_signal<vluint32_t> out_small;
+    sc_signal<vluint64_t> out_quad;
+    sc_signal<sc_bv<70> > out_wide;
+
+    // Construct the Verilated model, from inside Vtop.h
+    Vtop* top = new Vtop("top");
+    // Attach signals to the model
+    top->clk       (clk);
+    top->fastclk   (fastclk);
+    top->reset_l   (reset_l);
+    top->in_small  (in_small);
+    top->in_quad   (in_quad);
+    top->in_wide   (in_wide);
+    top->out_small (out_small);
+    top->out_quad  (out_quad);
+    top->out_wide  (out_wide);
+
+#if VM_TRACE
+    // Before any evaluation, need to know to calculate those signals only used for tracing
+    Verilated::traceEverOn(true);
+#endif
+
+    // You must do one evaluation before enabling waves, in order to allow
+    // SystemC to interconnect everything for testing.
+#if (SYSTEMC_VERSION>=20070314)
+    sc_start(1,SC_NS);
+#else
+    sc_start(1);
+#endif
+
+#if VM_TRACE
+    // If verilator was invoked with --trace argument,
+    // and if at run time passed the +trace argument, turn on tracing
+    VerilatedVcdSc* tfp = NULL;
+    const char* flag = Verilated::commandArgsPlusMatch("trace");
+    if (flag && 0==strcmp(flag, "+trace")) {
+        cout << "Enabling waves into logs/vlt_dump.vcd...\n";
+        tfp = new VerilatedVcdSc;
+        top->trace(tfp, 99);  // Trace 99 levels of hierarchy
+        Verilated::mkdir("logs");
+        tfp->open("logs/vlt_dump.vcd");
+    }
+#endif
+
+    // Simulate until $finish
+    while (!Verilated::gotFinish()) {
+#if VM_TRACE
+        // Flush the wave files each cycle so we can immediately see the output
+        // Don't do this in "real" programs, do it in an abort() handler instead
+        if (tfp) tfp->flush();
+#endif
+
+        // Apply inputs
+        if (VL_TIME_Q() > 1 && VL_TIME_Q() < 10) {
+            reset_l = !1;  // Assert reset
+        } else if (VL_TIME_Q() > 1) {
+            reset_l = !0;  // Deassert reset
+        }
+
+        // Simulate 1ns
+#if (SYSTEMC_VERSION>=20070314)
+        sc_start(1,SC_NS);
+#else
+        sc_start(1);
+#endif
+    }
+
+    // Final model cleanup
+    top->final();
+
+    // Close trace if opened
+#if VM_TRACE
+    if (tfp) { tfp->close(); tfp = NULL; }
+#endif
+
+    //  Coverage analysis (since test passed)
+#if VM_COVERAGE
+    Verilated::mkdir("logs");
+    VerilatedCov::write("logs/coverage.dat");
+#endif
+
+    // Destroy model
+    delete top; top = NULL;
+
+    // Fin
+    return 0;
+}

examples/tracing_sc/sub.v

@@ -0,0 +1,58 @@
+// DESCRIPTION: Verilator: Verilog Test module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2003 by Wilson Snyder.
+// ======================================================================
+
+module sub
+  (
+   input clk,
+   input fastclk,
+   input reset_l
+   );
+
+   // Example counter/flop
+   reg [31:0] count_f;
+   always_ff @ (posedge fastclk) begin
+      if (!reset_l) begin
+         /*AUTORESET*/
+         // Beginning of autoreset for uninitialized flops
+         count_f <= 32'h0;
+         // End of automatics
+      end
+      else begin
+         count_f <= count_f + 1;
+      end
+   end
+
+   // Another example flop
+   reg [31:0] count_c;
+   always_ff @ (posedge clk) begin
+      if (!reset_l) begin
+         /*AUTORESET*/
+         // Beginning of autoreset for uninitialized flops
+         count_c <= 32'h0;
+         // End of automatics
+      end
+      else begin
+         count_c <= count_c + 1;
+         if (count_c >= 3) begin
+            $display("[%0t] fastclk is %0d times faster than clk\n",
+                     $time, count_f/count_c);
+            // This write is a magic value the Makefile uses to make sure the
+            // test completes successfully.
+            $write("*-* All Finished *-*\n");
+            $finish;
+         end
+      end
+   end
+
+   // An example assertion
+   always_ff @ (posedge clk) begin
+      AssertionExample: assert(!reset_l || count_c<100);
+   end
+
+   // And example coverage analysis
+   cover property (@(posedge clk) count_c==3);
+
+endmodule

examples/tracing_sc/top.v

@@ -0,0 +1,42 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2003 by Wilson Snyder.
+// ======================================================================
+
+// This is intended to be a complex example of several features, please also
+// see the simpler examples/hello_world_c.
+
+module top
+  (
+   // Declare some signals so we can see how I/O works
+   input         clk,
+   input         fastclk,
+   input         reset_l,
+
+   output wire [1:0]  out_small,
+   output wire [39:0] out_quad,
+   output wire [69:0] out_wide,
+   input [1:0]   in_small,
+   input [39:0]  in_quad,
+   input [69:0]  in_wide
+   );
+
+   // Connect up the outputs, using some trivial logic
+   assign out_small = ~reset_l ? '0 : (in_small + 2'b1);
+   assign out_quad  = ~reset_l ? '0 : (in_quad + 40'b1);
+   assign out_wide  = ~reset_l ? '0 : (in_wide + 70'b1);
+
+   // And an example sub module. The submodule will print stuff.
+   sub sub (/*AUTOINST*/
+            // Inputs
+            .clk                        (clk),
+            .fastclk                    (fastclk),
+            .reset_l                    (reset_l));
+
+   // Print some stuff as an example
+   initial begin
+      $display("[%0t] Model running...\n", $time);
+   end
+
+endmodule

include/gtkwave/fastlz.c

@@ -0,0 +1,547 @@
+/*
+  FastLZ - lightning-fast lossless compression library
+
+  Copyright (C) 2007 Ariya Hidayat ([email protected])
+  Copyright (C) 2006 Ariya Hidayat ([email protected])
+  Copyright (C) 2005 Ariya Hidayat ([email protected])
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#include "fastlz.h"
+
+#if !defined(FASTLZ__COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR)
+
+/*
+ * Always check for bound when decompressing.
+ * Generally it is best to leave it defined.
+ */
+#define FASTLZ_SAFE
+
+
+/*
+ * Give hints to the compiler for branch prediction optimization.
+ */
+#if defined(__GNUC__) && (__GNUC__ > 2)
+#define FASTLZ_EXPECT_CONDITIONAL(c)    (__builtin_expect((c), 1))
+#define FASTLZ_UNEXPECT_CONDITIONAL(c)  (__builtin_expect((c), 0))
+#else
+#define FASTLZ_EXPECT_CONDITIONAL(c)    (c)
+#define FASTLZ_UNEXPECT_CONDITIONAL(c)  (c)
+#endif
+
+/*
+ * Use inlined functions for supported systems.
+ */
+#if defined(__GNUC__) || defined(__DMC__) || defined(__POCC__) || defined(__WATCOMC__) || defined(__SUNPRO_C)
+#define FASTLZ_INLINE inline
+#elif defined(__BORLANDC__) || defined(_MSC_VER) || defined(__LCC__)
+#define FASTLZ_INLINE __inline
+#else
+#define FASTLZ_INLINE
+#endif
+
+/*
+ * Prevent accessing more than 8-bit at once, except on x86 architectures.
+ */
+#if !defined(FASTLZ_STRICT_ALIGN)
+#define FASTLZ_STRICT_ALIGN
+#if defined(__i386__) || defined(__386)  /* GNU C, Sun Studio */
+#undef FASTLZ_STRICT_ALIGN
+#elif defined(__i486__) || defined(__i586__) || defined(__i686__) || defined(__amd64) /* GNU C */
+#undef FASTLZ_STRICT_ALIGN
+#elif defined(_M_IX86) /* Intel, MSVC */
+#undef FASTLZ_STRICT_ALIGN
+#elif defined(__386)
+#undef FASTLZ_STRICT_ALIGN
+#elif defined(_X86_) /* MinGW */
+#undef FASTLZ_STRICT_ALIGN
+#elif defined(__I86__) /* Digital Mars */
+#undef FASTLZ_STRICT_ALIGN
+#endif
+#endif
+
+/* prototypes */
+int fastlz_compress(const void* input, int length, void* output);
+int fastlz_compress_level(int level, const void* input, int length, void* output);
+int fastlz_decompress(const void* input, int length, void* output, int maxout);
+
+#define MAX_COPY       32
+#define MAX_LEN       264  /* 256 + 8 */
+#define MAX_DISTANCE 8192
+
+#if !defined(FASTLZ_STRICT_ALIGN)
+#define FASTLZ_READU16(p) *((const flzuint16*)(p))
+#else
+#define FASTLZ_READU16(p) ((p)[0] | (p)[1]<<8)
+#endif
+
+#define HASH_LOG  13
+#define HASH_SIZE (1<< HASH_LOG)
+#define HASH_MASK  (HASH_SIZE-1)
+#define HASH_FUNCTION(v,p) { v = FASTLZ_READU16(p); v ^= FASTLZ_READU16(p+1)^(v>>(16-HASH_LOG));v &= HASH_MASK; }
+
+#undef FASTLZ_LEVEL
+#define FASTLZ_LEVEL 1
+
+#undef FASTLZ_COMPRESSOR
+#undef FASTLZ_DECOMPRESSOR
+#define FASTLZ_COMPRESSOR fastlz1_compress
+#define FASTLZ_DECOMPRESSOR fastlz1_decompress
+static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output);
+static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout);
+#include "fastlz.c"
+
+#undef FASTLZ_LEVEL
+#define FASTLZ_LEVEL 2
+
+#undef MAX_DISTANCE
+#define MAX_DISTANCE 8191
+#define MAX_FARDISTANCE (65535+MAX_DISTANCE-1)
+
+#undef FASTLZ_COMPRESSOR
+#undef FASTLZ_DECOMPRESSOR
+#define FASTLZ_COMPRESSOR fastlz2_compress
+#define FASTLZ_DECOMPRESSOR fastlz2_decompress
+static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output);
+static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout);
+#include "fastlz.c"
+
+int fastlz_compress(const void* input, int length, void* output)
+{
+  /* for short block, choose fastlz1 */
+  if(length < 65536)
+    return fastlz1_compress(input, length, output);
+
+  /* else... */
+  return fastlz2_compress(input, length, output);
+}
+
+int fastlz_decompress(const void* input, int length, void* output, int maxout)
+{
+  /* magic identifier for compression level */
+  int level = ((*(const flzuint8*)input) >> 5) + 1;
+
+  if(level == 1)
+    return fastlz1_decompress(input, length, output, maxout);
+  if(level == 2)
+    return fastlz2_decompress(input, length, output, maxout);
+
+  /* unknown level, trigger error */
+  return 0;
+}
+
+int fastlz_compress_level(int level, const void* input, int length, void* output)
+{
+  if(level == 1)
+    return fastlz1_compress(input, length, output);
+  if(level == 2)
+    return fastlz2_compress(input, length, output);
+
+  return 0;
+}
+
+#else /* !defined(FASTLZ_COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR) */
+
+static FASTLZ_INLINE int FASTLZ_COMPRESSOR(const void* input, int length, void* output)
+{
+  const flzuint8* ip = (const flzuint8*) input;
+  const flzuint8* ip_bound = ip + length - 2;
+  const flzuint8* ip_limit = ip + length - 12;
+  flzuint8* op = (flzuint8*) output;
+
+  const flzuint8* htab[HASH_SIZE];
+  const flzuint8** hslot;
+  flzuint32 hval;
+
+  flzuint32 copy;
+
+  /* sanity check */
+  if(FASTLZ_UNEXPECT_CONDITIONAL(length < 4))
+  {
+    if(length)
+    {
+      /* create literal copy only */
+      *op++ = length-1;
+      ip_bound++;
+      while(ip <= ip_bound)
+        *op++ = *ip++;
+      return length+1;
+    }
+    else
+      return 0;
+  }
+
+  /* initializes hash table */
+  for (hslot = htab; hslot < htab + HASH_SIZE; hslot++)
+    *hslot = ip;
+
+  /* we start with literal copy */
+  copy = 2;
+  *op++ = MAX_COPY-1;
+  *op++ = *ip++;
+  *op++ = *ip++;
+
+  /* main loop */
+  while(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit))
+  {
+    const flzuint8* ref;
+    flzuint32 distance;
+
+    /* minimum match length */
+    flzuint32 len = 3;
+
+    /* comparison starting-point */
+    const flzuint8* anchor = ip;
+
+    /* check for a run */
+#if FASTLZ_LEVEL==2
+    if(ip[0] == ip[-1] && FASTLZ_READU16(ip-1)==FASTLZ_READU16(ip+1))
+    {
+      distance = 1;
+      /* ip += 3; */ /* scan-build, never used */
+      ref = anchor - 1 + 3;
+      goto match;
+    }
+#endif
+
+    /* find potential match */
+    HASH_FUNCTION(hval,ip);
+    hslot = htab + hval;
+    ref = htab[hval];
+
+    /* calculate distance to the match */
+    distance = anchor - ref;
+
+    /* update hash table */
+    *hslot = anchor;
+
+    /* is this a match? check the first 3 bytes */
+    if(distance==0 ||
+#if FASTLZ_LEVEL==1
+    (distance >= MAX_DISTANCE) ||
+#else
+    (distance >= MAX_FARDISTANCE) ||
+#endif
+    *ref++ != *ip++ || *ref++!=*ip++ || *ref++!=*ip++)
+      goto literal;
+
+#if FASTLZ_LEVEL==2
+    /* far, needs at least 5-byte match */
+    if(distance >= MAX_DISTANCE)
+    {
+      if(*ip++ != *ref++ || *ip++!= *ref++)
+        goto literal;
+      len += 2;
+    }
+
+    match:
+#endif
+
+    /* last matched byte */
+    ip = anchor + len;
+
+    /* distance is biased */
+    distance--;
+
+    if(!distance)
+    {
+      /* zero distance means a run */
+      flzuint8 x = ip[-1];
+      while(ip < ip_bound)
+        if(*ref++ != x) break; else ip++;
+    }
+    else
+    for(;;)
+    {
+      /* safe because the outer check against ip limit */
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      if(*ref++ != *ip++) break;
+      while(ip < ip_bound)
+        if(*ref++ != *ip++) break;
+      break;
+    }
+
+    /* if we have copied something, adjust the copy count */
+    if(copy)
+      /* copy is biased, '0' means 1 byte copy */
+      *(op-copy-1) = copy-1;
+    else
+      /* back, to overwrite the copy count */
+      op--;
+
+    /* reset literal counter */
+    copy = 0;
+
+    /* length is biased, '1' means a match of 3 bytes */
+    ip -= 3;
+    len = ip - anchor;
+
+    /* encode the match */
+#if FASTLZ_LEVEL==2
+    if(distance < MAX_DISTANCE)
+    {
+      if(len < 7)
+      {
+        *op++ = (len << 5) + (distance >> 8);
+        *op++ = (distance & 255);
+      }
+      else
+      {
+        *op++ = (7 << 5) + (distance >> 8);
+        for(len-=7; len >= 255; len-= 255)
+          *op++ = 255;
+        *op++ = len;
+        *op++ = (distance & 255);
+      }
+    }
+    else
+    {
+      /* far away, but not yet in the another galaxy... */
+      if(len < 7)
+      {
+        distance -= MAX_DISTANCE;
+        *op++ = (len << 5) + 31;
+        *op++ = 255;
+        *op++ = distance >> 8;
+        *op++ = distance & 255;
+      }
+      else
+      {
+        distance -= MAX_DISTANCE;
+        *op++ = (7 << 5) + 31;
+        for(len-=7; len >= 255; len-= 255)
+          *op++ = 255;
+        *op++ = len;
+        *op++ = 255;
+        *op++ = distance >> 8;
+        *op++ = distance & 255;
+      }
+    }
+#else
+
+    if(FASTLZ_UNEXPECT_CONDITIONAL(len > MAX_LEN-2))
+      while(len > MAX_LEN-2)
+      {
+        *op++ = (7 << 5) + (distance >> 8);
+        *op++ = MAX_LEN - 2 - 7 -2;
+        *op++ = (distance & 255);
+        len -= MAX_LEN-2;
+      }
+
+    if(len < 7)
+    {
+      *op++ = (len << 5) + (distance >> 8);
+      *op++ = (distance & 255);
+    }
+    else
+    {
+      *op++ = (7 << 5) + (distance >> 8);
+      *op++ = len - 7;
+      *op++ = (distance & 255);
+    }
+#endif
+
+    /* update the hash at match boundary */
+    HASH_FUNCTION(hval,ip);
+    htab[hval] = ip++;
+    HASH_FUNCTION(hval,ip);
+    htab[hval] = ip++;
+
+    /* assuming literal copy */
+    *op++ = MAX_COPY-1;
+
+    continue;
+
+    literal:
+      *op++ = *anchor++;
+      ip = anchor;
+      copy++;
+      if(FASTLZ_UNEXPECT_CONDITIONAL(copy == MAX_COPY))
+      {
+        copy = 0;
+        *op++ = MAX_COPY-1;
+      }
+  }
+
+  /* left-over as literal copy */
+  ip_bound++;
+  while(ip <= ip_bound)
+  {
+    *op++ = *ip++;
+    copy++;
+    if(copy == MAX_COPY)
+    {
+      copy = 0;
+      *op++ = MAX_COPY-1;
+    }
+  }
+
+  /* if we have copied something, adjust the copy length */
+  if(copy)
+    *(op-copy-1) = copy-1;
+  else
+    op--;
+
+#if FASTLZ_LEVEL==2
+  /* marker for fastlz2 */
+  *(flzuint8*)output |= (1 << 5);
+#endif
+
+  return op - (flzuint8*)output;
+}
+
+static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void* output, int maxout)
+{
+  const flzuint8* ip = (const flzuint8*) input;
+  const flzuint8* ip_limit  = ip + length;
+  flzuint8* op = (flzuint8*) output;
+  flzuint8* op_limit = op + maxout;
+  flzuint32 ctrl = (*ip++) & 31;
+  int loop = 1;
+
+  do
+  {
+    const flzuint8* ref = op;
+    flzuint32 len = ctrl >> 5;
+    flzuint32 ofs = (ctrl & 31) << 8;
+
+    if(ctrl >= 32)
+    {
+#if FASTLZ_LEVEL==2
+      flzuint8 code;
+#endif
+      len--;
+      ref -= ofs;
+      if (len == 7-1)
+#if FASTLZ_LEVEL==1
+        len += *ip++;
+      ref -= *ip++;
+#else
+        do
+        {
+          code = *ip++;
+          len += code;
+        } while (code==255);
+      code = *ip++;
+      ref -= code;
+
+      /* match from 16-bit distance */
+      if(FASTLZ_UNEXPECT_CONDITIONAL(code==255))
+      if(FASTLZ_EXPECT_CONDITIONAL(ofs==(31 << 8)))
+      {
+        ofs = (*ip++) << 8;
+        ofs += *ip++;
+        ref = op - ofs - MAX_DISTANCE;
+      }
+#endif
+
+#ifdef FASTLZ_SAFE
+      if (FASTLZ_UNEXPECT_CONDITIONAL(op + len + 3 > op_limit))
+        return 0;
+
+      if (FASTLZ_UNEXPECT_CONDITIONAL(ref-1 < (flzuint8 *)output))
+        return 0;
+#endif
+
+      if(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit))
+        ctrl = *ip++;
+      else
+        loop = 0;
+
+      if(ref == op)
+      {
+        /* optimize copy for a run */
+        flzuint8 b = ref[-1];
+        *op++ = b;
+        *op++ = b;
+        *op++ = b;
+        for(; len; --len)
+          *op++ = b;
+      }
+      else
+      {
+#if !defined(FASTLZ_STRICT_ALIGN)
+        const flzuint16* p;
+        flzuint16* q;
+#endif
+        /* copy from reference */
+        ref--;
+        *op++ = *ref++;
+        *op++ = *ref++;
+        *op++ = *ref++;
+
+#if !defined(FASTLZ_STRICT_ALIGN)
+        /* copy a byte, so that now it's word aligned */
+        if(len & 1)
+        {
+          *op++ = *ref++;
+          len--;
+        }
+
+        /* copy 16-bit at once */
+        q = (flzuint16*) op;
+        op += len;
+        p = (const flzuint16*) ref;
+        for(len>>=1; len > 4; len-=4)
+        {
+          *q++ = *p++;
+          *q++ = *p++;
+          *q++ = *p++;
+          *q++ = *p++;
+        }
+        for(; len; --len)
+          *q++ = *p++;
+#else
+        for(; len; --len)
+          *op++ = *ref++;
+#endif
+      }
+    }
+    else
+    {
+      ctrl++;
+#ifdef FASTLZ_SAFE
+      if (FASTLZ_UNEXPECT_CONDITIONAL(op + ctrl > op_limit))
+        return 0;
+      if (FASTLZ_UNEXPECT_CONDITIONAL(ip + ctrl > ip_limit))
+        return 0;
+#endif
+
+      *op++ = *ip++;
+      for(--ctrl; ctrl; ctrl--)
+        *op++ = *ip++;
+
+      loop = FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit);
+      if(loop)
+        ctrl = *ip++;
+    }
+  }
+  while(FASTLZ_EXPECT_CONDITIONAL(loop));
+
+  return op - (flzuint8*)output;
+}
+
+#endif /* !defined(FASTLZ_COMPRESSOR) && !defined(FASTLZ_DECOMPRESSOR) */

include/gtkwave/fastlz.h

@@ -0,0 +1,107 @@
+/*
+  FastLZ - lightning-fast lossless compression library
+
+  Copyright (C) 2007 Ariya Hidayat ([email protected])
+  Copyright (C) 2006 Ariya Hidayat ([email protected])
+  Copyright (C) 2005 Ariya Hidayat ([email protected])
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef FASTLZ_H
+#define FASTLZ_H
+
+#include <inttypes.h>
+
+#define flzuint8 uint8_t
+#define flzuint16 uint16_t
+#define flzuint32 uint32_t
+
+
+#define FASTLZ_VERSION 0x000100
+
+#define FASTLZ_VERSION_MAJOR     0
+#define FASTLZ_VERSION_MINOR     0
+#define FASTLZ_VERSION_REVISION  0
+
+#define FASTLZ_VERSION_STRING "0.1.0"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/**
+  Compress a block of data in the input buffer and returns the size of
+  compressed block. The size of input buffer is specified by length. The
+  minimum input buffer size is 16.
+
+  The output buffer must be at least 5% larger than the input buffer
+  and can not be smaller than 66 bytes.
+
+  If the input is not compressible, the return value might be larger than
+  length (input buffer size).
+
+  The input buffer and the output buffer can not overlap.
+*/
+
+int fastlz_compress(const void* input, int length, void* output);
+
+/**
+  Decompress a block of compressed data and returns the size of the
+  decompressed block. If error occurs, e.g. the compressed data is
+  corrupted or the output buffer is not large enough, then 0 (zero)
+  will be returned instead.
+
+  The input buffer and the output buffer can not overlap.
+
+  Decompression is memory safe and guaranteed not to write the output buffer
+  more than what is specified in maxout.
+ */
+
+int fastlz_decompress(const void* input, int length, void* output, int maxout);
+
+/**
+  Compress a block of data in the input buffer and returns the size of
+  compressed block. The size of input buffer is specified by length. The
+  minimum input buffer size is 16.
+
+  The output buffer must be at least 5% larger than the input buffer
+  and can not be smaller than 66 bytes.
+
+  If the input is not compressible, the return value might be larger than
+  length (input buffer size).
+
+  The input buffer and the output buffer can not overlap.
+
+  Compression level can be specified in parameter level. At the moment,
+  only level 1 and level 2 are supported.
+  Level 1 is the fastest compression and generally useful for short data.
+  Level 2 is slightly slower but it gives better compression ratio.
+
+  Note that the compressed data, regardless of the level, can always be
+  decompressed using the function fastlz_decompress above.
+*/
+
+int fastlz_compress_level(int level, const void* input, int length, void* output);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* FASTLZ_H */

include/gtkwave/fst_config.h

@@ -0,0 +1,11 @@
+/* This file specifically for FST usage */
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix). */
+#if !defined(__MINGW32__)
+# define HAVE_ALLOCA_H 1
+#endif
+
+/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
+#define HAVE_FSEEKO 1

include/gtkwave/fstapi.h

@@ -0,0 +1,452 @@
+/*
+ * Copyright (c) 2009-2018 Tony Bybell.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef FST_API_H
+#define FST_API_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <zlib.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include <time.h>
+
+#define FST_RDLOAD "FSTLOAD | "
+
+typedef uint32_t fstHandle;
+typedef uint32_t fstEnumHandle;
+
+enum fstWriterPackType {
+    FST_WR_PT_ZLIB             = 0,
+    FST_WR_PT_FASTLZ           = 1,
+    FST_WR_PT_LZ4              = 2
+};
+
+enum fstFileType {
+    FST_FT_MIN                 = 0,
+
+    FST_FT_VERILOG             = 0,
+    FST_FT_VHDL                = 1,
+    FST_FT_VERILOG_VHDL        = 2,
+
+    FST_FT_MAX                 = 2
+};
+
+enum fstBlockType {
+    FST_BL_HDR                 = 0,
+    FST_BL_VCDATA              = 1,
+    FST_BL_BLACKOUT            = 2,
+    FST_BL_GEOM                = 3,
+    FST_BL_HIER                = 4,
+    FST_BL_VCDATA_DYN_ALIAS    = 5,
+    FST_BL_HIER_LZ4            = 6,
+    FST_BL_HIER_LZ4DUO         = 7,
+    FST_BL_VCDATA_DYN_ALIAS2   = 8,
+
+    FST_BL_ZWRAPPER            = 254,   /* indicates that whole trace is gz wrapped */
+    FST_BL_SKIP                = 255    /* used while block is being written */
+};
+
+enum fstScopeType {
+    FST_ST_MIN                 = 0,
+
+    FST_ST_VCD_MODULE          = 0,
+    FST_ST_VCD_TASK            = 1,
+    FST_ST_VCD_FUNCTION        = 2,
+    FST_ST_VCD_BEGIN           = 3,
+    FST_ST_VCD_FORK            = 4,
+    FST_ST_VCD_GENERATE        = 5,
+    FST_ST_VCD_STRUCT          = 6,
+    FST_ST_VCD_UNION           = 7,
+    FST_ST_VCD_CLASS           = 8,
+    FST_ST_VCD_INTERFACE       = 9,
+    FST_ST_VCD_PACKAGE         = 10,
+    FST_ST_VCD_PROGRAM         = 11,
+
+    FST_ST_VHDL_ARCHITECTURE   = 12,
+    FST_ST_VHDL_PROCEDURE      = 13,
+    FST_ST_VHDL_FUNCTION       = 14,
+    FST_ST_VHDL_RECORD         = 15,
+    FST_ST_VHDL_PROCESS        = 16,
+    FST_ST_VHDL_BLOCK          = 17,
+    FST_ST_VHDL_FOR_GENERATE   = 18,
+    FST_ST_VHDL_IF_GENERATE    = 19,
+    FST_ST_VHDL_GENERATE       = 20,
+    FST_ST_VHDL_PACKAGE        = 21,
+
+    FST_ST_MAX                 = 21,
+
+    FST_ST_GEN_ATTRBEGIN       = 252,
+    FST_ST_GEN_ATTREND         = 253,
+
+    FST_ST_VCD_SCOPE           = 254,
+    FST_ST_VCD_UPSCOPE         = 255
+};
+
+enum fstVarType {
+    FST_VT_MIN                 = 0,     /* start of vartypes */
+
+    FST_VT_VCD_EVENT           = 0,
+    FST_VT_VCD_INTEGER         = 1,
+    FST_VT_VCD_PARAMETER       = 2,
+    FST_VT_VCD_REAL            = 3,
+    FST_VT_VCD_REAL_PARAMETER  = 4,
+    FST_VT_VCD_REG             = 5,
+    FST_VT_VCD_SUPPLY0         = 6,
+    FST_VT_VCD_SUPPLY1         = 7,
+    FST_VT_VCD_TIME            = 8,
+    FST_VT_VCD_TRI             = 9,
+    FST_VT_VCD_TRIAND          = 10,
+    FST_VT_VCD_TRIOR           = 11,
+    FST_VT_VCD_TRIREG          = 12,
+    FST_VT_VCD_TRI0            = 13,
+    FST_VT_VCD_TRI1            = 14,
+    FST_VT_VCD_WAND            = 15,
+    FST_VT_VCD_WIRE            = 16,
+    FST_VT_VCD_WOR             = 17,
+    FST_VT_VCD_PORT            = 18,
+    FST_VT_VCD_SPARRAY         = 19,    /* used to define the rownum (index) port for a sparse array */
+    FST_VT_VCD_REALTIME        = 20,
+
+    FST_VT_GEN_STRING          = 21,    /* generic string type   (max len is defined dynamically via fstWriterEmitVariableLengthValueChange) */
+
+    FST_VT_SV_BIT              = 22,
+    FST_VT_SV_LOGIC            = 23,
+    FST_VT_SV_INT              = 24,    /* declare as size = 32 */
+    FST_VT_SV_SHORTINT         = 25,    /* declare as size = 16 */
+    FST_VT_SV_LONGINT          = 26,    /* declare as size = 64 */
+    FST_VT_SV_BYTE             = 27,    /* declare as size = 8  */
+    FST_VT_SV_ENUM             = 28,    /* declare as appropriate type range */
+    FST_VT_SV_SHORTREAL        = 29,    /* declare and emit same as FST_VT_VCD_REAL (needs to be emitted as double, not a float) */
+
+    FST_VT_MAX                 = 29     /* end of vartypes */
+};
+
+enum fstVarDir {
+    FST_VD_MIN         = 0,
+
+    FST_VD_IMPLICIT    = 0,
+    FST_VD_INPUT       = 1,
+    FST_VD_OUTPUT      = 2,
+    FST_VD_INOUT       = 3,
+    FST_VD_BUFFER      = 4,
+    FST_VD_LINKAGE     = 5,
+
+    FST_VD_MAX         = 5
+};
+
+enum fstHierType {
+    FST_HT_MIN         = 0,
+
+    FST_HT_SCOPE       = 0,
+    FST_HT_UPSCOPE     = 1,
+    FST_HT_VAR         = 2,
+    FST_HT_ATTRBEGIN   = 3,
+    FST_HT_ATTREND     = 4,
+
+    /* FST_HT_TREEBEGIN and FST_HT_TREEEND are not yet used by FST but are currently used when fstHier bridges other formats */
+    FST_HT_TREEBEGIN   = 5,
+    FST_HT_TREEEND     = 6,
+
+    FST_HT_MAX         = 6
+};
+
+enum fstAttrType {
+    FST_AT_MIN         = 0,
+
+    FST_AT_MISC        = 0,     /* self-contained: does not need matching FST_HT_ATTREND */
+    FST_AT_ARRAY       = 1,
+    FST_AT_ENUM        = 2,
+    FST_AT_PACK        = 3,
+
+    FST_AT_MAX         = 3
+};
+
+enum fstMiscType {
+    FST_MT_MIN         = 0,
+
+    FST_MT_COMMENT     = 0,     /* use fstWriterSetComment() to emit */
+    FST_MT_ENVVAR      = 1,     /* use fstWriterSetEnvVar() to emit */
+    FST_MT_SUPVAR      = 2,     /* use fstWriterCreateVar2() to emit */
+    FST_MT_PATHNAME    = 3,     /* reserved for fstWriterSetSourceStem() string -> number management */
+    FST_MT_SOURCESTEM  = 4,     /* use fstWriterSetSourceStem() to emit */
+    FST_MT_SOURCEISTEM = 5,     /* use fstWriterSetSourceInstantiationStem() to emit */
+    FST_MT_VALUELIST   = 6,	/* use fstWriterSetValueList() to emit, followed by fstWriterCreateVar*() */
+    FST_MT_ENUMTABLE   = 7,	/* use fstWriterCreateEnumTable() and fstWriterEmitEnumTableRef() to emit */
+    FST_MT_UNKNOWN     = 8,
+
+    FST_MT_MAX         = 8
+};
+
+enum fstArrayType {
+    FST_AR_MIN         = 0,
+
+    FST_AR_NONE        = 0,
+    FST_AR_UNPACKED    = 1,
+    FST_AR_PACKED      = 2,
+    FST_AR_SPARSE      = 3,
+
+    FST_AR_MAX         = 3
+};
+
+enum fstEnumValueType {
+    FST_EV_SV_INTEGER           = 0,
+    FST_EV_SV_BIT               = 1,
+    FST_EV_SV_LOGIC             = 2,
+    FST_EV_SV_INT               = 3,
+    FST_EV_SV_SHORTINT          = 4,
+    FST_EV_SV_LONGINT           = 5,
+    FST_EV_SV_BYTE              = 6,
+    FST_EV_SV_UNSIGNED_INTEGER  = 7,
+    FST_EV_SV_UNSIGNED_BIT      = 8,
+    FST_EV_SV_UNSIGNED_LOGIC    = 9,
+    FST_EV_SV_UNSIGNED_INT      = 10,
+    FST_EV_SV_UNSIGNED_SHORTINT = 11,
+    FST_EV_SV_UNSIGNED_LONGINT  = 12,
+    FST_EV_SV_UNSIGNED_BYTE     = 13,
+
+    FST_EV_REG			= 14,
+    FST_EV_TIME			= 15,
+
+    FST_EV_MAX                  = 15
+};
+
+enum fstPackType {
+    FST_PT_NONE          = 0,
+    FST_PT_UNPACKED      = 1,
+    FST_PT_PACKED        = 2,
+    FST_PT_TAGGED_PACKED = 3,
+
+    FST_PT_MAX           = 3
+};
+
+enum fstSupplementalVarType {
+    FST_SVT_MIN                    = 0,
+
+    FST_SVT_NONE                   = 0,
+
+    FST_SVT_VHDL_SIGNAL            = 1,
+    FST_SVT_VHDL_VARIABLE          = 2,
+    FST_SVT_VHDL_CONSTANT          = 3,
+    FST_SVT_VHDL_FILE              = 4,
+    FST_SVT_VHDL_MEMORY            = 5,
+
+    FST_SVT_MAX                    = 5
+};
+
+enum fstSupplementalDataType {
+    FST_SDT_MIN                    = 0,
+
+    FST_SDT_NONE                   = 0,
+
+    FST_SDT_VHDL_BOOLEAN           = 1,
+    FST_SDT_VHDL_BIT               = 2,
+    FST_SDT_VHDL_BIT_VECTOR        = 3,
+    FST_SDT_VHDL_STD_ULOGIC        = 4,
+    FST_SDT_VHDL_STD_ULOGIC_VECTOR = 5,
+    FST_SDT_VHDL_STD_LOGIC         = 6,
+    FST_SDT_VHDL_STD_LOGIC_VECTOR  = 7,
+    FST_SDT_VHDL_UNSIGNED          = 8,
+    FST_SDT_VHDL_SIGNED            = 9,
+    FST_SDT_VHDL_INTEGER           = 10,
+    FST_SDT_VHDL_REAL              = 11,
+    FST_SDT_VHDL_NATURAL           = 12,
+    FST_SDT_VHDL_POSITIVE          = 13,
+    FST_SDT_VHDL_TIME              = 14,
+    FST_SDT_VHDL_CHARACTER         = 15,
+    FST_SDT_VHDL_STRING            = 16,
+
+    FST_SDT_MAX                    = 16,
+
+    FST_SDT_SVT_SHIFT_COUNT        = 10, /* FST_SVT_* is ORed in by fstWriterCreateVar2() to the left after shifting FST_SDT_SVT_SHIFT_COUNT */
+    FST_SDT_ABS_MAX                = ((1<<(FST_SDT_SVT_SHIFT_COUNT))-1)
+};
+
+
+struct fstHier
+{
+unsigned char htyp;
+
+union {
+        /* if htyp == FST_HT_SCOPE */
+        struct fstHierScope {
+                unsigned char typ; /* FST_ST_MIN ... FST_ST_MAX */
+                const char *name;
+                const char *component;
+                uint32_t name_length;           /* strlen(u.scope.name) */
+                uint32_t component_length;      /* strlen(u.scope.component) */
+                } scope;
+
+        /* if htyp == FST_HT_VAR */
+        struct fstHierVar {
+                unsigned char typ; /* FST_VT_MIN ... FST_VT_MAX */
+                unsigned char direction; /* FST_VD_MIN ... FST_VD_MAX */
+                unsigned char svt_workspace; /* zeroed out by FST reader, for client code use */
+                unsigned char sdt_workspace; /* zeroed out by FST reader, for client code use */
+                unsigned int  sxt_workspace; /* zeroed out by FST reader, for client code use */
+                const char *name;
+                uint32_t length;
+                fstHandle handle;
+                uint32_t name_length; /* strlen(u.var.name) */
+                unsigned is_alias : 1;
+                } var;
+
+        /* if htyp == FST_HT_ATTRBEGIN */
+        struct fstHierAttr {
+                unsigned char typ; /* FST_AT_MIN ... FST_AT_MAX */
+                unsigned char subtype; /* from fstMiscType, fstArrayType, fstEnumValueType, fstPackType */
+                const char *name;
+                uint64_t arg; /* number of array elements, struct members, or some other payload (possibly ignored) */
+                uint64_t arg_from_name; /* for when name is overloaded as a variable-length integer (FST_AT_MISC + FST_MT_SOURCESTEM) */
+                uint32_t name_length; /* strlen(u.attr.name) */
+                } attr;
+        } u;
+};
+
+
+struct fstETab
+{
+char *name;
+uint32_t elem_count;
+char **literal_arr;
+char **val_arr;
+};
+
+
+/*
+ * writer functions
+ */
+void            fstWriterClose(void *ctx);
+void *          fstWriterCreate(const char *nam, int use_compressed_hier);
+fstEnumHandle   fstWriterCreateEnumTable(void *ctx, const char *name, uint32_t elem_count, unsigned int min_valbits, const char **literal_arr, const char **val_arr);
+                /* used for Verilog/SV */
+fstHandle       fstWriterCreateVar(void *ctx, enum fstVarType vt, enum fstVarDir vd,
+                        uint32_t len, const char *nam, fstHandle aliasHandle);
+                /* future expansion for VHDL and other languages.  The variable type, data type, etc map onto
+                   the current Verilog/SV one.  The "type" string is optional for a more verbose or custom description */
+fstHandle       fstWriterCreateVar2(void *ctx, enum fstVarType vt, enum fstVarDir vd,
+                        uint32_t len, const char *nam, fstHandle aliasHandle,
+                        const char *type, enum fstSupplementalVarType svt, enum fstSupplementalDataType sdt);
+void            fstWriterEmitDumpActive(void *ctx, int enable);
+void 		fstWriterEmitEnumTableRef(void *ctx, fstEnumHandle handle);
+void            fstWriterEmitValueChange(void *ctx, fstHandle handle, const void *val);
+void            fstWriterEmitVariableLengthValueChange(void *ctx, fstHandle handle, const void *val, uint32_t len);
+void            fstWriterEmitTimeChange(void *ctx, uint64_t tim);
+void            fstWriterFlushContext(void *ctx);
+int             fstWriterGetDumpSizeLimitReached(void *ctx);
+int             fstWriterGetFseekFailed(void *ctx);
+void            fstWriterSetAttrBegin(void *ctx, enum fstAttrType attrtype, int subtype,
+                        const char *attrname, uint64_t arg);
+void            fstWriterSetAttrEnd(void *ctx);
+void            fstWriterSetComment(void *ctx, const char *comm);
+void            fstWriterSetDate(void *ctx, const char *dat);
+void            fstWriterSetDumpSizeLimit(void *ctx, uint64_t numbytes);
+void            fstWriterSetEnvVar(void *ctx, const char *envvar);
+void            fstWriterSetFileType(void *ctx, enum fstFileType filetype);
+void            fstWriterSetPackType(void *ctx, enum fstWriterPackType typ);
+void            fstWriterSetParallelMode(void *ctx, int enable);
+void            fstWriterSetRepackOnClose(void *ctx, int enable);       /* type = 0 (none), 1 (libz) */
+void            fstWriterSetScope(void *ctx, enum fstScopeType scopetype,
+                        const char *scopename, const char *scopecomp);
+void            fstWriterSetSourceInstantiationStem(void *ctx, const char *path, unsigned int line, unsigned int use_realpath);
+void            fstWriterSetSourceStem(void *ctx, const char *path, unsigned int line, unsigned int use_realpath);
+void            fstWriterSetTimescale(void *ctx, int ts);
+void            fstWriterSetTimescaleFromString(void *ctx, const char *s);
+void            fstWriterSetTimezero(void *ctx, int64_t tim);
+void            fstWriterSetUpscope(void *ctx);
+void		fstWriterSetValueList(void *ctx, const char *vl);
+void            fstWriterSetVersion(void *ctx, const char *vers);
+
+
+/*
+ * reader functions
+ */
+void            fstReaderClose(void *ctx);
+void            fstReaderClrFacProcessMask(void *ctx, fstHandle facidx);
+void            fstReaderClrFacProcessMaskAll(void *ctx);
+uint64_t        fstReaderGetAliasCount(void *ctx);
+const char *    fstReaderGetCurrentFlatScope(void *ctx);
+void *          fstReaderGetCurrentScopeUserInfo(void *ctx);
+int             fstReaderGetCurrentScopeLen(void *ctx);
+const char *    fstReaderGetDateString(void *ctx);
+int             fstReaderGetDoubleEndianMatchState(void *ctx);
+uint64_t        fstReaderGetDumpActivityChangeTime(void *ctx, uint32_t idx);
+unsigned char   fstReaderGetDumpActivityChangeValue(void *ctx, uint32_t idx);
+uint64_t        fstReaderGetEndTime(void *ctx);
+int             fstReaderGetFacProcessMask(void *ctx, fstHandle facidx);
+int             fstReaderGetFileType(void *ctx);
+int             fstReaderGetFseekFailed(void *ctx);
+fstHandle       fstReaderGetMaxHandle(void *ctx);
+uint64_t        fstReaderGetMemoryUsedByWriter(void *ctx);
+uint32_t        fstReaderGetNumberDumpActivityChanges(void *ctx);
+uint64_t        fstReaderGetScopeCount(void *ctx);
+uint64_t        fstReaderGetStartTime(void *ctx);
+signed char     fstReaderGetTimescale(void *ctx);
+int64_t         fstReaderGetTimezero(void *ctx);
+uint64_t        fstReaderGetValueChangeSectionCount(void *ctx);
+char *          fstReaderGetValueFromHandleAtTime(void *ctx, uint64_t tim, fstHandle facidx, char *buf);
+uint64_t        fstReaderGetVarCount(void *ctx);
+const char *    fstReaderGetVersionString(void *ctx);
+struct fstHier *fstReaderIterateHier(void *ctx);
+int             fstReaderIterateHierRewind(void *ctx);
+int             fstReaderIterBlocks(void *ctx,
+                        void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value),
+                        void *user_callback_data_pointer, FILE *vcdhandle);
+int             fstReaderIterBlocks2(void *ctx,
+                        void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value),
+                        void (*value_change_callback_varlen)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value, uint32_t len),
+                        void *user_callback_data_pointer, FILE *vcdhandle);
+void            fstReaderIterBlocksSetNativeDoublesOnCallback(void *ctx, int enable);
+void *          fstReaderOpen(const char *nam);
+void *          fstReaderOpenForUtilitiesOnly(void);
+const char *    fstReaderPopScope(void *ctx);
+int             fstReaderProcessHier(void *ctx, FILE *vcdhandle);
+const char *    fstReaderPushScope(void *ctx, const char *nam, void *user_info);
+void            fstReaderResetScope(void *ctx);
+void            fstReaderSetFacProcessMask(void *ctx, fstHandle facidx);
+void            fstReaderSetFacProcessMaskAll(void *ctx);
+void            fstReaderSetLimitTimeRange(void *ctx, uint64_t start_time, uint64_t end_time);
+void            fstReaderSetUnlimitedTimeRange(void *ctx);
+void            fstReaderSetVcdExtensions(void *ctx, int enable);
+
+
+/*
+ * utility functions
+ */
+int             fstUtilityBinToEscConvertedLen(const unsigned char *s, int len); /* used for mallocs for fstUtilityBinToEsc() */
+int             fstUtilityBinToEsc(unsigned char *d, const unsigned char *s, int len);
+int             fstUtilityEscToBin(unsigned char *d, unsigned char *s, int len);
+struct fstETab *fstUtilityExtractEnumTableFromString(const char *s);
+void 		fstUtilityFreeEnumTable(struct fstETab *etab); /* must use to free fstETab properly */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/gtkwave/lz4.h

@@ -0,0 +1,360 @@
+/*
+   LZ4 - Fast LZ compression algorithm
+   Header File
+   Copyright (C) 2011-2015, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - LZ4 source repository : https://github.com/Cyan4973/lz4
+   - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+#pragma once
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*
+ * lz4.h provides block compression functions, and gives full buffer control to programmer.
+ * If you need to generate inter-operable compressed data (respecting LZ4 frame specification),
+ * and can let the library handle its own memory, please use lz4frame.h instead.
+*/
+
+/**************************************
+*  Version
+**************************************/
+#define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
+#define LZ4_VERSION_MINOR    7    /* for new (non-breaking) interface capabilities */
+#define LZ4_VERSION_RELEASE  1    /* for tweaks, bug-fixes, or development */
+#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
+int LZ4_versionNumber (void);
+
+/**************************************
+*  Tuning parameter
+**************************************/
+/*
+ * LZ4_MEMORY_USAGE :
+ * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+ * Increasing memory usage improves compression ratio
+ * Reduced memory usage can improve speed, due to cache effect
+ * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
+ */
+#define LZ4_MEMORY_USAGE 14
+
+
+/**************************************
+*  Simple Functions
+**************************************/
+
+int LZ4_compress_default(const char* source, char* dest, int sourceSize, int maxDestSize);
+int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize);
+
+/*
+LZ4_compress_default() :
+    Compresses 'sourceSize' bytes from buffer 'source'
+    into already allocated 'dest' buffer of size 'maxDestSize'.
+    Compression is guaranteed to succeed if 'maxDestSize' >= LZ4_compressBound(sourceSize).
+    It also runs faster, so it's a recommended setting.
+    If the function cannot compress 'source' into a more limited 'dest' budget,
+    compression stops *immediately*, and the function result is zero.
+    As a consequence, 'dest' content is not valid.
+    This function never writes outside 'dest' buffer, nor read outside 'source' buffer.
+        sourceSize  : Max supported value is LZ4_MAX_INPUT_VALUE
+        maxDestSize : full or partial size of buffer 'dest' (which must be already allocated)
+        return : the number of bytes written into buffer 'dest' (necessarily <= maxOutputSize)
+              or 0 if compression fails
+
+LZ4_decompress_safe() :
+    compressedSize : is the precise full size of the compressed block.
+    maxDecompressedSize : is the size of destination buffer, which must be already allocated.
+    return : the number of bytes decompressed into destination buffer (necessarily <= maxDecompressedSize)
+             If destination buffer is not large enough, decoding will stop and output an error code (<0).
+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
+             This function is protected against buffer overflow exploits, including malicious data packets.
+             It never writes outside output buffer, nor reads outside input buffer.
+*/
+
+
+/**************************************
+*  Advanced Functions
+**************************************/
+#define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
+#define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
+
+/*
+LZ4_compressBound() :
+    Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
+    This function is primarily useful for memory allocation purposes (destination buffer size).
+    Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
+    Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
+        inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
+        return : maximum output size in a "worst case" scenario
+              or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
+*/
+int LZ4_compressBound(int inputSize);
+
+/*
+LZ4_compress_fast() :
+    Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
+    The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
+    It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
+    An acceleration value of "1" is the same as regular LZ4_compress_default()
+    Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
+*/
+int LZ4_compress_fast (const char* source, char* dest, int sourceSize, int maxDestSize, int acceleration);
+
+
+/*
+LZ4_compress_fast_extState() :
+    Same compression function, just using an externally allocated memory space to store compression state.
+    Use LZ4_sizeofState() to know how much memory must be allocated,
+    and allocate it on 8-bytes boundaries (using malloc() typically).
+    Then, provide it as 'void* state' to compression function.
+*/
+int LZ4_sizeofState(void);
+int LZ4_compress_fast_extState (void* state, const char* source, char* dest, int inputSize, int maxDestSize, int acceleration);
+
+
+/*
+LZ4_compress_destSize() :
+    Reverse the logic, by compressing as much data as possible from 'source' buffer
+    into already allocated buffer 'dest' of size 'targetDestSize'.
+    This function either compresses the entire 'source' content into 'dest' if it's large enough,
+    or fill 'dest' buffer completely with as much data as possible from 'source'.
+        *sourceSizePtr : will be modified to indicate how many bytes where read from 'source' to fill 'dest'.
+                         New value is necessarily <= old value.
+        return : Nb bytes written into 'dest' (necessarily <= targetDestSize)
+              or 0 if compression fails
+*/
+int LZ4_compress_destSize (const char* source, char* dest, int* sourceSizePtr, int targetDestSize);
+
+
+/*
+LZ4_decompress_fast() :
+    originalSize : is the original and therefore uncompressed size
+    return : the number of bytes read from the source buffer (in other words, the compressed size)
+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
+             Destination buffer must be already allocated. Its size must be a minimum of 'originalSize' bytes.
+    note : This function fully respect memory boundaries for properly formed compressed data.
+           It is a bit faster than LZ4_decompress_safe().
+           However, it does not provide any protection against intentionally modified data stream (malicious input).
+           Use this function in trusted environment only (data to decode comes from a trusted source).
+*/
+int LZ4_decompress_fast (const char* source, char* dest, int originalSize);
+
+/*
+LZ4_decompress_safe_partial() :
+    This function decompress a compressed block of size 'compressedSize' at position 'source'
+    into destination buffer 'dest' of size 'maxDecompressedSize'.
+    The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached,
+    reducing decompression time.
+    return : the number of bytes decoded in the destination buffer (necessarily <= maxDecompressedSize)
+       Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller.
+             Always control how many bytes were decoded.
+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
+             This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
+*/
+int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize);
+
+
+/***********************************************
+*  Streaming Compression Functions
+***********************************************/
+#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
+#define LZ4_STREAMSIZE     (LZ4_STREAMSIZE_U64 * sizeof(long long))
+/*
+ * LZ4_stream_t
+ * information structure to track an LZ4 stream.
+ * important : init this structure content before first use !
+ * note : only allocated directly the structure if you are statically linking LZ4
+ *        If you are using liblz4 as a DLL, please use below construction methods instead.
+ */
+typedef struct { long long table[LZ4_STREAMSIZE_U64]; } LZ4_stream_t;
+
+/*
+ * LZ4_resetStream
+ * Use this function to init an allocated LZ4_stream_t structure
+ */
+void LZ4_resetStream (LZ4_stream_t* streamPtr);
+
+/*
+ * LZ4_createStream will allocate and initialize an LZ4_stream_t structure
+ * LZ4_freeStream releases its memory.
+ * In the context of a DLL (liblz4), please use these methods rather than the static struct.
+ * They are more future proof, in case of a change of LZ4_stream_t size.
+ */
+LZ4_stream_t* LZ4_createStream(void);
+int           LZ4_freeStream (LZ4_stream_t* streamPtr);
+
+/*
+ * LZ4_loadDict
+ * Use this function to load a static dictionary into LZ4_stream.
+ * Any previous data will be forgotten, only 'dictionary' will remain in memory.
+ * Loading a size of 0 is allowed.
+ * Return : dictionary size, in bytes (necessarily <= 64 KB)
+ */
+int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
+
+/*
+ * LZ4_compress_fast_continue
+ * Compress buffer content 'src', using data from previously compressed blocks as dictionary to improve compression ratio.
+ * Important : Previous data blocks are assumed to still be present and unmodified !
+ * 'dst' buffer must be already allocated.
+ * If maxDstSize >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
+ * If not, and if compressed data cannot fit into 'dst' buffer size, compression stops, and function returns a zero.
+ */
+int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int maxDstSize, int acceleration);
+
+/*
+ * LZ4_saveDict
+ * If previously compressed data block is not guaranteed to remain available at its memory location
+ * save it into a safer place (char* safeBuffer)
+ * Note : you don't need to call LZ4_loadDict() afterwards,
+ *        dictionary is immediately usable, you can therefore call LZ4_compress_fast_continue()
+ * Return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error
+ */
+int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int dictSize);
+
+
+/************************************************
+*  Streaming Decompression Functions
+************************************************/
+
+#define LZ4_STREAMDECODESIZE_U64  4
+#define LZ4_STREAMDECODESIZE     (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
+typedef struct { unsigned long long table[LZ4_STREAMDECODESIZE_U64]; } LZ4_streamDecode_t;
+/*
+ * LZ4_streamDecode_t
+ * information structure to track an LZ4 stream.
+ * init this structure content using LZ4_setStreamDecode or memset() before first use !
+ *
+ * In the context of a DLL (liblz4) please prefer usage of construction methods below.
+ * They are more future proof, in case of a change of LZ4_streamDecode_t size in the future.
+ * LZ4_createStreamDecode will allocate and initialize an LZ4_streamDecode_t structure
+ * LZ4_freeStreamDecode releases its memory.
+ */
+LZ4_streamDecode_t* LZ4_createStreamDecode(void);
+int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
+
+/*
+ * LZ4_setStreamDecode
+ * Use this function to instruct where to find the dictionary.
+ * Setting a size of 0 is allowed (same effect as reset).
+ * Return : 1 if OK, 0 if error
+ */
+int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
+
+/*
+*_continue() :
+    These decoding functions allow decompression of multiple blocks in "streaming" mode.
+    Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB)
+    In the case of a ring buffers, decoding buffer must be either :
+    - Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
+      In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
+    - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
+      maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block.
+      In which case, encoding and decoding buffers do not need to be synchronized,
+      and encoding ring buffer can have any size, including small ones ( < 64 KB).
+    - _At least_ 64 KB + 8 bytes + maxBlockSize.
+      In which case, encoding and decoding buffers do not need to be synchronized,
+      and encoding ring buffer can have any size, including larger than decoding buffer.
+    Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
+    and indicate where it is saved using LZ4_setStreamDecode()
+*/
+int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxDecompressedSize);
+int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize);
+
+
+/*
+Advanced decoding functions :
+*_usingDict() :
+    These decoding functions work the same as
+    a combination of LZ4_setStreamDecode() followed by LZ4_decompress_x_continue()
+    They are stand-alone. They don't need nor update an LZ4_streamDecode_t structure.
+*/
+int LZ4_decompress_safe_usingDict (const char* source, char* dest, int compressedSize, int maxDecompressedSize, const char* dictStart, int dictSize);
+int LZ4_decompress_fast_usingDict (const char* source, char* dest, int originalSize, const char* dictStart, int dictSize);
+
+
+
+/**************************************
+*  Obsolete Functions
+**************************************/
+/* Deprecate Warnings */
+/* Should these warnings messages be a problem,
+   it is generally possible to disable them,
+   with -Wno-deprecated-declarations for gcc
+   or _CRT_SECURE_NO_WARNINGS in Visual for example.
+   You can also define LZ4_DEPRECATE_WARNING_DEFBLOCK. */
+#ifndef LZ4_DEPRECATE_WARNING_DEFBLOCK
+#  define LZ4_DEPRECATE_WARNING_DEFBLOCK
+#  define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#  if (LZ4_GCC_VERSION >= 405) || defined(__clang__)
+#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
+#  elif (LZ4_GCC_VERSION >= 301)
+#    define LZ4_DEPRECATED(message) __attribute__((deprecated))
+#  elif defined(_MSC_VER)
+#    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
+#  else
+#    pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
+#    define LZ4_DEPRECATED(message)
+#  endif
+#endif /* LZ4_DEPRECATE_WARNING_DEFBLOCK */
+
+/* Obsolete compression functions */
+/* These functions are planned to start generate warnings by r131 approximately */
+int LZ4_compress               (const char* source, char* dest, int sourceSize);
+int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
+int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
+int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
+int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
+int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
+
+/* Obsolete decompression functions */
+/* These function names are completely deprecated and must no longer be used.
+   They are only provided here for compatibility with older programs.
+    - LZ4_uncompress is the same as LZ4_decompress_fast
+    - LZ4_uncompress_unknownOutputSize is the same as LZ4_decompress_safe
+   These function prototypes are now disabled; uncomment them only if you really need them.
+   It is highly recommended to stop using these prototypes and migrate to maintained ones */
+/* int LZ4_uncompress (const char* source, char* dest, int outputSize); */
+/* int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize); */
+
+/* Obsolete streaming functions; use new streaming interface whenever possible */
+LZ4_DEPRECATED("use LZ4_createStream() instead") void* LZ4_create (char* inputBuffer);
+LZ4_DEPRECATED("use LZ4_createStream() instead") int   LZ4_sizeofStreamState(void);
+LZ4_DEPRECATED("use LZ4_resetStream() instead")  int   LZ4_resetStreamState(void* state, char* inputBuffer);
+LZ4_DEPRECATED("use LZ4_saveDict() instead")     char* LZ4_slideInputBuffer (void* state);
+
+/* Obsolete streaming decoding functions */
+LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
+LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
+
+
+#if defined (__cplusplus)
+}
+#endif

include/gtkwave/wavealloca.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 1999 Tony Bybell.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef WAVE_ALLOCA_H
+#define WAVE_ALLOCA_H
+#include <stdlib.h>
+#ifdef HAVE_ALLOCA_H
+#include <alloca.h>
+#elif defined(__GNUC__)
+#ifndef __MINGW32__
+#ifndef alloca
+#define alloca __builtin_alloca
+#endif
+#else
+#include <malloc.h>
+#endif
+#elif defined(_MSC_VER)
+#include <malloc.h>
+#define alloca _alloca
+#endif
+#define wave_alloca alloca
+#endif
+

include/verilated.mk.in

@@ -2,7 +2,7 @@
 ######################################################################
 # DESCRIPTION: Makefile commands for all verilated target files
 #
-# Copyright 2003-2015 by Wilson Snyder. Verilator is free software; you can
+# Copyright 2003-2019 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.
 ######################################################################
@@ -16,13 +16,20 @@ RANLIB = ranlib
 CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
 CFG_WITH_LONGTESTS = @CFG_WITH_LONGTESTS@
 
+# Select newest language
+CFG_CXXFLAGS_STD_NEWEST = @CFG_CXXFLAGS_STD_NEWEST@
+# Select oldest language (for Verilator internal testing only)
+CFG_CXXFLAGS_STD_OLDEST = @CFG_CXXFLAGS_STD_OLDEST@
 # Compiler flags to use to turn off unused and generated code warnings, such as -Wno-div-by-zero
 CFG_CXXFLAGS_NO_UNUSED = @CFG_CXXFLAGS_NO_UNUSED@
+# Compiler flags that turn on extra warnings
+CFG_CXXFLAGS_WEXTRA = @CFG_CXXFLAGS_WEXTRA@
+# Linker libraries for multithreading
+CFG_LDLIBS_THREADS = @CFG_LDLIBS_THREADS@
 
 ######################################################################
 # Programs
 
-SP_PREPROC	= sp_preproc
 SP_INCLUDER	= $(VERILATOR_INCLUDER)
 VERILATOR_COVERAGE = $(PERL) $(VERILATOR_ROOT)/bin/verilator_coverage
 VERILATOR_INCLUDER = $(PERL) $(VERILATOR_ROOT)/bin/verilator_includer
@@ -43,13 +50,13 @@ VK_CPPFLAGS_ALWAYS += \
 		-I$(VERILATOR_ROOT)/include \
 		-I$(VERILATOR_ROOT)/include/vltstd \
 		-DVL_PRINTF=printf \
-		-DVM_TRACE=$(VM_TRACE) \
 		-DVM_COVERAGE=$(VM_COVERAGE) \
+		-DVM_SC=$(VM_SC) \
+		-DVM_TRACE=$(VM_TRACE) \
 		$(CFG_CXXFLAGS_NO_UNUSED) \
 
 ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
-VK_CPPFLAGS_WALL += -Wall \
-		-Werror
+VK_CPPFLAGS_WALL += -Wall $(CFG_CXXFLAGS_WEXTRA) -Werror
 endif
 
 CPPFLAGS += -I. $(VK_CPPFLAGS_WALL) $(VK_CPPFLAGS_ALWAYS)
@@ -92,9 +99,9 @@ VM_CLASSES += $(VM_CLASSES_FAST) $(VM_CLASSES_SLOW)
 VM_SUPPORT += $(VM_SUPPORT_FAST) $(VM_SUPPORT_SLOW)
 
 #######################################################################
-##### SystemC or SystemPerl builds
+##### SystemC builds
 
-ifeq ($(VM_SP_OR_SC),1)
+ifeq ($(VM_SC),1)
   CPPFLAGS += $(SYSTEMC_CXX_FLAGS) -I$(SYSTEMC_INCLUDE)
   LDFLAGS  += $(SYSTEMC_CXX_FLAGS) -L$(SYSTEMC_LIBDIR)
   SC_LIBS   = -lsystemc
@@ -105,41 +112,39 @@ ifeq ($(VM_SP_OR_SC),1)
 endif
 
 #######################################################################
-##### SystemPerl builds
+##### Threaded builds
 
-ifeq ($(VM_SP),1)
-  CPPFLAGS += -I$(SYSTEMPERL_INCLUDE) -DSYSTEMPERL
-  VPATH    +=   $(SYSTEMPERL_INCLUDE)
-  LIBS   += -lm -lstdc++
-
-  VK_CLASSES_SP = $(addsuffix .sp, $(VM_CLASSES))
-
-  # This rule is called manually by the upper level makefile
-  preproc:
-	 @echo "      SP Preprocess" $(basename $(VM_CLASSES)) ...
-	 $(SP_PREPROC) -M sp_preproc.d --tree $(VM_PREFIX).sp_tree \
-		--preproc $(VK_CLASSES_SP)
-else
- ifeq ($(VM_COVERAGE),1)
-  CPPFLAGS += -I$(SYSTEMPERL_INCLUDE)
-  VPATH    +=   $(SYSTEMPERL_INCLUDE)
+ifneq ($(VM_THREADS),0)
+ ifneq ($(VM_THREADS),)
+  CPPFLAGS += -DVL_THREADED
+  VK_LIBS_THREADED=1
+ endif
+endif
+
+ifneq ($(VM_TRACE_THREADED),0)
+ ifneq ($(VM_TRACE_THREADED),)
+  CPPFLAGS += -DVL_TRACE_THREADED
+  VK_LIBS_THREADED=1
+ endif
+endif
+
+ifneq ($(VK_LIBS_THREADED),0)
+ ifneq ($(VK_LIBS_THREADED),)
+  # Need C++11 at least, so always default to newest
+  CPPFLAGS += $(CFG_CXXFLAGS_STD_NEWEST)
+  LDLIBS += $(CFG_LDLIBS_THREADS)
  endif
-  preproc:
 endif
 
 #######################################################################
-##### SystemC w/o SystemPerl builds
+##### Stub
 
-ifeq ($(VM_SC),1)
-  LIBS   += -lm -lstdc++
-endif
+preproc:
 
 #######################################################################
 ##### C/H builds
 
-ifeq ($(VM_PCLI),1)
-  LIBS   += -lm -lstdc++
-endif
+LIBS   += -lm -lstdc++
 
 #######################################################################
 # Overall Objects Linking
@@ -175,29 +180,44 @@ $(VM_PREFIX)__ALL.a: $(VK_OBJS)
 ######################################################################
 ### Compile rules
 
-#Default rule embedded in make:  (Not defined so user makefiles can override it)
-#.cpp.o:
-#	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -o $@ $<
+ifneq ($(VM_DEFAULT_RULES),0)
+$(VM_PREFIX)__ALLcls.o: $(VM_PREFIX)__ALLcls.cpp
+	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<
 
 $(VM_PREFIX)__ALLsup.o: $(VM_PREFIX)__ALLsup.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_SLOW) -c -o $@ $<
 
-$(VM_PREFIX)__ALLcls.o: $(VM_PREFIX)__ALLcls.cpp
+# VM_GLOBAL_FAST files including verilated.o use this rule
+%.o: %.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<
 
+%__Slow.o: %__Slow.cpp
+	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_SLOW) -c -o $@ $<
+
+endif
+
+#Default rule embedded in make:
+#.cpp.o:
+#	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -o $@ $<
+
 ######################################################################
 ### Debugging
 
 debug-make::
 	@echo
+	@echo CXXFLAGS: $(CXXFLAGS)
+	@echo CPPFLAGS: $(CPPFLAGS)
+	@echo OPT_FAST: $(OPT_FAST)
+	@echo OPT_SLOW: $(OPT_SLOW)
 	@echo VM_PREFIX:  $(VM_PREFIX)
+	@echo VM_PARALLEL_BUILDS:  $(VM_PARALLEL_BUILDS)
 	@echo VM_CLASSES_FAST: $(VM_CLASSES_FAST)
 	@echo VM_CLASSES_SLOW: $(VM_CLASSES_SLOW)
 	@echo VM_SUPPORT_FAST: $(VM_SUPPORT_FAST)
 	@echo VM_SUPPORT_SLOW: $(VM_SUPPORT_SLOW)
 	@echo VM_GLOBAL_FAST: $(VM_GLOBAL_FAST)
 	@echo VM_GLOBAL_SLOW: $(VM_GLOBAL_SLOW)
-	@echo CPPFLAGS: $(CPPFLAGS)
+	@echo VK_OBJS: $(VK_OBJS)
 	@echo
 
 ######################################################################

include/verilated.v

@@ -4,7 +4,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2019 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.
@@ -29,4 +29,4 @@
  // Hide file descriptor difference - deprecated - for older versions
  `define verilator_file_descriptor integer
 
-`endif // guard
+`endif  // guard

include/verilated_config.h.in

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2019 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.

include/verilated_cov.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2019 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.
 //
@@ -24,9 +24,9 @@
 #include "verilated_cov.h"
 #include "verilated_cov_key.h"
 
-#include <map>
 #include <deque>
 #include <fstream>
+#include <map>
 
 //=============================================================================
 // VerilatedCovImpBase
@@ -34,8 +34,8 @@
 
 struct VerilatedCovImpBase {
     // TYPES
-    enum { MAX_KEYS = 33 };		/// Maximum user arguments + filename+lineno
-    enum { KEY_UNDEF = 0 };		/// Magic key # for unspecified values
+    enum { MAX_KEYS = 33 };  /// Maximum user arguments + filename+lineno
+    enum { KEY_UNDEF = 0 };  /// Magic key # for unspecified values
 };
 
 //=============================================================================
@@ -45,15 +45,15 @@ struct VerilatedCovImpBase {
 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
+    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<MAX_KEYS; i++) {
-	    m_keys[i]=KEY_UNDEF;
-	    m_vals[i]=0;
-	}
+        for (int i=0; i<MAX_KEYS; ++i) {
+            m_keys[i] = KEY_UNDEF;
+            m_vals[i] = 0;
+        }
     }
     virtual ~VerilatedCovImpItem() {}
     virtual vluint64_t count() const = 0;
@@ -69,13 +69,15 @@ public:  // But only local to this file
 template <class T> class VerilatedCoverItemSpec : public VerilatedCovImpItem {
 private:
     // MEMBERS
-    T*	m_countp;	///< Count value
+    T*  m_countp;  ///< Count value
 public:
     // METHODS
+    // cppcheck-suppress truncLongCastReturn
     virtual vluint64_t count() const { return *m_countp; }
     virtual void zero() const { *m_countp = 0; }
     // CONSTRUCTORS
-    VerilatedCoverItemSpec(T* countp) : m_countp(countp) { zero(); }
+    // cppcheck-suppress noExplicitConstructor
+    VerilatedCoverItemSpec(T* countp) : m_countp(countp) { *m_countp = 0; }
     virtual ~VerilatedCoverItemSpec() {}
 };
 
@@ -88,363 +90,383 @@ public:
 class VerilatedCovImp : VerilatedCovImpBase {
 private:
     // TYPES
-    typedef map<string,int> ValueIndexMap;
-    typedef map<int,string> IndexValueMap;
-    typedef deque<VerilatedCovImpItem*> ItemList;
+    typedef std::map<std::string,int> ValueIndexMap;
+    typedef std::map<int,std::string> IndexValueMap;
+    typedef std::deque<VerilatedCovImpItem*> 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
+    VerilatedMutex      m_mutex;  ///< Protects all members, when VL_THREADED. Wrapper deals with setting it.
+    ValueIndexMap       m_valueIndexes VL_GUARDED_BY(m_mutex);  ///< For each key/value a unique arbitrary index value
+    IndexValueMap       m_indexValues VL_GUARDED_BY(m_mutex);  ///< For each key/value a unique arbitrary index value
+    ItemList            m_items VL_GUARDED_BY(m_mutex);  ///< 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
+    VerilatedCovImpItem* m_insertp VL_GUARDED_BY(m_mutex);  ///< Item about to insert
+    const char*         m_insertFilenamep VL_GUARDED_BY(m_mutex);  ///< Filename about to insert
+    int                 m_insertLineno VL_GUARDED_BY(m_mutex);  ///< Line number about to insert
 
     // CONSTRUCTORS
     VerilatedCovImp() {
-	m_insertp = NULL;
-	m_insertFilenamep = NULL;
-	m_insertLineno = 0;
+        m_insertp = NULL;
+        m_insertFilenamep = NULL;
+        m_insertLineno = 0;
     }
+    VL_UNCOPYABLE(VerilatedCovImp);
 public:
-    ~VerilatedCovImp() { clear(); }
-    static VerilatedCovImp& imp() {
-	static VerilatedCovImp s_singleton;
-	return s_singleton;
+    ~VerilatedCovImp() { clearGuts(); }
+    static VerilatedCovImp& imp() VL_MT_SAFE {
+        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;
+    int valueIndex(const std::string& value) VL_REQUIRES(m_mutex) {
+        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(std::make_pair(value, nextIndex));
+        m_indexValues.insert(std::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;
+    static std::string dequote(const std::string& text) VL_PURE {
+        // Quote any special characters
+        std::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;
+    static bool legalKey(const std::string& key) VL_PURE {
+        // 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;
+    static std::string keyValueFormatter(const std::string& key, const std::string& value) VL_PURE {
+        std::string name;
+        if (key.length()==1 && isalpha(key[0])) {
+            name += std::string("\001")+key;
+        } else {
+            name += std::string("\001")+dequote(key);
+        }
+        name += std::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;
+    static std::string combineHier(const std::string& old, const std::string& add) VL_PURE {
+        // (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.empty()) return add;
+        if (add.empty()) return old;
 
-	const char* a = old.c_str();
-	const char* b = add.c_str();
+        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++; }
+        // 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);
+        // We used to backup and split on only .'s but it seems better to be verbose
+        // and not assume . is the separator
+        std::string prefix = std::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--; }
+        // 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) : "";
+        // Forward to . so we have a whole word
+        std::string suffix = *bpost ? std::string(bpost+1) : "";
 
-	string out = prefix+"*"+suffix;
+        std::string out = prefix+"*"+suffix;
 
-	//cout << "\nch pre="<<prefix<<"  s="<<suffix<<"\nch a="<<old<<"\nch b="<<add<<"\nch o="<<out<<endl;
-	return out;
+        //cout << "\nch pre="<<prefix<<"  s="<<suffix<<"\nch a="<<old<<"\nch b="<<add<<"\nch o="<<out<<endl;
+        return out;
     }
-    bool itemMatchesString(VerilatedCovImpItem* itemp, const string& match) {
-	for (int i=0; i<MAX_KEYS; i++) {
-	    if (itemp->m_keys[i] != KEY_UNDEF) {
-		// We don't compare keys, only values
-		string val = m_indexValues[itemp->m_vals[i]];
-		if (string::npos != val.find(match)) {  // Found
-		    return true;
-		}
-	    }
-	}
-	return false;
+    bool itemMatchesString(VerilatedCovImpItem* itemp, const std::string& match) VL_REQUIRES(m_mutex) {
+        for (int i=0; i<MAX_KEYS; ++i) {
+            if (itemp->m_keys[i] != KEY_UNDEF) {
+                // We don't compare keys, only values
+                std::string val = m_indexValues[itemp->m_vals[i]];
+                if (std::string::npos != val.find(match)) {  // Found
+                    return true;
+                }
+            }
+        }
+        return false;
     }
-    void selftest() {
-	// Little selftest
-	if (combineHier ("a.b.c","a.b.c")	!="a.b.c") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("a.b.c","a.b")		!="a.b*") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("a.x.c","a.y.c")	!="a.*.c") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("a.z.z.z.c","a.b.c")	!="a.*.c") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("z","a")		!="*") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("q.a","q.b")		!="q.*") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("q.za","q.zb")		!="q.z*") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("1.2.3.a","9.8.7.a")	!="*.a") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
+    static void selftest() VL_MT_SAFE {
+        // Little selftest
+        if (combineHier("a.b.c","a.b.c")     !="a.b.c") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+        if (combineHier("a.b.c","a.b")       !="a.b*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+        if (combineHier("a.x.c","a.y.c")     !="a.*.c") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+        if (combineHier("a.z.z.z.c","a.b.c") !="a.*.c") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+        if (combineHier("z","a")             !="*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+        if (combineHier("q.a","q.b")         !="q.*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+        if (combineHier("q.za","q.zb")       !="q.z*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+        if (combineHier("1.2.3.a","9.8.7.a") !="*.a") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+    }
+    void clearGuts() VL_REQUIRES(m_mutex) {
+        for (ItemList::const_iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+            VerilatedCovImpItem* itemp = *(it);
+            delete itemp;
+        }
+        m_items.clear();
+        m_indexValues.clear();
+        m_valueIndexes.clear();
     }
 
 public:
     // PUBLIC METHODS
-    void clear() {
-	for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
-	    VerilatedCovImpItem* itemp = *(it);
-	    delete itemp;
-	}
-	m_items.clear();
-	m_indexValues.clear();
-	m_valueIndexes.clear();
+    void clear() VL_EXCLUDES(m_mutex) {
+        Verilated::quiesce();
+        VerilatedLockGuard lock(m_mutex);
+        clearGuts();
     }
-    void clearNonMatch (const char* matchp) {
-	if (matchp && matchp[0]) {
-	    ItemList newlist;
-	    for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
-		VerilatedCovImpItem* itemp = *(it);
-		if (!itemMatchesString(itemp, matchp)) {
-		    delete itemp;
-		} else {
-		    newlist.push_back(itemp);
-		}
-	    }
-	    m_items = newlist;
-	}
+    void clearNonMatch(const char* matchp) VL_EXCLUDES(m_mutex) {
+        Verilated::quiesce();
+        VerilatedLockGuard lock(m_mutex);
+        if (matchp && matchp[0]) {
+            ItemList newlist;
+            for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+                VerilatedCovImpItem* itemp = *(it);
+                if (!itemMatchesString(itemp, matchp)) {
+                    delete itemp;
+                } else {
+                    newlist.push_back(itemp);
+                }
+            }
+            m_items = newlist;
+        }
     }
-    void zero() {
-	for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
-	    (*it)->zero();
-	}
+    void zero() VL_EXCLUDES(m_mutex) {
+        Verilated::quiesce();
+        VerilatedLockGuard lock(m_mutex);
+        for (ItemList::const_iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+            (*it)->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 inserti(VerilatedCovImpItem* itemp) VL_EXCLUDES(m_mutex) {
+        VerilatedLockGuard lock(m_mutex);
+        assert(!m_insertp);
+        m_insertp = itemp;
     }
-    void insertf (const char* filenamep, int lineno) {
-	m_insertFilenamep = filenamep;
-	m_insertLineno = lineno;
+    void insertf(const char* filenamep, int lineno) VL_EXCLUDES(m_mutex) {
+        VerilatedLockGuard lock(m_mutex);
+        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();
+    void insertp(const char* ckeyps[MAX_KEYS],
+                 const char* valps[MAX_KEYS]) VL_EXCLUDES(m_mutex) {
+        VerilatedLockGuard lock(m_mutex);
+        assert(m_insertp);
+        // First two key/vals are filename
+        ckeyps[0]="filename";   valps[0]=m_insertFilenamep;
+        std::string linestr = vlCovCvtToStr(m_insertLineno);
+        ckeyps[1]="lineno";     valps[1]=linestr.c_str();
+        // 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++;
+        std::string page_default = "sp_user/"+std::string(fnstartp, fnendp-fnstartp);
+        ckeyps[2]="page";       valps[2]=page_default.c_str();
 
-	// Keys -> strings
-	string keys[MAX_KEYS];
-	for (int i=0; i<MAX_KEYS; i++) {
-	    if (ckeyps[i] && ckeyps[i][0]) {
-		keys[i] = ckeyps[i];
-	    }
-	}
-	// Ignore empty keys
-	for (int i=0; i<MAX_KEYS; i++) {
-	    if (keys[i]!="") {
-		for (int j=i+1; j<MAX_KEYS; j++) {
-		    if (keys[i] == keys[j]) {  // Duplicate key.  Keep the last one
-			keys[i] = "";
-			break;
-		    }
-		}
-	    }
-	}
-	// Insert the values
-	int addKeynum=0;
-	for (int i=0; i<MAX_KEYS; i++) {
-	    const string key = keys[i];
-	    if (keys[i]!="") {
-		const string val = valps[i];
-		//cout<<"   "<<__FUNCTION__<<"  "<<key<<" = "<<val<<endl;
-		m_insertp->m_keys[addKeynum] = valueIndex(key);
-		m_insertp->m_vals[addKeynum] = valueIndex(val);
-		addKeynum++;
-		if (!legalKey(key)) {
-		    string msg = "%Error: Coverage keys of one character, or letter+digit are illegal: "+key;
-		    vl_fatal("",0,"",msg.c_str());
-		}
-	    }
-	}
-	m_items.push_back(m_insertp);
-	// Prepare for next
-	m_insertp = NULL;
+        // Keys -> strings
+        std::string keys[MAX_KEYS];
+        for (int i=0; i<MAX_KEYS; ++i) {
+            if (ckeyps[i] && ckeyps[i][0]) {
+                keys[i] = ckeyps[i];
+            }
+        }
+        // Ignore empty keys
+        for (int i=0; i<MAX_KEYS; ++i) {
+            if (!keys[i].empty()) {
+                for (int j=i+1; j<MAX_KEYS; ++j) {
+                    if (keys[i] == keys[j]) {  // Duplicate key.  Keep the last one
+                        keys[i] = "";
+                        break;
+                    }
+                }
+            }
+        }
+        // Insert the values
+        int addKeynum = 0;
+        for (int i=0; i<MAX_KEYS; ++i) {
+            const std::string key = keys[i];
+            if (!keys[i].empty()) {
+                const std::string val = valps[i];
+                //cout<<"   "<<__FUNCTION__<<"  "<<key<<" = "<<val<<endl;
+                m_insertp->m_keys[addKeynum] = valueIndex(key);
+                m_insertp->m_vals[addKeynum] = valueIndex(val);
+                addKeynum++;
+                if (!legalKey(key)) {
+                    std::string msg
+                        = ("%Error: Coverage keys of one character, or letter+digit are illegal: "
+                           +key);
+                    VL_FATAL_MT("", 0, "", msg.c_str());
+                }
+            }
+        }
+        m_items.push_back(m_insertp);
+        // Prepare for next
+        m_insertp = NULL;
     }
 
-    void write (const char* filename) {
+    void write(const char* filename) VL_EXCLUDES(m_mutex) {
+        Verilated::quiesce();
+        VerilatedLockGuard lock(m_mutex);
 #ifndef VM_COVERAGE
-	vl_fatal("",0,"","%Error: Called VerilatedCov::write when VM_COVERAGE disabled\n");
+        VL_FATAL_MT("", 0, "", "%Error: Called VerilatedCov::write when VM_COVERAGE disabled\n");
 #endif
-	selftest();
+        selftest();
 
-	ofstream os (filename);
-	if (os.fail()) {
-	    string msg = (string)"%Error: Can't write '"+filename+"'";
-	    vl_fatal("",0,"",msg.c_str());
-	    return;
-	}
-	os << "# SystemC::Coverage-3\n";
+        std::ofstream os(filename);
+        if (os.fail()) {
+            std::string msg = std::string("%Error: Can't write '")+filename+"'";
+            VL_FATAL_MT("", 0, "", msg.c_str());
+            return;
+        }
+        os << "# SystemC::Coverage-3\n";
 
-	// Build list of events; totalize if collapsing hierarchy
-	typedef map<string,pair<string,vluint64_t> >	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;
+        // Build list of events; totalize if collapsing hierarchy
+        typedef std::map<std::string,std::pair<std::string,vluint64_t> > EventMap;
+        EventMap eventCounts;
+        for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+            VerilatedCovImpItem* itemp = *(it);
+            std::string name;
+            std::string hier;
+            bool per_instance = false;
 
-	    for (int i=0; i<MAX_KEYS; i++) {
-		if (itemp->m_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 = "";
-	    }
+            for (int i=0; i<MAX_KEYS; ++i) {
+                if (itemp->m_keys[i] != KEY_UNDEF) {
+                    std::string key = VerilatedCovKey::shortKey(m_indexValues[itemp->m_keys[i]]);
+                    std::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)
+            // 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())));
-	    }
-	}
+            // Find or insert the named event
+            EventMap::iterator cit = eventCounts.find(name);
+            if (cit != eventCounts.end()) {
+                const std::string& oldhier = cit->second.first;
+                cit->second.second += itemp->count();
+                cit->second.first  = combineHier(oldhier, hier);
+            } else {
+                eventCounts.insert(std::make_pair(name, make_pair(hier, itemp->count())));
+            }
+        }
 
-	// Output body
-	for (EventMap::iterator it=eventCounts.begin(); it!=eventCounts.end(); ++it) {
-	    os<<"C '"<<dec;
-	    os<<it->first;
-	    if (it->second.first != "") os<<keyValueFormatter(VL_CIK_HIER,it->second.first);
-	    os<<"' "<<it->second.second;
-	    os<<endl;
-	}
+        // Output body
+        for (EventMap::const_iterator it=eventCounts.begin(); it!=eventCounts.end(); ++it) {
+            os<<"C '"<<std::dec;
+            os<<it->first;
+            if (!it->second.first.empty()) os<<keyValueFormatter(VL_CIK_HIER, it->second.first);
+            os<<"' "<<it->second.second;
+            os<<std::endl;
+        }
     }
 };
 
 //=============================================================================
 // VerilatedCov
 
-void VerilatedCov::clear() {
+void VerilatedCov::clear() VL_MT_SAFE {
     VerilatedCovImp::imp().clear();
 }
-void VerilatedCov::clearNonMatch (const char* matchp) {
+void VerilatedCov::clearNonMatch(const char* matchp) VL_MT_SAFE {
     VerilatedCovImp::imp().clearNonMatch(matchp);
 }
-void VerilatedCov::zero() {
+void VerilatedCov::zero() VL_MT_SAFE {
     VerilatedCovImp::imp().zero();
 }
-void VerilatedCov::write (const char* filenamep) {
+void VerilatedCov::write(const char* filenamep) VL_MT_SAFE {
     VerilatedCovImp::imp().write(filenamep);
 }
-void VerilatedCov::_inserti (vluint32_t* itemp) {
+void VerilatedCov::_inserti(vluint32_t* itemp) VL_MT_SAFE {
     VerilatedCovImp::imp().inserti(new VerilatedCoverItemSpec<vluint32_t>(itemp));
 }
-void VerilatedCov::_inserti (vluint64_t* itemp) {
+void VerilatedCov::_inserti(vluint64_t* itemp) VL_MT_SAFE {
     VerilatedCovImp::imp().inserti(new VerilatedCoverItemSpec<vluint64_t>(itemp));
 }
-void VerilatedCov::_insertf (const char* filename, int lineno) {
-    VerilatedCovImp::imp().insertf(filename,lineno);
+void VerilatedCov::_insertf(const char* filename, int lineno) VL_MT_SAFE {
+    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)) {
+#define A(n) const char* key ## n, const char* valp ## n  // Argument list
+#define C(n) key ## n, valp ## 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)) VL_MT_SAFE {
     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};
+        = {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};
+        = {NULL,NULL,NULL,  // filename,lineno,page
+           valp0,valp1,valp2,valp3,valp4,valp5,valp6,valp7,valp8,valp9,
+           valp10,valp11,valp12,valp13,valp14,valp15,valp16,valp17,valp18,valp19,
+           valp20,valp21,valp22,valp23,valp24,valp25,valp26,valp27,valp28,valp29};
     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)) {
+void VerilatedCov::_insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)) VL_MT_SAFE {
     _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));
+             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)) {
+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)) VL_MT_SAFE {
     _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));
+             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)) {
+void VerilatedCov::_insertp(A(0), A(1),  K(2),int val2,  K(3),int val3,
+                            K(4),const std::string& val4,  A(5),A(6)) VL_MT_SAFE {
+    std::string val2str = vlCovCvtToStr(val2);
+    std::string val3str = vlCovCvtToStr(val3);
     _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));
+             key2,val2str.c_str(),  key3,val3str.c_str(),  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

include/verilated_cov.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2019 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.
 //
@@ -27,7 +27,6 @@
 #include <iostream>
 #include <sstream>
 #include <string>
-using namespace std;
 
 //=============================================================================
 /// Conditionally compile coverage code
@@ -45,100 +44,89 @@ using namespace std;
 /// 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.
+///     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; }
+///     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));
 ///     }
-///	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))
+    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<<t; return os.str();
+template< class T> std::string vlCovCvtToStr(const T& t) VL_PURE {
+    std::ostringstream os; os<<t; return os.str();
 }
 
-/// Usage: something(VlCovCvtToCStr(i))
-/// Note the pointer will only be valid for as long as the object remains
-/// in scope!
-struct VlCovCvtToCStr {
-    string m_str;
-    // Casters
-    template< class T> VlCovCvtToCStr (const T& t) {
-	ostringstream os; os<<t; m_str=os.str();
-    }
-    ~VlCovCvtToCStr() {}
-    operator const char* () const { return m_str.c_str(); };
-};
-
 //=============================================================================
 //  VerilatedCov
 ///  Verilator coverage global class
 ////
 /// Global class with methods affecting all coverage data.
+/// All public methods in this class are thread safe.
 
 class VerilatedCov {
+    VL_UNCOPYABLE(VerilatedCov);
 public:
     // GLOBAL METHODS
     /// Return default filename
-    static const char* defaultFilename() { return "coverage.dat"; }
+    static const char* defaultFilename() VL_PURE { return "coverage.dat"; }
     /// Write all coverage data to a file
-    static void write (const char* filenamep = defaultFilename());
+    static void write(const char* filenamep = defaultFilename()) VL_MT_SAFE;
     /// Insert a coverage item
     /// We accept from 1-30 key/value pairs, all as strings.
     /// Call _insert1, followed by _insert2 and _insert3
     /// Do not call directly; use VL_COVER_INSERT or higher level macros instead
     // _insert1: Remember item pointer with count.  (Not const, as may add zeroing function)
-    static void _inserti (vluint32_t* itemp);
-    static void _inserti (vluint64_t* itemp);
+    static void _inserti(vluint32_t* itemp) VL_MT_SAFE;
+    static void _inserti(vluint64_t* itemp) VL_MT_SAFE;
     // _insert2: Set default filename and line number
-    static void _insertf (const char* filename, int lineno);
+    static void _insertf(const char* filename, int lineno) VL_MT_SAFE;
     // _insert3: Set parameters
     // We could have just the maximum argument version, but this compiles
     // much slower (nearly 2x) than having smaller versions also.  However
     // there's not much more gain in having a version for each number of args.
 #define K(n) const char* key ## n
-#define A(n) const char* key ## n, const char* valp ## n	// Argument list
-#define D(n) const char* key ## n = NULL, const char* valp ## n = NULL	// Argument list
-    static void _insertp (D(0),D(1),D(2),D(3),D(4),D(5),D(6),D(7),D(8),D(9));
-    static void _insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)
-			  ,A(10),D(11),D(12),D(13),D(14),D(15),D(16),D(17),D(18),D(19));
-    static void _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),D(21),D(22),D(23),D(24),D(25),D(26),D(27),D(28),D(29));
+#define A(n) const char* key ## n, const char* valp ## n  // Argument list
+#define D(n) const char* key ## n = NULL, const char* valp ## n = NULL  // Argument list
+    static void _insertp(D(0),D(1),D(2),D(3),D(4),D(5),D(6),D(7),D(8),D(9));
+    static void _insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)
+                         ,A(10),D(11),D(12),D(13),D(14),D(15),D(16),D(17),D(18),D(19));
+    static void _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),D(21),D(22),D(23),D(24),D(25),D(26),D(27),D(28),D(29));
     // Backward compatibility for Verilator
-    static void _insertp (A(0), A(1),  K(2),int val2,  K(3),int val3,
-			  K(4),const string& val4,  A(5),A(6));
+    static void _insertp(A(0), A(1),  K(2),int val2,  K(3),int val3,
+                         K(4),const std::string& val4,  A(5),A(6));
 
 #undef K
 #undef A
 #undef D
     /// Clear coverage points (and call delete on all items)
-    static void clear();
+    static void clear() VL_MT_SAFE;
     /// Clear items not matching the provided string
-    static void clearNonMatch (const char* matchp);
+    static void clearNonMatch(const char* matchp) VL_MT_SAFE;
     /// Zero coverage points
-    static void zero();
+    static void zero() VL_MT_SAFE;
 };
 
-#endif // guard
+#endif  // Guard

include/verilated_cov_key.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2019 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.
 //
@@ -25,7 +25,6 @@
 #include "verilatedos.h"
 
 #include <string>
-using namespace std;
 
 //=============================================================================
 // Data used to edit below file, using vlcovgen
@@ -64,12 +63,6 @@ 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
-///  Verilator 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"
@@ -103,43 +96,48 @@ VLCOVGEN_ITEM("name=>'weight',      short=>'w',  group=>0, default=>undef, descr
 #define VL_CIK_WEIGHT "w"
 // VLCOVGEN_CIK_AUTO_EDIT_END
 
+//=============================================================================
+// VerilatedCovKey
+/// Verilator coverage global class.
+/// This class is thread safe.
+
 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;
+    static std::string shortKey(const std::string& key) VL_PURE {
+        // 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
+#endif  // guard

include/verilated_dpi.cpp

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2015 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2019 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.
@@ -16,21 +16,24 @@
 /// \file
 /// \brief Verilator: DPI implementation code
 ///
-///	This file must be compiled and linked against all objects
-///	created from Verilator or called by Verilator that use the DPI.
+///     This file must be compiled and linked against all objects
+///     created from Verilator or called by Verilator that use the DPI.
 ///
 /// Code available from: http://www.veripool.org/verilator
 ///
 //=========================================================================
 
 #define _VERILATED_DPI_CPP_
+
 #include "verilatedos.h"
 #include "verilated_dpi.h"
 #include "verilated_imp.h"
 
 // On MSVC++ we need svdpi.h to declare exports, not imports
 #define DPI_PROTOTYPES
+#undef XXTERN
 #define XXTERN DPI_EXTERN DPI_DLLESPEC
+#undef EETERN
 #define EETERN DPI_EXTERN DPI_DLLESPEC
 
 #include "vltstd/svdpi.h"
@@ -40,11 +43,14 @@
 
 // Not supported yet
 #define _VL_SVDPI_UNIMP() \
-    vl_fatal(__FILE__,__LINE__,"",(string("%%Error: Unsupported DPI function: ")+VL_FUNC).c_str())
+    VL_FATAL_MT(__FILE__,__LINE__,"",(std::string("%%Error: Unsupported DPI function: ")+VL_FUNC).c_str())
+
+#define _VL_SVDPI_WARN(message...) \
+    VL_PRINTF_MT(message)
 
 // Function requires a "context" in the import declaration
 #define _VL_SVDPI_CONTEXT_WARN() \
-    VL_PRINTF("%%Warning: DPI C Function called by Verilog DPI import with missing 'context' keyword.\n");
+    _VL_SVDPI_WARN("%%Warning: DPI C Function called by Verilog DPI import with missing 'context' keyword.\n");
 
 //======================================================================
 //======================================================================
@@ -58,197 +64,661 @@ const char* svDpiVersion() {
 //======================================================================
 // Bit-select utility functions.
 
-svBit svGetBitselBit(const svBitVecVal* s, int i) {
-    _VL_SVDPI_UNIMP(); return 0;
+svBit svGetBitselBit(const svBitVecVal* sp, int bit) {
+    return VL_BITRSHIFT_W(sp,bit) & 1;
 }
-svLogic svGetBitselLogic(const svLogicVecVal* s, int i) {
-    _VL_SVDPI_UNIMP(); return 0;
+svLogic svGetBitselLogic(const svLogicVecVal* sp, int bit) {
+    // Not VL_BITRSHIFT_W as sp is a different structure type
+    // Verilator doesn't support X/Z so only aval
+    return (((sp[VL_BITWORD_I(bit)].aval >> VL_BITBIT_I(bit)) & 1)
+            | (((sp[VL_BITWORD_I(bit)].bval >> VL_BITBIT_I(bit)) & 1)<<1));
 }
 
-void svPutBitselBit(svBitVecVal* d, int i, svBit s) {
-    _VL_SVDPI_UNIMP();
+void svPutBitselBit(svBitVecVal* dp, int bit, svBit s) {
+    VL_ASSIGNBIT_WI(32, bit, dp, s);
 }
-void svPutBitselLogic(svLogicVecVal* d, int i, svLogic s) {
-    _VL_SVDPI_UNIMP();
+void svPutBitselLogic(svLogicVecVal* dp, int bit, svLogic s) {
+    // Verilator doesn't support X/Z so only aval
+    dp[VL_BITWORD_I(bit)].aval
+        = ((dp[VL_BITWORD_I(bit)].aval & ~(VL_UL(1)<<VL_BITBIT_I(bit)))
+           | ((s&1)<<VL_BITBIT_I(bit)));
+    dp[VL_BITWORD_I(bit)].bval
+        = ((dp[VL_BITWORD_I(bit)].bval & ~(VL_UL(1)<<VL_BITBIT_I(bit)))
+           | ((s&2)>>1<<VL_BITBIT_I(bit)));
 }
 
-void svGetPartselBit(svBitVecVal* d, const svBitVecVal* s, int i, int w) {
-    _VL_SVDPI_UNIMP();
+void svGetPartselBit(svBitVecVal* dp, const svBitVecVal* sp, int lsb, int width) {
+    // See also VL_SEL_WWI
+    int msb = lsb+width-1;
+    int word_shift = VL_BITWORD_I(lsb);
+    if (VL_BITBIT_I(lsb)==0) {
+        // Just a word extract
+        for (int i=0; i<VL_WORDS_I(width); ++i) dp[i] = sp[i+word_shift];
+    } else {
+        int loffset = lsb & VL_SIZEBITS_I;
+        int nbitsfromlow = 32-loffset;  // bits that end up in lword (know loffset!=0)
+        // Middle words
+        int words = VL_WORDS_I(msb-lsb+1);
+        for (int i=0; i<words; ++i) {
+            dp[i] = sp[i+word_shift]>>loffset;
+            int upperword = i+word_shift+1;
+            if (upperword <= static_cast<int>(VL_BITWORD_I(msb))) {
+                dp[i] |= sp[upperword] << nbitsfromlow;
+            }
+        }
+    }
+    // Clean result
+    dp[VL_WORDS_I(width)-1] &= VL_MASK_I(width);
 }
-void svGetPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w) {
-    _VL_SVDPI_UNIMP();
+void svGetPartselLogic(svLogicVecVal* dp, const svLogicVecVal* sp, int lsb, int width) {
+    int msb = lsb+width-1;
+    int word_shift = VL_BITWORD_I(lsb);
+    if (VL_BITBIT_I(lsb)==0) {
+        // Just a word extract
+        for (int i=0; i<VL_WORDS_I(width); ++i) dp[i] = sp[i+word_shift];
+    } else {
+        int loffset = lsb & VL_SIZEBITS_I;
+        int nbitsfromlow = 32-loffset;  // bits that end up in lword (know loffset!=0)
+        // Middle words
+        int words = VL_WORDS_I(msb-lsb+1);
+        for (int i=0; i<words; ++i) {
+            dp[i].aval = sp[i+word_shift].aval >> loffset;
+            dp[i].bval = sp[i+word_shift].bval >> loffset;
+            int upperword = i+word_shift+1;
+            if (upperword <= static_cast<int>(VL_BITWORD_I(msb))) {
+                dp[i].aval |= sp[upperword].aval << nbitsfromlow;
+                dp[i].bval |= sp[upperword].bval << nbitsfromlow;
+            }
+        }
+    }
+    // Clean result
+    dp[VL_WORDS_I(width)-1].aval &= VL_MASK_I(width);
+    dp[VL_WORDS_I(width)-1].bval &= VL_MASK_I(width);
+}
+void svPutPartselBit(svBitVecVal* dp, const svBitVecVal s, int lbit, int width) {
+    // See also _VL_INSERT_WI
+    int hbit = lbit+width-1;
+    int hoffset = VL_BITBIT_I(hbit);
+    int loffset = VL_BITBIT_I(lbit);
+    if (hoffset==VL_SIZEBITS_I && loffset==0) {
+        // Fast and common case, word based insertion
+        dp[VL_BITWORD_I(lbit)] = s;
+    }
+    else {
+        int hword = VL_BITWORD_I(hbit);
+        int lword = VL_BITWORD_I(lbit);
+        if (hword==lword) {  // know < 32 bits because above checks it
+            IData insmask = (VL_MASK_I(hoffset-loffset+1))<<loffset;
+            dp[lword] = (dp[lword] & ~insmask) | ((s<<loffset) & insmask);
+        } else {
+            IData hinsmask = (VL_MASK_I(hoffset-0+1))<<0;
+            IData linsmask = (VL_MASK_I(31-loffset+1))<<loffset;
+            int nbitsonright = 32-loffset;  // bits that end up in lword
+            dp[lword] = (dp[lword] & ~linsmask) | ((s<<loffset) & linsmask);
+            dp[hword] = (dp[hword] & ~hinsmask) | ((s>>nbitsonright) & hinsmask);
+        }
+    }
+}
+// cppcheck-suppress passedByValue
+void svPutPartselLogic(svLogicVecVal* dp, const svLogicVecVal s, int lbit, int width) {
+    int hbit = lbit+width-1;
+    int hoffset = VL_BITBIT_I(hbit);
+    int loffset = VL_BITBIT_I(lbit);
+    if (hoffset==VL_SIZEBITS_I && loffset==0) {
+        // Fast and common case, word based insertion
+        dp[VL_BITWORD_I(lbit)].aval = s.aval;
+        dp[VL_BITWORD_I(lbit)].bval = s.bval;
+    }
+    else {
+        int hword = VL_BITWORD_I(hbit);
+        int lword = VL_BITWORD_I(lbit);
+        if (hword==lword) {  // know < 32 bits because above checks it
+            IData insmask = (VL_MASK_I(hoffset-loffset+1))<<loffset;
+            dp[lword].aval = (dp[lword].aval & ~insmask) | ((s.aval<<loffset) & insmask);
+            dp[lword].bval = (dp[lword].bval & ~insmask) | ((s.bval<<loffset) & insmask);
+        } else {
+            IData hinsmask = (VL_MASK_I(hoffset-0+1))<<0;
+            IData linsmask = (VL_MASK_I(31-loffset+1))<<loffset;
+            int nbitsonright = 32-loffset;  // bits that end up in lword
+            dp[lword].aval = (dp[lword].aval & ~linsmask) | ((s.aval<<loffset) & linsmask);
+            dp[lword].bval = (dp[lword].bval & ~linsmask) | ((s.bval<<loffset) & linsmask);
+            dp[hword].aval = (dp[hword].aval & ~hinsmask) | ((s.aval>>nbitsonright) & hinsmask);
+            dp[hword].bval = (dp[hword].bval & ~hinsmask) | ((s.bval>>nbitsonright) & hinsmask);
+        }
+    }
 }
 
-void svPutPartselBit(svBitVecVal* d, const svBitVecVal s, int i, int w) {
-    _VL_SVDPI_UNIMP();
-}
-void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w) {
-    _VL_SVDPI_UNIMP();
+//======================================================================
+// Open array internals
+
+static inline const VerilatedDpiOpenVar* _vl_openhandle_varp(const svOpenArrayHandle h) {
+    if (VL_UNLIKELY(!h)) {
+        VL_FATAL_MT(__FILE__, __LINE__, "",
+                    "%%Error: DPI svOpenArrayHandle function called with NULL handle");
+    }
+    const VerilatedDpiOpenVar* varp = reinterpret_cast<const VerilatedDpiOpenVar*>(h);
+    if (VL_UNLIKELY(!varp->magicOk())) {
+        VL_FATAL_MT(__FILE__, __LINE__, "",
+                    "%%Error: DPI svOpenArrayHandle function called with non-Verilator handle");
+    }
+    return varp;
 }
 
 //======================================================================
 // Open array querying functions
 
 int svLeft(const svOpenArrayHandle h, int d) {
-    _VL_SVDPI_UNIMP(); return 0;
+    return _vl_openhandle_varp(h)->left(d);
 }
 int svRight(const svOpenArrayHandle h, int d) {
-    _VL_SVDPI_UNIMP(); return 0;
+    return _vl_openhandle_varp(h)->right(d);
 }
 int svLow(const svOpenArrayHandle h, int d) {
-    _VL_SVDPI_UNIMP(); return 0;
+    return _vl_openhandle_varp(h)->low(d);
 }
 int svHigh(const svOpenArrayHandle h, int d) {
-    _VL_SVDPI_UNIMP(); return 0;
+    return _vl_openhandle_varp(h)->high(d);
 }
 int svIncrement(const svOpenArrayHandle h, int d) {
-    _VL_SVDPI_UNIMP(); return 0;
+    return _vl_openhandle_varp(h)->increment(d);
+}
+int svSize(const svOpenArrayHandle h, int d) {
+    return _vl_openhandle_varp(h)->elements(d);
 }
 int svDimensions(const svOpenArrayHandle h) {
-    _VL_SVDPI_UNIMP(); return 0;
+    return _vl_openhandle_varp(h)->udims();
 }
-
-void *svGetArrayPtr(const svOpenArrayHandle) {
-    _VL_SVDPI_UNIMP(); return NULL;
+/// Return pointer to open array data, or NULL if not in IEEE standard C layout
+void* svGetArrayPtr(const svOpenArrayHandle h) {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h);
+    if (VL_UNLIKELY(!varp->isDpiStdLayout())) return NULL;
+    return varp->datap();
 }
-
-int svSizeOfArray(const svOpenArrayHandle) {
-    _VL_SVDPI_UNIMP(); return 0;
-}
-
-void *svGetArrElemPtr(const svOpenArrayHandle, int indx1, ...) {
-    _VL_SVDPI_UNIMP(); return NULL;
-}
-void *svGetArrElemPtr1(const svOpenArrayHandle, int indx1) {
-    _VL_SVDPI_UNIMP(); return NULL;
-}
-void *svGetArrElemPtr2(const svOpenArrayHandle, int indx1, int indx2) {
-    _VL_SVDPI_UNIMP(); return NULL;
-}
-void *svGetArrElemPtr3(const svOpenArrayHandle, int indx1, int indx2, int indx3) {
-    _VL_SVDPI_UNIMP(); return NULL;
+/// Return size of open array, or 0 if not in IEEE standard C layout
+int svSizeOfArray(const svOpenArrayHandle h) {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h);
+    if (VL_UNLIKELY(!varp->isDpiStdLayout())) return 0;
+    // Truncate 64 bits to int; DPI is limited to 4GB
+    return static_cast<int>(varp->totalSize());
 }
 
 //======================================================================
-// s=source, d=destination
-// From user space into simulator storage
+// Open array access internals
+
+static void* _vl_sv_adjusted_datap(const VerilatedDpiOpenVar* varp,
+                                   int nargs, int indx1, int indx2, int indx3) {
+    void* datap = varp->datap();
+    if (VL_UNLIKELY(nargs != varp->udims())) {
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function called on"
+                       " %d dimensional array using %d dimensional function.\n",
+                       varp->udims(), nargs);
+        return NULL;
+    }
+    if (nargs>=1) {
+        datap = varp->datapAdjustIndex(datap, 1, indx1);
+        if (VL_UNLIKELY(!datap)) {
+            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 1 out of bounds; %d outside [%d:%d].\n",
+                           indx1, varp->left(1), varp->right(1));
+            return NULL;
+        }
+    }
+    if (nargs>=2) {
+        datap = varp->datapAdjustIndex(datap, 2, indx2);
+        if (VL_UNLIKELY(!datap)) {
+            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 2 out of bounds; %d outside [%d:%d].\n",
+                           indx2, varp->left(2), varp->right(2));
+            return NULL;
+        }
+    }
+    if (nargs>=3) {
+        datap = varp->datapAdjustIndex(datap, 3, indx3);
+        if (VL_UNLIKELY(!datap)) {
+            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 3 out of bounds; %d outside [%d:%d].\n",
+                           indx1, varp->left(3), varp->right(3));
+            return NULL;
+        }
+    }
+    return datap;
+}
+
+static int _vl_sv_adjusted_bit(const VerilatedDpiOpenVar* varp, int indx) {
+    if (VL_UNLIKELY(indx < varp->low(0) || indx > varp->high(0))) {
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function packed index out of bounds; %d outside [%d:%d].\n",
+                       indx, varp->left(0), varp->right(0));
+        return 0;
+    }
+    return indx - varp->low(0);
+}
+
+/// Return pointer to simulator open array element, or NULL if outside range
+static void* _vl_svGetArrElemPtr(const svOpenArrayHandle h,
+                                 int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h);
+    if (VL_UNLIKELY(!varp->isDpiStdLayout())) return NULL;
+    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+    return datap;
+}
+
+/// Copy to user bit array from simulator open array
+static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
+                                      int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
+    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+    if (VL_UNLIKELY(!datap)) return;
+    switch (varp->vltype()) {
+    case VLVT_UINT8:  d[0] = *(reinterpret_cast<CData*>(datap)); return;
+    case VLVT_UINT16: d[0] = *(reinterpret_cast<SData*>(datap)); return;
+    case VLVT_UINT32: d[0] = *(reinterpret_cast<IData*>(datap)); return;
+    case VLVT_UINT64: {
+        WData lwp[2]; VL_SET_WQ(lwp, *(reinterpret_cast<QData*>(datap)));
+        d[0] = lwp[0]; d[1] = lwp[1];
+        break;
+    }
+    case VLVT_WDATA: {
+        WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
+        for (int i=0; i<VL_WORDS_I(varp->packed().elements()); ++i) d[i] = wdatap[i];
+        return;
+    }
+    default:
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+                       varp->vltype());
+        return;
+    }
+}
+/// Copy to user logic array from simulator open array
+static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s,
+                                        int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
+    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+    if (VL_UNLIKELY(!datap)) return;
+    switch (varp->vltype()) {
+    case VLVT_UINT8:  d[0].aval = *(reinterpret_cast<CData*>(datap)); d[0].bval=0; return;
+    case VLVT_UINT16: d[0].aval = *(reinterpret_cast<SData*>(datap)); d[0].bval=0; return;
+    case VLVT_UINT32: d[0].aval = *(reinterpret_cast<IData*>(datap)); d[0].bval=0; return;
+    case VLVT_UINT64: {
+        WData lwp[2]; VL_SET_WQ(lwp, *(reinterpret_cast<QData*>(datap)));
+        d[0].aval = lwp[0]; d[0].bval=0;
+        d[1].aval = lwp[1]; d[0].bval=0;
+        break;
+    }
+    case VLVT_WDATA: {
+        WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
+        for (int i=0; i<VL_WORDS_I(varp->packed().elements()); ++i) {
+            d[i].aval = wdatap[i]; d[i].bval = 0;
+        }
+        return;
+    }
+    default:
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+                       varp->vltype());
+        return;
+    }
+}
+
+/// Copy to simulator open array from from user bit array
+static void _vl_svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s,
+                                      int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
+    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+    if (VL_UNLIKELY(!datap)) return;
+    switch (varp->vltype()) {
+    case VLVT_UINT8:  *(reinterpret_cast<CData*>(datap)) = s[0]; return;
+    case VLVT_UINT16: *(reinterpret_cast<SData*>(datap)) = s[0]; return;
+    case VLVT_UINT32: *(reinterpret_cast<IData*>(datap)) = s[0]; return;
+    case VLVT_UINT64: *(reinterpret_cast<QData*>(datap)) = _VL_SET_QII(s[1], s[0]); break;
+    case VLVT_WDATA: {
+        WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
+        for (int i=0; i<VL_WORDS_I(varp->packed().elements()); ++i) wdatap[i] = s[i];
+        return;
+    }
+    default:
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+                       varp->vltype());
+        return;
+    }
+}
+/// Copy to simulator open array from from user logic array
+static void _vl_svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
+                                        int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
+    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+    if (VL_UNLIKELY(!datap)) return;
+    switch (varp->vltype()) {
+    case VLVT_UINT8:  *(reinterpret_cast<CData*>(datap)) = s[0].aval; return;
+    case VLVT_UINT16: *(reinterpret_cast<SData*>(datap)) = s[0].aval; return;
+    case VLVT_UINT32: *(reinterpret_cast<IData*>(datap)) = s[0].aval; return;
+    case VLVT_UINT64: *(reinterpret_cast<QData*>(datap)) = _VL_SET_QII(s[1].aval, s[0].aval); break;
+    case VLVT_WDATA: {
+        WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
+        for (int i=0; i<VL_WORDS_I(varp->packed().elements()); ++i) wdatap[i] = s[i].aval;
+        return;
+    }
+    default:
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype());
+        return;
+    }
+}
+
+/// Return bit from simulator open array
+static svBit _vl_svGetBitArrElem(const svOpenArrayHandle s,
+                                 int nargs, int indx1, int indx2, int indx3, int indx4) VL_MT_SAFE {
+    // One extra index supported, as need bit number
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
+    void* datap;
+    int lsb;
+    if (varp->packed().elements()) {
+        datap = _vl_sv_adjusted_datap(varp, nargs-1, indx1, indx2, indx3);
+        lsb = _vl_sv_adjusted_bit(varp, ((nargs==1) ? indx1
+                                         : (nargs==2) ? indx2
+                                         : (nargs==3) ? indx3
+                                         : indx4));
+    } else {
+        datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+        lsb = 0;
+    }
+    if (VL_UNLIKELY(!datap)) return 0;
+    switch (varp->vltype()) {
+    case VLVT_UINT8:  return (*(reinterpret_cast<CData*>(datap)) >> lsb) & 1;
+    case VLVT_UINT16: return (*(reinterpret_cast<SData*>(datap)) >> lsb) & 1;
+    case VLVT_UINT32: return (*(reinterpret_cast<IData*>(datap)) >> lsb) & 1;
+    case VLVT_UINT64: return (*(reinterpret_cast<QData*>(datap)) >> static_cast<QData>(lsb)) & VL_ULL(1);
+    case VLVT_WDATA: {
+        WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
+        return VL_BITRSHIFT_W(wdatap, lsb) & 1;
+    }
+    default:
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype());
+        return 0;
+    }
+}
+/// Update simulator open array from bit
+static void _vl_svPutBitArrElem(const svOpenArrayHandle d, svBit value,
+                                int nargs, int indx1, int indx2, int indx3, int indx4) VL_MT_SAFE {
+    // One extra index supported, as need bit number
+    value &= 1;  // Make sure clean
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
+    void* datap;
+    int lsb;
+    if (varp->packed().elements()) {
+        datap = _vl_sv_adjusted_datap(varp, nargs-1, indx1, indx2, indx3);
+        lsb = _vl_sv_adjusted_bit(varp, ((nargs==1) ? indx1
+                                         : (nargs==2) ? indx2
+                                         : (nargs==3) ? indx3
+                                         : indx4));
+    } else {
+        datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+        lsb = 0;
+    }
+    if (VL_UNLIKELY(!datap)) return;
+    switch (varp->vltype()) {
+    case VLVT_UINT8:  VL_ASSIGNBIT_II(-1, lsb, *(reinterpret_cast<CData*>(datap)), value); return;
+    case VLVT_UINT16: VL_ASSIGNBIT_II(-1, lsb, *(reinterpret_cast<SData*>(datap)), value); return;
+    case VLVT_UINT32: VL_ASSIGNBIT_II(-1, lsb, *(reinterpret_cast<IData*>(datap)), value); return;
+    case VLVT_UINT64: VL_ASSIGNBIT_QI(-1, lsb, *(reinterpret_cast<QData*>(datap)), value); return;
+    case VLVT_WDATA:  VL_ASSIGNBIT_WI(-1, lsb, (reinterpret_cast<WDataOutP>(datap)), value); return;
+    default:
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype());
+        return;
+    }
+}
+
+//======================================================================
+// DPI accessors that simply call above functions
+
+void* svGetArrElemPtr(const svOpenArrayHandle h, int indx1, ...) {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h);
+    void* datap;
+    va_list ap;
+    va_start(ap, indx1);
+    // va_arg is a macro, so need temporaries as used below
+    switch (varp->udims()) {
+    case 1: datap = _vl_svGetArrElemPtr(h, 1, indx1, 0, 0); break;
+    case 2: { int indx2=va_arg(ap,int);
+            datap = _vl_svGetArrElemPtr(h, 2, indx1, indx2, 0); break; }
+    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
+            datap = _vl_svGetArrElemPtr(h, 3, indx1, indx2, indx3); break; }
+    default: datap = _vl_svGetArrElemPtr(h, -1, 0, 0, 0); break;  // Will error
+    }
+    va_end(ap);
+    return datap;
+}
+void* svGetArrElemPtr1(const svOpenArrayHandle h, int indx1) {
+    return _vl_svGetArrElemPtr(h, 1, indx1, 0, 0);
+}
+void* svGetArrElemPtr2(const svOpenArrayHandle h, int indx1, int indx2) {
+    return _vl_svGetArrElemPtr(h, 2, indx1, indx2, 0);
+}
+void* svGetArrElemPtr3(const svOpenArrayHandle h, int indx1, int indx2, int indx3) {
+    return _vl_svGetArrElemPtr(h, 3, indx1, indx2, indx3);
+}
 
 void svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s,
-			   int indx1, ...) {
-    _VL_SVDPI_UNIMP();
+                           int indx1, ...) {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
+    va_list ap;
+    va_start(ap, indx1);
+    switch (varp->udims()) {
+    case 1: _vl_svPutBitArrElemVecVal(d, s, 1, indx1, 0, 0); break;
+    case 2: { int indx2=va_arg(ap,int);
+            _vl_svPutBitArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
+    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
+            _vl_svPutBitArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
+    default: _vl_svPutBitArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
+    }
+    va_end(ap);
 }
 void svPutBitArrElem1VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
-			    int indx1) {
-    _VL_SVDPI_UNIMP();
+                            int indx1) {
+    _vl_svPutBitArrElemVecVal(d, s, 1, indx1, 0, 0);
 }
 void svPutBitArrElem2VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
-			    int indx1, int indx2) {
-    _VL_SVDPI_UNIMP();
+                            int indx1, int indx2) {
+    _vl_svPutBitArrElemVecVal(d, s, 2, indx1, indx2, 0);
 }
 void svPutBitArrElem3VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
-			    int indx1, int indx2, int indx3) {
-    _VL_SVDPI_UNIMP();
+                            int indx1, int indx2, int indx3) {
+    _vl_svPutBitArrElemVecVal(d, s, 3, indx1, indx2, indx3);
 }
 void svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
-			     int indx1, ...) {
-    _VL_SVDPI_UNIMP();
+                             int indx1, ...) {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
+    va_list ap;
+    va_start(ap, indx1);
+    switch (varp->udims()) {
+    case 1: _vl_svPutLogicArrElemVecVal(d, s, 1, indx1, 0, 0); break;
+    case 2: { int indx2=va_arg(ap,int);
+            _vl_svPutLogicArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
+    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
+            _vl_svPutLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
+    default: _vl_svPutLogicArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
+    }
+    va_end(ap);
 }
 void svPutLogicArrElem1VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
-			      int indx1) {
-    _VL_SVDPI_UNIMP();
+                              int indx1) {
+    _vl_svPutLogicArrElemVecVal(d, s, 1, indx1, 0, 0);
 }
 void svPutLogicArrElem2VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
-			      int indx1, int indx2) {
-    _VL_SVDPI_UNIMP();
+                              int indx1, int indx2) {
+    _vl_svPutLogicArrElemVecVal(d, s, 2, indx1, indx2, 0);
 }
 void svPutLogicArrElem3VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
-			      int indx1, int indx2, int indx3) {
-    _VL_SVDPI_UNIMP();
+                              int indx1, int indx2, int indx3) {
+    _vl_svPutLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3);
 }
 
 //======================================================================
 // From simulator storage into user space
 
 void svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
-			   int indx1, ...) {
-    _VL_SVDPI_UNIMP();
+                           int indx1, ...) {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
+    va_list ap;
+    va_start(ap, indx1);
+    switch (varp->udims()) {
+    case 1: _vl_svGetBitArrElemVecVal(d, s, 1, indx1, 0, 0); break;
+    case 2: { int indx2=va_arg(ap,int);
+            _vl_svGetBitArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
+    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
+            _vl_svGetBitArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
+    default: _vl_svGetBitArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
+    }
+    va_end(ap);
 }
 void svGetBitArrElem1VecVal(svBitVecVal* d, const svOpenArrayHandle s,
-			    int indx1) {
-    _VL_SVDPI_UNIMP();
+                            int indx1) {
+    _vl_svGetBitArrElemVecVal(d, s, 1, indx1, 0, 0);
 }
 void svGetBitArrElem2VecVal(svBitVecVal* d, const svOpenArrayHandle s,
-			    int indx1, int indx2) {
-    _VL_SVDPI_UNIMP();
+                            int indx1, int indx2) {
+    _vl_svGetBitArrElemVecVal(d, s, 2, indx1, indx2, 0);
 }
 void svGetBitArrElem3VecVal(svBitVecVal* d, const svOpenArrayHandle s,
-			    int indx1, int indx2, int indx3) {
-    _VL_SVDPI_UNIMP();
+                            int indx1, int indx2, int indx3) {
+    _vl_svGetBitArrElemVecVal(d, s, 3, indx1, indx2, indx3);
 }
 void svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s,
-			     int indx1, ...) {
-    _VL_SVDPI_UNIMP();
+                             int indx1, ...) {
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
+    va_list ap;
+    va_start(ap, indx1);
+    switch (varp->udims()) {
+    case 1: _vl_svGetLogicArrElemVecVal(d, s, 1, indx1, 0, 0); break;
+    case 2: { int indx2=va_arg(ap,int);
+            _vl_svGetLogicArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
+    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
+            _vl_svGetLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
+    default: _vl_svGetLogicArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
+    }
+    va_end(ap);
 }
 void svGetLogicArrElem1VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
-			      int indx1) {
-    _VL_SVDPI_UNIMP();
+                              int indx1) {
+    _vl_svGetLogicArrElemVecVal(d, s, 1, indx1, 0, 0);
 }
 void svGetLogicArrElem2VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
-			      int indx1, int indx2) {
-    _VL_SVDPI_UNIMP();
+                              int indx1, int indx2) {
+    _vl_svGetLogicArrElemVecVal(d, s, 2, indx1, indx2, 0);
 }
 void svGetLogicArrElem3VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
-			      int indx1, int indx2, int indx3) {
-    _VL_SVDPI_UNIMP();
+                              int indx1, int indx2, int indx3) {
+    _vl_svGetLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3);
 }
 
 svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...) {
-    _VL_SVDPI_UNIMP(); return 0;
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
+    svBit out;
+    va_list ap;
+    va_start(ap, indx1);
+    switch (varp->udims()) {
+    case 1: out = _vl_svGetBitArrElem(s, 1, indx1, 0, 0, 0); break;
+    case 2: { int indx2=va_arg(ap,int);
+            out = _vl_svGetBitArrElem(s, 2, indx1, indx2, 0, 0); break; }
+    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
+            out = _vl_svGetBitArrElem(s, 3, indx1, indx2, indx3, 0); break; }
+    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
+            out = _vl_svGetBitArrElem(s, 4, indx1, indx2, indx3, indx4); break; }
+    default: out = _vl_svGetBitArrElem(s, -1, 0, 0, 0, 0); break;  // Will error
+    }
+    va_end(ap);
+    return out;
 }
 svBit svGetBitArrElem1(const svOpenArrayHandle s, int indx1) {
-    _VL_SVDPI_UNIMP(); return 0;
+    return _vl_svGetBitArrElem(s, 1, indx1, 0, 0, 0);
 }
 svBit svGetBitArrElem2(const svOpenArrayHandle s, int indx1, int indx2) {
-    _VL_SVDPI_UNIMP(); return 0;
+    return _vl_svGetBitArrElem(s, 2, indx1, indx2, 0, 0);
 }
 svBit svGetBitArrElem3(const svOpenArrayHandle s, int indx1, int indx2, int indx3) {
-    _VL_SVDPI_UNIMP(); return 0;
+    return _vl_svGetBitArrElem(s, 3, indx1, indx2, indx3, 0);
 }
 svLogic svGetLogicArrElem(const svOpenArrayHandle s, int indx1, ...) {
-    _VL_SVDPI_UNIMP(); return sv_x;
+    // Verilator doesn't support X/Z so can just call Bit version
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
+    svBit out;
+    va_list ap;
+    va_start(ap, indx1);
+    switch (varp->udims()) {
+    case 1: out = _vl_svGetBitArrElem(s, 1, indx1, 0, 0, 0); break;
+    case 2: { int indx2=va_arg(ap,int);
+            out = _vl_svGetBitArrElem(s, 2, indx1, indx2, 0, 0); break; }
+    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
+            out = _vl_svGetBitArrElem(s, 3, indx1, indx2, indx3, 0); break; }
+    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
+            out = _vl_svGetBitArrElem(s, 4, indx1, indx2, indx3, indx4); break; }
+    default: out = _vl_svGetBitArrElem(s, -1, 0, 0, 0, 0); break;  // Will error
+    }
+    va_end(ap);
+    return out;
 }
 svLogic svGetLogicArrElem1(const svOpenArrayHandle s, int indx1) {
-    _VL_SVDPI_UNIMP(); return sv_x;
+    // Verilator doesn't support X/Z so can just call Bit version
+    return svGetBitArrElem1(s, indx1);
 }
 svLogic svGetLogicArrElem2(const svOpenArrayHandle s, int indx1, int indx2) {
-    _VL_SVDPI_UNIMP(); return sv_x;
+    // Verilator doesn't support X/Z so can just call Bit version
+    return svGetBitArrElem2(s, indx1, indx2);
 }
 svLogic svGetLogicArrElem3(const svOpenArrayHandle s, int indx1, int indx2, int indx3) {
-    _VL_SVDPI_UNIMP(); return sv_x;
-}
-void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1, ...) {
-    _VL_SVDPI_UNIMP();
-}
-void svPutLogicArrElem1(const svOpenArrayHandle d, svLogic value, int indx1) {
-    _VL_SVDPI_UNIMP();
-}
-void svPutLogicArrElem2(const svOpenArrayHandle d, svLogic value, int indx1, int indx2) {
-    _VL_SVDPI_UNIMP();
-}
-void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1, int indx2, int indx3) {
-    _VL_SVDPI_UNIMP();
+    // Verilator doesn't support X/Z so can just call Bit version
+    return svGetBitArrElem3(s, indx1, indx2, indx3);
 }
+
 void svPutBitArrElem(const svOpenArrayHandle d, svBit value, int indx1, ...) {
-    _VL_SVDPI_UNIMP();
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
+    va_list ap;
+    va_start(ap, indx1);
+    switch (varp->udims()) {
+    case 1: _vl_svPutBitArrElem(d, value, 1, indx1, 0, 0, 0); break;
+    case 2: { int indx2=va_arg(ap,int);
+            _vl_svPutBitArrElem(d, value, 2, indx1, indx2, 0, 0); break; }
+    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
+            _vl_svPutBitArrElem(d, value, 3, indx1, indx2, indx3, 0); break; }
+    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
+            _vl_svPutBitArrElem(d, value, 4, indx1, indx2, indx3, indx4); break; }
+    default: _vl_svPutBitArrElem(d, value, -1, 0, 0, 0, 0); break;  // Will error
+    }
+    va_end(ap);
 }
 void svPutBitArrElem1(const svOpenArrayHandle d, svBit value, int indx1) {
-    _VL_SVDPI_UNIMP();
+    _vl_svPutBitArrElem(d, value, 1, indx1, 0, 0, 0);
 }
 void svPutBitArrElem2(const svOpenArrayHandle d, svBit value, int indx1, int indx2) {
-    _VL_SVDPI_UNIMP();
+    _vl_svPutBitArrElem(d, value, 2, indx1, indx2, 0, 0);
 }
 void svPutBitArrElem3(const svOpenArrayHandle d, svBit value, int indx1, int indx2, int indx3) {
-    _VL_SVDPI_UNIMP();
+    _vl_svPutBitArrElem(d, value, 3, indx1, indx2, indx3, 0);
+}
+void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1, ...) {
+    // Verilator doesn't support X/Z so can just call Bit version
+    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
+    va_list ap;
+    va_start(ap, indx1);
+    switch (varp->udims()) {
+    case 1: _vl_svPutBitArrElem(d, value, 1, indx1, 0, 0, 0); break;
+    case 2: { int indx2=va_arg(ap,int);
+            _vl_svPutBitArrElem(d, value, 2, indx1, indx2, 0, 0); break; }
+    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
+            _vl_svPutBitArrElem(d, value, 3, indx1, indx2, indx3, 0); break; }
+    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
+            _vl_svPutBitArrElem(d, value, 4, indx1, indx2, indx3, indx4); break; }
+    default: _vl_svPutBitArrElem(d, value, -1, 0, 0, 0, 0); break;  // Will error
+    }
+    va_end(ap);
+}
+void svPutLogicArrElem1(const svOpenArrayHandle d, svLogic value, int indx1) {
+    // Verilator doesn't support X/Z so can just call Bit version
+    svPutBitArrElem1(d, value, indx1);
+}
+void svPutLogicArrElem2(const svOpenArrayHandle d, svLogic value,
+                        int indx1, int indx2) {
+    // Verilator doesn't support X/Z so can just call Bit version
+    svPutBitArrElem2(d, value, indx1, indx2);
+}
+void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value,
+                        int indx1, int indx2, int indx3) {
+    // Verilator doesn't support X/Z so can just call Bit version
+    svPutBitArrElem3(d, value, indx1, indx2, indx3);
 }
 
 //======================================================================
@@ -256,26 +726,29 @@ void svPutBitArrElem3(const svOpenArrayHandle d, svBit value, int indx1, int ind
 
 svScope svGetScope() {
     if (VL_UNLIKELY(!Verilated::dpiInContext())) { _VL_SVDPI_CONTEXT_WARN(); return NULL; }
-    return (svScope)Verilated::dpiScope();
+    // NOLINTNEXTLINE(google-readability-casting)
+    return (svScope)(Verilated::dpiScope());
 }
 
 svScope svSetScope(const svScope scope) {
     const VerilatedScope* prevScopep = Verilated::dpiScope();
-    const VerilatedScope* vscopep = (const VerilatedScope*)(scope);
+    const VerilatedScope* vscopep = reinterpret_cast<const VerilatedScope*>(scope);
     Verilated::dpiScope(vscopep);
-    return (svScope)prevScopep;
+    // NOLINTNEXTLINE(google-readability-casting)
+    return (svScope)(prevScopep);
 }
 
 const char* svGetNameFromScope(const svScope scope) {
-    const VerilatedScope* vscopep = (const VerilatedScope*)(scope);
+    const VerilatedScope* vscopep = reinterpret_cast<const VerilatedScope*>(scope);
     return vscopep->name();
 }
 
 svScope svGetScopeFromName(const char* scopeName) {
-    return (svScope)VerilatedImp::scopeFind(scopeName);
+    // NOLINTNEXTLINE(google-readability-casting)
+    return (svScope)(VerilatedImp::scopeFind(scopeName));
 }
 
-int svPutUserData(const svScope scope, void *userKey, void* userData) {
+int svPutUserData(const svScope scope, void* userKey, void* userData) {
     VerilatedImp::userInsert(scope,userKey,userData);
     return 0;
 }
@@ -295,7 +768,7 @@ int svGetCallerInfo(const char** fileNamepp, int *lineNumberp) {
 // Disables
 
 int svIsDisabledState() {
-    return 0; // Disables not implemented
+    return 0;  // Disables not implemented
 }
 
 void svAckDisabledState() {

include/verilated_dpi.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2019 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.
@@ -16,9 +16,9 @@
 /// \file
 /// \brief Verilator: Common include for all Verilated C files that use DPI
 ///
-///	This file is included automatically by Verilator at the top of
-///	all C++ files it generates where DPI is used.  It contains
-///	DPI interface functions required by the Verilated code.
+///     This file is included automatically by Verilator at the top of
+///     all C++ files it generates where DPI is used.  It contains
+///     DPI interface functions required by the Verilated code.
 ///
 /// Code available from: http://www.veripool.org/verilator
 ///
@@ -26,39 +26,58 @@
 
 
 #ifndef _VERILATED_DPI_H_
-#define _VERILATED_DPI_H_ 1 ///< Header Guard
+#define _VERILATED_DPI_H_ 1  ///< Header Guard
+
+#include "verilatedos.h"
+#include "verilated.h"  // Also presumably included by caller
+#include "verilated_sym_props.h"
 
-#include "verilated.h"   // Presumed done by caller
 #include "svdpi.h"
 
 //===================================================================
 // SETTING OPERATORS
 
+/// Return WData from svBitVecVal
+static inline void VL_SET_W_SVBV(int obits, WDataOutP owp, const svBitVecVal* lwp) VL_MT_SAFE {
+    int words = VL_WORDS_I(obits);
+    for (int i=0; i<words-1; ++i) owp[i]=lwp[i];
+    owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
+}
 /// Return svBitVecVal from WData
-static inline void VL_SET_W_SVBV(int obits, WDataOutP owp, svBitVecVal* lwp) {
+static inline void VL_SET_SVBV_W(int obits, svBitVecVal* owp, WDataInP lwp) VL_MT_SAFE {
     int words = VL_WORDS_I(obits);
-    for (int i=0; i<words-1; i++) owp[i]=lwp[i];
+    for (int i=0; i<words-1; ++i) owp[i]=lwp[i];
     owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
 }
-static inline void VL_SET_SVBV_W(int obits, svBitVecVal* owp, WDataInP lwp) {
+
+/// Convert svLogicVecVal to/from WData
+/// Note these functions ignore X/Z in svLogicVecVal
+static inline void VL_SET_W_SVLV(int obits, WDataOutP owp, const svLogicVecVal* lwp) VL_MT_SAFE {
     int words = VL_WORDS_I(obits);
-    for (int i=0; i<words-1; i++) owp[i]=lwp[i];
-    owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
-}
-static inline void VL_SET_W_SVLV(int obits, WDataOutP owp, svLogicVecVal* lwp) {
-    // Note we ignore X/Z in svLogicVecVal
-    int words = VL_WORDS_I(obits);
-    for (int i=0; i<words-1; i++) owp[i]=lwp[i].aval;
+    for (int i=0; i<words-1; ++i) owp[i]=lwp[i].aval;
     owp[words-1] = lwp[words-1].aval & VL_MASK_I(obits);
 }
-static inline void VL_SET_SVLV_W(int obits, svLogicVecVal* owp, WDataInP lwp) {
-    // Note we don't create X/Z in svLogicVecVal
+static inline QData VL_SET_Q_SVLV(const svLogicVecVal* lwp) VL_MT_SAFE {
+    return _VL_SET_QII(lwp[1].aval, lwp[0].aval);
+}
+static inline IData VL_SET_I_SVLV(const svLogicVecVal* lwp) VL_MT_SAFE {
+    return lwp[0].aval;
+}
+static inline void VL_SET_SVLV_W(int obits, svLogicVecVal* owp, WDataInP lwp) VL_MT_SAFE {
     int words = VL_WORDS_I(obits);
-    for (int i=0; i<words; i++) owp[i].bval=0;
-    for (int i=0; i<words-1; i++) owp[i].aval=lwp[i];
+    for (int i=0; i<words; ++i) owp[i].bval=0;
+    for (int i=0; i<words-1; ++i) owp[i].aval=lwp[i];
     owp[words-1].aval = lwp[words-1] & VL_MASK_I(obits);
 }
+static inline void VL_SET_SVLV_I(int, svLogicVecVal* owp, IData ld) VL_MT_SAFE {
+    owp[0].aval=ld; owp[0].bval=0;
+}
+static inline void VL_SET_SVLV_Q(int, svLogicVecVal* owp, QData ld) VL_MT_SAFE {
+    WData lwp[2]; VL_SET_WQ(lwp,ld);
+    owp[0].aval=lwp[0]; owp[0].bval=0;
+    owp[1].aval=lwp[1]; owp[1].bval=0;
+}
 
 //======================================================================
 
-#endif // _VERILATED_DPI_H_
+#endif  // Guard

include/verilated_fst_c.cpp

@@ -0,0 +1,250 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2001-2019 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 C++ Tracing in FST Format
+///
+//=============================================================================
+// SPDIFF_OFF
+
+#include "verilatedos.h"
+#include "verilated.h"
+#include "verilated_fst_c.h"
+
+// GTKWave configuration
+#ifdef VL_TRACE_THREADED
+# define HAVE_LIBPTHREAD
+# define FST_WRITER_PARALLEL
+#endif
+
+// Include the GTKWave implementation directly
+#include "gtkwave/fastlz.c"
+#include "gtkwave/fstapi.c"
+#include "gtkwave/lz4.c"
+
+#include <algorithm>
+#include <cerrno>
+#include <ctime>
+#include <fcntl.h>
+#include <iterator>
+#include <sstream>
+#include <sys/stat.h>
+
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
+# include <io.h>
+#else
+# include <unistd.h>
+#endif
+
+//=============================================================================
+
+class VerilatedFstCallInfo {
+protected:
+    friend class VerilatedFst;
+    VerilatedFstCallback_t m_initcb;  ///< Initialization Callback function
+    VerilatedFstCallback_t m_fullcb;  ///< Full Dumping Callback function
+    VerilatedFstCallback_t m_changecb;  ///< Incremental Dumping Callback function
+    void* m_userthis;  ///< Fake "this" for caller
+    vluint32_t m_code;  ///< Starting code number
+    // CONSTRUCTORS
+    VerilatedFstCallInfo(VerilatedFstCallback_t icb, VerilatedFstCallback_t fcb,
+                         VerilatedFstCallback_t changecb,
+                         void* ut, vluint32_t code)
+        : m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {}
+    ~VerilatedFstCallInfo() {}
+};
+
+//=============================================================================
+// VerilatedFst
+
+VerilatedFst::VerilatedFst(void* fst)
+    : m_fst(fst),
+      m_fullDump(true),
+      m_scopeEscape('.') {}
+
+void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
+    m_assertOne.check();
+    m_fst = fstWriterCreate(filename, 1);
+    fstWriterSetPackType(m_fst, FST_WR_PT_LZ4);
+#ifdef VL_TRACE_THREADED
+    fstWriterSetParallelMode(m_fst, 1);
+#endif
+    m_curScope.clear();
+
+    for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
+        VerilatedFstCallInfo* cip = m_callbacks[ent];
+        cip->m_code = 1;
+        (cip->m_initcb)(this, cip->m_userthis, cip->m_code);
+    }
+
+    // Clear the scope stack
+    std::list<std::string>::iterator it = m_curScope.begin();
+    while (it != m_curScope.end()) {
+        fstWriterSetUpscope(m_fst);
+        it = m_curScope.erase(it);
+    }
+}
+
+void VerilatedFst::module(const std::string& name) {
+    m_module = name;
+}
+
+//=============================================================================
+// Decl
+
+void VerilatedFst::declDTypeEnum(int dtypenum, const char* name, vluint32_t elements,
+                                 unsigned int minValbits,
+                                 const char** itemNamesp, const char** itemValuesp) {
+    fstEnumHandle enumNum = fstWriterCreateEnumTable(m_fst, name, elements,
+                                                     minValbits, itemNamesp, itemValuesp);
+    m_local2fstdtype[dtypenum] = enumNum;
+}
+
+void VerilatedFst::declSymbol(vluint32_t code, const char* name,
+                              int dtypenum, fstVarDir vardir, fstVarType vartype,
+                              int arraynum, vluint32_t len) {
+    std::pair<Code2SymbolType::iterator, bool> p
+        = m_code2symbol.insert(std::make_pair(code, static_cast<fstHandle>(NULL)));
+    std::istringstream nameiss(name);
+    std::istream_iterator<std::string> beg(nameiss), end;
+    std::list<std::string> tokens(beg, end);  // Split name
+    std::string symbol_name(tokens.back());
+    tokens.pop_back();  // Remove symbol name from hierarchy
+    tokens.insert(tokens.begin(), m_module);  // Add current module to the hierarchy
+
+    // Find point where current and new scope diverge
+    std::list<std::string>::iterator cur_it = m_curScope.begin();
+    std::list<std::string>::iterator new_it = tokens.begin();
+    while (cur_it != m_curScope.end() && new_it != tokens.end()) {
+        if (*cur_it != *new_it)
+            break;
+        ++cur_it;
+        ++new_it;
+    }
+
+    // Go back to the common point
+    while (cur_it != m_curScope.end()) {
+        fstWriterSetUpscope(m_fst);
+        cur_it = m_curScope.erase(cur_it);
+    }
+
+    // Follow the hierarchy of the new variable from the common scope point
+    while (new_it != tokens.end()) {
+        fstWriterSetScope(m_fst, FST_ST_VCD_SCOPE, new_it->c_str(), NULL);
+        m_curScope.push_back(*new_it);
+        new_it = tokens.erase(new_it);
+    }
+
+    std::stringstream name_ss;
+    name_ss << symbol_name;
+    if (arraynum >= 0)
+        name_ss << "(" << arraynum << ")";
+    std::string name_str = name_ss.str();
+
+    if (dtypenum > 0) {
+        fstEnumHandle enumNum = m_local2fstdtype[dtypenum];
+        fstWriterEmitEnumTableRef(m_fst, enumNum);
+    }
+    if (p.second) {  // New
+        p.first->second = fstWriterCreateVar(m_fst, vartype, vardir, len, name_str.c_str(), 0);
+        assert(p.first->second);
+    } else {  // Alias
+        fstWriterCreateVar(m_fst, vartype, vardir, len, name_str.c_str(), p.first->second);
+    }
+}
+
+//=============================================================================
+// Callbacks
+
+void VerilatedFst::addCallback(
+    VerilatedFstCallback_t initcb, VerilatedFstCallback_t fullcb,
+    VerilatedFstCallback_t changecb, void* userthis) VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
+    if (VL_UNLIKELY(isOpen())) {
+        std::string msg = (std::string("Internal: ")+__FILE__+"::"+__FUNCTION__
+                           +" called with already open file");
+        VL_FATAL_MT(__FILE__,__LINE__,"",msg.c_str());
+    }
+    VerilatedFstCallInfo* vci = new VerilatedFstCallInfo(initcb, fullcb, changecb, userthis, 1);
+    m_callbacks.push_back(vci);
+}
+
+//=============================================================================
+// Dumping
+
+void VerilatedFst::dump(vluint64_t timeui) {
+    if (!isOpen()) return;
+    if (VL_UNLIKELY(m_fullDump)) {
+        m_fullDump = false;  // No need for more full dumps
+        for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
+            VerilatedFstCallInfo* cip = m_callbacks[ent];
+            (cip->m_fullcb)(this, cip->m_userthis, cip->m_code);
+        }
+        return;
+    }
+    fstWriterEmitTimeChange(m_fst, timeui);
+    for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
+        VerilatedFstCallInfo* cip = m_callbacks[ent];
+        (cip->m_changecb)(this, cip->m_userthis, cip->m_code);
+    }
+}
+
+//=============================================================================
+// Helpers
+
+char* VerilatedFst::word2Str(vluint32_t newval, int bits) {
+    m_valueStrBuffer.resize(bits+1);
+    char* s = m_valueStrBuffer.data();
+    for (int i = 0; i < bits; ++i) {
+        *s = '0' + ((newval>>(bits-i-1))&1);
+        ++s;
+    }
+    *s = '\0';
+    return m_valueStrBuffer.data();
+}
+
+char* VerilatedFst::quad2Str(vluint64_t newval, int bits) {
+    m_valueStrBuffer.resize(bits+1);
+    char* s = m_valueStrBuffer.data();
+    for (int i = 0; i < bits; ++i) {
+        *s = '0' + ((newval>>(bits-i-1))&1);
+        ++s;
+    }
+    *s = '\0';
+    return m_valueStrBuffer.data();
+}
+
+char* VerilatedFst::array2Str(const vluint32_t* newval, int bits) {
+    int bq = bits/32, br = bits%32;
+    m_valueStrBuffer.resize(bits+1);
+    char* s = m_valueStrBuffer.data();
+    for (int i = 0; i < br; ++i) {
+        *s = '0' + ((newval[bq]>>(br-i-1))&1);
+        ++s;
+    }
+    for (int w = bq-1; w >= 0; --w) {
+        for (int i = 0; i < 32; ++i) {
+            *s = '0' + ((newval[w]>>(32-i-1))&1);
+            ++s;
+        }
+    }
+    *s = '\0';
+    return m_valueStrBuffer.data();
+}
+
+//********************************************************************
+// Local Variables:
+// End:

include/verilated_fst_c.h

@@ -0,0 +1,236 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2001-2019 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 C++ Tracing in FST Format
+///
+//=============================================================================
+// SPDIFF_OFF
+
+#ifndef _VERILATED_FST_C_H_
+#define _VERILATED_FST_C_H_ 1
+
+#include "verilatedos.h"
+#include "verilated.h"
+
+#include "gtkwave/fstapi.h"
+
+#include <list>
+#include <map>
+#include <string>
+#include <vector>
+
+class VerilatedFst;
+class VerilatedFstCallInfo;
+typedef void (*VerilatedFstCallback_t)(VerilatedFst* vcdp, void* userthis, vluint32_t code);
+
+//=============================================================================
+// VerilatedFst
+/// Base class to create a Verilator FST dump
+/// This is an internally used class - see VerilatedFstC for what to call from applications
+
+class VerilatedFst {
+    typedef std::map<vluint32_t, fstHandle> Code2SymbolType;
+    typedef std::map<int, fstEnumHandle> Local2FstDtype;
+    typedef std::vector<VerilatedFstCallInfo*> CallbackVec;
+private:
+    void* m_fst;
+    VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread
+    bool m_fullDump;
+    char m_scopeEscape;
+    std::string m_module;
+    CallbackVec m_callbacks;  ///< Routines to perform dumping
+    Code2SymbolType m_code2symbol;
+    Local2FstDtype m_local2fstdtype;
+    std::list<std::string> m_curScope;
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedFst);
+    void declSymbol(vluint32_t code, const char* name,
+                    int dtypenum, fstVarDir vardir, fstVarType vartype,
+                    int arraynum, vluint32_t len);
+    // helpers
+    std::vector<char> m_valueStrBuffer;
+    char* word2Str(vluint32_t newval, int bits);
+    char* quad2Str(vluint64_t newval, int bits);
+    char* array2Str(const vluint32_t *newval, int bits);
+public:
+    explicit VerilatedFst(void* fst=NULL);
+    ~VerilatedFst() { if (m_fst == NULL) { fstWriterClose(m_fst); } }
+    bool isOpen() const { return m_fst != NULL; }
+    void open(const char* filename) VL_MT_UNSAFE;
+    void flush() VL_MT_UNSAFE { fstWriterFlushContext(m_fst); }
+    void close() VL_MT_UNSAFE {
+        m_assertOne.check();
+        fstWriterClose(m_fst);
+        m_fst = NULL;
+    }
+    void set_time_unit(const char* unitp) { fstWriterSetTimescaleFromString(m_fst, unitp); }
+    void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
+
+    void set_time_resolution(const char* unitp) { if (unitp) {} }
+    void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
+
+    // double timescaleToDouble(const char* unitp);
+    // std::string doubleToTimescale(double value);
+
+    /// Change character that splits scopes.  Note whitespace are ALWAYS escapes.
+    void scopeEscape(char flag) { m_scopeEscape = flag; }
+    /// Is this an escape?
+    bool isScopeEscape(char c) { return isspace(c) || c==m_scopeEscape; }
+    /// Inside dumping routines, called each cycle to make the dump
+    void dump(vluint64_t timeui);
+    /// Inside dumping routines, declare callbacks for tracings
+    void addCallback(VerilatedFstCallback_t initcb, VerilatedFstCallback_t fullcb,
+                     VerilatedFstCallback_t changecb,
+                     void* userthis) VL_MT_UNSAFE_ONE;
+
+    /// Inside dumping routines, declare a module
+    void module(const std::string& name);
+    /// Inside dumping routines, declare a data type
+    void declDTypeEnum(int dtypenum, const char* name, vluint32_t elements,
+                       unsigned int minValbits,
+                       const char** itemNamesp, const char** itemValuesp);
+    /// Inside dumping routines, declare a signal
+    void declBit(vluint32_t code, const char* name,
+                 int dtypenum, fstVarDir vardir, fstVarType vartype,
+                 int arraynum) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 1);
+    }
+    void declBus(vluint32_t code, const char* name,
+                 int dtypenum, fstVarDir vardir, fstVarType vartype,
+                 int arraynum, int msb, int lsb) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
+    }
+    void declDouble(vluint32_t code, const char* name,
+                    int dtypenum, fstVarDir vardir, fstVarType vartype,
+                    int arraynum) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 2);
+    }
+    void declFloat(vluint32_t code, const char* name,
+                   int dtypenum, fstVarDir vardir, fstVarType vartype,
+                   int arraynum) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 1);
+    }
+    void declQuad(vluint32_t code, const char* name,
+                  int dtypenum, fstVarDir vardir, fstVarType vartype,
+                  int arraynum, int msb, int lsb) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
+    }
+    void declArray(vluint32_t code, const char* name,
+                   int dtypenum, fstVarDir vardir, fstVarType vartype,
+                   int arraynum, int msb, int lsb) {
+        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
+    }
+
+    /// Inside dumping routines, dump one signal if it has changed
+    void chgBit(vluint32_t code, const vluint32_t newval) {
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], newval ? "1" : "0");
+    }
+    void chgBus(vluint32_t code, const vluint32_t newval, int bits) {
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], word2Str(newval, bits));
+    }
+    void chgDouble(vluint32_t code, const double newval) {
+        double val = newval;
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], &val);
+    }
+    void chgFloat(vluint32_t code, const float newval) {
+        double val = (double)newval;
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], &val);
+    }
+    void chgQuad(vluint32_t code, const vluint64_t newval, int bits) {
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], quad2Str(newval, bits));
+    }
+    void chgArray(vluint32_t code, const vluint32_t* newval, int bits) {
+        fstWriterEmitValueChange(m_fst, m_code2symbol[code], array2Str(newval, bits));
+    }
+
+    void fullBit(vluint32_t code, const vluint32_t newval) {
+        chgBit(code, newval); }
+    void fullBus(vluint32_t code, const vluint32_t newval, int bits) {
+        chgBus(code, newval, bits); }
+    void fullDouble(vluint32_t code, const double newval) {
+        chgDouble(code, newval); }
+    void fullFloat(vluint32_t code, const float newval) {
+        chgFloat(code, newval); }
+    void fullQuad(vluint32_t code, const vluint64_t newval, int bits) {
+        chgQuad(code, newval, bits); }
+    void fullArray(vluint32_t code, const vluint32_t* newval, int bits) {
+        chgArray(code, newval, bits); }
+
+    void declTriBit   (vluint32_t code, const char* name, int arraynum);
+    void declTriBus   (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriQuad  (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriArray (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void fullTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri);
+    void fullTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits);
+    void fullTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits);
+    void fullTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits);
+    void fullBitX(vluint32_t code);
+    void fullBusX(vluint32_t code, int bits);
+    void fullQuadX(vluint32_t code, int bits);
+    void fullArrayX(vluint32_t code, int bits);
+    void chgTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri);
+    void chgTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits);
+    void chgTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits);
+    void chgTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits);
+};
+
+//=============================================================================
+// VerilatedFstC
+/// Create a FST dump file in C standalone (no SystemC) simulations.
+/// Also derived for use in SystemC simulations.
+/// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE
+
+class VerilatedFstC {
+    VerilatedFst m_sptrace;  ///< Trace file being created
+
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedFstC);
+public:
+    explicit VerilatedFstC(void* filep=NULL) : m_sptrace(filep) {}
+    ~VerilatedFstC() {}
+public:
+    // ACCESSORS
+    /// Is file open?
+    bool isOpen() const { return m_sptrace.isOpen(); }
+    // METHODS
+    /// Open a new FST file
+    void open(const char* filename) VL_MT_UNSAFE_ONE { m_sptrace.open(filename); }
+    /// Close dump
+    void close() VL_MT_UNSAFE_ONE { m_sptrace.close(); }
+    /// Flush dump
+    void flush() VL_MT_UNSAFE_ONE { m_sptrace.flush(); }
+    /// Write one cycle of dump data
+    void dump(vluint64_t timeui) { m_sptrace.dump(timeui); }
+    /// Write one cycle of dump data - backward compatible and to reduce
+    /// conversion warnings.  It's better to use a vluint64_t time instead.
+    void dump(double timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump(vluint32_t timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump(int timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    /// Set time units (s/ms, defaults to ns)
+    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    void set_time_unit(const char* unitp) { m_sptrace.set_time_unit(unitp); }
+    void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
+    /// Set time resolution (s/ms, defaults to ns)
+    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    void set_time_resolution(const char* unitp) { m_sptrace.set_time_resolution(unitp); }
+    void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
+
+    /// Internal class access
+    inline VerilatedFst* spTrace() { return &m_sptrace; };
+};
+
+#endif  // guard

include/verilated_heavy.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2010-2015 by Wilson Snyder. This program is free software; you can
+// Copyright 2010-2019 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.
@@ -16,10 +16,10 @@
 /// \file
 /// \brief Verilator: String include for all Verilated C files
 ///
-///	This file is included automatically by Verilator at the top of
-///	all C++ files it generates.  It is used when strings or other
-///	heavyweight types are required; these contents are not part of
-///	verilated.h to save compile time when such types aren't used.
+///     This file is included automatically by Verilator at the top of
+///     all C++ files it generates.  It is used when strings or other
+///     heavyweight types are required; these contents are not part of
+///     verilated.h to save compile time when such types aren't used.
 ///
 /// Code available from: http://www.veripool.org/verilator
 ///
@@ -27,7 +27,7 @@
 
 
 #ifndef _VERILATED_HEAVY_H_
-#define _VERILATED_HEAVY_H_ 1 ///< Header Guard
+#define _VERILATED_HEAVY_H_ 1  ///< Header Guard
 
 #include "verilated.h"
 
@@ -36,32 +36,58 @@
 //======================================================================
 // Conversion functions
 
-extern string VL_CVT_PACK_STR_NW(int lwords, WDataInP lwp);
-inline string VL_CVT_PACK_STR_NQ(QData lhs) {
-    IData lw[2];  VL_SET_WQ(lw, lhs);
+extern std::string VL_CVT_PACK_STR_NW(int lwords, WDataInP lwp) VL_MT_SAFE;
+inline std::string VL_CVT_PACK_STR_NQ(QData lhs) VL_PURE {
+    WData lw[2];  VL_SET_WQ(lw, lhs);
     return VL_CVT_PACK_STR_NW(2, lw);
 }
-inline string VL_CVT_PACK_STR_NN(const string& lhs) {
+inline std::string VL_CVT_PACK_STR_NN(const std::string& lhs) VL_PURE {
     return lhs;
 }
-inline string VL_CVT_PACK_STR_NI(IData lhs) {
-    IData lw[1];  lw[0] = lhs;
+inline std::string VL_CVT_PACK_STR_NI(IData lhs) VL_PURE {
+    WData lw[1];  lw[0] = lhs;
     return VL_CVT_PACK_STR_NW(1, lw);
 }
-inline string VL_CONCATN_NNN(const string& lhs, const string& rhs) {
+inline std::string VL_CONCATN_NNN(const std::string& lhs, const std::string& rhs) VL_PURE {
     return lhs+rhs;
 }
-inline string VL_REPLICATEN_NNQ(int,int,int, const string& lhs, IData rep) {
-    string out; out.reserve(lhs.length() * rep);
-    for (unsigned times=0; times<rep; times++) out += lhs;
+inline std::string VL_REPLICATEN_NNQ(int,int,int, const std::string& lhs, IData rep) VL_PURE {
+    std::string out; out.reserve(lhs.length() * rep);
+    for (unsigned times=0; times<rep; ++times) out += lhs;
     return out;
 }
-inline string VL_REPLICATEN_NNI(int obits,int lbits,int rbits, const string& lhs, IData rep) {
+inline std::string VL_REPLICATEN_NNI(int obits,int lbits,int rbits,
+                                     const std::string& lhs, IData rep) VL_PURE {
     return VL_REPLICATEN_NNQ(obits,lbits,rbits,lhs,rep);
 }
 
-extern IData VL_SSCANF_INX(int lbits, const string& ld, const char* formatp, ...);
-extern void VL_SFORMAT_X(int obits_ignored, string &output, const char* formatp, ...);
-extern string VL_SFORMATF_NX(const char* formatp, ...);
+inline IData VL_LEN_IN(const std::string& ld) { return ld.length(); }
 
-#endif // Guard
+extern IData VL_FOPEN_NI(const std::string& filename, IData mode) VL_MT_SAFE;
+extern void VL_READMEM_N(bool hex, int width, int depth, int array_lsb,
+                         const std::string& filename,
+                         void* memp, IData start, IData end) VL_MT_SAFE;
+extern void VL_WRITEMEM_N(bool hex, int width, int depth, int array_lsb,
+                          const std::string& filename,
+                          const void* memp, IData start, IData end) VL_MT_SAFE;
+extern IData VL_SSCANF_INX(int lbits, const std::string& ld,
+                           const char* formatp, ...) VL_MT_SAFE;
+extern void VL_SFORMAT_X(int obits_ignored, std::string& output,
+                         const char* formatp, ...) VL_MT_SAFE;
+extern std::string VL_SFORMATF_NX(const char* formatp, ...) VL_MT_SAFE;
+extern IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rwp) VL_MT_SAFE;
+inline IData VL_VALUEPLUSARGS_INI(int rbits, const std::string& ld, IData& rdr) VL_MT_SAFE {
+    WData rwp[2];  // WData must always be at least 2
+    IData got = VL_VALUEPLUSARGS_INW(rbits,ld,rwp);
+    if (got) rdr = rwp[0];
+    return got;
+}
+inline IData VL_VALUEPLUSARGS_INQ(int rbits, const std::string& ld, QData& rdr) VL_MT_SAFE {
+    WData rwp[2];
+    IData got = VL_VALUEPLUSARGS_INW(rbits,ld,rwp);
+    if (got) rdr = VL_SET_QW(rwp);
+    return got;
+}
+extern IData VL_VALUEPLUSARGS_INN(int, const std::string& ld, std::string& rdr) VL_MT_SAFE;
+
+#endif  // Guard

include/verilated_imp.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2015 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2019 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.
@@ -22,7 +22,7 @@
 
 
 #ifndef _VERILATED_IMP_H_
-#define _VERILATED_IMP_H_ 1 ///< Header Guard
+#define _VERILATED_IMP_H_ 1  ///< Header Guard
 
 #if !defined(_VERILATED_CPP_) && !defined(_VERILATED_DPI_CPP_)
 # error "verilated_imp.h only to be included by verilated*.cpp internals"
@@ -33,153 +33,295 @@
 #include "verilated_heavy.h"
 #include "verilated_syms.h"
 
-#include <map>
-#include <vector>
 #include <deque>
-#include <string>
+#include <set>
+#include <vector>
+#ifdef VL_THREADED
+# include <functional>
+# include <queue>
+#endif
 
 class VerilatedScope;
 
 //======================================================================
-// Types
+// Threaded message passing
+
+#ifdef VL_THREADED
+/// Message, enqueued on an mtask, and consumed on the main eval thread
+class VerilatedMsg {
+public:
+    // TYPES
+    struct Cmp {
+        bool operator() (const VerilatedMsg& a, const VerilatedMsg& b) const {
+            return a.mtaskId() < b.mtaskId(); }
+    };
+private:
+    // MEMBERS
+    vluint32_t m_mtaskId;  ///< MTask that did enqueue
+    std::function<void()> m_cb;  ///< Lambda to execute when message received
+public:
+    // CONSTRUCTORS
+    VerilatedMsg(const std::function<void()>& cb)
+        : m_mtaskId(Verilated::mtaskId()), m_cb(cb) {}
+    ~VerilatedMsg() {}
+    // METHODS
+    vluint32_t mtaskId() const { return m_mtaskId; }
+    /// Execute the lambda function
+    void run() const { m_cb(); }
+};
+
+/// Each thread has a queue it pushes to
+/// This assumes no thread starts pushing the next tick until the previous has drained.
+/// If more aggressiveness is needed, a double-buffered scheme might work well.
+class VerilatedEvalMsgQueue  {
+    typedef std::multiset<VerilatedMsg, VerilatedMsg::Cmp> VerilatedThreadQueue;
+
+    std::atomic<vluint64_t> m_depth;  ///< Current depth of queue (see comments below)
+
+    VerilatedMutex m_mutex;  ///< Mutex protecting queue
+    VerilatedThreadQueue m_queue VL_GUARDED_BY(m_mutex);  ///< Message queue
+public:
+    // CONSTRUCTORS
+    VerilatedEvalMsgQueue() : m_depth(0) {
+        assert(atomic_is_lock_free(&m_depth));
+    }
+    ~VerilatedEvalMsgQueue() { }
+private:
+    VL_UNCOPYABLE(VerilatedEvalMsgQueue);
+public:
+    // METHODS
+    //// Add message to queue (called by producer)
+    void post(const VerilatedMsg& msg) VL_EXCLUDES(m_mutex) {
+        VerilatedLockGuard lock(m_mutex);
+        m_queue.insert(msg);  // Pass by value to copy the message into queue
+        ++m_depth;
+    }
+    /// Service queue until completion (called by consumer)
+    void process() VL_EXCLUDES(m_mutex) {
+        // Tracking m_depth is redundant to e.g. getting the mutex and looking at queue size,
+        // but on the reader side it's 4x faster to test an atomic then getting a mutex
+        while (m_depth) {
+            // Wait for a message to be added to the queue
+            // We don't use unique_lock as want to unlock with the message copy still in scope
+            m_mutex.lock();
+            assert(!m_queue.empty());  // Otherwise m_depth is wrong
+            // Unfortunately to release the lock we need to copy the message
+            // (Or have the message be a pointer, but then new/delete cost on each message)
+            // We assume messages are small, so copy
+            auto it = m_queue.begin();
+            const VerilatedMsg msg = *(it);
+            m_queue.erase(it);
+            m_mutex.unlock();
+            m_depth--;  // Ok if outside critical section as only this code checks the value
+            {
+                VL_DEBUG_IF(VL_DBG_MSGF("Executing callback from mtaskId=%d\n", msg.mtaskId()););
+                msg.run();
+            }
+        }
+    }
+};
+
+/// Each thread has a local queue to build up messages until the end of the eval() call
+class VerilatedThreadMsgQueue  {
+    std::queue<VerilatedMsg> m_queue;
+public:
+    // CONSTRUCTORS
+    VerilatedThreadMsgQueue() { }
+    ~VerilatedThreadMsgQueue() {
+        // The only call of this with a non-empty queue is a fatal error.
+        // So this does not flush the queue, as the destination queue is not known to this class.
+    }
+private:
+    VL_UNCOPYABLE(VerilatedThreadMsgQueue);
+    // METHODS
+    static VerilatedThreadMsgQueue& threadton() {
+        static VL_THREAD_LOCAL VerilatedThreadMsgQueue t_s;
+        return t_s;
+    }
+public:
+    /// Add message to queue, called by producer
+    static void post(const VerilatedMsg& msg) VL_MT_SAFE {
+        // Handle calls to threaded routines outside
+        // of any mtask -- if an initial block calls $finish, say.
+        if (Verilated::mtaskId() == 0) {
+            // No queueing, just do the action immediately
+            msg.run();
+        } else {
+            Verilated::endOfEvalReqdInc();
+            threadton().m_queue.push(msg);  // Pass by value to copy the message into queue
+        }
+    }
+    /// Push all messages to the eval's queue
+    static void flush(VerilatedEvalMsgQueue* evalMsgQp) VL_MT_SAFE {
+        while (!threadton().m_queue.empty()) {
+            evalMsgQp->post(threadton().m_queue.front());
+            threadton().m_queue.pop();
+            Verilated::endOfEvalReqdDec();
+        }
+    }
+};
+#endif  // VL_THREADED
+
+//======================================================================
+// VerilatedImp
 
 class VerilatedImp {
     // Whole class is internal use only - Global information shared between verilated*.cpp files.
 
     // TYPES
-    typedef vector<string> ArgVec;
-    typedef map<pair<const void*,void*>,void*> UserMap;
-    typedef map<const char*, const VerilatedScope*, VerilatedCStrCmp>  ScopeNameMap;
-    typedef map<const char*, int, VerilatedCStrCmp>  ExportNameMap;
+    typedef std::vector<std::string> ArgVec;
+    typedef std::map<std::pair<const void*,void*>,void*> UserMap;
+    typedef std::map<const char*, int, VerilatedCStrCmp>  ExportNameMap;
 
     // MEMBERS
-    static VerilatedImp	s_s;		///< Static Singleton; One and only static this
+    static VerilatedImp s_s;  ///< Static Singleton; One and only static this
 
     // Nothing here is save-restored; users expected to re-register appropriately
 
-    ArgVec		m_argVec;	///< Argument list (NOT save-restored, may want different results)
-    bool		m_argVecLoaded;	///< Ever loaded argument list
-    UserMap	 	m_userMap;	///< Map of <(scope,userkey), userData>
-    ScopeNameMap	m_nameMap;	///< Map of <scope_name, scope pointer>
+    VerilatedMutex      m_argMutex;  ///< Protect m_argVec, m_argVecLoaded
+    ArgVec              m_argVec VL_GUARDED_BY(m_argMutex);  ///< Argument list (NOT save-restored, may want different results)
+    bool                m_argVecLoaded VL_GUARDED_BY(m_argMutex);  ///< Ever loaded argument list
+
+    VerilatedMutex      m_userMapMutex;  ///< Protect m_userMap
+    UserMap             m_userMap VL_GUARDED_BY(m_userMapMutex);  ///< Map of <(scope,userkey), userData>
+
+    VerilatedMutex      m_nameMutex;  ///< Protect m_nameMap
+    VerilatedScopeNameMap m_nameMap VL_GUARDED_BY(m_nameMutex);  ///< Map of <scope_name, scope pointer>
     // Slow - somewhat static:
-    ExportNameMap	m_exportMap;	///< Map of <export_func_proto, func number>
-    int			m_exportNext;	///< Next export funcnum
+    VerilatedMutex      m_exportMutex;  ///< Protect m_nameMap
+    ExportNameMap       m_exportMap VL_GUARDED_BY(m_exportMutex);  ///< Map of <export_func_proto, func number>
+    int                 m_exportNext VL_GUARDED_BY(m_exportMutex);  ///< Next export funcnum
 
     // File I/O
-    vector<FILE*>	m_fdps;		///< File descriptors
-    deque<IData>	m_fdFree;	///< List of free descriptors (SLOW - FOPEN/CLOSE only)
+    VerilatedMutex      m_fdMutex;  ///< Protect m_fdps, m_fdFree
+    std::vector<FILE*>  m_fdps VL_GUARDED_BY(m_fdMutex);  ///< File descriptors
+    std::deque<IData>   m_fdFree VL_GUARDED_BY(m_fdMutex);  ///< List of free descriptors (SLOW - FOPEN/CLOSE only)
 
-public: // But only for verilated*.cpp
+public:  // But only for verilated*.cpp
     // CONSTRUCTORS
-    VerilatedImp() : m_argVecLoaded(false), m_exportNext(0) {
-	m_fdps.resize(3);
-	m_fdps[0] = stdin;
-	m_fdps[1] = stdout;
-	m_fdps[2] = stderr;
+    VerilatedImp()
+        : m_argVecLoaded(false), m_exportNext(0) {
+        m_fdps.resize(3);
+        m_fdps[0] = stdin;
+        m_fdps[1] = stdout;
+        m_fdps[2] = stderr;
     }
     ~VerilatedImp() {}
-    static void internalsDump() {
-	VL_PRINTF("internalsDump:\n");
-	VL_PRINTF("  Argv:");
-	for (ArgVec::iterator it=s_s.m_argVec.begin(); it!=s_s.m_argVec.end(); ++it) {
-	    VL_PRINTF(" %s",it->c_str());
-	}
-	VL_PRINTF("\n");
-	VL_PRINTF("  Version: %s %s\n", Verilated::productName(), Verilated::productVersion());
-	scopesDump();
-	exportsDump();
-	userDump();
-    }
+private:
+    VL_UNCOPYABLE(VerilatedImp);
+public:
+    // METHODS - debug
+    static void internalsDump() VL_MT_SAFE;
+    static void versionDump() VL_MT_SAFE;
 
     // METHODS - arguments
-    static void commandArgs(int argc, const char** argv) {
-	s_s.m_argVec.clear();
-	for (int i=0; i<argc; i++) s_s.m_argVec.push_back(argv[i]);
-	s_s.m_argVecLoaded = true; // Can't just test later for empty vector, no arguments is ok
-    }
-    static string argPlusMatch(const char* prefixp) {
-	// Note prefixp does not include the leading "+"
-	size_t len = strlen(prefixp);
-	if (VL_UNLIKELY(!s_s.m_argVecLoaded)) {
-	    s_s.m_argVecLoaded = true;  // Complain only once
-	    vl_fatal("unknown",0,"",
-		     "%Error: Verilog called $test$plusargs or $value$plusargs without"
-		     " testbench C first calling Verilated::commandArgs(argc,argv).");
-	}
-	for (ArgVec::iterator it=s_s.m_argVec.begin(); it!=s_s.m_argVec.end(); ++it) {
-	    if ((*it)[0]=='+') {
-		if (0==strncmp(prefixp, it->c_str()+1, len)) return *it;
-	    }
-	}
-	return "";
+public:
+    static void commandArgs(int argc, const char** argv) VL_EXCLUDES(s_s.m_argMutex);
+    static void commandArgsAdd(int argc, const char** argv) VL_EXCLUDES(s_s.m_argMutex);
+    static std::string argPlusMatch(const char* prefixp) VL_EXCLUDES(s_s.m_argMutex) {
+        VerilatedLockGuard lock(s_s.m_argMutex);
+        // Note prefixp does not include the leading "+"
+        size_t len = strlen(prefixp);
+        if (VL_UNLIKELY(!s_s.m_argVecLoaded)) {
+            s_s.m_argVecLoaded = true;  // Complain only once
+            VL_FATAL_MT("unknown", 0, "",
+                        "%Error: Verilog called $test$plusargs or $value$plusargs without"
+                        " testbench C first calling Verilated::commandArgs(argc,argv).");
+        }
+        for (ArgVec::const_iterator it=s_s.m_argVec.begin(); it!=s_s.m_argVec.end(); ++it) {
+            if ((*it)[0]=='+') {
+                if (0==strncmp(prefixp, it->c_str()+1, len)) return *it;
+            }
+        }
+        return "";
     }
+private:
+    static void commandArgsAddGuts(int argc, const char** argv) VL_REQUIRES(s_s.m_argMutex);
+    static void commandArgVl(const std::string& arg);
+    static bool commandArgVlValue(const std::string& arg,
+                                  const std::string& prefix, std::string& valuer);
 
+public:
     // METHODS - user scope tracking
     // We implement this as a single large map instead of one map per scope
     // There's often many more scopes than userdata's and thus having a ~48byte
     // per map overhead * N scopes would take much more space and cache thrashing.
-    static inline void userInsert(const void* scopep, void* userKey, void* userData) {
-	UserMap::iterator it=s_s.m_userMap.find(make_pair(scopep,userKey));
-	if (it != s_s.m_userMap.end()) it->second = userData;
-	// When we support VL_THREADs, we need a lock around this insert, as it's runtime
-	else s_s.m_userMap.insert(it, make_pair(make_pair(scopep,userKey),userData));
+    static inline void userInsert(const void* scopep, void* userKey, void* userData) VL_MT_SAFE {
+        VerilatedLockGuard lock(s_s.m_userMapMutex);
+        UserMap::iterator it=s_s.m_userMap.find(std::make_pair(scopep, userKey));
+        if (it != s_s.m_userMap.end()) it->second = userData;
+        // When we support VL_THREADs, we need a lock around this insert, as it's runtime
+        else s_s.m_userMap.insert(it, std::make_pair(std::make_pair(scopep, userKey), userData));
     }
-    static inline void* userFind(const void* scopep, void* userKey) {
-	UserMap::iterator it=s_s.m_userMap.find(make_pair(scopep,userKey));
-	if (VL_LIKELY(it != s_s.m_userMap.end())) return it->second;
-	else return NULL;
+    static inline void* userFind(const void* scopep, void* userKey) VL_MT_SAFE {
+        VerilatedLockGuard lock(s_s.m_userMapMutex);
+        UserMap::const_iterator it=s_s.m_userMap.find(std::make_pair(scopep, userKey));
+        if (VL_LIKELY(it != s_s.m_userMap.end())) return it->second;
+        else return NULL;
     }
 private:
     /// Symbol table destruction cleans up the entries for each scope.
-    static void userEraseScope(const VerilatedScope* scopep) {
-	// Slow ok - called once/scope on destruction, so we simply iterate.
-	for (UserMap::iterator it=s_s.m_userMap.begin(); it!=s_s.m_userMap.end(); ) {
-	    if (it->first.first == scopep) {
-		s_s.m_userMap.erase(it++);
-	    } else {
-		++it;
-	    }
-	}
+    static void userEraseScope(const VerilatedScope* scopep) VL_MT_SAFE {
+        // Slow ok - called once/scope on destruction, so we simply iterate.
+        VerilatedLockGuard lock(s_s.m_userMapMutex);
+        for (UserMap::iterator it=s_s.m_userMap.begin(); it!=s_s.m_userMap.end(); ) {
+            if (it->first.first == scopep) {
+                s_s.m_userMap.erase(it++);
+            } else {
+                ++it;
+            }
+        }
     }
-    static void userDump() {
-	bool first = true;
-	for (UserMap::iterator it=s_s.m_userMap.begin(); it!=s_s.m_userMap.end(); ++it) {
-	    if (first) { VL_PRINTF("  userDump:\n"); first=false; }
-	    VL_PRINTF("    DPI_USER_DATA scope %p key %p: %p\n",
-		      it->first.first, it->first.second, it->second);
-	}
+    static void userDump() VL_MT_SAFE {
+        VerilatedLockGuard lock(s_s.m_userMapMutex);  // Avoid it changing in middle of dump
+        bool first = true;
+        for (UserMap::const_iterator it=s_s.m_userMap.begin(); it!=s_s.m_userMap.end(); ++it) {
+            if (first) { VL_PRINTF_MT("  userDump:\n"); first=false; }
+            VL_PRINTF_MT("    DPI_USER_DATA scope %p key %p: %p\n",
+                      it->first.first, it->first.second, it->second);
+        }
     }
 
-public: // But only for verilated*.cpp
+public:  // But only for verilated*.cpp
     // METHODS - scope name
-    static void scopeInsert(const VerilatedScope* scopep) {
-	// Slow ok - called once/scope at construction
-	ScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
-	if (it == s_s.m_nameMap.end()) {
-	    s_s.m_nameMap.insert(it, make_pair(scopep->name(),scopep));
-	}
+    static void scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE {
+        // Slow ok - called once/scope at construction
+        VerilatedLockGuard lock(s_s.m_nameMutex);
+        VerilatedScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
+        if (it == s_s.m_nameMap.end()) {
+            s_s.m_nameMap.insert(it, std::make_pair(scopep->name(), scopep));
+        }
     }
-    static inline const VerilatedScope* scopeFind(const char* namep) {
-	ScopeNameMap::iterator it=s_s.m_nameMap.find(namep);
-	if (VL_LIKELY(it != s_s.m_nameMap.end())) return it->second;
-	else return NULL;
+    static inline const VerilatedScope* scopeFind(const char* namep) VL_MT_SAFE {
+        VerilatedLockGuard lock(s_s.m_nameMutex);
+        // If too slow, can assume this is only VL_MT_SAFE_POSINIT
+        VerilatedScopeNameMap::const_iterator it=s_s.m_nameMap.find(namep);
+        if (VL_LIKELY(it != s_s.m_nameMap.end())) return it->second;
+        else return NULL;
     }
-    static void scopeErase(const VerilatedScope* scopep) {
-	// Slow ok - called once/scope at destruction
-	userEraseScope(scopep);
-	ScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
-	if (it != s_s.m_nameMap.end()) s_s.m_nameMap.erase(it);
+    static void scopeErase(const VerilatedScope* scopep) VL_MT_SAFE {
+        // Slow ok - called once/scope at destruction
+        VerilatedLockGuard lock(s_s.m_nameMutex);
+        userEraseScope(scopep);
+        VerilatedScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
+        if (it != s_s.m_nameMap.end()) s_s.m_nameMap.erase(it);
     }
-    static void scopesDump() {
-	VL_PRINTF("  scopesDump:\n");
-	for (ScopeNameMap::iterator it=s_s.m_nameMap.begin(); it!=s_s.m_nameMap.end(); ++it) {
-	    const VerilatedScope* scopep = it->second;
-	    scopep->scopeDump();
-	}
-	VL_PRINTF("\n");
+    static void scopesDump() VL_MT_SAFE {
+        VerilatedLockGuard lock(s_s.m_nameMutex);
+        VL_PRINTF_MT("  scopesDump:\n");
+        for (VerilatedScopeNameMap::const_iterator it=s_s.m_nameMap.begin();
+             it!=s_s.m_nameMap.end(); ++it) {
+            const VerilatedScope* scopep = it->second;
+            scopep->scopeDump();
+        }
+        VL_PRINTF_MT("\n");
+    }
+    static const VerilatedScopeNameMap* scopeNameMap() VL_MT_SAFE_POSTINIT {
+        // Thread save only assuming this is called only after model construction completed
+        return &s_s.m_nameMap;
     }
 
-public: // But only for verilated*.cpp
+public:  // But only for verilated*.cpp
     // METHODS - export names
 
     // Each function prototype is converted to a function number which we
@@ -188,68 +330,79 @@ public: // But only for verilated*.cpp
     // in the design that also happen to have our same callback function.
     // Rather than a 2D map, the integer scheme saves 500ish ns on a likely
     // miss at the cost of a multiply, and all lookups move to slowpath.
-    static int exportInsert(const char* namep) {
-	// Slow ok - called once/function at creation
-	ExportNameMap::iterator it=s_s.m_exportMap.find(namep);
-	if (it == s_s.m_exportMap.end()) {
-	    s_s.m_exportMap.insert(it, make_pair(namep, s_s.m_exportNext++));
-	    return s_s.m_exportNext++;
-	} else {
-	    return it->second;
-	}
+    static int exportInsert(const char* namep) VL_MT_SAFE {
+        // Slow ok - called once/function at creation
+        VerilatedLockGuard lock(s_s.m_exportMutex);
+        ExportNameMap::iterator it=s_s.m_exportMap.find(namep);
+        if (it == s_s.m_exportMap.end()) {
+            s_s.m_exportMap.insert(it, std::make_pair(namep, s_s.m_exportNext++));
+            return s_s.m_exportNext++;
+        } else {
+            return it->second;
+        }
     }
-    static int exportFind(const char* namep) {
-	ExportNameMap::iterator it=s_s.m_exportMap.find(namep);
-	if (VL_LIKELY(it != s_s.m_exportMap.end())) return it->second;
-	string msg = (string("%Error: Testbench C called ")+namep
-		      +" but no such DPI export function name exists in ANY model");
-	vl_fatal("unknown",0,"", msg.c_str());
-	return -1;
+    static int exportFind(const char* namep) VL_MT_SAFE {
+        VerilatedLockGuard lock(s_s.m_exportMutex);
+        ExportNameMap::const_iterator it=s_s.m_exportMap.find(namep);
+        if (VL_LIKELY(it != s_s.m_exportMap.end())) return it->second;
+        std::string msg = (std::string("%Error: Testbench C called ")+namep
+                           +" but no such DPI export function name exists in ANY model");
+        VL_FATAL_MT("unknown", 0, "", msg.c_str());
+        return -1;
     }
-    static const char* exportName(int funcnum) {
-	// Slowpath; find name for given export; errors only so no map to reverse-map it
-	for (ExportNameMap::iterator it=s_s.m_exportMap.begin(); it!=s_s.m_exportMap.end(); ++it) {
-	    if (it->second == funcnum) return it->first;
-	}
-	return "*UNKNOWN*";
+    static const char* exportName(int funcnum) VL_MT_SAFE {
+        // Slowpath; find name for given export; errors only so no map to reverse-map it
+        VerilatedLockGuard lock(s_s.m_exportMutex);
+        for (ExportNameMap::const_iterator it=s_s.m_exportMap.begin();
+             it!=s_s.m_exportMap.end(); ++it) {
+            if (it->second == funcnum) return it->first;
+        }
+        return "*UNKNOWN*";
     }
-    static void exportsDump() {
-	bool first = true;
-	for (ExportNameMap::iterator it=s_s.m_exportMap.begin(); it!=s_s.m_exportMap.end(); ++it) {
-	    if (first) { VL_PRINTF("  exportDump:\n"); first=false; }
-	    VL_PRINTF("    DPI_EXPORT_NAME %05d: %s\n", it->second, it->first);
-	}
+    static void exportsDump() VL_MT_SAFE {
+        VerilatedLockGuard lock(s_s.m_exportMutex);
+        bool first = true;
+        for (ExportNameMap::const_iterator it=s_s.m_exportMap.begin();
+             it!=s_s.m_exportMap.end(); ++it) {
+            if (first) { VL_PRINTF_MT("  exportDump:\n"); first=false; }
+            VL_PRINTF_MT("    DPI_EXPORT_NAME %05d: %s\n", it->second, it->first);
+        }
     }
     // We don't free up m_exportMap until the end, because we can't be sure
     // what other models are using the assigned funcnum's.
 
-public: // But only for verilated*.cpp
+public:  // But only for verilated*.cpp
     // METHODS - file IO
-    static IData fdNew(FILE* fp) {
-	if (VL_UNLIKELY(!fp)) return 0;
-	// Bit 31 indicates it's a descriptor not a MCD
-	if (s_s.m_fdFree.empty()) {
-	    // Need to create more space in m_fdps and m_fdFree
-	    size_t start = s_s.m_fdps.size();
-	    s_s.m_fdps.resize(start*2);
-	    for (size_t i=start; i<start*2; i++) s_s.m_fdFree.push_back((IData)i);
-	}
-	IData idx = s_s.m_fdFree.back(); s_s.m_fdFree.pop_back();
-	s_s.m_fdps[idx] = fp;
-	return (idx | (1UL<<31));  // bit 31 indicates not MCD
+    static IData fdNew(FILE* fp) VL_MT_SAFE {
+        if (VL_UNLIKELY(!fp)) return 0;
+        // Bit 31 indicates it's a descriptor not a MCD
+        VerilatedLockGuard lock(s_s.m_fdMutex);
+        if (s_s.m_fdFree.empty()) {
+            // Need to create more space in m_fdps and m_fdFree
+            size_t start = s_s.m_fdps.size();
+            s_s.m_fdps.resize(start*2);
+            for (size_t i=start; i<start*2; ++i) s_s.m_fdFree.push_back(static_cast<IData>(i));
+        }
+        IData idx = s_s.m_fdFree.back(); s_s.m_fdFree.pop_back();
+        s_s.m_fdps[idx] = fp;
+        return (idx | (1UL<<31));  // bit 31 indicates not MCD
     }
-    static void fdDelete(IData fdi) {
-	IData idx = VL_MASK_I(31) & fdi;
-	if (VL_UNLIKELY(!(fdi & (1ULL<<31)) || idx >= s_s.m_fdps.size())) return;
-	if (VL_UNLIKELY(!s_s.m_fdps[idx])) return;  // Already free
-	s_s.m_fdps[idx] = NULL;
-	s_s.m_fdFree.push_back(idx);
+    static void fdDelete(IData fdi) VL_MT_SAFE {
+        IData idx = VL_MASK_I(31) & fdi;
+        VerilatedLockGuard lock(s_s.m_fdMutex);
+        if (VL_UNLIKELY(!(fdi & (1ULL<<31)) || idx >= s_s.m_fdps.size())) return;
+        if (VL_UNLIKELY(!s_s.m_fdps[idx])) return;  // Already free
+        s_s.m_fdps[idx] = NULL;
+        s_s.m_fdFree.push_back(idx);
     }
-    static inline FILE* fdToFp(IData fdi) {
-	IData idx = VL_MASK_I(31) & fdi;
-	if (VL_UNLIKELY(!(fdi & (1ULL<<31)) || idx >= s_s.m_fdps.size())) return NULL;
-	return s_s.m_fdps[idx];
+    static inline FILE* fdToFp(IData fdi) VL_MT_SAFE {
+        IData idx = VL_MASK_I(31) & fdi;
+        VerilatedLockGuard lock(s_s.m_fdMutex);  // This might get slow, if it does we can cache it
+        if (VL_UNLIKELY(!(fdi & (1ULL<<31)) || idx >= s_s.m_fdps.size())) return NULL;
+        return s_s.m_fdps[idx];
     }
 };
 
+//======================================================================
+
 #endif  // Guard

include/verilated_save.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2019 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.
 //
@@ -23,8 +23,8 @@
 #include "verilated.h"
 #include "verilated_save.h"
 
-#include <fcntl.h>
 #include <cerrno>
+#include <fcntl.h>
 
 #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
 # include <io.h>
@@ -32,43 +32,48 @@
 # include <unistd.h>
 #endif
 
-#ifndef O_LARGEFILE // For example on WIN32
+#ifndef O_LARGEFILE  // For example on WIN32
 # define O_LARGEFILE 0
 #endif
 #ifndef O_NONBLOCK
 # define O_NONBLOCK 0
 #endif
+#ifndef O_CLOEXEC
+# define O_CLOEXEC 0
+#endif
 
 // CONSTANTS
-static const char* VLTSAVE_HEADER_STR = "verilatorsave01\n";	///< Value of first bytes of each file
-static const char* VLTSAVE_TRAILER_STR = "vltsaved";	///< Value of last bytes of each file
+static const char* const VLTSAVE_HEADER_STR = "verilatorsave01\n";  ///< Value of first bytes of each file
+static const char* const VLTSAVE_TRAILER_STR = "vltsaved";  ///< Value of last bytes of each file
 
 //=============================================================================
 //=============================================================================
 //=============================================================================
 // Searalization
 
-bool VerilatedDeserialize::readDiffers (const void* __restrict datap, size_t size) {
+bool VerilatedDeserialize::readDiffers(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
     bufferCheck();
-    const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
+    const vluint8_t* __restrict dp = static_cast<const vluint8_t* __restrict>(datap);
     vluint8_t miss = 0;
     while (size--) {
-	miss |= (*dp++ ^ *m_cp++);
+        miss |= (*dp++ ^ *m_cp++);
     }
     return (miss!=0);
 }
 
-VerilatedDeserialize& VerilatedDeserialize::readAssert (const void* __restrict datap, size_t size) {
-    if (VL_UNLIKELY(readDiffers(datap,size))) {
-	string fn = filename();
-	string msg = (string)"Can't deserialize save-restore file as was made from different model";
-	vl_fatal(fn.c_str(), 0, "", msg.c_str());
-	close();
+VerilatedDeserialize& VerilatedDeserialize::readAssert(const void* __restrict datap,
+                                                       size_t size) VL_MT_UNSAFE_ONE {
+    if (VL_UNLIKELY(readDiffers(datap, size))) {
+        std::string fn = filename();
+        std::string msg = "Can't deserialize save-restore file as was made from different model:"
+            +filename();
+        VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
+        close();
     }
     return *this;  // For function chaining
 }
 
-void VerilatedSerialize::header() {
+void VerilatedSerialize::header() VL_MT_UNSAFE_ONE {
     VerilatedSerialize& os = *this;  // So can cut and paste standard << code below
     assert((strlen(VLTSAVE_HEADER_STR) & 7) == 0);  // Keep aligned
     os.write(VLTSAVE_HEADER_STR, strlen(VLTSAVE_HEADER_STR));
@@ -78,30 +83,32 @@ void VerilatedSerialize::header() {
     os.write(Verilated::serializedPtr(), Verilated::serializedSize());
 }
 
-void VerilatedDeserialize::header() {
+void VerilatedDeserialize::header() VL_MT_UNSAFE_ONE {
     VerilatedDeserialize& os = *this;  // So can cut and paste standard >> code below
     if (VL_UNLIKELY(os.readDiffers(VLTSAVE_HEADER_STR, strlen(VLTSAVE_HEADER_STR)))) {
-	string fn = filename();
-	string msg = (string)"Can't deserialize; file has wrong header signature";
-	vl_fatal(fn.c_str(), 0, "", msg.c_str());
-	close();
+        std::string fn = filename();
+        std::string msg = std::string("Can't deserialize; file has wrong header signature: ")
+            +filename();
+        VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
+        close();
     }
     os.read(Verilated::serializedPtr(), Verilated::serializedSize());
 }
 
-void VerilatedSerialize::trailer() {
+void VerilatedSerialize::trailer() VL_MT_UNSAFE_ONE {
     VerilatedSerialize& os = *this;  // So can cut and paste standard << code below
     assert((strlen(VLTSAVE_TRAILER_STR) & 7) == 0);  // Keep aligned
     os.write(VLTSAVE_TRAILER_STR, strlen(VLTSAVE_TRAILER_STR));
 }
 
-void VerilatedDeserialize::trailer() {
+void VerilatedDeserialize::trailer() VL_MT_UNSAFE_ONE {
     VerilatedDeserialize& os = *this;  // So can cut and paste standard >> code below
     if (VL_UNLIKELY(os.readDiffers(VLTSAVE_TRAILER_STR, strlen(VLTSAVE_TRAILER_STR)))) {
-	string fn = filename();
-	string msg = (string)"Can't deserialize; file has wrong end-of-file signature";
-	vl_fatal(fn.c_str(), 0, "", msg.c_str());
-	close();
+        std::string fn = filename();
+        std::string msg = std::string("Can't deserialize; file has wrong end-of-file signature: ")
+            +filename();
+        VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
+        close();
     }
 }
 
@@ -110,21 +117,22 @@ void VerilatedDeserialize::trailer() {
 //=============================================================================
 // Opening/Closing
 
-void VerilatedSave::open (const char* filenamep) {
+void VerilatedSave::open(const char* filenamep) VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
     if (isOpen()) return;
-    VL_DEBUG_IF(VL_PRINTF("-vltSave: opening save file %s\n",filenamep););
+    VL_DEBUG_IF(VL_DBG_MSGF("- save: opening save file %s\n", filenamep););
 
     if (filenamep[0]=='|') {
-	assert(0);	// Not supported yet.
+        assert(0);  // Not supported yet.
     } else {
-	// cppcheck-suppress duplicateExpression
-	m_fd = ::open (filenamep, O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK
-		       , 0666);
-	if (m_fd<0) {
-	    // User code can check isOpen()
-	    m_isOpen = false;
-	    return;
-	}
+        // cppcheck-suppress duplicateExpression
+        m_fd = ::open(filenamep, O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK|O_CLOEXEC
+                      , 0666);
+        if (m_fd<0) {
+            // User code can check isOpen()
+            m_isOpen = false;
+            return;
+        }
     }
     m_isOpen = true;
     m_filename = filenamep;
@@ -132,21 +140,22 @@ void VerilatedSave::open (const char* filenamep) {
     header();
 }
 
-void VerilatedRestore::open (const char* filenamep) {
+void VerilatedRestore::open(const char* filenamep) VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
     if (isOpen()) return;
-    VL_DEBUG_IF(VL_PRINTF("-vltRestore: opening restore file %s\n",filenamep););
+    VL_DEBUG_IF(VL_DBG_MSGF("- restore: opening restore file %s\n", filenamep););
 
     if (filenamep[0]=='|') {
-	assert(0);	// Not supported yet.
+        assert(0);  // Not supported yet.
     } else {
-	// cppcheck-suppress duplicateExpression
-	m_fd = ::open (filenamep, O_CREAT|O_RDONLY|O_LARGEFILE
-		       , 0666);
-	if (m_fd<0) {
-	    // User code can check isOpen()
-	    m_isOpen = false;
-	    return;
-	}
+        // cppcheck-suppress duplicateExpression
+        m_fd = ::open(filenamep, O_CREAT|O_RDONLY|O_LARGEFILE|O_CLOEXEC
+                      , 0666);
+        if (m_fd<0) {
+            // User code can check isOpen()
+            m_isOpen = false;
+            return;
+        }
     }
     m_isOpen = true;
     m_filename = filenamep;
@@ -155,7 +164,7 @@ void VerilatedRestore::open (const char* filenamep) {
     header();
 }
 
-void VerilatedSave::close () {
+void VerilatedSave::close() VL_MT_UNSAFE_ONE {
     if (!isOpen()) return;
     trailer();
     flush();
@@ -163,7 +172,7 @@ void VerilatedSave::close () {
     ::close(m_fd);  // May get error, just ignore it
 }
 
-void VerilatedRestore::close () {
+void VerilatedRestore::close() VL_MT_UNSAFE_ONE {
     if (!isOpen()) return;
     trailer();
     flush();
@@ -174,61 +183,62 @@ void VerilatedRestore::close () {
 //=============================================================================
 // Buffer management
 
-void VerilatedSave::flush() {
+void VerilatedSave::flush() VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
     if (VL_UNLIKELY(!isOpen())) return;
     vluint8_t* wp = m_bufp;
     while (1) {
-	ssize_t remaining = (m_cp - wp);
-	if (remaining==0) break;
-	errno = 0;
-	ssize_t got = ::write (m_fd, wp, remaining);
-	if (got>0) {
-	    wp += got;
-	} else if (got < 0) {
-	    if (errno != EAGAIN && errno != EINTR) {
-		// write failed, presume error (perhaps out of disk space)
-		string msg = string(__FUNCTION__)+": "+strerror(errno);
-		vl_fatal("",0,"",msg.c_str());
-		close();
-		break;
-	    }
-	}
+        ssize_t remaining = (m_cp - wp);
+        if (remaining==0) break;
+        errno = 0;
+        ssize_t got = ::write(m_fd, wp, remaining);
+        if (got>0) {
+            wp += got;
+        } else if (got < 0) {
+            if (errno != EAGAIN && errno != EINTR) {
+                // write failed, presume error (perhaps out of disk space)
+                std::string msg = std::string(__FUNCTION__)+": "+strerror(errno);
+                VL_FATAL_MT("", 0, "", msg.c_str());
+                close();
+                break;
+            }
+        }
     }
-    m_cp = m_bufp; // Reset buffer
+    m_cp = m_bufp;  // Reset buffer
 }
 
-void VerilatedRestore::fill() {
+void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
     if (VL_UNLIKELY(!isOpen())) return;
     // Move remaining characters down to start of buffer.  (No memcpy, overlaps allowed)
     vluint8_t* rp = m_bufp;
-    for (vluint8_t* sp=m_cp; rp < m_endp;) *rp++ = *sp++;  // Overlaps
+    for (vluint8_t* sp=m_cp; sp < m_endp;) *rp++ = *sp++;  // Overlaps
     m_endp = m_bufp + (m_endp - m_cp);
-    m_cp = m_bufp; // Reset buffer
-    // Read into buffer starting at m_endp 
+    m_cp = m_bufp;  // Reset buffer
+    // Read into buffer starting at m_endp
     while (1) {
-	ssize_t remaining = (m_bufp+bufferSize() - m_endp);
-	if (remaining==0) break;
-	errno = 0;
-	ssize_t got = ::read (m_fd, m_endp, remaining);
-	if (got>0) {
-	    m_endp += got;
-	} else if (got < 0) {
-	    if (errno != EAGAIN && errno != EINTR) {
-		// write failed, presume error (perhaps out of disk space)
-		string msg = string(__FUNCTION__)+": "+strerror(errno);
-		vl_fatal("",0,"",msg.c_str());
-		close();
-		break;
-	    }
-	} else { // got==0, EOF
-	    // Fill buffer from here to end with NULLs so reader's don't need to check eof each character.
-	    while (m_endp < m_bufp+bufferSize()) *m_endp++ = '\0';
-	    break;
-	}
+        ssize_t remaining = (m_bufp+bufferSize() - m_endp);
+        if (remaining==0) break;
+        errno = 0;
+        ssize_t got = ::read(m_fd, m_endp, remaining);
+        if (got>0) {
+            m_endp += got;
+        } else if (got < 0) {
+            if (errno != EAGAIN && errno != EINTR) {
+                // write failed, presume error (perhaps out of disk space)
+                std::string msg = std::string(__FUNCTION__)+": "+strerror(errno);
+                VL_FATAL_MT("", 0, "", msg.c_str());
+                close();
+                break;
+            }
+        } else {  // got==0, EOF
+            // Fill buffer from here to end with NULLs so reader's don't
+            // need to check eof each character.
+            while (m_endp < m_bufp+bufferSize()) *m_endp++ = '\0';
+            break;
+        }
     }
 }
 
 //=============================================================================
 // Serialization of types
-
-

include/verilated_save.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2012-2015 by Wilson Snyder.  This program is free software;
+// Copyright 2012-2019 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.
 //
@@ -25,152 +25,171 @@
 #include "verilatedos.h"
 
 #include <string>
-using namespace std;
 
 //=============================================================================
-// VerilatedSerialBase - internal base class for common code between VerilatedSerialize and VerilatedDeserialize
+// VerilatedSerialize - convert structures to a stream representation
+// This class is not thread safe, it must be called by a single thread
 
-class VerilatedSerialBase {
+class VerilatedSerialize {
 protected:
     // MEMBERS
     // For speed, keep m_cp as the first member of this structure
-    vluint8_t*		m_cp;		///< Current pointer into m_bufp buffer
-    vluint8_t*		m_bufp;		///< Output buffer
-    bool 		m_isOpen;	///< True indicates open file/stream
-    string		m_filename;
+    vluint8_t*          m_cp;           ///< Current pointer into m_bufp buffer
+    vluint8_t*          m_bufp;         ///< Output buffer
+    bool                m_isOpen;       ///< True indicates open file/stream
+    std::string         m_filename;     ///< Filename, for error messages
+    VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread
 
     inline static size_t bufferSize() { return 256*1024; }  // See below for slack calculation
     inline static size_t bufferInsertSize() { return 16*1024; }
 
-    // CREATORS
-    VerilatedSerialBase() {
-	m_isOpen = false;
-	m_bufp = new vluint8_t [bufferSize()];
-	m_cp = m_bufp;
-    }
+    void header() VL_MT_UNSAFE_ONE;
+    void trailer() VL_MT_UNSAFE_ONE;
+
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedSerialize);
 public:
-    // CREATORS
-    virtual ~VerilatedSerialBase() {
-	close();
-	if (m_bufp) { delete m_bufp; m_bufp=NULL; }
+    VerilatedSerialize() {
+        m_isOpen = false;
+        m_bufp = new vluint8_t [bufferSize()];
+        m_cp = m_bufp;
+    }
+    virtual ~VerilatedSerialize() {
+        close();
+        if (m_bufp) { delete m_bufp; m_bufp=NULL; }
     }
     // METHODS
     bool isOpen() const { return m_isOpen; }
-    string filename() const { return m_filename; }
-    virtual void close() { flush(); }
-    virtual void flush() {}
-};
-
-//=============================================================================
-// VerilatedSerialize - convert structures to a stream representation
-
-class VerilatedSerialize : public VerilatedSerialBase {
-protected:
-    virtual void close() { flush(); }
-    virtual void flush() {}
-    void header();
-    void trailer();
-public:
-    // CREATORS
-    VerilatedSerialize() {}
-    virtual ~VerilatedSerialize() { close(); }
-    // METHODS
-    VerilatedSerialize& bufferCheck() {
-	// Flush the write buffer if there's not enough space left for new information
-	// We only call this once per vector, so we need enough slop for a very wide "b###" line
-	if (VL_UNLIKELY(m_cp > (m_bufp+(bufferSize()-bufferInsertSize())))) {
-	    flush();
-	}
-	return *this;  // For function chaining
+    std::string filename() const { return m_filename; }
+    virtual void close() VL_MT_UNSAFE_ONE { flush(); }
+    virtual void flush() VL_MT_UNSAFE_ONE {}
+    inline VerilatedSerialize& write(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
+        const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
+        while (size) {
+            bufferCheck();
+            size_t blk = size;  if (blk>bufferInsertSize()) blk = bufferInsertSize();
+            const vluint8_t* __restrict maxp = dp + blk;
+            while (dp < maxp) *m_cp++ = *dp++;
+            size -= blk;
+        }
+        return *this;  // For function chaining
     }
-    inline VerilatedSerialize& write (const void* __restrict datap, size_t size) {
-	const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
-	while (size) {
-	    bufferCheck();
-	    size_t blk = size;  if (blk>bufferInsertSize()) blk = bufferInsertSize();
-	    const vluint8_t* __restrict maxp = dp + blk;
-	    while (dp < maxp) *m_cp++ = *dp++;
-	    size -= blk;
-	}
-	return *this;  // For function chaining
+private:
+    VerilatedSerialize& bufferCheck() VL_MT_UNSAFE_ONE {
+        // Flush the write buffer if there's not enough space left for new information
+        // We only call this once per vector, so we need enough slop for a very wide "b###" line
+        if (VL_UNLIKELY(m_cp > (m_bufp+(bufferSize()-bufferInsertSize())))) {
+            flush();
+        }
+        return *this;  // For function chaining
     }
 };
 
 //=============================================================================
 // VerilatedDeserial - load structures from a stream representation
+// This class is not thread safe, it must be called by a single thread
 
-class VerilatedDeserialize : public VerilatedSerialBase {
+class VerilatedDeserialize {
 protected:
-    vluint8_t*		m_endp;		///< Last valid byte in m_bufp buffer
+    // MEMBERS
+    // For speed, keep m_cp as the first member of this structure
+    vluint8_t*          m_cp;           ///< Current pointer into m_bufp buffer
+    vluint8_t*          m_bufp;         ///< Output buffer
+    vluint8_t*          m_endp;         ///< Last valid byte in m_bufp buffer
+    bool                m_isOpen;       ///< True indicates open file/stream
+    std::string         m_filename;     ///< Filename, for error messages
+    VerilatedAssertOneThread m_assertOne;       ///< Assert only called from single thread
+
+    inline static size_t bufferSize() { return 256*1024; }  // See below for slack calculation
+    inline static size_t bufferInsertSize() { return 16*1024; }
+
     virtual void fill() = 0;
-    void header();
-    void trailer();
+    void header() VL_MT_UNSAFE_ONE;
+    void trailer() VL_MT_UNSAFE_ONE;
+
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedDeserialize);
 public:
-    // CREATORS
-    VerilatedDeserialize() { m_endp = NULL; }
-    virtual ~VerilatedDeserialize() { close(); }
+    VerilatedDeserialize() {
+        m_isOpen = false;
+        m_bufp = new vluint8_t [bufferSize()];
+        m_cp = m_bufp;
+        m_endp = NULL;
+    }
+    virtual ~VerilatedDeserialize() {
+        close();
+        if (m_bufp) { delete m_bufp; m_bufp=NULL; }
+    }
     // METHODS
-    inline VerilatedDeserialize& read (void* __restrict datap, size_t size) {
-	vluint8_t* __restrict dp = (vluint8_t* __restrict)datap;
-	while (size) {
-	    bufferCheck();
-	    size_t blk = size;  if (blk>bufferInsertSize()) blk = bufferInsertSize();
-	    const vluint8_t* __restrict maxp = dp + blk;
-	    while (dp < maxp) *dp++ = *m_cp++;
-	    size -= blk;
-	}
-	return *this;  // For function chaining
+    bool isOpen() const { return m_isOpen; }
+    std::string filename() const { return m_filename; }
+    virtual void close() VL_MT_UNSAFE_ONE { flush(); }
+    virtual void flush() VL_MT_UNSAFE_ONE {}
+    inline VerilatedDeserialize& read(void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
+        vluint8_t* __restrict dp = (vluint8_t* __restrict)datap;
+        while (size) {
+            bufferCheck();
+            size_t blk = size;  if (blk>bufferInsertSize()) blk = bufferInsertSize();
+            const vluint8_t* __restrict maxp = dp + blk;
+            while (dp < maxp) *dp++ = *m_cp++;
+            size -= blk;
+        }
+        return *this;  // For function chaining
     }
     // Read a datum and compare with expected value
-    bool readDiffers (const void* __restrict datap, size_t size);
-    VerilatedDeserialize& readAssert (const void* __restrict datap, size_t size);
-    VerilatedDeserialize& readAssert (vluint64_t data) { return readAssert(&data, sizeof(data)); }
-    VerilatedDeserialize& bufferCheck() {
-	// Flush the write buffer if there's not enough space left for new information
-	// We only call this once per vector, so we need enough slop for a very wide "b###" line
-	if (VL_UNLIKELY((m_cp+bufferInsertSize()) > m_endp)) {
-	    fill();
-	}
-	return *this;  // For function chaining
+    VerilatedDeserialize& readAssert(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE;
+    VerilatedDeserialize& readAssert(vluint64_t data) VL_MT_UNSAFE_ONE {
+        return readAssert(&data, sizeof(data)); }
+private:
+    bool readDiffers(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE;
+    VerilatedDeserialize& bufferCheck() VL_MT_UNSAFE_ONE {
+        // Flush the write buffer if there's not enough space left for new information
+        // We only call this once per vector, so we need enough slop for a very wide "b###" line
+        if (VL_UNLIKELY((m_cp+bufferInsertSize()) > m_endp)) {
+            fill();
+        }
+        return *this;  // For function chaining
     }
 };
 
 //=============================================================================
 // VerilatedSave - serialize to a file
+// This class is not thread safe, it must be called by a single thread
 
 class VerilatedSave : public VerilatedSerialize {
 private:
-    int			m_fd;		///< File descriptor we're writing to
+    int                 m_fd;           ///< File descriptor we're writing to
 
 public:
-    // CREATORS
+    // CONSTRUCTORS
     VerilatedSave() { m_fd=-1; }
     virtual ~VerilatedSave() { close(); }
     // METHODS
-    void open(const char* filenamep);	///< Open the file; call isOpen() to see if errors
-    void open(const string& filename) { open(filename.c_str()); }
-    virtual void close();
-    virtual void flush();
+    void open(const char* filenamep) VL_MT_UNSAFE_ONE;  ///< Open the file; call isOpen() to see if errors
+    void open(const std::string& filename) VL_MT_UNSAFE_ONE { open(filename.c_str()); }
+    virtual void close() VL_MT_UNSAFE_ONE;
+    virtual void flush() VL_MT_UNSAFE_ONE;
 };
 
 //=============================================================================
 // VerilatedRestore - deserialize from a file
+// This class is not thread safe, it must be called by a single thread
 
 class VerilatedRestore : public VerilatedDeserialize {
 private:
-    int			m_fd;		///< File descriptor we're writing to
+    int                 m_fd;           ///< File descriptor we're writing to
 
 public:
-    // CREATORS
+    // CONSTRUCTORS
     VerilatedRestore() { m_fd=-1; }
     virtual ~VerilatedRestore() { close(); }
 
     // METHODS
-    void open(const char* filenamep);	///< Open the file; call isOpen() to see if errors
-    void open(const string& filename) { open(filename.c_str()); }
-    virtual void close();
-    virtual void flush() {}
-    virtual void fill();
+    void open(const char* filenamep) VL_MT_UNSAFE_ONE;  ///< Open the file; call isOpen() to see if errors
+    void open(const std::string& filename) VL_MT_UNSAFE_ONE { open(filename.c_str()); }
+    virtual void close() VL_MT_UNSAFE_ONE;
+    virtual void flush() VL_MT_UNSAFE_ONE {}
+    virtual void fill() VL_MT_UNSAFE_ONE;
 };
 
 //=============================================================================
@@ -217,16 +236,16 @@ inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   float& rhs) {
 inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, float& rhs) {
     return os.read(&rhs, sizeof(rhs));
 }
-inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   string& rhs) {
-    vluint32_t len=rhs.length();
+inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   std::string& rhs) {
+    vluint32_t len = rhs.length();
     os<<len;
     return os.write(rhs.data(), len);
 }
-inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, string& rhs) {
-    vluint32_t len;
+inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, std::string& rhs) {
+    vluint32_t len = 0;
     os>>len;
     rhs.resize(len);
     return os.read((void*)rhs.data(), len);
 }
 
-#endif // guard
+#endif  // Guard

include/verilated_sc.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2015 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2019 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.
@@ -16,8 +16,8 @@
 /// \file
 /// \brief Verilator: Common include for all Verilated SystemC files
 ///
-///	This file is included automatically by Verilator at the top of
-///	all SystemC files it generates.
+///     This file is included automatically by Verilator at the top of
+///     all SystemC files it generates.
 ///
 /// Code available from: http://www.veripool.org/verilator
 ///
@@ -25,9 +25,10 @@
 
 
 #ifndef _VERILATED_SC_H_
-#define _VERILATED_SC_H_ 1 ///< Header Guard
+#define _VERILATED_SC_H_ 1  ///< Header Guard
 
 #include "verilatedos.h"
+
 #include "systemc.h"
 
 //=============================================================================
@@ -35,17 +36,18 @@
 // We want to get a pointer to m_data in the sc_bv_base class,
 // but it is protected.  So make an exposing class, then use
 // cast magic to get at it.  Saves patching get_datap in SystemC.
+// This class is thread safe (though most of SystemC is not).
 
 #define VL_SC_BV_DATAP(bv) (VlScBvExposer::sp_datap(bv))
 class VlScBvExposer : public sc_bv_base {
 public:
-    static vluint32_t* sp_datap(const sc_bv_base& base) {
-	return static_cast<const VlScBvExposer*>(&base)->sp_datatp(); }
-    vluint32_t* sp_datatp() const { return (vluint32_t*)(m_data); }
+    static const vluint32_t* sp_datap(const sc_bv_base& base) VL_MT_SAFE {
+        return static_cast<const VlScBvExposer*>(&base)->sp_datatp(); }
+    const vluint32_t* sp_datatp() const { return reinterpret_cast<vluint32_t*>(m_data); }
     // Above reads this protected element in sc_bv_base:
     //   sc_digit* m_data; // data array
 };
 
 //=========================================================================
 
-#endif // guard
+#endif  // Guard

include/verilated_sym_props.h

@@ -0,0 +1,232 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+//
+// Copyright 2003-2019 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.
+//
+//*************************************************************************
+///
+/// \file
+/// \brief Verilator: Include to provide information about symbol inspection
+///
+///     This file is for inclusion by internal files that need to inspect
+///     specific symbols.
+///
+///     User routines wanting to inspect the symbol table should use
+///     verilated_syms.h instead.
+///
+///     These classes are thread safe, and read only.
+///
+/// Code available from: http://www.veripool.org/verilator
+///
+//*************************************************************************
+
+
+#ifndef _VERILATED_SYM_PROPS_H_
+#define _VERILATED_SYM_PROPS_H_ 1  ///< Header Guard
+
+#include "verilatedos.h"
+
+//===========================================================================
+/// Verilator range
+/// Thread safety: Assume is constructed only with model, then any number of readers
+
+// See also V3Ast::VNumRange
+class VerilatedRange {
+    int         m_left;
+    int         m_right;
+protected:
+    friend class VerilatedVarProps;
+    friend class VerilatedScope;
+    VerilatedRange() : m_left(0), m_right(0) {}
+    VerilatedRange(int left, int right) : m_left(left), m_right(right) {}
+    void init(int left, int right) { m_left=left; m_right=right; }
+public:
+    ~VerilatedRange() {}
+    int left() const { return m_left; }
+    int right() const { return m_right; }
+    int low() const { return (m_left < m_right) ? m_left : m_right; }
+    int high() const { return (m_left > m_right) ? m_left : m_right; }
+    int elements() const {
+        return (VL_LIKELY(m_left>=m_right) ? (m_left-m_right+1) : (m_right-m_left+1)); }
+    int increment() const { return (m_left >= m_right) ? 1 : -1; }
+};
+
+//===========================================================================
+/// Verilator variable
+/// Thread safety: Assume is constructed only with model, then any number of readers
+
+class VerilatedVarProps {
+    // TYPES
+    enum { MAGIC = 0xddc4f829 };
+    // MEMBERS
+    const vluint32_t            m_magic;        // Magic number
+    const VerilatedVarType      m_vltype;       // Data type
+    const VerilatedVarFlags     m_vlflags;      // Direction
+    const int                   m_pdims;        // Packed dimensions
+    const int                   m_udims;        // Unpacked dimensions
+    VerilatedRange              m_packed;       // Packed array range
+    VerilatedRange              m_unpacked[3];  // Unpacked array range
+    // CONSTRUCTORS
+protected:
+    friend class VerilatedScope;
+    VerilatedVarProps(VerilatedVarType vltype, VerilatedVarFlags vlflags,
+                      int pdims, int udims)
+        : m_magic(MAGIC), m_vltype(vltype), m_vlflags(vlflags), m_pdims(pdims), m_udims(udims) {}
+public:
+    class Unpacked {};
+    // Without packed
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags)
+        : m_magic(MAGIC), m_vltype(vltype),
+          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(0), m_udims(0) { }
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
+                      Unpacked, int u0l, int u0r)
+        : m_magic(MAGIC), m_vltype(vltype),
+          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(0), m_udims(1) {
+        m_unpacked[0].init(u0l, u0r); }
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
+                      Unpacked, int u0l, int u0r, int u1l, int u1r)
+        : m_magic(MAGIC), m_vltype(vltype),
+          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(0), m_udims(2) {
+        m_unpacked[0].init(u0l, u0r); m_unpacked[1].init(u1l, u1r); }
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
+                      Unpacked, int u0l, int u0r, int u1l, int u1r, int u2l, int u2r)
+        : m_magic(MAGIC), m_vltype(vltype),
+          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(0), m_udims(3) {
+        m_unpacked[0].init(u0l, u0r); m_unpacked[1].init(u1l, u1r); m_unpacked[2].init(u2l, u2r); }
+    // With packed
+    class Packed {};
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
+                      Packed, int pl, int pr)
+        : m_magic(MAGIC), m_vltype(vltype),
+          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(1), m_udims(0), m_packed(pl,pr) { }
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
+                      Packed, int pl, int pr,
+                      Unpacked, int u0l, int u0r)
+        : m_magic(MAGIC), m_vltype(vltype),
+          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(1), m_udims(1), m_packed(pl,pr) {
+        m_unpacked[0].init(u0l, u0r); }
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
+                      Packed, int pl, int pr,
+                      Unpacked, int u0l, int u0r, int u1l, int u1r)
+        : m_magic(MAGIC), m_vltype(vltype), m_vlflags(VerilatedVarFlags(vlflags)),
+          m_pdims(1), m_udims(2), m_packed(pl,pr) {
+        m_unpacked[0].init(u0l, u0r); m_unpacked[1].init(u1l, u1r); }
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
+                      Packed, int pl, int pr,
+                      Unpacked, int u0l, int u0r, int u1l, int u1r, int u2l, int u2r)
+        : m_magic(MAGIC), m_vltype(vltype),
+          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(1), m_udims(3), m_packed(pl,pr) {
+        m_unpacked[0].init(u0l, u0r); m_unpacked[1].init(u1l, u1r); m_unpacked[2].init(u2l, u2r); }
+public:
+    ~VerilatedVarProps() {}
+    // METHODS
+    bool magicOk() const { return m_magic==MAGIC; }
+    VerilatedVarType vltype() const { return m_vltype; }
+    VerilatedVarFlags vldir() const {
+        return static_cast<VerilatedVarFlags>(static_cast<int>(m_vlflags) & VLVF_MASK_DIR); }
+    vluint32_t entSize() const;
+    bool isPublicRW() const { return ((m_vlflags & VLVF_PUB_RW) != 0); }
+    /// DPI compatible C standard layout
+    bool isDpiCLayout() const { return ((m_vlflags & VLVF_DPI_CLAY) != 0); }
+    int udims() const { return m_udims; }
+    int dims() const { return m_pdims + m_udims; }
+    const VerilatedRange& packed() const { return m_packed; }
+    const VerilatedRange& unpacked() const { return m_unpacked[0]; }
+    // DPI accessors
+    int left(int dim) const {
+        return dim==0 ? m_packed.left()
+            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].left() : 0;
+    }
+    int right(int dim) const {
+        return dim==0 ? m_packed.right()
+            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].right() : 0;
+    }
+    int low(int dim) const {
+        return dim==0 ? m_packed.low()
+            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].low() : 0;
+    }
+    int high(int dim) const {
+        return dim==0 ? m_packed.high()
+            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].high() : 0;
+    }
+    int increment(int dim) const {
+        return dim==0 ? m_packed.increment()
+            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].increment() : 0;
+    }
+    int elements(int dim) const {
+        return dim==0 ? m_packed.elements()
+            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].elements() : 0;
+    }
+    /// Total size in bytes (note DPI limited to 4GB)
+    size_t totalSize() const;
+    /// Adjust a data pointer to access a given array element, NuLL if something goes bad
+    void* datapAdjustIndex(void* datap, int dim, int indx) const;
+};
+
+//===========================================================================
+/// Verilator DPI open array variable
+
+class VerilatedDpiOpenVar {
+    // MEMBERS
+    const VerilatedVarProps* m_propsp;  // Variable properties
+    void*                    m_datap;  // Location of data (local to thread always, so safe)
+public:
+    // CONSTRUCTORS
+    VerilatedDpiOpenVar(const VerilatedVarProps* propsp, void* datap)
+        : m_propsp(propsp), m_datap(datap) {}
+    VerilatedDpiOpenVar(const VerilatedVarProps* propsp, const void* datap)
+        : m_propsp(propsp), m_datap(const_cast<void*>(datap)) {}
+    ~VerilatedDpiOpenVar() {}
+    // METHODS
+    void* datap() const { return m_datap; }
+    // METHODS - from VerilatedVarProps
+    bool magicOk() const { return m_propsp->magicOk(); }
+    VerilatedVarType vltype() const { return m_propsp->vltype(); }
+    bool isDpiStdLayout() const { return m_propsp->isDpiCLayout(); }
+    const VerilatedRange& packed() const { return m_propsp->packed(); }
+    const VerilatedRange& unpacked() const { return m_propsp->unpacked(); }
+    int udims() const { return m_propsp->udims(); }
+    int left(int dim) const { return m_propsp->left(dim); }
+    int right(int dim) const { return m_propsp->right(dim); }
+    int low(int dim) const { return m_propsp->low(dim); }
+    int high(int dim) const { return m_propsp->high(dim); }
+    int increment(int dim) const { return m_propsp->increment(dim); }
+    int elements(int dim) const { return m_propsp->elements(dim); }
+    size_t totalSize() const { return m_propsp->totalSize(); }
+    void* datapAdjustIndex(void* datap, int dim, int indx) const {
+        return m_propsp->datapAdjustIndex(datap, dim, indx); }
+};
+
+//===========================================================================
+/// Verilator variable
+/// Thread safety: Assume is constructed only with model, then any number of readers
+
+class VerilatedVar : public VerilatedVarProps {
+    // MEMBERS
+    void*       m_datap;  // Location of data
+    const char* m_namep;  // Name - slowpath
+protected:
+    friend class VerilatedScope;
+    // CONSTRUCTORS
+    VerilatedVar(const char* namep, void* datap,
+                 VerilatedVarType vltype, VerilatedVarFlags vlflags, int dims)
+        : VerilatedVarProps(vltype, vlflags, (dims>0?1:0), ((dims>1)?dims-1:0))
+        , m_datap(datap), m_namep(namep) {}
+public:
+    ~VerilatedVar() {}
+    // ACCESSORS
+    void* datap() const { return m_datap; }
+    const VerilatedRange& range() const { return packed(); }  // Deprecated
+    const VerilatedRange& array() const { return unpacked(); }  // Deprecated
+    const char* name() const { return m_namep; }
+};
+
+#endif  // Guard

include/verilated_syms.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2019 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.
@@ -16,9 +16,12 @@
 /// \file
 /// \brief Verilator: Include to allow symbol inspection
 ///
-///	This file is for inclusion by files that need to inspect
-///	the symbol table.  It is not included in verilated.h
-///	as it requires some heavyweight C++ classes.
+///     This file is for inclusion by files that need to inspect the symbol
+///     table.  It is not included in verilated.h (instead see
+///     verilated_sym_props.h) as it requires some heavyweight C++ classes.
+///
+///     These classes are thread safe and read only. It is constructed only
+///     when a model is built (from the main thread).
 ///
 /// Code available from: http://www.veripool.org/verilator
 ///
@@ -26,77 +29,38 @@
 
 
 #ifndef _VERILATED_SYMS_H_
-#define _VERILATED_SYMS_H_ 1 ///< Header Guard
+#define _VERILATED_SYMS_H_ 1  ///< Header Guard
 
+#include "verilatedos.h"
 #include "verilated_heavy.h"
+#include "verilated_sym_props.h"
 
 #include <map>
 
 //======================================================================
-// Types
+/// Types
 
+/// Class to sort maps keyed by const char*'s
 struct VerilatedCStrCmp {
-    /// Ordering maps keyed by const char*'s
     bool operator() (const char *a, const char *b) const {
-	return std::strcmp(a, b) < 0;
+        return std::strcmp(a, b) < 0;
     }
 };
 
-//===========================================================================
-/// Verilator range
-
-// See also V3Ast::VNumRange
-class VerilatedRange { 
-    int		m_left;
-    int		m_right;
-protected:
-    friend class VerilatedVar;
-    friend class VerilatedScope;
-    VerilatedRange() : m_left(0), m_right(0) {}
-    void sets(int left, int right) { m_left=left; m_right=right; }
+/// Map of sorted scope names to find associated scope class
+class VerilatedScopeNameMap
+    : public std::map<const char*, const VerilatedScope*, VerilatedCStrCmp> {
 public:
-    ~VerilatedRange() {}
-    int left() const { return m_left; }
-    int right() const { return m_right; }
-    int elements() const { return (VL_LIKELY(m_left>=m_right)?(m_left-m_right+1):(m_right-m_left+1)); }
+    VerilatedScopeNameMap() {}
+    ~VerilatedScopeNameMap() {}
 };
 
-//===========================================================================
-/// Verilator variable
-
-class VerilatedVar {
-    void*		m_datap;	// Location of data
-    VerilatedVarType	m_vltype;	// Data type
-    VerilatedVarFlags	m_vlflags;	// Direction
-    VerilatedRange	m_range;	// First range
-    VerilatedRange	m_array;	// Array
-    int			m_dims;		// Dimensions
-    const char*		m_namep;	// Name - slowpath
-protected:
-    friend class VerilatedScope;
-    VerilatedVar(const char* namep, void* datap,
-		 VerilatedVarType vltype, VerilatedVarFlags vlflags, int dims)
-	: m_datap(datap), m_vltype(vltype), m_vlflags(vlflags), m_dims(dims), m_namep(namep) {}
-public:
-    ~VerilatedVar() {}
-    void* datap() const { return m_datap; }
-    VerilatedVarType vltype() const { return m_vltype; }
-    VerilatedVarFlags vldir() const { return (VerilatedVarFlags)((int)m_vlflags & VLVF_MASK_DIR); }
-    vluint32_t entSize() const;
-    bool isPublicRW() const { return ((m_vlflags & VLVF_PUB_RW) != 0); }
-    const VerilatedRange& range() const { return m_range; }
-    const VerilatedRange& array() const { return m_array; }
-    const char* name() const { return m_namep; }
-    int dims() const { return m_dims; }
-};
-
-//======================================================================
-/// Types
-
-class VerilatedVarNameMap : public map<const char*, VerilatedVar, VerilatedCStrCmp> {
+/// Map of sorted variable names to find associated variable class
+class VerilatedVarNameMap
+    : public std::map<const char*, VerilatedVar, VerilatedCStrCmp> {
 public:
     VerilatedVarNameMap() {}
     ~VerilatedVarNameMap() {}
 };
 
-#endif // Guard
+#endif  // Guard

include/verilated_threads.cpp

@@ -0,0 +1,232 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2012-2019 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 Thread pool for verilated modules
+///
+//=============================================================================
+
+#include "verilatedos.h"
+#include "verilated_threads.h"
+
+#include <cstdio>
+
+std::atomic<vluint64_t> VlNotification::s_yields;
+
+VL_THREAD_LOCAL VlThreadPool::ProfileTrace* VlThreadPool::t_profilep = NULL;
+
+//=============================================================================
+// VlMTaskVertex
+
+VlMTaskVertex::VlMTaskVertex(vluint32_t upstreamDepCount)
+    : m_upstreamDepsDone(0),
+      m_upstreamDepCount(upstreamDepCount) {
+    assert(atomic_is_lock_free(&m_upstreamDepsDone));
+}
+
+//=============================================================================
+// VlWorkerThread
+
+VlWorkerThread::VlWorkerThread(VlThreadPool* poolp, bool profiling)
+    : m_poolp(poolp)
+    , m_profiling(profiling)
+    , m_exiting(false)
+      // Must init this last -- after setting up fields that it might read:
+    , m_cthread(startWorker, this) {}
+
+VlWorkerThread::~VlWorkerThread() {
+    m_exiting.store(true, std::memory_order_release);
+    {
+        VerilatedLockGuard lk(m_mutex);
+        if (sleeping()) {
+            wakeUp();
+        }
+    }
+    // The thread should exit; join it.
+    m_cthread.join();
+}
+
+void VlWorkerThread::workerLoop() {
+    if (VL_UNLIKELY(m_profiling)) {
+        m_poolp->setupProfilingClientThread();
+    }
+
+    VlNotification alarm;
+    ExecRec work;
+    work.m_fnp = NULL;
+
+    while (1) {
+        bool sleep = false;
+        if (VL_UNLIKELY(!work.m_fnp)) {
+            // Look for work
+            VerilatedLockGuard lk(m_mutex);
+            if (VL_LIKELY(!m_ready.empty())) {
+                dequeWork(&work);
+            } else {
+                // No work available, prepare to sleep. Pass alarm/work
+                // into m_sleepAlarm so wakeUp will tall this function.
+                //
+                // Must modify m_sleepAlarm in the same critical section as
+                // the check for ready work, otherwise we could race with
+                // another thread enqueueing work and never be awoken.
+                m_sleepAlarm.first = &alarm;
+                m_sleepAlarm.second = &work;
+                sleep = true;
+            }
+        }
+
+        // Do this here, not above, to avoid a race with the destructor.
+        if (VL_UNLIKELY(m_exiting.load(std::memory_order_acquire)))
+            break;
+
+        if (VL_UNLIKELY(sleep)) {
+            alarm.waitForNotification();  // ZZZzzzzz
+            alarm.reset();
+        }
+        if (VL_LIKELY(work.m_fnp)) {
+            work.m_fnp(work.m_evenCycle, work.m_sym);
+            work.m_fnp = NULL;
+        }
+    }
+
+    if (VL_UNLIKELY(m_profiling)) {
+        m_poolp->tearDownProfilingClientThread();
+    }
+}
+
+void VlWorkerThread::startWorker(VlWorkerThread* workerp) {
+    workerp->workerLoop();
+}
+
+//=============================================================================
+// VlThreadPool
+
+VlThreadPool::VlThreadPool(int nThreads, bool profiling)
+    : m_profiling(profiling) {
+    // --threads N passes nThreads=N-1, as the "main" threads counts as 1
+    unsigned cpus = std::thread::hardware_concurrency();
+    if (cpus < nThreads+1) {
+        static int warnedOnce = 0;
+        if (!warnedOnce++) {
+            VL_PRINTF_MT("%%Warning: System has %u CPUs but model Verilated with"
+                         " --threads %d; may run slow.\n", cpus, nThreads+1);
+        }
+    }
+    // Create'em
+    for (int i=0; i<nThreads; ++i) {
+        m_workers.push_back(new VlWorkerThread(this, profiling));
+    }
+    // Set up a profile buffer for the current thread too -- on the
+    // assumption that it's the same thread that calls eval and may be
+    // donated to run mtasks during the eval.
+    if (VL_UNLIKELY(m_profiling)) {
+        setupProfilingClientThread();
+    }
+}
+
+VlThreadPool::~VlThreadPool() {
+    for (int i = 0; i < m_workers.size(); ++i) {
+        // Each ~WorkerThread will wait for its thread to exit.
+        delete m_workers[i];
+    }
+    if (VL_UNLIKELY(m_profiling)) {
+        tearDownProfilingClientThread();
+    }
+}
+
+void VlThreadPool::tearDownProfilingClientThread() {
+    assert(t_profilep);
+    delete t_profilep;
+    t_profilep = NULL;
+}
+
+void VlThreadPool::setupProfilingClientThread() {
+    assert(!t_profilep);
+    t_profilep = new ProfileTrace;
+    // Reserve some space in the thread-local profiling buffer;
+    // try not to malloc while collecting profiling.
+    t_profilep->reserve(4096);
+    {
+        VerilatedLockGuard lk(m_mutex);
+        m_allProfiles.insert(t_profilep);
+    }
+}
+
+void VlThreadPool::profileAppendAll(const VlProfileRec& rec) {
+    VerilatedLockGuard lk(m_mutex);
+    for (ProfileSet::iterator it = m_allProfiles.begin();
+         it != m_allProfiles.end(); ++it) {
+        // Every thread's profile trace gets a copy of rec.
+        (*it)->emplace_back(rec);
+    }
+}
+
+void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
+    VerilatedLockGuard lk(m_mutex);
+    VL_DEBUG_IF(VL_DBG_MSGF("+prof+threads writing to '%s'\n", filenamep););
+
+    FILE* fp = fopen(filenamep, "w");
+    if (VL_UNLIKELY(!fp)) {
+        VL_FATAL_MT(filenamep, 0, "", "+prof+threads+file file not writable");
+        return;
+    }
+
+    // TODO Perhaps merge with verilated_coverage output format, so can
+    // have a common merging and reporting tool, etc.
+    fprintf(fp, "VLPROFTHREAD 1.0 # Verilator thread profile dump version 1.0\n");
+    fprintf(fp, "VLPROF arg --threads %" VL_PRI64 "u\n",
+            vluint64_t(m_workers.size()+1));
+    fprintf(fp, "VLPROF arg +verilator+prof+threads+start+%" VL_PRI64 "u\n",
+            Verilated::profThreadsStart());
+    fprintf(fp, "VLPROF arg +verilator+prof+threads+window+%u\n",
+            Verilated::profThreadsWindow());
+    fprintf(fp, "VLPROF stat yields %" VL_PRI64 "u\n",
+            VlNotification::yields());
+
+    vluint32_t thread_id = 0;
+    for (ProfileSet::iterator pit = m_allProfiles.begin();
+         pit != m_allProfiles.end(); ++pit) {
+        ++thread_id;
+
+        bool printing = false;  // False while in warmup phase
+        for (ProfileTrace::iterator eit = (*pit)->begin();
+             eit != (*pit)->end(); ++eit) {
+            switch (eit->m_type) {
+            case VlProfileRec::TYPE_BARRIER:
+                printing = true;
+                break;
+            case VlProfileRec::TYPE_MTASK_RUN:
+                if (!printing) break;
+                fprintf(fp, "VLPROF mtask %d"
+                        " start %" VL_PRI64"u end %" VL_PRI64"u elapsed %" VL_PRI64 "u"
+                        " predict_time %u cpu %u on thread %u\n",
+                        eit->m_mtaskId,
+                        eit->m_startTime,
+                        eit->m_endTime,
+                        (eit->m_endTime - eit->m_startTime),
+                        eit->m_predictTime,
+                        eit->m_cpu,
+                        thread_id);
+                break;
+            default: assert(false); break;  // LCOV_EXCL_LINE
+            }
+        }
+    }
+    fprintf(fp, "VLPROF stat ticks %" VL_PRI64 "u\n",
+            ticksElapsed);
+
+    fclose(fp);
+}

include/verilated_threads.h

@@ -0,0 +1,339 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2012-2019 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 Thread pool and profiling for Verilated modules
+///
+//=============================================================================
+
+#ifndef _VERILATED_THREADS_H_
+#define _VERILATED_THREADS_H_
+
+#include "verilatedos.h"
+#include "verilated.h"  // for VerilatedMutex and clang annotations
+
+#include <sched.h>  // For sched_getcpu()
+#include <set>
+#include <vector>
+#if defined(__APPLE__)
+# include <cpuid.h>  // For __cpuid_count()
+#endif
+
+// VlMTaskVertex and VlThreadpool will work with multiple symbol table types.
+// Since the type is opaque to VlMTaskVertex and VlThreadPool, represent it
+// as a void* here.
+typedef void* VlThrSymTab;
+
+class VlNotification {
+    // MEMBERS
+    std::atomic<bool> m_notified;  // Notification pending
+    static std::atomic<vluint64_t> s_yields;  // Statistics
+
+public:
+    // CONSTRUCTORS
+    VlNotification()
+        : m_notified(false) {
+        assert(atomic_is_lock_free(&m_notified));
+    }
+    ~VlNotification() {}
+
+    // METHODS
+    static vluint64_t yields() { return s_yields; }
+    static void yieldThread() {
+        ++s_yields;  // Statistics
+        std::this_thread::yield();
+    }
+
+    // Block until notify() has occurred, then return.
+    // If notify() has already occurred, return immediately.
+    //
+    // This is logically const: the object will remain in notified state
+    // after WaitForNotification() returns, so you could notify more than
+    // one thread of the same event.
+    inline void waitForNotification() {
+        unsigned ct = 0;
+        while (VL_UNLIKELY(!notified())) {
+            VL_CPU_RELAX();
+            ++ct;
+            if (VL_UNLIKELY(ct > VL_LOCK_SPINS)) {
+                ct = 0;
+                yieldThread();
+            }
+        }
+    }
+
+    // The 'inline' keyword here means nothing to the compiler, it's
+    // implicit on methods defined within the class body anyway.
+    //
+    // 'inline' is attached the this method, and others in this file,
+    // to remind humans that some routines in this file are called many
+    // times per cycle in threaded mode. Such routines should be
+    // inlinable; that's why they're declared in the .h and not the .cpp.
+    inline bool notified() {
+        return m_notified.load(std::memory_order_acquire);
+    }
+    // Set notified state. If state is already notified,
+    // it remains so.
+    inline void notify() {
+        m_notified.store(true, std::memory_order_release);
+    }
+    // Reset the state to un-notified state, which is also the
+    // state of a new Notification object.
+    inline void reset() {
+        m_notified.store(false, std::memory_order_relaxed);
+    }
+};
+
+typedef void (*VlExecFnp)(bool, VlThrSymTab);
+
+/// Track dependencies for a single MTask.
+class VlMTaskVertex {
+    // MEMBERS
+
+    // On even cycles, _upstreamDepsDone increases as upstream
+    // dependencies complete. When it reaches _upstreamDepCount,
+    // this MTaskVertex is ready.
+    //
+    // On odd cycles, _upstreamDepsDone decreases as upstream
+    // dependencies complete, and when it reaches zero this MTaskVertex
+    // is ready.
+    //
+    // An atomic is smaller than a mutex, and lock-free.
+    //
+    // (Why does the size of this class matter? If an mtask has many
+    // downstream mtasks to notify, we hope these will pack into a
+    // small number of cache lines to reduce the cost of pointer chasing
+    // during done-notification. Nobody's quantified that cost though.
+    // If we were really serious about shrinking this class, we could
+    // use 16-bit types here...)
+    std::atomic<vluint32_t> m_upstreamDepsDone;
+    const vluint32_t m_upstreamDepCount;
+
+public:
+    // CONSTRUCTORS
+
+    // 'upstreamDepCount' is the number of upstream MTaskVertex's
+    // that must notify this MTaskVertex before it will become ready
+    // to run.
+    explicit VlMTaskVertex(vluint32_t upstreamDepCount);
+    ~VlMTaskVertex() {}
+
+    // Upstream mtasks must call this when they complete.
+    // Returns true when the current MTaskVertex becomes ready to execute,
+    // false while it's still waiting on more dependencies.
+    inline bool signalUpstreamDone(bool evenCycle) {
+        if (evenCycle) {
+            vluint32_t upstreamDepsDone
+                = 1 + m_upstreamDepsDone.fetch_add(1, std::memory_order_release);
+            assert(upstreamDepsDone <= m_upstreamDepCount);
+            return (upstreamDepsDone == m_upstreamDepCount);
+        } else {
+            vluint32_t upstreamDepsDone_prev
+                = m_upstreamDepsDone.fetch_sub(1, std::memory_order_release);
+            assert(upstreamDepsDone_prev > 0);
+            return (upstreamDepsDone_prev == 1);
+        }
+    }
+    inline bool areUpstreamDepsDone(bool evenCycle) const {
+        vluint32_t target = evenCycle ? m_upstreamDepCount : 0;
+        return m_upstreamDepsDone.load(std::memory_order_acquire) == target;
+    }
+    inline void waitUntilUpstreamDone(bool evenCycle) const {
+        unsigned ct = 0;
+        while (VL_UNLIKELY(!areUpstreamDepsDone(evenCycle))) {
+            VL_CPU_RELAX();
+            ++ct;
+            if (VL_UNLIKELY(ct > VL_LOCK_SPINS)) {
+                ct = 0;
+                VlNotification::yieldThread();
+            }
+        }
+    }
+};
+
+// Profiling support
+class VlProfileRec {
+protected:
+    friend class VlThreadPool;
+    enum VlProfileE {
+        TYPE_MTASK_RUN,
+        TYPE_BARRIER
+    };
+    VlProfileE m_type;  // Record type
+    vluint32_t m_mtaskId;  // Mtask we're logging
+    vluint32_t m_predictTime;  // How long scheduler predicted would take
+    vluint64_t m_startTime;  // Tick at start of execution
+    vluint64_t m_endTime;  // Tick at end of execution
+    unsigned m_cpu;  // Execution CPU number (at start anyways)
+public:
+    class Barrier {};
+    VlProfileRec() {}
+    explicit VlProfileRec(Barrier) {
+        m_type = TYPE_BARRIER;
+        m_mtaskId = 0;
+        m_predictTime = 0;
+        m_startTime = 0;
+        m_cpu = getcpu();
+    }
+    void startRecord(vluint64_t time, uint32_t mtask, uint32_t predict) {
+        m_type = VlProfileRec::TYPE_MTASK_RUN;
+        m_mtaskId = mtask;
+        m_predictTime = predict;
+        m_startTime = time;
+        m_cpu = getcpu();
+    }
+    void endRecord(vluint64_t time) {
+        m_endTime = time;
+    }
+    static int getcpu() {  // Return current executing CPU
+#if defined(__linux)
+        return sched_getcpu();
+#elif defined(__APPLE__)
+        vluint32_t info[4];
+        __cpuid_count(1, 0, info[0], info[1], info[2], info[3]);
+        /* info[1] is EBX, bits 24-31 are APIC ID */
+        if ((info[3] & (1 << 9)) == 0) {
+            return -1;  /* no APIC on chip */
+        } else {
+            return (unsigned)info[1] >> 24;
+        }
+#else
+        return 0;
+#endif
+    }
+
+};
+
+class VlThreadPool;
+
+class VlWorkerThread {
+private:
+    // TYPES
+    struct ExecRec {
+        VlExecFnp m_fnp;  // Function to execute
+        VlThrSymTab m_sym;  // Symbol table to execute
+        bool m_evenCycle;  // Even/odd for flag alternation
+        ExecRec() : m_fnp(NULL), m_sym(NULL), m_evenCycle(false) {}
+        ExecRec(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym)
+            : m_fnp(fnp), m_sym(sym), m_evenCycle(evenCycle) {}
+    };
+
+    // MEMBERS
+    VerilatedMutex m_mutex;
+
+    // Why a vector? We expect the pending list to be very short, typically
+    // 0 or 1 or 2, so popping from the front shouldn't be
+    // expensive. Revisit if we ever have longer queues...
+    std::vector<ExecRec> m_ready VL_GUARDED_BY(m_mutex);
+
+    VlThreadPool* m_poolp;  // Our associated thread pool
+
+    // If values stored are non-NULL, the thread is asleep pending new
+    // work. If the thread is not asleep, both parts of m_sleepAlarm must
+    // be NULL.
+    std::pair<VlNotification*, ExecRec*> m_sleepAlarm VL_GUARDED_BY(m_mutex);
+
+    bool m_profiling;  // Is profiling enabled?
+    std::atomic<bool> m_exiting;  // Worker thread should exit
+    std::thread m_cthread;  // Underlying C++ thread record
+
+    VL_UNCOPYABLE(VlWorkerThread);
+
+public:
+    // CONSTRUCTORS
+    explicit VlWorkerThread(VlThreadPool* poolp, bool profiling);
+    ~VlWorkerThread();
+
+    // METHODS
+    inline void dequeWork(ExecRec* workp) VL_REQUIRES(m_mutex) {
+        // As noted above this is inefficient if our ready list is ever
+        // long (but it shouldn't be)
+        *workp = m_ready.front();
+        m_ready.erase(m_ready.begin());
+    }
+    inline void wakeUp() VL_REQUIRES(m_mutex) {
+        VlNotification* notifyp = m_sleepAlarm.first;
+        m_sleepAlarm.first = NULL;  // NULL+NULL means wake
+        m_sleepAlarm.second = NULL;
+        notifyp->notify();
+    }
+    inline bool sleeping() VL_REQUIRES(m_mutex) {
+        return (m_sleepAlarm.first != NULL);
+    }
+    inline void addTask(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym) {
+        VerilatedLockGuard lk(m_mutex);
+        m_ready.emplace_back(fnp, evenCycle, sym);
+        if (VL_LIKELY(sleeping())) {  // Generally queue is waiting for work
+            // Awaken thread
+            dequeWork(m_sleepAlarm.second);
+            wakeUp();
+        }
+    }
+    void workerLoop();
+    static void startWorker(VlWorkerThread* workerp);
+};
+
+class VlThreadPool {
+    // TYPES
+    typedef std::vector<VlProfileRec> ProfileTrace;
+    typedef std::set<ProfileTrace*> ProfileSet;
+
+    // MEMBERS
+    std::vector<VlWorkerThread*> m_workers;  // our workers
+    bool m_profiling;  // is profiling enabled?
+
+    // Support profiling -- we can append records of profiling events
+    // to this vector with very low overhead, and then dump them out
+    // later. This prevents the overhead of printf/malloc/IO from
+    // corrupting the profiling data. It's super cheap to append
+    // a VlProfileRec struct on the end of a pre-allocated vector;
+    // this is the only cost we pay in real-time during a profiling cycle.
+    static VL_THREAD_LOCAL ProfileTrace* t_profilep;
+    ProfileSet m_allProfiles VL_GUARDED_BY(m_mutex);
+    VerilatedMutex m_mutex;
+
+public:
+    // CONSTRUCTORS
+    // Construct a thread pool with 'nThreads' dedicated threads. The thread
+    // pool will create these threads and make them available to execute tasks
+    // via this->workerp(index)->addTask(...)
+    VlThreadPool(int nThreads, bool profiling);
+    ~VlThreadPool();
+
+    // METHODS
+    inline int numThreads() const {
+        return m_workers.size();
+    }
+    inline VlWorkerThread* workerp(int index) {
+        assert(index >= 0);
+        assert(index < m_workers.size());
+        return m_workers[index];
+    }
+    inline VlProfileRec* profileAppend() {
+        t_profilep->emplace_back();
+        return &(t_profilep->back());
+    }
+    void profileAppendAll(const VlProfileRec& rec);
+    void profileDump(const char* filenamep, vluint64_t ticksElapsed);
+    // In profiling mode, each executing thread must call
+    // this once to setup profiling state:
+    void setupProfilingClientThread();
+    void tearDownProfilingClientThread();
+private:
+    VL_UNCOPYABLE(VlThreadPool);
+};
+
+#endif

include/verilated_unordered_set_map.h

@@ -0,0 +1,547 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: pre-C++11 replacements for std::unordered_set
+//                         and std::unordered_map.
+//
+// Code available from: http://www.veripool.org/verilator
+//
+//*************************************************************************
+//
+// Copyright 2003-2019 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.
+//
+//*************************************************************************
+
+
+//*************************************************************************
+// This file has clones of the std::unordered_set and std::unordered_map
+// hash table types. They are here so that Verilator can use hash tables
+// in pre-C++11 compilers, and the same client code can link against the
+// std:: types when they are available.
+//
+// The implementations in this file do not implement the complete APIs
+// of the std:: types. Nor are they correct in every detail,
+// notably, the const_iterators do not enforce constness. We can extend
+// these implementations to cover more of the std API as needed.
+//
+// TODO: In the future, when Verilator requires C++11 to compile,
+//       remove this entire file and switch to the std:: types.
+//
+//*************************************************************************
+
+#ifndef _V3_UNORDERED_SET_MAP_H_
+#define _V3_UNORDERED_SET_MAP_H_
+
+#include "verilatedos.h"
+
+#include <list>
+#include <stdexcept>
+#include <string>
+
+// Abstract 'vl_hash' and 'vl_equal_to' templates.
+template <typename T> struct vl_hash {
+    size_t operator()(const T& k) const;
+};
+
+template <typename T> struct vl_equal_to {
+    bool operator()(const T& a, const T& b) const;
+};
+
+// Specializations of 'vl_hash' and 'vl_equal_to'.
+inline size_t vl_hash_bytes(const void* vbufp, size_t nbytes) {
+    const vluint8_t* bufp = static_cast<const vluint8_t*>(vbufp);
+    size_t hash = 0;
+    for (size_t i = 0; i < nbytes; i++) {
+        hash = bufp[i] + 31u * hash;  // the K&R classic!
+    }
+    return hash;
+}
+
+template <> inline size_t
+vl_hash<unsigned int>::operator()(const unsigned int& k) const {
+    return k;
+}
+
+template <> inline bool
+vl_equal_to<unsigned int>::operator()(const unsigned int& a,
+                                      const unsigned int& b) const {
+    return a == b;
+}
+
+template <> inline size_t
+vl_hash<std::string>::operator()(const std::string& k) const {
+    return vl_hash_bytes(k.data(), k.size());
+}
+
+template <> inline bool
+vl_equal_to<std::string>::operator()(const std::string& a,
+                                     const std::string& b) const {
+    // Don't scan the strings if the sizes are different.
+    if (a.size() != b.size()) {
+        return false;
+    }
+    return (0 == a.compare(b));  // Must scan.
+}
+
+template <typename T> struct vl_hash<T*> {
+    size_t operator()(T* kp) const {
+        return ((sizeof(size_t) == sizeof(kp))
+                ? reinterpret_cast<size_t>(kp)
+                : vl_hash_bytes(&kp, sizeof(kp)));
+    }
+};
+
+template <typename T> struct vl_equal_to<T*> {
+    bool operator()(T* ap, T* bp) const {
+        return ap == bp;
+    }
+};
+
+//===================================================================
+//
+/// Functional clone of the std::unordered_set hash table.
+template <class T_Key,
+          class T_Hash = vl_hash<T_Key>,
+          class T_Equal = vl_equal_to<T_Key> >
+class vl_unordered_set {
+public:
+    // TYPES
+    typedef std::list<T_Key> Bucket;
+    enum RehashType {GROW, SHRINK};
+
+    template <class KK, class VV,
+              class HH, class EQ> friend class vl_unordered_map;
+
+    class iterator {
+    protected:
+        // MEMBERS
+        size_t m_bucketIdx;  //  Bucket this iterator points into
+        typename Bucket::iterator m_bit;  // Bucket-local iterator
+        const vl_unordered_set* m_setp;  // The containing set
+
+    public:
+        // CONSTRUCTORS
+        iterator(size_t bucketIdx, typename Bucket::iterator bit,
+                 const vl_unordered_set* setp)
+            : m_bucketIdx(bucketIdx), m_bit(bit), m_setp(setp) {}
+
+        // METHODS
+        const T_Key& operator*() const {
+            return *m_bit;
+        }
+        // This should really be 'const T_Key*' type for unordered_set,
+        // however this iterator is shared with unordered_map whose
+        // operator-> returns a non-const ValueType*, so keep this
+        // non-const to avoid having to define a whole separate iterator
+        // for unordered_map.
+        T_Key* operator->() const {
+            return &(*m_bit);
+        }
+        bool operator==(const iterator& other) const {
+            return ((m_bucketIdx == other.m_bucketIdx)
+                    && (m_bit == other.m_bit));
+        }
+        bool operator!=(const iterator& other) const {
+            return (!this->operator==(other));
+        }
+        void advanceUntilValid() {
+            while (1) {
+                if (m_bit != m_setp->m_bucketsp[m_bucketIdx].end()) {
+                    // Valid iterator in this bucket; we're done.
+                    return;
+                }
+
+                // Try the next bucket?
+                m_bucketIdx++;
+                if (m_bucketIdx == m_setp->numBuckets()) {
+                    // Ran past the end of buckets, set to end().
+                    *this = m_setp->end();
+                    return;
+                }
+                m_bit = m_setp->m_bucketsp[m_bucketIdx].begin();
+            }
+        }
+        void operator++() {
+            ++m_bit;
+            advanceUntilValid();
+        }
+
+        typename Bucket::iterator bit() const { return m_bit; }
+    };
+
+    // TODO: there's no real const enforcement on the 'const_iterator'.
+    typedef iterator const_iterator;
+
+private:
+    // MEMBERS
+    size_t m_numElements;       //  Number of entries present.
+    size_t m_log2Buckets;       //  Log-base-2 of the number of buckets.
+    mutable Bucket* m_bucketsp; //  Hash table buckets. May be NULL;
+    //                          //   we'll allocate it on the fly when
+    //                          //   the first entries are created.
+    Bucket m_emptyBucket;       //  A fake bucket, used to construct end().
+    T_Hash m_hash;              //  Hash function provider.
+    T_Equal m_equal;            //  Equal-to function provider.
+
+public:
+    // CONSTRUCTORS
+    vl_unordered_set()
+        : m_numElements(0)
+        , m_log2Buckets(initLog2Buckets())
+        , m_bucketsp(NULL)
+        , m_hash()
+        , m_equal() { }
+
+    vl_unordered_set(const vl_unordered_set& other)
+        : m_numElements(other.m_numElements)
+        , m_log2Buckets(other.m_log2Buckets)
+        , m_bucketsp(NULL)
+        , m_hash()
+        , m_equal() {
+        if (other.m_bucketsp) {
+            m_bucketsp = new Bucket[numBuckets()];
+            for (size_t i = 0; i < numBuckets(); i++) {
+                m_bucketsp[i] = other.m_bucketsp[i];
+            }
+        }
+    }
+    ~vl_unordered_set() {
+        delete [] m_bucketsp; VL_DANGLING(m_bucketsp);
+    }
+
+    vl_unordered_set& operator=(const vl_unordered_set& other) {
+        if (this != &other) {
+            clear();
+            delete [] m_bucketsp;
+            m_numElements = other.m_numElements;
+            m_log2Buckets = other.m_log2Buckets;
+            if (other.m_bucketsp) {
+                m_bucketsp = new Bucket[numBuckets()];
+                for (size_t i = 0; i < numBuckets(); i++) {
+                    m_bucketsp[i] = other.m_bucketsp[i];
+                }
+            } else {
+                m_bucketsp = NULL;
+            }
+        }
+        return *this;
+    }
+
+    // METHODS
+    static size_t initLog2Buckets() { return 4; }
+
+    iterator begin() {
+        if (m_numElements) {
+            initBuckets();
+            iterator result = iterator(0, m_bucketsp[0].begin(), this);
+            result.advanceUntilValid();
+            return result;
+        }
+        return end();
+    }
+    const_iterator begin() const {
+        if (m_numElements) {
+            initBuckets();
+            const_iterator result = iterator(0, m_bucketsp[0].begin(), this);
+            result.advanceUntilValid();
+            return result;
+        }
+        return end();
+    }
+    const_iterator end() const {
+        return iterator(VL_ULL(0xFFFFFFFFFFFFFFFF),
+                        const_cast<Bucket&>(m_emptyBucket).begin(), this);
+    }
+
+    bool empty() const { return m_numElements == 0; }
+
+    size_t size() const { return m_numElements; }
+
+    size_t count(const T_Key& key) const {
+        return (find(key) == end()) ? 0 : 1;
+    }
+
+    size_t hashToBucket(size_t hashVal) const {
+        return hashToBucket(hashVal, m_log2Buckets);
+    }
+    static size_t hashToBucket(size_t hashVal, unsigned log2Buckets) {
+        // Fibonacci hashing
+        // See https://probablydance.com/2018/06/16/fibonacci-hashing-the-optimization-that-the-world-forgot-or-a-better-alternative-to-integer-modulo/
+        //
+        // * The magic numbers below are UINT_MAX/phi where phi is the
+        //   golden ratio number (1.618...)  for either 64- or 32-bit
+        //   values of UINT_MAX.
+        //
+        // * Fibonacci hashing mixes the result of the client's hash
+        //   function further. This permits the use of very fast client
+        //   hash funcs (like just returning the int or pointer value as
+        //   is!) and tolerates crappy client hash functions pretty well.
+        size_t mult = hashVal * ((sizeof(size_t) == 8)
+                                 ? VL_ULL(11400714819323198485)
+                                 : 2654435769lu);
+        size_t result = (mult >> (((sizeof(size_t) == 8)
+                                   ? 64 : 32) - log2Buckets));
+        return result;
+    }
+
+    iterator find_internal(const T_Key& key, size_t& bucketIdxOut) {
+        size_t hash = m_hash.operator()(key);
+        bucketIdxOut = hashToBucket(hash);
+        initBuckets();
+        Bucket* bucketp = &m_bucketsp[bucketIdxOut];
+
+        for (typename Bucket::iterator it = bucketp->begin();
+             it != bucketp->end(); ++it) {
+            if (m_equal.operator()(*it, key)) {
+                return iterator(bucketIdxOut, it, this);
+            }
+        }
+        return end();
+    }
+
+    const_iterator find(const T_Key& key) const {
+        size_t bucketIdx;
+        return const_cast<vl_unordered_set*>(this)->find_internal(key,
+                                                                  bucketIdx);
+    }
+
+    iterator find(const T_Key& key) {
+        size_t bucketIdx;
+        return find_internal(key, bucketIdx);
+    }
+
+    std::pair<iterator, bool> insert(const T_Key &val) {
+        size_t bucketIdx;
+        iterator existIt = find_internal(val, bucketIdx);
+        if (existIt != end()) {
+            // Collision with existing element.
+            //
+            // An element may be inserted only if it is not
+            // equal to an existing element. So fail.
+            return std::pair<iterator, bool>(end(), false);
+        }
+
+        // No collision, so insert it.
+        m_numElements++;
+
+        m_bucketsp[bucketIdx].push_front(val);
+
+        // Compute result iterator. This pointer will be valid
+        // if we don't rehash:
+        iterator result_it(bucketIdx, m_bucketsp[bucketIdx].begin(), this);
+
+        if (needToRehash(GROW)) {
+            rehash(GROW);
+            // ... since we rehashed, do a lookup to get the result iterator.
+            result_it = find(val);
+        }
+
+        return std::pair<iterator, bool>(result_it, true);
+    }
+
+    iterator erase(iterator it) {
+        iterator next_it = it;
+        ++next_it;
+        erase(*it);
+        return next_it;
+    }
+
+    size_t erase(const T_Key &key) {
+        size_t bucketIdx;
+        iterator it = find_internal(key, bucketIdx);
+        if (it != end()) {
+            m_bucketsp[bucketIdx].erase(it.bit());
+            m_numElements--;
+            // Rehashing to handle a shrinking data set is important
+            // for the Scoreboard in V3Partition, which begins tracking
+            // a huge number of vertices and then tracks a successively
+            // smaller number over time.
+            if (needToRehash(SHRINK)) {
+                rehash(SHRINK);
+            }
+            return 1;
+        }
+        return 0;
+    }
+
+    void clear() {
+        if (m_bucketsp) {
+            delete [] m_bucketsp;
+            m_bucketsp = NULL;
+        }
+        m_numElements = 0;
+        m_log2Buckets = initLog2Buckets();
+    }
+
+private:
+    size_t numBuckets() const { return (VL_ULL(1) << m_log2Buckets); }
+
+    Bucket* getBucket(size_t idx) {
+        initBuckets();
+        return &m_bucketsp[idx];
+    }
+
+    void initBuckets() const {
+        if (!m_bucketsp) m_bucketsp = new Bucket[numBuckets()];
+    }
+
+    bool needToRehash(RehashType rt) const {
+        if (rt == GROW) {
+            return ((4 * numBuckets()) < m_numElements);
+        } else {
+            return (numBuckets() > (4 * m_numElements));
+        }
+    }
+
+    void rehash(RehashType rt) {
+        size_t new_log2Buckets;
+        if (rt == GROW) {
+            new_log2Buckets = m_log2Buckets + 2;
+        } else {
+            if (m_log2Buckets <= 4) {
+                // On shrink, saturate m_log2Buckets at its
+                // initial size of 2^4 == 16 buckets. Don't risk
+                // underflowing!
+                return;
+            }
+            new_log2Buckets = m_log2Buckets - 2;
+        }
+
+        size_t new_num_buckets = VL_ULL(1) << new_log2Buckets;
+        Bucket* new_bucketsp = new Bucket[new_num_buckets];
+
+        for (size_t i=0; i<numBuckets(); i++) {
+            while (!m_bucketsp[i].empty()) {
+                typename Bucket::iterator bit = m_bucketsp[i].begin();
+                size_t hash = m_hash.operator()(*bit);
+                size_t new_idx = hashToBucket(hash, new_log2Buckets);
+                // Avoid mallocing one list elem and freeing another;
+                // splice just moves it over.
+                new_bucketsp[new_idx].splice(new_bucketsp[new_idx].begin(),
+                                             m_bucketsp[i], bit);
+            }
+        }
+
+        delete[] m_bucketsp;
+        m_bucketsp = new_bucketsp;
+        m_log2Buckets = new_log2Buckets;
+    }
+};
+
+//===================================================================
+//
+/// Functional clone of the std::unordered_map hash table.
+template <class T_Key,
+          class T_Value,
+          class T_Hash = vl_hash<T_Key>,
+          class T_Equal = vl_equal_to<T_Key> >
+class vl_unordered_map {
+private:
+    // TYPES
+    typedef std::pair<T_Key, T_Value> KeyValPair;
+
+    class KeyHash {
+    private:
+        T_Hash key_hash;
+    public:
+        KeyHash() {}
+        size_t operator()(const KeyValPair& kv_pair) const {
+            return key_hash.operator()(kv_pair.first);
+        }
+    };
+
+    class KeyEqual {
+    private:
+        T_Equal key_eq;
+    public:
+        KeyEqual() {}
+        bool operator()(const KeyValPair& kv_a, const KeyValPair& kv_b) const {
+            return key_eq.operator()(kv_a.first, kv_b.first);
+        }
+    };
+
+    // MEMBERS
+    typedef vl_unordered_set<KeyValPair, KeyHash, KeyEqual> MapSet;
+    MapSet m_set;  // Wrap this vl_unordered_set which holds all state.
+
+public:
+    // CONSTRUCTORS
+    vl_unordered_map() {}
+    ~vl_unordered_map() {}
+
+    typedef typename MapSet::iterator iterator;
+    typedef typename MapSet::const_iterator const_iterator;
+
+    // METHODS
+    iterator begin() { return m_set.begin(); }
+    const_iterator begin() const { return m_set.begin(); }
+    const_iterator end() const { return m_set.end(); }
+    bool empty() const { return m_set.empty(); }
+    iterator find(const T_Key& k) {
+        // We can't assume that T_Value() is defined.
+        // ie, this does not work:
+        //    return m_set.find(std::make_pair(k, T_Value()));
+
+        // So, do this instead:
+        T_Hash mapHash;
+        T_Equal mapEq;
+        size_t hash = mapHash.operator()(k);
+        size_t bucketIdxOut = m_set.hashToBucket(hash);
+        typename MapSet::Bucket* bucketp = m_set.getBucket(bucketIdxOut);
+
+        for (typename MapSet::Bucket::iterator it = bucketp->begin();
+             it != bucketp->end(); ++it) {
+            if (mapEq.operator()(it->first, k)) {
+                return iterator(bucketIdxOut, it, &m_set);
+            }
+        }
+        return end();
+    }
+    const_iterator find(const T_Key& k) const {
+        return const_cast<vl_unordered_map*>(this)->find(k);
+    }
+    std::pair<iterator, bool> insert(const KeyValPair& val) {
+        return m_set.insert(val);
+    }
+    iterator erase(iterator it) { return m_set.erase(it); }
+    size_t erase(const T_Key& k) {
+        iterator it = find(k);
+        if (it == end()) { return 0; }
+        m_set.erase(it);
+        return 1;
+    }
+    T_Value& operator[](const T_Key& k) {
+        // Here we can assume T_Value() is defined, as
+        // std::unordered_map::operator[] relies on it too.
+        KeyValPair dummy = std::make_pair(k, T_Value());
+        iterator it = m_set.find(dummy);
+        if (it == m_set.end()) {
+            it = m_set.insert(dummy).first;
+        }
+        // For the 'set', it's generally not safe to modify
+        // the value after deref. For the 'map' though, we know
+        // it's safe to modify the value field and we can allow it:
+        return it->second;
+    }
+    T_Value& at(const T_Key& k) {
+        iterator it = find(k);
+        if (it == end()) { throw std::out_of_range("sorry"); }
+        return it->second;
+    }
+    const T_Value& at(const T_Key& k) const {
+        iterator it = find(k);
+        if (it == end()) { throw std::out_of_range("sorry"); }
+        return it->second;
+    }
+    void clear() { m_set.clear(); }
+    size_t size() const { return m_set.size(); }
+};
+
+#endif

include/verilated_vcd_c.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2019 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.
 //
@@ -24,12 +24,11 @@
 #include "verilated.h"
 #include "verilated_vcd_c.h"
 
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
+#include <algorithm>
 #include <cerrno>
 #include <ctime>
-#include <algorithm>
+#include <fcntl.h>
+#include <sys/stat.h>
 
 #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
 # include <io.h>
@@ -39,17 +38,52 @@
 
 // SPDIFF_ON
 
-#ifndef O_LARGEFILE // For example on WIN32
+#ifndef O_LARGEFILE  // For example on WIN32
 # define O_LARGEFILE 0
 #endif
 #ifndef O_NONBLOCK
 # define O_NONBLOCK 0
 #endif
+#ifndef O_CLOEXEC
+# define O_CLOEXEC 0
+#endif
 
 //=============================================================================
-// Global
+// VerilatedVcdImp
+/// Base class to hold some static state
+/// This is an internally used class
 
-vector<VerilatedVcd*>	VerilatedVcd::s_vcdVecp;	///< List of all created traces
+class VerilatedVcdSingleton {
+private:
+    typedef std::vector<VerilatedVcd*> VcdVec;
+    struct Singleton {
+        VerilatedMutex  s_vcdMutex;  ///< Protect the singleton
+        VcdVec          s_vcdVecp VL_GUARDED_BY(s_vcdMutex);  ///< List of all created traces
+    };
+    static Singleton& singleton() { static Singleton s; return s; }
+public:
+    static void pushVcd(VerilatedVcd* vcdp) VL_EXCLUDES(singleton().s_vcdMutex) {
+        VerilatedLockGuard lock(singleton().s_vcdMutex);
+        singleton().s_vcdVecp.push_back(vcdp);
+    }
+    static void removeVcd(const VerilatedVcd* vcdp) VL_EXCLUDES(singleton().s_vcdMutex) {
+        VerilatedLockGuard lock(singleton().s_vcdMutex);
+        VcdVec::iterator pos = find(singleton().s_vcdVecp.begin(),
+                                    singleton().s_vcdVecp.end(), vcdp);
+        if (pos != singleton().s_vcdVecp.end()) { singleton().s_vcdVecp.erase(pos); }
+    }
+    static void flush_all() VL_EXCLUDES(singleton().s_vcdMutex) VL_MT_UNSAFE_ONE {
+        // Thread safety: Although this function is protected by a mutex so
+        // perhaps in the future we can allow tracing in separate threads,
+        // vcdp->flush() assumes call from single thread
+        VerilatedLockGuard lock(singleton().s_vcdMutex);
+        for (VcdVec::const_iterator it = singleton().s_vcdVecp.begin();
+             it != singleton().s_vcdVecp.end(); ++it) {
+            VerilatedVcd* vcdp = *it;
+            vcdp->flush();
+        }
+    }
+};
 
 //=============================================================================
 // VerilatedVcdCallInfo
@@ -62,16 +96,17 @@ vector<VerilatedVcd*>	VerilatedVcd::s_vcdVecp;	///< List of all created traces
 class VerilatedVcdCallInfo {
 protected:
     friend class VerilatedVcd;
-    VerilatedVcdCallback_t	m_initcb;	///< Initialization Callback function
-    VerilatedVcdCallback_t	m_fullcb;	///< Full Dumping Callback function
-    VerilatedVcdCallback_t	m_changecb;	///< Incremental Dumping Callback function
-    void*		m_userthis;	///< Fake "this" for caller
-    vluint32_t		m_code;		///< Starting code number
-    // CREATORS
-    VerilatedVcdCallInfo (VerilatedVcdCallback_t icb, VerilatedVcdCallback_t fcb,
-			  VerilatedVcdCallback_t changecb,
-			  void* ut, vluint32_t code)
-	: m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {};
+    VerilatedVcdCallback_t      m_initcb;       ///< Initialization Callback function
+    VerilatedVcdCallback_t      m_fullcb;       ///< Full Dumping Callback function
+    VerilatedVcdCallback_t      m_changecb;     ///< Incremental Dumping Callback function
+    void*               m_userthis;     ///< Fake "this" for caller
+    vluint32_t          m_code;         ///< Starting code number
+    // CONSTRUCTORS
+    VerilatedVcdCallInfo(VerilatedVcdCallback_t icb, VerilatedVcdCallback_t fcb,
+                         VerilatedVcdCallback_t changecb,
+                         void* ut, vluint32_t code)
+        : m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {}
+    ~VerilatedVcdCallInfo() {}
 };
 
 //=============================================================================
@@ -79,16 +114,16 @@ protected:
 //=============================================================================
 // VerilatedVcdFile
 
-bool VerilatedVcdFile::open(const string& name) {
-    m_fd = ::open(name.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK, 0666);
+bool VerilatedVcdFile::open(const std::string& name) VL_MT_UNSAFE {
+    m_fd = ::open(name.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK|O_CLOEXEC, 0666);
     return (m_fd>=0);
 }
 
-void VerilatedVcdFile::close() {
+void VerilatedVcdFile::close() VL_MT_UNSAFE {
     ::close(m_fd);
 }
 
-ssize_t VerilatedVcdFile::write(const char* bufp, ssize_t len) {
+ssize_t VerilatedVcdFile::write(const char* bufp, ssize_t len) VL_MT_UNSAFE {
     return ::write(m_fd, bufp, len);
 }
 
@@ -116,75 +151,77 @@ VerilatedVcd::VerilatedVcd(VerilatedVcdFile* filep)
     m_wroteBytes = 0;
 }
 
-void VerilatedVcd::open (const char* filename) {
+void VerilatedVcd::open(const char* filename) {
+    m_assertOne.check();
     if (isOpen()) return;
 
     // Set member variables
     m_filename = filename;
-    s_vcdVecp.push_back(this);
+    VerilatedVcdSingleton::pushVcd(this);
 
     // SPDIFF_OFF
     // Set callback so an early exit will flush us
     Verilated::flushCb(&flush_all);
 
     // SPDIFF_ON
-    openNext (m_rolloverMB!=0);
+    openNext(m_rolloverMB!=0);
     if (!isOpen()) return;
 
     dumpHeader();
 
     // Allocate space now we know the number of codes
     if (!m_sigs_oldvalp) {
-	m_sigs_oldvalp = new vluint32_t [m_nextCode+10];
+        m_sigs_oldvalp = new vluint32_t [m_nextCode+10];
     }
 
     if (m_rolloverMB) {
-	openNext(true);
-	if (!isOpen()) return;
+        openNext(true);
+        if (!isOpen()) return;
     }
 }
 
-void VerilatedVcd::openNext (bool incFilename) {
+void VerilatedVcd::openNext(bool incFilename) {
     // Open next filename in concat sequence, mangle filename if
     // incFilename is true.
-    closePrev(); // Close existing
+    m_assertOne.check();
+    closePrev();  // Close existing
     if (incFilename) {
-	// Find _0000.{ext} in filename
-	string name = m_filename;
-	size_t pos=name.rfind(".");
-	if (pos>8 && 0==strncmp("_cat",name.c_str()+pos-8,4)
-	    && isdigit(name.c_str()[pos-4])
-	    && isdigit(name.c_str()[pos-3])
-	    && isdigit(name.c_str()[pos-2])
-	    && isdigit(name.c_str()[pos-1])) {
-	    // Increment code.
-	    if ((++(name[pos-1])) > '9') {
-		name[pos-1] = '0';
-		if ((++(name[pos-2])) > '9') {
-		    name[pos-2] = '0';
-		    if ((++(name[pos-3])) > '9') {
-			name[pos-3] = '0';
-			if ((++(name[pos-4])) > '9') {
-			    name[pos-4] = '0';
-			}}}}
-	} else {
-	    // Append _cat0000
-	    name.insert(pos,"_cat0000");
-	}
-	m_filename = name;
+        // Find _0000.{ext} in filename
+        std::string name = m_filename;
+        size_t pos = name.rfind('.');
+        if (pos>8 && 0==strncmp("_cat",name.c_str()+pos-8,4)
+            && isdigit(name.c_str()[pos-4])
+            && isdigit(name.c_str()[pos-3])
+            && isdigit(name.c_str()[pos-2])
+            && isdigit(name.c_str()[pos-1])) {
+            // Increment code.
+            if ((++(name[pos-1])) > '9') {
+                name[pos-1] = '0';
+                if ((++(name[pos-2])) > '9') {
+                    name[pos-2] = '0';
+                    if ((++(name[pos-3])) > '9') {
+                        name[pos-3] = '0';
+                        if ((++(name[pos-4])) > '9') {
+                            name[pos-4] = '0';
+                        }}}}
+        } else {
+            // Append _cat0000
+            name.insert(pos,"_cat0000");
+        }
+        m_filename = name;
     }
     if (m_filename[0]=='|') {
-	assert(0);	// Not supported yet.
+        assert(0);  // Not supported yet.
     } else {
-	// cppcheck-suppress duplicateExpression
-	if (!m_filep->open(m_filename)) {
-	    // User code can check isOpen()
-	    m_isOpen = false;
-	    return;
-	}
+        // cppcheck-suppress duplicateExpression
+        if (!m_filep->open(m_filename)) {
+            // User code can check isOpen()
+            m_isOpen = false;
+            return;
+        }
     }
     m_isOpen = true;
-    m_fullDump = true;	// First dump must be full
+    m_fullDump = true;  // First dump must be full
     m_wroteBytes = 0;
 }
 
@@ -194,9 +231,9 @@ void VerilatedVcd::makeNameMap() {
     m_nextCode = 1;
     m_namemapp = new NameMap;
     for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
-	VerilatedVcdCallInfo *cip = m_callbacks[ent];
-	cip->m_code = nextCode();
-	(cip->m_initcb) (this, cip->m_userthis, cip->m_code);
+        VerilatedVcdCallInfo* cip = m_callbacks[ent];
+        cip->m_code = m_nextCode;
+        (cip->m_initcb)(this, cip->m_userthis, cip->m_code);
     }
 
     // Though not speced, it's illegal to generate a vcd with signals
@@ -204,22 +241,22 @@ void VerilatedVcd::makeNameMap() {
     // If no scope was specified, prefix everything with a "top"
     // This comes from user instantiations with no name - IE Vtop("").
     bool nullScope = false;
-    for (NameMap::iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
-	const string& hiername = it->first;
-	if (hiername.size() >= 1 && hiername[0] == '\t') nullScope=true;
+    for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
+        const std::string& hiername = it->first;
+        if (!hiername.empty() && hiername[0] == '\t') nullScope=true;
     }
     if (nullScope) {
-	NameMap* newmapp = new NameMap;
-	for (NameMap::iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
-	    const string& hiername = it->first;
-	    const string& decl     = it->second;
-	    string newname = string("top");
-	    if (hiername[0] != '\t') newname += ' ';
-	    newname += hiername;
-	    newmapp->insert(make_pair(newname,decl));
-	}
-	deleteNameMap();
-	m_namemapp = newmapp;
+        NameMap* newmapp = new NameMap;
+        for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
+            const std::string& hiername = it->first;
+            const std::string& decl     = it->second;
+            std::string newname = std::string("top");
+            if (hiername[0] != '\t') newname += ' ';
+            newname += hiername;
+            newmapp->insert(std::make_pair(newname,decl));
+        }
+        deleteNameMap();
+        m_namemapp = newmapp;
     }
 }
 
@@ -233,12 +270,15 @@ VerilatedVcd::~VerilatedVcd() {
     if (m_sigs_oldvalp) { delete[] m_sigs_oldvalp; m_sigs_oldvalp=NULL; }
     deleteNameMap();
     if (m_filep && m_fileNewed) { delete m_filep; m_filep = NULL; }
-    // Remove from list of traces
-    vector<VerilatedVcd*>::iterator pos = find(s_vcdVecp.begin(), s_vcdVecp.end(), this);
-    if (pos != s_vcdVecp.end()) { s_vcdVecp.erase(pos); }
+    for (CallbackVec::const_iterator it=m_callbacks.begin(); it!=m_callbacks.end(); ++it) {
+        delete (*it);
+    }
+    m_callbacks.clear();
+    VerilatedVcdSingleton::removeVcd(this);
 }
 
-void VerilatedVcd::closePrev () {
+void VerilatedVcd::closePrev() {
+    // This function is on the flush() call path
     if (!isOpen()) return;
 
     bufferFlush();
@@ -246,7 +286,8 @@ void VerilatedVcd::closePrev () {
     m_filep->close();
 }
 
-void VerilatedVcd::closeErr () {
+void VerilatedVcd::closeErr() {
+    // This function is on the flush() call path
     // Close due to an error.  We might abort before even getting here,
     // depending on the definition of vl_fatal.
     if (!isOpen()) return;
@@ -257,39 +298,41 @@ void VerilatedVcd::closeErr () {
 }
 
 void VerilatedVcd::close() {
+    // This function is on the flush() call path
+    m_assertOne.check();
     if (!isOpen()) return;
     if (m_evcd) {
-	printStr("$vcdclose ");
-	printTime(m_timeLastDump);
-	printStr(" $end\n");
+        printStr("$vcdclose ");
+        printTime(m_timeLastDump);
+        printStr(" $end\n");
     }
     closePrev();
 }
 
-void VerilatedVcd::printStr (const char* str) {
+void VerilatedVcd::printStr(const char* str) {
     // Not fast...
     while (*str) {
-	*m_writep++ = *str++;
-	bufferCheck();
+        *m_writep++ = *str++;
+        bufferCheck();
     }
 }
 
-void VerilatedVcd::printQuad (vluint64_t n) {
+void VerilatedVcd::printQuad(vluint64_t n) {
     char buf [100];
     sprintf(buf,"%" VL_PRI64 "u", n);
     printStr(buf);
 }
 
-void VerilatedVcd::printTime (vluint64_t timeui) {
+void VerilatedVcd::printTime(vluint64_t timeui) {
     // VCD file format specification does not allow non-integers for timestamps
     // Dinotrace doesn't mind, but Cadence vvision seems to choke
     if (VL_UNLIKELY(timeui < m_timeLastDump)) {
-	timeui = m_timeLastDump;
-	static bool backTime = false;
-	if (!backTime) {
-	    backTime = true;
-	    VL_PRINTF("VCD time is moving backwards, wave file may be incorrect.\n");
-	}
+        timeui = m_timeLastDump;
+        static VL_THREAD_LOCAL bool backTime = false;
+        if (!backTime) {
+            backTime = true;
+            VL_PRINTF_MT("%%Warning: VCD time is moving backwards, wave file may be incorrect.\n");
+        }
     }
     m_timeLastDump = timeui;
     printQuad(timeui);
@@ -299,39 +342,41 @@ void VerilatedVcd::bufferResize(vluint64_t minsize) {
     // minsize is size of largest write.  We buffer at least 8 times as much data,
     // writing when we are 3/4 full (with thus 2*minsize remaining free)
     if (VL_UNLIKELY(minsize > m_wrChunkSize)) {
-	char* oldbufp = m_wrBufp;
-	m_wrChunkSize = minsize*2;
-	m_wrBufp = new char [m_wrChunkSize * 8];
-	memcpy(m_wrBufp, oldbufp, m_writep - oldbufp);
+        char* oldbufp = m_wrBufp;
+        m_wrChunkSize = minsize*2;
+        m_wrBufp = new char [m_wrChunkSize * 8];
+        memcpy(m_wrBufp, oldbufp, m_writep - oldbufp);
         m_writep = m_wrBufp + (m_writep - oldbufp);
-	m_wrFlushp = m_wrBufp + m_wrChunkSize * 6;
-	delete oldbufp; oldbufp=NULL;
+        m_wrFlushp = m_wrBufp + m_wrChunkSize * 6;
+        delete [] oldbufp; oldbufp=NULL;
     }
 }
 
-void VerilatedVcd::bufferFlush () {
+void VerilatedVcd::bufferFlush() VL_MT_UNSAFE_ONE {
+    // This function is on the flush() call path
     // We add output data to m_writep.
     // When it gets nearly full we dump it using this routine which calls write()
     // This is much faster than using buffered I/O
+    m_assertOne.check();
     if (VL_UNLIKELY(!isOpen())) return;
     char* wp = m_wrBufp;
     while (1) {
-	ssize_t remaining = (m_writep - wp);
-	if (remaining==0) break;
-	errno = 0;
-	ssize_t got = m_filep->write(wp, remaining);
-	if (got>0) {
-	    wp += got;
-	    m_wroteBytes += got;
-	} else if (got < 0) {
-	    if (errno != EAGAIN && errno != EINTR) {
-		// write failed, presume error (perhaps out of disk space)
-		string msg = (string)"VerilatedVcd::bufferFlush: "+strerror(errno);
-		vl_fatal("",0,"",msg.c_str());
-		closeErr();
-		break;
-	    }
-	}
+        ssize_t remaining = (m_writep - wp);
+        if (remaining==0) break;
+        errno = 0;
+        ssize_t got = m_filep->write(wp, remaining);
+        if (got>0) {
+            wp += got;
+            m_wroteBytes += got;
+        } else if (got < 0) {
+            if (errno != EAGAIN && errno != EINTR) {
+                // write failed, presume error (perhaps out of disk space)
+                std::string msg = std::string("VerilatedVcd::bufferFlush: ")+strerror(errno);
+                VL_FATAL_MT("",0,"",msg.c_str());
+                closeErr();
+                break;
+            }
+        }
     }
 
     // Reset buffer
@@ -341,20 +386,22 @@ void VerilatedVcd::bufferFlush () {
 //=============================================================================
 // Simple methods
 
-void VerilatedVcd::set_time_unit (const char* unitp) {
-    //cout<<" set_time_unit ("<<unitp<<") == "<<timescaleToDouble(unitp)<<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
+void VerilatedVcd::set_time_unit(const char* unitp) {
+    //cout<<" set_time_unit("<<unitp<<") == "<<timescaleToDouble(unitp)
+    //    <<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
     m_timeUnit = timescaleToDouble(unitp);
 }
 
-void VerilatedVcd::set_time_resolution (const char* unitp) {
-    //cout<<"set_time_resolution ("<<unitp<<") == "<<timescaleToDouble(unitp)<<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
+void VerilatedVcd::set_time_resolution(const char* unitp) {
+    //cout<<"set_time_resolution("<<unitp<<") == "<<timescaleToDouble(unitp)
+    //    <<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
     m_timeRes = timescaleToDouble(unitp);
 }
 
-double VerilatedVcd::timescaleToDouble (const char* unitp) {
+double VerilatedVcd::timescaleToDouble(const char* unitp) {
     char* endp;
     double value = strtod(unitp, &endp);
-    if (!value) value=1;  // On error so we allow just "ns" to return 1e-9.
+    if (value==0.0 && endp==unitp) value=1;  // On error so we allow just "ns" to return 1e-9.
     unitp=endp;
     while (*unitp && isspace(*unitp)) unitp++;
     switch (*unitp) {
@@ -369,125 +416,127 @@ double VerilatedVcd::timescaleToDouble (const char* unitp) {
     return value;
 }
 
-string VerilatedVcd::doubleToTimescale (double value) {
+std::string VerilatedVcd::doubleToTimescale(double value) {
     const char* suffixp = "s";
-    if	    (value>=1e0)   { suffixp="s"; value *= 1e0; }
+    if      (value>=1e0)   { suffixp="s"; value *= 1e0; }
     else if (value>=1e-3 ) { suffixp="ms"; value *= 1e3; }
     else if (value>=1e-6 ) { suffixp="us"; value *= 1e6; }
     else if (value>=1e-9 ) { suffixp="ns"; value *= 1e9; }
     else if (value>=1e-12) { suffixp="ps"; value *= 1e12; }
     else if (value>=1e-15) { suffixp="fs"; value *= 1e15; }
     else if (value>=1e-18) { suffixp="as"; value *= 1e18; }
-    char valuestr[100]; sprintf(valuestr,"%d%s",(int)(value), suffixp);
+    char valuestr[100]; sprintf(valuestr,"%3.0f%s", value, suffixp);
     return valuestr;  // Gets converted to string, so no ref to stack
 }
 
 //=============================================================================
 // Definitions
 
-void VerilatedVcd::printIndent (int level_change) {
+void VerilatedVcd::printIndent(int level_change) {
     if (level_change<0) m_modDepth += level_change;
     assert(m_modDepth>=0);
     for (int i=0; i<m_modDepth; i++) printStr(" ");
     if (level_change>0) m_modDepth += level_change;
 }
 
-void VerilatedVcd::dumpHeader () {
+void VerilatedVcd::dumpHeader() {
     printStr("$version Generated by VerilatedVcd $end\n");
     time_t time_str = time(NULL);
     printStr("$date "); printStr(ctime(&time_str)); printStr(" $end\n");
 
     printStr("$timescale ");
-    const string& timeResStr = doubleToTimescale(m_timeRes);
+    const std::string& timeResStr = doubleToTimescale(m_timeRes);
     printStr(timeResStr.c_str());
     printStr(" $end\n");
 
     makeNameMap();
 
     // Signal header
-    assert (m_modDepth==0);
+    assert(m_modDepth==0);
     printIndent(1);
     printStr("\n");
 
     // We detect the spaces in module names to determine hierarchy.  This
     // allows signals to be declared without fixed ordering, which is
     // required as Verilog signals might be separately declared from
-    // "SP_TRACE" signals.
+    // SC module signals.
 
     // Print the signal names
     const char* lastName = "";
-    for (NameMap::iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
-	const string& hiernamestr = it->first;
-	const string& decl = it->second;
+    for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
+        const std::string& hiernamestr = it->first;
+        const std::string& decl = it->second;
 
-	// Determine difference between the old and new names
-	const char* hiername = hiernamestr.c_str();
-	const char* lp = lastName;
-	const char* np = hiername;
-	lastName = hiername;
+        // Determine difference between the old and new names
+        const char* hiername = hiernamestr.c_str();
+        const char* lp = lastName;
+        const char* np = hiername;
+        lastName = hiername;
 
-	// Skip common prefix, it must break at a space or tab
-	for (; *np && (*np == *lp); np++, lp++) {}
-	while (np!=hiername && *np && *np!=' ' && *np!='\t') { np--; lp--; }
-	//printf("hier %s\n  lp=%s\n  np=%s\n",hiername,lp,np);
+        // Skip common prefix, it must break at a space or tab
+        for (; *np && (*np == *lp); np++, lp++) {}
+        while (np!=hiername && *np && *np!=' ' && *np!='\t') { np--; lp--; }
+        //printf("hier %s\n  lp=%s\n  np=%s\n",hiername,lp,np);
 
-	// Any extra spaces in last name are scope ups we need to do
-	bool first = true;
-	for (; *lp; lp++) {
-	    if (*lp==' ' || (first && *lp!='\t')) {
-		printIndent(-1);
-		printStr("$upscope $end\n");
-	    }
-	    first = false;
-	}
+        // Any extra spaces in last name are scope ups we need to do
+        bool first = true;
+        for (; *lp; lp++) {
+            if (*lp==' ' || (first && *lp!='\t')) {
+                printIndent(-1);
+                printStr("$upscope $end\n");
+            }
+            first = false;
+        }
 
-	// Any new spaces are scope downs we need to do
-	while (*np) {
-	    if (*np==' ') np++;
-	    if (*np=='\t') break; // tab means signal name starts
-	    printIndent(1);
-	    printStr("$scope module ");
-	    for (; *np && *np!=' ' && *np!='\t'; np++) {
-		if (*np=='[') printStr("(");
-		else if (*np==']') printStr(")");
-		else *m_writep++=*np;
-	    }
-	    printStr(" $end\n");
-	}
+        // Any new spaces are scope downs we need to do
+        while (*np) {
+            if (*np==' ') np++;
+            if (*np=='\t') break;  // tab means signal name starts
+            printIndent(1);
+            printStr("$scope module ");
+            for (; *np && *np!=' ' && *np!='\t'; np++) {
+                if (*np=='[') printStr("(");
+                else if (*np==']') printStr(")");
+                else *m_writep++=*np;
+            }
+            printStr(" $end\n");
+        }
 
-	printIndent(0);
-	printStr(decl.c_str());
+        printIndent(0);
+        printStr(decl.c_str());
     }
 
     while (m_modDepth>1) {
-	printIndent(-1);
-	printStr("$upscope $end\n");
+        printIndent(-1);
+        printStr("$upscope $end\n");
     }
 
     printIndent(-1);
     printStr("$enddefinitions $end\n\n\n");
-    assert (m_modDepth==0);
+    assert(m_modDepth==0);
 
     // Reclaim storage
     deleteNameMap();
 }
 
-void VerilatedVcd::module (const string& name) {
+void VerilatedVcd::module(const std::string& name) {
+    m_assertOne.check();
     m_modName = name;
 }
 
-void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep,
-			    int arraynum, bool tri, bool bussed, int msb, int lsb) {
-    if (!code) { vl_fatal(__FILE__,__LINE__,"","Internal: internal trace problem, code 0 is illegal"); }
+void VerilatedVcd::declare(vluint32_t code, const char* name, const char* wirep,
+                           int arraynum, bool tri, bool bussed, int msb, int lsb) {
+    if (!code) { VL_FATAL_MT(__FILE__, __LINE__, "",
+                             "Internal: internal trace problem, code 0 is illegal"); }
 
     int bits = ((msb>lsb)?(msb-lsb):(lsb-msb))+1;
     int codesNeeded = 1+int(bits/32);
-    if (tri) codesNeeded *= 2;   // Space in change array for __en signals
+    if (tri) codesNeeded *= 2;  // Space in change array for __en signals
 
     // Make sure array is large enough
-    m_nextCode = max(nextCode(), code+codesNeeded);
+    m_nextCode = std::max(m_nextCode, code+codesNeeded);
     if (m_sigs.capacity() <= m_nextCode) {
-	m_sigs.reserve(m_nextCode*2);	// Power-of-2 allocation speeds things up
+        m_sigs.reserve(m_nextCode*2);  // Power-of-2 allocation speeds things up
     }
 
     // Make sure write buffer is large enough (one character per bit), plus header
@@ -503,84 +552,88 @@ void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep
     // Tab separates final scope from signal name
     // Tab sorts before spaces, so signals nicely will print before scopes
     // Note the hiername may be nothing, if so we'll add "\t{name}"
-    string nameasstr = name;
-    if (m_modName!="") { nameasstr = m_modName+m_scopeEscape+nameasstr; }  // Optional ->module prefix
-    string hiername;
-    string basename;
+    std::string nameasstr = name;
+    if (!m_modName.empty()) {
+        nameasstr = m_modName+m_scopeEscape+nameasstr;  // Optional ->module prefix
+    }
+    std::string hiername;
+    std::string basename;
     for (const char* cp=nameasstr.c_str(); *cp; cp++) {
-	if (isScopeEscape(*cp)) {
-	    // Ahh, we've just read a scope, not a basename
-	    if (hiername!="") hiername += " ";
-	    hiername += basename;
-	    basename = "";
-	} else {
-	    basename += *cp;
-	}
+        if (isScopeEscape(*cp)) {
+            // Ahh, we've just read a scope, not a basename
+            if (!hiername.empty()) hiername += " ";
+            hiername += basename;
+            basename = "";
+        } else {
+            basename += *cp;
+        }
     }
     hiername += "\t"+basename;
 
     // Print reference
-    string decl = "$var ";
+    std::string decl = "$var ";
     if (m_evcd) decl += "port"; else decl += wirep;  // usually "wire"
     char buf [1000];
     sprintf(buf, " %2d ", bits);
     decl += buf;
     if (m_evcd) {
-	sprintf(buf, "<%d", code);
-	decl += buf;
+        sprintf(buf, "<%u", code);
+        decl += buf;
     } else {
-	decl += stringCode(code);
+        decl += stringCode(code);
     }
     decl += " ";
     decl += basename;
     if (arraynum>=0) {
-	sprintf(buf, "(%d)", arraynum);
-	decl += buf;
-	hiername += buf;
+        sprintf(buf, "(%d)", arraynum);
+        decl += buf;
+        hiername += buf;
     }
     if (bussed) {
-	sprintf(buf, " [%d:%d]", msb, lsb);
-	decl += buf;
+        sprintf(buf, " [%d:%d]", msb, lsb);
+        decl += buf;
     }
     decl += " $end\n";
-    m_namemapp->insert(make_pair(hiername,decl));
+    m_namemapp->insert(std::make_pair(hiername,decl));
 }
 
 void VerilatedVcd::declBit      (vluint32_t code, const char* name, int arraynum)
-{  declare (code, name, "wire", arraynum, false, false, 0, 0); }
+{  declare(code, name, "wire", arraynum, false, false, 0, 0); }
 void VerilatedVcd::declBus      (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, false, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, false, true, msb, lsb); }
 void VerilatedVcd::declQuad     (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, false, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, false, true, msb, lsb); }
 void VerilatedVcd::declArray    (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, false, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, false, true, msb, lsb); }
 void VerilatedVcd::declTriBit   (vluint32_t code, const char* name, int arraynum)
-{  declare (code, name, "wire", arraynum, true, false, 0, 0); }
+{  declare(code, name, "wire", arraynum, true, false, 0, 0); }
 void VerilatedVcd::declTriBus   (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, true, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, true, true, msb, lsb); }
 void VerilatedVcd::declTriQuad  (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, true, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, true, true, msb, lsb); }
 void VerilatedVcd::declTriArray (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, true, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, true, true, msb, lsb); }
 void VerilatedVcd::declFloat    (vluint32_t code, const char* name, int arraynum)
-{  declare (code, name, "real", arraynum, false, false, 31, 0); }
+{  declare(code, name, "real", arraynum, false, false, 31, 0); }
 void VerilatedVcd::declDouble   (vluint32_t code, const char* name, int arraynum)
-{  declare (code, name, "real", arraynum, false, false, 63, 0); }
+{  declare(code, name, "real", arraynum, false, false, 63, 0); }
 
 //=============================================================================
 
-void VerilatedVcd::fullDouble (vluint32_t code, const double newval) {
-    (*((double*)&m_sigs_oldvalp[code])) = newval;
+void VerilatedVcd::fullDouble(vluint32_t code, const double newval) {
+    // cppcheck-suppress invalidPointerCast
+    (*(reinterpret_cast<double*>(&m_sigs_oldvalp[code]))) = newval;
     // Buffer can't overflow before sprintf; we sized during declaration
     sprintf(m_writep, "r%.16g", newval);
     m_writep += strlen(m_writep);
     *m_writep++=' '; printCode(code); *m_writep++='\n';
     bufferCheck();
 }
-void VerilatedVcd::fullFloat (vluint32_t code, const float newval) {
-    (*((float*)&m_sigs_oldvalp[code])) = newval;
+void VerilatedVcd::fullFloat(vluint32_t code, const float newval) {
+    // cppcheck-suppress invalidPointerCast
+    (*(reinterpret_cast<float*>(&m_sigs_oldvalp[code]))) = newval;
     // Buffer can't overflow before sprintf; we sized during declaration
-    sprintf(m_writep, "r%.16g", (double)newval);
+    sprintf(m_writep, "r%.16g", static_cast<double>(newval));
     m_writep += strlen(m_writep);
     *m_writep++=' '; printCode(code); *m_writep++='\n';
     bufferCheck();
@@ -589,66 +642,65 @@ void VerilatedVcd::fullFloat (vluint32_t code, const float newval) {
 //=============================================================================
 // Callbacks
 
-void VerilatedVcd::addCallback (
+void VerilatedVcd::addCallback(
     VerilatedVcdCallback_t initcb, VerilatedVcdCallback_t fullcb, VerilatedVcdCallback_t changecb,
-    void* userthis)
+    void* userthis) VL_MT_UNSAFE_ONE
 {
+    m_assertOne.check();
     if (VL_UNLIKELY(isOpen())) {
-	string msg = (string)"Internal: "+__FILE__+"::"+__FUNCTION__+" called with already open file";
-	vl_fatal(__FILE__,__LINE__,"",msg.c_str());
+        std::string msg = std::string("Internal: ")+__FILE__+"::"+__FUNCTION__
+            +" called with already open file";
+        VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str());
     }
-    VerilatedVcdCallInfo* vci = new VerilatedVcdCallInfo(initcb, fullcb, changecb, userthis, nextCode());
+    VerilatedVcdCallInfo* vci
+        = new VerilatedVcdCallInfo(initcb, fullcb, changecb, userthis, m_nextCode);
     m_callbacks.push_back(vci);
 }
 
 //=============================================================================
 // Dumping
 
-void VerilatedVcd::dumpFull (vluint64_t timeui) {
-    dumpPrep (timeui);
+void VerilatedVcd::dumpFull(vluint64_t timeui) {
+    m_assertOne.check();
+    dumpPrep(timeui);
+    Verilated::quiesce();
     for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
-	VerilatedVcdCallInfo *cip = m_callbacks[ent];
-	(cip->m_fullcb) (this, cip->m_userthis, cip->m_code);
+        VerilatedVcdCallInfo* cip = m_callbacks[ent];
+        (cip->m_fullcb)(this, cip->m_userthis, cip->m_code);
     }
-    dumpDone ();
 }
 
-void VerilatedVcd::dump (vluint64_t timeui) {
+void VerilatedVcd::dump(vluint64_t timeui) {
+    m_assertOne.check();
     if (!isOpen()) return;
     if (VL_UNLIKELY(m_fullDump)) {
-	m_fullDump = false;	// No need for more full dumps
-	dumpFull(timeui);
-	return;
+        m_fullDump = false;  // No need for more full dumps
+        dumpFull(timeui);
+        return;
     }
     if (VL_UNLIKELY(m_rolloverMB && m_wroteBytes > this->m_rolloverMB)) {
-	openNext(true);
-	if (!isOpen()) return;
+        openNext(true);
+        if (!isOpen()) return;
     }
-    dumpPrep (timeui);
-    for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
-	VerilatedVcdCallInfo *cip = m_callbacks[ent];
-	(cip->m_changecb) (this, cip->m_userthis, cip->m_code);
+    dumpPrep(timeui);
+    Verilated::quiesce();
+    for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
+        VerilatedVcdCallInfo* cip = m_callbacks[ent];
+        (cip->m_changecb)(this, cip->m_userthis, cip->m_code);
     }
-    dumpDone();
 }
 
-void VerilatedVcd::dumpPrep (vluint64_t timeui) {
+void VerilatedVcd::dumpPrep(vluint64_t timeui) {
     printStr("#");
     printTime(timeui);
     printStr("\n");
 }
 
-void VerilatedVcd::dumpDone () {
-}
-
 //======================================================================
 // Static members
 
-void VerilatedVcd::flush_all() {
-    for (vluint32_t ent = 0; ent< s_vcdVecp.size(); ent++) {
-	VerilatedVcd* vcdp = s_vcdVecp[ent];
-	vcdp->flush();
-    }
+void VerilatedVcd::flush_all() VL_MT_UNSAFE_ONE {
+    VerilatedVcdSingleton::flush_all();
 }
 
 //======================================================================
@@ -663,40 +715,40 @@ vluint8_t ch;
 vluint64_t timestamp = 1;
 double doub = 0;
 
-void vcdInit (VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+void vcdInit(VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
     vcdp->scopeEscape('.');
-    vcdp->module ("top");
-     vcdp->declBus (0x2, "v1",-1,5,1);
-     vcdp->declBus (0x3, "v2",-1,6,0);
-     vcdp->module ("top.sub1");
-      vcdp->declBit (0x4, "s1",-1);
-      vcdp->declBit (0x5, "ch",-1);
-     vcdp->module ("top.sub2");
-      vcdp->declArray (0x6, "s2",-1, 40,3);
+    vcdp->module("top");
+     vcdp->declBus(0x2, "v1",-1,5,1);
+     vcdp->declBus(0x3, "v2",-1,6,0);
+     vcdp->module("top.sub1");
+      vcdp->declBit(0x4, "s1",-1);
+      vcdp->declBit(0x5, "ch",-1);
+     vcdp->module("top.sub2");
+      vcdp->declArray(0x6, "s2",-1, 40,3);
     // Note need to add 3 for next code.
-    vcdp->module ("top2");
-     vcdp->declBus (0x2, "t2v1",-1,4,1);
-     vcdp->declTriBit   (0x10, "io1", -1);
-     vcdp->declTriBus   (0x12, "io5", -1,4,0);
-     vcdp->declTriArray (0x16, "io96",-1,95,0);
+    vcdp->module("top2");
+     vcdp->declBus(0x2, "t2v1",-1,4,1);
+     vcdp->declTriBit  (0x10, "io1", -1);
+     vcdp->declTriBus  (0x12, "io5", -1,4,0);
+     vcdp->declTriArray(0x16, "io96",-1,95,0);
     // Note need to add 6 for next code.
-     vcdp->declDouble   (0x1c, "doub",-1);
+     vcdp->declDouble  (0x1c, "doub",-1);
     // Note need to add 2 for next code.
 }
 
-void vcdFull (VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+void vcdFull(VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
     vcdp->fullBus  (0x2, v1,5);
     vcdp->fullBus  (0x3, v2,7);
     vcdp->fullBit  (0x4, s1);
     vcdp->fullBus  (0x5, ch,2);
     vcdp->fullArray(0x6, &s2[0], 38);
-    vcdp->fullTriBit   (0x10, tri96[0]&1,    tri96__tri[0]&1);
-    vcdp->fullTriBus   (0x12, tri96[0]&0x1f, tri96__tri[0]&0x1f,  5);
-    vcdp->fullTriArray (0x16, tri96,         tri96__tri,          96);
+    vcdp->fullTriBit  (0x10, tri96[0]&1,    tri96__tri[0]&1);
+    vcdp->fullTriBus  (0x12, tri96[0]&0x1f, tri96__tri[0]&0x1f,  5);
+    vcdp->fullTriArray(0x16, tri96,         tri96__tri,          96);
     vcdp->fullDouble(0x1c, doub);
 }
 
-void vcdChange (VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+void vcdChange(VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
     vcdp->chgBus  (0x2, v1,5);
     vcdp->chgBus  (0x3, v2,7);
     vcdp->chgBit  (0x4, s1);
@@ -718,34 +770,34 @@ main() {
     ch = 0;
     doub = 0;
     {
-	VerilatedVcdC* vcdp = new VerilatedVcdC;
-	vcdp->spTrace()->addCallback (&vcdInit, &vcdFull, &vcdChange, 0);
-	vcdp->open ("test.vcd");
-	// Dumping
-	vcdp->dump(timestamp++);
-	v1 = 0xfff;
-	tri96[2] = 4; tri96[1] = 2; tri96[0] = 1;
-	tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = ~0;  // Still tri
-	doub = 1.5;
-	vcdp->dump(timestamp++);
-	v2 = 0x1;
-	s2[1] = 2;
-	tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = 0; // enable w/o data change
-	doub = -1.66e13;
-	vcdp->dump(timestamp++);
-	ch = 2;
-	tri96[2] = ~4; tri96[1] = ~2; tri96[0] = ~1;
-	doub = -3.33e-13;
-	vcdp->dump(timestamp++);
-	vcdp->dump(timestamp++);
+        VerilatedVcdC* vcdp = new VerilatedVcdC;
+        vcdp->spTrace()->addCallback(&vcdInit, &vcdFull, &vcdChange, 0);
+        vcdp->open("test.vcd");
+        // Dumping
+        vcdp->dump(timestamp++);
+        v1 = 0xfff;
+        tri96[2] = 4; tri96[1] = 2; tri96[0] = 1;
+        tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = ~0;  // Still tri
+        doub = 1.5;
+        vcdp->dump(timestamp++);
+        v2 = 0x1;
+        s2[1] = 2;
+        tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = 0;  // enable w/o data change
+        doub = -1.66e13;
+        vcdp->dump(timestamp++);
+        ch = 2;
+        tri96[2] = ~4; tri96[1] = ~2; tri96[0] = ~1;
+        doub = -3.33e-13;
+        vcdp->dump(timestamp++);
+        vcdp->dump(timestamp++);
 # ifdef VERILATED_VCD_TEST_64BIT
-	vluint64_t bytesPerDump = 15ULL;
-	for (vluint64_t i=0; i<((1ULL<<32) / bytesPerDump); i++) {
-	    v1 = i;
-	    vcdp->dump(timestamp++);
-	}
+        vluint64_t bytesPerDump = 15ULL;
+        for (vluint64_t i=0; i<((1ULL<<32) / bytesPerDump); i++) {
+            v1 = i;
+            vcdp->dump(timestamp++);
+        }
 # endif
-	vcdp->close();
+        vcdp->close();
     }
 }
 #endif

include/verilated_vcd_c.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2019 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.
 //
@@ -24,11 +24,11 @@
 #define _VERILATED_VCD_C_H_ 1
 
 #include "verilatedos.h"
+#include "verilated.h"
 
+#include <map>
 #include <string>
 #include <vector>
-#include <map>
-using namespace std;
 
 class VerilatedVcd;
 class VerilatedVcdCallInfo;
@@ -40,14 +40,14 @@ class VerilatedVcdCallInfo;
 
 class VerilatedVcdFile {
 private:
-    int			m_fd;		///< File descriptor we're writing to
+    int m_fd;  ///< File descriptor we're writing to
 public:
     // METHODS
     VerilatedVcdFile() : m_fd(0) {}
     virtual ~VerilatedVcdFile() {}
-    virtual bool open(const string& name);
-    virtual void close();
-    virtual ssize_t write(const char* bufp, ssize_t len);
+    virtual bool open(const std::string& name) VL_MT_UNSAFE;
+    virtual void close() VL_MT_UNSAFE;
+    virtual ssize_t write(const char* bufp, ssize_t len) VL_MT_UNSAFE;
 };
 
 //=============================================================================
@@ -57,10 +57,10 @@ public:
 class VerilatedVcdSig {
 protected:
     friend class VerilatedVcd;
-    vluint32_t		m_code;		///< VCD file code number
-    int			m_bits;		///< Size of value in bits
-    VerilatedVcdSig (vluint32_t code, int bits)
-	: m_code(code), m_bits(bits) {}
+    vluint32_t          m_code;         ///< VCD file code number
+    int                 m_bits;         ///< Size of value in bits
+    VerilatedVcdSig(vluint32_t code, int bits)
+        : m_code(code), m_bits(bits) {}
 public:
     ~VerilatedVcdSig() {}
 };
@@ -76,88 +76,93 @@ typedef void (*VerilatedVcdCallback_t)(VerilatedVcd* vcdp, void* userthis, vluin
 
 class VerilatedVcd {
 private:
-    VerilatedVcdFile*	m_filep;	///< File we're writing to
-    bool		m_fileNewed;	///< m_filep needs destruction
-    bool 		m_isOpen;	///< True indicates open file
-    bool		m_evcd;		///< True for evcd format
-    string		m_filename;	///< Filename we're writing to (if open)
-    vluint64_t		m_rolloverMB;	///< MB of file size to rollover at
-    char		m_scopeEscape;	///< Character to separate scope components
-    int			m_modDepth;	///< Depth of module hierarchy
-    bool		m_fullDump;	///< True indicates dump ignoring if changed
-    vluint32_t		m_nextCode;	///< Next code number to assign
-    string		m_modName;	///< Module name being traced now
-    double		m_timeRes;	///< Time resolution (ns/ms etc)
-    double		m_timeUnit;	///< Time units (ns/ms etc)
-    vluint64_t		m_timeLastDump;	///< Last time we did a dump
+    VerilatedVcdFile*   m_filep;        ///< File we're writing to
+    bool                m_fileNewed;    ///< m_filep needs destruction
+    bool                m_isOpen;       ///< True indicates open file
+    bool                m_evcd;         ///< True for evcd format
+    std::string         m_filename;     ///< Filename we're writing to (if open)
+    vluint64_t          m_rolloverMB;   ///< MB of file size to rollover at
+    char                m_scopeEscape;  ///< Character to separate scope components
+    int                 m_modDepth;     ///< Depth of module hierarchy
+    bool                m_fullDump;     ///< True indicates dump ignoring if changed
+    vluint32_t          m_nextCode;     ///< Next code number to assign
+    std::string         m_modName;      ///< Module name being traced now
+    double              m_timeRes;      ///< Time resolution (ns/ms etc)
+    double              m_timeUnit;     ///< Time units (ns/ms etc)
+    vluint64_t          m_timeLastDump; ///< Last time we did a dump
 
-    char*		m_wrBufp;	///< Output buffer
-    char*		m_wrFlushp;	///< Output buffer flush trigger location
-    char*		m_writep;	///< Write pointer into output buffer
-    vluint64_t		m_wrChunkSize;	///< Output buffer size
-    vluint64_t		m_wroteBytes;	///< Number of bytes written to this file
+    char*               m_wrBufp;       ///< Output buffer
+    char*               m_wrFlushp;     ///< Output buffer flush trigger location
+    char*               m_writep;       ///< Write pointer into output buffer
+    vluint64_t          m_wrChunkSize;  ///< Output buffer size
+    vluint64_t          m_wroteBytes;   ///< Number of bytes written to this file
 
-    vluint32_t*			m_sigs_oldvalp;	///< Pointer to old signal values
-    vector<VerilatedVcdSig>	m_sigs;		///< Pointer to signal information
-    vector<VerilatedVcdCallInfo*>	m_callbacks;	///< Routines to perform dumping
-    typedef map<string,string>	NameMap;
-    NameMap*			m_namemapp;	///< List of names for the header
-    static vector<VerilatedVcd*>	s_vcdVecp;	///< List of all created traces
+    vluint32_t*         m_sigs_oldvalp; ///< Pointer to old signal values
+    typedef std::vector<VerilatedVcdSig>  SigVec;
+    SigVec              m_sigs;         ///< Pointer to signal information
+    typedef std::vector<VerilatedVcdCallInfo*>  CallbackVec;
+    CallbackVec         m_callbacks;    ///< Routines to perform dumping
+    typedef std::map<std::string,std::string>  NameMap;
+    NameMap*            m_namemapp;     ///< List of names for the header
+
+    VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread
 
     void bufferResize(vluint64_t minsize);
-    void bufferFlush();
+    void bufferFlush() VL_MT_UNSAFE_ONE;
     inline void bufferCheck() {
-	// Flush the write buffer if there's not enough space left for new information
-	// We only call this once per vector, so we need enough slop for a very wide "b###" line
-	if (VL_UNLIKELY(m_writep > m_wrFlushp)) {
-	    bufferFlush();
-	}
+        // Flush the write buffer if there's not enough space left for new information
+        // We only call this once per vector, so we need enough slop for a very wide "b###" line
+        if (VL_UNLIKELY(m_writep > m_wrFlushp)) {
+            bufferFlush();
+        }
     }
     void closePrev();
     void closeErr();
     void openNext();
     void makeNameMap();
     void deleteNameMap();
-    void printIndent (int levelchange);
-    void printStr (const char* str);
-    void printQuad (vluint64_t n);
-    void printTime (vluint64_t timeui);
-    void declare (vluint32_t code, const char* name, const char* wirep,
-		  int arraynum, bool tri, bool bussed, int msb, int lsb);
+    void printIndent(int level_change);
+    void printStr(const char* str);
+    void printQuad(vluint64_t n);
+    void printTime(vluint64_t timeui);
+    void declare(vluint32_t code, const char* name, const char* wirep,
+                 int arraynum, bool tri, bool bussed, int msb, int lsb);
 
     void dumpHeader();
-    void dumpPrep (vluint64_t timeui);
-    void dumpFull (vluint64_t timeui);
+    void dumpPrep(vluint64_t timeui);
+    void dumpFull(vluint64_t timeui);
     // cppcheck-suppress functionConst
-    void dumpDone ();
-    inline void printCode (vluint32_t code) {
-	if (code>=(94*94*94)) *m_writep++ = ((char)((code/94/94/94)%94+33));
-	if (code>=(94*94))    *m_writep++ = ((char)((code/94/94)%94+33));
-	if (code>=(94))       *m_writep++ = ((char)((code/94)%94+33));
-	*m_writep++ = ((char)((code)%94+33));
+    void dumpDone();
+    inline void printCode(vluint32_t code) {
+        *m_writep++ = static_cast<char>('!' + code % 94);
+        code /= 94;
+        while (code) {
+            code--;
+            *m_writep++ = static_cast<char>('!' + code % 94);
+            code /= 94;
+        }
     }
-    static string stringCode (vluint32_t code) {
-	string out;
-	if (code>=(94*94*94)) out += ((char)((code/94/94/94)%94+33));
-	if (code>=(94*94))    out += ((char)((code/94/94)%94+33));
-	if (code>=(94))       out += ((char)((code/94)%94+33));
-	return out + ((char)((code)%94+33));
+    static std::string stringCode(vluint32_t code) VL_PURE {
+        std::string out;
+        out += static_cast<char>('!' + code % 94);
+        code /= 94;
+        while (code) {
+            code--;
+            out += static_cast<char>('!' + code % 94);
+            code /= 94;
+        }
+        return out;
     }
 
-protected:
-    // METHODS
-    void evcd(bool flag) { m_evcd = flag; }
-
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedVcd);
 public:
-    // CREATORS
-    VerilatedVcd(VerilatedVcdFile* filep=NULL);
+    explicit VerilatedVcd(VerilatedVcdFile* filep=NULL);
     ~VerilatedVcd();
 
     // ACCESSORS
-    /// Inside dumping routines, return next VCD signal code
-    vluint32_t nextCode() const {return m_nextCode;}
     /// Set size in megabytes after which new file should be created
-    void rolloverMB(vluint64_t rolloverMB) { m_rolloverMB=rolloverMB; };
+    void rolloverMB(vluint64_t rolloverMB) { m_rolloverMB=rolloverMB; }
     /// Is file open?
     bool isOpen() const { return m_isOpen; }
     /// Change character that splits scopes.  Note whitespace are ALWAYS escapes.
@@ -166,33 +171,35 @@ public:
     inline bool isScopeEscape(char c) { return isspace(c) || c==m_scopeEscape; }
 
     // METHODS
-    void open (const char* filename);	///< Open the file; call isOpen() to see if errors
-    void openNext (bool incFilename);	///< Open next data-only file
-    void flush() { bufferFlush(); }	///< Flush any remaining data
-    static void flush_all();		///< Flush any remaining data from all files
-    void close ();			///< Close the file
+    void open(const char* filename) VL_MT_UNSAFE_ONE;  ///< Open the file; call isOpen() to see if errors
+    void openNext(bool incFilename);  ///< Open next data-only file
+    void close() VL_MT_UNSAFE_ONE;  ///< Close the file
+    /// Flush any remaining data to this file
+    void flush() VL_MT_UNSAFE_ONE { bufferFlush(); }
+    /// Flush any remaining data from all files
+    static void flush_all() VL_MT_UNSAFE_ONE;
 
-    void set_time_unit (const char* unit); ///< Set time units (s/ms, defaults to ns)
-    void set_time_unit (const string& unit) { set_time_unit(unit.c_str()); }
+    void set_time_unit(const char* unitp);  ///< Set time units (s/ms, defaults to ns)
+    void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
 
-    void set_time_resolution (const char* unit); ///< Set time resolution (s/ms, defaults to ns)
-    void set_time_resolution (const string& unit) { set_time_resolution(unit.c_str()); }
+    void set_time_resolution(const char* unitp);  ///< Set time resolution (s/ms, defaults to ns)
+    void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
 
-    double timescaleToDouble (const char* unitp);
-    string doubleToTimescale (double value);
+    double timescaleToDouble(const char* unitp);
+    std::string doubleToTimescale(double value);
 
     /// Inside dumping routines, called each cycle to make the dump
-    void dump     (vluint64_t timeui);
+    void dump(vluint64_t timeui);
     /// Call dump with a absolute unscaled time in seconds
-    void dumpSeconds (double secs) { dump((vluint64_t)(secs * m_timeRes)); }
+    void dumpSeconds(double secs) { dump(static_cast<vluint64_t>(secs * m_timeRes)); }
 
     /// Inside dumping routines, declare callbacks for tracings
-    void addCallback (VerilatedVcdCallback_t init, VerilatedVcdCallback_t full,
-		      VerilatedVcdCallback_t change,
-		      void* userthis);
+    void addCallback(VerilatedVcdCallback_t initcb, VerilatedVcdCallback_t fullcb,
+                     VerilatedVcdCallback_t changecb,
+                     void* userthis) VL_MT_UNSAFE_ONE;
 
     /// Inside dumping routines, declare a module
-    void module (const string& name);
+    void module(const std::string& name);
     /// Inside dumping routines, declare a signal
     void declBit      (vluint32_t code, const char* name, int arraynum);
     void declBus      (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
@@ -204,203 +211,222 @@ public:
     void declTriArray (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
     void declDouble   (vluint32_t code, const char* name, int arraynum);
     void declFloat    (vluint32_t code, const char* name, int arraynum);
-    //	... other module_start for submodules (based on cell name)
+    //  ... other module_start for submodules (based on cell name)
 
     /// Inside dumping routines, dump one signal
-    void fullBit (vluint32_t code, const vluint32_t newval) {
-	// Note the &1, so we don't require clean input -- makes more common no change case faster
-	m_sigs_oldvalp[code] = newval;
-	*m_writep++=('0'+(char)(newval&1)); printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullBit(vluint32_t code, const vluint32_t newval) {
+        // Note the &1, so we don't require clean input -- makes more common no change case faster
+        m_sigs_oldvalp[code] = newval;
+        *m_writep++=('0'+static_cast<char>(newval&1)); printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullBus (vluint32_t code, const vluint32_t newval, int bits) {
-	m_sigs_oldvalp[code] = newval;
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++=((newval&(1L<<bit))?'1':'0');
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullBus(vluint32_t code, const vluint32_t newval, int bits) {
+        m_sigs_oldvalp[code] = newval;
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++=((newval&(1L<<bit))?'1':'0');
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullQuad (vluint32_t code, const vluint64_t newval, int bits) {
-	(*((vluint64_t*)&m_sigs_oldvalp[code])) = newval;
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++=((newval&(1ULL<<bit))?'1':'0');
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullQuad(vluint32_t code, const vluint64_t newval, int bits) {
+        (*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) = newval;
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++=((newval&(1ULL<<bit))?'1':'0');
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullArray (vluint32_t code, const vluint32_t* newval, int bits) {
-	for (int word=0; word<(((bits-1)/32)+1); ++word) {
-	    m_sigs_oldvalp[code+word] = newval[word];
-	}
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++=((newval[(bit/32)]&(1L<<(bit&0x1f)))?'1':'0');
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullArray(vluint32_t code, const vluint32_t* newval, int bits) {
+        for (int word=0; word<(((bits-1)/32)+1); ++word) {
+            m_sigs_oldvalp[code+word] = newval[word];
+        }
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++=((newval[(bit/32)]&(1L<<(bit&0x1f)))?'1':'0');
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullTriBit (vluint32_t code, const vluint32_t newval, const vluint32_t newtri) {
-	m_sigs_oldvalp[code]   = newval;
-	m_sigs_oldvalp[code+1] = newtri;
-	*m_writep++ = "01zz"[m_sigs_oldvalp[code]
-			     | (m_sigs_oldvalp[code+1]<<1)];
-	printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri) {
+        m_sigs_oldvalp[code]   = newval;
+        m_sigs_oldvalp[code+1] = newtri;
+        *m_writep++ = "01zz"[m_sigs_oldvalp[code]
+                             | (m_sigs_oldvalp[code+1]<<1)];
+        printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullTriBus (vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits) {
-	m_sigs_oldvalp[code] = newval;
-	m_sigs_oldvalp[code+1] = newtri;
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++ = "01zz"[((newval >> bit)&1)
-				 | (((newtri >> bit)&1)<<1)];
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits) {
+        m_sigs_oldvalp[code] = newval;
+        m_sigs_oldvalp[code+1] = newtri;
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++ = "01zz"[((newval >> bit)&1)
+                                 | (((newtri >> bit)&1)<<1)];
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullTriQuad (vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) {
-	(*((vluint64_t*)&m_sigs_oldvalp[code])) = newval;
-	(*((vluint64_t*)&m_sigs_oldvalp[code+1])) = newtri;
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++ = "01zz"[((newval >> bit)&1ULL)
-				 | (((newtri >> bit)&1ULL)<<1ULL)];
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullTriQuad(vluint32_t code, const vluint64_t newval,
+                     const vluint32_t newtri, int bits) {
+        (*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) = newval;
+        (*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code+1]))) = newtri;
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++ = "01zz"[((newval >> bit)&1ULL)
+                                 | (((newtri >> bit)&1ULL)<<1ULL)];
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullTriArray (vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits) {
-	for (int word=0; word<(((bits-1)/32)+1); ++word) {
-	    m_sigs_oldvalp[code+word*2]   = newvalp[word];
-	    m_sigs_oldvalp[code+word*2+1] = newtrip[word];
-	}
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    vluint32_t valbit = (newvalp[(bit/32)]>>(bit&0x1f)) & 1;
-	    vluint32_t tribit = (newtrip[(bit/32)]>>(bit&0x1f)) & 1;
-	    *m_writep++ = "01zz"[valbit | (tribit<<1)];
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullTriArray(vluint32_t code, const vluint32_t* newvalp,
+                      const vluint32_t* newtrip, int bits) {
+        for (int word=0; word<(((bits-1)/32)+1); ++word) {
+            m_sigs_oldvalp[code+word*2]   = newvalp[word];
+            m_sigs_oldvalp[code+word*2+1] = newtrip[word];
+        }
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            vluint32_t valbit = (newvalp[(bit/32)]>>(bit&0x1f)) & 1;
+            vluint32_t tribit = (newtrip[(bit/32)]>>(bit&0x1f)) & 1;
+            *m_writep++ = "01zz"[valbit | (tribit<<1)];
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullDouble (vluint32_t code, const double newval);
-    void fullFloat (vluint32_t code, const float newval);
+    void fullDouble(vluint32_t code, const double newval);
+    void fullFloat(vluint32_t code, const float newval);
 
     /// Inside dumping routines, dump one signal as unknowns
     /// Presently this code doesn't change the oldval vector.
     /// Thus this is for special standalone applications that after calling
     /// fullBitX, must when then value goes non-X call fullBit.
-    inline void fullBitX (vluint32_t code) {
-	*m_writep++='x'; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    inline void fullBitX(vluint32_t code) {
+        *m_writep++='x'; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    inline void fullBusX (vluint32_t code, int bits) {
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++='x';
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    inline void fullBusX(vluint32_t code, int bits) {
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++='x';
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    inline void fullQuadX (vluint32_t code, int bits) { fullBusX (code, bits); }
-    inline void fullArrayX (vluint32_t code, int bits) { fullBusX (code, bits); }
+    inline void fullQuadX(vluint32_t code, int bits) { fullBusX(code, bits); }
+    inline void fullArrayX(vluint32_t code, int bits) { fullBusX(code, bits); }
 
     /// Inside dumping routines, dump one signal if it has changed
-    inline void chgBit (vluint32_t code, const vluint32_t newval) {
-	vluint32_t diff = m_sigs_oldvalp[code] ^ newval;
-	if (VL_UNLIKELY(diff)) {
-	    // Verilator 3.510 and newer provide clean input, so the below is only for back compatibility
-	    if (VL_UNLIKELY(diff & 1)) {   // Change after clean?
-		fullBit (code, newval);
-	    }
-	}
+    inline void chgBit(vluint32_t code, const vluint32_t newval) {
+        vluint32_t diff = m_sigs_oldvalp[code] ^ newval;
+        if (VL_UNLIKELY(diff)) {
+            // Verilator 3.510 and newer provide clean input, so the below
+            // is only for back compatibility
+            if (VL_UNLIKELY(diff & 1)) {  // Change after clean?
+                fullBit(code, newval);
+            }
+        }
     }
-    inline void chgBus (vluint32_t code, const vluint32_t newval, int bits) {
-	vluint32_t diff = m_sigs_oldvalp[code] ^ newval;
-	if (VL_UNLIKELY(diff)) {
-	    if (VL_UNLIKELY(bits==32 || (diff & ((1U<<bits)-1) ))) {
-		fullBus (code, newval, bits);
-	    }
-	}
+    inline void chgBus(vluint32_t code, const vluint32_t newval, int bits) {
+        vluint32_t diff = m_sigs_oldvalp[code] ^ newval;
+        if (VL_UNLIKELY(diff)) {
+            if (VL_UNLIKELY(bits==32 || (diff & ((1U<<bits)-1) ))) {
+                fullBus(code, newval, bits);
+            }
+        }
     }
-    inline void chgQuad (vluint32_t code, const vluint64_t newval, int bits) {
-	vluint64_t diff = (*((vluint64_t*)&m_sigs_oldvalp[code])) ^ newval;
-	if (VL_UNLIKELY(diff)) {
-	    if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
-		fullQuad(code, newval, bits);
-	    }
-	}
+    inline void chgQuad(vluint32_t code, const vluint64_t newval, int bits) {
+        vluint64_t diff = (*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) ^ newval;
+        if (VL_UNLIKELY(diff)) {
+            if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
+                fullQuad(code, newval, bits);
+            }
+        }
     }
-    inline void chgArray (vluint32_t code, const vluint32_t* newval, int bits) {
-	for (int word=0; word<(((bits-1)/32)+1); ++word) {
-	    if (VL_UNLIKELY(m_sigs_oldvalp[code+word] ^ newval[word])) {
-		fullArray (code,newval,bits);
-		return;
-	    }
-	}
+    inline void chgArray(vluint32_t code, const vluint32_t* newval, int bits) {
+        for (int word=0; word<(((bits-1)/32)+1); ++word) {
+            if (VL_UNLIKELY(m_sigs_oldvalp[code+word] ^ newval[word])) {
+                fullArray(code,newval,bits);
+                return;
+            }
+        }
     }
-    inline void chgTriBit (vluint32_t code, const vluint32_t newval, const vluint32_t newtri) {
-	vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval)
-			 | (m_sigs_oldvalp[code+1] ^ newtri));
-	if (VL_UNLIKELY(diff)) {
-	    // Verilator 3.510 and newer provide clean input, so the below is only for back compatibility
-	    if (VL_UNLIKELY(diff & 1)) {   // Change after clean?
-		fullTriBit (code, newval, newtri);
-	    }
-	}
+    inline void chgTriBit(vluint32_t code, const vluint32_t newval,
+                          const vluint32_t newtri) {
+        vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval)
+                         | (m_sigs_oldvalp[code+1] ^ newtri));
+        if (VL_UNLIKELY(diff)) {
+            // Verilator 3.510 and newer provide clean input, so the below
+            // is only for back compatibility
+            if (VL_UNLIKELY(diff & 1)) {  // Change after clean?
+                fullTriBit(code, newval, newtri);
+            }
+        }
     }
-    inline void chgTriBus (vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits) {
-	vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval)
-			 | (m_sigs_oldvalp[code+1] ^ newtri));
-	if (VL_UNLIKELY(diff)) {
-	    if (VL_UNLIKELY(bits==32 || (diff & ((1U<<bits)-1) ))) {
-		fullTriBus (code, newval, newtri, bits);
-	    }
-	}
+    inline void chgTriBus(vluint32_t code, const vluint32_t newval,
+                          const vluint32_t newtri, int bits) {
+        vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval)
+                         | (m_sigs_oldvalp[code+1] ^ newtri));
+        if (VL_UNLIKELY(diff)) {
+            if (VL_UNLIKELY(bits==32 || (diff & ((1U<<bits)-1) ))) {
+                fullTriBus(code, newval, newtri, bits);
+            }
+        }
     }
-    inline void chgTriQuad (vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) {
-	vluint64_t diff = ( ((*((vluint64_t*)&m_sigs_oldvalp[code])) ^ newval)
-			  | ((*((vluint64_t*)&m_sigs_oldvalp[code+1])) ^ newtri));
-	if (VL_UNLIKELY(diff)) {
-	    if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
-		fullTriQuad(code, newval, newtri, bits);
-	    }
-	}
+    inline void chgTriQuad(vluint32_t code, const vluint64_t newval,
+                           const vluint32_t newtri, int bits) {
+        vluint64_t diff = ( ((*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) ^ newval)
+                            | ((*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code+1]))) ^ newtri));
+        if (VL_UNLIKELY(diff)) {
+            if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
+                fullTriQuad(code, newval, newtri, bits);
+            }
+        }
     }
-    inline void chgTriArray (vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits) {
-	for (int word=0; word<(((bits-1)/32)+1); ++word) {
-	    if (VL_UNLIKELY((m_sigs_oldvalp[code+word*2] ^ newvalp[word])
-			    | (m_sigs_oldvalp[code+word*2+1] ^ newtrip[word]))) {
-		fullTriArray (code,newvalp,newtrip,bits);
-		return;
-	    }
-	}
+    inline void chgTriArray(vluint32_t code, const vluint32_t* newvalp,
+                            const vluint32_t* newtrip, int bits) {
+        for (int word=0; word<(((bits-1)/32)+1); ++word) {
+            if (VL_UNLIKELY((m_sigs_oldvalp[code+word*2] ^ newvalp[word])
+                            | (m_sigs_oldvalp[code+word*2+1] ^ newtrip[word]))) {
+                fullTriArray(code,newvalp,newtrip,bits);
+                return;
+            }
+        }
     }
-    inline void chgDouble (vluint32_t code, const double newval) {
-	if (VL_UNLIKELY((*((double*)&m_sigs_oldvalp[code])) != newval)) {
-	    fullDouble (code, newval);
-	}
+    inline void chgDouble(vluint32_t code, const double newval) {
+        // cppcheck-suppress invalidPointerCast
+        if (VL_UNLIKELY((*(reinterpret_cast<double*>(&m_sigs_oldvalp[code]))) != newval)) {
+            fullDouble(code, newval);
+        }
     }
-    inline void chgFloat (vluint32_t code, const float newval) {
-	if (VL_UNLIKELY((*((float*)&m_sigs_oldvalp[code])) != newval)) {
-	    fullFloat (code, newval);
-	}
+    inline void chgFloat(vluint32_t code, const float newval) {
+        // cppcheck-suppress invalidPointerCast
+        if (VL_UNLIKELY((*(reinterpret_cast<float*>(&m_sigs_oldvalp[code]))) != newval)) {
+            fullFloat(code, newval);
+        }
     }
+
+protected:
+    // METHODS
+    void evcd(bool flag) { m_evcd = flag; }
 };
 
 //=============================================================================
 // VerilatedVcdC
 /// Create a VCD dump file in C standalone (no SystemC) simulations.
+/// Also derived for use in SystemC simulations.
+/// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE
 
 class VerilatedVcdC {
-    VerilatedVcd		m_sptrace;	///< Trace file being created
-public:
+    VerilatedVcd m_sptrace;  ///< Trace file being created
+
     // CONSTRUCTORS
-    VerilatedVcdC(VerilatedVcdFile* filep=NULL) : m_sptrace(filep) {}
+    VL_UNCOPYABLE(VerilatedVcdC);
+public:
+    explicit VerilatedVcdC(VerilatedVcdFile* filep=NULL) : m_sptrace(filep) {}
     ~VerilatedVcdC() {}
+public:
     // ACCESSORS
     /// Is file open?
     bool isOpen() const { return m_sptrace.isOpen(); }
@@ -408,26 +434,35 @@ public:
     /// Open a new VCD file
     /// This includes a complete header dump each time it is called,
     /// just as if this object was deleted and reconstructed.
-    void open (const char* filename) { m_sptrace.open(filename); }
+    void open(const char* filename) VL_MT_UNSAFE_ONE { m_sptrace.open(filename); }
     /// Continue a VCD dump by rotating to a new file name
     /// The header is only in the first file created, this allows
     /// "cat" to be used to combine the header plus any number of data files.
-    void openNext (bool incFilename=true) { m_sptrace.openNext(incFilename); }
+    void openNext(bool incFilename=true) VL_MT_UNSAFE_ONE { m_sptrace.openNext(incFilename); }
     /// Set size in megabytes after which new file should be created
-    void rolloverMB(size_t rolloverMB) { m_sptrace.rolloverMB(rolloverMB); };
+    void rolloverMB(size_t rolloverMB) { m_sptrace.rolloverMB(rolloverMB); }
     /// Close dump
-    void close() { m_sptrace.close(); }
+    void close() VL_MT_UNSAFE_ONE { m_sptrace.close(); }
     /// Flush dump
-    void flush() { m_sptrace.flush(); }
+    void flush() VL_MT_UNSAFE_ONE { m_sptrace.flush(); }
     /// Write one cycle of dump data
-    void dump (vluint64_t timeui) { m_sptrace.dump(timeui); }
+    void dump(vluint64_t timeui) { m_sptrace.dump(timeui); }
     /// Write one cycle of dump data - backward compatible and to reduce
     /// conversion warnings.  It's better to use a vluint64_t time instead.
-    void dump (double timestamp) { dump((vluint64_t)timestamp); }
-    void dump (vluint32_t timestamp) { dump((vluint64_t)timestamp); }
-    void dump (int timestamp) { dump((vluint64_t)timestamp); }
+    void dump(double timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump(vluint32_t timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump(int timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    /// Set time units (s/ms, defaults to ns)
+    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    void set_time_unit(const char* unit) { m_sptrace.set_time_unit(unit); }
+    void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
+    /// Set time resolution (s/ms, defaults to ns)
+    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    void set_time_resolution(const char* unit) { m_sptrace.set_time_resolution(unit); }
+    void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
+
     /// Internal class access
-    inline VerilatedVcd* spTrace () { return &m_sptrace; };
+    inline VerilatedVcd* spTrace() { return &m_sptrace; }
 };
 
-#endif // guard
+#endif  // guard

include/verilated_vcd_sc.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2019 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.
 //
@@ -30,14 +30,20 @@
 //--------------------------------------------------
 #if (SYSTEMC_VERSION>=20050714)
     // SystemC 2.1.v1
-void VerilatedVcdSc::write_comment (const std::string &) {}
-void VerilatedVcdSc::trace (const unsigned int &, const std::string &, const char **) {}
+// cppcheck-suppress unusedFunction
+void VerilatedVcdSc::write_comment(const std::string &) {}
+void VerilatedVcdSc::trace(const unsigned int &, const std::string &, const char **) {}
 
 # define DECL_TRACE_METHOD_A(tp) \
     void VerilatedVcdSc::trace( const tp& object, const std::string& name ) {}
 # define DECL_TRACE_METHOD_B(tp) \
     void VerilatedVcdSc::trace( const tp& object, const std::string& name, int width ) {}
 
+#if (SYSTEMC_VERSION>=20171012)
+    DECL_TRACE_METHOD_A( sc_event )
+    DECL_TRACE_METHOD_A( sc_time )
+#endif
+
     DECL_TRACE_METHOD_A( bool )
     DECL_TRACE_METHOD_A( sc_dt::sc_bit )
     DECL_TRACE_METHOD_A( sc_dt::sc_logic )
@@ -74,8 +80,9 @@ void VerilatedVcdSc::trace (const unsigned int &, const std::string &, const cha
 //--------------------------------------------------
 #elif (SYSTEMC_VERSION>20011000)
     // SystemC 2.0.1
-void VerilatedVcdSc::write_comment (const sc_string &) {}
-void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char **) {}
+// cppcheck-suppress unusedFunction
+void VerilatedVcdSc::write_comment(const sc_string &) {}
+void VerilatedVcdSc::trace(const unsigned int &, const sc_string &, const char **) {}
 
 #define DECL_TRACE_METHOD_A(tp) \
     void VerilatedVcdSc::trace( const tp& object, const sc_string& name ) {}
@@ -116,8 +123,9 @@ void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char
 //--------------------------------------------------
 #else
     // SystemC 1.2.1beta
-void VerilatedVcdSc::write_comment (const sc_string &) {}
-void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char **) {}
+// cppcheck-suppress unusedFunction
+void VerilatedVcdSc::write_comment(const sc_string &) {}
+void VerilatedVcdSc::trace(const unsigned int &, const sc_string &, const char **) {}
 
 #define DECL_TRACE_METHOD_A(tp) \
     void VerilatedVcdSc::trace( const tp& object, const sc_string& name ) {}

include/verilated_vcd_sc.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2019 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.
 //
@@ -17,12 +17,15 @@
 /// \file
 /// \brief Verilator tracing in VCD format
 ///
+/// This class is not threadsafe, as the SystemC kernel is not threadsafe.
+///
 //=============================================================================
 // SPDIFF_OFF
 
 #ifndef _VERILATED_VCD_SC_H_
 #define _VERILATED_VCD_SC_H_ 1
 
+#include "verilatedos.h"
 #include "verilated_sc.h"
 #include "verilated_vcd_c.h"
 
@@ -37,34 +40,39 @@ class VerilatedVcdSc
     : sc_trace_file
     , public VerilatedVcdC
 {
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedVcdSc);
 public:
     VerilatedVcdSc() {
-	sc_get_curr_simcontext()->add_trace_file(this);
+        sc_get_curr_simcontext()->add_trace_file(this);
 # if (SYSTEMC_VERSION>=20060505)
-	// We want to avoid a depreciated warning, but still be back compatible.
-	// Turning off the message just for this still results in an annoying "to turn off" message.
-	sc_time t1sec(1,SC_SEC);
-	if (t1sec.to_default_time_units()!=0) {
-	    sc_time tunits(1.0/t1sec.to_default_time_units(),SC_SEC);
-	    spTrace()->set_time_unit(tunits.to_string());
-	}
-	spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
+        // We want to avoid a depreciated warning, but still be back compatible.
+        // Turning off the message just for this still results in an
+        // annoying "to turn off" message.
+        sc_time t1sec(1,SC_SEC);
+        if (t1sec.to_default_time_units()!=0) {
+            sc_time tunits(1.0/t1sec.to_default_time_units(),SC_SEC);
+            spTrace()->set_time_unit(tunits.to_string());
+        }
+        spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
 # elif (SYSTEMC_VERSION>20011000)
-	// To confuse matters 2.1.beta returns a char* here, while 2.1.v1 returns a std::string
-	// we allow both flavors with overloaded set_time_* functions.
-	spTrace()->set_time_unit(sc_get_default_time_unit().to_string());
-	spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
+        // To confuse matters 2.1.beta returns a char* here, while 2.1.v1 returns a std::string
+        // we allow both flavors with overloaded set_time_* functions.
+        spTrace()->set_time_unit(sc_get_default_time_unit().to_string());
+        spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
 # endif
     }
-
     virtual ~VerilatedVcdSc() {}
+
+    // METHODS
     /// Called by SystemC simulate()
-    virtual void cycle (bool delta_cycle) {
+    virtual void cycle(bool delta_cycle) {
 # if (SYSTEMC_VERSION>20011000)
-	if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
+        if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
 # else
-	// VCD files must have integer timestamps, so we write all times in increments of time_resolution
-	if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
+        // VCD files must have integer timestamps, so we write all times in
+        // increments of time_resolution
+        if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
 # endif
     }
 
@@ -73,10 +81,10 @@ private:
 
 #ifdef NC_SYSTEMC
     // Cadence Incisive has these as abstract functions so we must create them
-    virtual void set_time_unit( int exponent10_seconds ) {} // deprecated
+    virtual void set_time_unit(int exponent10_seconds) {}  // deprecated
 #endif
 #if defined(NC_SYSTEMC) || (SYSTEMC_VERSION>=20111100)
-    virtual void set_time_unit( double v, sc_time_unit tu ) {}
+    virtual void set_time_unit(double v, sc_time_unit tu) {}
 #endif
 
 
@@ -84,12 +92,17 @@ private:
 # if (SYSTEMC_VERSION>=20050714)
     // SystemC 2.1.v1
 # define DECL_TRACE_METHOD_A(tp) \
-    virtual void trace( const tp& object, const std::string& name );
+    virtual void trace(const tp& object, const std::string& name);
 # define DECL_TRACE_METHOD_B(tp) \
-    virtual void trace( const tp& object, const std::string& name, int width );
+    virtual void trace(const tp& object, const std::string& name, int width);
 
-    virtual void write_comment (const std::string &);
-    virtual void trace (const unsigned int &, const std::string &, const char **);
+    virtual void write_comment(const std::string &);
+    virtual void trace(const unsigned int &, const std::string &, const char **);
+
+#if (SYSTEMC_VERSION>=20171012)
+    DECL_TRACE_METHOD_A( sc_event )
+    DECL_TRACE_METHOD_A( sc_time )
+#endif
 
     DECL_TRACE_METHOD_A( bool )
     DECL_TRACE_METHOD_A( sc_dt::sc_bit )
@@ -128,14 +141,14 @@ private:
 # elif (SYSTEMC_VERSION>20011000)
     // SystemC 2.0.1
 # define DECL_TRACE_METHOD_A(tp) \
-    virtual void trace( const tp& object, const sc_string& name );
+    virtual void trace(const tp& object, const sc_string& name);
 # define DECL_TRACE_METHOD_B(tp) \
-    virtual void trace( const tp& object, const sc_string& name, int width );
+    virtual void trace(const tp& object, const sc_string& name, int width);
 
-    virtual void write_comment (const sc_string &);
-    virtual void trace (const unsigned int &, const sc_string &, const char **);
-    virtual void delta_cycles (bool) {}
-    virtual void space( int n ) {}
+    virtual void write_comment(const sc_string &);
+    virtual void trace(const unsigned int &, const sc_string &, const char **);
+    virtual void delta_cycles(bool) {}
+    virtual void space(int n) {}
 
     DECL_TRACE_METHOD_A( bool )
     DECL_TRACE_METHOD_A( sc_bit )
@@ -172,12 +185,12 @@ private:
 # else
     // SystemC 1.2.1beta
 # define DECL_TRACE_METHOD_A(tp) \
-    virtual void trace( const tp& object, const sc_string& name );
+    virtual void trace(const tp& object, const sc_string& name);
 # define DECL_TRACE_METHOD_B(tp) \
-    virtual void trace( const tp& object, const sc_string& name, int width );
+    virtual void trace(const tp& object, const sc_string& name, int width);
 
-    virtual void write_comment (const sc_string &);
-    virtual void trace (const unsigned int &, const sc_string &, const char **);
+    virtual void write_comment(const sc_string &);
+    virtual void trace(const unsigned int &, const sc_string &, const char **);
 
     DECL_TRACE_METHOD_A( bool )
     DECL_TRACE_METHOD_B( unsigned char )
@@ -210,4 +223,4 @@ private:
 # undef DECL_TRACE_METHOD_B
 };
 
-#endif // guard
+#endif  // Guard

include/verilatedos.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2019 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.
@@ -16,11 +16,11 @@
 /// \file
 /// \brief Verilator: Common include for OS portability (verilated & verilator)
 ///
-///	This header is used by both the Verilator source code (run on the
-///	build and host system), and the Verilated output (run on the target
-///	system).  Code needed by only the host system goes into
-///	config_build.h.in, code needed by Verilated code only goes into
-///	verilated.h, and code needed by both goes here (verilatedos.h).
+///     This header is used by both the Verilator source code (run on the
+///     build and host system), and the Verilated output (run on the target
+///     system).  Code needed by only the host system goes into
+///     config_build.h.in, code needed by Verilated code only goes into
+///     verilated.h, and code needed by both goes here (verilatedos.h).
 ///
 /// Code available from: http://www.veripool.org/verilator
 ///
@@ -28,7 +28,7 @@
 
 
 #ifndef _VERILATEDOS_H_
-#define _VERILATEDOS_H_ 1 ///< Header Guard
+#define _VERILATEDOS_H_ 1  ///< Header Guard
 
 //=========================================================================
 // Compiler pragma abstraction
@@ -36,80 +36,156 @@
 #ifdef __GNUC__
 # define VL_ATTR_ALIGNED(alignment) __attribute__ ((aligned (alignment)))
 # define VL_ATTR_ALWINLINE __attribute__ ((always_inline))
+# define VL_ATTR_COLD __attribute__ ((cold))
+# define VL_ATTR_HOT __attribute__ ((hot))
 # define VL_ATTR_NORETURN __attribute__ ((noreturn))
-# ifdef _WIN32
-#  define VL_ATTR_PRINTF(fmtArgNum)  // GCC with MS runtime will fool the print arg checker
-# else
-#  define VL_ATTR_PRINTF(fmtArgNum) __attribute__ ((format (printf, fmtArgNum, fmtArgNum+1)))
-# endif
+# define VL_ATTR_PRINTF(fmtArgNum) __attribute__ ((format (printf, (fmtArgNum), (fmtArgNum)+1)))
+# define VL_ATTR_PURE __attribute__ ((pure))
 # define VL_ATTR_UNUSED __attribute__ ((unused))
 # define VL_FUNC  __func__
-# define VL_LIKELY(x)	__builtin_expect(!!(x), 1)
-# define VL_UNLIKELY(x)	__builtin_expect(!!(x), 0)
+# if defined(__clang__) && defined(VL_THREADED)
+#  define VL_ACQUIRE(...) __attribute__ ((acquire_capability(__VA_ARGS__)))
+#  define VL_ACQUIRE_SHARED(...) __attribute__ ((acquire_shared_capability(__VA_ARGS__)))
+#  define VL_RELEASE(...) __attribute__ ((release_capability(__VA_ARGS__)))
+#  define VL_RELEASE_SHARED(...) __attribute__ ((release_shared_capability(__VA_ARGS__)))
+#  define VL_TRY_ACQUIRE(...) __attribute__ ((try_acquire_capability(__VA_ARGS__)))
+#  define VL_TRY_ACQUIRE_SHARED(...) __attribute__ ((try_acquire_shared_capability(__VA_ARGS__)))
+#  define VL_CAPABILITY(x) __attribute__ ((capability(x)))
+#  define VL_REQUIRES(x) __attribute__ ((requires_capability(x)))
+#  define VL_GUARDED_BY(x) __attribute__ ((guarded_by(x)))
+#  define VL_EXCLUDES(x) __attribute__ ((locks_excluded(x)))
+#  define VL_SCOPED_CAPABILITY __attribute__ ((scoped_lockable))
+# endif
+# define VL_LIKELY(x)   __builtin_expect(!!(x), 1)
+# define VL_UNLIKELY(x) __builtin_expect(!!(x), 0)
+# define VL_UNREACHABLE __builtin_unreachable();
 # define VL_PREFETCH_RD(p) __builtin_prefetch((p),0)
 # define VL_PREFETCH_RW(p) __builtin_prefetch((p),1)
 #elif defined(_MSC_VER)
-# define VL_ATTR_ALIGNED(alignment)
-# define VL_ATTR_ALWINLINE
-# define VL_ATTR_NORETURN
-# define VL_ATTR_PRINTF(fmtArgNum)
-# define VL_ATTR_UNUSED
 # define VL_FUNC  __FUNCTION__
-# define VL_LIKELY(x)	(!!(x))
-# define VL_UNLIKELY(x)	(!!(x))
-# define VL_PREFETCH_RD(p)
-# define VL_PREFETCH_RW(p)
-#else
-# define VL_ATTR_ALIGNED(alignment)	///< Align structure to specified byte alignment
-# define VL_ATTR_ALWINLINE		///< Inline, even when not optimizing
-# define VL_ATTR_NORETURN		///< Function does not ever return
-# define VL_ATTR_PRINTF(fmtArgNum)	///< Function with printf format checking
-# define VL_ATTR_UNUSED			///< Function that may be never used
-# define VL_FUNC "__func__"		///< Name of current function for error macros
-# define VL_LIKELY(x)	(!!(x))		///< Boolean expression more often true than false
-# define VL_UNLIKELY(x)	(!!(x))		///< Boolean expression more often false than true
-# define VL_PREFETCH_RD(p)		///< Prefetch data with read intent
-# define VL_PREFETCH_RW(p)		///< Prefetch data with read/write intent
+#endif
+
+// Defaults for unsupported compiler features
+#ifndef VL_ATTR_ALIGNED
+# define VL_ATTR_ALIGNED(alignment)     ///< Align structure to specified byte alignment
+#endif
+#ifndef VL_ATTR_ALWINLINE
+# define VL_ATTR_ALWINLINE              ///< Inline, even when not optimizing
+#endif
+#ifndef VL_ATTR_COLD
+# define VL_ATTR_COLD                   ///< Function is rarely executed
+#endif
+#ifndef VL_ATTR_HOT
+# define VL_ATTR_HOT                    ///< Function is highly executed
+#endif
+#ifndef VL_ATTR_NORETURN
+# define VL_ATTR_NORETURN               ///< Function does not ever return
+#endif
+#ifndef VL_ATTR_PRINTF
+# define VL_ATTR_PRINTF(fmtArgNum)      ///< Function with printf format checking
+#endif
+#ifndef VL_ATTR_PURE
+# define VL_ATTR_PURE                   ///< Function is pure (and thus also VL_MT_SAFE)
+#endif
+#ifndef VL_ATTR_UNUSED
+# define VL_ATTR_UNUSED                 ///< Function that may be never used
+#endif
+#ifndef VL_FUNC
+# define VL_FUNC "__func__"             ///< Name of current function for error macros
+#endif
+#ifndef VL_CAPABILITY
+# define VL_ACQUIRE(...)                ///< Function requires a capability/lock (-fthread-safety)
+# define VL_ACQUIRE_SHARED(...)         ///< Function aquires a shared capability/lock (-fthread-safety)
+# define VL_RELEASE(...)                ///< Function releases a capability/lock (-fthread-safety)
+# define VL_RELEASE_SHARED(...)         ///< Function releases a shared capability/lock (-fthread-safety)
+# define VL_TRY_ACQUIRE(...)            ///< Function returns bool if aquired a capability (-fthread-safety)
+# define VL_TRY_ACQUIRE_SHARED(...)     ///< Function returns bool if aquired a shared capability (-fthread-safety)
+# define VL_REQUIRES(x)                 ///< Function requires a capability inbound (-fthread-safety)
+# define VL_EXCLUDES(x)                 ///< Function requires not having a capability inbound (-fthread-safety)
+# define VL_CAPABILITY(x)               ///< Name of capability/lock (-fthread-safety)
+# define VL_GUARDED_BY(x)               ///< Name of mutex protecting this variable (-fthread-safety)
+# define VL_SCOPED_CAPABILITY           ///< Scoped threaded capability/lock (-fthread-safety)
+#endif
+#ifndef VL_LIKELY
+# define VL_LIKELY(x)   (!!(x))         ///< Boolean expression more often true than false
+# define VL_UNLIKELY(x) (!!(x))         ///< Boolean expression more often false than true
+#endif
+#define VL_UNCOVERABLE(x) VL_UNLIKELY(x)  ///< Boolean expression never hit by users (no coverage)
+#ifndef VL_UNREACHABLE
+# define VL_UNREACHABLE                 ///< Point that may never be reached
+#endif
+#ifndef VL_PREFETCH_RD
+# define VL_PREFETCH_RD(p)              ///< Prefetch data with read intent
+#endif
+#ifndef VL_PREFETCH_RW
+# define VL_PREFETCH_RW(p)              ///< Prefetch data with read/write intent
 #endif
 
 #ifdef VL_THREADED
 # ifdef __GNUC__
-#  define VL_THREAD	__thread	///< Storage class for thread-local storage
+#  if (__cplusplus < 201103L) && !defined(VL_THREADED_NO_C11_WARNING)
+#    error "VL_THREADED/--threads support requires C++-11 or newer only; use newer compiler"
+#  endif
 # else
 #  error "Unsupported compiler for VL_THREADED: No thread-local declarator"
 # endif
-# define VL_STATIC_OR_THREAD		///< Static if unthreaded, as some strings can be faster
-//					///< if non-dynamic and can't do "static VL_THREAD string"
+# define VL_THREAD_LOCAL thread_local   ///< Use new C++ static local thread
 #else
-# define VL_THREAD			///< Storage class for thread-local storage
-# define VL_STATIC_OR_THREAD static	///< Static if unthreaded, as some strings can be faster
-//					///< if non-dynamic and can't do "static VL_THREAD string"
+# define VL_THREAD_LOCAL                ///< Use new C++ static local thread
 #endif
+#define VL_THREAD                       ///< Deprecated
+#define VL_STATIC_OR_THREAD static      ///< Deprecated
+
+#define VL_PURE  ///< Comment tag that Function is pure (and thus also VL_MT_SAFE)
+#define VL_MT_SAFE  ///< Comment tag that function is threadsafe when VL_THREADED
+#define VL_MT_SAFE_POSTINIT  ///< Comment tag that function is threadsafe when VL_THREADED, only during normal operation (post-init)
+#define VL_MT_UNSAFE  ///< Comment tag that function is not threadsafe when VL_THREADED
+#define VL_MT_UNSAFE_ONE  ///< Comment tag that function is not threadsafe when VL_THREADED, protected to make sure single-caller
 
 #ifdef _MSC_VER
-# define VL_ULL(c) (c##ui64)	///< Add appropriate suffix to 64-bit constant
+# define VL_ULL(c) (c##ui64)    ///< Add appropriate suffix to 64-bit constant
 #else
-# define VL_ULL(c) (c##ULL)	///< Add appropriate suffix to 64-bit constant
+# define VL_ULL(c) (c##ULL)     ///< Add appropriate suffix to 64-bit constant
 #endif
 
 // This is not necessarily the same as #UL, depending on what the IData typedef is.
-#define VL_UL(c) ((IData)(c##UL))	///< Add appropriate suffix to 32-bit constant
+#define VL_UL(c) (static_cast<IData>(c##UL))  ///< Add appropriate suffix to 32-bit constant
+
+#if defined(VL_CPPCHECK) || defined(__clang_analyzer__)
+# define VL_DANGLING(v)
+#else
+# define VL_DANGLING(v) do { (v) = NULL; } while(0)  ///< After e.g. delete, set variable to NULL to indicate must not use later
+#endif
 
 //=========================================================================
 // C++-2011
 
 #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-# define VL_HAS_UNIQUE_PTR
-# define VL_UNIQUE_PTR unique_ptr
+# define VL_EQ_DELETE = delete
+# define vl_unique_ptr std::unique_ptr
+// By default we use std:: types in C++11.
+// Define VL_USE_UNORDERED_TYPES to test these pre-C++11 classes
+# ifdef VL_USE_UNORDERED_TYPES
+#  define VL_INCLUDE_UNORDERED_MAP "verilated_unordered_set_map.h"
+#  define VL_INCLUDE_UNORDERED_SET "verilated_unordered_set_map.h"
+# else
+#  define vl_unordered_map std::unordered_map
+#  define vl_unordered_set std::unordered_set
+#  define VL_INCLUDE_UNORDERED_MAP <unordered_map>
+#  define VL_INCLUDE_UNORDERED_SET <unordered_set>
+# endif
 #else
-# define VL_UNIQUE_PTR auto_ptr
+# define VL_EQ_DELETE
+# define vl_unique_ptr std::auto_ptr
+# define VL_INCLUDE_UNORDERED_MAP "verilated_unordered_set_map.h"
+# define VL_INCLUDE_UNORDERED_SET "verilated_unordered_set_map.h"
 #endif
 
 //=========================================================================
 // Optimization
 
 #ifndef VL_INLINE_OPT
-# define VL_INLINE_OPT		///< "inline" if compiling all objects in single compiler run
+# define VL_INLINE_OPT  ///< "inline" if compiling all objects in single compiler run
 #endif
 
 //=========================================================================
@@ -117,55 +193,61 @@
 
 #ifndef VL_WARNINGS
 # ifdef _MSC_VER
-#  pragma warning(disable:4099)	// C4099: type name first seen using 'class' now seen using 'struct' (V3AstNode)
-#  pragma warning(disable:4100)	// C4100: unreferenced formal parameter (L4)
-#  pragma warning(disable:4127)	// C4127: conditional expression is constant (L4)
-#  pragma warning(disable:4146)	// C4146: unary minus operator applied to unsigned type, result still unsigned
-#  pragma warning(disable:4189)	// C4189: local variable is initialized but not referenced (L4)
-#  pragma warning(disable:4244)	// C4244: conversion from 'uint64_t' to 'uint_32_t', possible loss of data
-#  pragma warning(disable:4245)	// C4245: conversion from 'int' to 'unsigned', signed/unsigned mismatch
-#  pragma warning(disable:4996)	// C4996: sscanf/fopen/etc may be unsafe
+#  pragma warning(disable:4099)  // C4099: type name first seen using 'class' now seen using 'struct' (V3AstNode)
+#  pragma warning(disable:4100)  // C4100: unreferenced formal parameter (L4)
+#  pragma warning(disable:4127)  // C4127: conditional expression is constant (L4)
+#  pragma warning(disable:4146)  // C4146: unary minus operator applied to unsigned type, result still unsigned
+#  pragma warning(disable:4189)  // C4189: local variable is initialized but not referenced (L4)
+#  pragma warning(disable:4244)  // C4244: conversion from 'uint64_t' to 'uint_32_t', possible loss of data
+#  pragma warning(disable:4245)  // C4245: conversion from 'int' to 'unsigned', signed/unsigned mismatch
+#  pragma warning(disable:4996)  // C4996: sscanf/fopen/etc may be unsafe
 # endif
 #endif
 
 //=========================================================================
 // Basic integer types
 
-#ifdef VL_UINTS_DEFINED
-#elif defined(__CYGWIN__)
+#ifdef __MINGW32__
+# define __USE_MINGW_ANSI_STDIO 1  // Force old MinGW (GCC 5 and older) to use C99 formats
+# define __STDC_FORMAT_MACROS   1  // Otherwise MinGW doesn't get PRId64 for fstapi.c
+#endif
+
+#if defined(__CYGWIN__)
 
 # include <stdint.h>
-typedef unsigned char           uint8_t;	///< 8-bit unsigned type (backward compatibility)
-typedef unsigned short int      uint16_t;	///< 16-bit unsigned type (backward compatibility)
-typedef unsigned char           vluint8_t;	///< 8-bit unsigned type
-typedef unsigned short int      vluint16_t;	///< 16-bit unsigned type
-# if defined(__uint32_t_defined) || defined(___int32_t_defined)    // Newer Cygwin uint32_t in stdint.h as an unsigned int
-typedef int32_t			vlsint32_t;	///< 32-bit signed type
-typedef uint32_t		vluint32_t;	///< 32-bit unsigned type
-# else				 		// Older Cygwin has long==uint32_t
-typedef unsigned long		uint32_t;	///< 32-bit unsigned type (backward compatibility)
-typedef long			vlsint32_t;	///< 32-bit signed type
-typedef unsigned long		vluint32_t;	///< 32-bit unsigned type
+# include <sys/types.h>  // __WORDSIZE
+# include <unistd.h>  // ssize_t
+typedef unsigned char           uint8_t;        ///< 8-bit unsigned type (backward compatibility)
+typedef unsigned short int      uint16_t;       ///< 16-bit unsigned type (backward compatibility)
+typedef unsigned char           vluint8_t;      ///< 8-bit unsigned type
+typedef unsigned short int      vluint16_t;     ///< 16-bit unsigned type
+# if defined(__uint32_t_defined) || defined(___int32_t_defined)  // Newer Cygwin uint32_t in stdint.h as an unsigned int
+typedef int32_t                 vlsint32_t;     ///< 32-bit signed type
+typedef uint32_t                vluint32_t;     ///< 32-bit unsigned type
+# else  // Older Cygwin has long==uint32_t
+typedef unsigned long           uint32_t;       ///< 32-bit unsigned type (backward compatibility)
+typedef long                    vlsint32_t;     ///< 32-bit signed type
+typedef unsigned long           vluint32_t;     ///< 32-bit unsigned type
 # endif
 # if defined(__WORDSIZE) && (__WORDSIZE == 64)
-typedef long			vlsint64_t;	///< 64-bit signed type
-typedef unsigned long		vluint64_t;	///< 64-bit unsigned type
+typedef long                    vlsint64_t;     ///< 64-bit signed type
+typedef unsigned long           vluint64_t;     ///< 64-bit unsigned type
 # else
-typedef long long		vlsint64_t;	///< 64-bit signed type
-typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
+typedef long long               vlsint64_t;     ///< 64-bit signed type
+typedef unsigned long long      vluint64_t;     ///< 64-bit unsigned type
 # endif
 
 #elif defined(_WIN32) && defined(_MSC_VER)
 
-typedef unsigned __int8		uint8_t;	///< 8-bit unsigned type (backward compatibility)
-typedef unsigned __int16	uint16_t;	///< 16-bit unsigned type (backward compatibility)
-typedef unsigned __int32	uint32_t;	///< 32-bit unsigned type (backward compatibility)
-typedef unsigned __int8		vluint8_t;	///< 8-bit unsigned type
-typedef unsigned __int16	vluint16_t;	///< 16-bit unsigned type
-typedef signed   __int32	vlsint32_t;	///< 32-bit signed type
-typedef unsigned __int32	vluint32_t;	///< 32-bit unsigned type
-typedef signed   __int64	vlsint64_t;	///< 64-bit signed type
-typedef unsigned __int64	vluint64_t;	///< 64-bit unsigned type
+typedef unsigned __int8         uint8_t;        ///< 8-bit unsigned type (backward compatibility)
+typedef unsigned __int16        uint16_t;       ///< 16-bit unsigned type (backward compatibility)
+typedef unsigned __int32        uint32_t;       ///< 32-bit unsigned type (backward compatibility)
+typedef unsigned __int8         vluint8_t;      ///< 8-bit unsigned type
+typedef unsigned __int16        vluint16_t;     ///< 16-bit unsigned type
+typedef signed   __int32        vlsint32_t;     ///< 32-bit signed type
+typedef unsigned __int32        vluint32_t;     ///< 32-bit unsigned type
+typedef signed   __int64        vlsint64_t;     ///< 64-bit signed type
+typedef unsigned __int64        vluint64_t;     ///< 64-bit unsigned type
 
 # ifndef _SSIZE_T_DEFINED
 #  ifdef  _WIN64
@@ -175,21 +257,22 @@ typedef signed   __int32        ssize_t;        ///< signed size_t; returned fro
 #  endif
 # endif
 
-#else // Linux or compliant Unix flavors, -m64
+#else  // Linux or compliant Unix flavors, -m64
 
-# include <stdint.h>	// Linux and most flavors
-# include <unistd.h>	// Linux ssize_t
-# include <inttypes.h>	// Solaris
-typedef uint8_t			vluint8_t;	///< 32-bit unsigned type
-typedef uint16_t		vluint16_t;	///< 32-bit unsigned type
-typedef int			vlsint32_t;	///< 32-bit signed type
-typedef uint32_t		vluint32_t;	///< 32-bit signed type
+# include <inttypes.h>  // Solaris
+# include <stdint.h>  // Linux and most flavors
+# include <sys/types.h>  // __WORDSIZE
+# include <unistd.h>  // ssize_t
+typedef uint8_t                 vluint8_t;      ///< 32-bit unsigned type
+typedef uint16_t                vluint16_t;     ///< 32-bit unsigned type
+typedef int                     vlsint32_t;     ///< 32-bit signed type
+typedef uint32_t                vluint32_t;     ///< 32-bit signed type
 # if defined(__WORDSIZE) && (__WORDSIZE == 64)
-typedef long			vlsint64_t;	///< 64-bit signed type
-typedef unsigned long		vluint64_t;	///< 64-bit unsigned type
+typedef long                    vlsint64_t;     ///< 64-bit signed type
+typedef unsigned long           vluint64_t;     ///< 64-bit unsigned type
 # else
-typedef long long		vlsint64_t;	///< 64-bit signed type
-typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
+typedef long long               vlsint64_t;     ///< 64-bit signed type
+typedef unsigned long long      vluint64_t;     ///< 64-bit unsigned type
 # endif
 #endif
 
@@ -197,9 +280,10 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 // Printing printf/scanf formats
 // Alas cinttypes isn't that standard yet
 
-#ifdef _WIN32
+// Use Microsoft-specific format specifiers for Microsoft Visual C++ only
+#ifdef _MSC_VER
 # define VL_PRI64 "I64"
-#else // Linux or compliant Unix flavors
+#else  // use standard C99 format specifiers
 # if defined(__WORDSIZE) && (__WORDSIZE == 64)
 #  define VL_PRI64 "l"
 # else
@@ -207,19 +291,15 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 # endif
 #endif
 
-#ifdef _WIN32
-# define VL_VSNPRINTF vl_vsnprintf
-inline int vl_vsnprintf(char* str, size_t size, const char* format, va_list ap) {
-    int count = -1;
-    if (size != 0) {
-        count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
-    }
-    if (count == -1) {
-        count = _vscprintf(format, ap);
-    }
-    return count;
-}
+#if defined(_WIN32) && defined(_MSC_VER)
+# if (_MSC_VER < 1900)
+#  define VL_SNPRINTF _snprintf
+# else
+#  define VL_SNPRINTF snprintf
+# endif
+# define VL_VSNPRINTF vsnprintf
 #else
+# define VL_SNPRINTF snprintf
 # define VL_VSNPRINTF vsnprintf
 #endif
 
@@ -228,45 +308,53 @@ inline int vl_vsnprintf(char* str, size_t size, const char* format, va_list ap)
 
 #ifdef _WIN32
 # define VL_DEV_NULL "nul"
-#else // Linux or compliant Unix flavors
+#else  // Linux or compliant Unix flavors
 # define VL_DEV_NULL "/dev/null"
 #endif
 
 //=========================================================================
 // Integer size macros
 
-#define VL_BYTESIZE 8			///< Bits in a byte
-#define VL_SHORTSIZE 16			///< Bits in a short
-#define VL_WORDSIZE 32			///< Bits in a word
-#define VL_QUADSIZE 64			///< Bits in a quadword
-#define VL_WORDSIZE_LOG2 5		///< log2(VL_WORDSIZE)
+#define VL_BYTESIZE 8                   ///< Bits in a byte
+#define VL_SHORTSIZE 16                 ///< Bits in a short
+#define VL_WORDSIZE 32                  ///< Bits in a word
+#define VL_QUADSIZE 64                  ///< Bits in a quadword
+#define VL_WORDSIZE_LOG2 5              ///< log2(VL_WORDSIZE)
 
 /// Bytes this number of bits needs (1 bit=1 byte)
 #define VL_BYTES_I(nbits) (((nbits)+(VL_BYTESIZE-1))/VL_BYTESIZE)
 /// Words this number of bits needs (1 bit=1 word)
 #define VL_WORDS_I(nbits) (((nbits)+(VL_WORDSIZE-1))/VL_WORDSIZE)
 
+//=========================================================================
+// Class definition helpers
+
+// Used to declare a class as uncopyable; put after a private:
+#define VL_UNCOPYABLE(Type)  \
+    Type(const Type& other) VL_EQ_DELETE;  \
+    Type& operator= (const Type&) VL_EQ_DELETE
+
 //=========================================================================
 // Verilated function size macros
 
-#define VL_MULS_MAX_WORDS 16		///< Max size in words of MULS operation
-#define VL_TO_STRING_MAX_WORDS 64	///< Max size in words of String conversion operation
+#define VL_MULS_MAX_WORDS 16            ///< Max size in words of MULS operation
+#define VL_TO_STRING_MAX_WORDS 64       ///< Max size in words of String conversion operation
 
 //=========================================================================
 // Base macros
 
-#define VL_SIZEBITS_I (VL_WORDSIZE-1)	///< Bit mask for bits in a word
-#define VL_SIZEBITS_Q (VL_QUADSIZE-1)	///< Bit mask for bits in a quad
+#define VL_SIZEBITS_I (VL_WORDSIZE-1)   ///< Bit mask for bits in a word
+#define VL_SIZEBITS_Q (VL_QUADSIZE-1)   ///< Bit mask for bits in a quad
 
 /// Mask for words with 1's where relevant bits are (0=all bits)
 #define VL_MASK_I(nbits)  (((nbits) & VL_SIZEBITS_I) \
-			 ? ((1U << ((nbits) & VL_SIZEBITS_I) )-1) : ~0)
+                         ? ((1U << ((nbits) & VL_SIZEBITS_I) )-1) : ~0)
 /// Mask for quads with 1's where relevant bits are (0=all bits)
 #define VL_MASK_Q(nbits)  (((nbits) & VL_SIZEBITS_Q) \
-			 ? ((VL_ULL(1) << ((nbits) & VL_SIZEBITS_Q) )-VL_ULL(1)) : VL_ULL(~0))
-#define VL_BITWORD_I(bit)	((bit)/VL_WORDSIZE)	///< Word number for a wide quantity
-#define VL_BITBIT_I(bit)	((bit)&VL_SIZEBITS_I)	///< Bit number for a bit in a long
-#define VL_BITBIT_Q(bit)	((bit)&VL_SIZEBITS_Q)	///< Bit number for a bit in a quad
+                         ? ((VL_ULL(1) << ((nbits) & VL_SIZEBITS_Q) )-VL_ULL(1)) : VL_ULL(~0))
+#define VL_BITWORD_I(bit) ((bit)/VL_WORDSIZE)  ///< Word number for a wide quantity
+#define VL_BITBIT_I(bit) ((bit)&VL_SIZEBITS_I)  ///< Bit number for a bit in a long
+#define VL_BITBIT_Q(bit) ((bit)&VL_SIZEBITS_Q)  ///< Bit number for a bit in a quad
 
 //=========================================================================
 // Floating point
@@ -281,5 +369,42 @@ inline int vl_vsnprintf(char* str, size_t size, const char* format, va_list ap)
 #endif
 
 //=========================================================================
+// Performance counters
 
-#endif /*guard*/
+/// The vluint64_t argument is loaded with a high-performance counter for profiling
+/// or 0x0 if not implemeted on this platform
+#if defined(__i386__) || defined(__x86_64__)
+# define VL_RDTSC(val) {  \
+    vluint32_t hi, lo;  \
+    asm volatile("rdtsc" : "=a" (lo), "=d" (hi));  \
+    (val) = ((vluint64_t)lo) | (((vluint64_t)hi)<<32);  \
+}
+#elif defined(__aarch64__)
+# define VL_RDTSC(val) asm volatile("mrs %[rt],PMCCNTR_EL0" : [rt] "=r" (val));
+#else
+// We just silently ignore unknown OSes, as only leads to missing statistics
+# define VL_RDTSC(val) (val) = 0;
+#endif
+
+//=========================================================================
+// Threading related OS-specific functions
+
+#if VL_THREADED
+# if defined(__i386__) || defined(__x86_64__)
+/// For more efficient busy waiting on SMT CPUs, let the processor know
+/// we're just waiting so it can let another thread run
+#  define VL_CPU_RELAX() asm volatile("rep; nop" ::: "memory")
+# elif defined(__ia64__)
+#  define VL_CPU_RELAX() asm volatile("hint @pause" ::: "memory")
+# elif defined(__aarch64__)
+#  define VL_CPU_RELAX() asm volatile("yield" ::: "memory")
+# elif defined(__powerpc64__)
+#  define VL_CPU_RELAX() asm volatile("or 1, 1, 1; or 2, 2, 2;" ::: "memory")
+# else
+#  error "Missing VL_CPU_RELAX() definition. Or, don't use VL_THREADED"
+# endif
+#endif
+
+//=========================================================================
+
+#endif  // Guard

include/vltstd/svdpi.h

@@ -7,7 +7,7 @@
  * This file contains the constant definitions, structure definitions,
  * and routine declarations used by SystemVerilog DPI.
  *
- * This file is from the SystemVerilog IEEE 1800-2012 Annex I.
+ * This file is from the SystemVerilog IEEE 1800-2017 Annex I.
  */
 
 #ifndef INCLUDED_SVDPI
@@ -117,7 +117,7 @@ typedef uint32_t svBitVecVal;
 /*
  * Return implementation version information string ("1800-2005" or "SV3.1a").
  */
-XXTERN const char* svDpiVersion();
+XXTERN const char* svDpiVersion( void );
 
 /* a handle to a scope (an instance of a module or interface) */
 XXTERN typedef void* svScope;
@@ -155,7 +155,7 @@ XXTERN void svGetPartselBit(svBitVecVal* d, const svBitVecVal* s, int i, int w);
 XXTERN void svGetPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w);
 
 XXTERN void svPutPartselBit(svBitVecVal* d, const svBitVecVal s, int i, int w);
-XXTERN void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w);
+XXTERN void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal s, int i, int w);
 
 /*
  * Open array querying functions
@@ -241,28 +241,28 @@ XXTERN void svGetLogicArrElem2VecVal(svLogicVecVal* d, const svOpenArrayHandle s
 XXTERN void svGetLogicArrElem3VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
         int indx1, int indx2, int indx3);
 
-XXTERN   svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...);
-XXTERN   svBit svGetBitArrElem1(const svOpenArrayHandle s, int indx1);
-XXTERN   svBit svGetBitArrElem2(const svOpenArrayHandle s, int indx1, int indx2);
-XXTERN   svBit svGetBitArrElem3(const svOpenArrayHandle s, int indx1, int indx2,
+XXTERN svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...);
+XXTERN svBit svGetBitArrElem1(const svOpenArrayHandle s, int indx1);
+XXTERN svBit svGetBitArrElem2(const svOpenArrayHandle s, int indx1, int indx2);
+XXTERN svBit svGetBitArrElem3(const svOpenArrayHandle s, int indx1, int indx2,
           int indx3);
-XXTERN   svLogic svGetLogicArrElem(const svOpenArrayHandle s, int indx1, ...);
-XXTERN   svLogic svGetLogicArrElem1(const svOpenArrayHandle s, int indx1);
-XXTERN   svLogic svGetLogicArrElem2(const svOpenArrayHandle s, int indx1, int indx2);
-XXTERN   svLogic svGetLogicArrElem3(const svOpenArrayHandle s, int indx1, int indx2,
+XXTERN svLogic svGetLogicArrElem(const svOpenArrayHandle s, int indx1, ...);
+XXTERN svLogic svGetLogicArrElem1(const svOpenArrayHandle s, int indx1);
+XXTERN svLogic svGetLogicArrElem2(const svOpenArrayHandle s, int indx1, int indx2);
+XXTERN svLogic svGetLogicArrElem3(const svOpenArrayHandle s, int indx1, int indx2,
           int indx3);
-XXTERN   void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1,
+XXTERN void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1,
           ...);
-XXTERN   void svPutLogicArrElem1(const svOpenArrayHandle d, svLogic value, int indx1);
-XXTERN   void svPutLogicArrElem2(const svOpenArrayHandle d, svLogic value, int indx1,
+XXTERN void svPutLogicArrElem1(const svOpenArrayHandle d, svLogic value, int indx1);
+XXTERN void svPutLogicArrElem2(const svOpenArrayHandle d, svLogic value, int indx1,
           int indx2);
-XXTERN   void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1,
+XXTERN void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1,
           int indx2, int indx3);
-XXTERN   void svPutBitArrElem(const svOpenArrayHandle d, svBit value, int indx1, ...);
-XXTERN   void svPutBitArrElem1(const svOpenArrayHandle d, svBit value, int indx1);
-XXTERN   void svPutBitArrElem2(const svOpenArrayHandle d, svBit value, int indx1,
+XXTERN void svPutBitArrElem(const svOpenArrayHandle d, svBit value, int indx1, ...);
+XXTERN void svPutBitArrElem1(const svOpenArrayHandle d, svBit value, int indx1);
+XXTERN void svPutBitArrElem2(const svOpenArrayHandle d, svBit value, int indx1,
           int indx2);
-XXTERN   void svPutBitArrElem3(const svOpenArrayHandle d, svBit value, int indx1,
+XXTERN void svPutBitArrElem3(const svOpenArrayHandle d, svBit value, int indx1,
           int indx2, int indx3);
 
 /* Functions for working with DPI context */
@@ -273,7 +273,7 @@ XXTERN   void svPutBitArrElem3(const svOpenArrayHandle d, svBit value, int indx1
  * is the scope of the function's declaration site, not call site.
  * Returns NULL if called from C code that is *not* an imported function.
  */
-XXTERN svScope svGetScope();
+XXTERN svScope svGetScope( void );
 
 /*
  * Set context for subsequent export function execution.
@@ -337,7 +337,7 @@ XXTERN int svGetCallerInfo(const char** fileName, int *lineNumber);
  * Returns 1 if the current execution thread is in the disabled state.
  * Disable protocol must be adhered to if in the disabled state.
  */
-XXTERN int svIsDisabledState();
+XXTERN int svIsDisabledState( void );
 
 /*
  * Imported functions call this API function during disable processing to
@@ -345,7 +345,7 @@ XXTERN int svIsDisabledState();
  * This function must be called before returning from an imported function that is
  * in the disabled state.
  */
-XXTERN void svAckDisabledState();
+XXTERN void svAckDisabledState( void );
 
 /*
  **********************************************************

include/vltstd/vpi_user.h

@@ -1,7 +1,7 @@
 /*******************************************************************************
  * vpi_user.h
  *
- * IEEE Std 1800-2012 Programming Language Interface (PLI)
+ * IEEE Std 1800-2017 Programming Language Interface (PLI)
  *
  * This file contains the constant definitions, structure definitions, and
  * routine declarations used by the SystemVerilog Verification Procedural
@@ -105,10 +105,12 @@ typedef unsigned char    PLI_UBYTE8;
 
 /* object is defined imported by the application */
 
+#undef XXTERN
 #define XXTERN PLI_EXTERN PLI_DLLISPEC
 
 /* object is exported by the application */
 
+#undef EETERN
 #define EETERN PLI_EXTERN PLI_DLLESPEC
 #endif
 
@@ -249,7 +251,7 @@ typedef PLI_UINT32 *vpiHandle;
 #define vpiModPathOut         96   /* output terminal of a module path */
 #define vpiOperand            97   /* operand of expression */
 #define vpiPortInst           98   /* connected port instance */
-#define vpiProcess            99   /* process in module */
+#define vpiProcess            99   /* process in module, program or interface */
 #define vpiVariables         100   /* variables in module */
 #define vpiUse               101   /* usage */
 
@@ -976,7 +978,7 @@ XXTERN vpiHandle    vpi_handle_by_multi_index PROTO_PARAMS((vpiHandle obj,
 
 /****************************** GLOBAL VARIABLES ******************************/
 
-PLI_VEXTERN PLI_DLLESPEC void (*vlog_startup_routines[])();
+PLI_VEXTERN PLI_DLLESPEC void (*vlog_startup_routines[])( void );
 
   /* array of function pointers, last pointer should be null */
 

install-sh

@@ -124,7 +124,7 @@ if [ x"$dir_arg" != x ]; then
 else
 
 # Waiting for this to be detected by the "$instcmd $src $dsttmp" command
-# might cause directories to be created, which would be especially bad 
+# might cause directories to be created, which would be especially bad
 # if $src (and thus $dsttmp) contains '*'.
 
 	if [ -f $src -o -d $src ]
@@ -134,7 +134,7 @@ else
 		echo "install:  $src does not exist"
 		exit 1
 	fi
-	
+
 	if [ x"$dst" = x ]
 	then
 		echo "install:	no destination specified"
@@ -162,7 +162,7 @@ dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
 
 # Skip lots of stat calls in the usual case.
 if [ ! -d "$dstdir" ]; then
-defaultIFS='	
+defaultIFS='
 '
 IFS="${IFS-${defaultIFS}}"
 
@@ -201,17 +201,17 @@ else
 
 # If we're going to rename the final executable, determine the name now.
 
-	if [ x"$transformarg" = x ] 
+	if [ x"$transformarg" = x ]
 	then
 		dstfile=`basename $dst`
 	else
-		dstfile=`basename $dst $transformbasename | 
+		dstfile=`basename $dst $transformbasename |
 			sed $transformarg`$transformbasename
 	fi
 
 # don't allow the sed command to completely eliminate the filename
 
-	if [ x"$dstfile" = x ] 
+	if [ x"$dstfile" = x ]
 	then
 		dstfile=`basename $dst`
 	else
@@ -242,7 +242,7 @@ else
 # Now rename the file to the real destination.
 
 	$doit $rmcmd -f $dstdir/$dstfile &&
-	$doit $mvcmd $dsttmp $dstdir/$dstfile 
+	$doit $mvcmd $dsttmp $dstdir/$dstfile
 
 fi &&
 

internals.pod

@@ -155,6 +155,221 @@ provided and documented in C<V3GraphAlg.cpp>.
 
 =back
 
+=head2 Multithreaded Mode
+
+In --threads mode, the frontend of the Verilator pipeline is the same as
+serial mode, up until V3Order.
+
+V3Order builds a fine-grained, statement-level dependency graph that governs
+the ordering of code within a single eval() call. In serial mode, that
+dependency graph is used to order all statements into a total serial order.
+In parallel mode, the same dependency graph is the starting point for a
+partitioner (V3Partition).
+
+The partitioner's goal is to coarsen the fine-grained DAG into a coarser
+DAG, while maintaining as much available parallelism as possible. Often the
+partitioner can transform an input graph with millions of nodes into a
+coarsened execution graph with a few dozen nodes, while maintaining enough
+parallelism to take advantage of a modern multicore CPU. Runtime
+synchronization cost is not prohibitive with so few nodes.
+
+=head3 Partitioning
+
+Our partitioner is similar to the one Vivek Sarkar described in his 1989
+paper "Partitioning and Scheduling Parallel Programs for Multiprocessors".
+
+Let's define some terms:
+
+=over 4
+
+=item C<Par Factor>
+
+The available parallelism or "par-factor" of a DAG is the total cost to
+execute all nodes, divided by the cost to execute the longest critical path
+through the graph. This is the speedup you would get from running the graph
+in parallel, if given infinite CPU cores available and communication and
+synchronization are zero.
+
+=item C<Macro Task>
+
+When the partitioner coarsens the graph, it combines nodes together. Each
+fine-grained node represents an atomic "task"; combined nodes in the
+coarsened graph are "macro-tasks". This term comes from Sarkar. Each
+macro-task executes from start to end on one processor, without any
+synchronization to any other macro-task during its
+execution. (Synchronization only happens before the macro-task begins or
+after it ends.)
+
+=item C<Edge Contraction>
+
+Our partitioner, like Sarkar's, primarily relies on "edge contraction" to
+coarsen the graph. It starts with one macro-task per atomic task and
+iteratively combines pairs of edge-connected macro-tasks.
+
+=item C<Local Critical Path>
+
+Each node in the graph has a "local" critical path. That's the critical
+path from the start of the graph to the start of the node, plus the node's
+cost, plus the critical path from the end of the node to the end of the
+graph.
+
+=back
+
+Sarkar calls out an important trade-off: coarsening the graph reduces
+runtime synchronization overhead among the macro-tasks, but it tends to
+increase the critical path through the graph and thus reduces par-factor.
+
+Sarkar's partitioner, and ours, chooses pairs of macro-tasks to merge such
+that the growth in critical path is minimized. Each candidate merge would
+result in a new node, which would have some local critical path. We choose
+the candidate that would produce the shortest local critical path. Repeat
+until par-factor falls to a target threshold. It's a greedy algorithm, and
+it's not guaranteed to produce the best partition (which Sarkar proves is
+NP-hard).
+
+=head3 Estimating Logic Costs
+
+To compute the cost of any given path through the graph, Verilator
+estimates an execution cost for each task. Each macro-task has an execution
+cost which is simply the sum of its tasks' costs. We assume that
+communication overhead and synchronization overhead are zero, so the cost
+of any given path through the graph is simply the sum of macro-task
+execution costs. Sarkar does almost the same thing, except that he has
+nonzero estimates for synchronization costs.
+
+Verilator's cost estimates are assigned by the InstrCountCostVisitor.  This
+class is perhaps the most fragile piece of the multithread implementation.
+It's easy to have a bug where you count something cheap (eg. accessing one
+element of a huge array) as if it were expensive (eg. by counting it as if
+it were an access to the entire array.) Even without such gross bugs, the
+estimates this produce are only loosely predictive of actual runtime cost.
+Multithread performance would be better with better runtime costs
+estimates.  This is an area to improve.
+
+=head3 Scheduling Macro-Tasks at Runtime
+
+After coarsening the graph, we must schedule the macro-tasks for runtime.
+Sarkar describes two options: you can dynamically schedule tasks at
+runtime, with a runtime graph follower. Sarkar calls this the
+"macro-dataflow model."  Verilator does not support this; early experiments
+with this approach had poor performance.
+
+The other option is to statically assign macro-tasks to threads, with each
+thread running its macro-tasks in a static order. Sarkar describes this in
+Chapter 5. Verilator takes this static approach. The only dynamic aspect is
+that each macro task may block before starting, to wait until its
+prerequisites on other threads have finished.
+
+The synchronization cost is cheap if the prereqs are done. If they're not,
+fragmentation (idle CPU cores waiting) is possible. This is the major
+source of overhead in this approach. The --prof-threads switch and the
+C<verilator_gantt> script can visualize the time lost to such
+fragmentation.
+
+=head3 Locating Variables for Best Spatial Locality
+
+After scheduling all code, we attempt to locate variables in memory such
+that variables accessed by a single macro-task are close together in
+memory.  This provides "spatial locality" -- when we pull in a 64-byte
+cache line to access a 2-byte variable, we want the other 62 bytes to be
+ones we'll also likely access soon, for best cache performance.
+
+This turns out to be critical for performance. It should allow Verilator
+to scale to very large models. We don't rely on our working set fitting
+in any CPU cache; instead we essentially "stream" data into caches from
+memory. It's not literally streaming, where the address increases
+monotonically, but it should have similar performance characteristics,
+so long as each macro-task's dataset fits in one core's local caches.
+
+To achieve spatial locality, we tag each variable with the set of
+macro-tasks that access it. Let's call this set the "footprint" of that
+variable. The variables in a given module have a set of footprints. We can
+order those footprints to minimize the distance between them (distance is
+the number of macro-tasks that are different across any two footprints) and
+then emit all variables into the struct in ordered-footprint order.
+
+The footprint ordering is literally the traveling salesman problem, and we
+use a TSP-approximation algorithm to get close to an optimal sort.
+
+This is an old idea. Simulators designed at DEC in the early 1990s used
+similar techniques to optimize both single-thread and multi-thread modes.
+(Verilator does not optimize variable placement for spatial locality in
+serial mode; that is a possible area for improvement.)
+
+=head3 Improving Multithreaded Performance Further (a TODO list)
+
+=over 4
+
+=item C<Wave Scheduling>
+
+To allow the Verilated model to run in parallel with the testbench, it
+might be nice to support "wave" scheduling, in which work on a cycle begins
+before eval() is called or continues after eval() returns.  For now all
+work on a cycle happens during the eval() call, leaving Verilator's threads
+idle while the testbench (everything outside eval()) is working. This would
+involve fundamental changes within the partitioner, however, it's probably
+the best bet for hiding testbench latency.
+
+=item C<Efficient Dynamic Scheduling>
+
+To scale to more than a few threads, we may revisit a fully dynamic
+scheduler. For large (>16 core) systems it might make sense to dedicate an
+entire core to scheduling, so that scheduler data structures would fit in
+its L1 cache and thus the cost of traversing priority-ordered ready lists
+would not be prohibitive.
+
+=item C<Static Scheduling with Runtime Repack>
+
+We could modify the static scheduling approach by gathering actual
+macro-task execution times at run time, and dynamically re-packing the
+macro-tasks into the threads also at run time. Say, re-pack once every
+10,000 cycles or something. This has the potential to do better than our
+static estimates about macro-task run times. It could potentially react to
+CPU cores that aren't performing equally, due to NUMA or thermal throttling
+or nonuniform competing memory traffic or whatever.
+
+=item C<Clock Domain Balancing>
+
+Right now Verilator makes no attempt to balance clock domains across
+macro-tasks. For a multi-domain model, that could lead to bad gantt chart
+fragmentation. This could be improved if it's a real problem in practice.
+
+=item C<Other Forms of MTask Balancing>
+
+The largest source of runtime overhead is idle CPUs, which happens due to
+variance between our predicted runtime for each MTask and its actual
+runtime. That variance is magnified if MTasks are homogeneous, containing
+similar repeating logic which was generally close together in source code
+and which is still packed together even after going through Verilator's
+digestive tract.
+
+If Verilator could avoid doing that, and instead would take source logic
+that was close together and distribute it across MTasks, that would
+increase the diversity of any given MTask, and this should reduce variance
+in the cost estimates.
+
+One way to do that might be to make various "tie breaker" comparison
+routines in the sources to rely more heavily on randomness, and generally
+try harder not to keep input nodes together when we have the option to
+scramble things.
+
+=item C<Performance Regression>
+
+It would be nice if we had a regression of large designs, with some
+diversity of design styles, to test on both single- and multi-threaded
+modes. This would help to avoid performance regressions, and also to
+evaluate the optimizations while minimizing the impact of parasitic noise.
+
+=item C<Per-Instance Classes>
+
+If we have multiple instances of the same module, and they partition
+differently (likely; we make no attempt to partition them the same) then
+the variable sort will be suboptimal for either instance.  A possible
+improvement would be to emit a unique class for each instance of a module,
+and sort its variables optimally for that instance's code stream.
+
+=back
+
 =head2 Verilated Flow
 
 The evaluation loop outputted by Verilator is designed to allow a single
@@ -237,10 +452,10 @@ implementation is not found, the system will look in turn for overloaded
 implementations up the inheritance hierarchy. For example calling C<accept>
 on C<AstIf> will look in turn for:
 
-  void visit (AstIf* nodep, AstNUser* vup)
-  void visit (AstNodeIf* nodep, AstNUser* vup)
-  void visit (AstNodeStmt* nodep, AstNUser* vup)
-  void visit (AstNode* nodep, AstNUser* vup)
+  void visit(AstIf* nodep)
+  void visit(AstNodeIf* nodep)
+  void visit(AstNodeStmt* nodep)
+  void visit(AstNode* nodep)
 
 There are three ways data is passed between visitor functions.
 
@@ -268,8 +483,8 @@ technique lifted from graph traversal packages).
 A visitor first clears the one it wants to use by calling
 C<AstNode::user#ClearTree()>, then it can mark any node's user() with whatever
 data it wants.  Readers just call C<< nodep->user() >>, but may need to cast
-appropriately, so you'll often see C<< nodep->userp()->castSOMETYPE() >>.  At
-the top of each visitor are comments describing how the C<user()> stuff
+appropriately, so you'll often see C<< VN_CAST(nodep->userp(), SOMETYPE) >>.
+At the top of each visitor are comments describing how the C<user()> stuff
 applies to that visitor class.  For example:
 
     // NODE STATE
@@ -299,16 +514,13 @@ as it slows the program down to have to pass vup everywhere.)
 
 =head2 Iterators
 
-C<AstNode> provides a set of iterators to facilitate walking over the
-tree. Each takes two arguments, a visitor, C<v>, of type C<AstNVisitor> and
-an optional pointer user data, C<vup>, of type C<AstNUser*>. The second is
-one of the ways to pass parameters to visitors described in L</Visitor
-Functions>, but its use is now deprecated and should I<not> be used for new
-visitor classes.
+C<AstNVisitor> provides a set of iterators to facilitate walking over the
+tree. Each operates on the current C<AstNVisitor> class (as this) and takes
+an argument type C<AstNode*>.
 
 =over 4
 
-=item C<iterate()>
+=item C<iterate>
 
 This just applies the C<accept> method of the C<AstNode> to the visitor
 function.
@@ -349,9 +561,9 @@ to be aware that calling iteration may cause the children to change.  For
 example:
 
     // nodep->lhsp() is 0x1234000
-    nodep->lhsp()->iterateAndNext(...);  // and under covers nodep->lhsp() changes
+    iterateAndNextNull(nodep->lhsp());  // and under covers nodep->lhsp() changes
     // nodep->lhsp() is 0x5678400
-    nodep->lhsp()->iterateAndNext(...);
+    iterateAndNextNull(nodep->lhsp());
 
 Will work fine, as even if the first iterate causes a new node to take the
 place of the lhsp(), that edit will update nodep->lhsp() and the second
@@ -359,9 +571,9 @@ call will correctly see the change. Alternatively:
 
     lp = nodep->lhsp();
     // nodep->lhsp() is 0x1234000, lp is 0x1234000
-    lp->iterateAndNext(...); **lhsp=NULL;** // and under covers nodep->lhsp() changes
+    iterateAndNextNull(lp); **lhsp=NULL;**  // and under covers nodep->lhsp() changes
     // nodep->lhsp() is 0x5678400, lp is 0x1234000
-    lp->iterateAndNext(...);
+    iterateAndNextNull(lp);
 
 This will cause bugs or a core dump, as lp is a dangling pointer.  Thus it
 is advisable to set lhsp=NULL shown in the *'s above to make sure these
@@ -370,7 +582,7 @@ V3Width is to use acceptSubtreeReturnEdits, which operates on a single node
 and returns the new pointer if any.  Note acceptSubtreeReturnEdits does not
 follow nextp() links.
 
-    lp = lp->acceptSubtreeReturnEdits()
+    lp = acceptSubtreeReturnEdits(lp)
 
 =head2 Identifying derived classes
 
@@ -379,16 +591,16 @@ dealing with. For example a visitor might not implement separate C<visit>
 methods for C<AstIf> and C<AstGenIf>, but just a single method for the base
 class:
 
-  void visit (AstNodeIf* nodep, AstNUser* vup)
+  void visit (AstNodeIf* nodep)
 
 However that method might want to specify additional code if it is called
-for C<AstGenIf>. Verilator does this by providing a C<castSOMETYPE()>
+for C<AstGenIf>. Verilator does this by providing a C<VN_CAST>
 method for each possible node type, using C++ C<dynamic_cast>. This either
 returns a pointer to the object cast to that type (if it is of class
 C<SOMETYPE>, or a derived class of C<SOMETYPE>) or else NULL. So our
 C<visit> method could use:
 
-  if (nodep->castAstGenIf()) {
+  if (VN_CAST(nodep, AstGenIf) {
       <code specific to AstGenIf>
   }
 
@@ -485,10 +697,10 @@ be warning free.
 
 =item --enable-longtests
 
-In addition to the standard C, SystemC tests also run the tests in the
-C<test_verilated> and C<test_regress> directories when using I<make test>.
-This is disabled by default as SystemC installation problems would
-otherwise falsely indicate a Verilator problem.
+In addition to the standard C, SystemC examples, also run the tests in the
+C<test_regress> directory when using I<make test>.  This is disabled by
+default as SystemC installation problems would otherwise falsely indicate a
+Verilator problem.
 
 =back
 
@@ -614,7 +826,7 @@ level. For example after inlining:
 
 The textual name of this node AST type (always in capitals). Many of these
 correspond directly to Verilog entities (for example C<MODULE> and
-C<TASK>), but others are internal to Verialtor (for example C<NETLIST> and
+C<TASK>), but others are internal to Verilator (for example C<NETLIST> and
 C<BASICDTYPE>).
 
 =item Address of the node
@@ -709,7 +921,7 @@ Start GDB, then C<start> with the remaining arguments.
   Temporary breakpoint 1, main (argc=13, argv=0xbfffefa4, env=0xbfffefdc)
       at ../Verilator.cpp:615
   615         ios::sync_with_stdio();
-  (gdb) 
+  (gdb)
 
 You can then continue execution with breakpoints as required.
 
@@ -749,7 +961,7 @@ File a bug (if there isn't already) so others know what you're working on.
 
 =item 2.
 
-Make a testcase in the test_regress/t/t_EXAMPLE format, see L<TESTING>.
+Make a testcase in the test_regress/t/t_EXAMPLE format, see L</TESTING>.
 
 =item 3.
 
@@ -785,7 +997,7 @@ in C<src/Makefile_obj.in> and reconfigure.
 
 The latest version is available from L<http://www.veripool.org/>.
 
-Copyright 2008-2015 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2008-2019 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.
 

nodist/bisondiff

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 ######################################################################
 #
-# Copyright 2007-2015 by Wilson Snyder.  This package is free software; you
+# Copyright 2007-2019 by Wilson Snyder.  This package 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.
@@ -23,9 +23,9 @@ our $Debug;
 our $Opt_Unsup;
 
 if (! GetOptions (
-	  #"help"	=> \&usage,
-	  "debug"	=> sub { $Debug = 1; },
-	  "unsup!"	=> \$Opt_Unsup,		# Ignore unsupported
+          #"help"       => \&usage,
+          "debug"       => sub { $Debug = 1; },
+          "unsup!"      => \$Opt_Unsup,  # Ignore unsupported
     )) {
     die "usage();"
 }
@@ -59,24 +59,24 @@ sub prep {
     my $rule = "";
     my $skip = 1;
     while (defined(my $line = $fh->getline)) {
-	if ($skip == 1) {
-	    next if $line !~ /%token/;
-	    $skip = 2;
-	}
+        if ($skip == 1) {
+            next if $line !~ /%token/;
+            $skip = 2;
+        }
 
-	if ($Opt_Unsup) {
-	    $line =~ s!//UNSUP!|!g;
-	    $line =~ s!(\s+)\|(\s+)!$1$2!g;  # As "UNSUP" often replaces "|"
-	}
+        if ($Opt_Unsup) {
+            $line =~ s!//UNSUP!|!g;
+            $line =~ s!(\s+)\|(\s+)!$1$2!g;  # As "UNSUP" often replaces "|"
+        }
 
-	# %type<foo>
-	$line =~ s/^(%\S+)<(\S+)>/$1/;
-	# rule<foo>
-	$line =~ s/^([a-zA-Z0-9_]+)<\S+>:/$1:/;
-	# Productions
-	$line =~ s/[ \t]{[^}]*?}/\t{}/g;
+        # %type<foo>
+        $line =~ s/^(%\S+)<(\S+)>/$1/;
+        # rule<foo>
+        $line =~ s/^([a-zA-Z0-9_]+)<\S+>:/$1:/;
+        # Productions
+        $line =~ s/[ \t]{[^}]*?}/\t{}/g;
 
-	$fho->print($line);
+        $fho->print($line);
     }
 }
 

nodist/bisonreader

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 ######################################################################
 #
-# Copyright 2007-2015 by Wilson Snyder.  This package is free software; you
+# Copyright 2007-2019 by Wilson Snyder.  This package 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.
@@ -32,27 +32,27 @@ foreach my $line (<STDIN>) {
     $line =~ s!\s+! !g;
     next if $line eq '';
     if ($line =~ m!^\%\%!) {
-	$body++;
+        $body++;
     } elsif ($body == 1) {
-	$rule .= $line;
-	if ($line =~ m!^\s*;\s*$!) {
-	    #print "Rule: $rule\n";
-	    ($rule =~ /^([a-zA-Z0-9_]+)(<\S+>)?:(.*)$/) or die "%Error: No rule name: $1\n";
-	    my $rulename = $1; my $preaction = $3;
-	    $declared{$rulename} = $lineno;
-	    $preaction =~ s/\{[^\}]*\}/ /g;
-	    #print "RULEN $rulename PA $preaction\n" if $Debug;
-	    $rule = '';
-	    foreach my $ref (split /\s+/, $preaction) {
-		next if $ref !~ /^[a-zA-Z]/;
-		next if $ref eq $rulename;
-		if (!$used{$ref} && $declared{$ref}) {
-		    print "   %Warning: $lineno: $ref used by $rulename after declaration\n";
-		}
-		$used{$ref} = $lineno;
-		print "  ref $ref\n" if $Debug;
-	    }
-	}
+        $rule .= $line;
+        if ($line =~ m!^\s*;\s*$!) {
+            #print "Rule: $rule\n";
+            ($rule =~ /^([a-zA-Z0-9_]+)(<\S+>)?:(.*)$/) or die "%Error: No rule name: $1\n";
+            my $rulename = $1; my $preaction = $3;
+            $declared{$rulename} = $lineno;
+            $preaction =~ s/\{[^\}]*\}/ /g;
+            #print "RULEN $rulename PA $preaction\n" if $Debug;
+            $rule = '';
+            foreach my $ref (split /\s+/, $preaction) {
+                next if $ref !~ /^[a-zA-Z]/;
+                next if $ref eq $rulename;
+                if (!$used{$ref} && $declared{$ref}) {
+                    print "   %Warning: $lineno: $ref used by $rulename after declaration\n";
+                }
+                $used{$ref} = $lineno;
+                print "  ref $ref\n" if $Debug;
+            }
+        }
     }
 }
 

nodist/code_coverage

@@ -0,0 +1,263 @@
+#!/usr/bin/perl -w
+# See copyright, etc in below POD section.
+######################################################################
+
+use Cwd;
+use File::Copy qw(cp);
+use File::Path qw(mkpath);
+use Getopt::Long;
+use IO::File;
+use Pod::Usage;
+use strict;
+use vars qw($Debug);
+
+our $Exclude_Line_Regexp;
+our @Remove_Sources;
+our @Source_Globs;
+
+#======================================================================
+# main
+
+our $Opt_Stage = 0;
+
+autoflush STDOUT 1;
+autoflush STDERR 1;
+Getopt::Long::config("no_auto_abbrev");
+if (! GetOptions(
+          "debug"       => sub { $Debug = 1; },
+          "<>"          => sub { die "%Error: Unknown parameter: $_[0]\n"; },
+          "stage=i"     => \$Opt_Stage,
+    )) {
+    die "%Error: Bad usage, try 'install_test --help'\n";
+}
+
+test();
+exit(0);
+
+#######################################################################
+
+sub test {
+    -r "nodist/code_coverage.dat" or die "%Error: Run from the top of the verilator kit,";
+    require "./nodist/code_coverage.dat";
+
+    if ($Opt_Stage <= 0) {
+        print "Stage 0: configure (coverage on)\n";
+        run("make distclean");
+        run("./configure --enable-longtests CXX='g++ --coverage'");
+        run("make -k");
+        # The optimized versions will not collect good coverage, overwrite them
+        run("cp bin/verilator_bin_dbg bin/verilator_bin");
+        run("cp bin/verilator_coverage_bin_dbg bin/verilator_coverage_bin");
+    }
+
+    if ($Opt_Stage <= 1) {
+        print "Stage 1: make examples (with coverage on)\n";
+        run("make examples");
+        run("make test_regress");
+    }
+
+    my $cc_dir = "nodist/obj_dir/coverage";
+    if ($Opt_Stage <= 2) {
+        print "Stage 2: Create info files under $cc_dir\n";
+        mkpath($cc_dir);
+        mkpath("$cc_dir/info");
+        my $dats = `find . -print | grep .gcda`;
+        my %dirs;
+        foreach my $dat (split '\n', $dats) {
+            $dat =~ s!/[^/]+$!!;
+            $dirs{$dat} = 1;
+        }
+        foreach my $dir (sort keys %dirs) {
+            (my $outname = $dir) =~ s![^a-zA-Z0-9]+!_!g;
+            run("cd $cc_dir/info ; lcov -c -d ../../../../$dir -o app_test_${outname}.info");
+        }
+    }
+
+    if ($Opt_Stage <= 3) {
+        # lcov doesn't have a control file to override single lines, so replicate the sources
+        print "Stage 3: Clone sources under $cc_dir\n";
+        clone_sources($cc_dir);
+    }
+
+    if ($Opt_Stage <= 4) {
+        print "Stage 4: Copy .gcno files\n";
+        my $dats = `find . -print | grep .gcno`;
+        foreach my $dat (split '\n', $dats) {
+            next if $dat =~ /$cc_dir/;
+            my $outdat = $cc_dir."/".$dat;
+            #print "cp $dat, $outdat);\n";
+            cp($dat, $outdat);
+        }
+    }
+
+    if ($Opt_Stage <= 5) {
+        print "Stage 5: Combine data files\n";
+        run("cd $cc_dir ; lcov -c -i -d src/obj_dbg -o app_base.info");
+        run("cd $cc_dir ; lcov -a app_base.info -o app_total.info");
+        my $infos = `cd $cc_dir ; find info -print | grep .info`;
+        my $comb = "";
+        my @infos = (split /\n/, $infos);
+        foreach my $info (@infos) {
+            $comb .= " -a $info";
+            # Need to batch them to avoid overrunning shell command length limit
+            if (length($comb) > 10000 || $info eq $infos[$#infos]) {
+                run("cd $cc_dir ; lcov -a app_total.info $comb -o app_total.info");
+                $comb = "";
+            }
+        }
+    }
+
+    if ($Opt_Stage <= 6) {
+        print "Stage 6: Filter processed source files\n";
+        my $cmd = '';
+        foreach my $glob (@Remove_Sources) {
+            $cmd .= " '$glob'";
+        }
+        run("cd $cc_dir ; lcov --remove app_total.info $cmd -o app_total.info");
+    }
+
+    if ($Opt_Stage <= 7) {
+        print "Stage 7: Create HTML\n";
+        cleanup_abs_paths($cc_dir, "$cc_dir/app_total.info", "$cc_dir/app_total.info");
+        run("cd $cc_dir ; genhtml app_total.info --demangle-cpp"
+            ." --rc lcov_branch_coverage=1 --rc genhtml_hi_limit=100 --output-directory html");
+    }
+
+    if ($Opt_Stage <= 9) {
+        print "*-* All Finished *-*\n";
+    }
+}
+
+sub clone_sources {
+    my $cc_dir = shift;
+    my $excluded_lines = 0;
+    foreach my $glob (@Source_Globs) {
+        foreach my $infile (glob $glob) {
+            $infile !~ m!^/!
+                or die "%Error: source globs should be relative not absolute filenames,";
+            my $outfile = $cc_dir."/".$infile;
+            (my $outpath = $outfile) =~ s!/[^/]*$!!;
+            mkpath($outpath);
+            my $fh = IO::File->new("<$infile") or die "%Error: $! $infile,";
+            my $ofh = IO::File->new(">$outfile") or die "%Error: $! $outfile,";
+            my $lineno = 0;
+            while (defined(my $line = $fh->getline)) {
+                $lineno++;
+                chomp $line;
+                if ($line !~ m!// LCOV_EXCL_LINE!
+                    && $line =~ /$Exclude_Line_Regexp/) {
+                    $line .= "  //code_coverage: // LCOV_EXCL_LINE";
+                    $excluded_lines++;
+                    #print "$infile:$lineno: $line";
+                } else {
+                }
+                $ofh->print("$line\n");
+            }
+        }
+    }
+    print "Source code lines automatically LCOV_EXCL_LINE'ed: $excluded_lines\n";
+}
+
+sub cleanup_abs_paths {
+    my $cc_dir = shift;
+    my $infile = shift;
+    my $outfile = shift;
+    my $fh = IO::File->new("<$infile") or die "%Error: $! $infile,";
+    my @lines;
+    while (defined(my $line = $fh->getline)) {
+        if ($line =~ m!^SF:!) {
+            $line =~ s!$ENV{VERILATOR_ROOT}/!!;
+            $line =~ s!$cc_dir/!!;
+            $line =~ s!obj_dbg/verilog.y$!verilog.y!;
+            #print "Remaining SF: ",$line;
+        }
+        push @lines, $line;
+    }
+    my $ofh = IO::File->new(">$outfile") or die "%Error: $! $outfile,";
+    $ofh->print(@lines);
+}
+
+#######################################################################
+# .dat file callbacks
+
+sub exclude_line_regexp {
+    $Exclude_Line_Regexp = shift;
+}
+
+sub remove_source {
+    my @srcs = @_;
+    push @Remove_Sources, @srcs;
+}
+
+sub source_globs {
+    my @dirs = @_;
+    push @Source_Globs, @dirs;
+}
+
+#######################################################################
+
+sub run {
+    # Run a system command, check errors
+    my $command = shift;
+    print "\t$command\n";
+    system "$command";
+    my $status = $?;
+    ($status == 0) or die "%Error: Command Failed $command, $status, stopped";
+}
+
+#######################################################################
+__END__
+
+=pod
+
+=head1 NAME
+
+code_coverage - Build and collect Verilator coverage
+
+=head1 SYNOPSIS
+
+  cd $VERILATOR_ROOT
+  nodist/code_coverage
+
+=head1 DESCRIPTION
+
+code_coverage builds Verilator with C++ coverage support and runs tests
+with coverage enabled.
+
+This will rebuild the current object files.
+
+=head1 ARGUMENTS
+
+=over 4
+
+=item --help
+
+Displays this message and program version and exits.
+
+=item -stage I<stage>
+
+Runs a specific stage (see the script).
+
+=back
+
+=head1 DISTRIBUTION
+
+Copyright 2019-2019 by Wilson Snyder.  This package 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.
+
+=head1 AUTHORS
+
+Wilson Snyder <[email protected]>
+
+=head1 SEE ALSO
+
+C<lcov>
+
+=cut
+
+######################################################################
+### Local Variables:
+### compile-command: "cd .. ; nodist/code_coverage "
+### End:

nodist/code_coverage.dat

@@ -0,0 +1,42 @@
+# -*- Perl -*-
+# DESCRIPTION: Verilator: Internal C++ code lcov control file
+#
+# Copyright 2019-2019 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.
+
+source_globs("src/*.cpp",
+             "src/*.h",
+             "src/*.l",
+             "src/*.y",
+             "src/obj_dbg/*.h",
+             "src/obj_dbg/*.cpp",
+             "include/*.c",
+             "include/*.cpp",
+             "include/*.h",
+             "include/*/*.h",
+             "include/*/*.cpp",
+             "include/*/*.c",
+    );
+
+remove_source("/usr/include/*");
+remove_source("*/include/sysc/*");
+remove_source("*/V3ClkGater.cpp");
+remove_source("*/V3ClkGater.h");
+remove_source("*/V3GraphDfa.cpp");
+remove_source("*/V3GraphDfa.h");
+remove_source("*/V3Lexer_pregen.yy.cpp");
+remove_source("*/V3PreLex_pregen.yy.cpp");
+remove_source("*/verilog.c");
+remove_source("*include/gtkwave/*");
+# Something wrong in generation, unfortunately as would like this
+#genhtml: ERROR: cannot read /svaha/wsnyder/SandBox/homecvs/v4/verilator/src/obj_dbg/verilog.y
+#remove_source("*/src/obj_dbg/verilog.y");
+remove_source("*test_regress/*");
+remove_source("*examples/*");
+
+
+exclude_line_regexp(qr/(\bv3fatalSrc\b|\bVL_UNCOVERABLE\b)/);
+
+1;

nodist/dot_importer

@@ -8,7 +8,7 @@ use IO::File;
 use Pod::Usage;
 use Data::Dumper; $Data::Dumper::Indent=1;
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);
 
 #======================================================================
 
@@ -24,22 +24,22 @@ $Debug = 0;
 my $opt_filename;
 autoflush STDOUT 1;
 autoflush STDERR 1;
-if (! GetOptions (
-		  "help"	=> \&usage,
-		  "debug"	=> \&debug,
-		  "<>"		=> \&parameter,
-		  )) {
+if (! GetOptions(
+          "help"        => \&usage,
+          "debug"       => \&debug,
+          "<>"          => \&parameter,
+    )) {
     usage();
 }
 
-dotread ($opt_filename);
-cwrite ("graph_export.cpp");
+dotread($opt_filename);
+cwrite("graph_export.cpp");
 
 #----------------------------------------------------------------------
 
 sub usage {
     pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
-    exit (1);
+    exit(1);
 }
 
 sub debug {
@@ -49,9 +49,9 @@ sub debug {
 sub parameter {
     my $param = shift;
     if (!$opt_filename) {
-	$opt_filename = $param;
+        $opt_filename = $param;
     } else {
-	die "%Error: Unknown parameter: $param\n";
+        die "%Error: Unknown parameter: $param\n";
     }
 }
 
@@ -64,30 +64,30 @@ sub dotread {
     my $header = 1;
     my $vnum = 0;
     while (defined (my $line = $fh->getline)) {
-	if ($line =~ /^\t([a-zA-Z0-9_]+)\t(.*)$/) {
-	    next if $1 eq 'nTITLE';
-	    $header = 0;
-	    $Vertexes{$1} = {num => $vnum++,
-			     line => $line,
-			     name => $1,};
-	}
-	elsif ($line =~ /^\t([a-zA-Z0-9_]+)\s+->\s+([a-zA-Z0-9_]+)\s+(.*)$/) {
-	    my $from=$1; my $to=$2;
-	    my $weight = 1; $weight = $1 if $line =~ /weight=(\d+)/;
-	    my $cutable = undef; $cutable = $1 if $line =~ /style=(\S+)/;
-	    my $edge =  {num => $vnum++,
-			 line => $line,
-			 weight => $weight,
-			 cutable => $cutable,
-			 from => $from,
-			 to => $to,};
-	    push @Edges, $edge;
-	    $Edges{$from}{$to} = $edge;
-	}
-	elsif ($header) {
-	    push @Header, $line;
-	    print "IGNORE: $line";
-	}
+        if ($line =~ /^\t([a-zA-Z0-9_]+)\t(.*)$/) {
+            next if $1 eq 'nTITLE';
+            $header = 0;
+            $Vertexes{$1} = {num => $vnum++,
+                             line => $line,
+                             name => $1,};
+        }
+        elsif ($line =~ /^\t([a-zA-Z0-9_]+)\s+->\s+([a-zA-Z0-9_]+)\s+(.*)$/) {
+            my $from=$1; my $to=$2;
+            my $weight = 1; $weight = $1 if $line =~ /weight=(\d+)/;
+            my $cutable = undef; $cutable = $1 if $line =~ /style=(\S+)/;
+            my $edge =  {num => $vnum++,
+                         line => $line,
+                         weight => $weight,
+                         cutable => $cutable,
+                         from => $from,
+                         to => $to,};
+            push @Edges, $edge;
+            $Edges{$from}{$to} = $edge;
+        }
+        elsif ($header) {
+            push @Header, $line;
+            print "IGNORE: $line";
+        }
     }
 }
 
@@ -100,14 +100,14 @@ sub cwrite {
     $fh->print("void V3GraphTestImport::dotImport() {\n");
     $fh->print("    DfaGraph* gp = &m_graph;\n");
     foreach my $ver (sort {$a->{num} <=> $b->{num}} (values %Vertexes)) {
-	$fh->printf("    V3GraphTestVertex* %s = new V3GraphTestVertex(gp, \"%s\");  if (%s) {}\n",
-		    $ver->{name}, $ver->{name}, $ver->{name});
+        $fh->printf("    V3GraphTestVertex* %s = new V3GraphTestVertex(gp, \"%s\");  if (%s) {}\n",
+                    $ver->{name}, $ver->{name}, $ver->{name});
     }
     $fh->print("\n");
     foreach my $edge (@Edges) {
-	$fh->printf("    new V3GraphEdge(gp, %s, %s, %s, %s);\n",
-		    $edge->{from}, $edge->{to},
-		    $edge->{weight}, $edge->{cutable}?"true":"false");
+        $fh->printf("    new V3GraphEdge(gp, %s, %s, %s, %s);\n",
+                    $edge->{from}, $edge->{to},
+                    $edge->{weight}, $edge->{cutable}?"true":"false");
     }
     $fh->print("}\n");
 }
@@ -143,7 +143,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2015 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2005-2019 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.
 

nodist/dot_pruner

@@ -8,7 +8,7 @@ use IO::File;
 use Pod::Usage;
 use Data::Dumper; $Data::Dumper::Indent=1;
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);
 
 #======================================================================
 
@@ -26,16 +26,16 @@ my $opt_filename;
 my $opt_circle;
 autoflush STDOUT 1;
 autoflush STDERR 1;
-if (! GetOptions (
-		  "help"	=> \&usage,
-		  "debug"	=> \&debug,
-		  "<>"		=> \&parameter,
-		  "circle=s"	=> \$opt_circle,
-		  )) {
+if (! GetOptions(
+          "help"        => \&usage,
+          "debug"       => \&debug,
+          "<>"          => \&parameter,
+          "circle=s"    => \$opt_circle,
+    )) {
     usage();
 }
 
-dotread ($opt_filename);
+dotread($opt_filename);
 circle($opt_circle) if $opt_circle;
 simplify();
 dotwrite();
@@ -44,7 +44,7 @@ dotwrite();
 
 sub usage {
     pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
-    exit (1);
+    exit(1);
 }
 
 sub debug {
@@ -54,9 +54,9 @@ sub debug {
 sub parameter {
     my $param = shift;
     if (!$opt_filename) {
-	$opt_filename = $param;
+        $opt_filename = $param;
     } else {
-	die "%Error: Unknown parameter: $param\n";
+        die "%Error: Unknown parameter: $param\n";
     }
 }
 
@@ -68,16 +68,16 @@ sub dotread {
     my $fh = IO::File->new($filename) or die "%Error: $! $filename,";
     my $header = 1;
     while (defined (my $line = $fh->getline)) {
-	if ($line =~ /^\t([a-zA-Z0-9_]+)\t(.*)$/) {
-	    $header = 0;
-	    $Vertexes{$1} = $2;
-	}
-	elsif ($line =~ /^\t([a-zA-Z0-9_]+)\s+->\s+([a-zA-Z0-9_]+)\s+(.*)$/) {
-	    $Edges{$1}{$2} = $3;
-	}
-	elsif ($header) {
-	    push @Header, $line;
-	}
+        if ($line =~ /^\t([a-zA-Z0-9_]+)\t(.*)$/) {
+            $header = 0;
+            $Vertexes{$1} = $2;
+        }
+        elsif ($line =~ /^\t([a-zA-Z0-9_]+)\s+->\s+([a-zA-Z0-9_]+)\s+(.*)$/) {
+            $Edges{$1}{$2} = $3;
+        }
+        elsif ($header) {
+            push @Header, $line;
+        }
     }
 }
 
@@ -85,12 +85,12 @@ sub dotread {
 
 sub simplify {
     foreach my $ver (sort (keys %Vertexes)) {
-	$Vertexes{$ver} = _simplify($Vertexes{$ver});
+        $Vertexes{$ver} = _simplify($Vertexes{$ver});
     }
     foreach my $v1 (sort (keys %Edges)) {
-	foreach my $v2 (sort (keys %{$Edges{$v1}})) {
-	    $Edges{$v1}{$v2} = _simplify($Edges{$v1}{$v2});
-	}
+        foreach my $v2 (sort (keys %{$Edges{$v1}})) {
+            $Edges{$v1}{$v2} = _simplify($Edges{$v1}{$v2});
+        }
     }
 }
 
@@ -103,15 +103,15 @@ sub _simplify {
 
 sub dotwrite {
     foreach my $line (@Header) {
-	print "$line";
+        print "$line";
     }
     foreach my $ver (sort (keys %Vertexes)) {
-	print "\t$ver\t$Vertexes{$ver}\n";
+        print "\t$ver\t$Vertexes{$ver}\n";
     }
     foreach my $v1 (sort (keys %Edges)) {
-	foreach my $v2 (sort (keys %{$Edges{$v1}})) {
-	    print "\t$v1 -> $v2\t$Edges{$v1}{$v2}\n";
-	}
+        foreach my $v2 (sort (keys %{$Edges{$v1}})) {
+            print "\t$v1 -> $v2\t$Edges{$v1}{$v2}\n";
+        }
     }
     print "}\n";
 }
@@ -125,15 +125,15 @@ sub circle {
     _circle_recurse($node, 1);
 
     foreach my $ver (keys %Vertexes) {
-	if (!$User{$ver}) {
-	    delete $Vertexes{$ver};
-	    delete $Edges{$ver};
-	}
+        if (!$User{$ver}) {
+            delete $Vertexes{$ver};
+            delete $Edges{$ver};
+        }
     }
     foreach my $v1 (sort (keys %Edges)) {
-	foreach my $v2 (sort (keys %{$Edges{$v1}})) {
-	    if (!$Vertexes{$v2}) { delete $Edges{$v1}{$v2}; }
-	}
+        foreach my $v2 (sort (keys %{$Edges{$v1}})) {
+            if (!$Vertexes{$v2}) { delete $Edges{$v1}{$v2}; }
+        }
     }
 }
 
@@ -148,7 +148,7 @@ sub _circle_recurse {
     $User2{$node} = 1;
     my $r = 0;
     foreach my $v2 (keys %{$Edges{$node}}) {
-	$r |= _circle_recurse($v2,$level++)||0;
+        $r |= _circle_recurse($v2,$level++)||0;
     }
     $User{$node} = 1 if $r;
     $User2{$node} = 2;
@@ -184,7 +184,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2015 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2005-2019 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.
 

nodist/flexdiff

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 ######################################################################
 #
-# Copyright 2007-2015 by Wilson Snyder.  This package is free software; you
+# Copyright 2007-2019 by Wilson Snyder.  This package 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.
@@ -47,12 +47,12 @@ sub prep {
     my @lines;
 
     while (defined(my $line = $fh->getline)) {
-	# Productions
-	#$line =~ s/[ \t]{[^}]*?}/\t{}/g;
-	$line =~ s/StashPrefix;//g;
-	$line =~ s/VALTEXT;//g;
-	$line =~ s/CALLBACK\([^)]*\);//g;
-	push @lines, $line;
+        # Productions
+        #$line =~ s/[ \t]{[^}]*?}/\t{}/g;
+        $line =~ s/StashPrefix;//g;
+        $line =~ s/VALTEXT;//g;
+        $line =~ s/CALLBACK\([^)]*\);//g;
+        push @lines, $line;
     }
 
     #@lines = sort @lines;

nodist/git_untabify

@@ -0,0 +1,252 @@
+#!/usr/bin/perl -w
+# See copyright, etc in below POD section.
+######################################################################
+
+use Getopt::Long;
+#use Data::Dumper; $Data::Dumper::Indent=1; $Data::Dumper::Sortkeys=1; #Debug
+use IO::File;
+use IO::Dir;
+use Pod::Usage;
+use strict;
+use vars qw($Debug);
+
+our $VERSION = '0.001';
+our $Opt_Widen = 1;
+
+#======================================================================
+# main
+
+autoflush STDOUT 1;
+autoflush STDERR 1;
+Getopt::Long::config("no_auto_abbrev");
+if (! GetOptions (
+          "debug"       => sub { $Debug = 1; },
+          "help"        => sub { print "Version $VERSION\n";
+                                 pod2usage(-verbose=>2, -exitval => 2, output=>\*STDOUT, -noperldoc=>1); },
+          "narrow!"     => sub { $Opt_Widen = 0; },
+          "version"     => sub { print "Version $VERSION\n"; exit(0); },
+          "widen!"      => sub { $Opt_Widen = 1; },  # Default, undocumented
+          "<>"          => sub { die "%Error: Unknown parameter: $_[0]\n"; },
+    )) {
+    die "%Error: Bad usage, try 'git_untabify --help'\n";
+}
+
+read_patch();
+
+#######################################################################
+
+sub read_patch {
+    my $filename = undef;
+    my $lineno = 0;
+    my $hunk = 0;
+    my $editlines = {};
+    while (defined(my $line = <STDIN>)) {
+        chomp $line;
+        if ($line =~ m!^\+\+\+ b/(.*)!) {
+            find_edits($editlines);
+            edit_file($filename, $editlines);
+            $filename = $1;
+            $lineno = 0;
+            $editlines = {};
+            print "FILE $filename\n" if $Debug;
+        }
+        elsif ($line  =~ m!^@@ -?[0-9]+,?[0-9]* \+?([0-9]+)!) {
+            $lineno = $1 - 1;
+            ++$hunk;
+            print "  LINE $1  $line" if $Debug;
+        }
+        elsif ($line  =~ m!^ !) {
+            ++$lineno;
+            $editlines->{$lineno} = {line => $line,
+                                     hunk => $hunk,
+                                     user_edit => 0, };
+        }
+        elsif ($line  =~ m!^\+!) {
+            ++$lineno;
+            print "  $lineno: $line" if $Debug;
+            $editlines->{$lineno} = {line => $line,
+                                     hunk => $hunk,
+                                     user_edit => 1, };
+        }
+    }
+    find_edits($editlines);
+    edit_file($filename, $editlines);
+}
+
+sub find_edits {
+    my $editlines = shift;
+    # Expand edit regions so if have edited line, non-edited line, edited
+    # line, we will tab expand the middle ones.
+    my %hunk_firstlines;
+    foreach my $lineno (sort {$a <=> $b} keys %$editlines) {
+        my $hunk = $editlines->{$lineno}{hunk};
+        $hunk_firstlines{$hunk} ||= $lineno if $editlines->{$lineno}{user_edit};
+    }
+    my %hunk_lastlines;
+    foreach my $lineno (sort {$b <=> $a} keys %$editlines) {
+        my $hunk = $editlines->{$lineno}{hunk};
+        $hunk_lastlines{$hunk} ||= $lineno if $editlines->{$lineno}{user_edit};
+    }
+
+    if ($Opt_Widen) {
+        # Expand to include }'s that finish basic block
+        foreach my $hunk (keys %hunk_lastlines) {
+            while (my $lineno = $hunk_lastlines{$hunk}) {
+                ++$lineno;
+                if (($editlines->{$lineno}{line} || "")
+                    =~ /^[+ ]\s+}[ \t};]*$/) {
+                    $hunk_lastlines{$hunk} = $lineno;
+                } else {
+                    last;
+                }
+            }
+        }
+        # Expand to always untabify at least 3 lines (so that future diff will
+        # have non-tabs within a edit hunk distance
+        foreach my $hunk (keys %hunk_firstlines) {
+            if ($hunk_firstlines{$hunk} == $hunk_lastlines{$hunk}) {
+                --$hunk_firstlines{$hunk};
+                ++$hunk_lastlines{$hunk};
+            }
+            elsif ($hunk_firstlines{$hunk}+1 == $hunk_lastlines{$hunk}) {
+                ++$hunk_lastlines{$hunk};
+            }
+        }
+    }
+
+    foreach my $lineno (sort {$a <=> $b} keys %$editlines) {
+        if (($editlines->{$lineno}{line}||"") =~ /\t/) {
+            my $hunk = $editlines->{$lineno}{hunk};
+            if ($hunk_firstlines{$hunk} <= $lineno && $hunk_lastlines{$hunk} >= $lineno) {
+                $editlines->{$lineno}{editit} = 1;
+            }
+        }
+    }
+}
+
+sub edit_file {
+    my $filename = shift;
+    my $editlines = shift;
+
+    my @editits;
+    foreach my $lineno (sort {$a <=> $b} keys %$editlines) {
+        push @editits, $lineno if $editlines->{$lineno}{editit};
+    }
+
+    return if $#editits < 0;
+    if (ignore($filename)) {
+        print "%Warning: Ignoring $filename\n";
+        return;
+    }
+    print "Edit $filename ",join(",",@editits),"\n";
+
+    my $lineno = 0;
+    my @out;
+    {
+        my $fh = IO::File->new("<$filename") or die "%Error: $! $filename\n";
+        while (defined(my $line = $fh->getline)) {
+            ++$lineno;
+            if ($editlines->{$lineno}{editit}) {
+                print $line;
+                push @out, untabify($line);
+            } else {
+                push @out, $line;
+            }
+        }
+        $fh->close;
+    }
+    {
+        my $fh = IO::File->new(">${filename}.untab") or die "%Error: $! ${filename}.untab,";
+        $fh->print(join('',@out));
+        $fh->close;
+
+        my ($dev,$ino,$mode) = stat($filename);
+        chmod $mode, "${filename}.untab";
+    }
+
+    rename("${filename}.untab", $filename) or die "%Error: $! ${filename}.untab,";
+}
+
+sub ignore {
+    my $filename = shift;
+    return 1 if ($filename =~ /(Makefile|\.mk)/);
+    return 1 if ($filename =~ /\.(y|l|out|vcd)$/);
+    return 1 if ($filename =~ /gtkwave/);
+    #
+    return 0 if ($filename =~ /\.(sv|v|vh|svh|h|vc|cpp|pl)$/);
+    return 0;
+}
+
+sub untabify {
+    my $line = shift;
+    my $out = "";
+    my $col = 0;
+    foreach my $c (split //, $line) {
+        if ($c eq "\t") {
+            my $destcol = int(($col+8)/8)*8;
+            while ($col < $destcol) { ++$col; $out .= " "; }
+        } else {
+            $out .= $c;
+            $col++;
+        }
+    }
+    return $out;
+}
+
+#######################################################################
+__END__
+
+=pod
+
+=head1 NAME
+
+git_untabify - Pipe a git diff report and untabify differences
+
+=head1 SYNOPSIS
+
+  git diff a..b | git_untabify
+
+=head1 DESCRIPTION
+
+Take a patch file, and edit the files in the destination patch list to
+untabify the related patch lines.
+
+=head1 ARGUMENTS
+
+=over 4
+
+=item --help
+
+Displays this message and program version and exits.
+
+=item --narrow
+
+Only edit lines which the user edited.
+
+If not provided, also edit other lines within at least a 3 line area around
+the edit, and between any edits within the same hunk.
+
+=item --version
+
+Displays program version and exits.
+
+=back
+
+=head1 DISTRIBUTION
+
+Copyright 2005-2019 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.
+
+=head1 AUTHORS
+
+Wilson Snyder <[email protected]>
+
+=head1 SEE ALSO
+
+=cut
+
+######################################################################
+### Local Variables:
+### compile-command: "./git_untabify "
+### End:

nodist/install_test

@@ -7,7 +7,7 @@ use Cwd;
 use IO::File;
 use Pod::Usage;
 use strict;
-use vars qw ($Debug);
+use vars qw($Debug);
 
 #======================================================================
 # main
@@ -17,12 +17,12 @@ our $Opt_Jobs = calc_jobs();
 
 autoflush STDOUT 1;
 autoflush STDERR 1;
-Getopt::Long::config ("no_auto_abbrev");
-if (! GetOptions (
-	  "debug"	=> sub { $Debug = 1; },
-	  "<>"		=> sub { die "%Error: Unknown parameter: $_[0]\n"; },
-	  "stage=i"	=> \$Opt_Stage,
-	  "j=i"		=> \$Opt_Jobs,
+Getopt::Long::config("no_auto_abbrev");
+if (! GetOptions(
+          "debug"       => sub { $Debug = 1; },
+          "<>"          => sub { die "%Error: Unknown parameter: $_[0]\n"; },
+          "stage=i"     => \$Opt_Stage,
+          "j=i"         => \$Opt_Jobs,
     )) {
     die "%Error: Bad usage, try 'install_test --help'\n";
 }
@@ -36,7 +36,6 @@ sub test {
     -r "nodist/install_test" or die "%Error: Run from the top of the verilator kit,";
 
     cleanenv();
-    $ENV{VERILATOR_NO_OPT_BUILD} = 1;   # Don't build optimized executables; just slows this down
     run("make distclean") if -r "Makefile";
 
     # Try building from a scratch area
@@ -47,50 +46,55 @@ sub test {
     my $testdirn= $srcdir."/test_regress/obj_dir/install_test_testn";
 
     if ($Opt_Stage <= 0) {
-	run("/bin/rm -rf $blddir");
-	run("/bin/mkdir -p $blddir");
-	run("cd $blddir && $srcdir/configure --prefix $prefix");
-	run("cd $blddir && make -j $Opt_Jobs");
+        run("/bin/rm -rf $blddir");
+        run("/bin/mkdir -p $blddir");
+        run("cd $blddir && $srcdir/configure --prefix $prefix");
+        run("cd $blddir && make -j $Opt_Jobs");
     }
 
     # Install it under the prefix
     if ($Opt_Stage <= 1) {
-	run("/bin/rm -rf $prefix");
-	run("/bin/mkdir -p $prefix");
-	run("cd $blddir && make install");
-	run("test -e $prefix/share/man/man1/verilator.1");
-	run("test -e $prefix/share/verilator/examples/test_c/Makefile");
-	run("test -e $prefix/share/verilator/include/verilated.h");
-	run("test -e $prefix/bin/verilator");
-	run("test -e $prefix/bin/verilator_bin");
-	run("test -e $prefix/bin/verilator_bin_dbg");
-	run("test -e $prefix/bin/verilator_profcfunc");
+        run("/bin/rm -rf $prefix");
+        run("/bin/mkdir -p $prefix");
+        run("cd $blddir && make install");
+        run("test -e $prefix/share/man/man1/verilator.1");
+        run("test -e $prefix/share/verilator/examples/tracing_c/Makefile");
+        run("test -e $prefix/share/verilator/include/verilated.h");
+        run("test -e $prefix/bin/verilator");
+        run("test -e $prefix/bin/verilator_bin");
+        run("test -e $prefix/bin/verilator_bin_dbg");
+        run("test -e $prefix/bin/verilator_gantt");
+        run("test -e $prefix/bin/verilator_profcfunc");
     }
 
     # Run a test using just the path
     if ($Opt_Stage <= 2) {
-	my $dir = $testdirp;
-	run("/bin/rm -rf   $dir");
-	run("/bin/mkdir -p $dir");
-	my $bin1 = $prefix."/bin";
-	my $bin2 = $prefix."/share/bin";
-	write_verilog($dir);
-	run("cd $dir && PATH=$bin1:$bin2:\$PATH verilator --cc foo.v --exe foo.cpp");
-	run("cd $dir/obj_dir && PATH=$bin1:$bin2:\$PATH make -f Vfoo.mk");
-	run("cd $dir && PATH=$bin1:$bin2:\$PATH obj_dir/Vfoo");
+        my $dir = $testdirp;
+        run("/bin/rm -rf   $dir");
+        run("/bin/mkdir -p $dir");
+        my $bin1 = $prefix."/bin";
+        my $bin2 = $prefix."/share/bin";
+        write_verilog($dir);
+        run("cd $dir && PATH=$bin1:$bin2:\$PATH verilator --cc foo.v --exe foo.cpp");
+        run("cd $dir/obj_dir && PATH=$bin1:$bin2:\$PATH make -f Vfoo.mk");
+        run("cd $dir && PATH=$bin1:$bin2:\$PATH obj_dir/Vfoo");
     }
 
     # Run a test using exact path to binary
     if ($Opt_Stage <= 3) {
-	my $dir = $testdirn;
-	run("/bin/rm -rf   $dir");
-	run("/bin/mkdir -p $dir");
-	write_verilog($dir);
-	my $bin1 = $prefix."/bin";
-	my $bin2 = $prefix."/share/bin";
-	run("cd $dir && $bin1/verilator --cc foo.v --exe foo.cpp");
-	run("cd $dir/obj_dir && make -f Vfoo.mk");
-	run("cd $dir/obj_dir && ./Vfoo");
+        my $dir = $testdirn;
+        run("/bin/rm -rf   $dir");
+        run("/bin/mkdir -p $dir");
+        write_verilog($dir);
+        my $bin1 = $prefix."/bin";
+        my $bin2 = $prefix."/share/bin";
+        run("cd $dir && $bin1/verilator --cc foo.v --exe foo.cpp");
+        run("cd $dir/obj_dir && make -f Vfoo.mk");
+        run("cd $dir/obj_dir && ./Vfoo");
+    }
+
+    if ($Opt_Stage <= 9) {
+        print "*-* All Finished *-*\n";
     }
 }
 
@@ -98,27 +102,29 @@ sub write_verilog {
     my $dir = shift;
     IO::File->new(">$dir/foo.v")->print('module t; initial begin $display("HELLO WORLD"); $finish; end endmodule'."\n");
     my $fh = IO::File->new(">$dir/foo.cpp");
-    $fh->print('#include "Vfoo.h"'		,"\n");
-    $fh->print('unsigned int main_time = 0;'	,"\n");
-    $fh->print('double sc_time_stamp () {'	,"\n");
-    $fh->print('    return main_time;'		,"\n");
-    $fh->print('}'				,"\n");
-    $fh->print('int main() {'			,"\n");
-    $fh->print('    Vfoo *top = new Vfoo;'	,"\n");
+    $fh->print('#include "Vfoo.h"'              ,"\n");
+    $fh->print('unsigned int main_time = 0;'    ,"\n");
+    $fh->print('double sc_time_stamp() {'       ,"\n");
+    $fh->print('    return main_time;'          ,"\n");
+    $fh->print('}'                              ,"\n");
+    $fh->print('int main() {'                   ,"\n");
+    $fh->print('    Vfoo *top = new Vfoo;'      ,"\n");
     $fh->print('    while (!Verilated::gotFinish()) {',"\n");
-    $fh->print('	top->eval();'		,"\n");
-    $fh->print('	main_time++;'		,"\n");
-    $fh->print('    }'				,"\n");
-    $fh->print('    top->final();'		,"\n");
-    $fh->print('}'				,"\n");
+    $fh->print('        top->eval();'           ,"\n");
+    $fh->print('        main_time++;'           ,"\n");
+    $fh->print('    }'                          ,"\n");
+    $fh->print('    top->final();'              ,"\n");
+    $fh->print('}'                              ,"\n");
 }
 
 sub cleanenv {
     foreach my $var (keys %ENV) {
-	if ($var eq "VERILATOR_ROOT") {
-	    print "unset $var # Was '$ENV{$var}'\n";
-	    delete $ENV{$var}
-	}
+        if ($var eq "VERILATOR_ROOT"
+            || $var eq "VERILATOR_INCLUDE"
+            || $var eq "VERILATOR_NO_OPT_BUILD") {
+            print "unset $var # Was '$ENV{$var}'\n";
+            delete $ENV{$var}
+        }
     }
 }
 
@@ -126,8 +132,8 @@ sub cleanenv {
 
 sub calc_jobs {
     my $ok = eval "
-	use Unix::Processors;
-	return Unix::Processors->new->max_online;
+        use Unix::Processors;
+        return Unix::Processors->new->max_online;
     ";
     $ok && !$@ or return 1;
     print "driver.pl: Found $ok cores, using -j ",$ok+1,"\n" if $Debug;
@@ -183,7 +189,7 @@ Runs a specific test stage (see the script).
 
 =head1 DISTRIBUTION
 
-Copyright 2009-2015 by Wilson Snyder.  This package is free software; you
+Copyright 2009-2019 by Wilson Snyder.  This package 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.

nodist/invoke_atsim

@@ -28,7 +28,7 @@ invoke_atsim - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2015 by Wilson Snyder.  This package is free software; you
+Copyright 2005-2019 by Wilson Snyder.  This package 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.

nodist/invoke_iccr

@@ -28,7 +28,7 @@ invoke_iccr - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2007-2015 by Wilson Snyder.  This package is free software; you
+Copyright 2007-2019 by Wilson Snyder.  This package 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.

nodist/invoke_ncverilog

@@ -8,7 +8,7 @@ use strict;
 #======================================================================
 # main
 
-eval `modulecmd perl add cds-ius`;
+eval `modulecmd perl add cds-ius/latest`;
 exec('ncverilog',@ARGV);
 
 #######################################################################
@@ -28,7 +28,7 @@ invoke_ncverilog - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2015 by Wilson Snyder.  This package is free software; you
+Copyright 2005-2019 by Wilson Snyder.  This package 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.