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,6 +1,7 @@
 \#*
 .#*
 *~
+*.tidy
 *.old
 *.gz
 *.gz.uu
@@ -23,6 +24,7 @@ dddrun*
 doxygen-doc
 gdbrun*
 gmon.out
+ncverilog.history
 internals.txt
 verilator.txt
 verilator_bin*

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

@@ -2,6 +2,269 @@ Revision history for Verilator
 
 The contributors that suggested a given feature are shown in []. Thanks!
 
+* Verilator 4.016 2016-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,
@@ -2156,7 +2419,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]
 
@@ -3024,7 +3287,7 @@ of input ports exists for tracing.
 
 This uses outline mode in Emacs.  See C-h m [M-x describe-mode].
 
-Copyright 2001-2018 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.

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,38 +9,46 @@
 .*\.log
 \..*\.swp
 .*\.tmp
+.*\.tidy
 .*\.tex
 .*\.key
 .*\.vcd
 .*\.1
 /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-2018 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.
@@ -56,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
@@ -113,25 +114,35 @@ 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/verilator \
 	bin/verilator_coverage \
 	bin/verilator_difftree \
+	bin/verilator_gantt \
 	bin/verilator_includer \
 	bin/verilator_profcfunc \
-	doxygen-mainpage doxygen.config veripool-logo.png \
-	install-sh configure mkinstalldirs *.pod \
+	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* \
@@ -154,10 +165,12 @@ 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 = \
@@ -183,8 +196,8 @@ 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
@@ -210,16 +223,18 @@ smoke-test: all_nomsg
 	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 $< $@
 
@@ -230,8 +245,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
@@ -246,8 +261,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
@@ -262,8 +277,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
@@ -272,12 +287,12 @@ 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 \
@@ -286,33 +301,35 @@ VL_INST_INC_BLDDIR_FILES = \
 # 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 = \
 	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 )
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_bin $(DESTDIR)$(bindir)/verilator_bin )
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_bin_dbg $(DESTDIR)$(bindir)/verilator_bin_dbg )
-	( cd ${srcdir}/bin ; $(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
-	cd $(srcdir) \
-	; for p in $(VL_INST_MAN_FILES) ; do \
+	$(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
@@ -320,15 +337,15 @@ installdata:
 	; for p in $(VL_INST_INC_SRCDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
 	done
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/hello_world_c
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/hello_world_sc
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/tracing_c
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/tracing_sc
+	$(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)/$$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
@@ -341,6 +358,7 @@ uninstall:
 	-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/hello_world_c
@@ -392,7 +410,7 @@ install-cadtools: dist
 	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
@@ -405,8 +423,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
@@ -418,11 +437,16 @@ 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
 
@@ -430,6 +454,17 @@ cppcheck: $(CPPCHECK_DEP)
 %.cppcheck: %.cpp
 	$(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
@@ -471,13 +506,13 @@ endif
 
 maintainer-clean::
 	@echo "This command is intended for maintainers to use;"
-	@echo "rebuilding the deleted files requires makeinfo."
-	rm -f *.info* *.1 $(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::
@@ -490,6 +525,7 @@ clean mostlyclean distclean maintainer-clean::
 	rm -rf examples/*/obj_dir examples/*/logs
 
 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*
@@ -504,7 +540,7 @@ TAGS:	$(TAGFILES)
 .PHONY: doxygen
 
 doxygen:
-	$(DOXYGEN) doxygen.config
+	$(MAKE) -C docs doxygen
 
 ######################################################################
 # Test targets

README.pod

@@ -5,30 +5,15 @@
 
 =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-2018 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 +32,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 +113,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,25 +148,32 @@ 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}
     unsetenv VERILATOR_ROOT
@@ -124,50 +183,49 @@ and add it to path using Modules/modulecmd:
 
 =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.
@@ -180,25 +238,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
-    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.v         => Stub defines for linting
-    include/verilated.mk        => Common makefile
-    src/                        => Translator source 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
+    src/                        => Translator source code
     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,123 +0,0 @@
-// DESCRIPTION: Verilator: List of To Do issues.
-//
-// Copyright 2004-2018 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
-	* 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 (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 - 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. (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
-	* 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-2018 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.
@@ -19,8 +19,8 @@ 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};
+        # Magic to allow author testing of perl packages in local directory
+        require $ENV{DIRPROJECT}."/".$ENV{DIRPROJECT_PERL_BOOT};
     }
 }
 
@@ -31,7 +31,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 +54,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 +90,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 +125,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";
     }
 }
 
@@ -271,7 +273,7 @@ Specifies a module search directory.
 
 The latest version is available from L<http://www.veripool.org/>.
 
-Copyright 2003-2018 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-2018 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-2018 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.
 ######################################################################

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-2018 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,20 +1,30 @@
 # DESCRIPTION: Process this file with autoconf to produce a configure script.
 #
-# Copyright 2003-2018 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.920 2018-02-01])
+AC_INIT([Verilator],[4.016 2019-06-16],
+        [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 use hardcoded paths)
 AC_ARG_ENABLE([defenv],
@@ -65,6 +75,21 @@ AC_ARG_ENABLE([longtests],
 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}
@@ -77,6 +102,8 @@ 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; }])],
@@ -163,29 +190,58 @@ AC_DEFUN([_MY_CXX_CHECK_OPT],
     fi
    ])
 
+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++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++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=std++03)
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++11)
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++14)
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++17)
+_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)
+#_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
@@ -199,7 +255,6 @@ 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,-fno-delete-null-pointer-checks)
 _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)
@@ -231,6 +286,13 @@ _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-variable)
 _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"
@@ -248,6 +310,22 @@ 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])],

docs/.gitignore

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

docs/CONTRIBUTORS

@@ -0,0 +1,13 @@
+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.
+
+Jeremy Bennett
+Alex Chadwick
+John Coiner
+Kanad Kanhere
+Richard Myers
+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,12 +630,8 @@ WARN_LOGFILE           =
 # with spaces.
 
 INPUT                  = doxygen-mainpage \
-		         include \
+                         include \
                          src \
-                         test_c \
-                         test_regress \
-                         test_sc \
-                         test_v
 
 # 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/Makefile

@@ -5,7 +5,7 @@
 # This calls the object directory makefile.  That allows the objects to
 # be placed in the "current directory" which simplifies the Makefile.
 #
-# Copyright 2003-2018 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.

examples/hello_world_sc/Makefile

@@ -5,7 +5,7 @@
 # This calls the object directory makefile.  That allows the objects to
 # be placed in the "current directory" which simplifies the Makefile.
 #
-# Copyright 2003-2018 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.

examples/tracing_c/Makefile

@@ -5,7 +5,7 @@
 # This calls the object directory makefile.  That allows the objects to
 # be placed in the "current directory" which simplifies the Makefile.
 #
-# Copyright 2003-2018 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.

examples/tracing_c/Makefile_obj

@@ -5,7 +5,7 @@
 #
 # This is executed in the object directory, and called by ../Makefile
 #
-# Copyright 2003-2018 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.
@@ -17,6 +17,9 @@ 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
 

examples/tracing_c/sim_main.cpp

@@ -7,8 +7,6 @@
 // Include common routines
 #include <verilated.h>
 
-#include <sys/stat.h>  // mkdir
-
 // Include model header, generated from Verilating "top.v"
 #include "Vtop.h"
 
@@ -20,8 +18,8 @@
 // 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
+double sc_time_stamp() {
+    return main_time;  // Note does conversion to real, to match SystemC
 }
 
 int main(int argc, char** argv, char** env) {
@@ -29,17 +27,21 @@ int main(int argc, char** argv, char** env) {
 
     // Prevent unused variable warnings
     if (0 && argc && argv && env) {}
-    // Pass arguments so Verilated code can see them, e.g. $value$plusargs
-    Verilated::commandArgs(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);
+
     // 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
+    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,
@@ -51,7 +53,7 @@ int main(int argc, char** argv, char** env) {
         VL_PRINTF("Enabling waves into logs/vlt_dump.vcd...\n");
         tfp = new VerilatedVcdC;
         top->trace(tfp, 99);  // Trace 99 levels of hierarchy
-        mkdir("logs", 0777);
+        Verilated::mkdir("logs");
         tfp->open("logs/vlt_dump.vcd");  // Open the dump file
     }
 #endif
@@ -92,14 +94,14 @@ int main(int argc, char** argv, char** env) {
 
 #if VM_TRACE
         // Dump trace data for this cycle
-        if (tfp) tfp->dump (main_time);
+        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]);
+        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
@@ -112,7 +114,7 @@ int main(int argc, char** argv, char** env) {
 
     //  Coverage analysis (since test passed)
 #if VM_COVERAGE
-    mkdir("logs", 0777);
+    Verilated::mkdir("logs");
     VerilatedCov::write("logs/coverage.dat");
 #endif
 

examples/tracing_sc/Makefile

@@ -5,7 +5,7 @@
 # This calls the object directory makefile.  That allows the objects to
 # be placed in the "current directory" which simplifies the Makefile.
 #
-# Copyright 2003-2018 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.

examples/tracing_sc/Makefile_obj

@@ -5,7 +5,7 @@
 #
 # This is executed in the object directory, and called by ../Makefile
 #
-# Copyright 2003-2018 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.
@@ -17,6 +17,9 @@ 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
 

examples/tracing_sc/sc_main.cpp

@@ -24,15 +24,19 @@ int sc_main(int argc, char* argv[]) {
 
     // Prevent unused variable warnings
     if (0 && argc && argv) {}
-    // Pass arguments so Verilated code can see them, e.g. $value$plusargs
-    Verilated::commandArgs(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();
 
@@ -95,8 +99,8 @@ int sc_main(int argc, char* argv[]) {
     if (flag && 0==strcmp(flag, "+trace")) {
         cout << "Enabling waves into logs/vlt_dump.vcd...\n";
         tfp = new VerilatedVcdSc;
-        top->trace(tfp, 99);
-        mkdir("logs", 0777);
+        top->trace(tfp, 99);  // Trace 99 levels of hierarchy
+        Verilated::mkdir("logs");
         tfp->open("logs/vlt_dump.vcd");
     }
 #endif
@@ -111,9 +115,9 @@ int sc_main(int argc, char* argv[]) {
 
         // Apply inputs
         if (VL_TIME_Q() > 1 && VL_TIME_Q() < 10) {
-            reset_l = !1;       // Assert reset
+            reset_l = !1;  // Assert reset
         } else if (VL_TIME_Q() > 1) {
-            reset_l = !0;       // Deassert reset
+            reset_l = !0;  // Deassert reset
         }
 
         // Simulate 1ns
@@ -134,7 +138,7 @@ int sc_main(int argc, char* argv[]) {
 
     //  Coverage analysis (since test passed)
 #if VM_COVERAGE
-    mkdir("logs", 0777);
+    Verilated::mkdir("logs");
     VerilatedCov::write("logs/coverage.dat");
 #endif
 

examples/tracing_sc/sub.v

@@ -49,7 +49,7 @@ module sub
 
    // An example assertion
    always_ff @ (posedge clk) begin
-      AssertionExample: assert (!reset_l || count_c<100);
+      AssertionExample: assert(!reset_l || count_c<100);
    end
 
    // And example coverage analysis

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-2018 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.
 ######################################################################
@@ -24,6 +24,8 @@ CFG_CXXFLAGS_STD_OLDEST = @CFG_CXXFLAGS_STD_OLDEST@
 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
@@ -114,8 +116,23 @@ endif
 
 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 += -DVL_THREADED $(CFG_CXXFLAGS_STD_NEWEST)
+  CPPFLAGS += $(CFG_CXXFLAGS_STD_NEWEST)
+  LDLIBS += $(CFG_LDLIBS_THREADS)
  endif
 endif
 
@@ -164,17 +181,19 @@ $(VM_PREFIX)__ALL.a: $(VK_OBJS)
 ### Compile rules
 
 ifneq ($(VM_DEFAULT_RULES),0)
-$(VM_PREFIX)__ALLsup.o: $(VM_PREFIX)__ALLsup.cpp
-	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_SLOW) -c -o $@ $<
-
 $(VM_PREFIX)__ALLcls.o: $(VM_PREFIX)__ALLcls.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<
 
-$(VM_PREFIX)%__Slow.o: $(VM_PREFIX)%__Slow.cpp
+$(VM_PREFIX)__ALLsup.o: $(VM_PREFIX)__ALLsup.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_SLOW) -c -o $@ $<
 
-$(VM_PREFIX)%.o: $(VM_PREFIX)%.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:
@@ -186,14 +205,19 @@ endif
 
 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-2018 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-2018 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-2018 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,7 +69,7 @@ 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
@@ -77,7 +77,7 @@ public:
     virtual void zero() const { *m_countp = 0; }
     // CONSTRUCTORS
     // cppcheck-suppress noExplicitConstructor
-    VerilatedCoverItemSpec(T* countp) : m_countp(countp) { zero(); }
+    VerilatedCoverItemSpec(T* countp) : m_countp(countp) { *m_countp = 0; }
     virtual ~VerilatedCoverItemSpec() {}
 };
 
@@ -96,7 +96,7 @@ private:
 
 private:
     // MEMBERS
-    VerilatedMutex	m_mutex;  ///< Protects all members, when VL_THREADED. Wrapper deals with setting it.
+    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
@@ -107,294 +107,296 @@ private:
 
     // 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() { clearGuts(); }
     static VerilatedCovImp& imp() VL_MT_SAFE {
-	static VerilatedCovImp s_singleton;
-	return s_singleton;
+        static VerilatedCovImp s_singleton;
+        return s_singleton;
     }
 
 private:
     // PRIVATE METHODS
     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;
+        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;
     }
     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;
+        // 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;
     }
     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;
+        // 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 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;
+        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;
     }
     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 == "") return add;
-	if (add == "") return old;
+        // (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
-	std::string prefix = std::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
-	std::string suffix = *bpost ? std::string(bpost+1) : "";
+        // Forward to . so we have a whole word
+        std::string suffix = *bpost ? std::string(bpost+1) : "";
 
-	std::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 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;
+        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;
     }
     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");
+        // 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();
+        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() VL_EXCLUDES(m_mutex) {
-	Verilated::quiesce();
-	VerilatedLockGuard guard(m_mutex);
-	clearGuts();
+        Verilated::quiesce();
+        VerilatedLockGuard lock(m_mutex);
+        clearGuts();
     }
     void clearNonMatch(const char* matchp) VL_EXCLUDES(m_mutex) {
-	Verilated::quiesce();
-	VerilatedLockGuard guard(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;
-	}
+        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() VL_EXCLUDES(m_mutex) {
-	Verilated::quiesce();
-	VerilatedLockGuard guard(m_mutex);
-	for (ItemList::const_iterator it=m_items.begin(); it!=m_items.end(); ++it) {
-	    (*it)->zero();
-	}
+        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) VL_EXCLUDES(m_mutex) {
-	VerilatedLockGuard guard(m_mutex);
-	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) VL_EXCLUDES(m_mutex) {
-	VerilatedLockGuard guard(m_mutex);
-	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]) VL_EXCLUDES(m_mutex) {
-	VerilatedLockGuard guard(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();
+    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
-	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]!="") {
-		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]!="") {
-		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;
+        // 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) VL_EXCLUDES(m_mutex) {
-	Verilated::quiesce();
-	VerilatedLockGuard guard(m_mutex);
+        Verilated::quiesce();
+        VerilatedLockGuard lock(m_mutex);
 #ifndef VM_COVERAGE
-	VL_FATAL_MT("",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();
 
-	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";
+        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 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;
+        // 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) {
-		    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 = "";
-	    }
+            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 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())));
-	    }
-	}
+            // 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::const_iterator it=eventCounts.begin(); it!=eventCounts.end(); ++it) {
-	    os<<"C '"<<std::dec;
-	    os<<it->first;
-	    if (it->second.first != "") os<<keyValueFormatter(VL_CIK_HIER,it->second.first);
-	    os<<"' "<<it->second.second;
-	    os<<std::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;
+        }
     }
 };
 
@@ -420,51 +422,51 @@ 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) VL_MT_SAFE {
-    VerilatedCovImp::imp().insertf(filename,lineno);
+    VerilatedCovImp::imp().insertf(filename, lineno);
 }
 
 #define K(n) const char* key ## n
-#define A(n) const char* key ## n, const char* val ## n		// Argument list
-#define C(n) key ## n, val ## n	// Calling argument list
-#define N(n) "",""	// Null argument list
-void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
-			     A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19),
-			     A(20),A(21),A(22),A(23),A(24),A(25),A(26),A(27),A(28),A(29)) VL_MT_SAFE {
+#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)) VL_MT_SAFE {
+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)) VL_MT_SAFE {
+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 std::string& val4,  A(5),A(6)) VL_MT_SAFE {
+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,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));
+             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-2018 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.
 //
@@ -44,36 +44,36 @@
 /// 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) VL_PURE {
+template< class T> std::string vlCovCvtToStr(const T& t) VL_PURE {
     std::ostringstream os; os<<t; return os.str();
 }
 
@@ -91,32 +91,32 @@ public:
     /// Return default filename
     static const char* defaultFilename() VL_PURE { return "coverage.dat"; }
     /// Write all coverage data to a file
-    static void write (const char* filenamep = defaultFilename()) VL_MT_SAFE;
+    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) VL_MT_SAFE;
-    static void _inserti (vluint64_t* itemp) VL_MT_SAFE;
+    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) VL_MT_SAFE;
+    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 std::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
@@ -124,9 +124,9 @@ public:
     /// Clear coverage points (and call delete on all items)
     static void clear() VL_MT_SAFE;
     /// Clear items not matching the provided string
-    static void clearNonMatch (const char* matchp) VL_MT_SAFE;
+    static void clearNonMatch(const char* matchp) VL_MT_SAFE;
     /// Zero coverage points
     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-2018 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.
 //
@@ -104,40 +104,40 @@ VLCOVGEN_ITEM("name=>'weight',      short=>'w',  group=>0, default=>undef, descr
 class VerilatedCovKey {
 public:
     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;
+        // 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-2018 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.
@@ -24,6 +24,7 @@
 //=========================================================================
 
 #define _VERILATED_DPI_CPP_
+
 #include "verilatedos.h"
 #include "verilated_dpi.h"
 #include "verilated_imp.h"
@@ -146,7 +147,7 @@ void svPutPartselBit(svBitVecVal* dp, const svBitVecVal s, int lbit, int width)
     else {
         int hword = VL_BITWORD_I(hbit);
         int lword = VL_BITWORD_I(lbit);
-        if (hword==lword) {     // know < 32 bits because above checks it
+        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 {
@@ -171,7 +172,7 @@ void svPutPartselLogic(svLogicVecVal* dp, const svLogicVecVal s, int lbit, int w
     else {
         int hword = VL_BITWORD_I(hbit);
         int lword = VL_BITWORD_I(lbit);
-        if (hword==lword) {     // know < 32 bits because above checks it
+        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);
@@ -192,11 +193,13 @@ void svPutPartselLogic(svLogicVecVal* dp, const svLogicVecVal s, int lbit, int w
 
 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");
+        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");
+        VL_FATAL_MT(__FILE__, __LINE__, "",
+                    "%%Error: DPI svOpenArrayHandle function called with non-Verilator handle");
     }
     return varp;
 }
@@ -246,7 +249,8 @@ 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",
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function called on"
+                       " %d dimensional array using %d dimensional function.\n",
                        varp->udims(), nargs);
         return NULL;
     }
@@ -316,7 +320,8 @@ static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
         return;
     }
     default:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype());
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+                       varp->vltype());
         return;
     }
 }
@@ -344,7 +349,8 @@ static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandl
         return;
     }
     default:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype());
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+                       varp->vltype());
         return;
     }
 }
@@ -366,7 +372,8 @@ static void _vl_svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecV
         return;
     }
     default:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype());
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+                       varp->vltype());
         return;
     }
 }
@@ -470,7 +477,7 @@ void* svGetArrElemPtr(const svOpenArrayHandle h, int indx1, ...) {
             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
+    default: datap = _vl_svGetArrElemPtr(h, -1, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
     return datap;
@@ -496,7 +503,7 @@ void svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s,
             _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
+    default: _vl_svPutBitArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
 }
@@ -523,7 +530,7 @@ void svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
             _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
+    default: _vl_svPutLogicArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
 }
@@ -554,7 +561,7 @@ void svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
             _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
+    default: _vl_svGetBitArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
 }
@@ -581,7 +588,7 @@ void svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s,
             _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
+    default: _vl_svGetLogicArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
 }
@@ -611,7 +618,7 @@ svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...) {
             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
+    default: out = _vl_svGetBitArrElem(s, -1, 0, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
     return out;
@@ -639,7 +646,7 @@ svLogic svGetLogicArrElem(const svOpenArrayHandle s, int indx1, ...) {
             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
+    default: out = _vl_svGetBitArrElem(s, -1, 0, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
     return out;
@@ -669,7 +676,7 @@ void svPutBitArrElem(const svOpenArrayHandle d, svBit value, int indx1, ...) {
             _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
+    default: _vl_svPutBitArrElem(d, value, -1, 0, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
 }
@@ -695,7 +702,7 @@ void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1, ...)
             _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
+    default: _vl_svPutBitArrElem(d, value, -1, 0, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
 }
@@ -703,11 +710,13 @@ 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) {
+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) {
+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);
 }
@@ -717,14 +726,16 @@ void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1, int
 
 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 = reinterpret_cast<const VerilatedScope*>(scope);
     Verilated::dpiScope(vscopep);
-    return (svScope)prevScopep;
+    // NOLINTNEXTLINE(google-readability-casting)
+    return (svScope)(prevScopep);
 }
 
 const char* svGetNameFromScope(const svScope scope) {
@@ -733,7 +744,8 @@ const char* svGetNameFromScope(const svScope scope) {
 }
 
 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) {
@@ -756,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-2018 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.
@@ -26,10 +26,12 @@
 
 
 #ifndef _VERILATED_DPI_H_
-#define _VERILATED_DPI_H_ 1 ///< Header Guard
+#define _VERILATED_DPI_H_ 1  ///< Header Guard
 
-#include "verilated.h"   // Also presumably included by caller
+#include "verilatedos.h"
+#include "verilated.h"  // Also presumably included by caller
 #include "verilated_sym_props.h"
+
 #include "svdpi.h"
 
 //===================================================================
@@ -78,4 +80,4 @@ static inline void VL_SET_SVLV_Q(int, svLogicVecVal* owp, QData ld) VL_MT_SAFE {
 
 //======================================================================
 
-#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-2018 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.
@@ -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"
 
@@ -56,19 +56,26 @@ inline std::string VL_REPLICATEN_NNQ(int,int,int, const std::string& lhs, IData
     for (unsigned times=0; times<rep; ++times) out += lhs;
     return out;
 }
-inline std::string VL_REPLICATEN_NNI(int obits,int lbits,int rbits, const std::string& lhs, IData rep) VL_PURE {
+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);
 }
 
 inline IData VL_LEN_IN(const std::string& ld) { return ld.length(); }
 
 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, int fnwords,
-                         const std::string& ofilename, 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 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 rdp) 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);
@@ -83,4 +90,4 @@ inline IData VL_VALUEPLUSARGS_INQ(int rbits, const std::string& ld, QData& rdr)
 }
 extern IData VL_VALUEPLUSARGS_INN(int, const std::string& ld, std::string& rdr) VL_MT_SAFE;
 
-#endif // Guard
+#endif  // Guard

include/verilated_imp.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2018 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,11 +33,9 @@
 #include "verilated_heavy.h"
 #include "verilated_syms.h"
 
-#include <map>
+#include <deque>
 #include <set>
 #include <vector>
-#include <deque>
-#include <string>
 #ifdef VL_THREADED
 # include <functional>
 # include <queue>
@@ -49,25 +47,25 @@ class VerilatedScope;
 // Threaded message passing
 
 #ifdef VL_THREADED
-/// Message, enqueued on a train, and consumed on the main eval thread
+/// 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) {
-	    return a.trainId() < b.trainId(); }
+        bool operator() (const VerilatedMsg& a, const VerilatedMsg& b) const {
+            return a.mtaskId() < b.mtaskId(); }
     };
 private:
     // MEMBERS
-    vluint32_t 		m_trainId;  	///< Train that did enqueue
-    std::function<void()> m_cb; 	///< Lambda to execute when message received
+    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_trainId(Verilated::trainId()), m_cb(cb) {}
+        : m_mtaskId(Verilated::mtaskId()), m_cb(cb) {}
     ~VerilatedMsg() {}
     // METHODS
-    vluint32_t trainId() const { return m_trainId; }
+    vluint32_t mtaskId() const { return m_mtaskId; }
     /// Execute the lambda function
     void run() const { m_cb(); }
 };
@@ -84,7 +82,9 @@ class VerilatedEvalMsgQueue  {
     VerilatedThreadQueue m_queue VL_GUARDED_BY(m_mutex);  ///< Message queue
 public:
     // CONSTRUCTORS
-    VerilatedEvalMsgQueue() : m_depth(0) { }
+    VerilatedEvalMsgQueue() : m_depth(0) {
+        assert(atomic_is_lock_free(&m_depth));
+    }
     ~VerilatedEvalMsgQueue() { }
 private:
     VL_UNCOPYABLE(VerilatedEvalMsgQueue);
@@ -92,34 +92,32 @@ public:
     // METHODS
     //// Add message to queue (called by producer)
     void post(const VerilatedMsg& msg) VL_EXCLUDES(m_mutex) {
-	Verilated::endOfEvalReqdInc(); // No mutex, threadsafe
-	VerilatedLockGuard guard(m_mutex);
-	m_queue.insert(msg);  // Pass by value to copy the message into queue
-	++m_depth;
+        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
-	    Verilated::endOfEvalReqdDec(); // No mutex, threadsafe
-	    {
-		VL_DEBUG_IF(VL_DBG_MSGF("Executing callback from trainId=%d\n", msg.trainId()););
-		msg.run();
-	    }
-	}
+        // 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();
+            }
+        }
     }
 };
 
@@ -130,32 +128,39 @@ 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.
+        // 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;
+        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 {
-	Verilated::endOfEvalReqdInc();
-	threadton().m_queue.push(msg);  // Pass by value to copy the message into queue
+        // 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();
-	}
+        while (!threadton().m_queue.empty()) {
+            evalMsgQp->post(threadton().m_queue.front());
+            threadton().m_queue.pop();
+            Verilated::endOfEvalReqdDec();
+        }
     }
 };
-#endif // VL_THREADED
+#endif  // VL_THREADED
 
 //======================================================================
 // VerilatedImp
@@ -169,7 +174,7 @@ class VerilatedImp {
     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
 
@@ -192,72 +197,49 @@ class VerilatedImp {
     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)
 
-    // Threads
-    VerilatedMutex      m_threadMutex;  ///< Protect m_numThreads, etc
-    bool                m_spawned VL_GUARDED_BY(m_threadMutex);  ///< Already called spawnThreads()
-    unsigned            m_numThreads VL_GUARDED_BY(m_threadMutex);  ///< Number of threads user requested, 0x0=all cpus
-
-public: // But only for verilated*.cpp
+public:  // But only for verilated*.cpp
     // CONSTRUCTORS
     VerilatedImp()
-	: m_argVecLoaded(false), m_exportNext(0), m_spawned(false), m_numThreads(0) {
-	m_fdps.resize(3);
-	m_fdps[0] = stdin;
-	m_fdps[1] = stdout;
-	m_fdps[2] = stderr;
+        : m_argVecLoaded(false), m_exportNext(0) {
+        m_fdps.resize(3);
+        m_fdps[0] = stdin;
+        m_fdps[1] = stdout;
+        m_fdps[2] = stderr;
     }
     ~VerilatedImp() {}
 private:
     VL_UNCOPYABLE(VerilatedImp);
 public:
-    static void internalsDump() VL_MT_SAFE {
-	VerilatedLockGuard guard(s_s.m_argMutex);
-	VL_PRINTF_MT("internalsDump:\n");
-	VL_PRINTF_MT("  Argv:");
-	for (ArgVec::const_iterator it=s_s.m_argVec.begin(); it!=s_s.m_argVec.end(); ++it) {
-	    VL_PRINTF_MT(" %s",it->c_str());
-	}
-	VL_PRINTF_MT("\n");
-	VL_PRINTF_MT("  Version: %s %s\n", Verilated::productName(), Verilated::productVersion());
-	scopesDump();
-	exportsDump();
-	userDump();
-    }
+    // METHODS - debug
+    static void internalsDump() VL_MT_SAFE;
+    static void versionDump() VL_MT_SAFE;
 
     // METHODS - arguments
 public:
-    static void commandArgs(int argc, const char** argv) VL_EXCLUDES(s_s.m_argMutex) {
-	VerilatedLockGuard guard(s_s.m_argMutex);
-	s_s.m_argVec.clear();  // Always clear
-	commandArgsAddGuts(argc, argv);
-    }
-    static void commandArgsAdd(int argc, const char** argv) VL_EXCLUDES(s_s.m_argMutex) {
-	VerilatedLockGuard guard(s_s.m_argMutex);
-	commandArgsAddGuts(argc, argv);
-    }
+    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 guard(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 "";
+        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) {
-	if (!s_s.m_argVecLoaded) 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 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
@@ -265,79 +247,81 @@ public:
     // 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) VL_MT_SAFE {
-	VerilatedLockGuard guard(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));
+        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) VL_MT_SAFE {
-	VerilatedLockGuard guard(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;
+        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) VL_MT_SAFE {
-	// Slow ok - called once/scope on destruction, so we simply iterate.
-	VerilatedLockGuard guard(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;
-	    }
-	}
+        // 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() VL_MT_SAFE {
-	VerilatedLockGuard guard(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);
-	}
+        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) VL_MT_SAFE {
-	// Slow ok - called once/scope at construction
-	VerilatedLockGuard guard(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));
-	}
+        // 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) VL_MT_SAFE {
-	VerilatedLockGuard guard(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;
+        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) VL_MT_SAFE {
-	// Slow ok - called once/scope at destruction
-	VerilatedLockGuard guard(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);
+        // 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_MT_SAFE {
-	VerilatedLockGuard guard(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");
+        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
+        // 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
@@ -347,104 +331,75 @@ public: // But only for verilated*.cpp
     // 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) VL_MT_SAFE {
-	// Slow ok - called once/function at creation
-	VerilatedLockGuard guard(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;
-	}
+        // 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) VL_MT_SAFE {
-	VerilatedLockGuard guard(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;
+        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) VL_MT_SAFE {
-	// Slowpath; find name for given export; errors only so no map to reverse-map it
-	VerilatedLockGuard guard(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*";
+        // 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() VL_MT_SAFE {
-	VerilatedLockGuard guard(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);
-	}
+        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) VL_MT_SAFE {
-	if (VL_UNLIKELY(!fp)) return 0;
-	// Bit 31 indicates it's a descriptor not a MCD
-	VerilatedLockGuard guard(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
+        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) VL_MT_SAFE {
-	IData idx = VL_MASK_I(31) & fdi;
-	VerilatedLockGuard guard(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);
+        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) VL_MT_SAFE {
-	IData idx = VL_MASK_I(31) & fdi;
-	VerilatedLockGuard guard(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];
-    }
-
-public: // But only for verilated*.cpp
-    // METHODS - Threading
-    static void numThreads(unsigned threads) VL_MT_SAFE {
-	VerilatedLockGuard guard(s_s.m_threadMutex);
-	if (!s_s.m_spawned) s_s.m_numThreads = threads;
-    }
-    static unsigned numThreads() VL_MT_SAFE {
-	VerilatedLockGuard guard(s_s.m_threadMutex);
-#ifdef VL_THREADED
-	unsigned threads = s_s.m_numThreads;
-	if (threads == 0x0) {
-	    threads = std::thread::hardware_concurrency(); // Or 0=unknown, C++11
-	}
-	if (threads<1) threads = 1;
-	return threads;
-#else
-	return 0;
-#endif
-    }
-    static void spawnThreads() VL_MT_SAFE {
-	VerilatedLockGuard guard(s_s.m_threadMutex);
-	if (!s_s.m_spawned) {
-	    // Convert numThreads from 0 to the spawned number
-	    numThreads(numThreads());
-	    s_s.m_spawned = true;
-#ifdef VL_THREADED
-	    // THREADED-TODO startup threads
-#endif
-	}
+        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];
     }
 };
 

include/verilated_save.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2018 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,38 +32,42 @@
 # 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* 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
+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) VL_MT_UNSAFE_ONE {
+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) VL_MT_UNSAFE_ONE {
-    if (VL_UNLIKELY(readDiffers(datap,size))) {
-	std::string fn = filename();
-	std::string msg = std::string("Can't deserialize save-restore file as was made from different model");
-	VL_FATAL_MT(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";
+        VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
+        close();
     }
     return *this;  // For function chaining
 }
@@ -81,10 +85,10 @@ void VerilatedSerialize::header() VL_MT_UNSAFE_ONE {
 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)))) {
-	std::string fn = filename();
-	std::string msg = std::string("Can't deserialize; file has wrong header signature");
-	VL_FATAL_MT(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");
+        VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
+        close();
     }
     os.read(Verilated::serializedPtr(), Verilated::serializedSize());
 }
@@ -98,10 +102,10 @@ void VerilatedSerialize::trailer() VL_MT_UNSAFE_ONE {
 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)))) {
-	std::string fn = filename();
-	std::string msg = std::string("Can't deserialize; file has wrong end-of-file signature");
-	VL_FATAL_MT(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");
+        VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
+        close();
     }
 }
 
@@ -113,19 +117,19 @@ void VerilatedDeserialize::trailer() VL_MT_UNSAFE_ONE {
 void VerilatedSave::open(const char* filenamep) VL_MT_UNSAFE_ONE {
     m_assertOne.check();
     if (isOpen()) return;
-    VL_DEBUG_IF(VL_DBG_MSGF("- save: 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;
@@ -136,19 +140,19 @@ void VerilatedSave::open(const char* filenamep) VL_MT_UNSAFE_ONE {
 void VerilatedRestore::open(const char* filenamep) VL_MT_UNSAFE_ONE {
     m_assertOne.check();
     if (isOpen()) return;
-    VL_DEBUG_IF(VL_DBG_MSGF("- restore: 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;
@@ -181,23 +185,23 @@ void VerilatedSave::flush() VL_MT_UNSAFE_ONE {
     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)
-		std::string msg = std::string(__FUNCTION__)+": "+strerror(errno);
-		VL_FATAL_MT("",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() VL_MT_UNSAFE_ONE {
@@ -207,32 +211,31 @@ void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
     vluint8_t* rp = m_bufp;
     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
+    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)
-		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;
-	}
+        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-2018 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.
 //
@@ -34,10 +34,10 @@ 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
-    std::string		m_filename;	///< Filename, for error messages
+    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
@@ -50,13 +50,13 @@ protected:
     VL_UNCOPYABLE(VerilatedSerialize);
 public:
     VerilatedSerialize() {
-	m_isOpen = false;
-	m_bufp = new vluint8_t [bufferSize()];
-	m_cp = m_bufp;
+        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; }
+        close();
+        if (m_bufp) { delete m_bufp; m_bufp=NULL; }
     }
     // METHODS
     bool isOpen() const { return m_isOpen; }
@@ -64,24 +64,24 @@ public:
     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
+        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
+        // 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
     }
 };
 
@@ -93,12 +93,12 @@ class VerilatedDeserialize {
 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
-    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
+    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; }
@@ -111,14 +111,14 @@ protected:
     VL_UNCOPYABLE(VerilatedDeserialize);
 public:
     VerilatedDeserialize() {
-	m_isOpen = false;
-	m_bufp = new vluint8_t [bufferSize()];
-	m_cp = m_bufp;
-	m_endp = NULL;
+        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; }
+        close();
+        if (m_bufp) { delete m_bufp; m_bufp=NULL; }
     }
     // METHODS
     bool isOpen() const { return m_isOpen; }
@@ -126,28 +126,29 @@ public:
     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
+        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
     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)); }
+    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
+        // 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
     }
 };
 
@@ -157,7 +158,7 @@ private:
 
 class VerilatedSave : public VerilatedSerialize {
 private:
-    int			m_fd;		///< File descriptor we're writing to
+    int                 m_fd;           ///< File descriptor we're writing to
 
 public:
     // CONSTRUCTORS
@@ -176,7 +177,7 @@ public:
 
 class VerilatedRestore : public VerilatedDeserialize {
 private:
-    int			m_fd;		///< File descriptor we're writing to
+    int                 m_fd;           ///< File descriptor we're writing to
 
 public:
     // CONSTRUCTORS
@@ -236,15 +237,15 @@ inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, float& rhs) {
     return os.read(&rhs, sizeof(rhs));
 }
 inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   std::string& rhs) {
-    vluint32_t len=rhs.length();
+    vluint32_t len = rhs.length();
     os<<len;
     return os.write(rhs.data(), len);
 }
 inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, std::string& rhs) {
-    vluint32_t len=0;
+    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-2018 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.
@@ -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"
 
 //=============================================================================
@@ -49,4 +50,4 @@ public:
 
 //=========================================================================
 
-#endif // guard
+#endif  // Guard

include/verilated_sym_props.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2018 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.
@@ -30,7 +30,9 @@
 
 
 #ifndef _VERILATED_SYM_PROPS_H_
-#define _VERILATED_SYM_PROPS_H_ 1 ///< Header Guard
+#define _VERILATED_SYM_PROPS_H_ 1  ///< Header Guard
+
+#include "verilatedos.h"
 
 //===========================================================================
 /// Verilator range
@@ -52,7 +54,8 @@ public:
     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 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; }
 };
 
@@ -81,45 +84,54 @@ 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) { }
+        : 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_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_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_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) { }
+        : 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_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_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_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); }
+    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
@@ -130,22 +142,28 @@ public:
     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;
+        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;
+        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;
+        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;
+        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;
+        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;
+        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;
@@ -211,4 +229,4 @@ public:
     const char* name() const { return m_namep; }
 };
 
-#endif // Guard
+#endif  // Guard

include/verilated_syms.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2018 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,11 +29,12 @@
 
 
 #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 "verilated_heavy.h"
 #include <map>
 
 //======================================================================
@@ -62,4 +63,4 @@ public:
     ~VerilatedVarNameMap() {}
 };
 
-#endif // Guard
+#endif  // Guard

include/verilated_threads.cpp

@@ -0,0 +1,233 @@
+// -*- 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;
+            }
+        }
+    }
+    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-2018 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,12 +38,15 @@
 
 // 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
 
 //=============================================================================
 // VerilatedVcdImp
@@ -58,25 +60,28 @@ private:
         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; }
+    static Singleton& singleton() { static Singleton s; return s; }
 public:
     static void pushVcd(VerilatedVcd* vcdp) VL_EXCLUDES(singleton().s_vcdMutex) {
-	VerilatedLockGuard guard(singleton().s_vcdMutex);
-	singleton().s_vcdVecp.push_back(vcdp);
+        VerilatedLockGuard lock(singleton().s_vcdMutex);
+        singleton().s_vcdVecp.push_back(vcdp);
     }
     static void removeVcd(const VerilatedVcd* vcdp) VL_EXCLUDES(singleton().s_vcdMutex) {
-	VerilatedLockGuard guard(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); }
+        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 guard(singleton().s_vcdMutex);
-	for (VcdVec::const_iterator it=singleton().s_vcdVecp.begin(); it!=singleton().s_vcdVecp.end(); ++it) {
-	    VerilatedVcd* vcdp = *it;
-	    vcdp->flush();
-	}
+        // 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();
+        }
     }
 };
 
@@ -91,16 +96,16 @@ public:
 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
+    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(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() {}
 };
 
@@ -110,7 +115,7 @@ protected:
 // VerilatedVcdFile
 
 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, 0666);
+    m_fd = ::open(name.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK|O_CLOEXEC, 0666);
     return (m_fd>=0);
 }
 
@@ -146,7 +151,7 @@ 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;
 
@@ -159,64 +164,64 @@ void VerilatedVcd::open (const char* filename) {
     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.
     m_assertOne.check();
-    closePrev(); // Close existing
+    closePrev();  // Close existing
     if (incFilename) {
-	// 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;
+        // 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;
 }
 
@@ -226,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 = m_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
@@ -237,21 +242,21 @@ void VerilatedVcd::makeNameMap() {
     // This comes from user instantiations with no name - IE Vtop("").
     bool nullScope = false;
     for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
-	const std::string& hiername = it->first;
-	if (hiername.size() >= 1 && hiername[0] == '\t') nullScope=true;
+        const std::string& hiername = it->first;
+        if (!hiername.empty() && hiername[0] == '\t') nullScope=true;
     }
     if (nullScope) {
-	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;
+        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;
     }
 }
 
@@ -266,13 +271,13 @@ VerilatedVcd::~VerilatedVcd() {
     deleteNameMap();
     if (m_filep && m_fileNewed) { delete m_filep; m_filep = NULL; }
     for (CallbackVec::const_iterator it=m_callbacks.begin(); it!=m_callbacks.end(); ++it) {
-	delete (*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;
 
@@ -281,7 +286,7 @@ 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.
@@ -297,37 +302,37 @@ void VerilatedVcd::close() {
     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 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");
-	}
+        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);
@@ -337,17 +342,17 @@ 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 () VL_MT_UNSAFE_ONE {
+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()
@@ -356,22 +361,22 @@ void VerilatedVcd::bufferFlush () VL_MT_UNSAFE_ONE {
     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)
-		std::string msg = std::string("VerilatedVcd::bufferFlush: ")+strerror(errno);
-		VL_FATAL_MT("",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
@@ -381,17 +386,19 @@ void VerilatedVcd::bufferFlush () VL_MT_UNSAFE_ONE {
 //=============================================================================
 // 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==0.0 && endp==unitp) value=1;  // On error so we allow just "ns" to return 1e-9.
@@ -409,9 +416,9 @@ double VerilatedVcd::timescaleToDouble (const char* unitp) {
     return value;
 }
 
-std::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; }
@@ -425,14 +432,14 @@ std::string VerilatedVcd::doubleToTimescale (double value) {
 //=============================================================================
 // 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");
@@ -445,7 +452,7 @@ void VerilatedVcd::dumpHeader () {
     makeNameMap();
 
     // Signal header
-    assert (m_modDepth==0);
+    assert(m_modDepth==0);
     printIndent(1);
     printStr("\n");
 
@@ -457,78 +464,79 @@ void VerilatedVcd::dumpHeader () {
     // Print the signal names
     const char* lastName = "";
     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;
+        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 std::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_MT(__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 = 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
@@ -545,18 +553,20 @@ void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep
     // Tab sorts before spaces, so signals nicely will print before scopes
     // Note the hiername may be nothing, if so we'll add "\t{name}"
     std::string nameasstr = name;
-    if (m_modName!="") { nameasstr = m_modName+m_scopeEscape+nameasstr; }  // Optional ->module prefix
+    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;
 
@@ -567,50 +577,50 @@ void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep
     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(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) {
+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
@@ -619,7 +629,7 @@ void VerilatedVcd::fullDouble (vluint32_t code, const double newval) {
     *m_writep++=' '; printCode(code); *m_writep++='\n';
     bufferCheck();
 }
-void VerilatedVcd::fullFloat (vluint32_t code, const float 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
@@ -632,53 +642,55 @@ void VerilatedVcd::fullFloat (vluint32_t code, const float newval) {
 //=============================================================================
 // Callbacks
 
-void VerilatedVcd::addCallback VL_MT_UNSAFE_ONE (
+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())) {
-	std::string msg = std::string("Internal: ")+__FILE__+"::"+__FUNCTION__+" called with already open file";
-	VL_FATAL_MT(__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, m_nextCode);
+    VerilatedVcdCallInfo* vci
+        = new VerilatedVcdCallInfo(initcb, fullcb, changecb, userthis, m_nextCode);
     m_callbacks.push_back(vci);
 }
 
 //=============================================================================
 // Dumping
 
-void VerilatedVcd::dumpFull (vluint64_t timeui) {
+void VerilatedVcd::dumpFull(vluint64_t timeui) {
     m_assertOne.check();
-    dumpPrep (timeui);
+    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);
     }
 }
 
-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);
+    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);
+    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);
     }
 }
 
-void VerilatedVcd::dumpPrep (vluint64_t timeui) {
+void VerilatedVcd::dumpPrep(vluint64_t timeui) {
     printStr("#");
     printTime(timeui);
     printStr("\n");
@@ -703,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);
@@ -758,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-2018 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.
 //
@@ -26,9 +26,9 @@
 #include "verilatedos.h"
 #include "verilated.h"
 
+#include <map>
 #include <string>
 #include <vector>
-#include <map>
 
 class VerilatedVcd;
 class VerilatedVcdCallInfo;
@@ -40,7 +40,7 @@ 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) {}
@@ -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,75 +76,82 @@ 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
-    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
+    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
+    vluint32_t*         m_sigs_oldvalp; ///< Pointer to old signal values
     typedef std::vector<VerilatedVcdSig>  SigVec;
-    SigVec		m_sigs;		///< Pointer to signal information
+    SigVec              m_sigs;         ///< Pointer to signal information
     typedef std::vector<VerilatedVcdCallInfo*>  CallbackVec;
-    CallbackVec		m_callbacks;	///< Routines to perform dumping
+    CallbackVec         m_callbacks;    ///< Routines to perform dumping
     typedef std::map<std::string,std::string>  NameMap;
-    NameMap*		m_namemapp;	///< List of names for the header
+    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() 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++ = static_cast<char>((code/94/94/94)%94+33);
-	if (code>=(94*94))    *m_writep++ = static_cast<char>((code/94/94)%94+33);
-	if (code>=(94))       *m_writep++ = static_cast<char>((code/94)%94+33);
-	*m_writep++ = static_cast<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 std::string stringCode (vluint32_t code) VL_PURE {
-	std::string out;
-	if (code>=(94*94*94)) out += static_cast<char>((code/94/94/94)%94+33);
-	if (code>=(94*94))    out += static_cast<char>((code/94/94)%94+33);
-	if (code>=(94))       out += static_cast<char>((code/94)%94+33);
-	return out + static_cast<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;
     }
 
     // CONSTRUCTORS
@@ -155,7 +162,7 @@ public:
 
     // ACCESSORS
     /// 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.
@@ -165,34 +172,34 @@ public:
 
     // METHODS
     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 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 std::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 std::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);
-    std::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(static_cast<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) VL_MT_UNSAFE_ONE;
+    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 std::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,192 +211,200 @@ 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'+static_cast<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) {
-	(*(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 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) {
-	(*(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 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 = (*(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 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 = ( ((*(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 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) {
-	// cppcheck-suppress invalidPointerCast
-	if (VL_UNLIKELY((*(reinterpret_cast<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) {
-	// cppcheck-suppress invalidPointerCast
-	if (VL_UNLIKELY((*(reinterpret_cast<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:
@@ -404,7 +419,7 @@ protected:
 /// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE
 
 class VerilatedVcdC {
-    VerilatedVcd		m_sptrace;	///< Trace file being created
+    VerilatedVcd m_sptrace;  ///< Trace file being created
 
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedVcdC);
@@ -425,29 +440,29 @@ public:
     /// "cat" to be used to combine the header plus any number of data files.
     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() 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); }
+    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)); }
+    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()); }
+    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()); }
+    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-2018 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.
 //
@@ -31,8 +31,8 @@
 #if (SYSTEMC_VERSION>=20050714)
     // SystemC 2.1.v1
 // cppcheck-suppress unusedFunction
-void VerilatedVcdSc::write_comment (const std::string &) {}
-void VerilatedVcdSc::trace (const unsigned int &, const std::string &, const char **) {}
+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 ) {}
@@ -81,8 +81,8 @@ void VerilatedVcdSc::trace (const unsigned int &, const std::string &, const cha
 #elif (SYSTEMC_VERSION>20011000)
     // SystemC 2.0.1
 // cppcheck-suppress unusedFunction
-void VerilatedVcdSc::write_comment (const sc_string &) {}
-void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char **) {}
+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 ) {}
@@ -124,8 +124,8 @@ void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char
 #else
     // SystemC 1.2.1beta
 // cppcheck-suppress unusedFunction
-void VerilatedVcdSc::write_comment (const sc_string &) {}
-void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char **) {}
+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-2018 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,6 +25,7 @@
 #ifndef _VERILATED_VCD_SC_H_
 #define _VERILATED_VCD_SC_H_ 1
 
+#include "verilatedos.h"
 #include "verilated_sc.h"
 #include "verilated_vcd_c.h"
 
@@ -43,33 +44,35 @@ class VerilatedVcdSc
     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
     }
 
@@ -78,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
 
 
@@ -89,12 +92,12 @@ 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 )
@@ -138,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 )
@@ -182,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 )
@@ -220,4 +223,4 @@ private:
 # undef DECL_TRACE_METHOD_B
 };
 
-#endif // guard
+#endif  // Guard

include/verilated_vpi.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2018 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.
@@ -24,8 +24,9 @@
 //=========================================================================
 
 #ifndef _VERILATED_VPI_H_
-#define _VERILATED_VPI_H_ 1 ///< Header Guard
+#define _VERILATED_VPI_H_ 1  ///< Header Guard
 
+#include "verilatedos.h"
 #include "verilated.h"
 #include "verilated_syms.h"
 
@@ -48,5 +49,4 @@ public:
     static void selfTest() VL_MT_UNSAFE_ONE;
 };
 
-
-#endif // Guard
+#endif  // Guard

include/verilatedos.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2018 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,12 +36,10 @@
 #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__
@@ -58,8 +56,8 @@
 #  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_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)
@@ -69,51 +67,57 @@
 
 // Defaults for unsupported compiler features
 #ifndef VL_ATTR_ALIGNED
-# define VL_ATTR_ALIGNED(alignment)	///< Align structure to specified byte alignment
+# 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
+# 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
+# define VL_ATTR_NORETURN               ///< Function does not ever return
 #endif
 #ifndef VL_ATTR_PRINTF
-# define VL_ATTR_PRINTF(fmtArgNum)	///< Function with printf format checking
+# 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)
+# 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
+# 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
+# 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)
+# 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
+# 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
 #ifndef VL_UNREACHABLE
-# define VL_UNREACHABLE			///< Point that may never be reached
+# define VL_UNREACHABLE                 ///< Point that may never be reached
 #endif
 #ifndef VL_PREFETCH_RD
-# define VL_PREFETCH_RD(p)		///< Prefetch data with read intent
+# 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
+# define VL_PREFETCH_RW(p)              ///< Prefetch data with read/write intent
 #endif
 
 #ifdef VL_THREADED
@@ -124,12 +128,12 @@
 # else
 #  error "Unsupported compiler for VL_THREADED: No thread-local declarator"
 # endif
-# define VL_THREAD_LOCAL thread_local	///< Use new C++ static local thread
+# define VL_THREAD_LOCAL thread_local   ///< Use new C++ static local thread
 #else
-# define VL_THREAD_LOCAL		///< Use new C++ static local thread
+# define VL_THREAD_LOCAL                ///< Use new C++ static local thread
 #endif
-#define VL_THREAD			///< Deprecated
-#define VL_STATIC_OR_THREAD static	///< Deprecated
+#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
@@ -138,18 +142,18 @@
 #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) (static_cast<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
+# define VL_DANGLING(v) do { (v) = NULL; } while(0)  ///< After e.g. delete, set variable to NULL to indicate must not use later
 #endif
 
 //=========================================================================
@@ -157,28 +161,30 @@
 
 #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
 # define VL_EQ_DELETE = delete
-# define VL_HAS_UNIQUE_PTR
-# define VL_HAS_UNORDERED_MAP
-# define VL_HAS_UNORDERED_SET
 # define vl_unique_ptr std::unique_ptr
-# 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>
+// 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_EQ_DELETE
 # define vl_unique_ptr std::auto_ptr
-# define vl_unordered_map std::map
-# define vl_unordered_set std::set
-# define VL_INCLUDE_UNORDERED_MAP <map>
-# define VL_INCLUDE_UNORDERED_SET <set>
+# 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
 
 //=========================================================================
@@ -186,55 +192,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
@@ -244,21 +256,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
 
@@ -266,9 +279,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
@@ -293,18 +307,18 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 
 #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)
@@ -322,24 +336,24 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 //=========================================================================
 // 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
@@ -353,6 +367,43 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 # define VL_ROUND(n) round(n)
 #endif
 
+//=========================================================================
+// Performance counters
+
+/// 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;
@@ -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
@@ -251,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 */
 
@@ -978,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 */
 

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)
-  void visit (AstNodeIf* nodep)
-  void visit (AstNodeStmt* nodep)
-  void visit (AstNode* nodep)
+  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>
   }
 
@@ -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
@@ -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-2018 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-2018 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-2018 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/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-2018 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-2018 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-2018 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,28 +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"
-	    || $var eq "VERILATOR_INCLUDE") {
-	    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}
+        }
     }
 }
 
@@ -127,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;
@@ -184,7 +189,7 @@ Runs a specific test stage (see the script).
 
 =head1 DISTRIBUTION
 
-Copyright 2009-2018 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-2018 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-2018 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

@@ -28,7 +28,7 @@ invoke_ncverilog - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2018 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_vcs

@@ -28,7 +28,7 @@ invoke_vcs - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2018 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/vtree_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);
 
 #======================================================================
 
@@ -23,15 +23,15 @@ $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();
 }
 
-vread ($opt_filename);
+vread($opt_filename);
 #print Dumper($Tree);
 vwrite();
 
@@ -41,7 +41,7 @@ print '(query-replace-regexp "(\\([0-9a-z_]+\\))" "\\1" nil nil nil)',"\n";
 
 sub usage {
     pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
-    exit (1);
+    exit(1);
 }
 
 sub debug {
@@ -51,9 +51,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,45 +64,45 @@ sub vread {
     my $fh = IO::File->new($filename) or die "%Error: $! $filename,";
     my $lasthier="";
     $Tree = {
-	op => 'NETLIST',
-	t => [[],[],[],[],[],],
+        op => 'NETLIST',
+        t => [[],[],[],[],[],],
     };
     my @stack;
     $stack[1] = $Tree;
     while (defined (my $line = $fh->getline)) {
-	if ($line =~ /^\s+(\S+):\s+(\S+)\s+0x\S+\s+{(\d+)}\s+w(\d+)\s+(.*)$/) {
-	    my $hier = $1;
-	    my $op = $2;
-	    my $lineno = $3;
-	    my $width = $4;
-	    my $etc = $5;
+        if ($line =~ /^\s+(\S+):\s+(\S+)\s+0x\S+\s+{(\d+)}\s+w(\d+)\s+(.*)$/) {
+            my $hier = $1;
+            my $op = $2;
+            my $lineno = $3;
+            my $width = $4;
+            my $etc = $5;
 
-	    $etc =~ s/__DOT__/./g;
-	    $etc =~ s/__PVT__//g;
+            $etc =~ s/__DOT__/./g;
+            $etc =~ s/__PVT__//g;
 
-	    my $self = {
-		op => $op,
-		#width =>  $width,
-		#lineno => $lineno,
-		#line => $line,
-		etc => $etc,
-		args => [split(/[ \t]+/,$etc)],
-		t => [[],[],[],[],[],],
-	    };
+            my $self = {
+                op => $op,
+                #width =>  $width,
+                #lineno => $lineno,
+                #line => $line,
+                etc => $etc,
+                args => [split(/[ \t]+/,$etc)],
+                t => [[],[],[],[],[],],
+            };
 
-	    my @hiers = (1,split(/:/,$hier));
-	    my $depth = $#hiers+1;
-	    my $newchild = $hiers[$#hiers];
+            my @hiers = (1,split(/:/,$hier));
+            my $depth = $#hiers+1;
+            my $newchild = $hiers[$#hiers];
 
-	    #print "DD $depth $newchild $op\n";
+            #print "DD $depth $newchild $op\n";
 
-	    push @{$stack[$depth-1]->{t}[$newchild]}, $self;
-	    $stack[$depth] = $self;
+            push @{$stack[$depth-1]->{t}[$newchild]}, $self;
+            $stack[$depth] = $self;
 
-	    $lasthier = $hier;
-	    #print "   $lasthier\n";
-	    #print Dumper($Tree);
-	}
+            $lasthier = $hier;
+            #print "   $lasthier\n";
+            #print Dumper($Tree);
+        }
     }
 }
 
@@ -168,125 +168,125 @@ sub nl { p "\n"," "x$Indent; }
 
 sub gentree {
 %OpMap = (
-  'NULLNODE'	=> sub { "" },
-  'NETLIST'	=> sub { nl;t1;t2;t3;t4;t5; },
-  'ACTIVE'	=> sub { p "always_act @(";t1;p ") begin";indentInc;nl;t2;t3;t4;t5;indentDec;p "end";nl; },
-  'ADD'		=> sub { p1;p " + ";p2; },
-  'ALWAYS'	=> sub { p "always @(";t1;p ") begin";indentInc;nl;t2;t3;t4;t5;indentDec;p "end";nl; },
-  'ALWAYSPOST'	=> sub { p "ALWAYSPOST what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'AND'		=> sub { p1;p " & ";p2; },
-  'ARRAYSEL'	=> sub { t1;p "[";t2;p "]"; },
-  'ASSIGN'	=> sub { t2;p " = ";t1;p ";";nl; },
-  'ASSIGNDLY'	=> sub { t2;p " <= ";t1;p ";";nl; },
-  'ASSIGNPOST'	=> sub { p "ASSIGNPOST what{";t1;p " = ";t2;p ";";nl; },
-  'ASSIGNPRE'	=> sub { p "ASSIGNPRE what{";t1;p " = ";t2;p ";";nl; },
-  'ASSIGNW'	=> sub { p "assign ";t2;p " = ";t1;p ";";nl; },
-  'ATTROF'	=> sub { p "ATTROF what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'BEGIN'	=> sub { p "begin";indentInc;nl;t1;t2;t3;t4;t5;indentDec;p "end";nl; },
-  'BITSEL'	=> sub { t1;local $Avoid_Hex=1; p "[";t2;p "]"; },
-  'CASE'	=> sub { p "CASE what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'CASEITEM'	=> sub { p "CASEITEM what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'CAST'	=> sub { p "CAST what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'CCALL'	=> sub { p "CCALL what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'CELL'	=> sub { a1;p " ";a7;p " (/*CELL*/);"; nl; },
-  'CFUNC'	=> sub { p "CFUNC what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'CHANGEDET'	=> sub { p "CHANGEDET what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'CINCLUDE'	=> sub { p "CINCLUDE what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'COMMENT'	=> sub { p "//COMMENT what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl;nl; },
-  'CONCAT'	=> sub { p "{";p1;p ",";p2;p "}"; },
-  'CONDITIONAL'	=> sub { p1;p " ? ";p2;p " : ";p3; },
-  'CONST'	=> sub { p_const(); },
-  'COVER'	=> sub { p "COVER what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'CRETURN'	=> sub { p "CRETURN what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'CSTMT'	=> sub { p "CSTMT what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'DEFPARAM'	=> sub { p "defparam ";p1;p " = ";p2;p ";";nl; },
-  'DISPLAY'	=> sub { p '$write("';p1;p "\",";p2;p3;p4;p5;p ");";nl; },
-  'DIV'		=> sub { p1;p " / ";p2; },
-  'EQ'		=> sub { p1;p " == ";p2; },
-  'EQCASE'	=> sub { p1;p " === ";p2; },
-  'EXTEND'	=> sub { t1; },
-  'EXTRACT'	=> sub { t1;local $Avoid_Hex=1; p "[";t2;p ":";t3;p "]"; },
-  'FINISH'	=> sub { p '$finish;';nl },
-  'FOR'		=> sub { p "for (";p1;p ",";p2;p ",";p3;p ") begin";indentInc;nl;p4;p5;indentDec;p "end";nl; },
-  'FUNC'	=> sub { p "FUNC what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'FUNCREF'	=> sub { p "FUNCREF what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'GT'		=> sub { p1;p " > ";p2; },
-  'GTE'		=> sub { p1;p " >= ";p2; },
-  'IF'		=> sub { p "if (";p1;p ") begin";indentInc;nl;t2;indentDec;if (exists3) {p "end else begin";indentInc;nl;t3;indentDec;} p "end"; nl; },
-  'INITARRAY'	=> sub { p "INITARRAY what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'INITIAL'	=> sub { p "initial begin";indentInc;nl;t1;t2;t3;t4;t5;indentDec;p "end";nl; },
-  'LOGAND'	=> sub { p1;p " && ";p2; },
-  'LOGNOT'	=> sub { p1;p " || ";p2; },
-  'LOGOR'	=> sub { p "!";p1; },
-  'LT'		=> sub { p1;p " < ";p2; },
-  'LTE'		=> sub { p1;p " <= ";p2; },
-  'MODDIV'	=> sub { p1;p " % ";p2; },
-  'MODULE'	=> sub { p "module ";a1;p " (/*AUTOARG*/);";indentInc;nl;t1;t2;t3;t4;t5;indentDec;nl;p "endmodule";nl; },
-  'MUL'		=> sub { p1;p " * ";p2; },
-  'NEQ'		=> sub { p1;p " != ";p2; },
-  'NEQCASE'	=> sub { p1;p " !== ";p2; },
-  'NOT'		=> sub { p " ~";p1; },
-  'OR'		=> sub { p1;p " | ";p2; },
-  'PIN'		=> sub { p ";p ";p1;p " (";p2;p "),";nl; },
-  'PORT'	=> sub { p ""; },
-  'PRAGMA'	=> sub { p "PRAGMA what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'RAND'	=> sub { p '$rand'; },
-  'RANGE'	=> sub { t1; local $Avoid_Hex=1; p "[";t2;p ":";t3;p "]"; },
-  'REDAND'	=> sub { p "&(";p1;p ")"; },
-  'REDOR'	=> sub { p "|(";p1;p ")"; },
-  'REDXNOR'	=> sub { p "~|(";p1;p ")"; },
-  'REDXOR'	=> sub { p "~^(";p1;p ")"; },
-  'REPLICATE'	=> sub { p "{";p1;p "{";p2;p "}}"; },
-  'SCCTOR'	=> sub { p "SCCTOR what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'SCHDR'	=> sub { p "SCHDR what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'SCIMP'	=> sub { p "SCIMP what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'SCINT'	=> sub { p "SCINT what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'SCOPE'	=> sub { t1;t2;t3;t4;t5; },
-  'SENITEM'	=> sub { a1;p " ";t1; },
-  'SENTREE'	=> sub { t1;t2;t3;t4;t5; },
-  'SHIFTL'	=> sub { p1;p " << ";p2; },
-  'SHIFTR'	=> sub { p1;p " >> ";p2; },
-  'STOP'	=> sub { p '$stop;';nl; },
-  'SUB'		=> sub { p1;p " - ";p2; },
-  'TASK'	=> sub { p "TASK what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'TASKREF'	=> sub { p "TASKREF what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'TEXT'	=> sub { p "TEXT what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'TIME'	=> sub { p '$time'; },
-  'TOPSCOPE'	=> sub { t1;t2;t3;t4;t5; },
-  'TRACE'	=> sub { p "TRACE what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'UCFUNC'	=> sub { p '$c(';p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p ")"; },
-  'UCSTMT'	=> sub { p '$c(';p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p ");";nl; },
-  'NEGATE'	=> sub { p " -";p1; },
-  'VAR'		=> sub { p_var(); },
-  'VARPIN'	=> sub { p "VARPIN what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
-  'VARREF'	=> sub { a1; },
-  'VARSCOPE'	=> sub { },
-  'WHILE'	=> sub { t1; p "while (";t2;p ") begin";indentInc;nl;t3;t4;indentDec;p "end";nl; },
-  'WORDSEL'	=> sub { p1;p "[";p2;p ":";p3;p "]"; },
-  'XNOR'	=> sub { p1;p " ~^ ";p2; },
-  'XOR'		=> sub { p1;p " ^";p2; },
+  'NULLNODE'    => sub { "" },
+  'NETLIST'     => sub { nl;t1;t2;t3;t4;t5; },
+  'ACTIVE'      => sub { p "always_act @(";t1;p ") begin";indentInc;nl;t2;t3;t4;t5;indentDec;p "end";nl; },
+  'ADD'         => sub { p1;p " + ";p2; },
+  'ALWAYS'      => sub { p "always @(";t1;p ") begin";indentInc;nl;t2;t3;t4;t5;indentDec;p "end";nl; },
+  'ALWAYSPOST'  => sub { p "ALWAYSPOST what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'AND'         => sub { p1;p " & ";p2; },
+  'ARRAYSEL'    => sub { t1;p "[";t2;p "]"; },
+  'ASSIGN'      => sub { t2;p " = ";t1;p ";";nl; },
+  'ASSIGNDLY'   => sub { t2;p " <= ";t1;p ";";nl; },
+  'ASSIGNPOST'  => sub { p "ASSIGNPOST what{";t1;p " = ";t2;p ";";nl; },
+  'ASSIGNPRE'   => sub { p "ASSIGNPRE what{";t1;p " = ";t2;p ";";nl; },
+  'ASSIGNW'     => sub { p "assign ";t2;p " = ";t1;p ";";nl; },
+  'ATTROF'      => sub { p "ATTROF what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'BEGIN'       => sub { p "begin";indentInc;nl;t1;t2;t3;t4;t5;indentDec;p "end";nl; },
+  'BITSEL'      => sub { t1;local $Avoid_Hex=1; p "[";t2;p "]"; },
+  'CASE'        => sub { p "CASE what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'CASEITEM'    => sub { p "CASEITEM what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'CAST'        => sub { p "CAST what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'CCALL'       => sub { p "CCALL what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'CELL'        => sub { a1;p " ";a7;p " (/*CELL*/);"; nl; },
+  'CFUNC'       => sub { p "CFUNC what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'CHANGEDET'   => sub { p "CHANGEDET what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'CINCLUDE'    => sub { p "CINCLUDE what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'COMMENT'     => sub { p "//COMMENT what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl;nl; },
+  'CONCAT'      => sub { p "{";p1;p ",";p2;p "}"; },
+  'CONDITIONAL' => sub { p1;p " ? ";p2;p " : ";p3; },
+  'CONST'       => sub { p_const(); },
+  'COVER'       => sub { p "COVER what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'CRETURN'     => sub { p "CRETURN what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'CSTMT'       => sub { p "CSTMT what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'DEFPARAM'    => sub { p "defparam ";p1;p " = ";p2;p ";";nl; },
+  'DISPLAY'     => sub { p '$write("';p1;p "\",";p2;p3;p4;p5;p ");";nl; },
+  'DIV'         => sub { p1;p " / ";p2; },
+  'EQ'          => sub { p1;p " == ";p2; },
+  'EQCASE'      => sub { p1;p " === ";p2; },
+  'EXTEND'      => sub { t1; },
+  'EXTRACT'     => sub { t1;local $Avoid_Hex=1; p "[";t2;p ":";t3;p "]"; },
+  'FINISH'      => sub { p '$finish;';nl },
+  'FOR'         => sub { p "for (";p1;p ",";p2;p ",";p3;p ") begin";indentInc;nl;p4;p5;indentDec;p "end";nl; },
+  'FUNC'        => sub { p "FUNC what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'FUNCREF'     => sub { p "FUNCREF what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'GT'          => sub { p1;p " > ";p2; },
+  'GTE'         => sub { p1;p " >= ";p2; },
+  'IF'          => sub { p "if (";p1;p ") begin";indentInc;nl;t2;indentDec;if (exists3) {p "end else begin";indentInc;nl;t3;indentDec;} p "end"; nl; },
+  'INITARRAY'   => sub { p "INITARRAY what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'INITIAL'     => sub { p "initial begin";indentInc;nl;t1;t2;t3;t4;t5;indentDec;p "end";nl; },
+  'LOGAND'      => sub { p1;p " && ";p2; },
+  'LOGNOT'      => sub { p1;p " || ";p2; },
+  'LOGOR'       => sub { p "!";p1; },
+  'LT'          => sub { p1;p " < ";p2; },
+  'LTE'         => sub { p1;p " <= ";p2; },
+  'MODDIV'      => sub { p1;p " % ";p2; },
+  'MODULE'      => sub { p "module ";a1;p " (/*AUTOARG*/);";indentInc;nl;t1;t2;t3;t4;t5;indentDec;nl;p "endmodule";nl; },
+  'MUL'         => sub { p1;p " * ";p2; },
+  'NEQ'         => sub { p1;p " != ";p2; },
+  'NEQCASE'     => sub { p1;p " !== ";p2; },
+  'NOT'         => sub { p " ~";p1; },
+  'OR'          => sub { p1;p " | ";p2; },
+  'PIN'         => sub { p ";p ";p1;p " (";p2;p "),";nl; },
+  'PORT'        => sub { p ""; },
+  'PRAGMA'      => sub { p "PRAGMA what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'RAND'        => sub { p '$rand'; },
+  'RANGE'       => sub { t1; local $Avoid_Hex=1; p "[";t2;p ":";t3;p "]"; },
+  'REDAND'      => sub { p "&(";p1;p ")"; },
+  'REDOR'       => sub { p "|(";p1;p ")"; },
+  'REDXNOR'     => sub { p "~|(";p1;p ")"; },
+  'REDXOR'      => sub { p "~^(";p1;p ")"; },
+  'REPLICATE'   => sub { p "{";p1;p "{";p2;p "}}"; },
+  'SCCTOR'      => sub { p "SCCTOR what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'SCHDR'       => sub { p "SCHDR what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'SCIMP'       => sub { p "SCIMP what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'SCINT'       => sub { p "SCINT what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'SCOPE'       => sub { t1;t2;t3;t4;t5; },
+  'SENITEM'     => sub { a1;p " ";t1; },
+  'SENTREE'     => sub { t1;t2;t3;t4;t5; },
+  'SHIFTL'      => sub { p1;p " << ";p2; },
+  'SHIFTR'      => sub { p1;p " >> ";p2; },
+  'STOP'        => sub { p '$stop;';nl; },
+  'SUB'         => sub { p1;p " - ";p2; },
+  'TASK'        => sub { p "TASK what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'TASKREF'     => sub { p "TASKREF what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'TEXT'        => sub { p "TEXT what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'TIME'        => sub { p '$time'; },
+  'TOPSCOPE'    => sub { t1;t2;t3;t4;t5; },
+  'TRACE'       => sub { p "TRACE what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'UCFUNC'      => sub { p '$c(';p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p ")"; },
+  'UCSTMT'      => sub { p '$c(';p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p ");";nl; },
+  'NEGATE'      => sub { p " -";p1; },
+  'VAR'         => sub { p_var(); },
+  'VARPIN'      => sub { p "VARPIN what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
+  'VARREF'      => sub { a1; },
+  'VARSCOPE'    => sub { },
+  'WHILE'       => sub { t1; p "while (";t2;p ") begin";indentInc;nl;t3;t4;indentDec;p "end";nl; },
+  'WORDSEL'     => sub { p1;p "[";p2;p ":";p3;p "]"; },
+  'XNOR'        => sub { p1;p " ~^ ";p2; },
+  'XOR'         => sub { p1;p " ^";p2; },
 );
 }
 
 sub p_var {
     my $self = $Code_Self;
     if ($self->{etc} =~ /\[I\]/) {
-	print "input";
+        print "input";
     } elsif ($self->{etc} =~ /\[O\]/) {
-	print "output";
+        print "output";
     } else {
-	print "reg";
+        print "reg";
     }
     p "\t";
     {
-	local $Avoid_Hex=1;
-	t1;
+        local $Avoid_Hex=1;
+        t1;
     }
     p "\t";
     a1;
     if (exists2()) {
-	p " = ";
-	t2;
+        p " = ";
+        t2;
     }
     p ";";
     nl;
@@ -295,10 +295,10 @@ sub p_var {
 sub p_const {
     my $v = $Code_Self->{args}[0];
     if ($v =~ /\?32\?h(.*)$/
-	|| ($Avoid_Hex && $v =~ /^[0-9?]*h(.*)$/)) {
-	print hex $1;
+        || ($Avoid_Hex && $v =~ /^[0-9?]*h(.*)$/)) {
+        print hex $1;
     } else {
-	print $v;
+        print $v;
     }
 }
 
@@ -331,7 +331,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2018 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.
 

src/.gdbinit

@@ -1,6 +1,6 @@
 # DESCRIPTION: Verilator: GDB startup file with useful defines
 #
-# Copyright 2012-2018 by Wilson Snyder. This program is free software; you can
+# 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.

src/Makefile.in

@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2018 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.
@@ -22,9 +22,10 @@
 #### Start of system configuration section. ####
 
 srcdir = @srcdir@
-VPATH = @srcdir@
 PERL = @PERL@
 EXEEXT = @EXEEXT@
+# VPATH only does sources; fix install_test's not creating ../bin
+vpath %.h @srcdir@
 
 #### End of system configuration section. ####
 
@@ -42,9 +43,11 @@ UNDER_GIT = $(wildcard ${srcdir}/../.git/logs/HEAD)
 #*********************************************************************
 
 obj_opt:
-	mkdir $@
+	mkdir -p $@
 obj_dbg:
-	mkdir $@
+	mkdir -p $@
+../bin:
+	mkdir -p $@
 
 .SUFFIXES:
 
@@ -56,19 +59,19 @@ ifeq ($(VERILATOR_NO_OPT_BUILD),1)	# Faster laptop development... One build
 	-rm -rf $@ $@.exe
 	-cp -p $<$(EXEEXT) $@$(EXEEXT)
 else
-../bin/verilator_bin: obj_opt prefiles
-	cd obj_opt && $(MAKE) -j 1  TGT=../$@ -f ../Makefile_obj serial
-	cd obj_opt && $(MAKE)       TGT=../$@ -f ../Makefile_obj
+../bin/verilator_bin: obj_opt ../bin prefiles
+	$(MAKE) -C obj_opt -j 1  TGT=../$@ -f ../Makefile_obj serial
+	$(MAKE) -C obj_opt       TGT=../$@ -f ../Makefile_obj
 endif
 
 dbg: ../bin/verilator_bin_dbg ../bin/verilator_coverage_bin_dbg
-../bin/verilator_bin_dbg: obj_dbg prefiles
-	cd obj_dbg && $(MAKE) -j 1  TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj serial
-	cd obj_dbg && $(MAKE)       TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj
+../bin/verilator_bin_dbg: obj_dbg ../bin prefiles
+	$(MAKE) -C obj_dbg -j 1  TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj serial
+	$(MAKE) -C obj_dbg       TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj
 
-../bin/verilator_coverage_bin_dbg: obj_dbg prefiles
-	cd obj_dbg && $(MAKE)       TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj serial_vlcov
-	cd obj_dbg && $(MAKE)       TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj
+../bin/verilator_coverage_bin_dbg: obj_dbg ../bin prefiles
+	$(MAKE) -C obj_dbg       TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj serial_vlcov
+	$(MAKE) -C obj_dbg       TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj
 
 prefiles::
 prefiles:: config_rev.h

src/Makefile_obj.in

@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2018 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.
@@ -78,7 +78,7 @@ ifeq ($(VL_DEBUG),)
 COPT = -O2
 else
 # Debug
-COPT = -ggdb -DVL_DEBUG
+COPT = -ggdb -DVL_DEBUG -D_GLIBCXX_DEBUG
 # Debug & Profile:
 #LDFLAGS += -pg -g
 #COPT = -ggdb -pg -g
@@ -93,7 +93,7 @@ endif
 LIBS = -lm -lstdc++
 
 CPPFLAGS += -MMD
-CPPFLAGS += -I. -I$(bldsrc) -I$(srcdir) -I$(incdir)
+CPPFLAGS += -I. -I$(bldsrc) -I$(srcdir) -I$(incdir) -I../../include
 CPPFLAGS += -DYYDEBUG 	# Required to get nice error messages
 #CPPFLAGS += -DVL_LEAK_CHECKS 	# If running valgrind or other hunting tool
 CPPFLAGS += $(COPT)
@@ -195,10 +195,12 @@ RAW_OBJS = \
 	V3GraphAlg.o \
 	V3GraphAcyc.o \
 	V3GraphDfa.o \
+	V3GraphPathChecker.o \
 	V3GraphTest.o \
 	V3Hashed.o \
 	V3Inline.o \
 	V3Inst.o \
+	V3InstrCount.o \
 	V3Life.o \
 	V3LifePost.o \
 	V3LinkCells.o \
@@ -215,9 +217,12 @@ RAW_OBJS = \
 	V3Order.o \
 	V3Os.o \
 	V3Param.o \
+	V3Partition.o \
 	V3PreShell.o \
 	V3Premit.o \
+	V3Reloop.o \
 	V3Scope.o \
+	V3Scoreboard.o \
 	V3Slice.o \
 	V3Split.o \
 	V3SplitAs.o \
@@ -230,6 +235,7 @@ RAW_OBJS = \
 	V3Trace.o \
 	V3TraceDecl.o \
 	V3Tristate.o \
+	V3TSP.o \
 	V3Undriven.o \
 	V3Unknown.o \
 	V3Unroll.o \

src/V3Active.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2018 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.
@@ -21,29 +21,26 @@
 //
 // Note this can be called multiple times.
 //   Create a IACTIVE(initial), SACTIVE(combo)
-//	ALWAYS: Remove any-edges from sense list
-//	    If no POS/NEG in senselist, Fold into SACTIVE(combo)
-//	    Else fold into SACTIVE(sequent).
-//	    OPTIMIZE: When support async clocks, fold into that active if possible
-//	INITIAL: Move into IACTIVE
-//	WIRE: Move into SACTIVE(combo)
+//      ALWAYS: Remove any-edges from sense list
+//          If no POS/NEG in senselist, Fold into SACTIVE(combo)
+//          Else fold into SACTIVE(sequent).
+//          OPTIMIZE: When support async clocks, fold into that active if possible
+//      INITIAL: Move into IACTIVE
+//      WIRE: Move into SACTIVE(combo)
 //
 //*************************************************************************
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <map>
-#include <algorithm>
-#include <vector>
 
 #include "V3Global.h"
 #include "V3Active.h"
 #include "V3Ast.h"
 #include "V3EmitCBase.h"
 #include "V3Const.h"
+#include "V3SenTree.h"  // for SenTreeSet
+
+#include VL_INCLUDE_UNORDERED_MAP
 
 //***** See below for main transformation engine
 
@@ -52,109 +49,106 @@
 
 class ActiveBaseVisitor : public AstNVisitor {
 protected:
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 };
 
 class ActiveNamer : public ActiveBaseVisitor {
 private:
     typedef std::map<string,AstActive*> ActiveNameMap;
     // STATE
-    AstScope*	m_scopep;		// Current scope to add statement to
-    AstActive*	m_iActivep;		// For current scope, the IActive we're building
-    AstActive*	m_cActivep;		// For current scope, the SActive(combo) we're building
-    vector<AstActive*>	m_activeVec;	// List of sensitive actives, for folding
+    AstScope*   m_scopep;               // Current scope to add statement to
+    AstActive*  m_iActivep;             // For current scope, the IActive we're building
+    AstActive*  m_cActivep;             // For current scope, the SActive(combo) we're building
+
+    SenTreeSet m_activeSens;  // Sen lists for each active we've made
+    typedef vl_unordered_map<AstSenTree*, AstActive*> ActiveMap;
+    ActiveMap m_activeMap;  // Map sentree to active, for folding.
+
     // METHODS
     void addActive(AstActive* nodep) {
-	if (!m_scopep) nodep->v3fatalSrc("NULL scope");
-	m_scopep->addActivep(nodep);
+        if (!m_scopep) nodep->v3fatalSrc("NULL scope");
+        m_scopep->addActivep(nodep);
     }
     // VISITORS
     virtual void visit(AstScope* nodep) {
-	m_scopep = nodep;
-	m_iActivep = NULL;
-	m_cActivep = NULL;
-	m_activeVec.clear();
-	nodep->iterateChildren(*this);
-	// Don't clear scopep, the namer persists beyond this visit
+        m_scopep = nodep;
+        m_iActivep = NULL;
+        m_cActivep = NULL;
+        m_activeSens.clear();
+        m_activeMap.clear();
+        iterateChildren(nodep);
+        // Don't clear scopep, the namer persists beyond this visit
     }
     virtual void visit(AstSenTree* nodep) {
-	// Simplify sensitivity list
-	V3Const::constifyExpensiveEdit(nodep); VL_DANGLING(nodep);
+        // Simplify sensitivity list
+        V3Const::constifyExpensiveEdit(nodep); VL_DANGLING(nodep);
     }
     // Empty visitors, speed things up
     virtual void visit(AstNodeStmt* nodep) { }
     //--------------------
     // Default
     virtual void visit(AstNode* nodep) {
-	// Default: Just iterate
-	nodep->iterateChildren(*this);
+        // Default: Just iterate
+        iterateChildren(nodep);
     }
     // METHODS
 public:
     AstScope* scopep() { return m_scopep; }
     AstActive* getCActive(FileLine* fl) {
-	if (!m_cActivep) {
-	    m_cActivep = new AstActive(fl, "combo",
-				       new AstSenTree(fl, new AstSenItem(fl,AstSenItem::Combo())));
-	    m_cActivep->sensesStorep(m_cActivep->sensesp());
-	    addActive(m_cActivep);
-	}
-	return m_cActivep;
+        if (!m_cActivep) {
+            m_cActivep = new AstActive(
+                fl, "combo",
+                new AstSenTree(fl, new AstSenItem(fl, AstSenItem::Combo())));
+            m_cActivep->sensesStorep(m_cActivep->sensesp());
+            addActive(m_cActivep);
+        }
+        return m_cActivep;
     }
     AstActive* getIActive(FileLine* fl) {
-	if (!m_iActivep) {
-	    m_iActivep = new AstActive(fl, "initial",
-				       new AstSenTree(fl, new AstSenItem(fl,AstSenItem::Initial())));
-	    m_iActivep->sensesStorep(m_iActivep->sensesp());
-	    addActive(m_iActivep);
-	}
-	return m_iActivep;
+        if (!m_iActivep) {
+            m_iActivep = new AstActive(
+                fl, "initial",
+                new AstSenTree(fl, new AstSenItem(fl, AstSenItem::Initial())));
+            m_iActivep->sensesStorep(m_iActivep->sensesp());
+            addActive(m_iActivep);
+        }
+        return m_iActivep;
     }
     AstActive* getActive(FileLine* fl, AstSenTree* sensesp) {
-	// Return a sentree in this scope that matches given sense list.
-	// Not the fastest, but scopes tend to have few clocks
-	AstActive* activep = NULL;
-	//sitemsp->dumpTree(cout,"  Lookingfor: ");
-	for (vector<AstActive*>::iterator it = m_activeVec.begin(); it!=m_activeVec.end(); ++it) {
-	    activep = *it;
-	    if (activep) {  // Not deleted
-		// Compare the list
-		AstSenTree* asenp = activep->sensesp();
-		if (asenp->sameTree(sensesp)) {
-		    UINFO(8,"    Found ACTIVE "<<activep<<endl);
-		    goto found;
-		}
-	    }
-	    activep = NULL;
-	}
-      found:
-	// Not found, form a new one
-	if (!activep) {
-	    AstSenTree* newsenp = sensesp->cloneTree(false);
-	    activep = new AstActive(fl, "sequent", newsenp);
-	    activep->sensesStorep(activep->sensesp());
-	    UINFO(8,"    New ACTIVE "<<activep<<endl);
-	    // Form the sensitivity list
-	    addActive(activep);
-	    m_activeVec.push_back(activep);
-	    // Note actives may have also been added above in the Active visitor
-	}
-	return activep;
+        // Return a sentree in this scope that matches given sense list.
+
+        AstActive* activep = NULL;
+        AstSenTree* activeSenp = m_activeSens.find(sensesp);
+        if (activeSenp) {
+            ActiveMap::iterator it = m_activeMap.find(activeSenp);
+            UASSERT(it != m_activeMap.end(), "Corrupt active map");
+            activep = it->second;
+        }
+
+        // Not found, form a new one
+        if (!activep) {
+            AstSenTree* newsenp = sensesp->cloneTree(false);
+            activep = new AstActive(fl, "sequent", newsenp);
+            activep->sensesStorep(activep->sensesp());
+            UINFO(8,"    New ACTIVE "<<activep<<endl);
+            // Form the sensitivity list
+            addActive(activep);
+            m_activeMap[newsenp] = activep;
+            m_activeSens.add(newsenp);
+            // Note actives may have also been added above in the Active visitor
+        }
+        return activep;
     }
 public:
     // CONSTUCTORS
     ActiveNamer() {
-	m_scopep = NULL;
-	m_iActivep = NULL;
-	m_cActivep = NULL;
+        m_scopep = NULL;
+        m_iActivep = NULL;
+        m_cActivep = NULL;
     }
     virtual ~ActiveNamer() {}
     void main(AstScope* nodep) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
 };
 
@@ -165,65 +159,67 @@ class ActiveDlyVisitor : public ActiveBaseVisitor {
 public:
     enum CheckType { CT_SEQ, CT_COMBO, CT_INITIAL, CT_LATCH };
 private:
-    CheckType 	m_check;	// Combo logic or other
-    AstNode*	m_alwaysp;	// Always we're under
-    AstNode*	m_assignp;	// In assign
+    CheckType   m_check;        // Combo logic or other
+    AstNode*    m_alwaysp;      // Always we're under
+    AstNode*    m_assignp;      // In assign
     // VISITORS
     virtual void visit(AstAssignDly* nodep) {
-	if (m_check != CT_SEQ) {
-	    // Convert to a non-delayed assignment
-	    UINFO(5,"    ASSIGNDLY "<<nodep<<endl);
-	    if (m_check == CT_INITIAL) {
-		nodep->v3warn(INITIALDLY,"Delayed assignments (<=) in initial or final block; suggest blocking assignments (=).");
-	    } else if (m_check == CT_LATCH) {
-		// Suppress. Shouldn't matter that the interior of the latch races
-	    } else {
-		nodep->v3warn(COMBDLY,"Delayed assignments (<=) in non-clocked (non flop or latch) block; suggest blocking assignments (=).");
-	    }
-	    AstNode* newp = new AstAssign (nodep->fileline(),
-					   nodep->lhsp()->unlinkFrBack(),
-					   nodep->rhsp()->unlinkFrBack());
-	    nodep->replaceWith(newp);
-	    nodep->deleteTree(); VL_DANGLING(nodep);
-	}
+        if (m_check != CT_SEQ) {
+            // Convert to a non-delayed assignment
+            UINFO(5,"    ASSIGNDLY "<<nodep<<endl);
+            if (m_check == CT_INITIAL) {
+                nodep->v3warn(INITIALDLY, "Delayed assignments (<=) in initial"
+                              " or final block; suggest blocking assignments (=).");
+            } else if (m_check == CT_LATCH) {
+                // Suppress. Shouldn't matter that the interior of the latch races
+            } else {
+                nodep->v3warn(COMBDLY, "Delayed assignments (<=) in non-clocked"
+                              " (non flop or latch) block; suggest blocking assignments (=).");
+            }
+            AstNode* newp = new AstAssign(nodep->fileline(),
+                                          nodep->lhsp()->unlinkFrBack(),
+                                          nodep->rhsp()->unlinkFrBack());
+            nodep->replaceWith(newp);
+            nodep->deleteTree(); VL_DANGLING(nodep);
+        }
     }
     virtual void visit(AstAssign* nodep) {
-	if (m_check == CT_SEQ) {
-	    AstNode* las = m_assignp;
-	    m_assignp = nodep;
-	    nodep->lhsp()->iterateAndNext(*this);
-	    m_assignp = las;
-	}
+        if (m_check == CT_SEQ) {
+            AstNode* las = m_assignp;
+            m_assignp = nodep;
+            iterateAndNextNull(nodep->lhsp());
+            m_assignp = las;
+        }
     }
     virtual void visit(AstVarRef* nodep) {
-	AstVar* varp=nodep->varp();
-	if (m_check == CT_SEQ
-	    && m_assignp
-	    && !varp->isUsedLoopIdx() // Ignore loop indicies
-	    && !varp->isTemp()
-	    ) {
-	    // Allow turning off warnings on the always, or the variable also
-	    if (!m_alwaysp->fileline()->warnIsOff(V3ErrorCode::BLKSEQ)
-		&& !m_assignp->fileline()->warnIsOff(V3ErrorCode::BLKSEQ)
-		&& !varp->fileline()->warnIsOff(V3ErrorCode::BLKSEQ)
-		) {
-		m_alwaysp->fileline()->modifyWarnOff(V3ErrorCode::BLKSEQ, true);  // Complain just once for the entire always
-		varp->fileline()->modifyWarnOff(V3ErrorCode::BLKSEQ, true);
-		nodep->v3warn(BLKSEQ,"Blocking assignments (=) in sequential (flop or latch) block; suggest delayed assignments (<=).");
-	    }
-	}
+        AstVar* varp = nodep->varp();
+        if (m_check == CT_SEQ
+            && m_assignp
+            && !varp->isUsedLoopIdx()  // Ignore loop indicies
+            && !varp->isTemp()
+            ) {
+            // Allow turning off warnings on the always, or the variable also
+            if (!m_alwaysp->fileline()->warnIsOff(V3ErrorCode::BLKSEQ)
+                && !m_assignp->fileline()->warnIsOff(V3ErrorCode::BLKSEQ)
+                && !varp->fileline()->warnIsOff(V3ErrorCode::BLKSEQ)
+                ) {
+                m_alwaysp->fileline()->modifyWarnOff(V3ErrorCode::BLKSEQ, true);  // Complain just once for the entire always
+                varp->fileline()->modifyWarnOff(V3ErrorCode::BLKSEQ, true);
+                nodep->v3warn(BLKSEQ, "Blocking assignments (=) in sequential (flop or latch) block; suggest delayed assignments (<=).");
+            }
+        }
     }
     //--------------------
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
     ActiveDlyVisitor(AstNode* nodep, CheckType check) {
-	m_alwaysp = nodep;
-	m_check = check;
-	m_assignp = NULL;
-	nodep->accept(*this);
+        m_alwaysp = nodep;
+        m_check = check;
+        m_assignp = NULL;
+        iterate(nodep);
     }
     virtual ~ActiveDlyVisitor() {}
 };
@@ -235,183 +231,188 @@ class ActiveVisitor : public ActiveBaseVisitor {
 private:
     // NODE STATE
     //  Each call to V3Const::constify
-    //   AstNode::user4()		Used by V3Const::constify, called below
+    //   AstNode::user4()               Used by V3Const::constify, called below
 
     // STATE
-    ActiveNamer	m_namer;	// Tracking of active names
-    AstCFunc*   m_scopeFinalp;	// Final function for this scope
-    bool	m_itemCombo;	// Found a SenItem combo
-    bool	m_itemSequent;	// Found a SenItem sequential
+    ActiveNamer m_namer;        // Tracking of active names
+    AstCFunc*   m_scopeFinalp;  // Final function for this scope
+    bool        m_itemCombo;    // Found a SenItem combo
+    bool        m_itemSequent;  // Found a SenItem sequential
 
     // VISITORS
     virtual void visit(AstScope* nodep) {
-	// Create required actives and add to scope
-	UINFO(4," SCOPE   "<<nodep<<endl);
-	// Clear last scope's names, and collect this scope's existing names
-	m_namer.main(nodep);
-	m_scopeFinalp = NULL;
-	nodep->iterateChildren(*this);
+        // Create required actives and add to scope
+        UINFO(4," SCOPE   "<<nodep<<endl);
+        // Clear last scope's names, and collect this scope's existing names
+        m_namer.main(nodep);
+        m_scopeFinalp = NULL;
+        iterateChildren(nodep);
     }
     virtual void visit(AstActive* nodep) {
-	// Actives are being formed, so we can ignore any already made
+        // Actives are being formed, so we can ignore any already made
     }
     virtual void visit(AstInitial* nodep) {
-	// Relink to IACTIVE, unless already under it
-	UINFO(4,"    INITIAL "<<nodep<<endl);
-	ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_INITIAL);
-	AstActive* wantactivep = m_namer.getIActive(nodep->fileline());
-	nodep->unlinkFrBack();
-	wantactivep->addStmtsp(nodep);
+        // Relink to IACTIVE, unless already under it
+        UINFO(4,"    INITIAL "<<nodep<<endl);
+        ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_INITIAL);
+        AstActive* wantactivep = m_namer.getIActive(nodep->fileline());
+        nodep->unlinkFrBack();
+        wantactivep->addStmtsp(nodep);
     }
     virtual void visit(AstAssignAlias* nodep) {
-	// Relink to CACTIVE, unless already under it
-	UINFO(4,"    ASSIGNW "<<nodep<<endl);
-	AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
-	nodep->unlinkFrBack();
-	wantactivep->addStmtsp(nodep);
+        // Relink to CACTIVE, unless already under it
+        UINFO(4,"    ASSIGNW "<<nodep<<endl);
+        AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
+        nodep->unlinkFrBack();
+        wantactivep->addStmtsp(nodep);
     }
     virtual void visit(AstAssignW* nodep) {
-	// Relink to CACTIVE, unless already under it
-	UINFO(4,"    ASSIGNW "<<nodep<<endl);
-	AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
-	nodep->unlinkFrBack();
-	wantactivep->addStmtsp(nodep);
+        // Relink to CACTIVE, unless already under it
+        UINFO(4,"    ASSIGNW "<<nodep<<endl);
+        AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
+        nodep->unlinkFrBack();
+        wantactivep->addStmtsp(nodep);
     }
     virtual void visit(AstCoverToggle* nodep) {
-	// Relink to CACTIVE, unless already under it
-	UINFO(4,"    COVERTOGGLE "<<nodep<<endl);
-	AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
-	nodep->unlinkFrBack();
-	wantactivep->addStmtsp(nodep);
+        // Relink to CACTIVE, unless already under it
+        UINFO(4,"    COVERTOGGLE "<<nodep<<endl);
+        AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
+        nodep->unlinkFrBack();
+        wantactivep->addStmtsp(nodep);
     }
     virtual void visit(AstFinal* nodep) {
-	// Relink to CFUNC for the final
-	UINFO(4,"    FINAL "<<nodep<<endl);
-	if (!nodep->bodysp()) { // Empty, Kill it.
-	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
-	    return;
-	}
-	ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_INITIAL);
-	if (!m_scopeFinalp) {
-	    m_scopeFinalp = new AstCFunc(nodep->fileline(), "_final_"+m_namer.scopep()->nameDotless(), m_namer.scopep());
-	    m_scopeFinalp->argTypes(EmitCBaseVisitor::symClassVar());
-	    m_scopeFinalp->addInitsp(new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symTopAssign()+"\n"));
-	    m_scopeFinalp->dontCombine(true);
-	    m_scopeFinalp->formCallTree(true);
-	    m_scopeFinalp->slow(true);
-	    m_namer.scopep()->addActivep(m_scopeFinalp);
-	}
-	nodep->unlinkFrBack();
-	m_scopeFinalp->addStmtsp(new AstComment(nodep->fileline(), nodep->typeName()));
-	m_scopeFinalp->addStmtsp(nodep->bodysp()->unlinkFrBackWithNext());
-	nodep->deleteTree(); VL_DANGLING(nodep);
+        // Relink to CFUNC for the final
+        UINFO(4,"    FINAL "<<nodep<<endl);
+        if (!nodep->bodysp()) {  // Empty, Kill it.
+            nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
+            return;
+        }
+        ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_INITIAL);
+        if (!m_scopeFinalp) {
+            m_scopeFinalp = new AstCFunc(
+                nodep->fileline(), "_final_"+m_namer.scopep()->nameDotless(),
+                m_namer.scopep());
+            m_scopeFinalp->argTypes(EmitCBaseVisitor::symClassVar());
+            m_scopeFinalp->addInitsp(
+                new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symTopAssign()+"\n"));
+            m_scopeFinalp->dontCombine(true);
+            m_scopeFinalp->formCallTree(true);
+            m_scopeFinalp->slow(true);
+            m_namer.scopep()->addActivep(m_scopeFinalp);
+        }
+        nodep->unlinkFrBack();
+        m_scopeFinalp->addStmtsp(new AstComment(nodep->fileline(), nodep->typeName()));
+        m_scopeFinalp->addStmtsp(nodep->bodysp()->unlinkFrBackWithNext());
+        nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
     // METHODS
     void visitAlways(AstNode* nodep, AstSenTree* oldsensesp, VAlwaysKwd kwd) {
-	// Move always to appropriate ACTIVE based on its sense list
-	if (oldsensesp
-	    && oldsensesp->sensesp()
-	    && oldsensesp->sensesp()->castSenItem()
-	    && oldsensesp->sensesp()->castSenItem()->isNever()) {
-	    // Never executing.  Kill it.
-	    if (oldsensesp->sensesp()->nextp()) nodep->v3fatalSrc("Never senitem should be alone, else the never should be eliminated.");
-	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
-	    return;
-	}
+        // Move always to appropriate ACTIVE based on its sense list
+        if (oldsensesp
+            && oldsensesp->sensesp()
+            && VN_IS(oldsensesp->sensesp(), SenItem)
+            && VN_CAST(oldsensesp->sensesp(), SenItem)->isNever()) {
+            // Never executing.  Kill it.
+            if (oldsensesp->sensesp()->nextp()) nodep->v3fatalSrc("Never senitem should be alone, else the never should be eliminated.");
+            nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
+            return;
+        }
 
-	// Read sensitivitues
-	m_itemCombo = false;
-	m_itemSequent = false;
-	if (oldsensesp) oldsensesp->iterateAndNext(*this);
-	bool combo = m_itemCombo;
-	bool sequent = m_itemSequent;
+        // Read sensitivitues
+        m_itemCombo = false;
+        m_itemSequent = false;
+        iterateAndNextNull(oldsensesp);
+        bool combo = m_itemCombo;
+        bool sequent = m_itemSequent;
 
-	if (!combo && !sequent) combo=true;	// If no list, Verilog 2000: always @ (*)
-	if (combo && sequent) {
-	    if (!v3Global.opt.bboxUnsup()) {
-		nodep->v3error("Unsupported: Mixed edge (pos/negedge) and activity (no edge) sensitive activity list");
-	    }
-	    sequent = false;
-	}
+        if (!combo && !sequent) combo=true;  // If no list, Verilog 2000: always @ (*)
+        if (combo && sequent) {
+            if (!v3Global.opt.bboxUnsup()) {
+                nodep->v3error("Unsupported: Mixed edge (pos/negedge) and activity (no edge) sensitive activity list");
+            }
+            sequent = false;
+        }
 
-	AstActive* wantactivep = NULL;
-	if (combo && !sequent) {
-	    // Combo:  Relink to ACTIVE(combo)
-	    wantactivep = m_namer.getCActive(nodep->fileline());
-	} else {
-	    // Sequential: Build a ACTIVE(name)
-	    // OPTIMIZE: We could substitute a constant for things in the sense list, for example
-	    // always (posedge RESET) { if (RESET).... }  we know RESET is true.
-	    // Summarize a long list of combo inputs as just "combo"
-#ifndef __COVERITY__ // Else dead code on next line.
-	    if (combo) oldsensesp->addSensesp
-			   (new AstSenItem(nodep->fileline(),AstSenItem::Combo()));
+        AstActive* wantactivep = NULL;
+        if (combo && !sequent) {
+            // Combo:  Relink to ACTIVE(combo)
+            wantactivep = m_namer.getCActive(nodep->fileline());
+        } else {
+            // Sequential: Build a ACTIVE(name)
+            // OPTIMIZE: We could substitute a constant for things in the sense list, for example
+            // always (posedge RESET) { if (RESET).... }  we know RESET is true.
+            // Summarize a long list of combo inputs as just "combo"
+#ifndef __COVERITY__  // Else dead code on next line.
+            if (combo) oldsensesp->addSensesp
+                           (new AstSenItem(nodep->fileline(), AstSenItem::Combo()));
 #endif
-	    wantactivep = m_namer.getActive(nodep->fileline(), oldsensesp);
-	}
+            wantactivep = m_namer.getActive(nodep->fileline(), oldsensesp);
+        }
 
-	// Delete sensitivity list
-	if (oldsensesp) {
-	    oldsensesp->unlinkFrBackWithNext()->deleteTree(); VL_DANGLING(oldsensesp);
-	}
+        // Delete sensitivity list
+        if (oldsensesp) {
+            oldsensesp->unlinkFrBackWithNext()->deleteTree(); VL_DANGLING(oldsensesp);
+        }
 
-	// Move node to new active
-	nodep->unlinkFrBack();
-	wantactivep->addStmtsp(nodep);
+        // Move node to new active
+        nodep->unlinkFrBack();
+        wantactivep->addStmtsp(nodep);
 
-	// Warn and/or convert any delayed assignments
-	if (combo && !sequent) {
-	    if (kwd == VAlwaysKwd::ALWAYS_LATCH) {
-		ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_LATCH);
-	    } else {
-		ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_COMBO);
-	    }
-	}
-	else if (!combo && sequent) {
-	    ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_SEQ);
-	}
+        // Warn and/or convert any delayed assignments
+        if (combo && !sequent) {
+            if (kwd == VAlwaysKwd::ALWAYS_LATCH) {
+                ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_LATCH);
+            } else {
+                ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_COMBO);
+            }
+        }
+        else if (!combo && sequent) {
+            ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_SEQ);
+        }
     }
     virtual void visit(AstAlways* nodep) {
-	// Move always to appropriate ACTIVE based on its sense list
-	UINFO(4,"    ALW   "<<nodep<<endl);
-	//if (debug()>=9) nodep->dumpTree(cout,"  Alw: ");
+        // Move always to appropriate ACTIVE based on its sense list
+        UINFO(4,"    ALW   "<<nodep<<endl);
+        //if (debug()>=9) nodep->dumpTree(cout, "  Alw: ");
 
-	if (!nodep->bodysp()) {
-	    // Empty always.  Kill it.
-	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
-	    return;
-	}
-	visitAlways(nodep, nodep->sensesp(), nodep->keyword());
+        if (!nodep->bodysp()) {
+            // Empty always.  Kill it.
+            nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
+            return;
+        }
+        visitAlways(nodep, nodep->sensesp(), nodep->keyword());
     }
     virtual void visit(AstAlwaysPublic* nodep) {
-	// Move always to appropriate ACTIVE based on its sense list
-	UINFO(4,"    ALWPub   "<<nodep<<endl);
-	//if (debug()>=9) nodep->dumpTree(cout,"  Alw: ");
-	visitAlways(nodep, nodep->sensesp(), VAlwaysKwd::ALWAYS);
+        // Move always to appropriate ACTIVE based on its sense list
+        UINFO(4,"    ALWPub   "<<nodep<<endl);
+        //if (debug()>=9) nodep->dumpTree(cout, "  Alw: ");
+        visitAlways(nodep, nodep->sensesp(), VAlwaysKwd::ALWAYS);
     }
     virtual void visit(AstSenGate* nodep) {
-	AstSenItem* subitemp = nodep->sensesp();
-	if (subitemp->edgeType() != AstEdgeType::ET_ANYEDGE
-	    && subitemp->edgeType() != AstEdgeType::ET_POSEDGE
-	    && subitemp->edgeType() != AstEdgeType::ET_NEGEDGE) {
-	    nodep->v3fatalSrc("Strange activity type under SenGate");
-	}
-	nodep->iterateChildren(*this);
+        AstSenItem* subitemp = nodep->sensesp();
+        if (subitemp->edgeType() != AstEdgeType::ET_ANYEDGE
+            && subitemp->edgeType() != AstEdgeType::ET_POSEDGE
+            && subitemp->edgeType() != AstEdgeType::ET_NEGEDGE) {
+            nodep->v3fatalSrc("Strange activity type under SenGate");
+        }
+        iterateChildren(nodep);
     }
     virtual void visit(AstSenItem* nodep) {
-	if (nodep->edgeType() == AstEdgeType::ET_ANYEDGE) {
-	    m_itemCombo = true;
-	    // Delete the sensitivity
-	    // We'll add it as a generic COMBO SenItem in a moment.
-	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
-	} else if (nodep->varrefp()) {
-	    // V3LinkResolve should have cleaned most of these up
-	    if (!nodep->varrefp()->width1()) nodep->v3error("Unsupported: Non-single bit wide signal pos/negedge sensitivity: "
-							    <<nodep->varrefp()->prettyName());
-	    m_itemSequent = true;
-	    nodep->varrefp()->varp()->usedClock(true);
-	}
+        if (nodep->edgeType() == AstEdgeType::ET_ANYEDGE) {
+            m_itemCombo = true;
+            // Delete the sensitivity
+            // We'll add it as a generic COMBO SenItem in a moment.
+            nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
+        } else if (nodep->varrefp()) {
+            // V3LinkResolve should have cleaned most of these up
+            if (!nodep->varrefp()->width1()) {
+                nodep->v3error("Unsupported: Non-single bit wide signal pos/negedge sensitivity: "
+                               <<nodep->varrefp()->prettyName());
+            }
+            m_itemSequent = true;
+            nodep->varrefp()->varp()->usedClock(true);
+        }
     }
 
     // Empty visitors, speed things up
@@ -419,15 +420,15 @@ private:
     virtual void visit(AstVarScope* nodep) {}
     //--------------------
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
     explicit ActiveVisitor(AstNetlist* nodep) {
-	m_scopeFinalp = NULL;
-	m_itemCombo = false;
-	m_itemSequent = false;
-	nodep->accept(*this);
+        m_scopeFinalp = NULL;
+        m_itemCombo = false;
+        m_itemSequent = false;
+        iterate(nodep);
     }
     virtual ~ActiveVisitor() {}
 };
@@ -437,6 +438,8 @@ public:
 
 void V3Active::activeAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    ActiveVisitor visitor (nodep);
+    {
+        ActiveVisitor visitor (nodep);
+    }  // Destruct before checking
     V3Global::dumpCheckGlobalTree("active", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Active.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2018 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.
@@ -20,8 +20,10 @@
 
 #ifndef _V3ACTIVE_H_
 #define _V3ACTIVE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 
@@ -32,4 +34,4 @@ public:
     static void activeAll(AstNetlist* nodep);
 };
 
-#endif // Guard
+#endif  // Guard

src/V3ActiveTop.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2018 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.
@@ -21,19 +21,14 @@
 //
 // Note this can be called multiple times.
 //   Across all ACTIVES
-//	SenTrees are now under each ACTIVE statement, we want them global:
-//	    Find SenTree in under global TopScope, or create it there
-//	    Move SenTree the global SenTree
+//      SenTrees are now under each ACTIVE statement, we want them global:
+//          Find SenTree in under global TopScope, or create it there
+//          Move SenTree the global SenTree
 //
 //*************************************************************************
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <algorithm>
-#include <vector>
 
 #include "V3Global.h"
 #include "V3ActiveTop.h"
@@ -48,108 +43,108 @@ class ActiveTopVisitor : public AstNVisitor {
 private:
     // NODE STATE
     //  Entire netlist
-    //   AstNode::user()		bool. True if processed
+    //   AstNode::user()                bool. True if processed
     //  Each call to V3Const::constify
-    //   AstNode::user4()		Used by V3Const::constify, called below
-    AstUser1InUse	m_inuser1;
+    //   AstNode::user4()               Used by V3Const::constify, called below
+    AstUser1InUse       m_inuser1;
 
     // STATE
-    AstTopScope*	m_topscopep;	// Top scope for adding sentrees under
-    SenTreeFinder	m_finder;	// Find global sentree's and add them
+    AstTopScope*        m_topscopep;    // Top scope for adding sentrees under
+    SenTreeFinder       m_finder;       // Find global sentree's and add them
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
     virtual void visit(AstTopScope* nodep) {
-	m_topscopep = nodep;
-	m_finder.main(m_topscopep);
-	nodep->iterateChildren(*this);
-	m_topscopep = NULL;
+        m_topscopep = nodep;
+        m_finder.main(m_topscopep);
+        iterateChildren(nodep);
+        m_topscopep = NULL;
     }
     virtual void visit(AstNodeModule* nodep) {
-	// Create required actives and add to module
-	// We can start ordering at a module, or a scope
-	UINFO(4," MOD   "<<nodep<<endl);
-	nodep->iterateChildren(*this);
+        // Create required actives and add to module
+        // We can start ordering at a module, or a scope
+        UINFO(4," MOD   "<<nodep<<endl);
+        iterateChildren(nodep);
     }
     virtual void visit(AstActive* nodep) {
-	UINFO(4,"   ACTIVE "<<nodep<<endl);
-	V3Const::constifyExpensiveEdit(nodep); // Remove duplicate clocks and such; sensesp() may change!
-	AstSenTree* sensesp = nodep->sensesp();
-	if (!sensesp) nodep->v3fatalSrc("NULL");
-	if (sensesp->sensesp()
-	    && sensesp->sensesp()->castSenItem()
-	    && sensesp->sensesp()->castSenItem()->isNever()) {
-	    // Never executing.  Kill it.
-	    if (sensesp->sensesp()->nextp()) nodep->v3fatalSrc("Never senitem should be alone, else the never should be eliminated.");
-	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
-	    return;
-	}
-	// Copy combo tree to settlement tree with duplicated statements
-	if (sensesp->hasCombo()) {
-	    AstSenTree* newsentreep
-		= new AstSenTree (nodep->fileline(),
-				  new AstSenItem (nodep->fileline(), AstSenItem::Settle()));
-	    AstActive* newp = new AstActive(nodep->fileline(),"settle", newsentreep);
-	    newp->sensesStorep(newsentreep);
-	    if (nodep->stmtsp()) newp->addStmtsp(nodep->stmtsp()->cloneTree(true));
-	    nodep->addNextHere(newp);
-	}
-	// Move the SENTREE for each active up to the global level.
-	// This way we'll easily see what clock domains are identical
-	AstSenTree* wantp = m_finder.getSenTree(nodep->fileline(), sensesp);
-	UINFO(4,"   lookdone\n");
-	if (wantp != sensesp) {
-	    // Move the active's contents to the other active
-	    UINFO(4,"   merge active "<<sensesp<<" into "<<wantp<<endl);
-	    if (nodep->sensesStorep()) {
-		if (sensesp != nodep->sensesStorep()) nodep->v3fatalSrc("sensesStore should have been deleted earlier if different");
-		sensesp->unlinkFrBack();
-		// There may be other references to same sense tree,
-		// we'll be removing all references when we get to them,
-		// but don't dangle our pointer yet!
-		pushDeletep(sensesp);
-	    }
-	    nodep->sensesp(wantp);
-	}
-	// No need to do statements under it, they're already moved.
-	//nodep->iterateChildren(*this);
+        UINFO(4,"   ACTIVE "<<nodep<<endl);
+        V3Const::constifyExpensiveEdit(nodep);  // Remove duplicate clocks and such; sensesp() may change!
+        AstSenTree* sensesp = nodep->sensesp();
+        if (!sensesp) nodep->v3fatalSrc("NULL");
+        if (sensesp->sensesp()
+            && VN_IS(sensesp->sensesp(), SenItem)
+            && VN_CAST(sensesp->sensesp(), SenItem)->isNever()) {
+            // Never executing.  Kill it.
+            if (sensesp->sensesp()->nextp()) {
+                nodep->v3fatalSrc("Never senitem should be alone, else the never should be eliminated.");
+            }
+            nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
+            return;
+        }
+        // Copy combo tree to settlement tree with duplicated statements
+        if (sensesp->hasCombo()) {
+            AstSenTree* newsentreep
+                = new AstSenTree(nodep->fileline(),
+                                 new AstSenItem(nodep->fileline(), AstSenItem::Settle()));
+            AstActive* newp = new AstActive(nodep->fileline(),"settle", newsentreep);
+            newp->sensesStorep(newsentreep);
+            if (nodep->stmtsp()) newp->addStmtsp(nodep->stmtsp()->cloneTree(true));
+            nodep->addNextHere(newp);
+        }
+        // Move the SENTREE for each active up to the global level.
+        // This way we'll easily see what clock domains are identical
+        AstSenTree* wantp = m_finder.getSenTree(nodep->fileline(), sensesp);
+        UINFO(4,"   lookdone\n");
+        if (wantp != sensesp) {
+            // Move the active's contents to the other active
+            UINFO(4,"   merge active "<<sensesp<<" into "<<wantp<<endl);
+            if (nodep->sensesStorep()) {
+                if (sensesp != nodep->sensesStorep()) {
+                    nodep->v3fatalSrc("sensesStore should have been deleted earlier if different");
+                }
+                sensesp->unlinkFrBack();
+                // There may be other references to same sense tree,
+                // we'll be removing all references when we get to them,
+                // but don't dangle our pointer yet!
+                pushDeletep(sensesp);
+            }
+            nodep->sensesp(wantp);
+        }
+        // No need to do statements under it, they're already moved.
+        //iterateChildren(nodep);
     }
     virtual void visit(AstInitial* nodep) {
-	nodep->v3fatalSrc("Node should have been under ACTIVE");
+        nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
     virtual void visit(AstAssignAlias* nodep) {
-	nodep->v3fatalSrc("Node should have been under ACTIVE");
+        nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
     virtual void visit(AstAssignW* nodep) {
-	nodep->v3fatalSrc("Node should have been under ACTIVE");
+        nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
     virtual void visit(AstAlways* nodep) {
-	nodep->v3fatalSrc("Node should have been under ACTIVE");
+        nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
     virtual void visit(AstAlwaysPublic* nodep) {
-	nodep->v3fatalSrc("Node should have been under ACTIVE");
+        nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
     virtual void visit(AstFinal* nodep) {
-	nodep->v3fatalSrc("Node should have been deleted");
+        nodep->v3fatalSrc("Node should have been deleted");
     }
     // Empty visitors, speed things up
     virtual void visit(AstNodeMath* nodep) {}
     virtual void visit(AstVarScope* nodep) {}
     //--------------------
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
     explicit ActiveTopVisitor(AstNetlist* nodep) {
-	m_topscopep = NULL;
-	nodep->accept(*this);
+        m_topscopep = NULL;
+        iterate(nodep);
     }
     virtual ~ActiveTopVisitor() {}
 };
@@ -159,6 +154,8 @@ public:
 
 void V3ActiveTop::activeTopAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    ActiveTopVisitor visitor (nodep);
+    {
+        ActiveTopVisitor visitor (nodep);
+    }  // Destruct before checking
     V3Global::dumpCheckGlobalTree("activetop", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3ActiveTop.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2018 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.
@@ -20,8 +20,10 @@
 
 #ifndef _V3ACTIVETOP_H_
 #define _V3ACTIVETOP_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 
@@ -32,4 +34,4 @@ public:
     static void activeTopAll(AstNetlist* nodep);
 };
 
-#endif // Guard
+#endif  // Guard

src/V3Assert.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2018 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-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.
@@ -20,11 +20,6 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <map>
-#include <iomanip>
 
 #include "V3Global.h"
 #include "V3Assert.h"
@@ -32,6 +27,9 @@
 #include "V3GraphDfa.h"
 #include "V3Stats.h"
 
+#include <cstdarg>
+#include <iomanip>
+
 //######################################################################
 // Assert class functions
 
@@ -39,308 +37,374 @@ class AssertVisitor : public AstNVisitor {
 private:
     // NODE STATE/TYPES
     // Cleared on netlist
-    //  AstNode::user()		-> bool.  True if processed
-    AstUser1InUse	m_inuser1;
+    //  AstNode::user()         -> bool.  True if processed
+    AstUser1InUse       m_inuser1;
 
     // STATE
-    AstNodeModule*	m_modp;		// Last module
-    AstBegin*	m_beginp;	// Last begin
-    V3Double0	m_statAsCover;	// Statistic tracking
-    V3Double0	m_statAsPsl;	// Statistic tracking
-    V3Double0	m_statAsFull;	// Statistic tracking
-    V3Double0	m_statAsSV;	// Statistic tracking
+    AstNodeModule*      m_modp;         // Last module
+    AstBegin*   m_beginp;       // Last begin
+    unsigned    m_modPastNum;   // Module past numbering
+    V3Double0   m_statAsCover;  // Statistic tracking
+    V3Double0   m_statAsPsl;    // Statistic tracking
+    V3Double0   m_statAsFull;   // Statistic tracking
+    V3Double0   m_statAsSV;     // Statistic tracking
 
     // METHODS
     string assertDisplayMessage(AstNode* nodep, const string& prefix, const string& message) {
-	return (string("[%0t] "+prefix+": ")+nodep->fileline()->filebasename()
-		+":"+cvtToStr(nodep->fileline()->lineno())
-		+": Assertion failed in %m"
-		+((message != "")?": ":"")+message
-		+"\n");
+        return (string("[%0t] "+prefix+": ")+nodep->fileline()->filebasename()
+                +":"+cvtToStr(nodep->fileline()->lineno())
+                +": Assertion failed in %m"
+                +((message != "")?": ":"")+message
+                +"\n");
     }
     void replaceDisplay(AstDisplay* nodep, const string& prefix) {
-	nodep->displayType(AstDisplayType::DT_WRITE);
-	nodep->fmtp()->text(assertDisplayMessage(nodep, prefix, nodep->fmtp()->text()));
-	// cppcheck-suppress nullPointer
-	AstNode* timenewp = new AstTime(nodep->fileline());
-	if (AstNode* timesp = nodep->fmtp()->exprsp()) {
-	    timesp->unlinkFrBackWithNext();
-	    timenewp->addNext(timesp);
-	}
-	nodep->fmtp()->addExprsp(timenewp);
-	if (!nodep->fmtp()->scopeNamep() && nodep->fmtp()->formatScopeTracking()) {
-	    nodep->fmtp()->scopeNamep(new AstScopeName(nodep->fileline()));
-	}
+        nodep->displayType(AstDisplayType::DT_WRITE);
+        nodep->fmtp()->text(assertDisplayMessage(nodep, prefix, nodep->fmtp()->text()));
+        // cppcheck-suppress nullPointer
+        AstNode* timenewp = new AstTime(nodep->fileline());
+        if (AstNode* timesp = nodep->fmtp()->exprsp()) {
+            timesp->unlinkFrBackWithNext();
+            timenewp->addNext(timesp);
+        }
+        nodep->fmtp()->addExprsp(timenewp);
+        if (!nodep->fmtp()->scopeNamep() && nodep->fmtp()->formatScopeTracking()) {
+            nodep->fmtp()->scopeNamep(new AstScopeName(nodep->fileline()));
+        }
     }
 
     AstNode* newIfAssertOn(AstNode* nodep) {
-	// Add a internal if to check assertions are on.
-	// Don't make this a AND term, as it's unlikely to need to test this.
-	AstNode* newp
-	    = new AstIf (nodep->fileline(),
-			 // If assertions are off, have constant propagation rip them out later
-			 // This allows syntax errors and such to be detected normally.
-			 (v3Global.opt.assertOn()
-			  ? (AstNode*)(new AstCMath(nodep->fileline(), "Verilated::assertOn()", 1))
-			  : (AstNode*)(new AstConst(nodep->fileline(), AstConst::LogicFalse()))),
-			 nodep, NULL);
-	newp->user1(true); // Don't assert/cover this if
-	return newp;
+        // Add a internal if to check assertions are on.
+        // Don't make this a AND term, as it's unlikely to need to test this.
+        FileLine* fl = nodep->fileline();
+        AstNode* newp
+            = new AstIf(fl,
+                        // If assertions are off, have constant propagation rip them out later
+                        // This allows syntax errors and such to be detected normally.
+                        (v3Global.opt.assertOn()
+                         ? static_cast<AstNode*>(new AstCMath(fl, "Verilated::assertOn()", 1))
+                         : static_cast<AstNode*>(new AstConst(fl, AstConst::LogicFalse()))),
+                        nodep, NULL);
+        newp->user1(true);  // Don't assert/cover this if
+        return newp;
+    }
+
+    AstNode* newFireAssertUnchecked(AstNode* nodep, const string& message) {
+        // Like newFireAssert() but omits the asserts-on check
+        AstDisplay* dispp = new AstDisplay(nodep->fileline(),
+                                           AstDisplayType::DT_ERROR, message, NULL, NULL);
+        AstNode* bodysp = dispp;
+        replaceDisplay(dispp, "%%Error");  // Convert to standard DISPLAY format
+        bodysp->addNext(new AstStop(nodep->fileline()));
+        return bodysp;
     }
 
     AstNode* newFireAssert(AstNode* nodep, const string& message) {
-	AstDisplay* dispp = new AstDisplay (nodep->fileline(), AstDisplayType::DT_ERROR, message, NULL, NULL);
-	AstNode* bodysp = dispp;
-	replaceDisplay(dispp, "%%Error");   // Convert to standard DISPLAY format
-	bodysp->addNext(new AstStop (nodep->fileline()));
-	bodysp = newIfAssertOn(bodysp);
-	return bodysp;
+        AstNode* bodysp = newFireAssertUnchecked(nodep, message);
+        bodysp = newIfAssertOn(bodysp);
+        return bodysp;
     }
 
     void newPslAssertion(AstNode* nodep, AstNode* propp, AstSenTree* sentreep,
-			 AstNode* stmtsp, const string& message) {
-	propp->unlinkFrBack();
-	sentreep->unlinkFrBack();
-	if (stmtsp) stmtsp->unlinkFrBack();
-	//
-	AstNode* bodysp = NULL;
-	bool selfDestruct = false;
-	if (AstPslCover* snodep = nodep->castPslCover()) {
-	    if (!v3Global.opt.coverageUser()) {
-		selfDestruct = true;
-	    } else {
-		// V3Coverage assigned us a bucket to increment.
-		AstCoverInc* covincp = snodep->coverincp()->castCoverInc();
-		if (!covincp) snodep->v3fatalSrc("Missing AstCoverInc under assertion");
-		covincp->unlinkFrBack();
-		if (message!="") covincp->declp()->comment(message);
-		bodysp = covincp;
-	    }
-	} else {
-	    nodep->v3fatalSrc("Unknown node type");
-	}
-	if (bodysp && stmtsp) bodysp = bodysp->addNext(stmtsp);
-	AstIf* ifp = new AstIf (nodep->fileline(), propp, bodysp, NULL);
-	bodysp = ifp;
-	if (nodep->castVAssert()) ifp->branchPred(AstBranchPred::BP_UNLIKELY);
-	//
-	AstNode* newp = new AstAlways (nodep->fileline(),
-				       VAlwaysKwd::ALWAYS,
-				       sentreep,
-				       bodysp);
-	// Install it
-	if (selfDestruct) {
-	    // Delete it after making the tree.  This way we can tell the user
-	    // if it wasn't constructed nicely or has other errors without needing --coverage.
-	    newp->deleteTree();
-	    nodep->unlinkFrBack();
-	} else {
-	    nodep->replaceWith(newp);
-	}
-	// Bye
-	pushDeletep(nodep); VL_DANGLING(nodep);
+                         AstNode* stmtsp, const string& message) {
+        propp->unlinkFrBack();
+        sentreep->unlinkFrBack();
+        if (stmtsp) stmtsp->unlinkFrBack();
+        //
+        AstNode* bodysp = NULL;
+        bool selfDestruct = false;
+        AstIf* ifp = NULL;
+        if (AstPslCover* snodep = VN_CAST(nodep, PslCover)) {
+            ++m_statAsCover;
+            if (!v3Global.opt.coverageUser()) {
+                selfDestruct = true;
+            } else {
+                // V3Coverage assigned us a bucket to increment.
+                AstCoverInc* covincp = VN_CAST(snodep->coverincp(), CoverInc);
+                if (!covincp) snodep->v3fatalSrc("Missing AstCoverInc under assertion");
+                covincp->unlinkFrBack();
+                if (message!="") covincp->declp()->comment(message);
+                bodysp = covincp;
+            }
+
+            if (bodysp && stmtsp) bodysp = bodysp->addNext(stmtsp);
+            ifp = new AstIf(nodep->fileline(), propp, bodysp, NULL);
+            bodysp = ifp;
+
+        } else if (VN_IS(nodep, PslAssert)) {
+            ++m_statAsPsl;
+            // Insert an automatic error message and $stop after
+            // any user-supplied statements.
+            AstNode* autoMsgp = newFireAssertUnchecked(nodep, "'assert property' failed.");
+            if (stmtsp) {
+                stmtsp->addNext(autoMsgp);
+            } else {
+                stmtsp = autoMsgp;
+            }
+            ifp = new AstIf(nodep->fileline(), propp, NULL, stmtsp);
+            // It's more LIKELY that we'll take the NULL if clause
+            // than the sim-killing else clause:
+            ifp->branchPred(AstBranchPred::BP_LIKELY);
+            bodysp = newIfAssertOn(ifp);
+        } else if (VN_IS(nodep, PslRestrict)) {
+            // IEEE says simulator ignores these
+            pushDeletep(nodep->unlinkFrBack()); VL_DANGLING(nodep);
+            return;
+        } else {
+            nodep->v3fatalSrc("Unknown node type");
+        }
+
+        AstNode* newp = new AstAlways(nodep->fileline(),
+                                      VAlwaysKwd::ALWAYS, sentreep, bodysp);
+        // Install it
+        if (selfDestruct) {
+            // Delete it after making the tree.  This way we can tell the user
+            // if it wasn't constructed nicely or has other errors without needing --coverage.
+            newp->deleteTree();
+            nodep->unlinkFrBack();
+        } else {
+            nodep->replaceWith(newp);
+        }
+        // Bye
+        pushDeletep(nodep); VL_DANGLING(nodep);
     }
 
     void newVAssertion(AstVAssert* nodep, AstNode* propp) {
-	propp->unlinkFrBackWithNext();
-	AstNode* passsp = nodep->passsp(); if (passsp) passsp->unlinkFrBackWithNext();
-	AstNode* failsp = nodep->failsp(); if (failsp) failsp->unlinkFrBackWithNext();
-	//
-	if (nodep->castVAssert()) {
-	    if (passsp) passsp = newIfAssertOn(passsp);
-	    if (failsp) failsp = newIfAssertOn(failsp);
-	} else {
-	    nodep->v3fatalSrc("Unknown node type");
-	}
+        propp->unlinkFrBackWithNext();
+        AstNode* passsp = nodep->passsp(); if (passsp) passsp->unlinkFrBackWithNext();
+        AstNode* failsp = nodep->failsp(); if (failsp) failsp->unlinkFrBackWithNext();
+        //
+        if (VN_IS(nodep, VAssert)) {
+            if (passsp) passsp = newIfAssertOn(passsp);
+            if (failsp) failsp = newIfAssertOn(failsp);
+        } else {
+            nodep->v3fatalSrc("Unknown node type");
+        }
 
-	AstIf* ifp = new AstIf (nodep->fileline(), propp, passsp, failsp);
-	AstNode* newp = ifp;
-	if (nodep->castVAssert()) ifp->branchPred(AstBranchPred::BP_UNLIKELY);
-	//
-	// Install it
-	nodep->replaceWith(newp);
-	// Bye
-	pushDeletep(nodep); VL_DANGLING(nodep);
+        AstIf* ifp = new AstIf(nodep->fileline(), propp, passsp, failsp);
+        AstNode* newp = ifp;
+        if (VN_IS(nodep, VAssert)) ifp->branchPred(AstBranchPred::BP_UNLIKELY);
+        //
+        // Install it
+        nodep->replaceWith(newp);
+        // Bye
+        pushDeletep(nodep); VL_DANGLING(nodep);
     }
 
+    // VISITORS
     virtual void visit(AstIf* nodep) {
-	if (nodep->user1SetOnce()) return;
-	if (nodep->uniquePragma() || nodep->unique0Pragma()) {
-	    AstNodeIf* ifp = nodep;
-	    AstNode* propp = NULL;
-	    bool hasDefaultElse = false;
-	    do {
-		// If this statement ends with 'else if', then nextIf will point to the
-		// nextIf statement.  Otherwise it will be null.
-		AstNodeIf* nextifp = dynamic_cast<AstNodeIf*>(ifp->elsesp());
-		ifp->condp()->iterateAndNext(*this);
+        if (nodep->user1SetOnce()) return;
+        if (nodep->uniquePragma() || nodep->unique0Pragma()) {
+            AstNodeIf* ifp = nodep;
+            AstNode* propp = NULL;
+            bool hasDefaultElse = false;
+            do {
+                // If this statement ends with 'else if', then nextIf will point to the
+                // nextIf statement.  Otherwise it will be null.
+                AstNodeIf* nextifp = dynamic_cast<AstNodeIf*>(ifp->elsesp());
+                iterateAndNextNull(ifp->condp());
 
-		// Recurse into the true case.
-		ifp->ifsp()->iterateAndNext(*this);
+                // Recurse into the true case.
+                iterateAndNextNull(ifp->ifsp());
 
-		// If the last else is not an else if, recurse into that too.
-		if (ifp->elsesp() && !nextifp) {
-		    ifp->elsesp()->iterateAndNext(*this);
-		}
+                // If the last else is not an else if, recurse into that too.
+                if (ifp->elsesp() && !nextifp) {
+                    iterateAndNextNull(ifp->elsesp());
+                }
 
-		// Build a bitmask of the true predicates
-	        AstNode* predp = ifp->condp()->cloneTree(false);
-	        if (propp) {
-		    propp = new AstConcat(nodep->fileline(), predp, propp);
-		} else {
-		    propp = predp;
-		}
+                // Build a bitmask of the true predicates
+                AstNode* predp = ifp->condp()->cloneTree(false);
+                if (propp) {
+                    propp = new AstConcat(nodep->fileline(), predp, propp);
+                } else {
+                    propp = predp;
+                }
 
-		// Record if this ends with an 'else' that does not have an if
-		if (ifp->elsesp() && !nextifp) {
-		    hasDefaultElse = true;
-		}
+                // Record if this ends with an 'else' that does not have an if
+                if (ifp->elsesp() && !nextifp) {
+                    hasDefaultElse = true;
+                }
 
-		ifp = nextifp;
-	    } while (ifp);
+                ifp = nextifp;
+            } while (ifp);
 
-	    AstNode *newifp = nodep->cloneTree(false);
-	    bool allow_none = nodep->unique0Pragma();
+            AstNode *newifp = nodep->cloneTree(false);
+            bool allow_none = nodep->unique0Pragma();
 
-	    // Empty case means no property
-	    if (!propp) propp = new AstConst(nodep->fileline(), AstConst::LogicFalse());
+            // Empty case means no property
+            if (!propp) propp = new AstConst(nodep->fileline(), AstConst::LogicFalse());
 
-	    // Note: if this ends with an 'else', then we don't need to validate that one of the
-	    // predicates evaluates to true.
-	    AstNode* ohot = ((allow_none || hasDefaultElse)
-			     ? static_cast<AstNode*>(new AstOneHot0(nodep->fileline(), propp))
-			     : static_cast<AstNode*>(new AstOneHot (nodep->fileline(), propp)));
-	    AstIf* checkifp = new AstIf (nodep->fileline(),
-					 new AstLogNot (nodep->fileline(), ohot),
-					 newFireAssert(nodep, "'unique if' statement violated"),
-					 newifp);
-	    checkifp->branchPred(AstBranchPred::BP_UNLIKELY);
-	    nodep->replaceWith(checkifp);
-	    pushDeletep(nodep);
-	} else {
-	    nodep->iterateChildren(*this);
-	}
+            // Note: if this ends with an 'else', then we don't need to validate that one of the
+            // predicates evaluates to true.
+            AstNode* ohot = ((allow_none || hasDefaultElse)
+                             ? static_cast<AstNode*>(new AstOneHot0(nodep->fileline(), propp))
+                             : static_cast<AstNode*>(new AstOneHot(nodep->fileline(), propp)));
+            AstIf* checkifp = new AstIf(nodep->fileline(),
+                                        new AstLogNot(nodep->fileline(), ohot),
+                                        newFireAssert(nodep, "'unique if' statement violated"),
+                                        newifp);
+            checkifp->branchPred(AstBranchPred::BP_UNLIKELY);
+            nodep->replaceWith(checkifp);
+            pushDeletep(nodep);
+        } else {
+            iterateChildren(nodep);
+        }
     }
 
-    // VISITORS  //========== Case assertions
+    //========== Case assertions
     virtual void visit(AstCase* nodep) {
-	nodep->iterateChildren(*this);
-	if (!nodep->user1SetOnce()) {
-	    bool has_default=false;
-	    for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
-		if (itemp->isDefault()) has_default=true;
-	    }
-	    if (nodep->fullPragma() || nodep->priorityPragma()) {
-		// Simply need to add a default if there isn't one already
-		++m_statAsFull;
-		if (!has_default) {
-		    nodep->addItemsp(new AstCaseItem(nodep->fileline(), NULL/*DEFAULT*/,
-						     newFireAssert(nodep, "synthesis full_case, but non-match found")));
-		}
-	    }
-	    if (nodep->parallelPragma() || nodep->uniquePragma() || nodep->unique0Pragma()) {
-		// Need to check that one, and only one of the case items match at any moment
-		// If there's a default, we allow none to match, else exactly one must match
-		++m_statAsFull;
-		if (!has_default && !nodep->itemsp()) {
-		    // Not parallel, but harmlessly so.
-		} else {
-		    AstNode* propp = NULL;
-		    for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
-			for (AstNode* icondp = itemp->condsp(); icondp!=NULL; icondp=icondp->nextp()) {
-			    AstNode* onep;
-			    if (nodep->casex() || nodep->casez() || nodep->caseInside()) {
-				onep = AstEqWild::newTyped(itemp->fileline(),
-							   nodep->exprp()->cloneTree(false),
-							   icondp->cloneTree(false));
-			    } else {
-				onep = AstEq::newTyped(icondp->fileline(),
-						       nodep->exprp()->cloneTree(false),
-						       icondp->cloneTree(false));
-			    }
-			    if (propp) propp = new AstConcat(icondp->fileline(), onep, propp);
-			    else propp = onep;
-			}
-		    }
-		    // Empty case means no property
-		    if (!propp) propp = new AstConst(nodep->fileline(), AstConst::LogicFalse());
+        iterateChildren(nodep);
+        if (!nodep->user1SetOnce()) {
+            bool has_default = false;
+            for (AstCaseItem* itemp = nodep->itemsp();
+                 itemp; itemp = VN_CAST(itemp->nextp(), CaseItem)) {
+                if (itemp->isDefault()) has_default = true;
+            }
+            if (nodep->fullPragma() || nodep->priorityPragma()) {
+                // Simply need to add a default if there isn't one already
+                ++m_statAsFull;
+                if (!has_default) {
+                    nodep->addItemsp(new AstCaseItem(nodep->fileline(), NULL/*DEFAULT*/,
+                                                     newFireAssert(nodep, "synthesis full_case, but non-match found")));
+                }
+            }
+            if (nodep->parallelPragma() || nodep->uniquePragma() || nodep->unique0Pragma()) {
+                // Need to check that one, and only one of the case items match at any moment
+                // If there's a default, we allow none to match, else exactly one must match
+                ++m_statAsFull;
+                if (!has_default && !nodep->itemsp()) {
+                    // Not parallel, but harmlessly so.
+                } else {
+                    AstNode* propp = NULL;
+                    for (AstCaseItem* itemp = nodep->itemsp();
+                         itemp; itemp=VN_CAST(itemp->nextp(), CaseItem)) {
+                        for (AstNode* icondp = itemp->condsp();
+                             icondp!=NULL; icondp=icondp->nextp()) {
+                            AstNode* onep;
+                            if (nodep->casex() || nodep->casez() || nodep->caseInside()) {
+                                onep = AstEqWild::newTyped(itemp->fileline(),
+                                                           nodep->exprp()->cloneTree(false),
+                                                           icondp->cloneTree(false));
+                            } else {
+                                onep = AstEq::newTyped(icondp->fileline(),
+                                                       nodep->exprp()->cloneTree(false),
+                                                       icondp->cloneTree(false));
+                            }
+                            if (propp) propp = new AstConcat(icondp->fileline(), onep, propp);
+                            else propp = onep;
+                        }
+                    }
+                    // Empty case means no property
+                    if (!propp) propp = new AstConst(nodep->fileline(), AstConst::LogicFalse());
 
-		    bool allow_none = has_default || nodep->unique0Pragma();
-		    AstNode* ohot = (allow_none
-				     ? static_cast<AstNode*>(new AstOneHot0(nodep->fileline(), propp))
-				     : static_cast<AstNode*>(new AstOneHot (nodep->fileline(), propp)));
-		    AstIf* ifp = new AstIf (nodep->fileline(),
-					    new AstLogNot (nodep->fileline(), ohot),
-					    newFireAssert(nodep, "synthesis parallel_case, but multiple matches found"),
-					    NULL);
-		    ifp->branchPred(AstBranchPred::BP_UNLIKELY);
-		    nodep->addNotParallelp(ifp);
-		}
-	    }
-	}
+                    bool allow_none = has_default || nodep->unique0Pragma();
+                    AstNode* ohot
+                        = (allow_none
+                           ? static_cast<AstNode*>(new AstOneHot0(nodep->fileline(), propp))
+                           : static_cast<AstNode*>(new AstOneHot(nodep->fileline(), propp)));
+                    AstIf* ifp = new AstIf(nodep->fileline(),
+                                           new AstLogNot(nodep->fileline(), ohot),
+                                           newFireAssert(nodep, "synthesis parallel_case, but multiple matches found"),
+                                           NULL);
+                    ifp->branchPred(AstBranchPred::BP_UNLIKELY);
+                    nodep->addNotParallelp(ifp);
+                }
+            }
+        }
     }
 
-    // VISITORS  //========== Statements
+    //========== Past
+    virtual void visit(AstPast* nodep) {
+        iterateChildren(nodep);
+        uint32_t ticks = 1;
+        if (nodep->ticksp()) {
+            if (!VN_IS(nodep->ticksp(), Const)) nodep->v3fatalSrc("Expected constant ticks, checked in V3Width");
+            ticks = VN_CAST(nodep->ticksp(), Const)->toUInt();
+        }
+        if (ticks<1) nodep->v3fatalSrc("0 tick should have been checked in V3Width");
+        AstNode* inp = nodep->exprp()->unlinkFrBack();
+        AstVar* invarp = NULL;
+        AstSenTree* sentreep = nodep->sentreep(); sentreep->unlinkFrBack();
+        AstAlways* alwaysp = new AstAlways(nodep->fileline(), VAlwaysKwd::ALWAYS,
+                                           sentreep, NULL);
+        m_modp->addStmtp(alwaysp);
+        for (uint32_t i=0; i<ticks; ++i) {
+            AstVar* outvarp = new AstVar(nodep->fileline(), AstVarType::MODULETEMP,
+                                         "_Vpast_"+cvtToStr(m_modPastNum++)+"_"+cvtToStr(i),
+                                         inp->dtypep());
+            m_modp->addStmtp(outvarp);
+            AstNode* assp = new AstAssignDly(nodep->fileline(),
+                                             new AstVarRef(nodep->fileline(), outvarp, true),
+                                             inp);
+            alwaysp->addStmtp(assp);
+            //if (debug()>-9) assp->dumpTree(cout, "-ass: ");
+            invarp = outvarp;
+            inp = new AstVarRef(nodep->fileline(), invarp, false);
+        }
+        nodep->replaceWith(inp);
+    }
+
+    //========== Statements
     virtual void visit(AstDisplay* nodep) {
-	nodep->iterateChildren(*this);
-	// Replace the special types with standard text
-	if (nodep->displayType()==AstDisplayType::DT_INFO) {
-	    replaceDisplay(nodep, "-Info");
-	} else if (nodep->displayType()==AstDisplayType::DT_WARNING) {
-	    replaceDisplay(nodep, "%%Warning");
-	} else if (nodep->displayType()==AstDisplayType::DT_ERROR
-		   || nodep->displayType()==AstDisplayType::DT_FATAL) {
-	    replaceDisplay(nodep, "%%Error");
-	}
+        iterateChildren(nodep);
+        // Replace the special types with standard text
+        if (nodep->displayType()==AstDisplayType::DT_INFO) {
+            replaceDisplay(nodep, "-Info");
+        } else if (nodep->displayType()==AstDisplayType::DT_WARNING) {
+            replaceDisplay(nodep, "%%Warning");
+        } else if (nodep->displayType()==AstDisplayType::DT_ERROR
+                   || nodep->displayType()==AstDisplayType::DT_FATAL) {
+            replaceDisplay(nodep, "%%Error");
+        }
     }
 
-    virtual void visit(AstPslCover* nodep) {
-	nodep->iterateChildren(*this);
-	if (m_beginp && nodep->name() == "") nodep->name(m_beginp->name());
-	newPslAssertion(nodep, nodep->propp(), nodep->sentreep(),
-			nodep->stmtsp(), nodep->name()); VL_DANGLING(nodep);
-	++m_statAsCover;
+    virtual void visit(AstNodePslCoverOrAssert* nodep) {
+        iterateChildren(nodep);
+        if (m_beginp && nodep->name() == "") nodep->name(m_beginp->name());
+        newPslAssertion(nodep, nodep->propp(), nodep->sentreep(),
+                        nodep->stmtsp(), nodep->name()); VL_DANGLING(nodep);
     }
     virtual void visit(AstVAssert* nodep) {
-	nodep->iterateChildren(*this);
-	newVAssertion(nodep, nodep->propp()); VL_DANGLING(nodep);
-	++m_statAsSV;
+        iterateChildren(nodep);
+        newVAssertion(nodep, nodep->propp()); VL_DANGLING(nodep);
+        ++m_statAsSV;
     }
 
     virtual void visit(AstNodeModule* nodep) {
-	m_modp = nodep;
-	//
-	nodep->iterateChildren(*this);
-	// Reset defaults
-	m_modp = NULL;
+        m_modp = nodep;
+        m_modPastNum = 0;
+        //
+        iterateChildren(nodep);
+        // Reset defaults
+        m_modp = NULL;
     }
     virtual void visit(AstBegin* nodep) {
-	// This code is needed rather than a visitor in V3Begin,
-	// because V3Assert is called before V3Begin
-	AstBegin* lastp = m_beginp;
-	{
-	    m_beginp = nodep;
-	    nodep->iterateChildren(*this);
-	}
-	m_beginp = lastp;
+        // This code is needed rather than a visitor in V3Begin,
+        // because V3Assert is called before V3Begin
+        AstBegin* lastp = m_beginp;
+        {
+            m_beginp = nodep;
+            iterateChildren(nodep);
+        }
+        m_beginp = lastp;
     }
 
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTRUCTORS
     explicit AssertVisitor(AstNetlist* nodep) {
-	m_beginp = NULL;
-	m_modp = NULL;
-	// Process
-	nodep->accept(*this);
+        m_beginp = NULL;
+        m_modp = NULL;
+        m_modPastNum = 0;
+        // Process
+        iterate(nodep);
     }
     virtual ~AssertVisitor() {
-	V3Stats::addStat("Assertions, PSL asserts", m_statAsPsl);
-	V3Stats::addStat("Assertions, SystemVerilog asserts", m_statAsSV);
-	V3Stats::addStat("Assertions, cover statements", m_statAsCover);
-	V3Stats::addStat("Assertions, full/parallel case", m_statAsFull);
+        V3Stats::addStat("Assertions, PSL asserts", m_statAsPsl);
+        V3Stats::addStat("Assertions, SystemVerilog asserts", m_statAsSV);
+        V3Stats::addStat("Assertions, cover statements", m_statAsCover);
+        V3Stats::addStat("Assertions, full/parallel case", m_statAsFull);
     }
 };
 
@@ -349,6 +413,8 @@ public:
 
 void V3Assert::assertAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    AssertVisitor visitor (nodep);
+    {
+        AssertVisitor visitor (nodep);
+    }  // Destruct before checking
     V3Global::dumpCheckGlobalTree("assert", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Assert.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2018 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-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.
@@ -20,8 +20,10 @@
 
 #ifndef _V3ASSERT_H_
 #define _V3ASSERT_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 
@@ -32,4 +34,4 @@ public:
     static void assertAll(AstNetlist* nodep);
 };
 
-#endif // Guard
+#endif  // Guard

src/V3AssertPre.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2018 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-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.
@@ -18,20 +18,17 @@
 //
 //*************************************************************************
 //  Pre steps:
-//	Attach clocks to each assertion
+//      Attach clocks to each assertion
 //*************************************************************************
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <cstdio>
-#include <cstdarg>
-#include <unistd.h>
-#include <map>
-#include <iomanip>
 
 #include "V3Global.h"
 #include "V3AssertPre.h"
-#include "V3Ast.h"
+
+#include <cstdarg>
+#include <iomanip>
 
 //######################################################################
 // Assert class functions
@@ -44,89 +41,106 @@ private:
     // NODE STATE/TYPES
     // STATE
     // Reset each module:
-    AstNodeSenItem*	m_seniDefaultp;	// Default sensitivity (from AstDefClock)
+    AstNodeSenItem* m_seniDefaultp;  // Default sensitivity (from AstDefClock)
     // Reset each assertion:
-    AstNodeSenItem*	m_senip;	// Last sensitivity
+    AstNodeSenItem* m_senip;  // Last sensitivity
+    // Reset each always:
+    AstNodeSenItem* m_seniAlwaysp;  // Last sensitivity in always
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     AstSenTree* newSenTree(AstNode* nodep) {
-	// Create sentree based on clocked or default clock
-	// Return NULL for always
-	AstSenTree* newp = NULL;
-	AstNodeSenItem* senip = m_senip ? m_senip : m_seniDefaultp;
-	if (!senip) {
-	    nodep->v3error("Unsupported: Unclocked assertion");
-	    newp = new AstSenTree(nodep->fileline(), NULL);
-	} else {
-	    newp = new AstSenTree(nodep->fileline(), senip->cloneTree(true));
-	}
-	return newp;
+        // Create sentree based on clocked or default clock
+        // Return NULL for always
+        AstSenTree* newp = NULL;
+        AstNodeSenItem* senip = m_senip;
+        if (!senip) senip = m_seniDefaultp;
+        if (!senip) senip = m_seniAlwaysp;
+        if (!senip) {
+            nodep->v3error("Unsupported: Unclocked assertion");
+            newp = new AstSenTree(nodep->fileline(), NULL);
+        } else {
+            newp = new AstSenTree(nodep->fileline(), senip->cloneTree(true));
+        }
+        return newp;
     }
     void clearAssertInfo() {
-	m_senip = NULL;
+        m_senip = NULL;
     }
 
-    // VISITORS  //========== Statements
+    // VISITORS
+    //========== Statements
     virtual void visit(AstClocking* nodep) {
-	UINFO(8,"   CLOCKING"<<nodep<<endl);
-	// Store the new default clock, reset on new module
-	m_seniDefaultp = nodep->sensesp();
-	// Trash it, keeping children
-	if (nodep->bodysp()) {
-	    nodep->replaceWith(nodep->bodysp()->unlinkFrBack());
-	} else {
-	    nodep->unlinkFrBack();
-	}
-	pushDeletep(nodep); VL_DANGLING(nodep);
+        UINFO(8,"   CLOCKING"<<nodep<<endl);
+        // Store the new default clock, reset on new module
+        m_seniDefaultp = nodep->sensesp();
+        // Trash it, keeping children
+        if (nodep->bodysp()) {
+            nodep->replaceWith(nodep->bodysp()->unlinkFrBack());
+        } else {
+            nodep->unlinkFrBack();
+        }
+        pushDeletep(nodep); VL_DANGLING(nodep);
+    }
+    virtual void visit(AstAlways* nodep) {
+        iterateAndNextNull(nodep->sensesp());
+        if (nodep->sensesp()) {
+            m_seniAlwaysp = nodep->sensesp()->sensesp();
+        }
+        iterateAndNextNull(nodep->bodysp());
+        m_seniAlwaysp = NULL;
     }
 
-    virtual void visit(AstPslCover* nodep) {
-	if (nodep->sentreep()) return;  // Already processed
-	clearAssertInfo();
-	nodep->iterateChildren(*this);
-	nodep->sentreep(newSenTree(nodep));
-	clearAssertInfo();
+    virtual void visit(AstNodePslCoverOrAssert* nodep) {
+        if (nodep->sentreep()) return;  // Already processed
+        clearAssertInfo();
+        // Find PslClocking's burried under nodep->exprsp
+        iterateChildren(nodep);
+        nodep->sentreep(newSenTree(nodep));
+        clearAssertInfo();
+    }
+    virtual void visit(AstPast* nodep) {
+        if (nodep->sentreep()) return;  // Already processed
+        iterateChildren(nodep);
+        nodep->sentreep(newSenTree(nodep));
     }
     virtual void visit(AstPslClocked* nodep) {
-	nodep->iterateChildren(*this);
-	if (m_senip) {
-	    nodep->v3error("Unsupported: Only one PSL clock allowed per assertion");
-	}
-	// Block is the new expression to evaluate
-	AstNode* blockp = nodep->propp()->unlinkFrBack();
-	if (nodep->disablep()) {
-	    blockp = new AstAnd(nodep->disablep()->fileline(),
-				new AstNot(nodep->disablep()->fileline(),
-					   nodep->disablep()->unlinkFrBack()),
-				blockp);
-	}
-	// Unlink and just keep a pointer to it, convert to sentree as needed
-	m_senip = nodep->sensesp();
-	nodep->replaceWith(blockp);
-	pushDeletep(nodep); VL_DANGLING(nodep);
+        // No need to iterate the body, once replace will get iterated
+        iterateAndNextNull(nodep->sensesp());
+        if (m_senip) {
+            nodep->v3error("Unsupported: Only one PSL clock allowed per assertion");
+        }
+        // Block is the new expression to evaluate
+        AstNode* blockp = nodep->propp()->unlinkFrBack();
+        if (nodep->disablep()) {
+            blockp = new AstAnd(nodep->disablep()->fileline(),
+                                new AstNot(nodep->disablep()->fileline(),
+                                           nodep->disablep()->unlinkFrBack()),
+                                blockp);
+        }
+        // Unlink and just keep a pointer to it, convert to sentree as needed
+        m_senip = nodep->sensesp();
+        nodep->replaceWith(blockp);
+        pushDeletep(nodep); VL_DANGLING(nodep);
     }
     virtual void visit(AstNodeModule* nodep) {
-	nodep->iterateChildren(*this);
-	// Reset defaults
-	m_seniDefaultp = NULL;
+        iterateChildren(nodep);
+        // Reset defaults
+        m_seniDefaultp = NULL;
     }
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
     // CONSTRUCTORS
     explicit AssertPreVisitor(AstNetlist* nodep) {
-	m_seniDefaultp = NULL;
-	clearAssertInfo();
-	// Process
-	nodep->accept(*this);
+        m_seniDefaultp = NULL;
+        m_seniAlwaysp = NULL;
+        clearAssertInfo();
+        // Process
+        iterate(nodep);
     }
     virtual ~AssertPreVisitor() {}
 };
@@ -136,6 +150,8 @@ public:
 
 void V3AssertPre::assertPreAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    AssertPreVisitor visitor (nodep);
+    {
+        AssertPreVisitor visitor (nodep);
+    }  // Destruct before checking
     V3Global::dumpCheckGlobalTree("assertpre", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3AssertPre.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2018 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-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.
@@ -20,8 +20,10 @@
 
 #ifndef _V3ASSERTPRE_H_
 #define _V3ASSERTPRE_H_ 1
+
 #include "config_build.h"
 #include "verilatedos.h"
+
 #include "V3Error.h"
 #include "V3Ast.h"
 
@@ -32,4 +34,4 @@ public:
     static void assertPreAll(AstNetlist* nodep);
 };
 
-#endif // Guard
+#endif  // Guard

src/V3AstConstOnly.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2018 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.
@@ -30,4 +30,4 @@
 #define deleteTree       error_no_deleteTree_in_ConstOnlyVisitor
 #define unlinkFrBack     error_no_unlinkFrBack_in_ConstOnlyVisitor
 
-#endif // Guard
+#endif  // Guard