Version bump

set DIRPROJECT_PERL_BOOT to a script for bin/verilator to call to do setup.

.gitignore

@@ -1,3 +1,4 @@
+*~
 *.old
 *.gz
 *.gz.uu
@@ -7,7 +8,7 @@
 *.1
 *.tmp
 *.tex
-Makefile
+/Makefile
 README
 config.cache
 config.status

Artistic

@@ -0,0 +1,197 @@
+Artistic License 2.0
+
+Copyright (c) 2000-2006, The Perl Foundation.
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+Preamble
+********
+
+This license establishes the terms under which a given free software
+Package may be copied, modified, distributed, and/or redistributed.  The
+intent is that the Copyright Holder maintains some artistic control over
+the development of that Package while still keeping the Package
+available as open source and free software.
+
+You are always permitted to make arrangements wholly outside of this
+license directly with the Copyright Holder of a given Package.  If the
+terms of this license do not permit the full use that you propose to
+make of the Package, you should contact the Copyright Holder and seek a
+different licensing arrangement.
+
+Definitions
+***********
+
+"Copyright Holder" means the individual(s) or organization(s) named in
+the copyright notice for the entire Package.
+
+"Contributor" means any party that has contributed code or other
+material to the Package, in accordance with the Copyright Holder's
+procedures.
+
+"You" and "your" means any person who would like to copy, distribute, or
+modify the Package.
+
+"Package" means the collection of files distributed by the Copyright
+Holder, and derivatives of that collection and/or of those files.  A
+given Package may consist of either the Standard Version, or a Modified
+Version.
+
+"Distribute" means providing a copy of the Package or making it
+accessible to anyone else, or in the case of a company or organization,
+to others outside of your company or organization.
+
+"Distributor Fee" means any fee that you charge for Distributing this
+Package or providing support for this Package to another party.  It does
+not mean licensing fees.
+
+"Standard Version" refers to the Package if it has not been modified, or
+has been modified only in ways explicitly requested by the Copyright
+Holder.
+
+"Modified Version" means the Package, if it has been changed, and such
+changes were not explicitly requested by the Copyright Holder.
+
+"Original License" means this Artistic License as Distributed with the
+Standard Version of the Package, in its current version or as it may be
+modified by The Perl Foundation in the future.
+
+"Source" form means the source code, documentation source, and
+configuration files for the Package.
+
+"Compiled" form means the compiled bytecode, object code, binary, or any
+other form resulting from mechanical transformation or translation of
+the Source form.
+
+Permission for Use and Modification Without Distribution
+********************************************************
+
+(1) You are permitted to use the Standard Version and create and use
+Modified Versions for any purpose without restriction, provided that you
+do not Distribute the Modified Version.
+
+Permissions for Redistribution of the Standard Version
+******************************************************
+
+(2) You may Distribute verbatim copies of the Source form of the
+Standard Version of this Package in any medium without restriction,
+either gratis or for a Distributor Fee, provided that you duplicate all
+of the original copyright notices and associated disclaimers.  At your
+discretion, such verbatim copies may or may not include a Compiled form
+of the Package.
+
+(3) You may apply any bug fixes, portability changes, and other
+modifications made available from the Copyright Holder.  The resulting
+Package will still be considered the Standard Version, and as such will
+be subject to the Original License.
+
+Distribution of Modified Versions of the Package as Source
+**********************************************************
+
+(4) You may Distribute your Modified Version as Source (either gratis or
+for a Distributor Fee, and with or without a Compiled form of the
+Modified Version) provided that you clearly document how it differs from
+the Standard Version, including, but not limited to, documenting any
+non-standard features, executables, or modules, and provided that you do
+at least ONE of the following:
+
+(a) make the Modified Version available to the Copyright Holder of the
+Standard Version, under the Original License, so that the Copyright
+Holder may include your modifications in the Standard Version.
+
+(b) ensure that installation of your Modified Version does not prevent
+the user installing or running the Standard Version.  In addition, the
+Modified Version must bear a name that is different from the name of the
+Standard Version.
+
+(c) allow anyone who receives a copy of the Modified Version to make the
+Source form of the Modified Version available to others under
+
+(i) the Original License or
+
+(ii) a license that permits the licensee to freely copy, modify and
+redistribute the Modified Version using the same licensing terms that
+apply to the copy that the licensee received, and requires that the
+Source form of the Modified Version, and of any works derived from it,
+be made freely available in that license fees are prohibited but
+Distributor Fees are allowed.
+
+Distribution of Compiled Forms of the Standard Version or Modified
+******************************************************************
+Versions without the Source
+***************************
+
+(5) You may Distribute Compiled forms of the Standard Version without
+the Source, provided that you include complete instructions on how to
+get the Source of the Standard Version.  Such instructions must be valid
+at the time of your distribution.  If these instructions, at any time
+while you are carrying out such distribution, become invalid, you must
+provide new instructions on demand or cease further distribution.  If
+you provide valid instructions or cease distribution within thirty days
+after you become aware that the instructions are invalid, then you do
+not forfeit any of your rights under this license.
+
+(6) You may Distribute a Modified Version in Compiled form without the
+Source, provided that you comply with Section 4 with respect to the
+Source of the Modified Version.
+
+Aggregating or Linking the Package
+**********************************
+
+(7) You may aggregate the Package (either the Standard Version or
+Modified Version) with other packages and Distribute the resulting
+aggregation provided that you do not charge a licensing fee for the
+Package.  Distributor Fees are permitted, and licensing fees for other
+components in the aggregation are permitted.  The terms of this license
+apply to the use and Distribution of the Standard or Modified Versions
+as included in the aggregation.
+
+(8) You are permitted to link Modified and Standard Versions with other
+works, to embed the Package in a larger work of your own, or to build
+stand-alone binary or bytecode versions of applications that include the
+Package, and Distribute the result without restriction, provided the
+result does not expose a direct interface to the Package.
+
+Items That are Not Considered Part of a Modified Version
+********************************************************
+
+(9) Works (including, but not limited to, modules and scripts) that
+merely extend or make use of the Package, do not, by themselves, cause
+the Package to be a Modified Version.  In addition, such works are not
+considered parts of the Package itself, and are not subject to the terms
+of this license.
+
+General Provisions
+******************
+
+(10) Any use, modification, and distribution of the Standard or Modified
+Versions is governed by this Artistic License.  By using, modifying or
+distributing the Package, you accept this license.  Do not use, modify,
+or distribute the Package, if you do not accept this license.
+
+(11) If your Modified Version has been derived from a Modified Version
+made by someone other than you, you are nevertheless required to ensure
+that your Modified Version complies with the requirements of this
+license.
+
+(12) This license does not grant you the right to use any trademark,
+service mark, tradename, or logo of the Copyright Holder.
+
+(13) This license includes the non-exclusive, worldwide, free-of-charge
+patent license to make, have made, use, offer to sell, sell, import and
+otherwise transfer the Package with respect to any patent claims
+licensable by the Copyright Holder that are necessarily infringed by the
+Package.  If you institute patent litigation (including a cross-claim or
+counterclaim) against any party alleging that the Package constitutes
+direct or contributory patent infringement, then this Artistic License
+to you shall terminate on the date that such litigation is filed.
+
+(14) Disclaimer of Warranty: THE PACKAGE IS PROVIDED BY THE COPYRIGHT
+HOLDER AND CONTRIBUTORS "AS IS' AND WITHOUT ANY EXPRESS OR IMPLIED
+WARRANTIES.  THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT
+PERMITTED BY YOUR LOCAL LAW.  UNLESS REQUIRED BY LAW, NO COPYRIGHT
+HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE
+OF THE PACKAGE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

COPYING

@@ -1,285 +1,626 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
 
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
- 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ 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
+                            Preamble
 
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
+  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
-this service 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.
+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 make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
+  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 give the recipients all the rights that
-you have.  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.
+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.
 
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
+  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.
 
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
+  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.
 
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
+  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.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
+                       TERMS AND CONDITIONS
 
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
+  0. Definitions.
 
-  1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
+  "This License" refers to version 3 of the GNU General Public License.
 
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
 
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
+  "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.
 
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
+  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.
 
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
 
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
+  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.
 
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
+  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.
 
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
+  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.
 
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
+  1. Source Code.
 
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
+  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.
 
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
+  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.
 
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
+  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 source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
+  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.
 
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
 
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
+  The Corresponding Source for a work in source code form is that
+same work.
 
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
+  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.
 
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
+  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
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
+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.
 
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
+  13. Use with the GNU Affero General Public License.
 
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
+  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.
 
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
+  14. Revised Versions of this License.
 
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
+  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 a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
+  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.
 
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
+  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.
 
-			    NO WARRANTY
+  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.
 
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
+  15. Disclaimer of Warranty.
 
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE 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.
+  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.
 
-		     END OF TERMS AND CONDITIONS
-
-	Appendix: How to Apply These Terms to Your New Programs
+  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
@@ -287,15 +628,15 @@ 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
-convey the exclusion of warranty; and each file should have at least
+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) 19yy  <name of author>
+    Copyright (C) <year>  <name of author>
 
-    This program is free software; you can redistribute it and/or modify
+    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 2 of the License, or
+    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,
@@ -304,36 +645,30 @@ the "copyright" line and a pointer to where the full notice is found.
     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, write to the Free Software
-    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+    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 is interactive, make it output a short notice like this
-when it starts in an interactive mode:
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
 
-    Gnomovision version 69, Copyright (C) 19yy name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    <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, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
+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 your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
+  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/>.
 
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This 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 Library General
-Public License instead of this License.
+  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>.

MANIFEST.SKIP

@@ -0,0 +1,28 @@
+^CVS/
+/CVS/
+\.git/
+\.svn/
+\.(bak|old)/
+\.(bak|old)$
+\bMakefile$
+\.tar\.
+.*\.tgz
+.*\.log
+.*\.tmp
+.*\.tex
+.*\.key
+.*\.vcd
+/obj_dir/
+/obj_dbg/
+/obj_opt/
+/INCA_libs/
+/cov_work/
+/logs/
+Makefile
+src/Makefile_obj
+include/verilated.mk
+config.cache
+config.status
+verilator_bin.*
+autom4te\.cache/
+nodist/

Makefile.in

@@ -1,24 +1,24 @@
-# $Id$
 #*****************************************************************************
 # DESCRIPTION: Verilator top level: Makefile pre-configure version
-# 
-# This file is part of Verilator.  
-# 
-# Author: Wilson Snyder <[email protected]> or <[email protected]>
-# 
-# Code available from: http://www.veripool.com/verilator
-# 
+#
+# This file is part of Verilator.
+#
+# Author: Wilson Snyder <[email protected]>
+#
+# Code available from: http://www.veripool.org/verilator
+#
 #*****************************************************************************
-# 
-# Copyright 2003-2007 by Wilson Snyder. This program is free software; you can
+#
+# Copyright 2003-2009 by Wilson Snyder. This program is free software; you can
 # redistribute it and/or modify it under the terms of either the GNU
-# General Public License or the Perl Artistic License.
-# 
+# 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.
-# 
+#
 #****************************************************************************/
 #
 # make all	to compile and build Verilator.
@@ -38,7 +38,7 @@
 #      source and built the program without creating any other files,
 #      `make distclean' should leave only the files that were in the
 #      distribution.
-# 
+#
 # make maintainer-clean
 #      Delete everything from the current directory that can be
 #      reconstructed with this Makefile.  This typically includes
@@ -61,6 +61,9 @@ MAKEINFO = makeinfo
 TEXI2DVI = texi2dvi
 PERL = @PERL@
 
+# Destination prefix for RPMs
+DESTDIR =
+
 #### Don't edit: You're much better using configure switches to set these
 prefix = @prefix@
 exec_prefix = @exec_prefix@
@@ -78,8 +81,15 @@ datadir = @datadir@
 infodir = @infodir@
 
 # Directory in which to install package specific files
+# Generally ${prefix}/share/verilator
 pkgdatadir = @pkgdatadir@
 
+# Directory in which to install data across multiple architectures
+datarootdir = @datarootdir@
+
+# Compile options
+CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
+
 #### End of system configuration section. ####
 ######################################################################
 
@@ -94,26 +104,33 @@ DISTDEP = info Makefile
 # Files to distribute.
 DISTBIN = $(wildcard bin/verilator-*)
 
-DISTFILES_INC = $(INFOS) .cvsignore COPYING *.in *.ac \
+DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING *.in *.ac \
 	Changes README TODO \
+	MANIFEST.SKIP \
 	bin/* \
 	install-sh configure mkinstalldirs *.texi \
-	include/verilated.[chv]* \
-	include/verilatedos.[chv]* \
+	include/verilated*.[chv]* \
 	include/*.in \
-	src/.cvsignore src/*.in src/*.cpp src/*.[chly] src/astgen src/flexfix \
-	src/*.pl \
-	test_*/.cvsignore test_*/Makefile* test_*/*.cpp \
+	include/.*ignore \
+	.*attributes */.*attributes  */*/.*attributes \
+	src/.*ignore src/*.in src/*.cpp src/*.[chly] src/astgen src/bisonpre src/*fix \
+	src/*.pl src/*.pod \
+	test_*/.*ignore test_*/Makefile* test_*/*.cpp \
 	test_*/*.pl test_*/*.v test_*/*.vc test_*/vlint \
 	test_verilated/vgen*.pl \
-	test_regress/t/*.v* \
-	test_regress/t/*.pl \
+	test_regress/t/*.cpp \
+	test_regress/t/*.h \
+	test_regress/t/*.dat \
+	test_regress/t/*.mem \
 	test_regress/t/*.out \
+	test_regress/t/*.pl \
+	test_regress/t/*.v* \
 	verilator.* \
 
 INST_PROJ_FILES = \
 	bin/verilator \
 	bin/verilator_includer \
+	bin/verilator_profcfunc \
 	include/verilated.[chv]* \
 	include/verilated.mk \
 	include/verilatedos.[chv]* \
@@ -124,8 +141,10 @@ INST_PROJ_BIN_FILES = \
 
 DISTFILES := $(DISTFILES_INC)
 
+VL_INST_MAN_FILES = verilator.1
+
 all: all_nomsg msg_test
-all_nomsg: verilator_exe
+all_nomsg: verilator_exe $(VL_INST_MAN_FILES)
 
 .PHONY:verilator_exe
 verilator_exe verilator_bin verilator_bin_dbg:
@@ -140,6 +159,7 @@ msg_test:
 	@echo "Type 'make test' to test."
 	@echo
 
+.PHONY:test
 ifeq ($(VERILATOR_AUTHOR_SITE),1)	# Local... Else don't burden users
 test: test_vcs test_c test_sc test_sp test_verilated test_regress
 else
@@ -184,16 +204,18 @@ verilator.html: bin/verilator
 verilator.pdf: bin/verilator $(DISTCONFIG)
 	pod2latex --full --out verilator.tex bin/verilator
 	cat < verilator.tex \
+	   | sed 's/\\begin{document}/\\usepackage[left=1.7in,right=1.7in,top=1.3in,bottom=1.3in]{geometry}\n\\begin{document}/' \
+	   | sed 's/\\begin{document}/\\usepackage[pdftex,bookmarks=true,bookmarksnumbered=true,hypertexnames=false,breaklinks=true,linkbordercolor={0 0 1}]{hyperref}\n\\begin{document}/' \
 	   | sed 's/\\begin{document}/\\usepackage{fancyhdr} \\pagestyle{fancy}\n\\begin{document}/' \
 	   | sed 's/\\begin{document}/\\setlength{\\parindent}{0pt} \\setlength{\\parskip}{\\baselineskip}\n\\begin{document}/' \
-	   | sed 's/\\begin{document}/\\title{$(DISTTITLE)} \\date{${DISTDATE}} \\author{Wilson Snyder\\\\ http:\/\/www.veripool.com}\n\\begin{document}/' \
+	   | sed 's/\\begin{document}/\\title{$(DISTTITLE)} \\date{${DISTDATE}} \\author{Wilson Snyder\\\\ http:\/\/www.veripool.org}\n\\begin{document}/' \
 	   | sed 's/\\begin{document}/\\lhead[$(DISTTITLE)]{$(DISTTITLE)}\n\\begin{document}/' \
 	   | sed 's/\\tableofcontents/\\begin{titlepage} \\maketitle \\end{titlepage}\n\\tableofcontents/' \
 	   > verilator2.tex
 	mv verilator2.tex verilator.tex
 	pdflatex verilator.tex
 	pdflatex verilator.tex
-	-rm -f verilator.toc verilator.aux verilator.idx
+	-rm -f verilator.toc verilator.aux verilator.idx verilator.out
 
 INSTALL: install.texi
 	$(MAKEINFO) -I$(srcdir) $(srcdir)/install.texi --output=$@ \
@@ -203,21 +225,36 @@ README: readme.texi
 	$(MAKEINFO) -I$(srcdir) $(srcdir)/readme.texi --output=$@ \
 	--no-headers --no-validate
 
-installdirs:
-	$(SHELL) ${srcdir}/mkinstalldirs $(bindir) $(infodir)
-
 # See uninstall also
-VL_INST_BIN_FILES = verilator
+VL_INST_BIN_FILES = verilator verilator_bin verilator_bin_dbg \
+	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.
 installbin:
-	( cd bin ; $(INSTALL_PROGRAM) verilator $(bindir)/verilator )
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(bindir)
+	( cd bin ; $(INSTALL_PROGRAM) verilator $(DESTDIR)$(bindir)/verilator )
+	( cd bin ; $(INSTALL_PROGRAM) verilator_profcfunc $(DESTDIR)$(bindir)/verilator_profcfunc )
+	( $(INSTALL_PROGRAM) verilator_bin $(DESTDIR)$(bindir)/verilator_bin )
+	( $(INSTALL_PROGRAM) verilator_bin_dbg $(DESTDIR)$(bindir)/verilator_bin_dbg )
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/bin
+	( cd bin ; $(INSTALL_PROGRAM) verilator_includer $(DESTDIR)$(pkgdatadir)/bin/verilator_includer )
 
-VL_INST_MAN_FILES = verilator.1
 installman:
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(mandir)/man1
 	for p in $(VL_INST_MAN_FILES) ; do \
-	  $(INSTALL_PROGRAM) $$p $(mandir)/man1/$$p; \
+	  $(INSTALL_PROGRAM) $$p $(DESTDIR)$(mandir)/man1/$$p; \
 	done
 
-install: all_nomsg installdirs installbin installman install-msg
+installdata:
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples
+	cp -r include $(DESTDIR)$(pkgdatadir)
+	cp -r test_c  $(DESTDIR)$(pkgdatadir)/examples
+	cp -r test_sc $(DESTDIR)$(pkgdatadir)/examples
+	cp -r test_sp $(DESTDIR)$(pkgdatadir)/examples
+	cp -r test_v  $(DESTDIR)$(pkgdatadir)/examples
+
+VL_INST_DATA_FILES = verilator.1
+install: all_nomsg installbin installman installdata install-msg
 
 install-here: installman ftp
 
@@ -232,10 +269,14 @@ install-project: dist
 	for p in verilator.1 ; do \
 	  $(INSTALL_PROGRAM) -m 0666 $$p $(DIRPROJECT_PREFIX)/man/man1/$$p; \
 	done
-	$(INST_PROJ_CVS) $(DISTNAME).tar.gz $(DIRPROJECT)/hw/utils/verilator/verilator.tgz
-	rm $(DISTNAME).tar.gz
+	$(INST_PROJ_CVS) $(DISTNAME).tgz $(DIRPROJECT)/hw/utils/verilator/verilator.tgz
+	rm $(DISTNAME).tgz
 
 install-project-quick:
+ifeq ($(CFG_WITH_DEFENV),yes)
+	@echo "%Error: Reconfigure with './configure --disable-defenv' to avoid hardcoded paths."
+	false
+endif
 	@echo "Install-project-quick (no strip) to $(DIRPROJECT)"
 	for p in $(INST_PROJ_FILES) ; do \
 	  $(INST_PROJ_CVS) $$p $(DIRPROJECT)/hw/utils/verilator/$$p; \
@@ -246,9 +287,6 @@ install-project-quick:
 endif
 
 ftp: info
-	echo "http://www.veripool.com/verilator3.html"
-	cp verilator.html verilator_man.html
-	ftp_tree --password $(VERIPOOL_PW) --user $(VERIPOOL_USER) verilator_man.html webftp.veripool.com:/web
 
 install-msg:
 	@echo "Installed!"
@@ -261,8 +299,9 @@ install-msg:
 	@echo
 
 uninstall:
-	-cd $(mandir)/man1 && rm -f $(VL_INST_MAN_FILES)
-	-cd $(bindir) && rm -f $(VL_INST_BIN_FILES)
+	-cd $(DESTDIR)$(mandir)/man1 && rm -f $(VL_INST_MAN_FILES)
+	-cd $(DESTDIR)$(bindir) && rm -f $(VL_INST_BIN_FILES)
+	-rm -f $(DESTDIR)$(pkgdatadir)
 
 # autoheader might not change config_build.h.in, so touch a stamp file.
 IN_WILD := ${srcdir}/*.in ${srcdir}/*/*.in ${srcdir}/*/*/*.in \
@@ -287,7 +326,7 @@ configure: configure.ac
 maintainer-clean::
 	@echo "This command is intended for maintainers to use;"
 	@echo "rebuilding the deleted files requires makeinfo."
-	rm -f *.info* $(INFOS) faq.html verilator.html configure bin/*
+	rm -f *.info* $(INFOS) faq.html verilator.html configure
 
 clean mostlyclean distclean maintainer-clean maintainer-copy::
 	for dir in $(SUBDIRS); do \
@@ -296,7 +335,7 @@ clean mostlyclean distclean maintainer-clean maintainer-copy::
 	done
 
 clean mostlyclean distclean maintainer-clean::
-	rm -f $(SCRIPTS) *.tmp 
+	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
@@ -312,6 +351,13 @@ TAGFILES=${srcdir}/*/*.cpp ${srcdir}/*/*.h ${srcdir}/*/[a-z]*.in \
 TAGS:	$(TAGFILES)
 	etags $(TAGFILES)
 
+######################################################################
+# Test targets
+
+dist-file-list:
+	@echo "begin-dist-file-list:";  # Scripts look for this
+	@echo $(wildcard $(DISTFILES))
+	@echo "end-dist-file-list:";  # Scripts look for this
 
 ######################################################################
 # Distributions
@@ -320,7 +366,7 @@ DISTCONFIG = src/config_build.h.in
 
 DISTTITLE := $(shell sed -e '/DTVERSION/!d' -e 's/[^0-9]*\([0-9.a-z]*\).*/verilator-\1/' -e 's/v/V/' -e q $(DISTCONFIG))
 DISTNAME := $(shell sed -e '/DTVERSION/!d' -e 's/[^0-9]*\([0-9.a-z]*\).*/verilator-\1/' -e q $(DISTCONFIG))
-DISTDATEPRE := $(shell sed -e '/DTVERSION/!d' -e 's/.*\([0-3]\?[0-9].[0-3]\?[0-9].[1-2][0-9][0-9][0-9]\).*/\1/' -e q $(DISTCONFIG))
+DISTDATEPRE := $(shell sed -e '/DTVERSION/!d' -e 's/.*\([1-2][0-9][0-9][0-9].[0-9]*[0-9].[0-9]*[0-9]\).*/\1/' -e q $(DISTCONFIG))
 
 DISTTAGNAME := $(subst .,_,$(subst -,_,$(DISTNAME)))
 DISTDATE := $(subst /,-,$(DISTDATEPRE))
@@ -339,14 +385,14 @@ dist: $(DISTDEP) maintainer-copy
 	chmod -R a+r $(DISTNAME)
 	tar chf $(DISTNAME).tar $(DISTNAME)
 	gzip --force --best $(DISTNAME).tar
+	mv $(DISTNAME).tar.gz $(DISTNAME).tgz
 	rm -fr $(DISTNAME)
 
 maintainer-diff:
 	svnorcvs diff $(DISTTAGNAME)
 
 preexist:
-	test ! -r ~/src/kits/$(DISTNAME).tar.gz
+	svnorcvs nexists $(DISTTAGNAME)
 
 maintainer-dist: preexist dist tag
-	cp *.gz ~/backpack
-	cp *.gz ~/src/kits
+	svnorcvs release $(DISTNAME).tgz

README

@@ -1,167 +0,0 @@
-1 Verilator
-***********
-
-This is the Verilator Package.
-
-1.1 Copyright
-=============
-
-This package is Copyright 2003-2007 by Wilson Snyder
-<[email protected]>.
-
-   You may distribute under the terms of either the GNU General Public
-License or the Artistic License, as specified in the Perl README file.
-
-   This code is provided with no warranty of any kind, and is used
-entirely at your own risk.
-
-1.2 Description
-===============
-
-Verilator converts synthesizable (not behavioral) Verilog code into C++
-or SystemC code.  It is not a complete simulator, just a translator.
-
-   Verilator is invoked with parameters similar to GCC or Synopsys's
-VCS.  It reads the specified Verilog code, lints it, and optionally
-adds coverage code.  For C++ format, it outputs .cpp and .h files.  For
-SystemC format, it outputs .sp files for the SystemPerl preprocessor
-available at http://veripool.com.
-
-   The resulting files are then compiled with C++.  The user writes a
-little C++ wrapper file, which instantiates the top level module.  This
-is compiled in C++, and linked with the Verilated files.
-
-   The resulting executable will perform the actual simulation.
-
-1.3 Obtaining Distribution
-==========================
-
-The latest version is available at `http://veripool.com/verilator.htm'
-
-   Download the latest package from that site, and decompress.  `gunzip
-verilator_version.tar.gz ; tar xvf verilator_version.tar'
-
-1.4 Directory Structure
-=======================
-
-The directories after de-taring are as follows:
-
-   * bin/verilator	     => Compiler Wrapper invoked on user Verilog 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
-
-   * test_v		     => Example Verilog code for other test dirs
-
-   * test_c		     => Example Verilog->C++ conversion
-
-   * test_sc		     => Example Verilog->SystemC conversion
-
-   * test_sp		     => Example Verilog->SystemPerl conversion
-
-   * test_vcs		     => Example Verilog->VCS conversion (test the
-     test)
-
-   * test_verilated	     => Internal tests
-
-   * test_regress	     => Internal tests
-
-1.5 Supported Systems
-=====================
-
-This version of verilator has been built and tested on:
-
-   * SuSE AMD64 i686-linux-2.6.5
-
-   Other users report success with Redhat Linux 2.4, Windows under
-Cygwin, HPUX and Solaris.  It should run with minor porting on any Unix
-system.
-
-1.6 Installation
-================
-
-  1. If you will be using SystemC (vs straight C++ output), download
-     SystemC 2.0.1 from `http://www.systemc.org'.  Follow their
-     installation instructions.  As described in the System-Perl README,
-     you will need to set SYSTEMC and/or SYSTEMC_KIT to point to this
-     download.  Also, set SYSTEMC_ARCH to the architecture name you used
-     with SystemC, generally 'linux' or 'cygwin'.
-
-  2. If you will be using SystemC, download and install Verilog-Perl,
-     `http://search.cpan.org/search?module=Verilog::Language'.
-
-  3. If you will be using SystemC, download and install System-Perl,
-     `http://search.cpan.org/search?module=SystemC::Netlist'.  Note
-     you'll need to set a `SYSTEMPERL' environment variable to point to
-     the downloaded kit (not the installed files.)  Also, make sure to
-     do a `make sc_patch'.
-
-  4. `cd' to the Verilator directory containing this README.
-
-  5. Type `./configure' to configure Verilator for your system.
-
-  6. Type `make' to compile Verilator.
-
-     On Cygwin (Windows) you may get a error about libperl.a not being
-     found.  You need to copy your perl libraries as follows.
-
-       1.   Type `perl -MExtUtils::Embed -e ldopts'
-
-       2.   It will show a directory name ending in /CORE.  cd to that
-          directory.
-
-       3.   `cp libperl5_6_1.a libperl.a'
-
-       4.   `cp libperl5_6_1.dll libperl.dll'
-
-       5.   `cp libperl5_6_1.def libperl.def'
-
-  7. Type `make test' to check the compilation.
-
-     You may get a error about the Bit::Vector perl package.  You will
-     need to install it if you want the tests to pass.  (Try `make
-     test_c' for a smaller test that doesn't require it.)
-
-     You may get a error about a typedef conflict for uint32_t.  Edit
-     verilated.h to change the typedef to work, probably to `typedef
-     unsigned long uint32_t;'.
-
-     If you get warnings, you might want to edit `include/verilated.mk'
-     to delete the lines that define VK_CPPFLAGS_WALL.
-
-  8.  There is no installation at present; this package runs from the
-     distribution directory.  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.
-
-     Verilator assumes you did a make in the SystemC kit directory.  If
-     not, you will need to populate `$SYSTEMC/include' and
-     `$SYSTEMC/lib-linux' appropriately.
-
-     If you will be modifying Verilator, you will probably want a second
-     stable copy of this kit for others to use while you experiment.
-
-  9. 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.
-
-
-1.7 Limitations
-===============
-
-See verilator.txt (or execute `bin/verilator --help') for limitations.
-

TODO

@@ -1,13 +1,13 @@
-// $Id$
 // DESCRIPTION: Verilator: List of To Do issues.
 //
-// Copyright 2004-2007 by Wilson Snyder. This program is free software; you can
+// Copyright 2004-2009 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
 
 
 Features:
- 	Finish 3.400 new ordering fixes
+	Finish 3.400 new ordering fixes
 	Latch optimizations {Need here}
 	Task I/Os connecting to non-simple variables.
 	Fix nested casez statements expanding into to huge C++. [JeanPaul Vanitegem]
@@ -25,12 +25,13 @@ Features:
 	Coverage
 		Points should be per-scope like everything else rather then per-module
 		Expression coverage (see notes)
+	Constant functions for widths, etc, IE   "input [log2(PARAM):0] xx;"
 	More Verilog 2001 Support
-		C-style function and task arguments.  [Wim Michiels]
 		(* *) Attributes  (just ignore -- preprocessor?)
 		Real numbers (NEVER)
 		Recursive functions (NEVER)
 		Verilog configuration files (NEVER)
+	DPI to define C/C++ calls from Verilog
 
 Long-term Features
 	Assertions
@@ -49,7 +50,12 @@ Testing:
 
 Usability:
 	Better reporting of unopt problems, including what lines of code
-	Report more errors (all of them?) before exiting [Eugene Weber]	
+	Report more errors (all of them?) before exiting [Eugene Weber]
+
+Internal Code:
+	Eliminate the AstNUser* passed to all visitors; its only needed in V3Width,
+	and removing it will speed up and simplify all the other code.
+	V3Graph should be templated container type, taking in Vertex + Edge types
 
 Performance:
 	Constant propagation
@@ -64,7 +70,7 @@ Performance:
 	Multithreaded execution
 	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 
+		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
@@ -103,6 +109,12 @@ Performance:
 	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)
 
+	All of the temp vars that get set, exp pre_ vars and never feedback
+	(not flops) don't need to be stored in the structs, but instead can
+	be per-invocation, and even better register-colored-like to reuse
+	the space.  This will greatly reduce the data footprint.
+
+
 //**********************************************************************
 //* Detailed notes on 'todo' features
 
@@ -128,15 +140,15 @@ Selectable SystemC types based on widths (see notes below)
        c) a conditional whose possible values are (a) or (b)
 
  2) One can lose that fact that a node is a tristate node.  This happens
-    if a tristate node is assigned to a 'standard' node, or is used on 
+    if a tristate node is assigned to a 'standard' node, or is used on
     RHS of a conditional. The following infer tristate signals:
-       a) inout <SIGNAL> 
-       b) tri <SIGNAL> 
+       a) inout <SIGNAL>
+       b) tri <SIGNAL>
        c) assigning to 'Z' (maybe through a conditional)
     Note: tristate-ness of an output port determined only by
           statements in the module (not the instances it calls)
-  
+
  4) Tristate variables can't be multidimensional arrays
- 5) Only check tristate contention between modules (not within!)	
+ 5) Only check tristate contention between modules (not within!)
  6) Only simple compares with 'Z' are allowed (===)
 

bin/verilator_difftree

@@ -1,19 +1,7 @@
 : # -*-Mode: perl;-*- use perl, wherever it is
 eval 'exec perl -wS $0 ${1+"$@"}'
   if 0;
-# $Id$
-######################################################################
-#
-# Copyright 2005-2007 by Wilson Snyder <[email protected]>.  This
-# program is free software; you can redistribute it and/or modify it under
-# the terms of either the GNU Lesser General Public License or the Perl
-# Artistic License.
-#
-# 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.
-#
+# See copyright, etc in below POD section.
 ######################################################################
 
 require 5.006_001;
@@ -33,14 +21,17 @@ use vars qw ($Debug);
 $Debug = 0;
 my $Opt_A;
 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,
-		  )) {
-    usage();
+	  "help"	=> \&usage,
+	  "debug"	=> \&debug,
+	  "<>"		=> \&parameter,
+	  "lineno!"	=> \$Opt_Lineno,
+    )) {
+    die "%Error: Bad usage, try 'verilator_difftree --help'\n";
 }
 
 defined $Opt_A or die "%Error: No old diff filename\n";
@@ -90,7 +81,7 @@ sub diff_file {
 
     filter ($a, $tmp_a);
     filter ($b, $tmp_b);
-    system("diff $tmp_a $tmp_b");
+    system("diff -u $tmp_a $tmp_b");
     unlink $tmp_a;
     unlink $tmp_b;
 }
@@ -105,6 +96,7 @@ sub filter {
 	next if $line =~ / This=/;
 	$line =~ s/0x[a-f0-9]+/0x/g;
 	$line =~ s/<e[0-9]+\#?>/<e>/g;
+	$line =~ s/{\d+}/{}/g if !$Opt_Lineno;
 	print $f2 $line;
     }
     $f1->close;
@@ -114,7 +106,6 @@ sub filter {
 #----------------------------------------------------------------------
 
 sub usage {
-    print '$Id$ ', "\n";
     pod2usage(-verbose=>2, -exitval => 2);
     exit (1);
 }
@@ -129,7 +120,7 @@ sub parameter {
 	$Opt_A = $param;
     } elsif (!defined $Opt_B) {
 	$Opt_B = $param;
-    } else {	
+    } else {
 	die "%Error: Unknown parameter: $param\n";
     }
 }
@@ -173,15 +164,19 @@ directories, ignoring irrelevant pointer differences.
 
 Displays this message and program version and exits.
 
+=item --nolineno
+
+Do not show differences in line numbering.
+
 =back
 
 =head1 DISTRIBUTION
 
-The latest version is available from L<http://www.veripool.com/>.
+The latest version is available from L<http://www.veripool.org/verilator>.
 
-Copyright 2005-2007 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 or the Perl Artistic License.
+Copyright 2005-2009 by Wilson Snyder.  This package is free software; you can
+redistribute it and/or modify it under the terms of either the GNU Lesser
+General Public License Version 3 or the Perl Artistic License Version 2.0.
 
 =head1 AUTHORS
 

bin/verilator_includer

@@ -1,12 +1,11 @@
 : # -*-Mode: perl;-*- use perl, wherever it is
 eval 'exec perl -wS $0 ${1+"$@"}'
   if 0;
-# $Id$
 # DESCRIPTION: Print include statements for each ARGV
 #
-# Copyright 2003-2007 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
-# General Public License or the Perl Artistic License.
+# Copyright 2003-2009 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.
 ######################################################################
 
 require 5.005;

bin/verilator_profcfunc

@@ -0,0 +1,228 @@
+: # -*-Mode: perl;-*- use perl, wherever it is
+eval 'exec perl -wS $0 ${1+"$@"}'
+  if 0;
+# See copyright, etc in below POD section.
+######################################################################
+
+require 5.006_001;
+use warnings;
+use Getopt::Long;
+use IO::File;
+use Pod::Usage;
+eval { use Data::Dumper;  $Data::Dumper::Indent = 1; }; # Debug, ok if missing
+use strict;
+use vars qw ($Debug);
+
+#======================================================================
+
+
+#======================================================================
+# main
+
+$Debug = 0;
+my $Opt_File;
+autoflush STDOUT 1;
+autoflush STDERR 1;
+Getopt::Long::config ("no_auto_abbrev");
+if (! GetOptions (
+		  "help"	=> \&usage,
+		  "debug"	=> \&debug,
+		  "<>"		=> \&parameter,
+		  )) {
+    die "%Error: Bad usage, try 'verilator_profcfunc --help'\n";
+}
+
+defined $Opt_File or die "%Error: No filename given\n";
+
+profcfunc($Opt_File);
+
+#----------------------------------------------------------------------
+
+sub usage {
+    pod2usage(-verbose=>2, -exitval => 2);
+    exit (1);
+}
+
+sub debug {
+    $Debug = 1;
+}
+
+sub parameter {
+    my $param = shift;
+    if (!defined $Opt_File) {
+	$Opt_File = $param;
+    } else {
+	die "%Error: Unknown parameter: $param\n";
+    }
+}
+
+#######################################################################
+
+sub profcfunc {
+    my $filename = shift;
+    # Remove hex numbers before diffing
+    my $fh = IO::File->new ($filename) or die "%Error: $! $filename,";
+
+    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;
+	}
+    }
+    $fh->close;
+
+    # Find modules
+    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;
+	}
+    }
+    #print Dumper(\%pointer_mods, \%verilated_mods);
+
+    # Resort by Verilog name
+    my %vfuncs;
+    my %groups;
+    foreach my $func (keys %funcs) {
+	my $pct = $funcs{$func}{pct};
+	my $vfunc = $func;
+	my $design;
+
+	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;
+	    }
+	}
+
+	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;
+	    } 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;
+	}
+
+	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");
+    print("   These are split into three categories:\n");
+    print("      C++:     Time in non-Verilated C++ code\n");
+    print("      VBlock:  Time attributable to a block in a Verilog file and line\n");
+    print("      VCommon: Time in a Verilated module, due to all parts of the design\n");
+    print("\n");
+
+    print("  %   cumulative   self              \n");
+    print(" time   seconds   seconds    calls   type      filename and line number\n");
+
+    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);
+    }
+}
+
+#######################################################################
+__END__
+
+=pod
+
+=head1 NAME
+
+verilator_profcfunc - Read gprof report created with --profile-cfuncs
+
+=head1 SYNOPSIS
+
+  verilator --profile-cfuncs ....
+  gcc --ggdb -pg ....
+  {run executable}
+  gprof
+  verilator_profcfuncs gprof.out
+
+=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,
+in each Verilog block.
+
+=head1 ARGUMENTS
+
+=over 4
+
+=item --help
+
+Displays this message and program version and exits.
+
+=back
+
+=head1 DISTRIBUTION
+
+The latest version is available from L<http://www.veripool.org/>.
+
+Copyright 2007-2009 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_profcfunc  $V4/test_c/obj_dir/V*_03_*.tree $V4N/test_c/obj_dir/V*_03_*.tree"
+### End:

configure.ac

@@ -1,23 +1,49 @@
-dnl $Id$
 dnl DESCRIPTION: Process this file with autoconf to produce a configure script.
-dnl Copyright 2003-2007 by Wilson Snyder. This program is free software; you can
-dnl redistribute it and/or modify it under the terms of either the GNU
-dnl General Public License or the Perl Artistic License.
+dnl
+dnl Copyright 2003-2009 by Wilson Snyder. Verilator is free software; you can
+dnl redistribute it and/or modify it under the terms of either the GNU Lesser
+dnl General Public License Version 3 or the Perl Artistic License Version 2.0.
 
-AC_REVISION($Revision$)dnl
 AC_INIT(src/Verilator.cpp)
 AC_CONFIG_HEADER(src/config_build.h)
 
 dnl Special Substitutions
+AC_ARG_ENABLE(defenv,
+   [AS_HELP_STRING([--disable-defenv], [disable hardcoded default environment variables])],
+   CFG_WITH_DEFENV=$enableval,
+   CFG_WITH_DEFENV=yes)
+AC_SUBST(CFG_WITH_DEFENV)
+
+dnl Compiler flags
+CXX=g++
+CFLAGS=-I${includedir}
+CPPFLAGS=-I${includedir}
+CXXFLAGS=-I${includedir}
+LDFLAGS=-L${libdir}
 
 dnl Checks for programs.
-CXX=g++
 AC_PROG_CC
 AC_PROG_CXX
 AC_PROG_INSTALL
+
+AC_LANG_PUSH(C++)
+AC_MSG_CHECKING([that C++ compiler can compile simple program])
+AC_TRY_RUN([int main() { return 0; }],
+           AC_MSG_RESULT(yes),
+           AC_MSG_RESULT(no);AC_MSG_ERROR([a working C++ compiler is required]))
+
 AC_PATH_PROG(PERL,perl)
-AC_PATH_PROG(YACC,bison)
+if test "x$PERL" = "x" ; then
+   AC_MSG_ERROR([Cannot find "perl" in your PATH, please install it])
+fi
 AC_PATH_PROG(LEX,flex)
+if test "x$LEX" = "x" ; then
+   AC_MSG_ERROR([Cannot find "flex" in your PATH, please install it])
+fi
+AC_PATH_PROG(YACC,bison)
+if test "x$YACC" = "x" ; then
+   AC_MSG_ERROR([Cannot find "bison" in your PATH, please install it])
+fi
 
 dnl Checks for libraries.
 
@@ -47,5 +73,5 @@ AC_SUBST(pkgdatadir)
 AC_OUTPUT(Makefile src/Makefile src/Makefile_obj include/verilated.mk)
 
 AC_MSG_RESULT([])
-AC_MSG_RESULT([Now type 'make'])
+AC_MSG_RESULT([Now type 'gmake'])
 AC_MSG_RESULT([])

include/verilated.cpp

@@ -1,15 +1,16 @@
-// $Id$ -*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// Lesser General Public License Version 3 or the Perl Artistic License.
+// Version 2.0.
 //
 // Verilator is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
-// 
+//
 //=========================================================================
 ///
 /// \file
@@ -18,20 +19,19 @@
 ///	This file must be compiled and linked against all objects
 ///	created from Verilator.
 ///
-/// Code available from: http://www.veripool.com/verilator
+/// Code available from: http://www.veripool.org/verilator
 ///
 //=========================================================================
 
 #include "verilated.h"
-#include <string.h>
-#include <ctype.h>
+#include <cctype>
 
 #define VL_VALUE_STRING_MAX_WIDTH 1024	///< Max static char array for VL_VALUE_STRING
 
 //===========================================================================
 // Global variables
 
-int  Verilated::s_randReset = false;
+int  Verilated::s_randReset = 0;
 int  Verilated::s_debug = 1;
 bool Verilated::s_calcUnusedSigs = false;
 bool Verilated::s_gotFinish = false;
@@ -72,30 +72,51 @@ void vl_fatal (const char* filename, int linenum, const char* hier, const char*
 // Random reset -- Only called at init time, so don't inline.
 
 IData VL_RAND32() {
-#ifdef _MSC_VER
-    return (rand()<<16) | rand();
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    // Windows doesn't have lrand48(), although Cygwin does.
+    return (rand()<<16) ^ rand();
 #else
-    return (lrand48()<<16) | lrand48();
+    return (lrand48()<<16) ^ lrand48();
 #endif
 }
 
-IData VL_RAND_RESET_I(int outBits) {
+IData VL_RANDOM_I(int obits) {
+    return VL_RAND32() & VL_MASK_I(obits);
+}
+
+QData VL_RANDOM_Q(int obits) {
+    QData data = ((QData)VL_RAND32()<<VL_ULL(32)) | (QData)VL_RAND32();
+    return data & VL_MASK_Q(obits);
+}
+
+WDataOutP VL_RANDOM_W(int obits, WDataOutP outwp) {
+    for (int i=0; i<VL_WORDS_I(obits); i++) {
+	if (i<(VL_WORDS_I(obits)-1)) {
+	    outwp[i] = VL_RAND32();
+	} else {
+	    outwp[i] = VL_RAND32() & VL_MASK_I(obits);
+	}
+    }
+    return outwp;
+}
+
+IData VL_RAND_RESET_I(int obits) {
     if (Verilated::randReset()==0) return 0;
     IData data = ~0;
     if (Verilated::randReset()!=1) {	// if 2, randomize
-	data = VL_RAND32();
+	data = VL_RANDOM_I(obits);
     }
-    if (outBits<32) data &= VL_MASK_I(outBits); 
+    if (obits<32) data &= VL_MASK_I(obits);
     return data;
 }
 
-QData VL_RAND_RESET_Q(int outBits) {
+QData VL_RAND_RESET_Q(int obits) {
     if (Verilated::randReset()==0) return 0;
     QData data = VL_ULL(~0);
     if (Verilated::randReset()!=1) {	// if 2, randomize
-	data = ((QData)VL_RAND32()<<VL_ULL(32)) | (QData)VL_RAND32();
+	data = VL_RANDOM_Q(obits);
     }
-    if (outBits<64) data &= VL_MASK_Q(outBits); 
+    if (obits<64) data &= VL_MASK_Q(obits);
     return data;
 }
 
@@ -118,94 +139,368 @@ WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp) {
 //===========================================================================
 // Formatting
 
-const char* VL_VALUE_FORMATTED_Q(int obits, char fmt, bool drop0, QData ld) {
-    // Convert value into %b/%o/%x/%s/%u/%d formatted string
-    // Note uses a single buffer; presumes only one call per printf
-    static VL_THREAD char str[VL_VALUE_STRING_MAX_WIDTH];
-    char* strp = &str[0];
-    int lsb=obits-1;
-    if (drop0) while (lsb && !VL_BITISSET_Q(ld,lsb)) lsb--;
-    switch (fmt) {
-    case 'd':
-	sprintf(str,"%lld",(vlsint64_t)(VL_EXTENDS_QQ(obits,obits,ld)));
-	return str;
-    case 'u':
-	sprintf(str,"%llu",ld);
-	return str;
-    case 's':
-	for (; lsb>=0; lsb--) {
-	    lsb = (lsb / 8) * 8; // Next digit
-	    IData charval = (ld>>VL_BITBIT_Q(lsb)) & 0xff;
-	    *strp++ = (charval==0)?' ':charval;
+// Do a va_arg returning a quad, assuming input argument is anything less than wide
+#define _VL_VA_ARG_Q(ap, bits) (((bits) <= VL_WORDSIZE) ? va_arg(ap,IData) : va_arg(ap,QData))
+
+void _vl_vsformat(string& output, const char* formatp, va_list ap) {
+    // Format a Verilog $write style format into the output list
+    // The format must be pre-processed (and lower cased) by Verilator
+    // Arguments are in "width, arg-value (or WDataIn* if wide)" form
+    //
+    // Note uses a single buffer internally; presumes only one usage per printf
+    // Note also assumes variables < 64 are not wide, this assumption is
+    // sometimes not true in low-level routines written here in verilated.cpp
+    static VL_THREAD char tmp[VL_VALUE_STRING_MAX_WIDTH];
+    bool inPct = false;
+    bool widthSet = false;
+    int width = 0;
+    const char* pos = formatp;
+    for (; *pos; ++pos) {
+	if (!inPct && pos[0]=='%') {
+	    inPct = true;
+	    widthSet = false;
+	    width = 0;
+	} else if (!inPct) {   // Normal text
+	    // Fast-forward to next escape and add to output
+	    const char *ep = pos;
+	    while (ep[0] && ep[0]!='%') ep++;
+	    if (ep != pos) {
+		output += string(pos, ep-pos);
+		pos += ep-pos-1;
+	    }
+	} else { // Format character
+	    inPct = false;
+	    char fmt = pos[0];
+	    switch (fmt) {
+	    case '0': case '1': case '2': case '3': case '4':
+	    case '5': case '6': case '7': case '8': case '9':
+		inPct = true;  // Get more digits
+		widthSet = true;
+		width = width*10 + (fmt - '0');
+		break;
+	    case '%':
+		output += '%';
+		break;
+	    case 'S': { // "C" string
+		const char* cstrp = va_arg(ap, const char*);
+		output += cstrp;
+		break;
+	    }
+	    default: {
+		// Deal with all read-and-print somethings
+		const int lbits = va_arg(ap, int);
+		QData ld = 0;
+		WDataInP lwp;
+		if (lbits <= VL_QUADSIZE) {
+		    WData qlwp[2];
+		    ld = _VL_VA_ARG_Q(ap, lbits);
+		    VL_SET_WQ(qlwp,ld);
+		    lwp = qlwp;
+		} else {
+		    lwp = va_arg(ap,WDataInP);
+		    ld = lwp[0];
+		    if (fmt == 'u' || fmt == 'd') fmt = 'x';  // Not supported, but show something
+		}
+		int lsb=lbits-1;
+		if (widthSet && width==0) while (lsb && !VL_BITISSET_W(lwp,lsb)) lsb--;
+		switch (fmt) {
+		case 'c': {
+		    IData charval = ld & 0xff;
+		    output += charval;
+		    break;
+		}
+		case 's':
+		    for (; lsb>=0; lsb--) {
+			lsb = (lsb / 8) * 8; // Next digit
+			IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xff;
+			output += (charval==0)?' ':charval;
+		    }
+		    break;
+		case 'd': { // Signed decimal
+		    int digits=sprintf(tmp,"%lld",(vlsint64_t)(VL_EXTENDS_QQ(lbits,lbits,ld)));
+		    int needmore = width-digits;
+		    if (needmore>0) output.append(needmore,' '); // Pre-pad spaces
+		    output += tmp;
+		    break;
+		}
+		case 'u': { // Unsigned decimal
+		    int digits=sprintf(tmp,"%llu",ld);
+		    int needmore = width-digits;
+		    if (needmore>0) output.append(needmore,' '); // Pre-pad spaces
+		    output += tmp;
+		    break;
+		}
+		case 't': { // Time
+		    int digits;
+		    if (VL_TIME_MULTIPLIER==1) {
+			digits=sprintf(tmp,"%llu",ld);
+		    } else if (VL_TIME_MULTIPLIER==1000) {
+			digits=sprintf(tmp,"%llu.%03llu",
+				       (QData)(ld/VL_TIME_MULTIPLIER),
+				       (QData)(ld%VL_TIME_MULTIPLIER));
+		    } else {
+			vl_fatal(__FILE__,__LINE__,"","%%Error: Unsupported VL_TIME_MULTIPLIER");
+		    }
+		    int needmore = width-digits;
+		    if (needmore>0) output.append(needmore,' '); // Pre-pad spaces
+		    output += tmp;
+		    break;
+		}
+		case 'b':
+		    for (; lsb>=0; lsb--) {
+			output += ((lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 1) + '0';
+		    }
+		    break;
+		case 'o':
+		    for (; lsb>=0; lsb--) {
+			lsb = (lsb / 3) * 3; // Next digit
+			// Octal numbers may span more than one wide word,
+			// so we need to grab each bit separately and check for overrun
+			// Octal is rare, so we'll do it a slow simple way
+			output += ('0'
+				   + ((VL_BITISSETLIMIT_W(lwp, lbits, lsb+0)) ? 1 : 0)
+				   + ((VL_BITISSETLIMIT_W(lwp, lbits, lsb+1)) ? 2 : 0)
+				   + ((VL_BITISSETLIMIT_W(lwp, lbits, lsb+2)) ? 4 : 0));
+		    }
+		    break;
+		case 'x':
+		    for (; lsb>=0; lsb--) {
+			lsb = (lsb / 4) * 4; // Next digit
+			IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xf;
+			output += "0123456789abcdef"[charval];
+		    }
+		    break;
+		default:
+		    string msg = string("%%Error: Unknown _vl_vsformat code: ")+pos[0]+"\n";
+		    vl_fatal(__FILE__,__LINE__,"",msg.c_str());
+		    break;
+		} // switch
+	    }
+	    } // switch
 	}
-	*strp++ = '\0';
-	return str;
-    case 'b':
-	for (; lsb>=0; lsb--) {
-	    *strp++ = ((ld>>VL_BITBIT_Q(lsb)) & 1) + '0';
-	}
-	*strp++ = '\0';
-	return str;
-    case 'o':
-	for (; lsb>=0; lsb--) {
-	    lsb = (lsb / 3) * 3; // Next digit
-	    *strp++ = ((ld>>VL_BITBIT_Q(lsb)) & 7) + '0';
-	}
-	*strp++ = '\0';
-	return str;
-    default:
-	for (; lsb>=0; lsb--) {
-	    lsb = (lsb / 4) * 4; // Next digit
-	    IData charval = (ld>>VL_BITBIT_Q(lsb)) & 0xf;
-	    *strp++ = (charval + ((charval < 10) ? '0':('a'-10)));
-	}
-	*strp++ = '\0';
-	return str;
     }
-    *strp++ = '\0';
-    return str;
 }
 
-const char* VL_VALUE_FORMATTED_W(int obits, char fmt, bool drop0, WDataInP lwp) {
-    // Convert value into %b/%o/%x/%s/%u/%d formatted string
-    // Note uses a single buffer; presumes only one call per printf
-    static VL_THREAD char str[VL_VALUE_STRING_MAX_WIDTH];
-    char* strp = &str[0];
-    int lsb=obits-1;
-    if (drop0) while (lsb && !VL_BITISSET_W(lwp,lsb)) lsb--;
-    switch (fmt) {
-    case 's':
-	for (; lsb>=0; lsb--) {
-	    lsb = (lsb / 8) * 8; // Next digit
-	    IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xff;
-	    *strp++ = (charval==0)?' ':charval;
-	}
-	*strp++ = '\0';
-	return str;
-    case 'b':
-	for (; lsb>=0; lsb--) {
-	    *strp++ = ((lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 1) + '0';
-	}
-	*strp++ = '\0';
-	return str;
-    case 'o':
-	for (; lsb>=0; lsb--) {
-	    lsb = (lsb / 3) * 3; // Next digit
-	    *strp++ = ((lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 7) + '0';
-	}
-	*strp++ = '\0';
-	return str;
-    default:
-	for (; lsb>=0; lsb--) {
-	    lsb = (lsb / 4) * 4; // Next digit
-	    IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xf;
-	    *strp++ = (charval + ((charval < 10) ? '0':('a'-10)));
-	}
-	*strp++ = '\0';
-	return str;
+static inline bool _vl_vsss_eof(FILE* fp, int& floc) {
+    return fp ? feof(fp) : (floc<0);
+}
+static inline void _vl_vsss_advance(FILE* fp, int& floc) {
+    if (fp) fgetc(fp);
+    else floc -= 8;
+}
+static inline int  _vl_vsss_peek(FILE* fp, int& floc, WDataInP fromp) {
+    // Get a character without advancing
+    if (fp) {
+	int data = fgetc(fp);
+	if (data == EOF) return EOF;
+	ungetc(data,fp);
+	return data;
+    } else {
+	if (floc < 0) return EOF;
+	floc = floc & ~7;	// Align to closest character
+	int data = (fromp[VL_BITWORD_I(floc)] >> VL_BITBIT_I(floc)) & 0xff;
+	return data;
     }
-    *strp++ = '\0';
-    return str;
+}
+static inline void _vl_vsss_skipspace(FILE* fp, int& floc, WDataInP fromp) {
+    while (1) {
+	int c = _vl_vsss_peek(fp, floc, fromp);
+	if (c==EOF || !isspace(c)) return;
+	_vl_vsss_advance(fp, floc);
+    }
+}
+static inline void _vl_vsss_read(FILE* fp, int& floc, WDataInP fromp,
+				 char* tmpp, const char* acceptp) {
+    // Read into tmp, consisting of characters from acceptp list
+    char* cp = tmpp;
+    while (1) {
+	int c = _vl_vsss_peek(fp, floc, fromp);
+	if (c==EOF || isspace(c)) break;
+	if (acceptp!=NULL // String - allow anything
+	    && NULL==strchr(acceptp, c)) break;
+	if (acceptp!=NULL) c = tolower(c); // Non-strings we'll simplify
+	*cp++ = c;
+	_vl_vsss_advance(fp, floc);
+    }
+    *cp++ = '\0';
+    //VL_PRINTF("\t_read got='%s'\n", tmpp);
+}
+static inline void _vl_vsss_setbit(WDataOutP owp, int obits, int lsb, int nbits, IData ld) {
+    for (; nbits && lsb<obits; nbits--, lsb++, ld>>=1) {
+	VL_ASSIGNBIT_WI(0, lsb, owp, ld & 1);
+    }
+}
+
+IData _vl_vsscanf(FILE* fp,  // If a fscanf
+		  int fbits, WDataInP fromp,  // Else if a sscanf
+		  const char* formatp, va_list ap) {
+    // Read a Verilog $sscanf/$fscanf style format into the output list
+    // The format must be pre-processed (and lower cased) by Verilator
+    // Arguments are in "width, arg-value (or WDataIn* if wide)" form
+    static VL_THREAD char tmp[VL_VALUE_STRING_MAX_WIDTH];
+    int floc = fbits - 1;
+    IData got = 0;
+    bool inPct = false;
+    const char* pos = formatp;
+    for (; *pos && !_vl_vsss_eof(fp,floc); ++pos) {
+	//VL_PRINTF("_vlscan fmt='%c' floc=%d file='%c'\n", pos[0], floc, _vl_vsss_peek(fp,floc,fromp));
+	if (!inPct && pos[0]=='%') {
+	    inPct = true;
+	} else if (!inPct && isspace(pos[0])) {   // Format spaces
+	    while (isspace(pos[1])) pos++;
+	    _vl_vsss_skipspace(fp,floc,fromp);
+	} else if (!inPct) {   // Expected Format
+	    _vl_vsss_skipspace(fp,floc,fromp);
+	    int c = _vl_vsss_peek(fp,floc,fromp);
+	    if (c != pos[0]) goto done;
+	    else _vl_vsss_advance(fp,floc);
+	} else { // Format character
+	    // Skip loading spaces
+	    inPct = false;
+	    char fmt = pos[0];
+	    switch (fmt) {
+	    case '%': {
+		int c = _vl_vsss_peek(fp,floc,fromp);
+		if (c != '%') goto done;
+		else _vl_vsss_advance(fp,floc);
+		break;
+	    }
+	    default: {
+		// Deal with all read-and-scan somethings
+		// Note LSBs are preserved if there's an overflow
+		const int obits = va_arg(ap, int);
+		int lsb = 0;
+		WData qowp[2];
+		WDataOutP owp = qowp;
+		if (obits > VL_QUADSIZE) {
+		    owp = va_arg(ap,WDataOutP);
+		}
+		for (int i=0; i<VL_WORDS_I(obits); i++) owp[i] = 0;
+		switch (fmt) {
+		case 'c': {
+		    int c = _vl_vsss_peek(fp,floc,fromp);
+		    if (c==EOF) goto done;
+		    else _vl_vsss_advance(fp,floc);
+		    owp[0] = c;
+		    break;
+		}
+		case 's': {
+		    _vl_vsss_skipspace(fp,floc,fromp);
+		    _vl_vsss_read(fp,floc,fromp, tmp, NULL);
+		    if (!tmp[0]) goto done;
+		    int pos = strlen(tmp)-1;
+		    for (int i=0; i<obits && pos>=0; pos--) {
+			_vl_vsss_setbit(owp,obits,lsb, 8, tmp[pos]); lsb+=8;
+		    }
+		    break;
+		}
+		case 'd': { // Signed decimal
+		    _vl_vsss_skipspace(fp,floc,fromp);
+		    _vl_vsss_read(fp,floc,fromp, tmp, "0123456789+-xz?_");
+		    if (!tmp[0]) goto done;
+		    vlsint64_t ld;
+		    sscanf(tmp,"%lld",&ld);
+		    VL_SET_WQ(owp,ld);
+		    break;
+		}
+		case 't': // FALLTHRU  // Time
+		case 'u': { // Unsigned decimal
+		    _vl_vsss_skipspace(fp,floc,fromp);
+		    _vl_vsss_read(fp,floc,fromp, tmp, "0123456789+-xz?_");
+		    if (!tmp[0]) goto done;
+		    QData ld;
+		    sscanf(tmp,"%llu",&ld);
+		    VL_SET_WQ(owp,ld);
+		    break;
+		}
+		case 'b': {
+		    _vl_vsss_skipspace(fp,floc,fromp);
+		    _vl_vsss_read(fp,floc,fromp, tmp, "01xz?_");
+		    if (!tmp[0]) goto done;
+		    int pos = strlen(tmp)-1;
+		    for (int i=0; i<obits && pos>=0; pos--) {
+			switch(tmp[pos]) {
+			case 'x': case 'z': case '?': //FALLTHRU
+			case '0': lsb++; break;
+			case '1': _vl_vsss_setbit(owp,obits,lsb, 1, 1); lsb++; break;
+			case '_': break;
+			}
+		    }
+		    break;
+		}
+		case 'o': {
+		    _vl_vsss_skipspace(fp,floc,fromp);
+		    _vl_vsss_read(fp,floc,fromp, tmp, "01234567xz?_");
+		    if (!tmp[0]) goto done;
+		    int pos = strlen(tmp)-1;
+		    for (int i=0; i<obits && pos>=0; pos--) {
+			switch(tmp[pos]) {
+			case 'x': case 'z': case '?': //FALLTHRU
+			case '0': lsb+=3; break;
+			case '1': _vl_vsss_setbit(owp,obits,lsb, 3, 1); lsb+=3; break;
+			case '2': _vl_vsss_setbit(owp,obits,lsb, 3, 2); lsb+=3; break;
+			case '3': _vl_vsss_setbit(owp,obits,lsb, 3, 3); lsb+=3; break;
+			case '4': _vl_vsss_setbit(owp,obits,lsb, 3, 4); lsb+=3; break;
+			case '5': _vl_vsss_setbit(owp,obits,lsb, 3, 5); lsb+=3; break;
+			case '6': _vl_vsss_setbit(owp,obits,lsb, 3, 6); lsb+=3; break;
+			case '7': _vl_vsss_setbit(owp,obits,lsb, 3, 7); lsb+=3; break;
+			case '_': break;
+			}
+		    }
+		    break;
+		}
+		case 'x': {
+		    _vl_vsss_skipspace(fp,floc,fromp);
+		    _vl_vsss_read(fp,floc,fromp, tmp, "0123456789abcdefxz?_");
+		    if (!tmp[0]) goto done;
+		    int pos = strlen(tmp)-1;
+		    for (int i=0; i<obits && pos>=0; pos--) {
+			switch(tmp[pos]) {
+			case 'x': case 'z': case '?': //FALLTHRU
+			case '0': lsb+=4; break;
+			case '1': _vl_vsss_setbit(owp,obits,lsb, 4,  1); lsb+=4; break;
+			case '2': _vl_vsss_setbit(owp,obits,lsb, 4,  2); lsb+=4; break;
+			case '3': _vl_vsss_setbit(owp,obits,lsb, 4,  3); lsb+=4; break;
+			case '4': _vl_vsss_setbit(owp,obits,lsb, 4,  4); lsb+=4; break;
+			case '5': _vl_vsss_setbit(owp,obits,lsb, 4,  5); lsb+=4; break;
+			case '6': _vl_vsss_setbit(owp,obits,lsb, 4,  6); lsb+=4; break;
+			case '7': _vl_vsss_setbit(owp,obits,lsb, 4,  7); lsb+=4; break;
+			case '8': _vl_vsss_setbit(owp,obits,lsb, 4,  8); lsb+=4; break;
+			case '9': _vl_vsss_setbit(owp,obits,lsb, 4,  9); lsb+=4; break;
+			case 'a': _vl_vsss_setbit(owp,obits,lsb, 4, 10); lsb+=4; break;
+			case 'b': _vl_vsss_setbit(owp,obits,lsb, 4, 11); lsb+=4; break;
+			case 'c': _vl_vsss_setbit(owp,obits,lsb, 4, 12); lsb+=4; break;
+			case 'd': _vl_vsss_setbit(owp,obits,lsb, 4, 13); lsb+=4; break;
+			case 'e': _vl_vsss_setbit(owp,obits,lsb, 4, 14); lsb+=4; break;
+			case 'f': _vl_vsss_setbit(owp,obits,lsb, 4, 15); lsb+=4; break;
+			case '_': break;
+			}
+		    }
+		    break;
+		}
+		default:
+		    string msg = string("%%Error: Unknown _vl_vsscanf code: ")+pos[0]+"\n";
+		    vl_fatal(__FILE__,__LINE__,"",msg.c_str());
+		    break;
+		} // switch
+
+		got++;
+		// Reload data if non-wide (if wide, we put it in the right place directly)
+		if (obits <= VL_BYTESIZE) {
+		    CData* p = va_arg(ap,CData*); *p = owp[0];
+		} else if (obits <= VL_SHORTSIZE) {
+		    SData* p = va_arg(ap,SData*); *p = owp[0];
+		} else if (obits <= VL_WORDSIZE) {
+		    IData* p = va_arg(ap,IData*); *p = owp[0];
+		} else if (obits <= VL_QUADSIZE) {
+		    QData* p = va_arg(ap,QData*); *p = VL_SET_QW(owp);
+		}
+	    }
+	    } // switch
+	}
+    }
+  done:
+    return got;
 }
 
 //===========================================================================
@@ -227,6 +522,44 @@ void _VL_VINT_TO_STRING(int obits, char* destoutp, WDataInP sourcep) {
     while (isspace(*(destp-1)) && destp>destoutp) *--destp = '\0';  // Drop trailing spaces
 }
 
+void _VL_STRING_TO_VINT(int obits, void* destp, int srclen, const char* srcp) {
+    // Convert C string to Verilog format
+    int bytes = VL_BYTES_I(obits);
+    char* op = ((char*)(destp));
+    if (srclen > bytes) srclen = bytes;  // Don't overflow destination
+    int i;
+    for (i=0; i<srclen; i++) { *op++ = srcp[srclen-1-i]; }
+    for (; i<bytes; i++) { *op++ = 0; }
+}
+
+IData VL_FGETS_IXQ(int obits, void* destp, QData fpq) {
+    FILE* fp = VL_CVT_Q_FP(fpq);
+    if (VL_UNLIKELY(!fp)) return 0;
+
+    // The string needs to be padded with 0's in unused spaces in front of
+    // any read data.  This means we can't know in what location the first
+    // character will finally live, so we need to copy.  Yuk.
+    IData bytes = VL_BYTES_I(obits);
+    char buffer[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
+    // V3Emit has static check that bytes < VL_TO_STRING_MAX_WORDS, but be safe
+    if (VL_UNLIKELY(bytes > VL_TO_STRING_MAX_WORDS*VL_WORDSIZE)) {
+	vl_fatal(__FILE__,__LINE__,"","Internal: fgets buffer overrun");
+    }
+
+    // We don't use fgets, as we must read \0s.
+    IData got = 0;
+    char* cp = buffer;
+    while (got < bytes) {
+	int c = getc(fp);
+	if (c==EOF) break;
+	*cp++ = c;  got++;
+	if (c=='\n') break;
+    }
+
+    _VL_STRING_TO_VINT(obits, destp, got, buffer);
+    return got;
+}
+
 QData VL_FOPEN_QI(QData filename, IData mode) {
     IData fnw[2];  VL_SET_WQ(fnw, filename);
     return VL_FOPEN_WI(2, fnw, mode);
@@ -239,6 +572,67 @@ QData VL_FOPEN_WI(int fnwords, WDataInP filenamep, IData mode) {
     return VL_CVT_FP_Q(fopen(filenamez,modez));
 }
 
+void VL_WRITEF(const char* formatp, ...) {
+    va_list ap;
+    va_start(ap,formatp);
+    string output;
+    _vl_vsformat(output, formatp, ap);
+    va_end(ap);
+
+    // Users can redefine VL_PRINTF if they wish.
+    VL_PRINTF("%s", output.c_str());
+}
+
+void VL_FWRITEF(QData fpq, const char* formatp, ...) {
+    FILE* fp = VL_CVT_Q_FP(fpq);
+    if (VL_UNLIKELY(!fp)) return;
+
+    va_list ap;
+    va_start(ap,formatp);
+    string output;
+    _vl_vsformat(output, formatp, ap);
+    va_end(ap);
+
+    fputs(output.c_str(), fp);
+}
+
+IData VL_FSCANF_IX(QData fpq, const char* formatp, ...) {
+    FILE* fp = VL_CVT_Q_FP(fpq);
+    if (VL_UNLIKELY(!fp)) return 0;
+
+    va_list ap;
+    va_start(ap,formatp);
+    IData got = _vl_vsscanf(fp, 0, NULL, formatp, ap);
+    va_end(ap);
+    return got;
+}
+
+IData VL_SSCANF_IIX(int lbits, IData ld, const char* formatp, ...) {
+    IData fnw[2];  VL_SET_WI(fnw, ld);
+
+    va_list ap;
+    va_start(ap,formatp);
+    IData got = _vl_vsscanf(NULL, lbits, fnw, formatp, ap);
+    va_end(ap);
+    return got;
+}
+IData VL_SSCANF_IQX(int lbits, QData ld, const char* formatp, ...) {
+    IData fnw[2];  VL_SET_WQ(fnw, ld);
+
+    va_list ap;
+    va_start(ap,formatp);
+    IData got = _vl_vsscanf(NULL, lbits, fnw, formatp, ap);
+    va_end(ap);
+    return got;
+}
+IData VL_SSCANF_IWX(int lbits, WDataInP lwp, const char* formatp, ...) {
+    va_list ap;
+    va_start(ap,formatp);
+    IData got = _vl_vsscanf(NULL, lbits, lwp, formatp, ap);
+    va_end(ap);
+    return got;
+}
+
 void VL_READMEM_Q(bool hex, int width, int depth, int array_lsb, int,
 		  QData ofilename, void* memp, IData start, IData end) {
     IData fnw[2];  VL_SET_WQ(fnw, ofilename);
@@ -275,7 +669,7 @@ void VL_READMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
 	else if (c=='\t' || c==' ' || c=='\r' || c=='\f') { if (innum) reading_addr=false; innum=false; }
 	// Skip // comments and detect /* comments
 	else if (ignore_to_cmt && lastc=='*' && c=='/') {
-	    ignore_to_cmt = false; if (innum) reading_addr=false; innum=false; 
+	    ignore_to_cmt = false; if (innum) reading_addr=false; innum=false;
 	} else if (!ignore_to_eol && !ignore_to_cmt) {
 	    if (lastc=='/' && c=='*') { ignore_to_cmt = true; }
 	    else if (lastc=='/' && c=='/') { ignore_to_eol = true; }
@@ -354,7 +748,7 @@ const char* Verilated::catName(const char* n1, const char* n2) {
     // Used by symbol table creation to make module names
     static char* strp = NULL;
     static int   len  = -1;
-    int newlen = strlen(n1)+strlen(n2)+2;    
+    int newlen = strlen(n1)+strlen(n2)+2;
     if (newlen > len) {
 	if (strp) delete [] strp;
 	strp = new char[newlen];

include/verilated.h

@@ -1,15 +1,16 @@
-// $Id$ -*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// Lesser General Public License Version 3 or the Perl Artistic License.
+// Version 2.0.
 //
 // Verilator is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
-// 
+//
 //*************************************************************************
 ///
 /// \file
@@ -19,7 +20,7 @@
 ///	all C++ files it generates.  It contains standard macros and
 ///	classes required by the Verilated code.
 ///
-/// Code available from: http://www.veripool.com/verilator
+/// Code available from: http://www.veripool.org/verilator
 ///
 //*************************************************************************
 
@@ -29,11 +30,11 @@
 
 #include "verilatedos.h"
 
-#include <assert.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include <cassert>
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 #include <iostream>
 using namespace std;
 
@@ -129,7 +130,7 @@ struct Verilated {
     // Extern Vars
     // Below two are used as bool, but having as uint32_t avoids conversion time
 private:
-    static int  	s_randReset;		///< Random reset: 0=all 0s, 1=all 1s, 2=random
+    static int		s_randReset;		///< Random reset: 0=all 0s, 1=all 1s, 2=random
     static int		s_debug;		///< See accessors... only when VL_DEBUG set
     static bool		s_calcUnusedSigs;	///< Waves file on, need all signals calculated
     static bool		s_gotFinish;		///< A $finish statement executed
@@ -152,7 +153,7 @@ public:
 #endif
     /// Internal: Create a new module name by concatenating two strings
     static const char* catName(const char* n1, const char* n2); // Returns new'ed data
-    /// Enable calculation of unused signals 
+    /// Enable calculation of unused signals
     static void calcUnusedSigs(bool flag) { s_calcUnusedSigs=flag; }
     static bool calcUnusedSigs() { return s_calcUnusedSigs; }	///< Return calcUnusedSigs value
     /// Did the simulation $finish?
@@ -165,7 +166,7 @@ public:
     /// Enable/disable assertions
     static void assertOn(bool flag) { s_assertOn=flag; }
     static bool assertOn() { return s_assertOn; }
-};    
+};
 
 //=========================================================================
 // Extern functions -- User may override -- See verilated.cpp
@@ -179,21 +180,21 @@ extern void vl_fatal  (const char* filename, int linenum, const char* hier,
 		       const char* msg);
 
 //=========================================================================
-// Extern functions -- Init time only, so slow is fine
+// Extern functions -- Slow path
 
+extern IData  VL_RANDOM_I(int obits);	///< Randomize a signal
+extern QData  VL_RANDOM_Q(int obits);	///< Randomize a signal
+extern WDataOutP VL_RANDOM_W(int obits, WDataOutP outwp);	///< Randomize a signal
+
+/// Init time only, so slow is fine
 extern IData  VL_RAND_RESET_I(int obits);	///< Random reset a signal
 extern QData  VL_RAND_RESET_Q(int obits);	///< Random reset a signal
 extern WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp);	///< Random reset a signal
 extern WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp);	///< Zero reset a signal
 
-/// Return string with formated Verilog value
-extern const char* VL_VALUE_FORMATTED_W(int obits, char fmt, bool drop0, WDataInP lwp);
-extern const char* VL_VALUE_FORMATTED_Q(int obits, char fmt, bool drop0, QData ld);
-inline const char* VL_VALUE_FORMATTED_I(int obits, char fmt, bool drop0, IData ld) {
-    return VL_VALUE_FORMATTED_Q(obits,fmt,drop0,ld);
-}
-
 /// File I/O
+extern IData VL_FGETS_IXQ(int sbits, void* strgp, QData fpq);
+
 extern QData VL_FOPEN_WI(int fnwords, WDataInP ofilename, IData mode);
 extern QData VL_FOPEN_QI(QData ofilename, IData mode);
 inline QData VL_FOPEN_II(IData ofilename, IData mode) { return VL_FOPEN_QI(ofilename,mode); }
@@ -206,16 +207,27 @@ inline void VL_READMEM_I(bool hex, int width, int depth, int array_lsb, int fnwo
 			 IData ofilename,    void* memp, IData start, IData end) {
     VL_READMEM_Q(hex, width,depth,array_lsb,fnwords, ofilename,memp,start,end); }
 
+extern void VL_WRITEF(const char* formatp, ...);
+extern void VL_FWRITEF(QData fpq, const char* formatp, ...);
+
+extern IData VL_FSCANF_IX(QData fpq, const char* formatp, ...);
+extern IData VL_SSCANF_IIX(int lbits, IData ld, const char* formatp, ...);
+extern IData VL_SSCANF_IQX(int lbits, QData ld, const char* formatp, ...);
+extern IData VL_SSCANF_IWX(int lbits, WDataInP lwp, const char* formatp, ...);
+
 //=========================================================================
 // Base macros
 
 /// Return true if data[bit] set
-#define VL_BITISSET_I(data,bit) (data & (1UL<<VL_BITBIT_I(bit)))
+#define VL_BITISSET_I(data,bit) (data & (VL_UL(1)<<VL_BITBIT_I(bit)))
 #define VL_BITISSET_Q(data,bit) (data & (VL_ULL(1)<<VL_BITBIT_Q(bit)))
-#define VL_BITISSET_W(data,bit) (data[VL_BITWORD_I(bit)] & (1UL<<VL_BITBIT_I(bit)))
+#define VL_BITISSET_W(data,bit) (data[VL_BITWORD_I(bit)] & (VL_UL(1)<<VL_BITBIT_I(bit)))
+#define VL_BITISSETLIMIT_W(data,width,bit) (((bit)<(width)) && data[VL_BITWORD_I(bit)] & (VL_UL(1)<<VL_BITBIT_I(bit)))
 
 /// Create two 32-bit words from quadword
-#define VL_SET_WQ(decl,data)	{ decl[0]=(data); decl[1]=((data)>>VL_WORDSIZE); }
+#define VL_SET_WQ(owp,data)	{ owp[0]=(data); owp[1]=((data)>>VL_WORDSIZE); }
+#define VL_SET_WI(owp,data)	{ owp[0]=(data); owp[1]=0; }
+#define VL_SET_QW(lwp)		( ((QData)(lwp[0])) | ((QData)(lwp[1])<<((QData)(VL_WORDSIZE)) ))
 
 // Use a union to avoid cast-to-different-size warnings
 /// Return FILE* from QData
@@ -225,18 +237,18 @@ static inline QData  VL_CVT_FP_Q(FILE* fp) { union { FILE* fp; QData q; } u; u.q
 
 // Sign extend such that if MSB set, we get ffff_ffff, else 0s
 // (Requires clean input)
-#define VL_SIGN_I(nbits,lhs)      ((lhs) >> VL_BITBIT_I((nbits) - 1UL))
+#define VL_SIGN_I(nbits,lhs)      ((lhs) >> VL_BITBIT_I((nbits) - VL_UL(1)))
 #define VL_SIGN_Q(nbits,lhs)      ((lhs) >> VL_BITBIT_Q((nbits) - VL_ULL(1)))
 #define VL_SIGNONES_I(nbits,lhs)  (-(VL_SIGN_I(nbits,lhs)))
 
 // Sign bit extended up to MSB, doesn't include unsigned portion
 // Optimization bug in GCC 3.3 returns different bitmasks to later states for
-static inline IData  VL_EXTENDSIGN_I(int lbits, IData lhs) { return (-((lhs)&(1UL<<(lbits-1)))); }
+static inline IData  VL_EXTENDSIGN_I(int lbits, IData lhs) { return (-((lhs)&(VL_UL(1)<<(lbits-1)))); }
 static inline QData  VL_EXTENDSIGN_Q(int lbits, QData lhs) { return (-((lhs)&(VL_ULL(1)<<(lbits-1)))); }
 
 // Debugging prints
 static inline void _VL_DEBUG_PRINT_W(int lbits, WDataInP iwp) {
-    printf("  Data: w%d: ", lbits); 
+    printf("  Data: w%d: ", lbits);
     for (int i=VL_WORDS_I(lbits)-1; i>=0; i--) { printf("%08x ",iwp[i]); }
     printf("\n");
 }
@@ -244,13 +256,17 @@ static inline void _VL_DEBUG_PRINT_W(int lbits, WDataInP iwp) {
 //=========================================================================
 // Pli macros
 
+#ifndef VL_TIME_MULTIPLIER
+# define VL_TIME_MULTIPLIER 1
+#endif
+
 /// Return current simulation time
 #if defined(SYSTEMC_VERSION) && (SYSTEMC_VERSION>20011000)
-# define VL_TIME_I(ign) ((IData)sc_time_stamp().to_default_time_units())
-# define VL_TIME_Q(ign) ((QData)sc_time_stamp().to_default_time_units())
+# define VL_TIME_I(ign) ((IData)(sc_time_stamp().to_default_time_units()*VL_TIME_MULTIPLIER))
+# define VL_TIME_Q(ign) ((QData)(sc_time_stamp().to_default_time_units()*VL_TIME_MULTIPLIER))
 #else
-# define VL_TIME_I(ign) ((IData)sc_time_stamp())
-# define VL_TIME_Q(ign) ((QData)sc_time_stamp())
+# define VL_TIME_I(ign) ((IData)(sc_time_stamp()*VL_TIME_MULTIPLIER))
+# define VL_TIME_Q(ign) ((QData)(sc_time_stamp()*VL_TIME_MULTIPLIER))
 extern double sc_time_stamp();
 #endif
 
@@ -304,15 +320,15 @@ static inline WDataOutP VL_ASSIGN_W(int obits, WDataOutP owp,WDataInP lwp){
 
 // EMIT_RULE: VL_ASSIGNBIT:  rclean=clean;
 static inline void VL_ASSIGNBIT_II(int, int bit, CData& lhsr, IData rhs) {
-    lhsr = ((lhsr & ~(1UL<<VL_BITBIT_I(bit)))
+    lhsr = ((lhsr & ~(VL_UL(1)<<VL_BITBIT_I(bit)))
 	    | (rhs<<VL_BITBIT_I(bit)));
 }
 static inline void VL_ASSIGNBIT_II(int, int bit, SData& lhsr, IData rhs) {
-    lhsr = ((lhsr & ~(1UL<<VL_BITBIT_I(bit)))
+    lhsr = ((lhsr & ~(VL_UL(1)<<VL_BITBIT_I(bit)))
 	    | (rhs<<VL_BITBIT_I(bit)));
 }
 static inline void VL_ASSIGNBIT_II(int, int bit, IData& lhsr, IData rhs) {
-    lhsr = ((lhsr & ~(1UL<<VL_BITBIT_I(bit)))
+    lhsr = ((lhsr & ~(VL_UL(1)<<VL_BITBIT_I(bit)))
 	    | (rhs<<VL_BITBIT_I(bit)));
 }
 static inline void VL_ASSIGNBIT_QI(int, int bit, QData& lhsr, QData rhs) {
@@ -321,58 +337,68 @@ static inline void VL_ASSIGNBIT_QI(int, int bit, QData& lhsr, QData rhs) {
 }
 static inline void VL_ASSIGNBIT_WI(int, int bit, WDataOutP owp, IData rhs) {
     IData orig = owp[VL_BITWORD_I(bit)];
-    owp[VL_BITWORD_I(bit)] = (orig & ~(1UL<<VL_BITBIT_I(bit))
-			    | (rhs<<VL_BITBIT_I(bit)));
+    owp[VL_BITWORD_I(bit)] = ((orig & ~(VL_UL(1)<<VL_BITBIT_I(bit)))
+			      | (rhs<<VL_BITBIT_I(bit)));
 }
 // Alternative form that is an instruction faster when rhs is constant one.
 static inline void VL_ASSIGNBIT_IO(int, int bit, CData& lhsr, IData) {
-    lhsr = (lhsr | (1UL<<VL_BITBIT_I(bit)));
+    lhsr = (lhsr | (VL_UL(1)<<VL_BITBIT_I(bit)));
 }
 static inline void VL_ASSIGNBIT_IO(int, int bit, SData& lhsr, IData) {
-    lhsr = (lhsr | (1UL<<VL_BITBIT_I(bit)));
+    lhsr = (lhsr | (VL_UL(1)<<VL_BITBIT_I(bit)));
 }
 static inline void VL_ASSIGNBIT_IO(int, int bit, IData& lhsr, IData) {
-    lhsr = (lhsr | (1UL<<VL_BITBIT_I(bit)));
+    lhsr = (lhsr | (VL_UL(1)<<VL_BITBIT_I(bit)));
 }
 static inline void VL_ASSIGNBIT_QO(int, int bit, QData& lhsr, IData) {
     lhsr = (lhsr | (VL_ULL(1)<<VL_BITBIT_Q(bit)));
 }
 static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
     IData orig = owp[VL_BITWORD_I(bit)];
-    owp[VL_BITWORD_I(bit)] = (orig |  (1UL<<VL_BITBIT_I(bit)));
+    owp[VL_BITWORD_I(bit)] = (orig |  (VL_UL(1)<<VL_BITBIT_I(bit)));
 }
 
 //===================================================================
 // SYSTEMC OPERATORS
-// Copying verilog format to/from systemc integers and bit vectors.
-
-#define VL_ASSIGN_IS(obits,vvar,svar) { (vvar) = VL_CLEAN_II((obits),(obits),(svar).read()); }
-#define VL_ASSIGN_SI(obits,svar,vvar) { (svar).write(vvar); }
+// Copying verilog format to systemc integers and bit vectors.
 
+#define VL_ASSIGN_ISI(obits,vvar,svar) { (vvar) = VL_CLEAN_II((obits),(obits),(svar).read()); }
 #define VL_ASSIGN_QSQ(obits,vvar,svar) { (vvar) = VL_CLEAN_QQ((obits),(obits),(svar).read()); }
+
+#define VL_ASSIGN_ISW(obits,od,svar) { \
+    od = (svar.read().get_word(0)) & VL_MASK_I(obits); \
+}
+#define VL_ASSIGN_QSW(obits,od,svar) { \
+    od = (((QData)svar.read().get_word(1))<<VL_WORDSIZE | svar.read().get_word(0)) \
+	& VL_MASK_Q(obits); \
+}
+#define VL_ASSIGN_WSW(obits,owp,svar) { \
+    int words = VL_WORDS_I(obits); \
+    for (int i=0; i < words; i++) owp[i] = svar.read().get_word(i); \
+    owp[words-1] &= VL_MASK_I(obits); \
+}
+
+// Copying verilog format from systemc integers and bit vectors.
+
+#define VL_ASSIGN_SII(obits,svar,vvar) { (svar).write(vvar); }
 #define VL_ASSIGN_SQQ(obits,svar,vvar) { (svar).write(vvar); }
 
-#define VL_ASSIGN_SQ(obits,svar,rd) { \
+#define VL_ASSIGN_SWI(obits,svar,rd) { \
+    sc_bv<obits> _bvtemp; \
+    _bvtemp.set_word(0,rd); \
+    svar.write(_bvtemp); \
+}
+#define VL_ASSIGN_SWQ(obits,svar,rd) { \
     sc_bv<obits> _bvtemp; \
     _bvtemp.set_word(0,rd); \
     _bvtemp.set_word(1,rd>>VL_WORDSIZE); \
     svar.write(_bvtemp); \
 }
-#define VL_ASSIGN_QS(obits,od,svar) { \
-    od = (((QData)svar.read().get_word(1))<<VL_WORDSIZE | svar.read().get_word(0)) \
-	& VL_MASK_Q(obits); \
-}
-
-#define VL_ASSIGN_SW(obits,svar,rwp) { \
+#define VL_ASSIGN_SWW(obits,svar,rwp) { \
     sc_bv<obits> _bvtemp; \
     for (int i=0; i < VL_WORDS_I(obits); i++) _bvtemp.set_word(i,rwp[i]); \
     svar.write(_bvtemp); \
 }
-#define VL_ASSIGN_WS(obits,owp,svar) { \
-    int words = VL_WORDS_I(obits); \
-    for (int i=0; i < words; i++) owp[i] = svar.read().get_word(i); \
-    owp[words-1] &= VL_MASK_I(obits); \
-}
 
 //===================================================================
 // Extending sizes
@@ -416,7 +442,7 @@ static inline QData VL_EXTENDS_QQ(int, int lbits, QData lhs) {
 
 static inline WDataOutP VL_EXTENDS_WI(int obits, int lbits, WDataOutP owp, IData ld) {
     IData sign = VL_SIGNONES_I(lbits,ld);
-    owp[0] = ld | sign & ~VL_MASK_I(lbits);
+    owp[0] = ld | (sign & ~VL_MASK_I(lbits));
     for (int i=1; i < VL_WORDS_I(obits); i++) owp[i] = sign;
     return(owp);
 }
@@ -431,7 +457,7 @@ static inline WDataOutP VL_EXTENDS_WW(int obits, int lbits, WDataOutP owp, WData
     for (int i=0; i < VL_WORDS_I(lbits)-1; i++) owp[i] = lwp[i];
     int lmsw=VL_WORDS_I(lbits)-1;
     IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]);
-    owp[lmsw] = lwp[lmsw] | sign & ~VL_MASK_I(lbits);
+    owp[lmsw] = lwp[lmsw] | (sign & ~VL_MASK_I(lbits));
     for (int i=VL_WORDS_I(lbits); i < VL_WORDS_I(obits); i++) owp[i] = sign;
     return(owp);
 }
@@ -460,43 +486,60 @@ static inline IData VL_REDOR_W(int words, WDataInP lwp) {
 }
 
 // EMIT_RULE: VL_REDXOR:  oclean=dirty; obits=1;
-static inline IData VL_REDXOR_W(int words, WDataInP lwp) {
-    IData r = lwp[0];
-    for (int i=1; i < words; i++) r ^= lwp[i];
-    r=(r^(r>>1));
-    r=(r^(r>>2));
-    r=(r^(r>>4));
-    r=(r^(r>>8));
-    r=(r^(r>>16));
-    return r;
-}
 static inline IData VL_REDXOR_2(IData r) {
+    // Experiments show VL_REDXOR_2 is faster than __builtin_parityl
     r=(r^(r>>1));
     return r;
 }
 static inline IData VL_REDXOR_4(IData r) {
+#if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(VL_NO_BUILTINS)
+    return __builtin_parityl(r);
+#else
     r=(r^(r>>1)); r=(r^(r>>2));
     return r;
+#endif
 }
 static inline IData VL_REDXOR_8(IData r) {
+#if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(VL_NO_BUILTINS)
+    return __builtin_parityl(r);
+#else
     r=(r^(r>>1)); r=(r^(r>>2)); r=(r^(r>>4));
     return r;
+#endif
 }
 static inline IData VL_REDXOR_16(IData r) {
+#if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(VL_NO_BUILTINS)
+    return __builtin_parityl(r);
+#else
     r=(r^(r>>1)); r=(r^(r>>2)); r=(r^(r>>4)); r=(r^(r>>8));
     return r;
+#endif
 }
 static inline IData VL_REDXOR_32(IData r) {
+#if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(VL_NO_BUILTINS)
+    return __builtin_parityl(r);
+#else
     r=(r^(r>>1)); r=(r^(r>>2)); r=(r^(r>>4)); r=(r^(r>>8)); r=(r^(r>>16));
     return r;
+#endif
 }
 static inline IData VL_REDXOR_64(QData r) {
+#if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(VL_NO_BUILTINS)
+    return __builtin_parityll(r);
+#else
     r=(r^(r>>1)); r=(r^(r>>2)); r=(r^(r>>4)); r=(r^(r>>8)); r=(r^(r>>16)); r=(r^(r>>32));
     return r;
+#endif
+}
+static inline IData VL_REDXOR_W(int words, WDataInP lwp) {
+    IData r = lwp[0];
+    for (int i=1; i < words; i++) r ^= lwp[i];
+    return VL_REDXOR_32(r);
 }
 
 // EMIT_RULE: VL_COUNTONES_II:  oclean = false; lhs clean
 static inline IData VL_COUNTONES_I(IData lhs) {
+    // This is faster than __builtin_popcountl
     IData r = lhs - ((lhs >> 1) & 033333333333) - ((lhs >> 2) & 011111111111);
     r = (r + (r>>3)) & 030707070707;
     r = (r + (r>>6));
@@ -513,10 +556,10 @@ static inline IData VL_COUNTONES_W(int words, WDataInP lwp) {
 }
 
 static inline IData VL_ONEHOT_I(IData lhs) {
-    return ((lhs & (lhs-1))==0 & lhs!=0);
+    return (((lhs & (lhs-1))==0) & (lhs!=0));
 }
 static inline IData VL_ONEHOT_Q(QData lhs) {
-    return ((lhs & (lhs-1))==0 & lhs!=0);
+    return (((lhs & (lhs-1))==0) & (lhs!=0));
 }
 static inline IData VL_ONEHOT_W(int words, WDataInP lwp) {
     IData one=0;
@@ -548,6 +591,36 @@ static inline IData VL_ONEHOT0_W(int words, WDataInP lwp) {
     return 1;
 }
 
+static inline IData VL_CLOG2_I(IData lhs) {
+    // There are faster algorithms, or fls GCC4 builtins, but rarely used
+    if (!lhs) return 0;
+    lhs--;
+    int shifts=0;
+    for (; lhs!=0; shifts++) lhs = lhs >> 1;
+    return shifts;
+}
+static inline IData VL_CLOG2_Q(QData lhs) {
+    if (!lhs) return 0;
+    lhs--;
+    int shifts=0;
+    for (; lhs!=0; shifts++) lhs = lhs >> VL_ULL(1);
+    return shifts;
+}
+static inline IData VL_CLOG2_W(int words, WDataInP lwp) {
+    IData adjust = (VL_COUNTONES_W(words,lwp)==1) ? 0 : 1;
+    for (int i=words-1; i>=0; i--) {
+	if (lwp[i]) {
+	    for (int bit=31; bit>=0; bit--) {
+		if (VL_UNLIKELY(VL_BITISSET_I(lwp[i],bit))) {
+		    return i*VL_WORDSIZE + bit + adjust;
+		}
+	    }
+	    // Can't get here - one bit must be set
+	}
+    }
+    return 0;
+}
+
 //===================================================================
 // SIMPLE LOGICAL OPERATORS
 
@@ -829,7 +902,7 @@ static inline IData VL_POW_III(int, int, int rbits, IData lhs, IData rhs) {
     return out;
 }
 
-#define VL_POW_QQI(obits,lbits,rbits,lhs,rhs) VL_POW_QQQ(obits,lbits,rbits,lhs,rhs) 
+#define VL_POW_QQI(obits,lbits,rbits,lhs,rhs) VL_POW_QQQ(obits,lbits,rbits,lhs,rhs)
 
 static inline QData VL_POW_QQQ(int, int, int rbits, QData lhs, QData rhs) {
     if (lhs==0) return 0;
@@ -847,23 +920,23 @@ static inline QData VL_POW_QQQ(int, int, int rbits, QData lhs, QData rhs) {
 
 // INTERNAL: Stuff LHS bit 0++ into OUTPUT at specified offset
 // ld may be "dirty", output is clean
-static inline void _VL_INSERT_II(int, CData& lhsr, IData ld, int hbit, int lbit) { 
+static inline void _VL_INSERT_II(int, CData& lhsr, IData ld, int hbit, int lbit) {
     IData insmask = (VL_MASK_I(hbit-lbit+1))<<lbit;
     lhsr = (lhsr & ~insmask) | ((ld<<lbit) & insmask);
 }
-static inline void _VL_INSERT_II(int, SData& lhsr, IData ld, int hbit, int lbit) { 
+static inline void _VL_INSERT_II(int, SData& lhsr, IData ld, int hbit, int lbit) {
     IData insmask = (VL_MASK_I(hbit-lbit+1))<<lbit;
     lhsr = (lhsr & ~insmask) | ((ld<<lbit) & insmask);
 }
-static inline void _VL_INSERT_II(int, IData& lhsr, IData ld, int hbit, int lbit) { 
+static inline void _VL_INSERT_II(int, IData& lhsr, IData ld, int hbit, int lbit) {
     IData insmask = (VL_MASK_I(hbit-lbit+1))<<lbit;
     lhsr = (lhsr & ~insmask) | ((ld<<lbit) & insmask);
 }
-static inline void _VL_INSERT_QQ(int, QData& lhsr, QData ld, int hbit, int lbit) { 
+static inline void _VL_INSERT_QQ(int, QData& lhsr, QData ld, int hbit, int lbit) {
     QData insmask = (VL_MASK_Q(hbit-lbit+1))<<lbit;
     lhsr = (lhsr & ~insmask) | ((ld<<lbit) & insmask);
 }
-static inline void _VL_INSERT_WI(int, WDataOutP owp, IData ld, int hbit, int lbit) { 
+static inline void _VL_INSERT_WI(int, WDataOutP owp, IData ld, int hbit, int lbit) {
     int hoffset = VL_BITBIT_I(hbit);
     int loffset = VL_BITBIT_I(lbit);
     if (hoffset==VL_SIZEBITS_I && loffset==0) {
@@ -888,7 +961,7 @@ static inline void _VL_INSERT_WI(int, WDataOutP owp, IData ld, int hbit, int lbi
 
 // INTERNAL: Stuff large LHS bit 0++ into OUTPUT at specified offset
 // lwp may be "dirty"
-static inline void _VL_INSERT_WW(int, WDataOutP owp, WDataInP lwp, int hbit, int lbit) { 
+static inline void _VL_INSERT_WW(int, WDataOutP owp, WDataInP lwp, int hbit, int lbit) {
     int hoffset = hbit & VL_SIZEBITS_I;
     int loffset = lbit & VL_SIZEBITS_I;
     int lword = VL_BITWORD_I(lbit);
@@ -917,16 +990,16 @@ static inline void _VL_INSERT_WW(int, WDataOutP owp, WDataInP lwp, int hbit, int
 	    {	// Lower word
 		int oword = lword+i;
 		IData d = lwp[i]<<loffset;
-		IData od = owp[oword] & ~linsmask | d & linsmask;
-		if (oword==hword) owp[oword] = owp[oword] & ~hinsmask | od & hinsmask;
+		IData od = (owp[oword] & ~linsmask) | (d & linsmask);
+		if (oword==hword) owp[oword] = (owp[oword] & ~hinsmask) | (od & hinsmask);
 		else owp[oword] = od;
 	    }
 	    {   // Upper word
 		int oword = lword+i+1;
 		if (oword <= hword) {
 		    IData d = lwp[i]>>nbitsonright;
-		    IData od = d & ~linsmask | owp[oword] & linsmask;
-		    if (oword==hword) owp[oword] = owp[oword] & ~hinsmask | od & hinsmask;
+		    IData od = (d & ~linsmask) | (owp[oword] & linsmask);
+		    if (oword==hword) owp[oword] = (owp[oword] & ~hinsmask) | (od & hinsmask);
 		    else owp[oword] = od;
 		}
 	    }
@@ -934,7 +1007,7 @@ static inline void _VL_INSERT_WW(int, WDataOutP owp, WDataInP lwp, int hbit, int
     }
 }
 
-static inline void _VL_INSERT_WQ(int obits, WDataOutP owp, QData ld, int hbit, int lbit) { 
+static inline void _VL_INSERT_WQ(int obits, WDataOutP owp, QData ld, int hbit, int lbit) {
     WData lwp[2]; VL_SET_WQ(lwp,ld);
     _VL_INSERT_WW(obits,owp,lwp,hbit,lbit);
 }
@@ -1114,12 +1187,12 @@ static inline IData VL_SHIFTRS_III(int obits, int, int, IData lhs, IData rhs) {
     // Note the C standard does not specify the >> operator as a arithmetic shift!
     IData sign    = -(lhs >> (obits-1)); // ffff_ffff if negative
     IData signext = ~(VL_MASK_I(obits) >> rhs);   // One with bits where we've shifted "past"
-    return (lhs >> rhs) | sign & VL_CLEAN_II(obits,obits,signext);
+    return (lhs >> rhs) | (sign & VL_CLEAN_II(obits,obits,signext));
 }
 static inline QData VL_SHIFTRS_QQI(int obits, int, int, QData lhs, IData rhs) {
     QData sign    = -(lhs >> (obits-1));
     QData signext = ~(VL_MASK_Q(obits) >> rhs);
-    return (lhs >> rhs) | sign & VL_CLEAN_QQ(obits,obits,signext);
+    return (lhs >> rhs) | (sign & VL_CLEAN_QQ(obits,obits,signext));
 }
 static inline WDataOutP VL_SHIFTRS_WWI(int obits,int,int,WDataOutP owp,WDataInP lwp, IData rd) {
     int word_shift = VL_BITWORD_I(rd);
@@ -1164,7 +1237,7 @@ static inline IData VL_BITSEL_IWII(int, int lbits, int, int, WDataInP lwp, IData
     int word = VL_BITWORD_I(rd);
     if ((int)rd>lbits) {
 	return ~0; // Spec says you can go outside the range of a array.  Don't coredump if so.
-	// We return all 1's as that's more likely to find bugs (?) then 0's.
+	// We return all 1's as that's more likely to find bugs (?) than 0's.
     } else {
 	return (lwp[word]>>VL_BITBIT_I(rd));
     }
@@ -1214,7 +1287,7 @@ static inline QData VL_SEL_QWII(int, int lbits, int, int, WDataInP lwp, IData ls
 static inline WDataOutP VL_SEL_WWII(int obits,int lbits,int,int,WDataOutP owp,WDataInP lwp, IData lsb, IData width) {
     int msb = lsb+width-1;
     int word_shift = VL_BITWORD_I(lsb);
-    if (msb>lbits) { // Outside bounds, 
+    if (msb>lbits) { // Outside bounds,
 	for (int i=0; i<VL_WORDS_I(obits)-1; i++) owp[i] = ~0;
 	owp[VL_WORDS_I(obits)-1] = VL_MASK_I(obits);
     } else if (VL_BITBIT_I(lsb)==0) {
@@ -1288,126 +1361,61 @@ static inline WDataOutP VL_COND_WIWW(int obits, int, int, int,
 // VL_CONST_W_#X(int obits, WDataOutP owp, IData data0, .... IData data(#-1))
 // Sets wide vector words to specified constant words, zeros upper data.
 
-#define I IData
+// If changing the number of functions here, also change EMITCINLINES_NUM_CONSTW
+
 #define _END(obits,wordsSet) \
     for(int i=(wordsSet);i<VL_WORDS_I(obits);i++) o[i] = (IData)0x0; \
     return o
 
+#define VL_HAVE_CONST_W_1X
 static inline WDataOutP VL_CONST_W_1X(int obits, WDataOutP o,
-				      I d0) {
+				      IData d0) {
     o[0]=d0;
     _END(obits,1);  }
+#define VL_HAVE_CONST_W_2X
 static inline WDataOutP VL_CONST_W_2X(int obits, WDataOutP o,
-				      I d1,I d0) {
+				      IData d1,IData d0) {
     o[0]=d0;  o[1]=d1;
     _END(obits,2);  }
+#define VL_HAVE_CONST_W_3X
 static inline WDataOutP VL_CONST_W_3X(int obits, WDataOutP o,
-				      I d2,I d1,I d0) {
+				      IData d2,IData d1,IData d0) {
     o[0]=d0;  o[1]=d1;  o[2]=d2;
     _END(obits,3);  }
-static inline WDataOutP VL_CONST_W_4X(int obits, WDataOutP o, 
-				      I d3,I d2,I d1,I d0) {
+#define VL_HAVE_CONST_W_4X
+static inline WDataOutP VL_CONST_W_4X(int obits, WDataOutP o,
+				      IData d3,IData d2,IData d1,IData d0) {
     o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;
     _END(obits,4);  }
-static inline WDataOutP VL_CONST_W_5X(int obits, WDataOutP o, 
-				      I d4,I d3,I d2,I d1,I d0) {
+#define VL_HAVE_CONST_W_5X
+static inline WDataOutP VL_CONST_W_5X(int obits, WDataOutP o,
+				      IData d4,IData d3,IData d2,IData d1,IData d0) {
     o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;
     _END(obits,5);  }
-static inline WDataOutP VL_CONST_W_6X(int obits, WDataOutP o, 
-				      I d5,I d4,I d3,I d2,I d1,I d0) {
+#define VL_HAVE_CONST_W_6X
+static inline WDataOutP VL_CONST_W_6X(int obits, WDataOutP o,
+				      IData d5,IData d4,IData d3,IData d2,IData d1,IData d0) {
     o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;
     _END(obits,6);  }
-static inline WDataOutP VL_CONST_W_7X(int obits, WDataOutP o, 
-				      I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
+#define VL_HAVE_CONST_W_7X
+static inline WDataOutP VL_CONST_W_7X(int obits, WDataOutP o,
+				      IData d6,IData d5,IData d4,IData d3,IData d2,IData d1,IData d0) {
     o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;
     _END(obits,7);  }
-static inline WDataOutP VL_CONST_W_8X(int obits, WDataOutP o, 
-				      I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
+#define VL_HAVE_CONST_W_8X
+static inline WDataOutP VL_CONST_W_8X(int obits, WDataOutP o,
+				      IData d7,IData d6,IData d5,IData d4,IData d3,IData d2,IData d1,IData d0) {
     o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
     _END(obits,8);  }
-static inline WDataOutP VL_CONST_W_9X(int obits, WDataOutP o, 
-				      I d8,
-				      I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
+#define VL_HAVE_CONST_W_9X
+static inline WDataOutP VL_CONST_W_9X(int obits, WDataOutP o,
+				      IData d8,
+				      IData d7,IData d6,IData d5,IData d4,IData d3,IData d2,IData d1,IData d0) {
     o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
     o[8]=d8;
     _END(obits,9);  }
-static inline WDataOutP VL_CONST_W_10X(int obits, WDataOutP o, 
-				       I d9,I d8,
-				       I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
-    o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
-    o[8]=d8;  o[9]=d9;
-    _END(obits,10);  }
-static inline WDataOutP VL_CONST_W_11X(int obits, WDataOutP o, 
-				       I d10,I d9,I d8,
-				       I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
-    o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
-    o[8]=d8;  o[9]=d9;  o[10]=d10;
-    _END(obits,11);  }
-static inline WDataOutP VL_CONST_W_12X(int obits, WDataOutP o, 
-				       I d11,I d10,I d9,I d8,
-				       I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
-    o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
-    o[8]=d8;  o[9]=d9;  o[10]=d10; o[11]=d11;
-    _END(obits,12);  }
-static inline WDataOutP VL_CONST_W_16X(int obits, WDataOutP o, 
-				       I d15,I d14,I d13,I d12,I d11,I d10,I d9,I d8,
-				       I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
-    o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
-    o[8]=d8;  o[9]=d9;  o[10]=d10;  o[11]=d11;  o[12]=d12;  o[13]=d13;  o[14]=d14;  o[15]=d15;
-    _END(obits,16);  }
-static inline WDataOutP VL_CONST_W_17X(int obits, WDataOutP o, 
-				       I d16,
-				       I d15,I d14,I d13,I d12,I d11,I d10,I d9,I d8,
-				       I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
-    o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
-    o[8]=d8;  o[9]=d9;  o[10]=d10;  o[11]=d11;  o[12]=d12;  o[13]=d13;  o[14]=d14;  o[15]=d15;
-    o[16]=d16;
-    _END(obits,17);  }
-static inline WDataOutP VL_CONST_W_18X(int obits, WDataOutP o, 
-				       I d17,I d16,
-				       I d15,I d14,I d13,I d12,I d11,I d10,I d9,I d8,
-				       I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
-    o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
-    o[8]=d8;  o[9]=d9;  o[10]=d10;  o[11]=d11;  o[12]=d12;  o[13]=d13;  o[14]=d14;  o[15]=d15;
-    o[16]=d16;  o[17]=d17;
-    _END(obits,18);  }
-static inline WDataOutP VL_CONST_W_19X(int obits, WDataOutP o, 
-				       I d18,I d17,I d16,
-				       I d15,I d14,I d13,I d12,I d11,I d10,I d9,I d8,
-				       I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
-    o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
-    o[8]=d8;  o[9]=d9;  o[10]=d10;  o[11]=d11;  o[12]=d12;  o[13]=d13;  o[14]=d14;  o[15]=d15;
-    o[16]=d16;  o[17]=d17;  o[18]=d18;
-    _END(obits,19);  }
-static inline WDataOutP VL_CONST_W_20X(int obits, WDataOutP o, 
-				       I d19,I d18,I d17,I d16,
-				       I d15,I d14,I d13,I d12,I d11,I d10,I d9,I d8,
-				       I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
-    o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
-    o[8]=d8;  o[9]=d9;  o[10]=d10;  o[11]=d11;  o[12]=d12;  o[13]=d13;  o[14]=d14;  o[15]=d15;
-    o[16]=d16;  o[17]=d17;  o[18]=d18;  o[19]=d19;
-    _END(obits,20);  }
-static inline WDataOutP VL_CONST_W_24X(int obits, WDataOutP o, 
-				       I d23,I d22,I d21,I d20,I d19,I d18,I d17,I d16,
-				       I d15,I d14,I d13,I d12,I d11,I d10,I d9,I d8,
-				       I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
-    o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
-    o[8]=d8;  o[9]=d9;  o[10]=d10;  o[11]=d11;  o[12]=d12;  o[13]=d13;  o[14]=d14;  o[15]=d15;
-    o[16]=d16;  o[17]=d17;  o[18]=d18;  o[19]=d19;  o[20]=d20;  o[21]=d21;  o[22]=d22;  o[23]=d23;
-    _END(obits,24);  }
-static inline WDataOutP VL_CONST_W_28X(int obits, WDataOutP o, 
-				       I d27,I d26,I d25,I d24,
-				       I d23,I d22,I d21,I d20,I d19,I d18,I d17,I d16,
-				       I d15,I d14,I d13,I d12,I d11,I d10,I d9,I d8,
-				       I d7,I d6,I d5,I d4,I d3,I d2,I d1,I d0) {
-    o[0]=d0;  o[1]=d1;  o[2]=d2;  o[3]=d3;  o[4]=d4;  o[5]=d5;  o[6]=d6;  o[7]=d7;
-    o[8]=d8;  o[9]=d9;  o[10]=d10;  o[11]=d11;  o[12]=d12;  o[13]=d13;  o[14]=d14;  o[15]=d15;
-    o[16]=d16;  o[17]=d17;  o[18]=d18;  o[19]=d19;  o[20]=d20;  o[21]=d21;  o[22]=d22;  o[23]=d23;
-    o[24]=d24;  o[25]=d25;  o[26]=d26;  o[27]=d27;
-    _END(obits,28);  }
 
 #undef _END
-#undef I
 
 // Debugging
 

include/verilated.mk.in

@@ -1,10 +1,10 @@
-# $Id$ -*- Makefile -*-
+# -*- Makefile -*-
 ######################################################################
 # DESCRIPTION: Makefile commands for all verilated target files
 #
-# Copyright 2003-2007 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
-# General Public License or the Perl Artistic License.
+# Copyright 2003-2009 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.
 ######################################################################
 
 PERL = @PERL@
@@ -28,6 +28,7 @@ VK_CPPFLAGS_ALWAYS += \
 		-I$(VERILATOR_ROOT)/include \
 		-DVL_PRINTF=printf \
 		-DVM_TRACE=$(VM_TRACE) \
+		-DVM_COVERAGE=$(VM_COVERAGE) \
 
 ifeq ($(VERILATOR_AUTHOR_SITE),1)	# Local... Else don't burden users
 VK_CPPFLAGS_WALL += -Wall \
@@ -44,21 +45,26 @@ CPPFLAGS += -I. $(VK_CPPFLAGS_ALWAYS) $(VK_CPPFLAGS_WALL)
 VPATH += ..
 VPATH += $(VERILATOR_ROOT)/include
 
-#OPT = -ggdb -DPRINTINITSTR -DDETECTCHANGE 
+#OPT = -ggdb -DPRINTINITSTR -DDETECTCHANGE
 #OPT = -ggdb -DPRINTINITSTR
 CPPFLAGS += $(OPT)
 
 CPPFLAGS += $(M32)
-LDFLAGS += $(M32)
+LDFLAGS  += $(M32)
+
+# Allow upper level user makefiles to specify flags they want.
+# These aren't ever set by Verilator, so users are free to override them.
+CPPFLAGS += $(USER_CPPFLAGS)
+LDFLAGS  += $(USER_LDFLAGS)
 
 # See the benchmarking section of bin/verilator.
 # Support class optimizations.  This includes the tracing and symbol table.
 # SystemC takes minutes to optimize, thus it is off by default.
-#OPT_SLOW = 
+#OPT_SLOW =
 # Fast path optimizations.  Most time is spent in these classes.
 #OPT_FAST = -O2 -fstrict-aliasing
 #OPT_FAST = -O
-#OPT_FAST = 
+#OPT_FAST =
 
 #######################################################################
 ##### Aggregates
@@ -72,7 +78,6 @@ VM_SUPPORT += $(VM_SUPPORT_FAST) $(VM_SUPPORT_SLOW)
 ifeq ($(VM_SP_OR_SC),1)
   CPPFLAGS += $(SYSTEMC_CXX_FLAGS) -I$(SYSTEMC)/include
   LDFLAGS  += $(SYSTEMC_CXX_FLAGS) -L$(SYSTEMC)/lib-$(VM_SC_TARGET_ARCH)
-  LIBS     += -lm -lstdc++
   SC_LIBS   = -lsystemc
  ifneq ($(wildcard $(SYSTEMC)/lib-$(VM_SC_TARGET_ARCH)/*numeric_bit*),)
   # Systemc 1.2.1beta
@@ -84,8 +89,9 @@ endif
 ##### SystemPerl builds
 
 ifeq ($(VM_SP),1)
-  CPPFLAGS += -I$(SYSTEMPERL)/src -DSYSTEMPERL
-  VPATH    +=   $(SYSTEMPERL)/src
+  CPPFLAGS += -I$(SYSTEMPERL_INCLUDE) -DSYSTEMPERL
+  VPATH    +=   $(SYSTEMPERL_INCLUDE)
+  LIBS   += -lm -lstdc++
 
   VK_CLASSES_SP = $(addsuffix .sp, $(VM_CLASSES))
 
@@ -98,14 +104,25 @@ else
   preproc:
 endif
 
+#######################################################################
+##### SystemC w/o SystemPerl builds
+
+ifeq ($(VM_SC),1)
+  LIBS   += -lm -lstdc++
+ ifeq ($(VM_TRACE),1)
+  CPPFLAGS += -I$(SYSTEMPERL_INCLUDE)
+  VPATH    +=   $(SYSTEMPERL_INCLUDE)
+ endif
+endif
+
 #######################################################################
 ##### C/H builds
 
 ifeq ($(VM_PCLI),1)
   LIBS   += -lm -lstdc++
  ifeq ($(VM_TRACE),1)
-  CPPFLAGS += -I$(SYSTEMPERL)/src
-  VPATH    +=   $(SYSTEMPERL)/src
+  CPPFLAGS += -I$(SYSTEMPERL_INCLUDE)
+  VPATH    +=   $(SYSTEMPERL_INCLUDE)
  endif
 endif
 

include/verilated.v

@@ -1,19 +1,20 @@
-// $Id$ -*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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.
-// 
+//
 //=========================================================================
 //
 // DESCRIPTION: Verilator: Include in verilog files to hide verilator defines
@@ -25,7 +26,7 @@
  `ifdef verilator `else
   `define coverage_block_off
  `endif
- 
+
  // Hide file descriptor difference
  `ifdef verilator
   `define verilator_file_descriptor reg [63:0]

include/verilatedos.h

@@ -1,15 +1,16 @@
-// $Id$ -*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// Lesser General Public License Version 3 or the Perl Artistic License.
+// Version 2.0.
 //
 // Verilator is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
-// 
+//
 //*************************************************************************
 ///
 /// \file
@@ -21,7 +22,7 @@
 ///	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.com/verilator
+/// Code available from: http://www.veripool.org/verilator
 ///
 //*************************************************************************
 
@@ -46,8 +47,8 @@
 # define VL_ATTR_ALIGNED(alignment)	///< Align structure to specified byte alignment
 # define VL_ATTR_NORETURN		///< Function does not ever return
 # define VL_ATTR_UNUSED			///< Function that may be never used
-# define VL_LIKELY(x)	(!!(x))		///< Boolean expression more often true then false
-# define VL_UNLIKELY(x)	(!!(x))		///< Boolean expression more often false then 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
 # define VL_PREFETCH_RD(p)		///< Prefetch data with read intent
 # define VL_PREFETCH_RW(p)		///< Prefetch data with read/write intent
 #endif
@@ -68,6 +69,9 @@
 # define VL_ULL(c) (c##ULL)	///< Add appropriate suffix to 64-bit constant
 #endif
 
+// This is not necessarily the same as #UL, depending on what the IData typedef is.
+#define VL_UL(c) ((IData)(c##UL))	///< Add appropriate suffix to 32-bit constant
+
 //=========================================================================
 // Basic integer types
 
@@ -81,36 +85,40 @@ typedef unsigned char           vluint8_t;	///< 8-bit unsigned type
 typedef unsigned short int      vluint16_t;	///< 16-bit unsigned type
 typedef long  			vlsint32_t;	///< 32-bit signed type
 typedef unsigned long           vluint32_t;	///< 32-bit unsigned type
-typedef long long      		vlsint64_t;	///< 64-bit signed type
+typedef long long		vlsint64_t;	///< 64-bit signed type
 typedef unsigned long long      vluint64_t;	///< 64-bit unsigned type
-#elif defined(_WIN32)
+#elif defined(_WIN32) && defined(_MSC_VER)
 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 long           uint32_t;	///< 32-bit unsigned type (backward compatibility)
+typedef unsigned int		uint32_t;	///< 32-bit unsigned type (backward compatibility)
 typedef unsigned char           vluint8_t;	///< 8-bit unsigned type
 typedef unsigned short int      vluint16_t;	///< 16-bit unsigned type
-typedef int  			vlsint32_t;	///< 32-bit signed type
+typedef int			vlsint32_t;	///< 32-bit signed type
 typedef unsigned int            vluint32_t;	///< 32-bit unsigned type
-typedef __int64      		vlsint64_t;	///< 64-bit signed type
+typedef __int64			vlsint64_t;	///< 64-bit signed type
 typedef unsigned __int64        vluint64_t;	///< 64-bit unsigned type
 #else // Linux or compliant Unix flavors, -m64
 # include <stdint.h>	// Linux and most flavors
 # 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 int			vlsint32_t;	///< 32-bit signed type
 typedef uint32_t		vluint32_t;	///< 32-bit signed type
-typedef long long      		vlsint64_t;	///< 64-bit signed type
+typedef long long		vlsint64_t;	///< 64-bit signed type
 typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 #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)
 
+/// Bytes this number of bits needs (1 bit=1 byte)
+#define VL_BYTES_I(nbits) (((nbits)+(VL_BYTESIZE-1))/VL_BYTESIZE)
 /// Words this number of bits needs (1 bit=1 word)
 #define VL_WORDS_I(nbits) (((nbits)+(VL_WORDSIZE-1))/VL_WORDSIZE)
 

include/verilatedsc.h

@@ -0,0 +1,51 @@
+// -*- C++ -*-
+//*************************************************************************
+//
+// Copyright 2009-2009 by Wilson Snyder. This program is free software; you can
+// redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License.
+// Version 2.0.
+//
+// Verilator is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+//*************************************************************************
+///
+/// \file
+/// \brief Verilator: Common include for all Verilated SystemC files
+///
+///	This file is included automatically by Verilator at the top of
+///	all SystemC files it generates.
+///
+/// Code available from: http://www.veripool.org/verilator
+///
+//*************************************************************************
+
+
+#ifndef _VERILATEDSC_H_
+#define _VERILATEDSC_H_ 1 ///< Header Guard
+
+#include "verilatedos.h"
+#include "systemc.h"
+
+//=============================================================================
+// VL_SC_BV_DATAP
+// We want to get a pointer to m_data in the sc_bv_base class,
+// but it is protected.  So make an exposing class, then use
+// cast magic to get at it.  Saves patching get_datap in SystemC.
+
+#define VL_SC_BV_DATAP(bv) (VlScBvExposer::sp_datap(bv))
+class VlScBvExposer : public sc_bv_base {
+public:
+    static uint32_t* sp_datap(const sc_bv_base& base) {
+	return static_cast<const VlScBvExposer*>(&base)->sp_datatp(); }
+    uint32_t* sp_datatp() const { return (uint32_t*)(m_data); }
+    // Above reads this protected element in sc_bv_base:
+    //   sc_digit* m_data; // data array
+};
+
+//=========================================================================
+
+#endif // guard

install-sh

@@ -115,7 +115,7 @@ fi
 if [ x"$dir_arg" != x ]; then
 	dst=$src
 	src=""
-	
+
 	if [ -d $dst ]; then
 		instcmd=:
 	else

mkinstalldirs

@@ -4,8 +4,6 @@
 # Created: 1993-05-16
 # Public domain
 
-# $Id:$
-
 errstatus=0
 
 for file

nodist/bisondiff

@@ -0,0 +1,85 @@
+#!/usr/bin/perl -w
+######################################################################
+#
+# Copyright 2007-2009 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.
+#
+# 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.
+#
+######################################################################
+
+# DESCRIPTION: Diff bison files
+
+use Getopt::Long;
+use IO::File;
+use strict;
+
+our $Debug;
+our $Opt_Unsup;
+
+if (! GetOptions (
+	  #"help"	=> \&usage,
+	  "debug"	=> sub { $Debug = 1; },
+	  "unsup!"	=> \$Opt_Unsup,		# Ignore unsupported
+    )) {
+    die "usage();"
+}
+
+diff($ARGV[0],$ARGV[1]);
+
+sub diff {
+    my $a=shift;
+    my $b=shift;
+
+    my $ta = "/tmp/bisondiff.$$.a";
+    my $tb = "/tmp/bisondiff.$$.b";
+
+    prep($a,$ta);
+    prep($b,$tb);
+
+    system("diff -u -w $ta $tb");
+}
+
+sub prep {
+    my $filename = shift;
+    my $wfilename = shift;
+
+    my $fh = IO::File->new("<$filename") or die "%Error: $! $filename";
+    my $fho = IO::File->new(">$wfilename") or die "%Error: $! writing $wfilename";
+
+    my %declared;
+    my %used;
+
+    my $body = 0;
+    my $rule = "";
+    my $skip = 1;
+    while (defined(my $line = $fh->getline)) {
+	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 "|"
+	}
+
+	# %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);
+    }
+}
+
+# Local Variables:
+# compile-command: "./bisondiff --unsup $WUP/Verilog/Parser/VParseBison.y ../src/verilog.y"
+# End:

nodist/bisonreader

@@ -0,0 +1,61 @@
+#!/usr/bin/perl -w
+######################################################################
+#
+# Copyright 2007-2009 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.
+#
+# 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.
+#
+######################################################################
+
+# DESCRIPTION: Debugging of bison output
+
+use strict;
+
+my $Debug;
+
+my %declared;
+my %used;
+
+my $body = 0;
+my $rule = "";
+my $lineno = 0;
+foreach my $line (<STDIN>) {
+    $lineno++;
+    chomp $line;
+    $line =~ s!//.*$!!g;
+    $line =~ s!\s+! !g;
+    next if $line eq '';
+    if ($line =~ m!^\%\%!) {
+	$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;
+	    }
+	}
+    }
+}
+
+# Local Variables:
+# compile-command: "./bisonreader < ../src/verilog.y"
+# End:

nodist/dot_importer

@@ -1,17 +1,5 @@
 #!/usr/bin/perl -w
-# $Id$
-######################################################################
-#
-# Copyright 2005-2007 by Wilson Snyder <[email protected]>.  This
-# program is free software; you can redistribute it and/or modify it under
-# the terms of either the GNU Lesser General Public License or the Perl
-# Artistic License.
-#
-# 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.
-#
+# See copyright, etc in below POD section.
 ######################################################################
 
 require 5.006_001;
@@ -50,7 +38,6 @@ cwrite ("graph_export.cpp");
 #----------------------------------------------------------------------
 
 sub usage {
-    print '$Id$ ', "\n";
     pod2usage(-verbose=>2, -exitval => 2);
     exit (1);
 }
@@ -120,7 +107,7 @@ sub cwrite {
     foreach my $edge (@Edges) {
 	$fh->printf("    new V3GraphEdge(gp, %s, %s, %s, %s);\n",
 		    $edge->{from}, $edge->{to},
-		    $edge->{weight}, $edge->{cutable}?"true":"false");	       
+		    $edge->{weight}, $edge->{cutable}?"true":"false");
     }
     $fh->print("}\n");
 }
@@ -156,9 +143,9 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2007 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 or the Perl Artistic License.
+Copyright 2005-2009 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
 

nodist/dot_pruner

@@ -1,17 +1,5 @@
 #!/usr/bin/perl -w
-# $Id$
-######################################################################
-#
-# Copyright 2005-2007 by Wilson Snyder <[email protected]>.  This
-# program is free software; you can redistribute it and/or modify it under
-# the terms of either the GNU Lesser General Public License or the Perl
-# Artistic License.
-#
-# 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.
-#
+# See copyright, etc in below POD section.
 ######################################################################
 
 require 5.006_001;
@@ -55,7 +43,6 @@ dotwrite();
 #----------------------------------------------------------------------
 
 sub usage {
-    print '$Id$ ', "\n";
     pod2usage(-verbose=>2, -exitval => 2);
     exit (1);
 }
@@ -175,7 +162,7 @@ __END__
 
 =head1 NAME
 
-dot_pruner - 
+dot_pruner -
 
 =head1 SYNOPSIS
 
@@ -197,9 +184,9 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2007 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 or the Perl Artistic License.
+Copyright 2005-2009 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
 

nodist/flexdiff

@@ -0,0 +1,61 @@
+#!/usr/bin/perl -w
+######################################################################
+#
+# Copyright 2007-2009 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.
+#
+# 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.
+#
+######################################################################
+
+# DESCRIPTION: Diff flex files
+
+use IO::File;
+use strict;
+
+my $Debug;
+
+diff($ARGV[0],$ARGV[1]);
+
+sub diff {
+    my $a=shift;
+    my $b=shift;
+
+    my $ta = "/tmp/flexdiff.$$.a";
+    my $tb = "/tmp/flexdiff.$$.b";
+
+    prep($a,$ta);
+    prep($b,$tb);
+
+    system("diff -u -w $ta $tb");
+}
+
+sub prep {
+    my $filename = shift;
+    my $wfilename = shift;
+
+    my $fh = IO::File->new("<$filename") or die "%Error: $! $filename";
+    my $fho = IO::File->new(">$wfilename") or die "%Error: $! writing $wfilename";
+
+    my %declared;
+    my %used;
+    my @lines;
+
+    while (defined(my $line = $fh->getline)) {
+	# Productions
+	$line =~ s/[ \t]{[^}]*?}/\t{}/g;
+	push @lines, $line;
+    }
+
+    #@lines = sort @lines;
+    $fho->print(@lines);
+}
+
+# Local Variables:
+# compile-command: "./flexdiff $WUP/Verilog/Parser/VParseLex.l ../src/verilog.l"
+# End:

nodist/invoke_iccr

@@ -0,0 +1,59 @@
+#!/usr/bin/perl -w
+# See copyright, etc in below POD section.
+######################################################################
+
+require 5.006_001;
+use strict;
+
+#======================================================================
+# main
+
+delete $ENV{MODULE_VERSION};
+_setup_modules();
+module('add','cadence_verif');
+exec('iccr',@ARGV);
+
+#######################################################################
+# Modules package
+
+sub _setup_modules {
+    # Load the 'module' command into the environment
+    my $init = "/sicortex/$ENV{DIRPROJECT_ARCH}/lib/Modules/default/init/perl";
+    (-f $init) or die "%Error: Script not found: $init,";
+    require $init;
+}
+
+#######################################################################
+__END__
+
+=pod
+
+=head1 NAME
+
+invoke_iccr - Invoke tool under "modules" command
+
+=head1 SYNOPSIS
+
+  invoke_iccr  {ncv arguments}
+
+=head1 DESCRIPTION
+
+=head1 DISTRIBUTION
+
+Copyright 2007-2009 by Wilson Snyder.  This package is free software; you
+can redistribute it and/or modify it under the terms of either the GNU
+Lesser General Public License Version 3 or the Perl Artistic License
+Version 2.0.
+
+=head1 AUTHORS
+
+Wilson Snyder <[email protected]>
+
+=head1 SEE ALSO
+
+=cut
+
+######################################################################
+### Local Variables:
+### compile-command: "./invoke_iccr -help"
+### End:

nodist/invoke_ncverilog

@@ -0,0 +1,59 @@
+#!/usr/bin/perl -w
+# See copyright, etc in below POD section.
+######################################################################
+
+require 5.006_001;
+use strict;
+
+#======================================================================
+# main
+
+delete $ENV{MODULE_VERSION};
+_setup_modules();
+module('add','cadence_verif');
+exec('ncverilog',@ARGV);
+
+#######################################################################
+# Modules package
+
+sub _setup_modules {
+    # Load the 'module' command into the environment
+    my $init = "/sicortex/$ENV{DIRPROJECT_ARCH}/lib/Modules/default/init/perl";
+    (-f $init) or die "%Error: Script not found: $init,";
+    require $init;
+}
+
+#######################################################################
+__END__
+
+=pod
+
+=head1 NAME
+
+invoke_ncverilog - Invoke tool under "modules" command
+
+=head1 SYNOPSIS
+
+  invoke_ncverilog  {ncv arguments}
+
+=head1 DESCRIPTION
+
+=head1 DISTRIBUTION
+
+Copyright 2005-2009 by Wilson Snyder.  This package is free software; you
+can redistribute it and/or modify it under the terms of either the GNU
+Lesser General Public License Version 3 or the Perl Artistic License
+Version 2.0.
+
+=head1 AUTHORS
+
+Wilson Snyder <[email protected]>
+
+=head1 SEE ALSO
+
+=cut
+
+######################################################################
+### Local Variables:
+### compile-command: "./invoke_ncverilog -help"
+### End:

nodist/leakchecking.txt

@@ -0,0 +1,4 @@
+export GLIBCPP_FORCE_NEW=1
+compile with -DVL_LEAK_CHECKS
+valgrind --tool=memcheck --leak-check=yes /home/wsnyder/src/verilator/v4/verilator/verilator_bin_dbg -MMD --bin /home/wsnyder/src/verilator/v4/verilator/verilator_bin_dbg --cc -f /home/wsnyder/src/verilator/v4/verilator/test_c/../test_v/input.vc top.v --no-skip-identical 2>&1 | tee ~/d/aa
+valgrind --tool=memcheck --leak-check=yes /home/wsnyder/src/verilator/v4/verilator/verilator_bin_dbg -MMD --bin /home/wsnyder/src/verilator/v4/verilator/verilator_bin_dbg --cc /home/wsnyder/src/verilator/v4/verilator/test_regress/t/t_case_huge.v --no-skip-identical -I/home/wsnyder/src/verilator/v4/verilator/test_regress/t 2>&1 | tee ~/d/aa

nodist/vtree_importer

@@ -1,17 +1,5 @@
 #!/usr/bin/perl -w
-# $Id$
-######################################################################
-#
-# Copyright 2005-2007 by Wilson Snyder <[email protected]>.  This
-# program is free software; you can redistribute it and/or modify it under
-# the terms of either the GNU Lesser General Public License or the Perl
-# Artistic License.
-#
-# 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.
-#
+# See copyright, etc in below POD section.
 ######################################################################
 
 require 5.006_001;
@@ -52,7 +40,6 @@ print '(query-replace-regexp "(\\([0-9a-z_]+\\))" "\\1" nil nil nil)',"\n";
 #----------------------------------------------------------------------
 
 sub usage {
-    print '$Id$ ', "\n";
     pod2usage(-verbose=>2, -exitval => 2);
     exit (1);
 }
@@ -292,7 +279,7 @@ sub p_var {
     }
     p "\t";
     {
-	local $Avoid_Hex=1; 
+	local $Avoid_Hex=1;
 	t1;
     }
     p "\t";
@@ -322,7 +309,7 @@ __END__
 
 =head1 NAME
 
-vtree_importer - 
+vtree_importer -
 
 =head1 SYNOPSIS
 
@@ -344,9 +331,9 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2007 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 or the Perl Artistic License.
+Copyright 2005-2009 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
 

readme.texi

@@ -1,6 +1,5 @@
 \input texinfo @c -*-texinfo-*-
 @c %**start of header
-$c $Id$
 @setfilename readme.info
 @settitle Verilator Installation
 @c %**end of header
@@ -15,25 +14,29 @@ $c $Id$
 This is the Verilator Package.
 
 @menu
-* Copyright::                   
-* Description::                 
-* Obtaining Distribution::      
-* Directory Structure::         
-* Supported Systems::           
-* Installation::                
-* Limitations::                 
+* Copyright::
+* Description::
+* Obtaining Distribution::
+* Directory Structure::
+* Supported Systems::
+* Installation::
+* Limitations::
 @end menu
 
 @node Copyright, Description, Top, Top
 @section Copyright
 
-This package is Copyright 2003-2007 by Wilson Snyder @email{wsnyder@@wsnyder.org}.
+This package is Copyright 2003-2009 by Wilson Snyder @email{wsnyder@@wsnyder.org}.
 
-You may distribute under the terms of either the GNU General Public License
-or the Artistic License, as specified in the Perl README file.
+Verilator is free software; you can redistribute it and/or modify it
+under the terms of either the GNU General Public License Version 3 or
+the Perl Artistic License Version 2.0.  (See the documentation for
+more details.)
 
-This code is provided with no warranty of any kind, and is used entirely at
-your own risk.
+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.
 
 @node Description, Obtaining Distribution, Copyright, Top
 @section Description
@@ -45,7 +48,7 @@ Verilator is invoked with parameters similar to GCC or Synopsys's VCS.  It
 reads the specified Verilog code, lints it, and optionally adds coverage
 code.  For C++ format, it outputs .cpp and .h files.  For SystemC format,
 it outputs .sp files for the SystemPerl preprocessor available at
-http://veripool.com.
+http://www.veripool.org.
 
 The resulting files are then compiled with C++.  The user writes a little
 C++ wrapper file, which instantiates the top level module.  This is
@@ -56,11 +59,11 @@ The resulting executable will perform the actual simulation.
 @node Obtaining Distribution, Directory Structure, Description, Top
 @section Obtaining Distribution
 
-The latest version is available at 
-@uref{http://veripool.com/verilator.htm}
+The latest version is available at
+@uref{http://www.veripool.org/verilator}
 
 Download the latest package from that site, and decompress.
-@samp{gunzip verilator_version.tar.gz ; tar xvf verilator_version.tar}
+@samp{tar xvzf verilator_version.tgz}
 
 @node Directory Structure, Supported Systems, Obtaining Distribution, Top
 @section Directory Structure
@@ -117,8 +120,8 @@ If you will be using SystemC, download and install Verilog-Perl,
 If you will be using SystemC, download and install System-Perl,
 @url{http://search.cpan.org/search?module=SystemC::Netlist}.  Note
 you'll need to set a @samp{SYSTEMPERL} environment variable to point
-to the downloaded kit (not the installed files.)  Also, make sure to
-do a @code{make sc_patch}.
+to the downloaded kit.  Optionally also set @samp{SYSTEMPERL_INCLUDE}
+to point to the installed headers.
 
 @item
 @code{cd} to the Verilator directory containing this README.
@@ -126,6 +129,12 @@ do a @code{make sc_patch}.
 @item
 Type @samp{./configure} to configure Verilator for your system.
 
+If you are configuring Verilator to be part of a RPM or other
+distribution package system, you may want to use the --enable-defenv
+configure flag.  This will take the current value of VERILATOR_ROOT,
+SYSTEMC, SYSTEMC_ARCH, SYSTEMPERL, and SYSTEMPERL_INCLUDE and build
+them as defaults into the executable.
+
 @item
 Type @samp{make} to compile Verilator.
 

src/.gitignore

@@ -1,3 +1,4 @@
+*~
 *.old
 config_build.h
 Makefile

src/0CodeNotes.pod

@@ -0,0 +1,70 @@
+=pod
+
+=head1 NAME
+
+Verilator Source Code Notes
+
+=head1 INTRODUCTION
+
+See also the Verilator internals presentation at http://www.veripool.org.
+
+=head1 VISITOR FUNCTIONS
+
+=head2 Passing Variables
+
+There's three ways data is passed between visitor functions.
+
+1. A visitor-class member variable.  This is generally for passing "parent"
+information down to children.  m_modp is a common example.  It's set to
+NULL in the constructor, where that node (AstModule visitor) sets it, then
+the children are iterated, then it's cleared.  Children under an AstModule
+will see it set, while nodes elsewhere will see it clear.  If there can be
+nested items (for example an AstFor under an AstFor) the variable needs to
+be save-set-restored in the AstFor visitor, otherwise exiting the lower for
+will loose the upper for's setting.
+
+2. User() attributes.  Each node has 4 ->user() number or ->userp() pointer
+utility values (a common technique lifted from graph traversal packages).
+A visitor first clears the one it wants to use by calling
+AstNode::user#ClearTree(), then it can mark any node's user() with whatever
+data it wants.  Readers just call nodep->user(), but may need to cast
+appropriately, so you'll often see nodep->userp()->castSOMETYPE().  At the
+top of each visitor are comments describing how the user() stuff applies to
+that visitor class.  For example:
+
+    // NODE STATE
+    // Cleared entire netlist
+    //   AstModule::user1p()     // bool. True to inline this module
+
+This says that at the AstNetlist user1ClearTree() is called.  Each
+AstModule's is user1() is used to indicate if we're going to inline it.
+
+These comments are important to make sure a user#() on a given AstNode type
+is never being used for two different purposes.
+
+Note that calling user#ClearTree is fast, it doesn't walk the tree, so it's
+ok to call fairly often.  For example, it's commonly called on every
+module.
+
+3. Parameters can be passed between the visitors in close to the "normal"
+function caller to callee way.  This is the second "vup" parameter that is
+ignored on most of the visitor functions.  V3Width does this, but it proved
+more messy than the above and is deprecated.  (V3Width was nearly the first
+module written.  Someday this scheme may be removed, as it slows the
+program down to have to pass vup everywhere.)
+
+=head1 DEBUGGING WITH GDB
+
+The test_regress/driver.pl script accepts --gdb to start Verilator under
+gdb.
+
+To break at a specific edit number which changed a node (presumably to find
+what made a <e####> line in the tree dumps):
+
+   watch AstNode::s_editCntGbl==####
+
+=head1 DISTRIBUTION
+
+Copyright 2008-2009 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/Makefile.in

@@ -1,15 +1,16 @@
-# $Id$ */
+# -*- Makefile -*-
 #*****************************************************************************
 #
 # DESCRIPTION: Verilator: Makefile for verilog source
 #
-# Code available from: http://www.veripool.com/verilator
+# Code available from: http://www.veripool.org/verilator
 #
 #*****************************************************************************
 #
-# Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+# Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 # redistribute it and/or modify it under the terms of either the GNU
-# General Public License or the Perl Artistic License.
+# 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
@@ -40,12 +41,16 @@ export OBJCACHE_HOSTS := $(shell rschedule --no-allow-reserved --similar hostnam
 endif
 
 ifeq ($(OBJCACHE_HOSTS),)
-export OBJCACHE := 
+export OBJCACHE :=
 else
 export OBJCACHE_JOBS := -j $(shell objcache --jobs "$(OBJCACHE_HOSTS)")
 export OBJCACHE := @objcache --read --write
 endif
 
+UNDER_GIT = $(wildcard ../.git/logs/HEAD)
+
+#*********************************************************************
+
 obj_opt:
 	mkdir $@
 obj_dbg:
@@ -71,10 +76,10 @@ dbg: ../verilator_bin_dbg
 
 prefiles::
 
-ifeq ($(VERILATOR_AUTHOR_SITE),1)	# Local... Else don't burden users
+ifneq ($(UNDER_GIT),)	# If local git tree... Else don't burden users
 prefiles:: config_rev.h
 # This output goes into srcdir, as we need to distribute it as part of the kit.
-config_rev.h:	config_rev.pl .svn/entries
+config_rev.h:	config_rev.pl ../.git/logs/HEAD
 	$(PERL) config_rev.pl . >$@
 endif
 
@@ -83,7 +88,6 @@ clean mostlyclean distclean maintainer-clean::
 	-rm -rf obj_* *.log *.dmp *.vpd core
 	-rm -f *.o *.d perlxsi.c *_gen_*
 	-rm -f *__gen*
-	-rm -f *.yy.* y.output y.tab.[cho] *_test
 	-rm -f .objcache*
 
 distclean maintainer-clean::

src/Makefile_obj.in

@@ -1,15 +1,16 @@
-# $Id$ -*- Makefile -*-
+# -*- Makefile -*-
 #*****************************************************************************
 #
 # DESCRIPTION: Verilator: Makefile for verilog source
 #
-# Code available from: http://www.veripool.com/verilator
+# Code available from: http://www.veripool.org/verilator
 #
 #*****************************************************************************
 #
-# Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+# Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 # redistribute it and/or modify it under the terms of either the GNU
-# General Public License or the Perl Artistic License.
+# 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
@@ -23,11 +24,27 @@
 srcdir = ..
 incdir = ../../include
 
-PERL = @PERL@
+# Programs
 CC = @CC@
 CXX = @CXX@
 LINK = @CXX@
+LEX = @LEX@
+LFLAGS = -d
+PERL = @PERL@
+YACC = @YACC@
 
+prefix = @prefix@
+
+# Directory in which to install data across multiple architectures
+datarootdir = @datarootdir@
+
+# Directory in which to install package specific files
+# Generally ${prefix}/share/verilator
+pkgdatadir = @pkgdatadir@
+
+# Compile options
+CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
+CPPFLAGSNOWALL += @CPPFLAGS@
 LDFLAGS += @LDFLAGS@
 
 #### End of system configuration section. ####
@@ -48,17 +65,12 @@ COPT = -ggdb -DVL_DEBUG
 endif
 #################
 
-LEX = @LEX@
-LFLAGS = -d
-YACC = @YACC@
-YFLAGS = -y -d -v
-
 #LIBS += -ldl
 #CCMALLOC = /usr/local/lib/ccmalloc-gcc.o -lccmalloc -ldl
 
 LIBS = -lm -lfl
 
-CPPFLAGSNOWALL = -MMD
+CPPFLAGSNOWALL += -MMD
 CPPFLAGSNOWALL += -I. -I$(srcdir) -I$(incdir)
 CPPFLAGSNOWALL += -DYYDEBUG 	# Required to get nice error messages
 #CPPFLAGSNOWALL += -DVL_LEAK_CHECKS 	# If running valgrind or other hunting tool
@@ -70,9 +82,30 @@ CPPFLAGS += -W -Wall -Wno-unused-parameter -Wno-char-subscripts -Werror
 #CPPFLAGS += -pedantic-errors
 endif
 
+ifneq ($(SYSTEMPERL),)	# Intuit SYSTEMPERL_INCLUDE as it's new
+ SYSTEMPERL_INCLUDE ?= $(SYSTEMPERL)/src
+#else if set, leave as-is.
+#else if SYSTEMPERL="" don't set _INCLUDE so source will figure it out
+endif
+
+# Allow RPM builds to specify hardcoded data directories
+# To do this:
+ifeq ($(CFG_WITH_DEFENV),yes)
+ CPPFLAGS += -DDEFENV_SYSTEMC=\"$(SYSTEMC)\"
+ CPPFLAGS += -DDEFENV_SYSTEMC_ARCH=\"$(SYSTEMC_ARCH)\"
+ CPPFLAGS += -DDEFENV_SYSTEMPERL=\"$(SYSTEMPERL)\"
+ CPPFLAGS += -DDEFENV_SYSTEMPERL_INCLUDE=\"$(SYSTEMPERL_INCLUDE)\"
+ ifeq ($(VERILATOR_ROOT),)	# Use what we're given, or intuit
+  CPPFLAGS += -DDEFENV_VERILATOR_ROOT=\"$(pkgdatadir)\"
+ else
+  CPPFLAGS += -DDEFENV_VERILATOR_ROOT=\"$(VERILATOR_ROOT)\"
+ endif
+endif
+
 HEADERS = $(wildcard V*.h v*.h)
 
 ASTGEN = $(srcdir)/astgen
+BISONPRE = $(srcdir)/bisonpre
 
 ######################################################################
 #### Top level
@@ -85,7 +118,6 @@ make_info:
 clean mostlyclean distclean maintainer-clean::
 	-rm -f *.o *.d perlxsi.c *_gen_*
 	-rm -f *__gen*
-	-rm -f *.yy.* y.output y.tab.[cho] *_test
 	-rm -f obj_* .objcache*
 
 distclean maintainer-clean:: clean
@@ -111,15 +143,19 @@ RAW_OBJS = \
 	V3Cast.o \
 	V3Changed.o \
 	V3Clean.o \
+	V3ClkGater.o \
 	V3Clock.o \
 	V3Combine.o \
 	V3Const__gen.o \
 	V3Coverage.o \
+	V3CoverageJoin.o \
 	V3Dead.o \
 	V3Delayed.o \
 	V3Depth.o \
+	V3DepthBlock.o \
 	V3Descope.o \
 	V3EmitC.o \
+	V3EmitCInlines.o \
 	V3EmitCSyms.o \
 	V3EmitMk.o \
 	V3EmitV.o \
@@ -164,6 +200,7 @@ RAW_OBJS = \
 	V3Task.o \
 	V3Trace.o \
 	V3TraceDecl.o \
+	V3Tristate.o \
 	V3Unknown.o \
 	V3Unroll.o \
 	V3Width.o \
@@ -191,15 +228,15 @@ $(TGT): V3Ast__gen_classes.h $(OBJS)
 	@echo "      Linking $@..."
 	-rm -rf $@ [email protected]
 	${LINK} ${LDFLAGS} -o $@ $(OBJS) $(CCMALLOC) ${LIBS}
-	@-cp [email protected] $@
-# ok if cp failes on linux, it's there to insure make works on NT
+	@-(cp [email protected] $@ || true)
+# ok if cp failes on linux, it's there to insure executable works on NT
 
 V3Number_test: V3Number_test.o
 	${LINK} ${LDFLAGS} -o $@ $^ ${LIBS}
 
 #### Modules
 
-%__gen.cpp:	%.cpp $(ASTGEN)
+%__gen.cpp:	%.cpp $(ASTGEN) V3Ast.h V3AstNodes.h
 	$(PERL) $(ASTGEN) -I$(srcdir) $*.cpp
 
 %.o:	%.cpp
@@ -207,10 +244,10 @@ V3Number_test: V3Number_test.o
 %.o:	%.c
 	$(OBJCACHE) ${CC}  ${CPPFLAGS} -c $<
 
-V3Read.o:	V3Read.cpp V3Lexer.yy.cpp
+V3Read.o:	V3Read.cpp V3Lexer.yy.cpp V3ParseBison.c
 	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
 
-V3Parse.o:	V3Parse.cpp y.tab.c
+V3Parse.o:	V3Parse.cpp V3ParseBison.c
 	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
 
 V3PreProc.o:	V3PreProc.cpp V3PreLex.yy.cpp
@@ -219,22 +256,27 @@ V3PreProc.o:	V3PreProc.cpp V3PreLex.yy.cpp
 #### Generated files
 
 # Target rule called before parallel build to make generated files
-serial:: V3Ast__gen_classes.h
+serial:: V3Ast__gen_classes.h V3ParseBison.c
 
 V3Ast__gen_classes.h : $(ASTGEN) V3Ast.h V3AstNodes.h
 	$(PERL) $(ASTGEN) -I$(srcdir)  --classes
 
-y.tab.c y.tab.h:	verilog.y $(HEADERS)
-	@echo "If you get errors from verilog.y below, try upgrading bison to version 1.875 or newer."
-	${YACC} ${YFLAGS} $<
+V3ParseBison.h: V3ParseBison.c
 
-V3Lexer_pregen.yy.cpp:	verilog.l y.tab.h $(HEADERS)
+# Have only one output file in this rule to prevent parallel make issues
+V3ParseBison.c: verilog.y $(BISONPRE)
+	@echo "If you get errors from verilog.y below, try upgrading bison to version 1.875 or newer."
+	$(PERL) $(BISONPRE) --yacc ${YACC} -d -v -o V3ParseBison.c $<
+
+V3Lexer_pregen.yy.cpp:	verilog.l V3ParseBison.h $(HEADERS)
+	${LEX} --version
 	${LEX} ${LFLAGS} -o$@ $<
 
 V3Lexer.yy.cpp:	V3Lexer_pregen.yy.cpp
 	$(PERL) $(srcdir)/flexfix <$< >$@
 
 V3PreLex_pregen.yy.cpp:	V3PreLex.l $(HEADERS)
+	${LEX} --version
 	${LEX} ${LFLAGS} -o$@ $<
 
 V3PreLex.yy.cpp:	V3PreLex_pregen.yy.cpp
@@ -247,4 +289,3 @@ DEPS := $(wildcard *.d)
 ifneq ($(DEPS),)
 include $(DEPS)
 endif
-

src/V3Active.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Break always into sensitivity active domains
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Active's Transformations:
-//		
+//
 // Note this can be called multiple times.
 //   Create a IACTIVE(initial), SACTIVE(combo)
 //	ALWAYS: Remove any-edges from sense list
@@ -33,8 +33,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <map>
 #include <algorithm>
@@ -44,6 +44,7 @@
 #include "V3Active.h"
 #include "V3Ast.h"
 #include "V3EmitCBase.h"
+#include "V3Const.h"
 
 //***** See below for main transformation engine
 
@@ -52,7 +53,11 @@
 
 class ActiveBaseVisitor : public AstNVisitor {
 protected:
-    //int debug() { return 9; }
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
 };
 
 class ActiveNamer : public ActiveBaseVisitor {
@@ -78,8 +83,8 @@ private:
 	// Don't clear scopep, the namer persists beyond this visit
     }
     virtual void visit(AstSenTree* nodep, AstNUser*) {
-	// Sort sensitivity list
-	nodep->sortSenses();
+	// Simplify sensitivity list
+	V3Const::constifyTreeExpensive(nodep);
     }
     // Empty visitors, speed things up
     virtual void visit(AstNodeStmt* nodep, AstNUser*) { }
@@ -130,7 +135,7 @@ public:
       found:
 	// Not found, form a new one
 	if (!activep) {
-	    AstSenTree* newsenp = sensesp->cloneTree(false)->castSenTree();
+	    AstSenTree* newsenp = sensesp->cloneTree(false);
 	    activep = new AstActive(fl, "sequent", newsenp);
 	    activep->sensesStorep(activep->sensesp());
 	    UINFO(8,"    New ACTIVE "<<activep<<endl);
@@ -186,10 +191,15 @@ public:
 class ActiveVisitor : public ActiveBaseVisitor {
 private:
     // NODE STATE
+    //  Each call to V3Const::constify
+    //   AstNode::user4()		Used by V3Const::constify, called below
 
     // STATE
     ActiveNamer	m_namer;	// Tracking of active names
     AstCFunc*   m_scopeFinalp;	// Final function for this scope
+    AstAlways*	m_alwaysp;	// Under always
+    bool	m_itemCombo;	// Found a SenItem combo
+    bool	m_itemSequent;	// Found a SenItem sequential
 
     // VISITORS
     virtual void visit(AstScope* nodep, AstNUser*) {
@@ -224,6 +234,13 @@ private:
 	nodep->unlinkFrBack();
 	wantactivep->addStmtsp(nodep);
     }
+    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+	// 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, AstNUser*) {
 	// Relink to CFUNC for the final
 	UINFO(4,"    FINAL "<<nodep<<endl);
@@ -246,6 +263,7 @@ private:
 	nodep->deleteTree(); nodep = NULL;
     }
 
+    // METHODS
     virtual void visit(AstAlways* nodep, AstNUser*) {
 	// Move always to appropriate ACTIVE based on its sense list
 	UINFO(4,"    ALW   "<<nodep<<endl);
@@ -256,7 +274,10 @@ private:
 	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
 	    return;
 	}
-	if (nodep->sensesp() && nodep->sensesp()->sensesp() && nodep->sensesp()->sensesp()->isNever()) {
+	if (nodep->sensesp()
+	    && nodep->sensesp()->sensesp()
+	    && nodep->sensesp()->sensesp()->castSenItem()
+	    && nodep->sensesp()->sensesp()->castSenItem()->isNever()) {
 	    // Never executing.  Kill it.
 	    if (nodep->sensesp()->sensesp()->nextp()) nodep->v3fatalSrc("Never senitem should be alone, else the never should be eliminated.");
 	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
@@ -264,24 +285,14 @@ private:
 	}
 
 	// Read sensitivitues
-	bool combo = false;
-	bool sequent = false;
-	if (nodep->sensesp()) {
-	    for (AstSenItem* nextp, *senp = nodep->sensesp()->sensesp(); senp; senp=nextp) {
-		nextp = senp->nextp()->castSenItem();
-		if (senp->edgeType() == AstEdgeType::ANYEDGE) {
-		    combo = true;
-		    // Delete the sensitivity
-		    // We'll add it as a generic COMBO SenItem in a moment.
-		    senp->unlinkFrBack()->deleteTree(); senp=NULL;
-		} else if (senp->varrefp()) {
-		    if (senp->varrefp()->width()>1) senp->v3error("Unsupported: Non-single bit wide signal pos/negedge sensitivity: "
-								  <<senp->varrefp()->prettyName());
-		    sequent = true;
-		    senp->varrefp()->varp()->usedClock(true);
-		}
-	    }
-	}
+	m_alwaysp = nodep;
+	m_itemCombo = false;
+	m_itemSequent = false;
+	nodep->sensesp()->iterateAndNext(*this);
+	m_alwaysp = NULL;
+	bool combo = m_itemCombo;
+	bool sequent = m_itemSequent;
+
 	if (!combo && !sequent) combo=true;	// If no list, Verilog 2000: always @ (*)
 #ifndef NEW_ORDERING
 	if (combo && sequent) {
@@ -320,6 +331,29 @@ private:
 	    ActiveDlyVisitor dlyvisitor (nodep);
 	}
     }
+    virtual void visit(AstSenGate* nodep, AstNUser*) {
+	AstSenItem* subitemp = nodep->sensesp();
+	if (subitemp->edgeType() != AstEdgeType::ANYEDGE
+	    && subitemp->edgeType() != AstEdgeType::POSEDGE
+	    && subitemp->edgeType() != AstEdgeType::NEGEDGE) {
+	    nodep->v3fatalSrc("Strange activity type under SenGate");
+	}
+	nodep->iterateChildren(*this);
+    }
+    virtual void visit(AstSenItem* nodep, AstNUser*) {
+	if (nodep->edgeType() == AstEdgeType::ANYEDGE) {
+	    m_itemCombo = true;
+	    // Delete the sensitivity
+	    // We'll add it as a generic COMBO SenItem in a moment.
+	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	} else if (nodep->varrefp()) {
+	    // V3LinkResolve should have cleaned most of these up
+	    if (nodep->varrefp()->width()>1) 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
     virtual void visit(AstNodeMath* nodep, AstNUser*) {}
@@ -332,6 +366,9 @@ public:
     // CONSTUCTORS
     ActiveVisitor(AstNode* nodep) {
 	m_scopeFinalp = NULL;
+	m_alwaysp = NULL;
+	m_itemCombo = false;
+	m_itemSequent = false;
 	nodep->accept(*this);
     }
     virtual ~ActiveVisitor() {}

src/V3Active.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Break always into sensitivity block domains
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3ActiveTop.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Break always into sensitivity active domains
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Active's Transformations:
-//		
+//
 // Note this can be called multiple times.
 //   Across all ACTIVES
 //	SenTrees are now under each ACTIVE statement, we want them global:
@@ -30,8 +30,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 #include <vector>
@@ -40,6 +40,7 @@
 #include "V3ActiveTop.h"
 #include "V3Ast.h"
 #include "V3SenTree.h"
+#include "V3Const.h"
 
 //######################################################################
 // Active class functions
@@ -49,10 +50,20 @@ private:
     // NODE STATE
     //  Entire netlist
     //   AstNode::user()		bool. True if processed
+    //  Each call to V3Const::constify
+    //   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
-    //int debug() { return 9; }
+
+    // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
 
     // VISITORS
     virtual void visit(AstTopScope* nodep, AstNUser*) {
@@ -71,8 +82,10 @@ private:
 	UINFO(4,"   ACTIVE "<<nodep<<endl);
 	AstSenTree* sensesp = nodep->sensesp();
 	if (!sensesp) nodep->v3fatalSrc("NULL");
-	sensesp->sortSenses();	// Remove duplicate clocks and such
-	if (sensesp->sensesp() && sensesp->sensesp()->isNever()) {
+	V3Const::constifyTreeExpensive(nodep);	// Remove duplicate clocks and such
+	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(); nodep=NULL;
@@ -134,7 +147,6 @@ public:
     // CONSTUCTORS
     ActiveTopVisitor(AstNetlist* nodep) {
 	m_topscopep = NULL;
-	AstNode::userClearTree();
 	nodep->accept(*this);
     }
     virtual ~ActiveTopVisitor() {}

src/V3ActiveTop.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Break always into sensitivity block domains
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3Assert.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Collect and print statistics
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2005-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -21,8 +21,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <map>
 #include <iomanip>
@@ -41,9 +41,11 @@ private:
     // NODE STATE/TYPES
     // Cleared on netlist
     //  AstNode::user()		-> bool.  True if processed
+    AstUser1InUse	m_inuser1;
 
     // STATE
     AstModule*	m_modp;		// Last module
+    AstBegin*	m_beginp;	// Last begin
     V3Double0	m_statAsCover;	// Statistic tracking
     V3Double0	m_statAsPsl;	// Statistic tracking
     V3Double0	m_statAsFull;	// Statistic tracking
@@ -63,6 +65,11 @@ private:
 	AstNode* timesp = nodep->exprsp(); if (timesp) timesp->unlinkFrBack();
 	timesp = timesp->addNext(new AstTime(nodep->fileline()));
 	nodep->exprsp(timesp);
+	if (!nodep->scopeNamep()
+	    && (nodep->name().find("%m") != string::npos
+		|| nodep->name().find("%M") != string::npos)) {
+	    nodep->scopeNamep(new AstScopeName(nodep->fileline()));
+	}
     }
 
     AstNode* newIfAssertOn(AstNode* nodep) {
@@ -98,19 +105,21 @@ private:
 	return bodysp;
     }
 
-    void newPslAssertion(AstNode* nodep, AstNode* propp, AstSenTree* sentreep, const string& message) {
+    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;	
+	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 coverage in PSL");
+		if (!covincp) snodep->v3fatalSrc("Missing AstCoverInc under assertion");
 		covincp->unlinkFrBack();
 		if (message!="") covincp->declp()->comment(message);
 		bodysp = covincp;
@@ -124,6 +133,7 @@ private:
 	} else {
 	    nodep->v3fatalSrc("Unknown node type");
 	}
+	if (stmtsp) bodysp = bodysp->addNext(stmtsp);
 	AstIf* ifp = new AstIf (nodep->fileline(), propp, bodysp, NULL);
 	bodysp = ifp;
 	if (nodep->castPslAssert()) ifp->branchPred(AstBranchPred::UNLIKELY);
@@ -169,8 +179,8 @@ private:
     // VISITORS  //========== Case assertions
     virtual void visit(AstCase* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
-	if (!nodep->user()) {
-	    nodep->user(true);
+	if (!nodep->user1()) {
+	    nodep->user1(true);
 	    bool has_default=false;
 	    for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
 		if (itemp->isDefault()) has_default=true;
@@ -230,12 +240,15 @@ private:
 
     virtual void visit(AstPslCover* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
-	newPslAssertion(nodep, nodep->propp(), nodep->sentreep(), nodep->name()); nodep=NULL;
+	if (m_beginp && nodep->name() == "") nodep->name(m_beginp->name());
+	newPslAssertion(nodep, nodep->propp(), nodep->sentreep(),
+			nodep->stmtsp(), nodep->name()); nodep=NULL;
 	m_statAsCover++;
     }
     virtual void visit(AstPslAssert* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
-	newPslAssertion(nodep, nodep->propp(), nodep->sentreep(), nodep->name()); nodep=NULL;
+	newPslAssertion(nodep, nodep->propp(), nodep->sentreep(),
+			NULL, nodep->name()); nodep=NULL;
 	m_statAsPsl++;
     }
     virtual void visit(AstVAssert* nodep, AstNUser*) {
@@ -251,6 +264,16 @@ private:
 	// Reset defaults
 	m_modp = NULL;
     }
+    virtual void visit(AstBegin* nodep, AstNUser*) {
+	// 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;
+    }
 
     // VISITORS  //========== Temporal Layer
 
@@ -266,9 +289,9 @@ private:
 public:
     // CONSTRUCTORS
     AssertVisitor(AstNetlist* nodep) {
+	m_beginp = NULL;
 	m_modp = NULL;
 	// Process
-	AstNode::userClearTree();	// userp() used on entire tree
 	nodep->accept(*this);
     }
     virtual ~AssertVisitor() {

src/V3Assert.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Assertion expansion
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2005-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3AssertPre.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Collect and print statistics
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2005-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -24,8 +24,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <map>
 #include <iomanip>
@@ -45,22 +45,33 @@ private:
     // NODE STATE/TYPES
     // STATE
     // Reset each module:
-    AstSenItem*	m_seniDefaultp;	// Default sensitivity (from AstDefClock)
+    AstNodeSenItem*	m_seniDefaultp;	// Default sensitivity (from AstDefClock)
     // Reset each assertion:
-    AstSenItem*	m_senip;	// Last sensitivity
-
-    int debug() { return 0; }
+    AstNodeSenItem*	m_senip;	// Last sensitivity
 
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     AstSenTree* newSenTree(AstNode* nodep) {
 	// Create sentree based on clocked or default clock
 	// Return NULL for always
 	AstSenTree* newp = NULL;
-	AstSenItem* senip = m_senip ? m_senip : m_seniDefaultp;
-	if (senip) newp = new AstSenTree(nodep->fileline(), senip->cloneTree(true));
-	if (!senip) nodep->v3error("Unsupported: Unclocked assertion");
+	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;
     }
+    void clearAssertInfo() {
+	m_senip = NULL;
+    }
 
     // VISITORS  //========== Statements
     virtual void visit(AstPslDefClock* nodep, AstNUser*) {
@@ -71,28 +82,47 @@ private:
 	nodep->unlinkFrBack();
 	pushDeletep(nodep); nodep=NULL;
     }
+    virtual void visit(AstClocking* nodep, AstNUser*) {
+	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); nodep=NULL;
+    }
 
     virtual void visit(AstPslCover* nodep, AstNUser*) {
-	// Prep
-	m_senip = NULL;
+	if (nodep->sentreep()) return;  // Already processed
+	clearAssertInfo();
 	nodep->iterateChildren(*this);
 	nodep->sentreep(newSenTree(nodep));
-	m_senip = NULL;
+	clearAssertInfo();
     }
     virtual void visit(AstPslAssert* nodep, AstNUser*) {
-	// Prep
-	m_senip = NULL;
+	if (nodep->sentreep()) return;  // Already processed
+	clearAssertInfo();
 	nodep->iterateChildren(*this);
 	nodep->sentreep(newSenTree(nodep));
-	m_senip = NULL;
+	clearAssertInfo();
     }
     virtual void visit(AstPslClocked* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	if (m_senip) {
 	    nodep->v3error("Unsupported: Only one PSL clock allowed per assertion\n");
 	}
-	// Unlink and just keep a pointer to it, convert to sentree as needed
+	// 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); nodep=NULL;
@@ -109,8 +139,8 @@ private:
 public:
     // CONSTRUCTORS
     AssertPreVisitor(AstNetlist* nodep) {
-	m_senip = NULL;
 	m_seniDefaultp = NULL;
+	clearAssertInfo();
 	// Process
 	nodep->accept(*this);
     }

src/V3AssertPre.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Assertion pre-expansion
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2005-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3Ast.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Ast node structures
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,8 +19,8 @@
 //
 //*************************************************************************
 
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <fstream>
 #include <iomanip>
 #include <memory>
@@ -40,11 +40,15 @@ vluint64_t AstNode::s_editCntLast=0;
 // along with each userp, and thus by bumping this count we can make it look
 // as if we iterated across the entire tree to set all the userp's to null.
 int AstNode::s_cloneCntGbl=0;
-int AstNode::s_userCntGbl=0;
-int AstNode::s_user2CntGbl=0;
-int AstNode::s_user3CntGbl=0;
-int AstNode::s_user4CntGbl=0;
-int AstNode::s_user5CntGbl=0;
+uint32_t AstUser1InUse::s_userCntGbl=0;	// Hot cache line, leave adjacent
+uint32_t AstUser2InUse::s_userCntGbl=0;	// Hot cache line, leave adjacent
+uint32_t AstUser3InUse::s_userCntGbl=0;	// Hot cache line, leave adjacent
+uint32_t AstUser4InUse::s_userCntGbl=0;	// Hot cache line, leave adjacent
+
+bool AstUser1InUse::s_userBusy=false;
+bool AstUser2InUse::s_userBusy=false;
+bool AstUser3InUse::s_userBusy=false;
+bool AstUser4InUse::s_userBusy=false;
 
 //######################################################################
 // V3AstType
@@ -71,16 +75,49 @@ void AstNode::init() {
     m_signed = false;
     m_width = 0;
     m_widthMin = 0;
-    m_userp = NULL;
-    m_userCnt = 0;
+    m_user1p = NULL;
+    m_user1Cnt = 0;
     m_user2p = NULL;
     m_user2Cnt = 0;
     m_user3p = NULL;
     m_user3Cnt = 0;
     m_user4p = NULL;
     m_user4Cnt = 0;
-    m_user5p = NULL;
-    m_user5Cnt = 0;
+}
+
+string AstNode::encodeName(const string& namein) {
+    // Encode signal name raw from parser, then not called again on same signal
+    const char* start = namein.c_str();
+    string out;
+    for (const char* pos = start; *pos; pos++) {
+	if ((pos==start) ? isalpha(pos[0])  // digits can't lead identifiers
+	    : isalnum(pos[0])) {
+	    out += pos[0];
+	} else if (pos[0]=='_') {
+	    if (pos[1]=='_') {
+		out += "_"; out += "__05F";  // hex(_) = 0x5F
+		pos++;
+	    } else {
+		out += pos[0];
+	    }
+	} else {
+	    // Need the leading 0 so this will never collide with
+	    // a user identifier nor a temp we create in Verilator.
+	    // We also do *NOT* use __DOT__ etc, as we search for those
+	    // in some replacements, and don't want to mangle the user's names.
+	    char hex[10]; sprintf(hex,"__0%02X",pos[0]);
+	    out += hex;
+	}
+    }
+    return out;
+}
+
+string AstNode::encodeNumber(vlsint64_t num) {
+    if (num < 0) {
+	return "__02D"+cvtToStr(-num);  // 2D=-
+    } else {
+	return cvtToStr(num);
+    }
 }
 
 string AstNode::shortName() const {
@@ -103,18 +140,45 @@ string AstNode::dedotName(const string& namein) {
 }
 
 string AstNode::prettyName(const string& namein) {
-    string pretty = namein;
-    string::size_type pos;
-    while ((pos=pretty.find("__BRA__")) != string::npos) {
-	pretty.replace(pos, 7, "[");
+    string pretty;
+    pretty = "";
+    for (const char* pos = namein.c_str(); *pos; ) {
+	if (0==strncmp(pos,"__BRA__",7)) {
+	    pretty += "[";
+	    pos += 7;
+	}
+	else if (0==strncmp(pos,"__KET__",7)) {
+	    pretty += "]";
+	    pos += 7;
+	}
+	else if (0==strncmp(pos,"__DOT__",7)) {
+	    pretty += ".";
+	    pos += 7;
+	}
+	else if (0==strncmp(pos,"__PVT__",7)) {
+	    pretty += "";
+	    pos += 7;
+	}
+	else if (pos[0]=='_' && pos[1]=='_' && pos[2]=='0'
+		 && isxdigit(pos[3]) && isxdigit(pos[4])) {
+	    char value = 0;
+	    value += 16*(isdigit(pos[3]) ? (pos[3]-'0') : (tolower(pos[3])-'a'+10));
+	    value +=    (isdigit(pos[4]) ? (pos[4]-'0') : (tolower(pos[4])-'a'+10));
+	    pretty += value;
+	    pos += 5;
+	}
+	else {
+	    pretty += pos[0];
+	    pos++;
+	}
     }
-    while ((pos=pretty.find("__KET__")) != string::npos) {
-	pretty.replace(pos, 7, "]");
-    }
-    while ((pos=pretty.find("__PVT__")) != string::npos) {
-	pretty.replace(pos, 7, "");
-    }
-    return AstNode::dedotName(pretty);
+    if (pretty.substr(0,4) == "TOP.") pretty.replace(0,4,"");
+    return pretty;
+}
+
+string AstNode::prettyTypeName() const {
+    if (name()=="") return typeName();
+    return string(typeName())+" '"+prettyName()+"'";
 }
 
 int AstNode::widthPow2() const {
@@ -134,6 +198,7 @@ inline void AstNode::debugTreeChange(const char* prefix, int lineno, bool next)
     // Called on all major tree changers.
     // Only for use for those really nasty bugs relating to internals
     // Note this may be null.
+    //if (debug()) cout<<"-treeChange: V3Ast.cpp:"<<lineno<<" Tree Change for "<<prefix<<": "<<(void*)this<<endl;
     //if (debug()) {
     //	cout<<"-treeChange: V3Ast.cpp:"<<lineno<<" Tree Change for "<<prefix<<endl;
     //	v3Global.rootp()->dumpTree(cout,"-treeChange: ");
@@ -237,8 +302,8 @@ void AstNode::addNextHere(AstNode* newp) {
 void AstNode::setOp1p(AstNode* newp) {
     UASSERT(newp,"Null item passed to setOp1p\n");
     UDEBUGONLY(if (m_op1p) this->v3fatalSrc("Adding to non-empty, non-list op1"););
-    UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node");); 
-    UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op1");); 
+    UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node"););
+    UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op1"););
     this->debugTreeChange("-setOp1pThs: ", __LINE__, false);
     newp->debugTreeChange("-setOp1pNew: ", __LINE__, true);
     m_op1p = newp;
@@ -250,8 +315,8 @@ void AstNode::setOp1p(AstNode* newp) {
 void AstNode::setOp2p(AstNode* newp) {
     UASSERT(newp,"Null item passed to setOp2p\n");
     UDEBUGONLY(if (m_op2p) this->v3fatalSrc("Adding to non-empty, non-list op2"););
-    UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node");); 
-    UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op2");); 
+    UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node"););
+    UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op2"););
     this->debugTreeChange("-setOp2pThs: ", __LINE__, false);
     newp->debugTreeChange("-setOp2pNew: ", __LINE__, true);
     m_op2p = newp;
@@ -263,8 +328,8 @@ void AstNode::setOp2p(AstNode* newp) {
 void AstNode::setOp3p(AstNode* newp) {
     UASSERT(newp,"Null item passed to setOp3p\n");
     UDEBUGONLY(if (m_op3p) this->v3fatalSrc("Adding to non-empty, non-list op3"););
-    UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node");); 
-    UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op3");); 
+    UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node"););
+    UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op3"););
     this->debugTreeChange("-setOp3pThs: ", __LINE__, false);
     newp->debugTreeChange("-setOp3pNew: ", __LINE__, true);
     m_op3p = newp;
@@ -276,8 +341,8 @@ void AstNode::setOp3p(AstNode* newp) {
 void AstNode::setOp4p(AstNode* newp) {
     UASSERT(newp,"Null item passed to setOp4p\n");
     UDEBUGONLY(if (m_op4p) this->v3fatalSrc("Adding to non-empty, non-list op4"););
-    UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node");); 
-    UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op4");); 
+    UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node"););
+    UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op4"););
     this->debugTreeChange("-setOp4pThs: ", __LINE__, false);
     newp->debugTreeChange("-setOp4pNew: ", __LINE__, true);
     m_op4p = newp;
@@ -458,7 +523,7 @@ void AstNode::relink(AstNRelinker* linkerp) {
     if (linkerp->m_iterpp) {
 	// If we're iterating over a next() link, we need to follow links off the
 	// NEW node.  Thus we pass iteration information via a pointer in the node.
-	// This adds a unfortunate 4 bytes to every AstNode, but is faster then passing
+	// This adds a unfortunate 4 bytes to every AstNode, but is faster than passing
 	// across every function.
 	// If anyone has a cleaner way, I'd be grateful.
 	*(linkerp->m_iterpp) = newp;
@@ -586,20 +651,65 @@ void AstNode::deleteTree() {
     // unlinkFromBack or unlinkFromBackWithNext as appropriate before calling this.
     if (!this) return;
     UASSERT(m_backp==NULL,"Delete called on node with backlink still set\n");
-    this->debugTreeChange("-delete: ", __LINE__, true);
+    this->debugTreeChange("-delTree:  ", __LINE__, true);
     // MUST be depth first!
     deleteTreeIter();
 }
 
+//======================================================================
+// Memory checks
+
+#ifdef VL_LEAK_CHECKS
+void* AstNode::operator new(size_t size) {
+    AstNode* objp = static_cast<AstNode*>(::operator new(size));
+    V3Broken::addNewed(objp);
+    return objp;
+}
+
+void AstNode::operator delete(void* objp, size_t size) {
+    if (!objp) return;
+    AstNode* nodep = static_cast<AstNode*>(objp);
+    V3Broken::deleted(nodep);
+    ::operator delete(objp);
+}
+#endif
+
 //======================================================================
 // Iterators
 
 void AstNode::iterateChildren(AstNVisitor& v, AstNUser* vup) {
+    // This is a very hot function
     if (!this) return;
-    m_op1p->iterateAndNext(v, vup);
-    m_op2p->iterateAndNext(v, vup);
-    m_op3p->iterateAndNext(v, vup);
-    m_op4p->iterateAndNext(v, vup);
+    ASTNODE_PREFETCH(m_op1p);
+    ASTNODE_PREFETCH(m_op2p);
+    ASTNODE_PREFETCH(m_op3p);
+    ASTNODE_PREFETCH(m_op4p);
+    // if () not needed since iterateAndNext accepts null this, but faster with it.
+    if (m_op1p) m_op1p->iterateAndNext(v, vup);
+    if (m_op2p) m_op2p->iterateAndNext(v, vup);
+    if (m_op3p) m_op3p->iterateAndNext(v, vup);
+    if (m_op4p) m_op4p->iterateAndNext(v, vup);
+}
+
+void AstNode::iterateAndNext(AstNVisitor& v, AstNUser* vup) {
+    // This is a very hot function
+    // IMPORTANT: If you replace a node that's the target of this iterator,
+    // then the NEW node will be iterated on next, it isn't skipped!
+    // if (!this) return;  // Part of for()
+    for (AstNode* nodep=this; nodep;) {
+	AstNode* niterp = nodep;
+	ASTNODE_PREFETCH(nodep->m_nextp);
+	niterp->m_iterpp = &niterp;
+	niterp->accept(v, vup);
+	// accept may do a replaceNode and change niterp on us...
+	if (!niterp) return;
+	niterp->m_iterpp = NULL;
+	if (niterp!=nodep) { // Edited it
+	    nodep = niterp;
+	} else {  // Same node, just loop
+	    nodep = niterp->m_nextp;
+	}
+    }
 }
 
 void AstNode::iterateListBackwards(AstNVisitor& v, AstNUser* vup) {
@@ -608,7 +718,7 @@ void AstNode::iterateListBackwards(AstNVisitor& v, AstNUser* vup) {
     while (nodep->m_nextp) nodep=nodep->m_nextp;
     while (nodep) {
 	// Edits not supported: nodep->m_iterpp = &nodep;
-  	nodep->accept(v, vup);
+	nodep->accept(v, vup);
 	if (nodep->backp()->m_nextp == nodep) nodep=nodep->backp();
 	else nodep = NULL;  // else: backp points up the tree.
     }
@@ -622,31 +732,12 @@ void AstNode::iterateChildrenBackwards(AstNVisitor& v, AstNUser* vup) {
     this->op4p()->iterateListBackwards(v,vup);
 }
 
-void AstNode::iterateAndNext(AstNVisitor& v, AstNUser* vup) {
-    // IMPORTANT: If you replace a node that's the target of this iterator,
-    // then the NEW node will be iterated on next, it isn't skipped!
-    // if (!this) return;  // Part of for()
-    for (AstNode* nodep=this; nodep;) {
-	AstNode* niterp = nodep;
-	niterp->m_iterpp = &niterp;
-  	niterp->accept(v, vup);
-	// accept may do a replaceNode and change niterp on us...
-	if (!niterp) return;
-	niterp->m_iterpp = NULL;
-	if (niterp!=nodep) { // Edited it
-	    nodep = niterp;
-	} else {  // Same node, just loop
-	    nodep = niterp->m_nextp;
-	}
-    }
-}
-
 void AstNode::iterateAndNextIgnoreEdit(AstNVisitor& v, AstNUser* vup) {
     // Keep following the current list even if edits change it
     if (!this) return;
     for (AstNode* nodep=this; nodep; ) {
 	AstNode* nnextp = nodep->m_nextp;
-  	nodep->accept(v, vup);
+	nodep->accept(v, vup);
 	nodep = nnextp;
     }
 }
@@ -711,6 +802,11 @@ void AstNode::checkTreeIter(AstNode* backp) {
     if (backp != this->backp()) {
 	this->v3fatalSrc("Back node inconsistent");
     }
+    if (castNodeTermop() || castNodeVarRef()) {
+	// Termops have a short-circuited iterateChildren, so check usage
+	if (op1p()||op2p()||op3p()||op4p())
+	    this->v3fatalSrc("Terminal operation with non-terminals");
+    }
     if (op1p()) op1p()->checkTreeIterList(this);
     if (op2p()) op2p()->checkTreeIterList(this);
     if (op3p()) op3p()->checkTreeIterList(this);
@@ -753,7 +849,10 @@ void AstNode::dumpPtrs(ostream& os) {
     if (op2p()) os<<" op2p="<<(void*)op2p();
     if (op3p()) os<<" op3p="<<(void*)op3p();
     if (op4p()) os<<" op4p="<<(void*)op4p();
-    if (userp()) os<<" user="<<(void*)userp();
+    if (user1p()) os<<" user1p="<<(void*)user1p();
+    if (user2p()) os<<" user2p="<<(void*)user2p();
+    if (user3p()) os<<" user3p="<<(void*)user3p();
+    if (user4p()) os<<" user4p="<<(void*)user4p();
     if (m_iterpp) {
 	os<<" iterpp="<<(void*)m_iterpp;
 	os<<"*="<<(void*)*m_iterpp;
@@ -789,7 +888,7 @@ void AstNode::dumpTreeFile(const string& filename, bool append) {
 	    if (logsp->fail()) v3fatalSrc("Can't write "<<filename);
 	    *logsp<<"Tree Dump from <e"<<dec<<editCountLast()<<">";
 	    *logsp<<" to <e"<<dec<<editCountGbl()<<">"<<endl;
-	    if (editCountGbl()==editCountLast() && 1) {  // Off, as messes up tree diffing
+	    if (editCountGbl()==editCountLast()) {
 		*logsp<<endl;
 		*logsp<<"No changes since last dump!\n";
 	    } else {
@@ -808,7 +907,7 @@ void AstNode::dumpTreeFile(const string& filename, bool append) {
     editCountSetLast();
 }
 
-void AstNode::v3errorEnd(ostringstream& str) {
+void AstNode::v3errorEnd(ostringstream& str) const {
     if (this && m_fileline) {
 	ostringstream nsstr;
 	nsstr<<str.str();

src/V3Ast.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Ast node structure
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -40,10 +41,10 @@ public:
     //   enum en {...};
     //   const char* ascii() const {...};
     enum en m_e;
-    inline AstType () {};
-    inline AstType (en _e) : m_e(_e) {};
-    explicit inline AstType (int _e) : m_e(static_cast<en>(_e)) {};
-    operator en () const { return m_e; };
+    inline AstType () {}
+    inline AstType (en _e) : m_e(_e) {}
+    explicit inline AstType (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
   };
   inline bool operator== (AstType lhs, AstType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstType lhs, AstType::en rhs) { return (lhs.m_e == rhs); }
@@ -63,10 +64,10 @@ public:
 	PUBLIC_TASK
     };
     enum en m_e;
-    inline AstPragmaType () {};
-    inline AstPragmaType (en _e) : m_e(_e) {};
-    explicit inline AstPragmaType (int _e) : m_e(static_cast<en>(_e)) {};
-    operator en () const { return m_e; };
+    inline AstPragmaType () {}
+    inline AstPragmaType (en _e) : m_e(_e) {}
+    explicit inline AstPragmaType (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
   };
   inline bool operator== (AstPragmaType lhs, AstPragmaType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstPragmaType lhs, AstPragmaType::en rhs) { return (lhs.m_e == rhs); }
@@ -79,14 +80,21 @@ public:
     enum en {
 	NORMAL,
 	TRACE_INIT,
+	TRACE_INIT_SUB,
 	TRACE_FULL,
-	TRACE_CHANGE
+	TRACE_FULL_SUB,
+	TRACE_CHANGE,
+	TRACE_CHANGE_SUB
     };
     enum en m_e;
-    inline AstCFuncType () {};
-    inline AstCFuncType (en _e) : m_e(_e) {};
-    explicit inline AstCFuncType (int _e) : m_e(static_cast<en>(_e)) {};
-    operator en () const { return m_e; };
+    inline AstCFuncType () {}
+    inline AstCFuncType (en _e) : m_e(_e) {}
+    explicit inline AstCFuncType (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
+    // METHODS
+    bool isTrace() const { return (m_e==TRACE_INIT || m_e==TRACE_INIT_SUB
+				   || m_e==TRACE_FULL || m_e==TRACE_FULL_SUB
+				   || m_e==TRACE_CHANGE || m_e==TRACE_CHANGE_SUB); }
   };
   inline bool operator== (AstCFuncType lhs, AstCFuncType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstCFuncType lhs, AstCFuncType::en rhs) { return (lhs.m_e == rhs); }
@@ -98,7 +106,7 @@ class AstEdgeType {
 public:
 // REMEMBER to edit the strings below too
     enum en {
-	// These must be in general -> most specific order, as we sort by it in AstSenTree::sortSenses()
+	// These must be in general -> most specific order, as we sort by it in V3Const::visit AstSenTre
 	ILLEGAL,
 	// Involving a variable
 	ANYEDGE,	// Default for sensitivities; rip them out
@@ -142,15 +150,15 @@ public:
     };
     const char* verilogKwd() const {
 	static const char* names[] = {
-	    "%E-edge", "", "[both]", "posedge", "negedge", "[high]","[low]",
-	    "/*AS*/","[initial]","[settle]","[never]"
+	    "%E-edge", "[any]", "[both]", "posedge", "negedge", "[high]","[low]",
+	    "*","[initial]","[settle]","[never]"
 	};
 	return names[m_e];
     };
-    inline AstEdgeType () {};
-    inline AstEdgeType (en _e) : m_e(_e) {};
-    explicit inline AstEdgeType (int _e) : m_e(static_cast<en>(_e)) {};
-    operator en () const { return m_e; };
+    inline AstEdgeType () {}
+    inline AstEdgeType (en _e) : m_e(_e) {}
+    explicit inline AstEdgeType (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
   };
   inline bool operator== (AstEdgeType lhs, AstEdgeType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstEdgeType lhs, AstEdgeType::en rhs) { return (lhs.m_e == rhs); }
@@ -161,16 +169,29 @@ public:
 class AstAttrType {
 public:
     enum en {
-	BITS,
-	RANGE_LSB,
-	ARRAY_LSB,
-	SCOPE_TEXT
+	BITS,				// V3Const converts to constant
+	RANGE_LSB,			// V3Const converts to constant
+	ARRAY_LSB,			// V3Const converts to constant
+	//
+	VAR_CLOCK,			// V3LinkParse moves to AstVar::attrScClocked
+	VAR_CLOCK_ENABLE,		// V3LinkParse moves to AstVar::attrClockEn
+	VAR_PUBLIC,			// V3LinkParse moves to AstVar::sigPublic
+	VAR_PUBLIC_FLAT,		// V3LinkParse moves to AstVar::sigPublic
+	VAR_ISOLATE_ASSIGNMENTS		// V3LinkParse moves to AstVar::attrIsolateAssign
     };
     enum en m_e;
-    inline AstAttrType () {};
-    inline AstAttrType (en _e) : m_e(_e) {};
-    explicit inline AstAttrType (int _e) : m_e(static_cast<en>(_e)) {};
-    operator en () const { return m_e; };
+    const char* ascii() const {
+	static const char* names[] = {
+	    "BITS", "RANGE_LSB", "ARRAY_LSB",
+	    "VAR_CLOCK", "VAR_CLOCK_ENABLE", "VAR_PUBLIC", "VAR_PUBLIC_FLAT",
+	    "VAR_ISOLATE_ASSIGNMENTS"
+	};
+	return names[m_e];
+    };
+    inline AstAttrType () {}
+    inline AstAttrType (en _e) : m_e(_e) {}
+    explicit inline AstAttrType (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
   };
   inline bool operator== (AstAttrType lhs, AstAttrType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstAttrType lhs, AstAttrType::en rhs) { return (lhs.m_e == rhs); }
@@ -195,22 +216,24 @@ public:
 	IMPLICIT,
 	REG,
 	TRIWIRE,
+	PORT,		// Temp type used in parser only
 	BLOCKTEMP,
 	MODULETEMP,
-	STMTTEMP
+	STMTTEMP,
+	XTEMP
     };
     enum en m_e;
-    inline AstVarType () {};
-    inline AstVarType (en _e) : m_e(_e) {};
-    explicit inline AstVarType (int _e) : m_e(static_cast<en>(_e)) {};
-    operator en () const { return m_e; };
+    inline AstVarType () {}
+    inline AstVarType (en _e) : m_e(_e) {}
+    explicit inline AstVarType (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
     const char* ascii() const {
 	static const char* names[] = {
 	    "?","GPARAM","LPARAM","GENVAR",
 	    "INTEGER","INPUT","OUTPUT","INOUT",
-	    "SUPPLY0","SUPPLY1","WIRE","IMPLICIT","REG","TRIWIRE",
-	    "BLOCKTEMP","MODULETEMP","STMTTEMP"};
-	return names[m_e];};
+	    "SUPPLY0","SUPPLY1","WIRE","IMPLICIT","REG","TRIWIRE","PORT",
+	    "BLOCKTEMP","MODULETEMP","STMTTEMP","XTEMP"};
+	return names[m_e]; }
   };
   inline bool operator== (AstVarType lhs, AstVarType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstVarType lhs, AstVarType::en rhs) { return (lhs.m_e == rhs); }
@@ -229,10 +252,10 @@ public:
     };
     enum en m_e;
     // CONSTRUCTOR - note defaults to *UNKNOWN*
-    inline AstBranchPred () : m_e(UNKNOWN) {};
-    inline AstBranchPred (en _e) : m_e(_e) {};
-    explicit inline AstBranchPred (int _e) : m_e(static_cast<en>(_e)) {};
-    operator en () const { return m_e; };
+    inline AstBranchPred () : m_e(UNKNOWN) {}
+    inline AstBranchPred (en _e) : m_e(_e) {}
+    explicit inline AstBranchPred (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
     AstBranchPred invert() const {
 	if (m_e==UNLIKELY) return LIKELY;
 	else if (m_e==LIKELY) return UNLIKELY;
@@ -241,7 +264,7 @@ public:
     const char* ascii() const {
 	static const char* names[] = {
 	    "","VL_LIKELY","VL_UNLIKELY"};
-	return names[m_e];};
+	return names[m_e]; }
   };
   inline bool operator== (AstBranchPred lhs, AstBranchPred rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstBranchPred lhs, AstBranchPred::en rhs) { return (lhs.m_e == rhs); }
@@ -250,6 +273,25 @@ public:
 
 //######################################################################
 
+class AstCaseType {
+public:
+    enum en {
+	CASE,
+	CASEX,
+	CASEZ
+    };
+    enum en m_e;
+    inline AstCaseType () {}
+    inline AstCaseType (en _e) : m_e(_e) {}
+    explicit inline AstCaseType (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
+  };
+  inline bool operator== (AstCaseType lhs, AstCaseType rhs) { return (lhs.m_e == rhs.m_e); }
+  inline bool operator== (AstCaseType lhs, AstCaseType::en rhs) { return (lhs.m_e == rhs); }
+  inline bool operator== (AstCaseType::en lhs, AstCaseType rhs) { return (lhs == rhs.m_e); }
+
+//######################################################################
+
 class AstDisplayType {
 public:
     enum en {
@@ -261,16 +303,16 @@ public:
 	FATAL
     };
     enum en m_e;
-    inline AstDisplayType () {};
-    inline AstDisplayType (en _e) : m_e(_e) {};
-    explicit inline AstDisplayType (int _e) : m_e(static_cast<en>(_e)) {};
-    operator en () const { return m_e; };
+    inline AstDisplayType () {}
+    inline AstDisplayType (en _e) : m_e(_e) {}
+    explicit inline AstDisplayType (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
     bool addNewline() const { return m_e!=WRITE; }
     bool needScopeTracking() const { return m_e!=DISPLAY && m_e!=WRITE; }
     const char* ascii() const {
 	static const char* names[] = {
 	    "display","write","info","error","warning","fatal"};
-	return names[m_e];};
+	return names[m_e]; }
   };
   inline bool operator== (AstDisplayType lhs, AstDisplayType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstDisplayType lhs, AstDisplayType::en rhs) { return (lhs.m_e == rhs); }
@@ -289,14 +331,14 @@ public:
 	_ENUM_END
     };
     enum en m_e;
-    inline AstParseRefExp() : m_e(NONE) {};
-    inline AstParseRefExp (en _e) : m_e(_e) {};
-    explicit inline AstParseRefExp (int _e) : m_e(static_cast<en>(_e)) {};
-    operator en () const { return m_e; };
+    inline AstParseRefExp() : m_e(NONE) {}
+    inline AstParseRefExp (en _e) : m_e(_e) {}
+    explicit inline AstParseRefExp (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
     const char* ascii() const {
 	static const char* names[] = {
 	    "","VAR_MEM","VAR_ANY","TASK","FUNC"};
-	return names[m_e];};
+	return names[m_e]; }
   };
   inline bool operator== (AstParseRefExp lhs, AstParseRefExp rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstParseRefExp lhs, AstParseRefExp::en rhs) { return (lhs.m_e == rhs); }
@@ -335,6 +377,83 @@ struct AstNUser {
     }
 };
 
+//######################################################################
+// AstUserResource - Generic pointer base class for tracking usage of user()
+//
+//  Where AstNode->user2() is going to be used, for example, you write:
+//
+//	AstUser2InUse  m_userres;
+//
+//  This will clear the tree, and prevent another visitor from clobering
+//  user2.  When the member goes out of scope it will be automagically
+//  freed up.
+
+class AstUserInUseBase {
+protected:
+    static void	allocate(uint32_t& cntGblRef, bool& userBusyRef) {
+	// Perhaps there's still a AstUserInUse in scope for this?
+	UASSERT_STATIC(!userBusyRef, "Conflicting user use; AstUser*InUse request when under another AstUserInUse");
+	userBusyRef = true;
+	clearcnt(cntGblRef, userBusyRef);
+    }
+    static void	free(uint32_t& cntGblRef, bool& userBusyRef) {
+	UASSERT_STATIC(userBusyRef, "Free of User*() not under AstUserInUse");
+	clearcnt(cntGblRef, userBusyRef);  // Includes a checkUse for us
+	userBusyRef = false;
+    }
+    static void clearcnt(uint32_t& cntGblRef, bool& userBusyRef) {
+	UASSERT_STATIC(userBusyRef, "Clear of User*() not under AstUserInUse");
+	// If this really fires and is real (after 2^32 edits???)
+	// we could just walk the tree and clear manually
+	++cntGblRef;
+	UASSERT_STATIC(cntGblRef, "User*() overflowed!");
+    }
+};
+
+// For each user() declare the in use structure
+// We let AstNode peek into here, because when under low optimization even
+// an accessor would be way too slow.
+class AstUser1InUse : AstUserInUseBase {
+protected:
+    friend class AstNode;
+    static uint32_t	s_userCntGbl;	// Count of which usage of userp() this is
+    static bool		s_userBusy;	// Count is in use
+public:
+    AstUser1InUse()     { allocate(s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+    ~AstUser1InUse()    { free    (s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+    static void clear() { clearcnt(s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+};
+class AstUser2InUse : AstUserInUseBase {
+protected:
+    friend class AstNode;
+    static uint32_t	s_userCntGbl;	// Count of which usage of userp() this is
+    static bool		s_userBusy;	// Count is in use
+public:
+    AstUser2InUse()      { allocate(s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+    ~AstUser2InUse()     { free    (s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+    static void clear()  { clearcnt(s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+};
+class AstUser3InUse : AstUserInUseBase {
+protected:
+    friend class AstNode;
+    static uint32_t	s_userCntGbl;	// Count of which usage of userp() this is
+    static bool		s_userBusy;	// Count is in use
+public:
+    AstUser3InUse()      { allocate(s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+    ~AstUser3InUse()     { free    (s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+    static void clear()  { clearcnt(s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+};
+class AstUser4InUse : AstUserInUseBase {
+protected:
+    friend class AstNode;
+    static uint32_t	s_userCntGbl;	// Count of which usage of userp() this is
+    static bool		s_userBusy;	// Count is in use
+public:
+    AstUser4InUse()      { allocate(s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+    ~AstUser4InUse()     { free    (s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+    static void clear()  { clearcnt(s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
+};
+
 //######################################################################
 // AstNVisitor -- Allows new functions to be called on each node
 // type without changing the base classes.  See "Modern C++ Design".
@@ -401,8 +520,9 @@ public:
     uint32_t depth() const { return (m_both >> 24) & 255; }
     uint32_t hshval() const { return m_both & M24; }
     // OPERATORS
-    inline bool operator== (const V3Hash& rh) const { return m_both==rh.m_both; };
-    inline bool operator< (const V3Hash& rh) const { return m_both<rh.m_both; };
+    inline bool operator== (const V3Hash& rh) const { return m_both==rh.m_both; }
+    inline bool operator!= (const V3Hash& rh) const { return m_both!=rh.m_both; }
+    inline bool operator< (const V3Hash& rh) const { return m_both<rh.m_both; }
     // CREATORS
     class Illegal {};		// for creator type-overload selection
     class FullValue {};		// for creator type-overload selection
@@ -415,13 +535,7 @@ public:
     // Creating from raw data (sameHash functions)
     V3Hash() { setBoth(1,0); }
     V3Hash(uint32_t val) { setBoth(1,val); }
-    V3Hash(void* vp) {
-	// It's just a hash, so we can shove a 64 bit pointer into a 32 bit bucket
-	// On 32 bit systems, lower is always 0, but who cares?
-	union { void* up; struct {uint32_t upper; uint32_t lower;} l;} u;
-	u.l.upper=0; u.l.lower=0; u.up=vp;
-	setBoth(1,u.l.upper^u.l.lower);
-    }
+    V3Hash(void* vp) { setBoth(1,cvtToHash(vp)); }
     V3Hash(const string& name);
     V3Hash(V3Hash lh, V3Hash rh) {
 	setBoth(1,lh.hshval()*31+rh.hshval());
@@ -432,45 +546,46 @@ ostream& operator<<(ostream& os, V3Hash rhs);
 //######################################################################
 // AstNode -- Base type of all Ast types
 
+// Prefetch a node.
+// The if() makes it faster, even though prefetch won't fault on null pointers
+#define ASTNODE_PREFETCH(nodep) \
+    { if (nodep) { VL_PREFETCH_RD(&(nodep->m_nextp)); VL_PREFETCH_RD(&(nodep->m_iterpp)); }}
+
 class AstNode {
-private:
+    // v ASTNODE_PREFETCH depends on below ordering of members
     AstNode*	m_nextp;	// Next peer in the parent's list
     AstNode*	m_backp;	// Node that points to this one (via next/op1/op2/...)
-    AstNode*	m_headtailp;	// When at begin/end of list, the opposite end of the list
     AstNode*	m_op1p;		// Generic pointer 1
     AstNode*	m_op2p;		// Generic pointer 2
     AstNode*	m_op3p;		// Generic pointer 3
     AstNode*	m_op4p;		// Generic pointer 4
     AstNode**	m_iterpp;	// Pointer to node iterating on, change it if we replace this node.
+    // ^ ASTNODE_PREFETCH depends on above ordering of members
 
-    AstNode*	m_clonep;	// Pointer to clone of/ source of this module (for *LAST* cloneTree() ONLY)
-    int		m_cloneCnt;	// Mark of when userp was set
-    static int	s_cloneCntGbl;	// Count of which userp is set
+    AstNode*	m_headtailp;	// When at begin/end of list, the opposite end of the list
 
     FileLine*	m_fileline;	// Where it was declared
     vluint64_t	m_editCount;	// When it was last edited
     static vluint64_t s_editCntGbl; // Global edit counter
     static vluint64_t s_editCntLast;// Global edit counter, last value for printing * near node #s
 
+    AstNode*	m_clonep;	// Pointer to clone of/ source of this module (for *LAST* cloneTree() ONLY)
+    int		m_cloneCnt;	// Mark of when userp was set
+    static int	s_cloneCntGbl;	// Count of which userp is set
+
     // Attributes
     bool	m_signed;	// Node is signed
     int		m_width;	// Bit width of operation
     int		m_widthMin;	// If unsized, bitwidth of minimum implementation
-    AstNUser*	m_userp;	// Pointer to any information the user iteration routine wants
-    int		m_userCnt;	// Mark of when userp was set
-    static int	s_userCntGbl;	// Count of which userp is set
+    // This member ordering both allows 64 bit alignment and puts associated data together
+    AstNUser*	m_user1p;	// Pointer to any information the user iteration routine wants
+    uint32_t	m_user1Cnt;	// Mark of when userp was set
+    uint32_t	m_user2Cnt;	// Mark of when userp was set
     AstNUser*	m_user2p;	// Pointer to any information the user iteration routine wants
-    int		m_user2Cnt;	// Mark of when userp was set
-    static int	s_user2CntGbl;	// Count of which userp is set
     AstNUser*	m_user3p;	// Pointer to any information the user iteration routine wants
-    int		m_user3Cnt;	// Mark of when userp was set
-    static int	s_user3CntGbl;	// Count of which userp is set
+    uint32_t	m_user3Cnt;	// Mark of when userp was set
+    uint32_t	m_user4Cnt;	// Mark of when userp was set
     AstNUser*	m_user4p;	// Pointer to any information the user iteration routine wants
-    int		m_user4Cnt;	// Mark of when userp was set
-    static int	s_user4CntGbl;	// Count of which userp is set
-    AstNUser*	m_user5p;	// Pointer to any information the user iteration routine wants
-    int		m_user5Cnt;	// Mark of when userp was set
-    static int	s_user5CntGbl;	// Count of which userp is set
 
     // METHODS
     void	op1p(AstNode* nodep) { m_op1p = nodep; if (nodep) nodep->m_backp = this; }
@@ -494,7 +609,7 @@ protected:
     // CONSTUCTORS
     AstNode() {init(); }
     AstNode(FileLine* fileline) {init(); m_fileline = fileline; }
-    virtual AstNode* clone() = 0;	// Generally, cloneTree/cloneNode is what you want
+    virtual AstNode* clone() = 0;	// Generally, cloneTree is what you want instead
     virtual void cloneRelink() {}
     void 	cloneRelinkTree();
 
@@ -525,7 +640,7 @@ protected:
 public:
     // ACCESSORS
     virtual AstType	type() const = 0;
-    const char*	typeName() const { return type().ascii(); }
+    const char*	typeName() const { return type().ascii(); }  // See also prettyTypeName
     AstNode*	nextp() const { return m_nextp; }
     AstNode*	backp() const { return m_backp; }
     AstNode*	op1p() const { return m_op1p; }
@@ -538,6 +653,10 @@ public:
 
     // CONSTRUCTORS
     virtual ~AstNode();
+#ifdef VL_LEAK_CHECKS
+    static void* operator new(size_t size);
+    static void operator delete(void* obj, size_t size);
+#endif
 
     // CONSTANT ACCESSORS
     static int	instrCountBranch() { return 4; }	///< Instruction cycles to branch
@@ -550,11 +669,15 @@ public:
 
     // ACCESSORS
     virtual string name() const { return ""; }
+    virtual void name(const string& name) { this->v3fatalSrc("name() called on object without name() method"); }
     virtual string verilogKwd() const { return ""; }
     string 	shortName() const;	// Name with __PVT__ removed for concatenating scopes
     static string dedotName(const string& namein);	// Name with dots removed
     static string prettyName(const string& namein);	// Name for printing out to the user
+    static string encodeName(const string& namein);	// Encode user name into internal C representation
+    static string encodeNumber(vlsint64_t numin);	// Encode number into internal C representation
     string	prettyName() const { return prettyName(name()); }
+    string	prettyTypeName() const;			// "VARREF name" for error messages
     FileLine*	fileline() const { return m_fileline; }
     int		width() const { return m_width; }
     bool	width1() const { return width()==1; }
@@ -572,34 +695,42 @@ public:
     bool	isQuad() const { return (width()>VL_WORDSIZE && width()<=VL_QUADSIZE); }
     bool	isWide() const { return (width()>VL_QUADSIZE); }
 
-    int		user() const { return userp()->castInt(); }
-    AstNUser*	userp() const { return ((m_userCnt==s_userCntGbl)?m_userp:NULL); }
-    void	userp(void* userp) { m_userp=(AstNUser*)(userp); m_userCnt=s_userCntGbl; }
-    void	user(int val) { userp(AstNUser::fromInt(val)); }
-    static void	userClearTree() { s_userCntGbl++; UASSERT_STATIC(s_userCntGbl,"Rollover"); }  // Clear userp()'s across the entire tree
+    AstNUser*	user1p() const {
+	// Slows things down measurably, so disabled by default
+	//UASSERT_STATIC(AstUser1InUse::s_userBusy, "userp set w/o busy");
+	return ((m_user1Cnt==AstUser1InUse::s_userCntGbl)?m_user1p:NULL);
+    }
+    void	user1p(void* userp) { m_user1p=(AstNUser*)(userp); m_user1Cnt=AstUser1InUse::s_userCntGbl; }
+    int		user1() const { return user1p()->castInt(); }
+    void	user1(int val) { user1p(AstNUser::fromInt(val)); }
+    static void	user1ClearTree() { AstUser1InUse::clear(); }  // Clear userp()'s across the entire tree
+
+    AstNUser*	user2p() const {
+	//UASSERT_STATIC(AstUser2InUse::s_userBusy, "user2p set w/o busy");
+	return ((m_user2Cnt==AstUser2InUse::s_userCntGbl)?m_user2p:NULL); }
+    void	user2p(void* userp) { m_user2p=(AstNUser*)(userp); m_user2Cnt=AstUser2InUse::s_userCntGbl; }
     int		user2() const { return user2p()->castInt(); }
-    AstNUser*	user2p() const { return ((m_user2Cnt==s_user2CntGbl)?m_user2p:NULL); }
-    void	user2p(void* userp) { m_user2p=(AstNUser*)(userp); m_user2Cnt=s_user2CntGbl; }
     void	user2(int val) { user2p(AstNUser::fromInt(val)); }
-    static void	user2ClearTree() { s_user2CntGbl++; }  // Clear userp()'s across the entire tree
+    static void	user2ClearTree() { AstUser2InUse::clear(); }
+
+    AstNUser*	user3p() const {
+	//UASSERT_STATIC(AstUser3InUse::s_userBusy, "user3p set w/o busy");
+	return ((m_user3Cnt==AstUser3InUse::s_userCntGbl)?m_user3p:NULL); }
+    void	user3p(void* userp) { m_user3p=(AstNUser*)(userp); m_user3Cnt=AstUser3InUse::s_userCntGbl; }
     int		user3() const { return user3p()->castInt(); }
-    AstNUser*	user3p() const { return ((m_user3Cnt==s_user3CntGbl)?m_user3p:NULL); }
-    void	user3p(void* userp) { m_user3p=(AstNUser*)(userp); m_user3Cnt=s_user3CntGbl; }
     void	user3(int val) { user3p(AstNUser::fromInt(val)); }
-    static void	user3ClearTree() { s_user3CntGbl++; }  // Clear userp()'s across the entire tree
+    static void	user3ClearTree() { AstUser3InUse::clear(); }
+
+    AstNUser*	user4p() const {
+	//UASSERT_STATIC(AstUser4InUse::s_userBusy, "user4p set w/o busy");
+	return ((m_user4Cnt==AstUser4InUse::s_userCntGbl)?m_user4p:NULL); }
+    void	user4p(void* userp) { m_user4p=(AstNUser*)(userp); m_user4Cnt=AstUser4InUse::s_userCntGbl; }
     int		user4() const { return user4p()->castInt(); }
-    AstNUser*	user4p() const { return ((m_user4Cnt==s_user4CntGbl)?m_user4p:NULL); }
-    void	user4p(void* userp) { m_user4p=(AstNUser*)(userp); m_user4Cnt=s_user4CntGbl; }
     void	user4(int val) { user4p(AstNUser::fromInt(val)); }
-    static void	user4ClearTree() { s_user4CntGbl++; }  // Clear userp()'s across the entire tree
-    int		user5() const { return user5p()->castInt(); }
-    AstNUser*	user5p() const { return ((m_user5Cnt==s_user5CntGbl)?m_user5p:NULL); }
-    void	user5p(void* userp) { m_user5p=(AstNUser*)(userp); m_user5Cnt=s_user5CntGbl; }
-    void	user5(int val) { user5p(AstNUser::fromInt(val)); }
-    static void	user5ClearTree() { s_user5CntGbl++; }  // Clear userp()'s across the entire tree
+    static void	user4ClearTree() { AstUser4InUse::clear(); }
 
     vluint64_t	editCount() const { return m_editCount; }
-    void	editCountInc() { m_editCount = s_editCntGbl++; }
+    void	editCountInc() { m_editCount = ++s_editCntGbl; }
     static vluint64_t	editCountLast() { return s_editCntLast; }
     static vluint64_t	editCountGbl() { return s_editCntGbl; }
     static void		editCountSetLast() { s_editCntLast = editCountGbl(); }
@@ -617,7 +748,7 @@ public:
     AstNode*	addNextNull(AstNode* newp);	// Returns this, adds to end of list, NULL is OK
     void	addNextHere(AstNode* newp);	// Adds after speced node
     void	replaceWith(AstNode* newp);	// Replace current node in tree with new node
-    void	v3errorEnd(ostringstream& str);
+    void	v3errorEnd(ostringstream& str) const;
     virtual void dump(ostream& str=cout);
     AstNode*	unlinkFrBack(AstNRelinker* linkerp=NULL);  // Unlink this from whoever points to it.
     AstNode*	unlinkFrBackWithNext(AstNRelinker* linkerp=NULL);  // Unlink this from whoever points to it, keep entire next list with unlinked node
@@ -646,7 +777,6 @@ public:
     virtual bool same(AstNode* otherp) const { return true; }
     virtual bool maybePointedTo() const { return false; }  // Another AstNode* may have a pointer into this node, other then normal front/back/etc.
     virtual bool broken() const { return false; }
-    virtual bool emitWordForm() { return false; }
 
     // INVOKERS
     virtual void accept(AstNVisitor& v, AstNUser* vup=NULL) = 0;
@@ -670,14 +800,18 @@ inline void AstNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); }
 //######################################################################
 //=== AstNode* : Derived generic node types
 
+#define ASTNODE_BASE_FUNCS(name)	\
+    virtual ~Ast ##name() {} \
+    Ast ##name * cloneTree(bool cloneNext) { return AstNode::cloneTree(cloneNext)->cast ##name(); }
+
 struct AstNodeMath : public AstNode {
     // Math -- anything that's part of an expression tree
     AstNodeMath(FileLine* fl)
 	: AstNode(fl) {}
-    virtual ~AstNodeMath() {}
+    ASTNODE_BASE_FUNCS(NodeMath)
     // METHODS
     virtual string emitVerilog() = 0;  /// Format string for verilog writing; see V3EmitV
-    virtual string emitOperator() = 0;
+    virtual string emitC() = 0;
     virtual string emitSimpleOperator() { return ""; }
     virtual bool cleanOut() = 0; // True if output has extra upper bits zero
 };
@@ -686,7 +820,10 @@ struct AstNodeTermop : public AstNodeMath {
     // Terminal operator -- a operator with no "inputs"
     AstNodeTermop(FileLine* fl)
 	: AstNodeMath(fl) {}
-    virtual ~AstNodeTermop() {}
+    ASTNODE_BASE_FUNCS(NodeTermop)
+    // Know no children, and hot function, so skip iterator for speed
+    // See checkTreeIter also that asserts no children
+    void iterateChildren(AstNVisitor& v, AstNUser* vup=NULL) { }
 };
 
 struct AstNodeUniop : public AstNodeMath {
@@ -695,7 +832,7 @@ struct AstNodeUniop : public AstNodeMath {
 	: AstNodeMath(fl) {
 	if (lhsp) widthSignedFrom(lhsp);
 	setOp1p(lhsp); }
-    virtual ~AstNodeUniop() {}
+    ASTNODE_BASE_FUNCS(NodeUniop)
     AstNode*	lhsp() 	const { return op1p()->castNode(); }
     // METHODS
     virtual void numberOperate(V3Number& out, const V3Number& lhs) = 0; // Set out to evaluation of a AstConst'ed lhs
@@ -711,7 +848,7 @@ struct AstNodeBiop : public AstNodeMath {
     AstNodeBiop(FileLine* fl, AstNode* lhs, AstNode* rhs)
 	: AstNodeMath(fl) {
 	setOp1p(lhs); setOp2p(rhs); }
-    virtual ~AstNodeBiop() {}
+    ASTNODE_BASE_FUNCS(NodeBiop)
     AstNode*	lhsp() 	const { return op1p()->castNode(); }
     AstNode*	rhsp() 	const { return op2p()->castNode(); }
     void	lhsp(AstNode* nodep)  { return setOp1p(nodep); }
@@ -733,7 +870,7 @@ struct AstNodeTriop : public AstNodeMath {
     AstNodeTriop(FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths)
 	: AstNodeMath(fl) {
 	setOp1p(lhs); setOp2p(rhs); setOp3p(ths); }
-    virtual ~AstNodeTriop() {}
+    ASTNODE_BASE_FUNCS(NodeTriop)
     AstNode*	lhsp() 	const { return op1p()->castNode(); }
     AstNode*	rhsp() 	const { return op2p()->castNode(); }
     AstNode*	thsp() 	const { return op3p()->castNode(); }
@@ -757,14 +894,14 @@ struct AstNodeBiCom : public AstNodeBiop {
     // Binary math with commutative properties
     AstNodeBiCom(FileLine* fl, AstNode* lhs, AstNode* rhs)
 	: AstNodeBiop(fl, lhs, rhs) {}
-    virtual ~AstNodeBiCom() {}
+    ASTNODE_BASE_FUNCS(NodeBiCom)
 };
 
 struct AstNodeBiComAsv : public AstNodeBiCom {
     // Binary math with commutative & associative properties
     AstNodeBiComAsv(FileLine* fl, AstNode* lhs, AstNode* rhs)
 	: AstNodeBiCom(fl, lhs, rhs) {}
-    virtual ~AstNodeBiComAsv() {}
+    ASTNODE_BASE_FUNCS(NodeBiComAsv)
 };
 struct AstNodeCond : public AstNodeTriop {
     AstNodeCond(FileLine* fl, AstNode* condp, AstNode* expr1p, AstNode* expr2p)
@@ -772,14 +909,14 @@ struct AstNodeCond : public AstNodeTriop {
 	if (expr1p) widthSignedFrom(expr1p);
 	else if (expr2p) widthSignedFrom(expr2p);
     }
-    virtual ~AstNodeCond() {}
+    ASTNODE_BASE_FUNCS(NodeCond)
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) {
 	if (lhs.isNeqZero()) out.opAssign(rhs); else out.opAssign(ths); }
     AstNode*	condp() 	const { return op1p()->castNode(); }	// op1 = Condition
     AstNode*	expr1p() 	const { return op2p()->castNode(); }	// op2 = If true...
     AstNode*	expr2p() 	const { return op3p()->castNode(); }	// op3 = If false...
     virtual string emitVerilog() { return "%k(%l %k? %r %k: %t)"; }
-    virtual string emitOperator() { return "VL_COND"; }
+    virtual string emitC() { return "VL_COND_%nq%lq%rq%tq(%nw,%lw,%rw,%tw, %P, %li, %ri, %ti)"; }
     virtual bool cleanOut() { return false; } // clean if e1 & e2 clean
     virtual bool cleanLhs() { return true; }
     virtual bool cleanRhs() { return false; } virtual bool cleanThs() { return false; } // Propagates up
@@ -793,7 +930,7 @@ struct AstNodePreSel : public AstNode {
     AstNodePreSel(FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths)
 	: AstNode(fl) {
 	setOp1p(lhs); setOp2p(rhs); setNOp3p(ths); }
-    virtual ~AstNodePreSel() {}
+    ASTNODE_BASE_FUNCS(NodePreSel)
     AstNode*	lhsp() 	const { return op1p()->castNode(); }
     AstNode*	rhsp() 	const { return op2p()->castNode(); }
     AstNode*	thsp() 	const { return op3p()->castNode(); }
@@ -809,7 +946,7 @@ struct AstNodeStmt : public AstNode {
     // Statement -- anything that's directly under a function
     AstNodeStmt(FileLine* fl)
 	: AstNode(fl) {}
-    virtual ~AstNodeStmt() {}
+    ASTNODE_BASE_FUNCS(NodeStmt)
     // METHODS
 };
 
@@ -819,7 +956,7 @@ struct AstNodeAssign : public AstNodeStmt {
 	setOp1p(rhsp); setOp2p(lhsp);
 	if (lhsp) widthSignedFrom(lhsp);
     }
-    virtual ~AstNodeAssign() {}
+    ASTNODE_BASE_FUNCS(NodeAssign)
     virtual AstNode*	cloneType(AstNode* lhsp, AstNode* rhsp)=0;	// Clone single node, just get same type back.
     // So iteration hits the RHS which is "earlier" in execution order, it's op1, not op2
     AstNode* rhsp()		const { return op1p()->castNode(); }	// op1 = Assign from
@@ -838,13 +975,12 @@ struct AstNodeFor : public AstNodeStmt {
 	: AstNodeStmt(fileline) {
 	addNOp1p(initsp); setOp2p(condp); addNOp3p(incsp); addNOp4p(bodysp);
     }
-    virtual ~AstNodeFor() {}
+    ASTNODE_BASE_FUNCS(NodeFor)
     AstNode*	initsp()	const { return op1p()->castNode(); }	// op1= initial statements
     AstNode*	condp()		const { return op2p()->castNode(); }	// op2= condition to continue
     AstNode*	incsp()		const { return op3p()->castNode(); }	// op3= increment statements
     AstNode*	bodysp()	const { return op4p()->castNode(); }	// op4= body of loop
     virtual bool isGateOptimizable() const { return false; }
-    virtual bool isPredictOptimizable() const { return false; }
     virtual int  instrCount() const { return instrCountBranch(); }
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(AstNode* samep) const { return true; }
@@ -858,7 +994,7 @@ public:
 	: AstNodeStmt(fl) {
 	setOp1p(condp); addNOp2p(ifsp); addNOp3p(elsesp);
     }
-    virtual ~AstNodeIf() {}
+    ASTNODE_BASE_FUNCS(NodeIf)
     AstNode*	condp()		const { return op1p(); }	// op1 = condition
     AstNode*	ifsp()		const { return op2p(); }	// op2 = list of true statements
     AstNode*	elsesp()	const { return op3p(); }	// op3 = list of false statements
@@ -878,7 +1014,7 @@ struct AstNodeCase : public AstNodeStmt {
 	: AstNodeStmt(fl) {
 	setOp1p(exprp); addNOp2p(casesp);
     }
-    virtual ~AstNodeCase() {}
+    ASTNODE_BASE_FUNCS(NodeCase)
     virtual int   instrCount()	const { return instrCountBranch(); }
     AstNode*	  exprp()	const { return op1p()->castNode(); }	// op1 = case condition <expression>
     AstCaseItem*  itemsp()	const { return op2p()->castCaseItem(); }  // op2 = list of case expressions
@@ -887,8 +1023,19 @@ struct AstNodeCase : public AstNodeStmt {
     void addNotParallelp(AstNode* nodep) { setOp3p(nodep); }
 };
 
+struct AstNodeSenItem : public AstNode {
+    // An AstSenItem or AstSenGate
+    AstNodeSenItem(FileLine* fl) : AstNode(fl) {}
+    ASTNODE_BASE_FUNCS(NodeSenItem)
+    virtual bool isClocked() const = 0;
+    virtual bool isCombo() const = 0;
+    virtual bool isInitial() const = 0;
+    virtual bool isSettle() const = 0;
+    virtual bool isNever() const = 0;
+};
+
 class AstNodeVarRef : public AstNodeMath {
-    // A AstVarRef or AstVarXRef
+    // An AstVarRef or AstVarXRef
 private:
     bool	m_lvalue;	// Left hand side assignment
     AstVar*	m_varp;		// [AfterLink] Pointer to variable itself
@@ -907,12 +1054,12 @@ public:
 	// May have varp==NULL
 	if (m_varp) widthSignedFrom((AstNode*)m_varp);
     }
-    virtual ~AstNodeVarRef() {}
+    ASTNODE_BASE_FUNCS(NodeVarRef)
     virtual bool broken() const;
     virtual int instrCount() const { return widthInstrs(); }
     virtual void cloneRelink();
     virtual string name()	const { return m_name; }		// * = Var name
-    void 	name(const string& name) 	{ m_name = name; }
+    virtual void name(const string& name) { m_name = name; }
     bool	lvalue() const { return m_lvalue; }
     void	lvalue(bool lval) { m_lvalue=lval; }  // Avoid using this; Set in constructor
     AstVar*	varp() const { return m_varp; }				// [After Link] Pointer to variable
@@ -923,6 +1070,9 @@ public:
     void hiername(const string& hn) { m_hiername = hn; }
     bool hierThis() const { return m_hierThis; }
     void hierThis(bool flag) { m_hierThis = flag; }
+    // Know no children, and hot function, so skip iterator for speed
+    // See checkTreeIter also that asserts no children
+    void iterateChildren(AstNVisitor& v, AstNUser* vup=NULL) { }
 };
 
 class AstNodePli : public AstNodeStmt {
@@ -931,7 +1081,7 @@ public:
     AstNodePli(FileLine* fl, const string& text, AstNode* exprsp)
 	: AstNodeStmt(fl), m_text(text) {
 	addNOp1p(exprsp); }
-    virtual ~AstNodePli() {}
+    ASTNODE_BASE_FUNCS(NodePli)
     virtual string name()	const { return m_text; }
     virtual int instrCount()	const { return instrCountPli(); }
     void exprsp(AstNode* nodep)	{ addOp1p(nodep); }	// op1 = Expressions to output
@@ -950,7 +1100,7 @@ public:
 	: AstNode(fileline) {
 	m_text = textp;	// Copy it
     }
-    virtual ~AstNodeText() {}
+    ASTNODE_BASE_FUNCS(NodeText)
     const string& text() const { return m_text; }
     virtual V3Hash sameHash() const { return V3Hash(text()); }
     virtual bool same(AstNode* samep) const {
@@ -980,13 +1130,13 @@ public:
 	, m_name(name), m_taskPublic(false) {
 	addNOp3p(stmtsp);
     }
-    virtual ~AstNodeFTask() {}
+    ASTNODE_BASE_FUNCS(NodeFTask)
     virtual void dump(ostream& str=cout);
     virtual string name()	const { return m_name; }		// * = Var name
     virtual bool maybePointedTo() const { return true; }
     // {AstFunc only} op1 = Range output variable
     // op3 = Statements/Ports/Vars
-    void 	name(const string& name) 	{ m_name = name; }
+    virtual void name(const string& name) 	{ m_name = name; }
     AstNode*	stmtsp() 	const { return op3p()->castNode(); }	// op1 = List of statements
     void	addStmtsp(AstNode* nodep) { addOp3p(nodep); }
     void	taskPublic(bool flag) { m_taskPublic=flag; }
@@ -999,14 +1149,14 @@ private:
     AstNodeFTask*	m_taskp;	// [AfterLink] Pointer to task referenced
     string		m_name;		// Name of variable
     string		m_dotted;	// Dotted part of scope to task or ""
-    string		m_inlinedDots;	// Dotted hiearchy flattened out
+    string		m_inlinedDots;	// Dotted hierarchy flattened out
 public:
     AstNodeFTaskRef(FileLine* fl, AstNode* namep, AstNode* pinsp)
 	:AstNode(fl)
 	, m_taskp(NULL) {
-	setOp1p(namep);	addNOp2p(pinsp); 
+	setOp1p(namep);	addNOp2p(pinsp);
     }
-    virtual ~AstNodeFTaskRef() {}
+    ASTNODE_BASE_FUNCS(NodeFTaskRef)
     virtual bool broken() const { return m_taskp && !m_taskp->brokeExists(); }
     virtual void cloneRelink() { if (m_taskp && m_taskp->clonep()) {
 	m_taskp = m_taskp->clonep()->castNodeFTask();
@@ -1019,7 +1169,7 @@ public:
     void	inlinedDots(const string& flag) { m_inlinedDots = flag; }
     AstNodeFTask*	taskp() const { return m_taskp; }		// [After Link] Pointer to variable
     void  	taskp(AstNodeFTask* taskp) { m_taskp=taskp; }
-    void	name(const string& name) { m_name = name; }
+    virtual void name(const string& name) { m_name = name; }
     void	dotted(const string& name) { m_dotted = name; }
     // op1 = namep
     AstNode*	namep()		const { return op1p(); }

src/V3AstNodes.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Ast node structures
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -21,8 +21,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <fstream>
 #include <iomanip>
 #include <vector>
@@ -44,19 +44,19 @@ void AstNodeVarRef::cloneRelink() {
 }
 
 int AstNodeSel::bitConst() const {
-    AstConst* constp=bitp()->castConst(); return (constp?constp->asInt():0);
+    AstConst* constp=bitp()->castConst(); return (constp?constp->toSInt():0);
 }
 
 bool AstVar::isSigPublic() const {
-    return (m_sigPublic || (v3Global.opt.allPublic() && !isTemp()));
+    return (m_sigPublic || (v3Global.opt.allPublic() && !isTemp() && !isGenVar()));
 }
 
 bool AstVar::isScQuad() const {
-    return (isSc()&&isQuad()&&v3Global.opt.pins64());
+    return (isSc() && isQuad() && !isScBv());
 }
 
-bool AstVar::isScWide() const {
-    return (isWide() || isSc()&&isQuad()&&!v3Global.opt.pins64());
+bool AstVar::isScBv() const {
+    return (isSc() && width() >= v3Global.opt.pinsBv());
 }
 
 void AstVar::combineType(AstVarType type) {
@@ -109,7 +109,7 @@ string AstVar::cType() const {
 	return "bool";
     } else if (widthMin() <= VL_WORDSIZE) {
 	return "uint32_t";
-    } else if (isScWide()) {
+    } else if (isWide()) {
 	return "uint32_t";  // []'s added later
     } else {
 	return "uint64_t";
@@ -117,12 +117,18 @@ string AstVar::cType() const {
 }
 
 string AstVar::scType() const {
-    if (widthMin() == 1) {
+    if (isScBv()) {
+	return (string("sc_bv<")+cvtToStr(widthMin())+"> ");  // Keep the space so don't get >>
+    } else if (widthMin() == 1) {
 	return "bool";
     } else if (widthMin() <= VL_WORDSIZE) {
-	return "uint32_t";
-    } else if (isScWide()) {
-	return (string("sc_bv<")+cvtToStr(widthMin())+"> ");  // Keep the space so don't get >>
+	if (widthMin() <= 8 && v3Global.opt.pinsUint8()) {
+	    return "uint8_t";
+	} else if (widthMin() <= 16 && v3Global.opt.pinsUint8()) {
+	    return "uint16_t";
+	} else {
+	    return "uint32_t";
+	}
     } else {
 	return "uint64_t";
     }
@@ -164,113 +170,30 @@ string AstScope::nameDotless() const {
     return dotless;
 }
 
-struct AstSenItemCmp {
-    inline bool operator () (const AstSenItem* lhsp, const AstSenItem* rhsp) const {
-	// Looks visually better if we keep sorted by name
-	if (lhsp->edgeType() < rhsp->edgeType()) return true;
-	if (lhsp->edgeType() > rhsp->edgeType()) return false;
-	if (!lhsp->varrefp() &&  rhsp->varrefp()) return true;
-	if ( lhsp->varrefp() && !rhsp->varrefp()) return false;
-	if (lhsp->varrefp() && rhsp->varrefp()) {
-	    if (lhsp->varrefp()->name() < rhsp->varrefp()->name()) return true;
-	    if (lhsp->varrefp()->name() > rhsp->varrefp()->name()) return false;
-	    // But might be same name with different scopes
-	    if (lhsp->varrefp()->varScopep() < rhsp->varrefp()->varScopep()) return true;
-	    if (lhsp->varrefp()->varScopep() > rhsp->varrefp()->varScopep()) return false;
-	}
-	return false;
-    }
-};
-
-void AstSenTree::sortSenses() {
-    // Sort the sensitivity names so "posedge a or b" and "posedge b or a" end up together.
-    // Also, remove duplicate assignments, and fold POS&NEGs into ANYEDGEs
-    //cout<<endl; this->dumpTree(cout,"ssin: ");
-    AstSenItem* nextp;
-    // Make things a little faster; check first if we need a sort
-    for (AstSenItem* senp = sensesp(); senp; senp=senp->nextp()->castSenItem()) {
-	nextp=senp->nextp()->castSenItem();
-	AstSenItemCmp cmp;
-	if (nextp && !cmp(senp, nextp)) {
-	    // Something's out of order, sort it
-	    senp = NULL;
-	    vector<AstSenItem*> vec;
-	    for (AstSenItem* senp = sensesp(); senp; senp=senp->nextp()->castSenItem()) {
-		vec.push_back(senp);
-	    }
-	    sort(vec.begin(), vec.end(), AstSenItemCmp());
-	    for (vector<AstSenItem*>::iterator it=vec.begin(); it!=vec.end(); ++it) {
-		(*it)->unlinkFrBack();
-	    }
-	    for (vector<AstSenItem*>::iterator it=vec.begin(); it!=vec.end(); ++it) {
-		this->addSensesp(*it);
-	    }
-	    break;
-	}
-    }
-
-    // Pass2, remove dup edges
-    for (AstSenItem* senp = sensesp(); senp; senp=nextp) {
-	nextp=senp->nextp()->castSenItem();
-	AstSenItem* cmpp = nextp;
-	if (cmpp
-	    && ((senp->varrefp() && cmpp->varrefp() && senp->varrefp()->sameTree(cmpp->varrefp()))
-		|| (!senp->varrefp() && !cmpp->varrefp()))) {
-	    // We've sorted in the order ANY, BOTH, POS, NEG, so we don't need to try opposite orders
-	    if ((   senp->edgeType()==AstEdgeType::ANYEDGE)    // ANY  or {BOTH|POS|NEG} -> ANY
-		|| (senp->edgeType()==AstEdgeType::BOTHEDGE)   // BOTH or {POS|NEG} -> BOTH
-		|| (senp->edgeType()==AstEdgeType::POSEDGE     // POS  or NEG -> BOTH
-		    && cmpp->edgeType()==AstEdgeType::NEGEDGE)
-		|| (senp->edgeType()==cmpp->edgeType())		// Identical edges
-		) {
-		// Fix edge of old node
-		if (senp->edgeType()==AstEdgeType::POSEDGE
-		    && cmpp->edgeType()==AstEdgeType::NEGEDGE)
-		    senp->edgeType(AstEdgeType::BOTHEDGE);
-		// Remove redundant node
-		cmpp->unlinkFrBack()->deleteTree(); cmpp=NULL;
-		// Try to collapse again
-		nextp=senp;
-	    }
-	}
-    }
-
-    // Pass3, remove nevers
-    if (sensesp()->nextp()) {   // Else only one never, can't remove it
-	for (AstSenItem* senp = sensesp(); senp; senp=nextp) {
-	    nextp=senp->nextp()->castSenItem();
-	    if (senp->isNever()) {
-		senp->unlinkFrBack()->deleteTree(); senp=NULL;
-	    }
-	}
-    }
-    //this->dumpTree(cout,"ssou: ");
-}
-
 bool AstSenTree::hasClocked() {
     if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
-    for (AstSenItem* senp = sensesp(); senp; senp=senp->nextp()->castSenItem()) {
+    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
 	if (senp->isClocked()) return true;
     }
     return false;
 }
 bool AstSenTree::hasSettle() {
     if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
-    for (AstSenItem* senp = sensesp(); senp; senp=senp->nextp()->castSenItem()) {
+    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
 	if (senp->isSettle()) return true;
     }
     return false;
 }
 bool AstSenTree::hasInitial() {
     if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
-    for (AstSenItem* senp = sensesp(); senp; senp=senp->nextp()->castSenItem()) {
+    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
 	if (senp->isInitial()) return true;
     }
     return false;
 }
 bool AstSenTree::hasCombo() {
     if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
-    for (AstSenItem* senp = sensesp(); senp; senp=senp->nextp()->castSenItem()) {
+    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
 	if (senp->isCombo()) return true;
     }
     return false;
@@ -290,6 +213,11 @@ void AstNode::dump(ostream& os) {
     if (!widthSized()) os<<"/"<<widthMin();
     if (name()!="") os<<"  "<<name();
 }
+
+void AstAttrOf::dump(ostream& str) {
+    this->AstNode::dump(str);
+    str<<" ["<<attrType().ascii()<<"]";
+}
 void AstCast::dump(ostream& str) {
     this->AstNode::dump(str);
     str<<" sz"<<size();
@@ -303,10 +231,15 @@ void AstCellInline::dump(ostream& str) {
     this->AstNode::dump(str);
     str<<" -> "<<origModName();
 }
+void AstDisplay::dump(ostream& str) {
+    this->AstNode::dump(str);
+    //str<<" "<<displayType().ascii();
+}
 void AstPin::dump(ostream& str) {
     this->AstNode::dump(str);
     if (modVarp()) { str<<" -> "; modVarp()->dump(str); }
     else { str<<" ->UNLINKED"; }
+    if (svImplicit()) str<<" [.SV]";
 }
 void AstVarXRef::dump(ostream& str) {
     this->AstNode::dump(str);
@@ -387,6 +320,12 @@ void AstNodeFTask::dump(ostream& str) {
 }
 void AstCoverDecl::dump(ostream& str) {
     this->AstNode::dump(str);
+    if (this->dataDeclNullp()) {
+	str<<" -> ";
+	this->dataDeclNullp()->dump(str);
+    } else {
+	if (binNum()) { str<<" bin"<<dec<<binNum(); }
+    }
 }
 void AstCoverInc::dump(ostream& str) {
     this->AstNode::dump(str);
@@ -412,3 +351,7 @@ void AstCCall::dump(ostream& str) {
 	funcp()->dump(str);
     }
 }
+void AstCFunc::dump(ostream& str) {
+    this->AstNode::dump(str);
+    if (slow()) str<<" [SLOW]";
+}

src/V3Begin.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Removal of named begin blocks
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Begin's Transformations:
-//		
+//
 // Each module:
 //	Look for BEGINs
 //	    BEGIN(VAR...) -> VAR ... {renamed}
@@ -29,8 +29,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 #include <vector>
@@ -48,11 +48,19 @@ private:
     AstModule*		m_modp;		// Current module
     AstNodeFTask* 	m_ftaskp;	// Current function/task
     string		m_beginScope;	// Name of begin blocks above us
-    //int debug() { return 9; }
+    int			m_repeatNum;	// Repeat counter
+
+    // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
 
     // VISITORS
     virtual void visit(AstModule* nodep, AstNUser*) {
 	m_modp = nodep;
+	m_repeatNum = 0;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
@@ -131,10 +139,42 @@ private:
 	nodep->replaceWith(newp);
 	nodep->deleteTree(); nodep=NULL;
     }
-    virtual void visit(AstDisplay* nodep, AstNUser*) {
+    virtual void visit(AstRepeat* nodep, AstNUser*) {
+	// So later optimizations don't need to deal with them,
+	//    REPEAT(count,body) -> loop=count,WHILE(loop>0) { body, loop-- }
+	// Note var can be signed or unsigned based on original number.
+	AstNode* countp = nodep->countp()->unlinkFrBackWithNext();
+   	string name = string("__Vrepeat")+cvtToStr(m_repeatNum++);
+	AstVar* varp = new AstVar(nodep->fileline(), AstVarType::BLOCKTEMP, name,
+				  new AstRange(nodep->fileline(), countp->width()-1, 0));
+	m_modp->addStmtp(varp);
+	AstNode* initsp = new AstAssign(nodep->fileline(), new AstVarRef(nodep->fileline(), varp, true),
+					countp);
+	AstNode* decp = new AstAssign(nodep->fileline(), new AstVarRef(nodep->fileline(), varp, true),
+				      new AstSub(nodep->fileline(), new AstVarRef(nodep->fileline(), varp, false),
+						 new AstConst(nodep->fileline(), 1)));
+	AstNode* condp;
+	if (countp->isSigned()) {
+	    condp = new AstGtS(nodep->fileline(), new AstVarRef(nodep->fileline(), varp, false),
+			       new AstConst(nodep->fileline(), 0));
+	} else {
+	    condp = new AstGt (nodep->fileline(), new AstVarRef(nodep->fileline(), varp, false),
+			       new AstConst(nodep->fileline(), 0));
+	}
+	AstNode* bodysp = nodep->bodysp(); if (bodysp) bodysp->unlinkFrBackWithNext();
+	bodysp = bodysp->addNext(decp);
+	AstNode* newp = new AstWhile(nodep->fileline(),
+				     condp,
+				     bodysp);
+	initsp = initsp->addNext(newp);
+	newp = initsp;
+	nodep->replaceWith(newp);
+	nodep->deleteTree(); nodep=NULL;
+    }
+    virtual void visit(AstScopeName* nodep, AstNUser*) {
 	// If there's a %m in the display text, we add a special node that will contain the name()
 	// Similar code in V3Inline
-	if (m_beginScope != "" && nodep->needScopeTracking()) {
+	if (m_beginScope != "") {
 	    // To keep correct visual order, must add before other Text's
 	    AstNode* afterp = nodep->scopeAttrp();
 	    if (afterp) afterp->unlinkFrBackWithNext();
@@ -143,6 +183,11 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
+    virtual void visit(AstCoverDecl* nodep, AstNUser*) {
+	// Don't need to fix path in coverage statements, they're not under
+	// any BEGINs, but V3Coverage adds them all under the module itself.
+	nodep->iterateChildren(*this);
+    }
     virtual void visit(AstNode* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
     }
@@ -151,6 +196,7 @@ public:
     BeginVisitor(AstNetlist* nodep) {
 	m_modp = NULL;
 	m_ftaskp = NULL;
+	m_repeatNum = 0;
 	nodep->accept(*this);
     }
     virtual ~BeginVisitor() {}

src/V3Begin.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Removal of named begin blocks
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3Branch.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Branch prediction
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -21,14 +21,14 @@
 // BRANCH TRANSFORMATIONS:
 //	At each IF/(IF else).
 //	   Count underneath $display/$stop statements.
-//	   If more on if then else, this branch is unlikely, or vice-versa.
+//	   If more on if than else, this branch is unlikely, or vice-versa.
 //
 //*************************************************************************
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <map>
 
@@ -44,9 +44,14 @@ private:
     // STATE
     int		m_likely;	// Excuses for branch likely taken
     int		m_unlikely;	// Excuses for branch likely not taken
-    //int debug() { return 9; }
 
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     void reset() {
 	m_likely = false;
 	m_unlikely = false;

src/V3Branch.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Branch prediction
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3Broken.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Find broken links in tree
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Broken's Transformations:
-//		
+//
 // Entire netlist
 //	Mark all nodes
 //	Check all links point to marked nodes
@@ -28,11 +28,11 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
-#include <set>
+#include <map>
 
 #include "V3Global.h"
 #include "V3Broken.h"
@@ -45,19 +45,100 @@ class BrokenTable : public AstNVisitor {
 private:
     // MEMBERS
     //   For each node, we keep if it exists or not.
-    typedef set<const AstNode*> NodeSet;
-    static NodeSet s_nodes;	// Set of all nodes that exist
+    typedef map<const AstNode*,int> NodeMap;
+    static NodeMap s_nodes;	// Set of all nodes that exist
+    // BITMASK
+    static const int FLAG_ALLOCATED	= 0x01;		// new() and not delete()ed
+    static const int FLAG_IN_TREE	= 0x02;		// Is in netlist tree
+    static const int FLAG_LINKABLE	= 0x04;		// Is in netlist tree, can be linked to
+    static const int FLAG_LEAKED	= 0x08;		// Known to have been leaked
 public:
     // METHODS
-    static void add(const AstNode* nodep) {
-	s_nodes.insert(nodep);
+    static void deleted(const AstNode* nodep) {
+	// Called by operator delete on any node - only if VL_LEAK_CHECKS
+	if (debug()) cout<<"-nodeDel:  "<<(void*)(nodep)<<endl;
+	NodeMap::iterator iter = s_nodes.find(nodep);
+	if (iter==s_nodes.end() || !(iter->second & FLAG_ALLOCATED)) {
+	    ((AstNode*)(nodep))->v3fatalSrc("Deleting AstNode object that was never tracked or already deleted\n");
+	}
+	if (iter!=s_nodes.end()) s_nodes.erase(iter);
     }
-    static bool exists(const AstNode* nodep) {
-	NodeSet::iterator iter = s_nodes.find(nodep);
-	return (iter != s_nodes.end());
+    static void addNewed(const AstNode* nodep) {
+	// Called by operator new on any node - only if VL_LEAK_CHECKS
+	if (debug()) cout<<"-nodeNew:  "<<(void*)(nodep)<<endl;
+	NodeMap::iterator iter = s_nodes.find(nodep);
+	if (iter!=s_nodes.end() || (iter->second & FLAG_ALLOCATED)) {
+	    ((AstNode*)(nodep))->v3fatalSrc("Newing AstNode object that is already allocated\n");
+	}
+	if (iter == s_nodes.end()) {
+	    s_nodes.insert(make_pair(nodep,FLAG_ALLOCATED));
+	}
     }
-    static void clear() {
+    static void addInTree(AstNode* nodep, bool linkable) {
+#ifndef VL_LEAK_CHECKS
+	if (!linkable) return;  // save some time, else the map will get huge!
+#endif
+	NodeMap::iterator iter = s_nodes.find(nodep);
+	if (iter == s_nodes.end()) {
+#ifdef VL_LEAK_CHECKS
+	    nodep->v3fatalSrc("AstNode is in tree, but not allocated\n");
+#endif
+	} else {
+	    if (!(iter->second & FLAG_ALLOCATED)) {
+#ifdef VL_LEAK_CHECKS
+		nodep->v3fatalSrc("AstNode is in tree, but not allocated\n");
+#endif
+	    }
+	    if (iter->second & FLAG_IN_TREE) {
+		nodep->v3fatalSrc("AstNode is already in tree at another location\n");
+	    }
+	}
+	int or_flags = FLAG_IN_TREE | (linkable?FLAG_LINKABLE:0);
+	if (iter == s_nodes.end()) {
+	    s_nodes.insert(make_pair(nodep,or_flags));
+	} else {
+	    iter->second |= or_flags;
+	}
+    }
+    static bool okIfLinkedTo(const AstNode* nodep) {
+	// Someone has a pointer to this node.  Is it kosher?
+	NodeMap::iterator iter = s_nodes.find(nodep);
+	if (iter == s_nodes.end()) return false;
+#ifdef VL_LEAK_CHECKS
+	if (!(iter->second & FLAG_ALLOCATED)) return false;
+#endif
+	if (!(iter->second & FLAG_IN_TREE)) return false;
+	if (!(iter->second & FLAG_LINKABLE)) return false;
+	return true;
+    }
+    static void prepForTree() {
+#ifndef VL_LEAK_CHECKS
 	s_nodes.clear();
+#endif
+	for (NodeMap::iterator it = s_nodes.begin(); it != s_nodes.end(); ++it) {
+	    it->second &= ~FLAG_IN_TREE;
+	    it->second &= ~FLAG_LINKABLE;
+	}
+    }
+    static void doneWithTree() {
+	for (int backs=0; backs<2; backs++) {  // Those with backp() are probably under one leaking without
+	    for (NodeMap::iterator it = s_nodes.begin(); it != s_nodes.end(); ++it) {
+		if ((it->second & FLAG_ALLOCATED)
+		    && !(it->second & FLAG_IN_TREE)
+		    && !(it->second & FLAG_LEAKED)
+		    && (it->first->backp() ? backs==1 : backs==0)) {
+		    // Use only AstNode::dump instead of the virtual one, as there
+		    // may be varp() and other cross links that are bad.
+		    if (debug()) {
+			cerr<<"%Error: LeakedNode"<<(it->first->backp()?"Back: ":": ");
+			((AstNode*)(it->first))->AstNode::dump(cerr);
+			cerr<<endl;
+			V3Error::incErrors();
+		    }
+		    it->second |= FLAG_LEAKED;
+		}
+	    }
+	}
     }
 public:
     // CONSTUCTORS
@@ -65,11 +146,11 @@ public:
     virtual ~BrokenTable() {}
 };
 
-BrokenTable::NodeSet BrokenTable::s_nodes;
+BrokenTable::NodeMap BrokenTable::s_nodes;
 
 bool AstNode::brokeExists() const {
     // Called by node->broken() routines to do table lookup
-    return BrokenTable::exists(this);
+    return BrokenTable::okIfLinkedTo(this);
 }
 
 //######################################################################
@@ -82,9 +163,7 @@ private:
     //			// so userp and friends may not be used
     // VISITORS
     virtual void visit(AstNode* nodep, AstNUser*) {
-	if (nodep->maybePointedTo()) {
-	    BrokenTable::add(nodep);
-	}
+	BrokenTable::addInTree(nodep, nodep->maybePointedTo());
 	nodep->iterateChildren(*this);
     }
 public:
@@ -127,8 +206,15 @@ public:
 
 void V3Broken::brokenAll(AstNetlist* nodep) {
     //UINFO(9,__FUNCTION__<<": "<<endl);
-    BrokenTable::clear();
+    BrokenTable::prepForTree();
     BrokenMarkVisitor mvisitor (nodep);
     BrokenCheckVisitor cvisitor (nodep);
-    BrokenTable::clear();
+    BrokenTable::doneWithTree();
+}
+
+void V3Broken::addNewed(AstNode* nodep) {
+    BrokenTable::addNewed(nodep);
+}
+void V3Broken::deleted(AstNode* nodep) {
+    BrokenTable::deleted(nodep);
 }

src/V3Broken.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Find broken links in tree
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -31,6 +32,8 @@
 class V3Broken {
 public:
     static void brokenAll(AstNetlist* nodep);
+    static void addNewed(AstNode* nodep);
+    static void deleted(AstNode* nodep);
 };
 
 #endif // Guard

src/V3Case.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Break case statements up and add Unknown assigns
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Case's Transformations:
-//		
+//
 // Each module:
 //	TBD: Eliminate tristates by adding __in, __inen, __en wires in parallel
 //	    Need __en in changed list if a signal is on the LHS of a assign
@@ -40,8 +40,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 
@@ -59,12 +59,14 @@
 class CaseLintVisitor : public AstNVisitor {
 private:
     AstNodeCase* m_caseExprp;	// Under a CASE value node, if so the relevant case statement
-    //int debug() { return 9; }
+
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
 
     virtual void visit(AstNodeCase* nodep, AstNUser*) {
-	// We report a syntax error on empty "case (x) endcase" blocks, so never no items at all
-	if (!nodep->itemsp()) nodep->v3fatalSrc("No items (not even default) under case statement?\n");
-
 	// Detect multiple defaults
 	bool hitDefault = false;
 	for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
@@ -77,7 +79,7 @@ private:
 	}
 
 	// Check for X/Z in non-casex statements
-	if (!nodep->castCase() || !nodep->castCase()->casex()) {
+	{
 	    m_caseExprp = nodep;
 	    nodep->exprp()->accept(*this);
 	    for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
@@ -87,11 +89,18 @@ private:
 	}
     }
     virtual void visit(AstConst* nodep, AstNUser*) {
+	// See also neverItem
 	if (m_caseExprp && nodep->num().isFourState()) {
 	    if (m_caseExprp->castGenCase()) {
 		nodep->v3error("Use of x/? constant in generate case statement, (no such thing as 'generate casez')");
+	    } else if (m_caseExprp->castCase() && m_caseExprp->castCase()->casex()) {
+		// Don't sweat it, we already complained about casex in general
+	    } else if (m_caseExprp->castCase() && m_caseExprp->castCase()->casez()) {
+		if (nodep->num().isUnknown()) {
+		    nodep->v3warn(CASEWITHX, "Use of x constant in casez statement, (perhaps intended ?/z in constant)");
+		}
 	    } else {
-		nodep->v3error("Use of x/? constant in case statement, (perhaps intended casex/casez)");
+		nodep->v3warn(CASEWITHX, "Use of x/? constant in case statement, (perhaps intended casex/casez)");
 	    }
 	}
     }
@@ -115,6 +124,7 @@ private:
     // NODE STATE
     // Cleared each Case
     //  AstIf::user3()		-> bool.  Set true to indicate clone not needed
+    AstUser3InUse	m_inuser3;
 
     // STATE
     V3Double0	m_statCaseFast;	// Statistic tracking
@@ -126,9 +136,13 @@ private:
     int		m_caseNoOverlapsAllCovered;	// Proven to be synopsys parallel_case compliant
     AstNode*	m_valueItem[1<<CASE_OVERLAP_WIDTH];  // For each possible value, the case branch we need
 
-    //int debug() { return 9; }
-
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     bool isCaseTreeFast(AstCase* nodep) {
 	int width = 0;
 	m_caseItems = 0;
@@ -156,20 +170,24 @@ private:
 		//if (debug()>=9) icondp->dumpTree(cout," caseitem: ");
 		AstConst* iconstp = icondp->castConst();
 		if (!iconstp) nodep->v3fatalSrc("above 'can't parse' should have caught this\n");
-		V3Number nummask (itemp->fileline(), iconstp->width());
-		nummask.opBitsNonX(iconstp->num());
-		uint32_t mask = nummask.asInt();
-		V3Number numval  (itemp->fileline(), iconstp->width());
-		numval.opBitsOne(iconstp->num());
-		uint32_t val  = numval.asInt();
-		for (uint32_t i=0; i<(1UL<<m_caseWidth); i++) {
-		    if ((i & mask) == val) {
-			if (!m_valueItem[i]) {
-			    m_valueItem[i] = itemp;
-			} else if (!itemp->ignoreOverlap() && !bitched) {
-			    itemp->v3warn(CASEOVERLAP,"Case values overlap (example pattern 0x"<<hex<<i<<")");
-			    bitched = true;
-			    m_caseNoOverlapsAllCovered = false;
+		if (neverItem(nodep, iconstp)) {
+		    // X in casez can't ever be executed
+		} else {
+		    V3Number nummask (itemp->fileline(), iconstp->width());
+		    nummask.opBitsNonX(iconstp->num());
+		    uint32_t mask = nummask.toUInt();
+		    V3Number numval  (itemp->fileline(), iconstp->width());
+		    numval.opBitsOne(iconstp->num());
+		    uint32_t val  = numval.toUInt();
+		    for (uint32_t i=0; i<(1UL<<m_caseWidth); i++) {
+			if ((i & mask) == val) {
+			    if (!m_valueItem[i]) {
+				m_valueItem[i] = itemp;
+			    } else if (!itemp->ignoreOverlap() && !bitched) {
+				itemp->v3warn(CASEOVERLAP,"Case values overlap (example pattern 0x"<<hex<<i<<")");
+				bitched = true;
+				m_caseNoOverlapsAllCovered = false;
+			    }
 			}
 		    }
 		}
@@ -201,6 +219,7 @@ private:
 	if (msb<0) {
 	    // There's no space for a IF.  We know upperValue is thus down to a specific
 	    // exact value, so just return the tree value
+	    // Note can't clone here, as we're going to check for equivelence above
 	    return m_valueItem[upperValue];
 	}
 	else {
@@ -221,7 +240,10 @@ private:
 		 a++, b++) {
 		if (m_valueItem[a] != m_valueItem[b]) { same=false; break; }
 	    }
-	    if (same) return tree0p;
+	    if (same) {
+		tree1p->deleteTree(); tree1p=NULL;
+		return tree0p;
+	    }
 
 	    // Must have differing logic, so make a selection
 
@@ -235,7 +257,7 @@ private:
 	    //                            new AstConst(cexprp->fileline(), nummask));
 	    AstNode* and1p = new AstSel(cexprp->fileline(), cexprp->cloneTree(false),
 					msb, 1);
-	    AstNode* eqp = new AstNeq(cexprp->fileline(), 
+	    AstNode* eqp = new AstNeq(cexprp->fileline(),
 				      new AstConst(cexprp->fileline(), 0),
 				      and1p);
 	    AstIf* ifp = new AstIf(cexprp->fileline(), eqp, tree1p, tree0p);
@@ -248,8 +270,7 @@ private:
 	// CASEx(cexpr,....
 	// ->  tree of IF(msb,  IF(msb-1, 11, 10)
 	//                      IF(msb-1, 01, 00))
-	AstNode* cexprp = nodep->exprp();
-	cexprp->unlinkFrBack();
+	AstNode* cexprp = nodep->exprp()->unlinkFrBack();
 
 	if (debug()>=9) {
 	    for (uint32_t i=0; i<(1UL<<m_caseWidth); i++) {
@@ -264,9 +285,13 @@ private:
 
 	AstNode::user3ClearTree();
 	AstNode* ifrootp = replaceCaseFastRecurse(cexprp, m_caseWidth-1, 0UL);
+	// Case expressions can't be linked twice, so clone them
+	if (ifrootp && !ifrootp->user3()) ifrootp = ifrootp->cloneTree(true);
 
 	if (ifrootp) nodep->replaceWith(ifrootp);
 	else nodep->unlinkFrBack();
+	nodep->deleteTree(); nodep=NULL;
+	cexprp->deleteTree(); cexprp=NULL;
 	if (debug()>=9) ifrootp->dumpTree(cout,"    _simp: ");
     }
 
@@ -292,21 +317,29 @@ private:
 		for (AstNode* icondp = itemp->condsp(); icondp!=NULL; icondp=icondNextp) {
 		    icondNextp = icondp->nextp();
 		    icondp->unlinkFrBack();
-		    
+
 		    AstNode* and1p;
 		    AstNode* and2p;
 		    AstConst* iconstp = icondp->castConst();
-		    if (iconstp && iconstp->num().isFourState()
-			&& nodep->casex()) {
+		    if (iconstp && neverItem(nodep, iconstp)) {
+			// X in casez can't ever be executed
+			icondp->deleteTree(); icondp=NULL; iconstp=NULL;
+			// For simplicity, make expression that is not equal, and let later
+			// optimizations remove it
+			and1p = new AstConst(itemp->fileline(), V3Number(itemp->fileline(),1,0));
+			and2p = new AstConst(itemp->fileline(), V3Number(itemp->fileline(),1,1));
+		    } else if (iconstp && iconstp->num().isFourState()
+			       && (nodep->casex() || nodep->casez())) {
 			V3Number nummask (itemp->fileline(), iconstp->width());
 			nummask.opBitsNonX(iconstp->num());
 			V3Number numval  (itemp->fileline(), iconstp->width());
 			numval.opBitsOne(iconstp->num());
 			and1p = new AstAnd(itemp->fileline(), cexprp->cloneTree(false),
 					   new AstConst(itemp->fileline(), nummask));
-			and2p = new AstAnd(itemp->fileline(), 
+			and2p = new AstAnd(itemp->fileline(),
 					   new AstConst(itemp->fileline(), numval),
 					   new AstConst(itemp->fileline(), nummask));
+			icondp->deleteTree(); icondp=NULL; iconstp=NULL;
 		    } else {
 			// Not a caseX mask, we can simply build CASEEQ(cexpr icond)
 			and1p = cexprp->cloneTree(false);
@@ -323,6 +356,7 @@ private:
 		itemp->condsp(ifexprp);
 	    }
 	}
+	cexprp->deleteTree(); cexprp=NULL;
 	if (!hadDefault) {
 	    // If there was no default, add a empty one, this greatly simplifies below code
 	    // and constant propagation will just eliminate it for us later.
@@ -392,6 +426,17 @@ private:
 	}
     }
 
+    bool neverItem(AstCase* casep, AstConst* itemp) {
+	// Xs in case or casez are impossible due to two state simulations
+	if (casep->casex()) {
+	} else if (casep->casez()) {
+	    if (itemp->num().isUnknown()) return true;
+	} else {
+	    if (itemp->num().isFourState()) return true;
+	}
+	return false;
+    }
+
     // VISITORS
     virtual void visit(AstCase* nodep, AstNUser*) {
 	V3Case::caseLint(nodep);

src/V3Case.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Break case statements up and add Unknown assigns
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3Cast.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Add C++ casts across expression size changes
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2004-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2004-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Cast's Transformations:
-//		
+//
 // Each module:
 //	For each math operator, if above operator requires 32 bits,
 //	and this isn't, cast to 32 bits.
@@ -44,8 +44,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 
@@ -60,11 +60,18 @@ class CastVisitor : public AstNVisitor {
 private:
     // NODE STATE
     // Entire netlist:
+    //   AstNode::user()		// bool.  Indicates node is of known size
+    AstUser1InUse	m_inuser1;
 
     // STATE
-    //int debug() { return 9; }
 
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     void insertCast(AstNode* nodep, int needsize) {  // We'll insert ABOVE passed node
 	UINFO(4,"  NeedCast "<<nodep<<endl);
 	AstNRelinker relinkHandle;
@@ -76,6 +83,7 @@ private:
 	//if (debug()>8) castp->dumpTree(cout,"-castins: ");
 	//
 	insureLower32Cast(castp);
+	nodep->user1(1);  // Now must be of known size
     }
     int castSize (AstNode* nodep) {
 	if (nodep->isQuad()) return VL_QUADSIZE;
@@ -84,7 +92,8 @@ private:
 	else return VL_WORDSIZE;
     }
     void insureCast(AstNode* nodep) {
-	if (castSize(nodep->backp()) != castSize(nodep)) {
+	if (castSize(nodep->backp()) != castSize(nodep)
+	    || !nodep->user1()) {
 	    insertCast(nodep, castSize(nodep->backp()));
 	}
     }
@@ -102,15 +111,21 @@ private:
     // VISITORS
     virtual void visit(AstNodeUniop* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
+	nodep->user1(nodep->lhsp()->user1());
 	if (nodep->sizeMattersLhs()) insureCast(nodep->lhsp());
     }
     virtual void visit(AstNodeBiop* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
+	nodep->user1(nodep->lhsp()->user1()
+		    | nodep->rhsp()->user1());
 	if (nodep->sizeMattersLhs()) insureCast(nodep->lhsp());
 	if (nodep->sizeMattersRhs()) insureCast(nodep->rhsp());
     }
     virtual void visit(AstNodeTriop* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
+	nodep->user1(nodep->lhsp()->user1()
+		    | nodep->rhsp()->user1()
+		    | nodep->thsp()->user1());
 	if (nodep->sizeMattersLhs()) insureCast(nodep->lhsp());
 	if (nodep->sizeMattersRhs()) insureCast(nodep->rhsp());
 	if (nodep->sizeMattersThs()) insureCast(nodep->thsp());
@@ -118,9 +133,11 @@ private:
     virtual void visit(AstCast* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	insureLower32Cast(nodep);
+	nodep->user1(1);
     }
     virtual void visit(AstUnaryMin* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
+	nodep->user1(nodep->lhsp()->user1());
 	if (nodep->lhsp()->widthMin()==1) {
 	    // We want to avoid a GCC "converting of negative value" warning
 	    // from our expansion of
@@ -137,9 +154,16 @@ private:
 	    && nodep->backp()->width()
 	    && castSize(nodep) != castSize(nodep->varp())) {
 	    // Cast vars to IData first, else below has upper bits wrongly set
-	    //  CData x=3;  out = (QData)(x<<30); 
+	    //  CData x=3;  out = (QData)(x<<30);
 	    insertCast (nodep, castSize(nodep));
 	}
+	nodep->user1(1);
+    }
+    virtual void visit(AstConst* nodep, AstNUser*) {
+	// Constants are of unknown size if smaller than 33 bits, becase
+	// we're too lazy to wrap every constant in the universe in
+	// ((IData)#).
+	nodep->user1(nodep->isQuad() || nodep->isWide());
     }
 
     // NOPs

src/V3Cast.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Add C++ casts across expression size changes
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2004-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2004-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3Changed.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Add temporaries, such as for changed nodes
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Changed's Transformations:
-//		
+//
 // Each module:
 //	Each combo block
 //	    For each variable that comes from combo block and is generated AFTER a usage
@@ -33,8 +33,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 #include <set>
@@ -51,19 +51,27 @@ class ChangedVisitor : public AstNVisitor {
 private:
     // NODE STATE
     // Entire netlist:
-    //  AstVarScope::user()		-> bool.  True indicates processed
+    //  AstVarScope::user1()		-> bool.  True indicates processed
+    AstUser1InUse	m_inuser1;
+
     // STATE
     AstModule*		m_topModp;	// Top module
     AstScope*		m_scopetopp;	// Scope under TOPSCOPE
     AstCFunc*		m_chgFuncp;	// Change function we're building
-    //int debug() { return 9; }
 
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     void genChangeDet(AstVarScope* vscp) {
 #ifdef NEW_ORDERING
 	vscp->v3fatalSrc("Not applicable\n");
 #endif
 	AstVar* varp = vscp->varp();
+	vscp->v3warn(IMPERFECTSCH,"Imperfect scheduling of variable: "<<vscp);
 	if (varp->arraysp()) {
 	    vscp->v3error("Unsupported: Can't detect changes on arrayed variable (probably with UNOPTFLAT warning suppressed): "<<varp->prettyName());
 	} else {
@@ -101,7 +109,7 @@ private:
     virtual void visit(AstTopScope* nodep, AstNUser*) {
 	UINFO(4," TS "<<nodep<<endl);
 	// Clearing
-	AstNode::userClearTree();
+	AstNode::user1ClearTree();
 	// Create the change detection function
 	AstScope* scopep = nodep->scopep();
 	if (!scopep) nodep->v3fatalSrc("No scope found on top level, perhaps you have no statements?\n");
@@ -120,8 +128,8 @@ private:
     virtual void visit(AstVarScope* nodep, AstNUser*) {
 	if (nodep->isCircular()) {
 	    UINFO(8,"  CIRC "<<nodep<<endl);
-	    if (!nodep->user()) {
-		nodep->user(true);
+	    if (!nodep->user1()) {
+		nodep->user1(true);
 		genChangeDet(nodep);
 	    }
 	}

src/V3Changed.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Pre C-Emit stage changes
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3Clean.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Add temporaries, such as for clean nodes
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Clean's Transformations:
-//		
+//
 // Each module:
 //	For each math operator, if it requires a clean operand,
 //	and the operand is dirty, insert a CLEAN node.
@@ -30,8 +30,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 
@@ -48,15 +48,22 @@ private:
     // Entire netlist:
     //  AstNode::user()		-> CleanState.  For this node, 0==UNKNOWN
     //  AstNode::user2()	-> bool.  True indicates minWidth has been propagated
+    AstUser1InUse	m_inuser1;
+    AstUser2InUse	m_inuser2;
+
+    // TYPES
+    enum CleanState { UNKNOWN, CLEAN, DIRTY };
 
     // STATE
     AstModule* m_modp;
-    //int debug() { return 9; }
 
-    // ENUMS
-    enum CleanState { UNKNOWN, CLEAN, DIRTY };
-    
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     // Width resetting
     int  cppWidth(AstNode* nodep) {
 	if (nodep->width()<=VL_WORDSIZE) return VL_WORDSIZE;
@@ -79,10 +86,10 @@ private:
 
     // Store the clean state in the userp on each node
     void setCleanState(AstNode* nodep, CleanState clean) {
-	nodep->user(clean);
+	nodep->user1(clean);
     }
     CleanState getCleanState(AstNode* nodep) {
-	return ((CleanState)nodep->user());
+	return ((CleanState)nodep->user1());
     }
     bool isClean(AstNode* nodep) {
 	CleanState clstate = getCleanState(nodep);
@@ -156,6 +163,7 @@ private:
     virtual void visit(AstModule* nodep, AstNUser*) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
+	m_modp = NULL;
     }
     virtual void visit(AstNodeUniop* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
@@ -196,6 +204,9 @@ private:
     virtual void visit(AstText* nodep, AstNUser*) {
 	setClean (nodep, true);
     }
+    virtual void visit(AstScopeName* nodep, AstNUser*) {
+	setClean (nodep, true);
+    }
     virtual void visit(AstSel* nodep, AstNUser*) {
 	operandTriop(nodep);
         setClean (nodep, nodep->cleanOut());
@@ -254,8 +265,6 @@ public:
     CleanVisitor() {}
     virtual ~CleanVisitor() {}
     void main(AstNetlist* nodep) {
-	AstNode::userClearTree();	// userp() used on entire tree
-	AstNode::user2ClearTree();	// userp() used on entire tree
 	nodep->accept(*this);
     }
 };

src/V3Clean.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Pre C-Emit stage changes
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3ClkGater.cpp

@@ -0,0 +1,918 @@
+// -*- C++ -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: Break always into sensitivity active domains
+//
+// Code available from: http://www.veripool.org/verilator
+//
+// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
+//
+//*************************************************************************
+//
+// Copyright 2008-2009 by Wilson Snyder.  This program is free software; you can
+// redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+//
+// 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.
+//
+//*************************************************************************
+// V3ClkGater's Transformations:
+//
+//   Look for clock gaters
+//   Note there's overlap between this process and V3Split's
+//	ALWAYS: Build graph
+// 	    IF: Form vertex pointing to any IFs or ALWAYS above
+//	    VARREF: Form vertex pointing to IFs it is under
+//	    ASSIGN: If under normal assignment, disable optimization
+//          FUTURE OPTIMIZE: If signal is set to itself, consider that OK for gating.
+// 	    !splitable: Mark all VARREFs in this statement as comming from it
+//	Optimize graph so if signal is referenced under multiple IF branches it moves up
+//	Make ALWAYS for each new gating term, and move statements there
+//*************************************************************************
+
+#include "config_build.h"
+#include "verilatedos.h"
+#include <cstdio>
+#include <cstdarg>
+#include <unistd.h>
+#include <map>
+#include <algorithm>
+#include <vector>
+
+#include "V3Global.h"
+#include "V3Ast.h"
+#include "V3Stats.h"
+#include "V3Graph.h"
+#include "V3ClkGater.h"
+
+//######################################################################
+// Base for debug
+
+class GaterBaseVisitor : public AstNVisitor {
+protected:
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+};
+
+//######################################################################
+// Support classes
+
+class GaterVarVertex;
+
+class GaterVertex : public V3GraphVertex {
+    static uint32_t s_rankNum;
+public:
+    GaterVertex(V3Graph* graphp)
+	: V3GraphVertex(graphp) {
+	s_rankNum++; rank(s_rankNum);
+    }
+    virtual ~GaterVertex() {}
+    virtual int typeNum() const = 0;
+    static void clearRank() { s_rankNum=0; }
+    virtual int sortCmp(const V3GraphVertex* rhsp) const;
+};
+uint32_t GaterVertex::s_rankNum = 0;
+
+class GaterHeadVertex : public GaterVertex {
+public:
+    GaterHeadVertex(V3Graph* graphp)
+	: GaterVertex(graphp) {}
+    virtual ~GaterHeadVertex() {}
+    virtual int typeNum() const { return __LINE__; }  // C++ typeof() equivelent
+    virtual string name() const { return "*HEAD*"; }
+    virtual string dotColor() const { return "green"; }
+};
+
+class GaterPliVertex : public GaterVertex {
+public:
+    GaterPliVertex(V3Graph* graphp)
+	: GaterVertex(graphp) {}
+    virtual ~GaterPliVertex() {}
+    virtual int typeNum() const { return __LINE__; }  // C++ typeof() equivelent
+    virtual string name() const { return "*PLI*"; }
+    virtual string dotColor() const { return "red"; }
+};
+
+class GaterIfVertex : public GaterVertex {
+    AstNodeIf*	m_nodep;
+public:
+    AstNodeIf* nodep() const { return m_nodep; }
+    GaterIfVertex(V3Graph* graphp, AstNodeIf* nodep)
+	: GaterVertex(graphp), m_nodep(nodep) { }
+    virtual ~GaterIfVertex() {}
+    virtual int typeNum() const { return __LINE__; }  // C++ typeof() equivelent
+    virtual string name() const { return cvtToStr((void*)m_nodep)+" {"+cvtToStr(m_nodep->fileline()->lineno())+"}"; }
+};
+
+class GaterVarVertex : public GaterVertex {
+    AstVarScope*	m_nodep;
+public:
+    AstVarScope* nodep() const { return m_nodep; }
+    GaterVarVertex(V3Graph* graphp, AstVarScope* nodep)
+	: GaterVertex(graphp), m_nodep(nodep) { }
+    virtual ~GaterVarVertex() {}
+    virtual int typeNum() const { return __LINE__; }  // C++ typeof() equivelent
+    virtual string name() const { return nodep()->name(); }
+    virtual string dotColor() const { return "skyblue"; }
+};
+
+//######################################################################
+// Edge types
+
+class GaterEdge : public V3GraphEdge {
+    uint32_t	m_ifelse;	// True branch of if
+public:
+    // These are used as shift amounts into node's user()
+#define VU_DEFINE  enum VarUsage { VU_NONE=0, VU_IF=1, VU_ELSE=2, VU_PLI=4, VU_MADE=8}
+    VU_DEFINE;
+
+    uint32_t ifelse() const { return m_ifelse; }
+    bool ifelseTrue()  const { return m_ifelse & VU_IF; }
+    bool ifelseFalse() const { return m_ifelse & VU_ELSE; }
+    bool ifelseBoth() const { return ifelseTrue() && ifelseFalse(); }
+    GaterEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top, uint32_t ifelse)
+	: V3GraphEdge(graphp, fromp, top, 10, false), m_ifelse(ifelse) {}
+    virtual ~GaterEdge() {}
+    virtual string dotColor() const { return ((ifelse() & VU_PLI) ? "red"
+					      : (ifelseBoth() ? "blue"
+						 : (ifelseTrue() ? "green"
+						    : "darkgreen"))); }
+    virtual int sortCmp(const V3GraphEdge* rEdgep) const {
+	// Our master sort sorts by edges first, so we don't want to
+	// consider the upstream vertex::sortCmp when sorting by edges.
+	// We do want to order by something though; rank works
+	if (fromp()->rank() < rEdgep->fromp()->rank()) return -1;
+	if (fromp()->rank() > rEdgep->fromp()->rank()) return 1;
+	// If same, resolve by ifelse
+	const GaterEdge* crEdgep = static_cast<const GaterEdge*>(rEdgep);
+	if (m_ifelse < crEdgep->m_ifelse) return -1;
+	if (m_ifelse > crEdgep->m_ifelse) return 1;
+	return 0;
+    }
+};
+
+int GaterVertex::sortCmp(const V3GraphVertex* rhsp) const {
+    const GaterVertex* crhsp = static_cast<const GaterVertex*>(rhsp);
+    // We really only care about ordering Var's together, but...
+    // First put same type together
+    if (typeNum() < crhsp->typeNum()) return -1;
+    if (typeNum() > crhsp->typeNum()) return 1;
+    // If variable, group by same input fanin
+    // (know they're the same type based on above compare)
+    if (dynamic_cast<const GaterVarVertex*>(this)) {
+	// We've already sorted by edges, so just see if same tree
+	// If this gets too slow, we could compute a hash up front
+	V3GraphEdge* lEdgep = this->inBeginp();
+	V3GraphEdge* rEdgep = rhsp->inBeginp();
+	while (lEdgep && rEdgep) {
+	    const GaterEdge* clEdgep = static_cast<const GaterEdge*>(lEdgep);
+	    const GaterEdge* crEdgep = static_cast<const GaterEdge*>(rEdgep);
+	    if (lEdgep->fromp()->rank() < rEdgep->fromp()->rank()) return -1;
+	    if (lEdgep->fromp()->rank() > rEdgep->fromp()->rank()) return 1;
+	    if (clEdgep->ifelse() < crEdgep->ifelse()) return -1;
+	    if (clEdgep->ifelse() > crEdgep->ifelse()) return 1;
+	    lEdgep = lEdgep->inNextp();
+	    rEdgep = rEdgep->inNextp();
+	}
+	if (!lEdgep && !rEdgep) return 0;
+	return lEdgep ? -1 : 1;
+    }
+    // Finally by rank of this vertex
+    if (rank() < rhsp->rank()) return -1;
+    if (rank() > rhsp->rank()) return 1;
+    return 0;
+}
+
+//######################################################################
+// Check for non-simple gating equations
+
+class GaterCondVisitor : public GaterBaseVisitor {
+private:
+    // RETURN STATE
+    bool		m_isSimple;	// Set false when we know it isn't simple
+    // METHODS
+    inline void okIterate(AstNode* nodep) {
+	if (m_isSimple) nodep->iterateChildren(*this);
+    }
+    // VISITORS
+    virtual void visit(AstOr* nodep, AstNUser*) {	okIterate(nodep); }
+    virtual void visit(AstAnd* nodep, AstNUser*) {	okIterate(nodep); }
+    virtual void visit(AstNot* nodep, AstNUser*) {	okIterate(nodep); }
+    virtual void visit(AstLogOr* nodep, AstNUser*) {	okIterate(nodep); }
+    virtual void visit(AstLogAnd* nodep, AstNUser*) {	okIterate(nodep); }
+    virtual void visit(AstLogNot* nodep, AstNUser*) {	okIterate(nodep); }
+    virtual void visit(AstVarRef* nodep, AstNUser*) {	okIterate(nodep); }
+
+    // Other possibilities are equals, etc
+    // But, we don't want to get too complicated or it will take too much
+    // effort to calculate the gater
+
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	m_isSimple = false;
+	//nodep->iterateChildren(*this);
+    }
+public:
+    // CONSTUCTORS
+    GaterCondVisitor(AstNode* nodep) {
+	m_isSimple = true;
+	nodep->accept(*this);
+    }
+    virtual ~GaterCondVisitor() {}
+    // PUBLIC METHODS
+    bool isSimple() const { return m_isSimple; }
+};
+
+//######################################################################
+// Check for non-simple gating equations
+
+class GaterBodyVisitor : public GaterBaseVisitor {
+    // NODE STATE
+    // Input state
+    //  AstVarScope::user2p()	-> AstAlways* moving this variable to
+
+    enum State {
+	// This is used as a bitmask
+	STATE_UNKNOWN=0,
+	STATE_KEEP=1,	// Seen a variable we need, keep this statement
+	STATE_DELETE=2	// Seen a variable we need, delete this statement
+	// 3=keep & delete
+    };
+
+    bool	m_original;	// Deleting original statements, vs deleting new var statements
+    AstNode*	m_exprp;	// New gater expression we are building
+    bool	m_cloning;	// Clone this object 0=not sure yet, 1=do
+    uint32_t	m_state;	// Parsing state
+
+    // VISITORS
+    virtual void visit(AstVarRef* nodep, AstNUser*) {
+	if (nodep->lvalue()) {
+	    AstVarScope* vscp = nodep->varScopep();
+	    if (vscp->user2p()->castNode() == m_exprp) {
+		// This variable's block needs to move to the new always
+		if (m_original) {
+		    UINFO(9,"  VARREF delete in old: "<<nodep<<endl);
+		    m_state |= STATE_DELETE;
+		} else {
+		    UINFO(9,"  VARREF stays in new:  "<<nodep<<endl);
+		    m_state |= STATE_KEEP;
+		}
+	    } else {
+		if (m_original) {
+		    UINFO(9,"  VARREF other stays in old\n");
+		    m_state |= STATE_KEEP;
+		} else {
+		    UINFO(9,"  VARREF other delete in new\n");
+		    m_state |= STATE_DELETE;
+		}
+	    }
+	}
+    }
+
+    //virtual void visit(AstNodeIf* nodep, AstNUser*) { ... }
+    // Not needed, it's the same handling as any other statement.  Cool, huh?
+    // (We may get empty IFs but the constant propagater will rip them up for us)
+
+    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+	uint32_t oldstate = m_state;
+	// Find if children want to delete this or not.
+	// Note children may bicker, and want to both keep and delete (branches on a if)
+	uint32_t childstate;
+	{
+	    m_state = STATE_UNKNOWN;
+	    nodep->iterateChildren(*this);
+	    childstate = m_state;
+	}
+	m_state = oldstate;
+	UINFO(9,"    Did state="<<childstate<<"  "<<nodep<<endl);
+
+	// Indeterminate (statement with no lvalue), so keep only in original
+	if (childstate == STATE_UNKNOWN) {
+	    if (m_original) childstate |= STATE_KEEP;
+	    else childstate |= STATE_DELETE;
+	}
+
+	if ((childstate & STATE_DELETE) && !(childstate & STATE_KEEP)) {
+	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    // Pass upwards we did delete
+	    m_state |= STATE_DELETE;
+	} else {
+	    // Pass upwards we must keep
+	    m_state |= STATE_KEEP;
+	}
+    }
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+    }
+public:
+    // CONSTUCTORS
+    GaterBodyVisitor(AstAlways* nodep, AstNode* exprp, bool original) {
+	m_exprp = exprp;
+	m_original = original;
+	m_state = STATE_UNKNOWN;
+	if (debug()>=9) nodep->dumpTree(cout,"  GateBodyIn:  ");
+	nodep->bodysp()->iterateAndNext(*this);
+	if (debug()>=9) nodep->dumpTree(cout,"  GateBodyOut: ");
+	// If there's no statements we shouldn't have had a resulting graph
+	// vertex asking for this creation
+    }
+    virtual ~GaterBodyVisitor() {}
+};
+
+//######################################################################
+// Create clock gaters
+
+class GaterVisitor : public GaterBaseVisitor {
+    // NODE STATE
+    // Cleared on Always
+    //  AstVarScope::user1p()	-> GaterVarVertex*
+    //  AstAlways::user4()	-> bool.  True indicates processed
+    // Cleared on each new Always
+    //  AstVarScope::user2p()	-> AstAlways* moving this variable to
+    AstUser1InUse	m_inuser1;
+    AstUser2InUse	m_inuser2;
+    AstUser4InUse	m_inuser4;
+
+    // GRAPH STATE
+    // Cleared on simplify
+    //  Vertex::user()		-> VarUsage: Mark of which if/else edges are hit
+
+    // TYPES
+    VU_DEFINE;
+
+    enum MiscConsts {
+	IF_DEPTH_MAX = 4,	// IFs deep we bother to analyze
+	DOMAINS_MAX = 32	// Clock domains before avoiding O(N^2) blowup
+    };
+
+    // MEMBERS
+    string	m_nonopt;		// Reason block is not optimizable
+    V3Double0	m_statGaters;		// Statistic tracking
+    V3Double0	m_statBits;		// Statistic tracking
+    bool	m_directlyUnderAlw;	// Immediately under Always or If
+    int		m_ifDepth;		// Depth of IF statements
+    int		m_numIfs;		// Number of IF statements
+    V3Graph	m_graph;		// Scoreboard of var usages/dependencies
+    GaterPliVertex*	m_pliVertexp;	// Element specifying PLI ordering
+    GaterHeadVertex*	m_headVertexp;	// Top vertex
+    V3GraphVertex*	m_aboveVertexp;	// Vertex above this point in tree
+    uint32_t		m_aboveTrue;	// Vertex above this point is true branch
+    AstVarScope*	m_stmtVscp;	// Current statement had variable assigned
+    bool		m_stmtInPli;	// Current statement has PLI
+
+    // METHODS
+    void nonOptimizable(AstNode* nodep, const char* reasonp) {
+	if (m_nonopt=="") {
+	    UINFO(9,"    Nonopt: "<<reasonp<<": "<<nodep<<endl);
+	    m_nonopt = reasonp;
+	}
+    }
+    void scoreboardPli(AstNode* nodep) {
+	// Order all PLI statements with other PLI statements
+	// This insures $display's and such remain in proper order
+	// We don't prevent splitting out other non-pli statements, however,
+	// because it is common to have $uasserts sprinkled about.
+	if (!m_pliVertexp) {
+	    m_pliVertexp = new GaterPliVertex(&m_graph);
+	}
+	if (m_stmtVscp) {  // Already saw a variable, be sure to mark it!
+	    GaterVarVertex* varVtxp = (GaterVarVertex*)(m_stmtVscp->user1p());
+	    new GaterEdge(&m_graph, m_pliVertexp, varVtxp, VU_PLI);
+	}
+	m_stmtInPli = true;  // Mark all followon variables too
+    }
+
+    // METHODS -- GRAPH stuff
+    void simplifyGraph() {
+	if (debug()>=9) m_graph.dumpDotFilePrefixed("gater_init", false);
+
+	// We now have all PLI variables with edges FROM the pli vertex
+	simplifyPli();
+	if (debug()>=9) m_graph.dumpDotFilePrefixed("gater_pli", false);
+
+	// Any vertex that points along both true & false path to variable
+	// can be simplfied so parent points to that vertex.  Any vertex
+	// that points to a (great...) grandparent of a variable can just
+	// point to the edge.
+	m_graph.userClearVertices();	// user() will contain VarUsage
+	simplifyIfElseRecurse(m_headVertexp);
+	if (debug()>=9) m_graph.dumpDotFilePrefixed("gater_ifelse", false);
+
+	m_graph.userClearVertices();	// user() will contain VarUsage
+	simplifyGrandRecurse(m_headVertexp, 1);
+	if (debug()>=9) m_graph.dumpDotFilePrefixed("gater_grand", false);
+
+	simplifyRemoveUngated(m_headVertexp);
+
+	// Give all signals with same gating term same color
+	graphColorSameFeeder();
+
+	if (debug()>=9) m_graph.dumpDotFilePrefixed("gater_done", false);
+    }
+
+    void simplifyPli() {
+	// For now, we'll not gate any logic with PLI lvariables in it.  In
+	// the future we may move PLI statements.  One way to do so is to
+	// all below pli VARs to go IfVertex -> PliVertex -> VarVertex then
+	// they all must get colored the same. There may be a lot of
+	// duplicated edges to the PLI; they'll need cleanup.  All of the
+	// later optimizations need to deal, and the GaterBodyVisitor needs
+	// to know how to move them.
+	if (m_pliVertexp) {
+	    // Follow PLI out edges to find all relevant variables
+	    for (V3GraphEdge* nextp,* edgep = m_pliVertexp->outBeginp(); edgep; edgep = nextp) {
+		nextp = edgep->outNextp();  // We may edit the list
+		if (GaterVarVertex* vVxp = dynamic_cast<GaterVarVertex*>(edgep->top())) {
+		    vVxp->unlinkDelete(&m_graph); vVxp=NULL; edgep=NULL;
+		} else {
+		    m_graph.dump();
+		    v3fatalSrc("PLI vertex points to non-signal");
+		}
+	    }
+	    m_pliVertexp->unlinkDelete(&m_graph); m_pliVertexp = NULL;
+	}
+    }
+
+    void simplifyIfElseRecurse(V3GraphVertex* vertexp) {
+	// From bottom-up, propagate duplicate IF/ELSE branches to grandparent
+	for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep=edgep->outNextp()) {
+	    simplifyIfElseRecurse(edgep->top());
+	}
+	//UINFO(9,"IERecurse "<<vertexp<<endl);
+	if (dynamic_cast<GaterIfVertex*>(vertexp)) {
+	    // Clear indications
+	    for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep=edgep->outNextp()) {
+		edgep->top()->user(VU_NONE);
+	    }
+	    // Mark nodes on to/from side
+	    for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep=edgep->outNextp()) {
+		V3GraphVertex* toVxp = edgep->top();
+		GaterEdge* cedgep = static_cast<GaterEdge*>(edgep);
+		// We may mark this twice in one pass - if so it's duplicated; no worries
+		if (cedgep->ifelseTrue()) toVxp->user(toVxp->user() | VU_IF);
+		if (cedgep->ifelseFalse()) toVxp->user(toVxp->user() | VU_ELSE);
+		//UINFO(9,"  mark "<<edgep<<" "<<toVxp<<endl);
+	    }
+	    // Any with both IF & ELSE mark get removal mark, and new parent edge
+	    for (V3GraphEdge* nextp,* edgep = vertexp->outBeginp(); edgep; edgep = nextp) {
+		nextp = edgep->outNextp();  // We may edit the list
+		V3GraphVertex* toVxp = edgep->top();
+		//UINFO(9," to "<<toVxp->user()<<" "<<toVxp<<endl);
+		if ((toVxp->user() & VU_IF) && (toVxp->user() & VU_ELSE)) {
+		    edgep->unlinkDelete(); edgep = NULL;
+		    if (!(toVxp->user() & VU_MADE)) {   // Make an edge only once
+			toVxp->user(toVxp->user() | VU_MADE);
+			GaterEdge* inedgep = static_cast<GaterEdge*>(vertexp->inBeginp());
+			V3GraphVertex* grandparent = inedgep->fromp();
+			new GaterEdge(&m_graph, grandparent, toVxp, inedgep->ifelse());
+		    }
+		}
+	    }
+	}
+    }
+
+    void simplifyGrandRecurse(V3GraphVertex* vertexp, uint32_t depth) {
+	// From top-down delete any vars that grandparents source
+	// IE    A -> B -> C -> VAR
+	//         \----------^
+	//UINFO(9,"GRecurse "<<depth<<" "<<vertexp<<endl);
+	// Mark all variables to be swept
+	for (V3GraphEdge *nextp, *edgep = vertexp->outBeginp(); edgep; edgep=nextp) {
+	    nextp = edgep->outNextp();  // We may edit the list
+	    if (GaterVarVertex* toVxp = dynamic_cast<GaterVarVertex*>(edgep->top())) {
+		if (toVxp->user() && toVxp->user() < depth) {
+		    // A recursion "above" us marked it,
+		    // Remove this edge, it's redundant with the upper edge
+		    edgep->unlinkDelete(); edgep=NULL;
+		} else {
+		    GaterEdge* cedgep = static_cast<GaterEdge*>(edgep);
+		    if (cedgep->ifelseBoth()) {
+			toVxp->user(depth);
+		    }
+		}
+	    }
+	}
+	// Recurse
+	for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep=edgep->outNextp()) {
+	    simplifyGrandRecurse(edgep->top(), depth+1);
+	}
+	// Clean our marks
+	for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep=edgep->outNextp()) {
+	    V3GraphVertex* toVxp = edgep->top();
+	    if (toVxp->user() && toVxp->user() < depth) {  // A recursion "above" us marked it; don't mess with it
+	    } else {
+		toVxp->user(0);  // We marked it originally, so unmark now
+	    }
+	}
+	// Delete any If nodes with no children
+	// Last, as want bottom-up cleanup
+	for (V3GraphEdge *nextp, *edgep = vertexp->outBeginp(); edgep; edgep=nextp) {
+	    nextp = edgep->outNextp();  // We may edit the list
+	    if (GaterIfVertex* toVxp = dynamic_cast<GaterIfVertex*>(edgep->top())) {
+		if (!toVxp->outBeginp()) {
+		    if (!nextp || nextp->top() != edgep->top()) {  // Else next would disappear; we'll do it next loop
+			toVxp->unlinkDelete(&m_graph); toVxp=NULL; edgep=NULL;
+		    }
+		}
+	    }
+	}
+    }
+
+    void simplifyRemoveUngated(V3GraphVertex* vertexp) {
+	// Remove variables that are ungated
+	// At this point, any variable under the head is ungated
+	for (V3GraphEdge *nextp, *edgep = vertexp->outBeginp(); edgep; edgep=nextp) {
+	    nextp = edgep->outNextp();  // We may edit the list
+	    if (GaterVarVertex* toVxp = dynamic_cast<GaterVarVertex*>(edgep->top())) {
+		if (!nextp || nextp->top() != edgep->top()) {  // Else next would disappear; we'll do it next loop
+		    toVxp->unlinkDelete(&m_graph); toVxp=NULL; edgep=NULL;
+		}
+	    }
+	}
+    }
+
+    void graphColorSameFeeder() {
+	// Assign same color to all destination vertices that have same
+	// subgraph feeding into them
+	// (I.E. all "from" nodes are common within each color)
+	// We could hash, but instead it's faster to sort edges, so we know
+	// the same edge list is always adjacent.  The result is a
+	// O(vertices*edges) loop, but we'd need that to hash too.
+	if (debug()>9) { cout<<"PreColor:\n"; m_graph.dump(); }
+
+	m_graph.sortEdges();
+
+	// Now sort vertices, so same inbound edge set ends up adjacent
+	m_graph.sortVertices();
+
+	// Now walk and assign colors; same color is adjacent
+	m_graph.clearColors();
+	m_graph.userClearEdges(); // Used by newExprFromGraph
+	uint32_t color = 1;
+	GaterVarVertex* lastVxp	= NULL;
+	for (V3GraphVertex* vertexp = m_graph.verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
+	    if (GaterVarVertex* vVxp = dynamic_cast<GaterVarVertex*>(vertexp)) {
+		if (!vVxp->inBeginp()) {
+		    // At this point, any variable not linked is an error
+		    // (It should have at least landed under the Head node)
+		    vVxp->nodep()->v3fatalSrc("Variable became stranded in clk gate detection\n");
+		}
+		if (!lastVxp || vVxp->sortCmp(lastVxp)) {
+		    // Different sources for this new node
+		    color++;
+		}
+		vVxp->color(color);
+		lastVxp = vVxp;
+	    }
+	}
+
+	if (debug()>9) { cout<<"PostColor:\n"; m_graph.dump(); }
+    }
+
+    AstNode* newExprFromGraph(GaterVarVertex* vertexp) {
+	// Recurse backwards, then form equation on return path
+	// We could use user()!=0, but zeroing it is slow, so instead we'll mark with a generation
+	// We get equations like "a | (!a & b)" which obviously could be reduced here,
+	// instead out of generality, there's a V3Const::matchOrAndNot that'll clean it up
+	static uint32_t s_generation = 0;
+	++s_generation;
+	nafgMarkRecurse(vertexp, s_generation);
+	AstNode* nodep = nafgCreateRecurse(m_headVertexp, s_generation);
+	if (debug()>=9) nodep->dumpTree(cout,"  GateExpr: ");
+	return nodep;
+    }
+    void nafgMarkRecurse(V3GraphVertex* vertexp, uint32_t generation) {
+	// Backwards mark user() on the path we recurse
+	//UINFO(9," nafgMark: v "<<(void*)(vertexp)<<" "<<vertexp->name()<<endl);
+	for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
+	    //UINFO(9," nafgMark: "<<(void*)(edgep)<<" "<<edgep->name()<<endl);
+	    edgep->user(generation);
+	    nafgMarkRecurse(edgep->fromp(), generation);
+	}
+    }
+    AstNode* nafgCreateRecurse(V3GraphVertex* vertexp, uint32_t generation) {
+	// Forewards follow user() marked previously and build tree
+	AstNode* nodep = NULL;
+	// OR across all edges found at this level
+	//UINFO(9," nafgEnter: v "<<(void*)(vertexp)<<" "<<vertexp->name()<<endl);
+	for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
+	    if (edgep->user() == generation) {
+		GaterEdge* cedgep = static_cast<GaterEdge*>(edgep);
+		AstNode* eqnp = NULL;
+		//UINFO(9," nafgFollow: "<<(void*)(edgep)<<" "<<edgep->name()<<endl);
+		if (dynamic_cast<GaterHeadVertex*>(edgep->fromp())) {
+		    // Just OR in all lower terms
+		    eqnp = nafgCreateRecurse(edgep->top(), generation);
+		} else if (GaterIfVertex* cVxp = dynamic_cast<GaterIfVertex*>(edgep->fromp())) {
+		    // Edges from IFs represent a real IF branch in the equation tree
+		    //UINFO(9,"  ifver "<<(void*)(edgep)<<" cc"<<edgep->dotColor()<<endl);
+		    eqnp = cVxp->nodep()->condp()->cloneTree(true);
+		    if (eqnp && cedgep->ifelseFalse()) {
+			eqnp = new AstNot(eqnp->fileline(),eqnp);
+		    }
+		    // We need to AND this term onto whatever was found below it
+		    AstNode* belowp = nafgCreateRecurse(edgep->top(), generation);
+		    if (belowp) eqnp = new AstAnd(eqnp->fileline(),eqnp,belowp);
+		}
+		// Top level we could choose to make multiple gaters, or ORs under the gater
+		// Right now we'll put OR lower down and let other optimizations deal
+		if (nodep) nodep = new AstOr(eqnp->fileline(),nodep,eqnp);
+		else nodep = eqnp;
+		//if (debug()>=9) nodep->dumpTree(cout,"      followExpr: ");
+	    }
+	}
+	//UINFO(9," nafgExit:  "<<(void*)(vertexp)<<" "<<vertexp->name()<<endl);
+	return nodep;
+    }
+
+    void newAlwaysTrees(AstAlways* nodep) {
+	// Across all variables we're moving
+	uint32_t lastColor = 0;
+	AstNode* lastExprp = NULL;
+	for (V3GraphVertex* vertexp = m_graph.verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
+	    if (GaterVarVertex* vVxp = dynamic_cast<GaterVarVertex*>(vertexp)) {
+		if (!lastExprp || lastColor != vVxp->color()) {
+		    lastColor = vVxp->color();
+		    // Create the block we've just finished
+		    if (lastExprp) newAlwaysTree(nodep, lastExprp); // Duplicate below
+		    // New expression for this color
+		    lastExprp = newExprFromGraph(vVxp);
+		}
+		// Mark variable to move
+		if (vVxp->nodep()->user2p()) vVxp->nodep()->v3fatalSrc("One variable got marked under two gaters");
+		vVxp->nodep()->user2p(lastExprp);
+		m_statBits += vVxp->nodep()->width();  // Moving a wide bus counts more!
+		// There shouldn't be two possibilities we want to
+		// move to, IE {A,B} <= Z because we marked such
+		// things as unoptimizable
+	    }
+	}
+	// Create the final block we've just finished
+	if (lastExprp) newAlwaysTree(nodep, lastExprp);   // Duplicate above
+    }
+
+    void newAlwaysTree(AstAlways* nodep, AstNode* exprp) {
+	// Create new always with specified gating expression
+	// Relevant vars are already marked with user2p
+
+	// Should we put the gater under the always itself,
+	// or make a new signal?
+	//   New signal: May cause replicated logic until we can combine
+	//		Need way to toggle signal on complicated pos/negedge
+	//   Under Always: More complicated, may not propagate logic with gateer
+	//	Untill we get better gate optimization, we'll go this route.
+//#define GATER_NOP
+#ifdef GATER_NOP
+	// For testing only, don't clock gate but still make new always
+	AstSenTree* sensesp = nodep->sensesp()->cloneTree(true);
+#else
+	// Make a SenGate
+	AstSenItem* oldsenitemsp = nodep->sensesp()->sensesp()->castSenItem();
+	if (!oldsenitemsp) nodep->v3fatalSrc("SenTree doesn't have any SenItem under it");
+
+	AstSenTree* sensesp = new AstSenTree(nodep->fileline(),
+					     new AstSenGate(nodep->fileline(),
+							    oldsenitemsp->cloneTree(true),
+							    exprp));
+#endif
+
+	// Make new body; note clone will preserve user2p() indicating moving vars
+	AstNode* bodyp = nodep->bodysp()->cloneTree(true);
+
+	AstAlways* alwp = new AstAlways(nodep->fileline(),
+					sensesp,
+					bodyp);
+
+	alwp->user4(1);  // No need to process the new always again!
+	nodep->addNextHere(alwp);
+
+	// Blow moved statements from old body
+	GaterBodyVisitor(nodep,exprp,true);
+	// Blow old statements from new body
+	GaterBodyVisitor(alwp,exprp,false);
+
+	m_statGaters++;
+	if (debug()>=9) alwp->dumpTree(cout,"  new: ");
+    }
+
+    // VISITORS
+    virtual void visit(AstAlways* nodep, AstNUser*) {
+	if (debug()>=9) cout<<endl<<endl<<endl;
+	UINFO(5, "Gater: ALWAYS: "<<nodep<<endl);
+	if (nodep->user4()) return;
+	nodep->user4(1);
+
+	clear();
+
+	if (debug()>=9) nodep->dumpTree(cout,"  Alwin:  ");
+
+	// Look for constructs we can't optimize
+	// Form graph with Vertices at each IF, and each Variable
+	m_aboveTrue = VU_IF | VU_ELSE;
+	iterateChildrenAlw(nodep, true);
+
+	// Other reasons to not optimize
+	if (!m_numIfs) nonOptimizable(nodep, "No if statements");
+
+	// Something to optimize, oh my!
+	if (m_nonopt!="") {
+	    UINFO(5, "  Gater non-opt: "<<m_nonopt<<endl);
+	} else {
+	    // Process it
+	    simplifyGraph();
+
+	    // See how much moves
+	    uint32_t lastColor = 0;
+	    for (V3GraphVertex* vertexp = m_graph.verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
+		if (GaterVarVertex* vVxp = dynamic_cast<GaterVarVertex*>(vertexp)) {
+		    if (lastColor < vVxp->color()) {
+			lastColor = vVxp->color();
+		    }
+		}
+	    }
+	    if (lastColor == 0) { // Nothing we moved!
+		nonOptimizable(nodep, "Nothing moved");
+	    }
+	    else if (lastColor > DOMAINS_MAX) {
+		// Our move algorithm is fairly slow and if we're splitting
+		// up too much it'll get really nasty.  It's probably a bad
+		// move for performance to split too much, anyhow, as the
+		// number of gaters will result in calling many small c functions.
+		nonOptimizable(nodep, "Too much moved");
+	    }
+	    if (m_nonopt=="") {
+		newAlwaysTrees(nodep);
+		if (debug()>=9) nodep->dumpTree(cout,"  Gaterout: ");
+	    }
+	}
+	UINFO(5, "  Gater done"<<endl);
+    }
+    virtual void visit(AstVarRef* nodep, AstNUser*) {
+	if (nodep->lvalue()) {
+	    AstVarScope* vscp = nodep->varScopep();
+	    if (nodep->varp()->isSigPublic()) {
+		// Public signals shouldn't be changed, pli code might be messing with them
+		scoreboardPli(nodep);
+	    }
+	    // If another lvalue in this node, give up optimizing.
+	    // We could just not optimize this variable, but we've already marked the
+	    // other variable as optimizable, so we can instead pretend it's a PLI node.
+	    if (m_stmtVscp) {
+		UINFO(5, "   Multiple lvalues in one statement: "<<nodep<<endl);
+		scoreboardPli(nodep);  // This will set m_stmtInPli
+	    }
+	    m_stmtVscp = vscp;
+	    // Find, or make new Vertex
+	    GaterVarVertex* vertexp = (GaterVarVertex*)(vscp->user1p());
+	    if (!vertexp) {
+		vertexp = new GaterVarVertex(&m_graph, vscp);
+		vscp->user1p(vertexp);
+	    }
+	    new GaterEdge(&m_graph, m_aboveVertexp, vertexp, m_aboveTrue);
+	    if (m_stmtInPli) {
+		new GaterEdge(&m_graph, m_pliVertexp, vertexp, VU_PLI);
+	    }
+	}
+    }
+    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+	m_ifDepth++;
+	bool allowGater = m_directlyUnderAlw && m_ifDepth <= IF_DEPTH_MAX;
+	if (allowGater) {
+	    GaterCondVisitor condVisitor(nodep->condp());
+	    if (!condVisitor.isSimple()) {
+		// Don't clear optimization, simply drop this IF as part of the gating
+		UINFO(5,"   IFnon-simple-condition: "<<nodep<<endl);
+		allowGater = false;
+	    }
+	}
+	if (!allowGater) {
+	    // IF burried under something complicated
+	    iterateChildrenAlw(nodep, true);
+	} else {
+	    UINFO(5, "  IF: "<<nodep<<endl);
+	    m_numIfs++;
+	    // Recurse to next level of if.
+	    V3GraphVertex*	lastabovep = m_aboveVertexp;
+	    uint32_t		lasttrue = m_aboveTrue;
+	    GaterIfVertex* vertexp = new GaterIfVertex(&m_graph, nodep);
+	    new GaterEdge(&m_graph, m_aboveVertexp, vertexp, m_aboveTrue);
+	    {
+		nodep->condp()->iterateAndNext(*this);  // directlyUnder stays as-is
+	    }
+	    {
+		m_aboveVertexp = vertexp;  // Vars will point at this edge
+		m_aboveTrue = VU_IF;
+		nodep->ifsp()->iterateAndNext(*this);  // directlyUnder stays as-is (true)
+	    }
+	    {
+		m_aboveVertexp = vertexp;  // Vars will point at this edge
+		m_aboveTrue = VU_ELSE;
+		nodep->elsesp()->iterateAndNext(*this);  // directlyUnder stays as-is (true)
+	    }
+	    m_aboveVertexp = lastabovep;
+	    m_aboveTrue = lasttrue;
+	}
+	m_ifDepth--;
+    }
+
+    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+	// iterateChildrenAlw will detect this is a statement for us
+	iterateChildrenAlw(nodep, false);
+    }
+
+    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+	// Note NOT AssignDly; handled above, We'll just mark this block as
+	// not optimizable.
+	//
+	// A future alternative is to look for any lvalues that are also
+	// variables in the sensitivity list, or rvalues in this block.  If
+	// any hit, disable optimization.  Unlikely to be useful (For loops
+	// being an exception, but they're already unrolled.)
+	nonOptimizable(nodep, "Non-delayed assignment");
+	// No reason to iterate.
+    }
+
+    virtual void visit(AstSenItem* nodep, AstNUser*) {
+	if (!nodep->isClocked()) {
+	    nonOptimizable(nodep, "Non-clocked sensitivity");
+	}
+	iterateChildrenAlw(nodep, false);
+    }
+
+    //--------------------
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	if (m_nonopt=="") {  // Else accelerate
+	    iterateChildrenAlw(nodep, false);
+	}
+    }
+    inline void iterateChildrenAlw(AstNode* nodep, bool under) {
+	// **** USE THIS INSTEAD OF iterateChildren!
+	// Note If visitor doesn't call here; does it its own way
+	bool lastdua = m_directlyUnderAlw;
+	AstVarScope* lastvscp = m_stmtVscp;
+	bool lastpli = m_stmtInPli;
+	m_directlyUnderAlw = under;
+	if (nodep->castNodeStmt()) {  // Restored below
+	    UINFO(9,"       Stmt: "<<nodep<<endl);
+	    m_stmtVscp = NULL;
+	    m_stmtInPli = false;
+	}
+	if (!nodep->isSplittable()) {
+	    // May also be a new statement (above if); if so we mark it immediately
+	    UINFO(9,"         NotSplittable "<<nodep<<endl);
+	    scoreboardPli(nodep);
+	}
+	{
+	    nodep->iterateChildren(*this);
+	}
+	m_directlyUnderAlw = lastdua;
+	if (nodep->castNodeStmt()) {  // Reset what set above; else propagate up to above statement
+	    m_stmtVscp = lastvscp;
+	    m_stmtInPli = lastpli;
+	}
+    }
+
+public:
+    // CONSTUCTORS
+    GaterVisitor(AstNode* nodep) {
+	// AstAlways visitor does the real work, so most zeroing needs to be in clear()
+	clear();
+	nodep->accept(*this);
+    }
+    void clear() {
+	m_nonopt = "";
+	m_directlyUnderAlw = false;
+	m_ifDepth = 0;
+	m_numIfs = 0;
+	AstNode::user1ClearTree();
+	AstNode::user2ClearTree();
+	// Prepare graph
+	m_graph.clear();
+	GaterVertex::clearRank();
+	m_pliVertexp = NULL;
+	m_headVertexp = new GaterHeadVertex(&m_graph);
+	m_aboveVertexp = m_headVertexp;
+	m_aboveTrue = false;
+	m_stmtVscp = NULL;
+	m_stmtInPli = false;
+    }
+    virtual ~GaterVisitor() {
+	V3Stats::addStat("Optimizations, Gaters inserted", m_statGaters);
+	V3Stats::addStat("Optimizations, Gaters impacted bits", m_statBits);
+    }
+};
+
+//######################################################################
+// Active class functions
+
+void V3ClkGater::clkGaterAll(AstNetlist* nodep) {
+    UINFO(2,__FUNCTION__<<": "<<endl);
+    // While the gater does well at some modules, it seems to slow down many others
+    UINFO(5,"ClkGater is disabled due to performance issues\n");
+    //GaterVisitor visitor (nodep);
+}

src/V3ClkGater.h

@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: Break always into clock gated blocks
+//
+// Code available from: http://www.veripool.org/verilator
+//
+// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
+//
+//*************************************************************************
+//
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
+// redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+//
+// Verilator is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+//*************************************************************************
+
+#ifndef _V3CLKGATER_H_
+#define _V3CLKGATER_H_ 1
+#include "config_build.h"
+#include "verilatedos.h"
+#include "V3Error.h"
+#include "V3Ast.h"
+
+//============================================================================
+
+class V3ClkGater {
+public:
+    static void clkGaterAll(AstNetlist* nodep);
+};
+
+#endif // Guard

src/V3Clock.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Clocking POS/NEGEDGE insertion
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Clock's Transformations:
-//		
+//
 // Top Scope:
 //   Check created ACTIVEs
 //      Compress adjacent ACTIVEs with same sensitivity list
@@ -34,8 +34,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 
@@ -51,8 +51,10 @@ class ClockVisitor : public AstNVisitor {
 private:
     // NODE STATE
     // Cleared each Module:
-    //  AstVarScope::userp()	-> AstVarScope*.  Temporary signal that was created.
+    //  AstVarScope::user1p()	-> AstVarScope*.  Temporary signal that was created.
     //  AstVarScope::user2p()	-> AstVarScope*.  Temporary signal for change detects
+    AstUser1InUse	m_inuser1;
+    AstUser2InUse	m_inuser2;
 
     // TYPES
     enum {  DOUBLE_OR_RATE = 10 };	// How many | per ||, Determined experimentally as best
@@ -70,20 +72,25 @@ private:
     AstSenTree*		m_lastSenp;	// Last sensitivity match, so we can detect duplicates.
     AstIf*		m_lastIfp;	// Last sensitivity if active to add more under
     int			m_stableNum;	// Number of each untilstable
-    //int debug() { return 9; }
 
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     AstVarScope* getCreateLastClk(AstVarScope* vscp) {
-	if (vscp->userp()) return ((AstVarScope*)vscp->userp());
+	if (vscp->user1p()) return ((AstVarScope*)vscp->user1p());
 	AstVar* varp = vscp->varp();
 	if (varp->width()!=1) varp->v3error("Unsupported: Clock edge on non-single bit signal: "<<varp->prettyName());
 	string newvarname = ((string)"__Vclklast__"+vscp->scopep()->nameDotless()+"__"+varp->shortName());
 	AstVar* newvarp
-	    = new AstVar (vscp->fileline(), AstVarType::MODULETEMP, newvarname); // No range; 1 bit.
+	    = new AstVar (vscp->fileline(), AstVarType::MODULETEMP, newvarname, NULL, NULL); // No range; 1 bit.
 	newvarp->width(1,1);
 	m_modp->addStmtp(newvarp);
 	AstVarScope* newvscp = new AstVarScope(vscp->fileline(), m_scopep, newvarp);
-	vscp->userp(newvscp);
+	vscp->user1p(newvscp);
 	m_scopep->addVarp(newvscp);
 	// At bottom, assign them
 	AstAssign* finalp
@@ -107,48 +114,66 @@ private:
 	m_scopep->addVarp(newvscp);
 	return newvscp;
     }
-    AstNode* createSenseEquation(AstSenTree* nodep) {
+    AstNode* createSenItemEquation(AstSenItem* nodep) {
+	// We know the var is clean, and one bit, so we use binary ops
+	// for speed instead of logical ops.
+	// POSEDGE:  var & ~var_last
+	// NEGEDGE:  ~var & var_last
+	// BOTHEDGE:  var ^ var_last
+	// HIGHEDGE:  var
+	// LOWEDGE:  ~var
+	AstNode* newp = NULL;
+	AstVarScope* clkvscp = nodep->varrefp()->varScopep();
+	if (nodep->edgeType()==AstEdgeType::POSEDGE) {
+	    AstVarScope* lastVscp = getCreateLastClk(clkvscp);
+	    newp = new AstAnd(nodep->fileline(),
+			      new AstVarRef(nodep->fileline(),
+					    nodep->varrefp()->varScopep(), false),
+			      new AstNot(nodep->fileline(),
+					 new AstVarRef(nodep->fileline(),
+						       lastVscp, false)));
+	} else if (nodep->edgeType()==AstEdgeType::NEGEDGE) {
+	    AstVarScope* lastVscp = getCreateLastClk(clkvscp);
+	    newp = new AstAnd(nodep->fileline(),
+			      new AstNot(nodep->fileline(),
+					 new AstVarRef(nodep->fileline(),
+						       nodep->varrefp()->varScopep(), false)),
+			      new AstVarRef(nodep->fileline(), lastVscp, false));
+	} else if (nodep->edgeType()==AstEdgeType::BOTHEDGE) {
+	    AstVarScope* lastVscp = getCreateLastClk(clkvscp);
+	    newp = new AstXor(nodep->fileline(),
+			      new AstVarRef(nodep->fileline(),
+					    nodep->varrefp()->varScopep(), false),
+			      new AstVarRef(nodep->fileline(), lastVscp, false));
+	} else if (nodep->edgeType()==AstEdgeType::HIGHEDGE) {
+	    newp = new AstVarRef(nodep->fileline(),
+				 clkvscp, false);
+	} else if (nodep->edgeType()==AstEdgeType::LOWEDGE) {
+	    newp = new AstNot(nodep->fileline(),
+			      new AstVarRef(nodep->fileline(),
+					    clkvscp, false));
+	} else {
+	    nodep->v3fatalSrc("Bad edge type");
+	}
+	return newp;
+    }
+    AstNode* createSenGateEquation(AstSenGate* nodep) {
+	AstNode* newp = new AstAnd(nodep->fileline(),
+				   createSenseEquation(nodep->sensesp()),
+				   nodep->rhsp()->cloneTree(true));
+	return newp;
+    }
+    AstNode* createSenseEquation(AstNodeSenItem* nodesp) {
+	// Nodep may be a list of elements; we need to walk it
 	AstNode* senEqnp = NULL;
-	for (AstSenItem* senp = nodep->sensesp(); senp; senp=senp->nextp()->castSenItem()) {
-	    // We know the var is clean, and one bit, so we use binary ops
-	    // for speed instead of logical ops.
-	    // POSEDGE:  var & ~var_last
-	    // NEGEDGE:  ~var & var_last
-	    // BOTHEDGE:  var ^ var_last
-	    // HIGHEDGE:  var
-	    // LOWEDGE:  ~var
-	    AstVarScope* lastVscp = senp->varrefp()->varScopep()->userp()->castNode()->castVarScope();
+	for (AstNodeSenItem* senp = nodesp; senp; senp=senp->nextp()->castNodeSenItem()) {
 	    AstNode* senOnep = NULL;
-	    if (senp->edgeType()==AstEdgeType::POSEDGE) {
-		if (!lastVscp) senp->v3fatalSrc("No last var ptr?\n");
-		senOnep = new AstAnd(senp->fileline(),
-				     new AstVarRef(senp->fileline(),
-						   senp->varrefp()->varScopep(), false),
-				     new AstNot(senp->fileline(),
-						new AstVarRef(senp->fileline(),
-							      lastVscp, false)));
-	    } else if (senp->edgeType()==AstEdgeType::NEGEDGE) {
-		if (!lastVscp) senp->v3fatalSrc("No last var ptr?\n");
-		senOnep = new AstAnd(senp->fileline(),
-				     new AstNot(senp->fileline(),
-						new AstVarRef(senp->fileline(),
-							      senp->varrefp()->varScopep(), false)),
-				     new AstVarRef(senp->fileline(), lastVscp, false));
-	    } else if (senp->edgeType()==AstEdgeType::BOTHEDGE) {
-		if (!lastVscp) senp->v3fatalSrc("No last var ptr?\n");
-		senOnep = new AstXor(senp->fileline(),
-				     new AstVarRef(senp->fileline(),
-						   senp->varrefp()->varScopep(), false),
-				     new AstVarRef(senp->fileline(), lastVscp, false));
-	    } else if (senp->edgeType()==AstEdgeType::HIGHEDGE) {
-		senOnep = new AstVarRef(senp->fileline(),
-					senp->varrefp()->varScopep(), false);
-	    } else if (senp->edgeType()==AstEdgeType::LOWEDGE) {
-		senOnep = new AstNot(senp->fileline(),
-				     new AstVarRef(senp->fileline(),
-						   senp->varrefp()->varScopep(), false));
+	    if (AstSenItem* itemp = senp->castSenItem()) {
+		senOnep = createSenItemEquation(itemp);
+	    } else if (AstSenGate* itemp = senp->castSenGate()) {
+		senOnep = createSenGateEquation(itemp);
 	    } else {
-		senp->v3fatalSrc("Bad edge type");
+		senp->v3fatalSrc("Strange node under sentree");
 	    }
 	    if (senEqnp) {
 		// Add new OR to the sensitivity list equation
@@ -160,14 +185,7 @@ private:
 	return senEqnp;
     }
     AstIf* makeActiveIf(AstSenTree* sensesp) {
-	for (AstSenItem* senp = sensesp->sensesp(); senp; senp=senp->nextp()->castSenItem()) {
-	    if (senp->edgeType() != AstEdgeType::HIGHEDGE
-		&& senp->varrefp()) {
-		AstVarScope* oldvscp = senp->varrefp()->varScopep();
-		getCreateLastClk(oldvscp);
-	    }
-	}
-	AstNode* senEqnp = createSenseEquation(sensesp);
+	AstNode* senEqnp = createSenseEquation(sensesp->sensesp());
 	if (!senEqnp) sensesp->v3fatalSrc("No sense equation, shouldn't be in sequent activation.");
 	AstIf* newifp = new AstIf (sensesp->fileline(),
 				   senEqnp, NULL, NULL);
@@ -184,8 +202,8 @@ private:
 	m_topScopep=nodep;
 	m_scopep = nodep->scopep();
 	if (!m_scopep) nodep->v3fatalSrc("No scope found on top level, perhaps you have no statements?\n");
-	//VV*****  We reset all userp()
-	AstNode::userClearTree();
+	//VV*****  We reset all user1p()
+	AstNode::user1ClearTree();
 	// Make top functions
 	{
 	    AstCFunc* funcp = new AstCFunc(nodep->fileline(), "_eval", m_scopep);
@@ -245,12 +263,13 @@ private:
 	//UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_stableNum = 0;
-  	nodep->iterateChildren(*this);
+	nodep->iterateChildren(*this);
+	m_modp= NULL;
     }
     virtual void visit(AstScope* nodep, AstNUser*) {
 	//UINFO(4," SCOPE   "<<nodep<<endl);
 	m_scopep = nodep;
-  	nodep->iterateChildren(*this);
+	nodep->iterateChildren(*this);
 	if (AstNode* movep = nodep->finalClksp()) {
 	    if (!m_topScopep) nodep->v3fatalSrc("Final clocks under non-top scope");
 	    movep->unlinkFrBackWithNext();
@@ -278,6 +297,26 @@ private:
 	}
 	nodep->deleteTree(); nodep = NULL;
     }
+    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+	//nodep->dumpTree(cout,"ct:");
+	//COVERTOGGLE(INC, ORIG, CHANGE) ->
+	//   IF(ORIG ^ CHANGE) { INC; CHANGE = ORIG; }
+	AstNode* incp = nodep->incp()->unlinkFrBack();
+	AstNode* origp = nodep->origp()->unlinkFrBack();
+	AstNode* changep = nodep->changep()->unlinkFrBack();
+	AstIf* newp = new AstIf(nodep->fileline(),
+				new AstXor(nodep->fileline(),
+					   origp,
+					   changep),
+				incp, NULL);
+	// We could add another IF to detect posedges, and only increment if so.
+	// It's another whole branch though verus a potential memory miss.
+	// We'll go with the miss.
+	newp->addIfsp(new AstAssign(nodep->fileline(),
+				    changep->cloneTree(false),
+				    origp->cloneTree(false)));
+	nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
+    }
     virtual void visit(AstInitial* nodep, AstNUser*) {
 	AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName());
 	nodep->replaceWith(cmtp);
@@ -416,7 +455,7 @@ private:
 					 new AstConst(fl, 1)));
         preUntilp->addNext(new AstAssign(fl, new AstVarRef(fl, countVarp, true),
 					 new AstConst(fl, 0)));
-	
+
 	// Add stable variables & preinits
 	AstNode* setChglastp = NULL;
 	for (AstVarRef* varrefp = nodep->stablesp(); varrefp; varrefp=varrefp->nextp()->castVarRef()) {

src/V3Clock.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Clocking POS/NEGEDGE insertion
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3Combine.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Combine common code into functions
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Combine's Transformations:
-//		
+//
 //	For every function that we spit out
 //	Examine code to find largest common blocks
 //	    Hash each node depth first
@@ -32,13 +32,13 @@
 //		Make new function
 //		Move common block to function
 //		Replace each common block ref with funccall
-//		
+//
 //*************************************************************************
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 #include <vector>
@@ -59,8 +59,14 @@
 class CombBaseVisitor : public AstNVisitor {
 protected:
     // STATE
-    //int debug() { return 9; }
+
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     virtual ~CombBaseVisitor() {}
 
     //***** optimization levels
@@ -175,6 +181,9 @@ private:
     //  AstCFunc::user3p()	-> AstCFunc*, If set, replace ccalls to this func with new func
     //  AstNodeStmt::user3()	-> AstNode*.  True if to ignore this cell
     //  AstNodeStmt::user4()	-> V3Hashed::V3Hash.  Hash value of this node (hash of 0 is illegal)
+    AstUser1InUse	m_inuser1;
+    AstUser3InUse	m_inuser3;
+    //AstUser4InUse	part of V3Hashed
 
     // STATE
     typedef enum {STATE_IDLE, STATE_HASH, STATE_DUP} CombineState;
@@ -187,7 +196,7 @@ private:
     int			m_modNFuncs;	// Number of functions made
     AstNode*		m_walkLast1p;	// Final node that is the same in duplicate list
     AstNode*		m_walkLast2p;	// Final node that is the same in duplicate list
-    V3Hashed		m_hashed;	// Hash for every node
+    V3Hashed		m_hashed;	// Hash for every node in module
 
     // METHODS
     void hashStatement(AstNode* nodep) {
@@ -280,7 +289,7 @@ private:
 	    if (node1p==node2p) continue;
 	    //
 	    // We need to mark iteration to prevent matching code inside code (abab matching in ababab)
-	    AstNode::userClearTree();	// userp() used on entire tree
+	    AstNode::user1ClearTree();	// user1p() used on entire tree
 	    m_walkLast1p = NULL;
 	    m_walkLast2p = NULL;
 	    int depth = walkDupCodeNext(node1p, node2p, 1);
@@ -306,7 +315,7 @@ private:
 
     int walkDupCodeNext(AstNode* node1p, AstNode* node2p, int level) {
 	// Find number of common statements between the two node1p_nextp's...
-	if (node1p->userp() || node2p->userp()) return 0;   // Already iterated
+	if (node1p->user1p() || node2p->user1p()) return 0;   // Already iterated
 	if (node1p->user3p() || node2p->user3p()) return 0;   // Already merged
 	if (!m_hashed.sameNodes(node1p,node2p)) return 0; // walk of tree has same comparison
 	V3Hash hashval(node1p->user4p());
@@ -314,8 +323,8 @@ private:
 	//UINFO(9,"        wdup2 "<<level<<" "<<V3Hash(node2p->user4p())<<" "<<node2p<<endl);
 	m_walkLast1p = node1p;
 	m_walkLast2p = node2p;
-	node1p->user(true);
-	node2p->user(true);
+	node1p->user1(true);
+	node2p->user1(true);
 	if (node1p->nextp() && node2p->nextp()) {
 	    return hashval.depth()+walkDupCodeNext(node1p->nextp(), node2p->nextp(), level+1);
 	}
@@ -379,8 +388,7 @@ private:
 	// Track all callers of each function
 	m_call.main(nodep);
 	//
-	AstNode::user3ClearTree();	// userp() used on entire tree
-	//In V3Hashed AstNode::user4ClearTree();	// userp() used on entire tree
+	//In V3Hashed AstNode::user4ClearTree();	// user4p() used on entire tree
 	// Iterate modules backwards, in bottom-up order.
 	// Required so that a module instantiating another can benefit from collapsing.
 	nodep->iterateChildrenBackwards(*this);
@@ -392,8 +400,11 @@ private:
 	m_hashed.clear();
 	// Compute hash of all statement trees in the function
 	m_state = STATE_HASH;
-  	nodep->iterateChildren(*this);
+	nodep->iterateChildren(*this);
 	m_state = STATE_IDLE;
+	if (debug()>=9) {
+	    m_hashed.dumpFilePrefixed("combine");
+	}
 	// Walk the hashes removing empty functions
 	if (emptyFunctionDeletion()) {
 	    walkEmptyFuncs();
@@ -408,6 +419,7 @@ private:
 	    nodep->iterateChildren(*this);
 	    m_state = STATE_IDLE;
 	}
+	m_modp = NULL;
     }
     virtual void visit(AstCFunc* nodep, AstNUser*) {
 	m_funcp = nodep;

src/V3Combine.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Combine common code into functions
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3Const.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Constant folding
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -27,10 +27,11 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <map>
+#include <algorithm>
 
 #include "V3Global.h"
 #include "V3Const.h"
@@ -38,23 +39,82 @@
 #include "V3Ast.h"
 #include "V3Width.h"
 #include "V3Signed.h"
+#include "V3Simulate.h"
+
+//######################################################################
+// Utilities
+
+class ConstVarMarkVisitor : public AstNVisitor {
+    // NODE STATE
+    // AstVar::user4p		-> bool, Var marked, 0=not set yet
+private:
+    // VISITORS
+    virtual void visit(AstVarRef* nodep, AstNUser*) {
+	if (nodep->varp()) nodep->varp()->user4(1);
+    }
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+    }
+public:
+    // CONSTUCTORS
+    ConstVarMarkVisitor(AstNode* nodep) {
+	AstNode::user4ClearTree();  // Check marked InUse before we're called
+	nodep->iterateAndNext(*this, NULL);
+    }
+    virtual ~ConstVarMarkVisitor() {}
+};
+
+class ConstVarFindVisitor : public AstNVisitor {
+    // NODE STATE
+    // AstVar::user4p		-> bool, input from ConstVarMarkVisitor
+    // MEMBERS
+    bool m_found;
+private:
+    // VISITORS
+    virtual void visit(AstVarRef* nodep, AstNUser*) {
+	if (nodep->varp() && nodep->varp()->user4()) m_found = true;
+    }
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+    }
+public:
+    // CONSTUCTORS
+    ConstVarFindVisitor(AstNode* nodep) {
+	m_found = false;
+	nodep->iterateAndNext(*this, NULL);
+    }
+    virtual ~ConstVarFindVisitor() {}
+    // METHODS
+    bool found() const { return m_found; }
+};
 
 //######################################################################
 // Const state, as a visitor of each AstNode
 
 class ConstVisitor : public AstNVisitor {
 private:
+    // NODE STATE
+    // ** only when m_warn/m_expensive is set.  If state is needed other times,
+    // ** must track down everywhere V3Const is called and make sure no overlaps.
+    // AstVar::user4p		-> Used by ConstVarMarkVisitor/ConstVarFindVisitor
+
     // STATE
     bool	m_params;	// If true, propogate parameterized and true numbers only
     bool	m_required;	// If true, must become a constant
     bool	m_wremove;	// Inside scope, no assignw removal
     bool	m_warn;		// Output warnings
     bool	m_cpp;		// C++ conversions only
-    AstModule*	m_modp;		// Current module	
+    bool	m_expensive;	// Enable computationally expensive optimizations
+    AstModule*	m_modp;		// Current module
     AstNode*	m_scopep;	// Current scope
-    //int debug() { return 9; }
 
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     bool operandConst (AstNode* nodep) {
 	return (nodep->castConst());
     }
@@ -81,18 +141,103 @@ private:
 	if (rnodep->width() != bnodep->width()) return false;
 	return operandsSame(bnodep->lhsp(), rnodep->lhsp());
     }
+    bool operandAsvLUp (AstNode* nodep) {
+	// BIASV(BIASV(CONSTll,lr),r) -> BIASV(CONSTll,BIASV(lr,r))
+	//
+	// Example of how this is useful:
+	// BIASV(BIASV(CONSTa,b...),BIASV(CONSTc,d...))	 // hits operandAsvUp
+	// BIASV(CONSTa,BIASV(b...,BIASV(CONSTc,d...)))	 // hits operandAsvUp
+	// BIASV(CONSTa,BIASV(CONSTc,BIASV(c...,d...)))  // hits operandAsvConst
+	// BIASV(BIASV(CONSTa,CONSTc),BIASV(c...,d...))) // hits normal constant propagation
+	// BIASV(CONST_a_c,BIASV(c...,d...)))	
+	//
+	// Idea for the future: All BiComAsvs could be lists, sorted by if they're constant
+	AstNodeBiComAsv* bnodep = nodep->castNodeBiComAsv();
+	if (!bnodep) return false;
+	AstNodeBiComAsv* lnodep = bnodep->lhsp()->castNodeBiComAsv();
+	if (!lnodep) return false;
+	if (lnodep->type() != bnodep->type()) return false;
+	if (lnodep->width() != bnodep->width()) return false;
+	return lnodep->lhsp()->castConst();
+    }
+    bool operandAsvRUp (AstNode* nodep) {
+	// BIASV(l,BIASV(CONSTrl,rr)) -> BIASV(CONSTrl,BIASV(l,rr))
+	AstNodeBiComAsv* bnodep = nodep->castNodeBiComAsv();
+	if (!bnodep) return false;
+	AstNodeBiComAsv* rnodep = bnodep->rhsp()->castNodeBiComAsv();
+	if (!rnodep) return false;
+	if (rnodep->type() != bnodep->type()) return false;
+	if (rnodep->width() != bnodep->width()) return false;
+	return rnodep->lhsp()->castConst();
+    }
+    static bool operandAndOrSame(AstNode* nodep) {
+	AstNodeBiop* np = nodep->castNodeBiop();
+	AstNodeBiop* lp = np->lhsp()->castNodeBiop();
+	AstNodeBiop* rp = np->rhsp()->castNodeBiop();
+	return (lp && rp
+		&& lp->width()==rp->width()
+		&& lp->type()==rp->type()
+		&& operandsSame(lp->lhsp(),rp->lhsp()));
+    }
+    static bool matchOrAndNot(AstNodeBiop* nodep) {
+	// AstOr{$a, AstAnd{AstNot{$b}, $c}} if $a.width1, $a==$b => AstOr{$a,$c}
+	// Someday we'll sort the biops completely and this can be simplified
+	// This often results from our simplified clock generation:
+	// if (rst) ... else if (enable)... -> OR(rst,AND(!rst,enable))
+	AstNode* ap;
+	AstNodeBiop* andp;
+	if      (nodep->lhsp()->castAnd()) { andp=nodep->lhsp()->castAnd(); ap=nodep->rhsp(); }
+	else if (nodep->rhsp()->castAnd()) { andp=nodep->rhsp()->castAnd(); ap=nodep->lhsp(); }
+	else return false;
+	AstNodeUniop* notp;
+	AstNode* cp;
+	if      (andp->lhsp()->castNot()) { notp=andp->lhsp()->castNot(); cp=andp->rhsp(); }
+	else if (andp->rhsp()->castNot()) { notp=andp->rhsp()->castNot(); cp=andp->lhsp(); }
+	else return false;
+	AstNode* bp = notp->lhsp();
+	if (!operandsSame(ap, bp)) return false;
+	// Do it
+	cp->unlinkFrBack();
+	andp->unlinkFrBack()->deleteTree(); andp=NULL; notp=NULL;
+	// Replace whichever branch is now dangling
+	if (nodep->rhsp()) nodep->lhsp(cp);
+	else nodep->rhsp(cp);
+	return true;
+    }
+    static bool operandShiftSame(AstNode* nodep) {
+	AstNodeBiop* np = nodep->castNodeBiop();
+	{
+	    AstShiftL* lp = np->lhsp()->castShiftL();
+	    AstShiftL* rp = np->rhsp()->castShiftL();
+	    if (lp && rp) {
+		return (lp->width() == rp->width()
+			&& lp->lhsp()->width() == rp->lhsp()->width()
+			&& operandsSame(lp->rhsp(), rp->rhsp()));
+	    }
+	}
+	{
+	    AstShiftR* lp = np->lhsp()->castShiftR();
+	    AstShiftR* rp = np->rhsp()->castShiftR();
+	    if (lp && rp) {
+		return (lp->width() == rp->width()
+			&& lp->lhsp()->width() == rp->lhsp()->width()
+			&& operandsSame(lp->rhsp(), rp->rhsp()));
+	    }
+	}
+	return false;
+    }
     bool operandHugeShiftL(AstNodeBiop* nodep) {
 	return (nodep->rhsp()->castConst()
-		&& nodep->rhsp()->castConst()->asInt() >= (uint32_t)(nodep->width()));
+		&& nodep->rhsp()->castConst()->toUInt() >= (uint32_t)(nodep->width()));
     }
     bool operandHugeShiftR(AstNodeBiop* nodep) {
 	return (nodep->rhsp()->castConst()
-		&& nodep->rhsp()->castConst()->asInt() >= (uint32_t)(nodep->lhsp()->width()));
+		&& nodep->rhsp()->castConst()->toUInt() >= (uint32_t)(nodep->lhsp()->width()));
     }
     bool operandIsTwo(AstNode* nodep) {
 	return (nodep->castConst()
-		&& nodep->width() <= VL_QUADSIZE 
-		&& nodep->castConst()->asQuad()==2);
+		&& nodep->width() <= VL_QUADSIZE
+		&& nodep->castConst()->toUQuad()==2);
     }
     bool operandIsTwostate(AstNode* nodep) {
 	return (nodep->castConst()
@@ -129,7 +274,7 @@ private:
 	return (nodep->rhsp()->castConst()
 		&& nodep->fromp()->castNodeVarRef()
 		&& !nodep->fromp()->castNodeVarRef()->lvalue()
-		&& ((int)(nodep->rhsp()->castConst()->asInt())
+		&& ((int)(nodep->rhsp()->castConst()->toUInt())
 		    >= nodep->fromp()->castNodeVarRef()->varp()->widthWords()));
     }
     bool operandSelFull(AstSel* nodep) {
@@ -164,15 +309,28 @@ private:
     bool warnSelect(AstSel* nodep) {
 	AstNode* basefromp = AstArraySel::baseFromp(nodep->fromp());
 	if (AstNodeVarRef* varrefp = basefromp->castNodeVarRef()) {
+	    AstVar* varp = varrefp->varp();
 	    if (m_warn
 		&& nodep->lsbp()->castConst()
 		&& nodep->widthp()->castConst()
-		&& (!varrefp->varp()->rangep() || varrefp->varp()->msb())  // else it's non-resolvable parameterized
-		&& ( (  (nodep->msbConst() > varrefp->varp()->msb())
-			|| (nodep->lsbConst() > varrefp->varp()->msb())))) {
-		nodep->v3error("Selection index out of range: "
-			       <<nodep->msbConst()<<":"<<nodep->lsbConst()
-			       <<" outside "<<varrefp->varp()->msb()<<":0");
+		&& (!varp->rangep() || varp->msb())) {  // else it's non-resolvable parameterized
+		if (nodep->lsbp()->castConst()->num().isFourState()
+		    || nodep->widthp()->castConst()->num().isFourState()) {
+		    nodep->v3error("Selection index is constantly unknown or tristated: "
+				   "lsb="<<nodep->lsbp()->name()<<" width="<<nodep->widthp()->name());
+		    // Replacing nodep will make a mess above, so we replace the offender
+		    replaceZero(nodep->lsbp());
+		}
+		else if ((nodep->msbConst() > varp->msbMaxSelect())
+			 || (nodep->lsbConst() > varp->msbMaxSelect())) {
+		    // See also warning in V3Width
+		    nodep->v3error("Selection index out of range: "
+				   <<nodep->msbConst()<<":"<<nodep->lsbConst()
+				   <<" outside "<<varp->msbMaxSelect()<<":0"
+				   <<(varp->lsb()>=0 ? ""
+				      :" (adjusted +"+cvtToStr(-varp->lsb())+" to account for negative lsb)"));
+		    // Don't replace with zero, we'll do it later
+		}
 	    }
 	}
 	return false;  // Not a transform, so NOP
@@ -218,7 +376,9 @@ private:
     void replaceNum (AstNode* oldp, const V3Number& num) {
 	// Replace oldp node with a constant set to specified value
 	UASSERT (oldp, "Null old\n");
-	if (oldp->castConst()) oldp->v3fatalSrc("Already constant??\n");
+	if (oldp->castConst() && !oldp->castConst()->num().isFourState()) {
+	    oldp->v3fatalSrc("Already constant??\n");
+	}
 	AstNode* newp = new AstConst(oldp->fileline(), num);
 	newp->widthSignedFrom(oldp);
 	if (debug()>5) oldp->dumpTree(cout,"  const_old: ");
@@ -313,6 +473,66 @@ private:
 	if (rp->lhsp()->castConst() && rp->rhsp()->castConst()) replaceConst(rp);
 	//nodep->dumpTree(cout, "  repAsvConst_new: ");
     }
+    void replaceAsvLUp (AstNodeBiop* nodep) {
+	// BIASV(BIASV(CONSTll,lr),r) -> BIASV(CONSTll,BIASV(lr,r))
+	AstNodeBiop* lp = nodep->lhsp()->unlinkFrBack()->castNodeBiop();
+	AstNode* llp = lp->lhsp()->unlinkFrBack();
+	AstNode* lrp = lp->rhsp()->unlinkFrBack();
+	AstNode* rp  = nodep->rhsp()->unlinkFrBack();
+	nodep->lhsp(llp);
+	nodep->rhsp(lp);
+	lp->lhsp(lrp);
+	lp->rhsp(rp);
+	//nodep->dumpTree(cout, "  repAsvLUp_new: ");
+    }
+    void replaceAsvRUp (AstNodeBiop* nodep) {
+	// BIASV(l,BIASV(CONSTrl,rr)) -> BIASV(CONSTrl,BIASV(l,rr))
+	AstNode* lp  = nodep->lhsp()->unlinkFrBack();
+	AstNodeBiop* rp = nodep->rhsp()->unlinkFrBack()->castNodeBiop();
+	AstNode* rlp = rp->lhsp()->unlinkFrBack();
+	AstNode* rrp = rp->rhsp()->unlinkFrBack();
+	nodep->lhsp(rlp);
+	nodep->rhsp(rp);
+	rp->lhsp(lp);
+	rp->rhsp(rrp);
+	//nodep->dumpTree(cout, "  repAsvRUp_new: ");
+    }
+    void replaceAndOr (AstNodeBiop* nodep) {
+	// Or(And(CONSTll,lr),And(CONSTrl==ll,rr)) -> And(CONSTll,Or(lr,rr))
+	// (Or/And may also be reversed)
+	AstNodeBiop* lp = nodep->lhsp()->unlinkFrBack()->castNodeBiop();
+	AstNode* llp = lp->lhsp()->unlinkFrBack();
+	AstNode* lrp = lp->rhsp()->unlinkFrBack();
+	AstNodeBiop* rp = nodep->rhsp()->unlinkFrBack()->castNodeBiop();
+	AstNode* rlp = rp->lhsp()->unlinkFrBack();
+	AstNode* rrp = rp->rhsp()->unlinkFrBack();
+	nodep->replaceWith(lp);
+	lp->lhsp(llp);
+	lp->rhsp(nodep);
+	nodep->lhsp(lrp);
+	nodep->rhsp(rrp);
+	rp->deleteTree();
+	rlp->deleteTree();
+	//nodep->dumpTree(cout, "  repAndOr_new: ");
+    }
+    void replaceShiftSame (AstNodeBiop* nodep) {
+	// Or(Shift(ll,CONSTlr),Shift(rl,CONSTrr==lr)) -> Shift(Or(ll,rl),CONSTlr)
+	// (Or/And may also be reversed)
+	AstNodeBiop* lp = nodep->lhsp()->unlinkFrBack()->castNodeBiop();
+	AstNode* llp = lp->lhsp()->unlinkFrBack();
+	AstNode* lrp = lp->rhsp()->unlinkFrBack();
+	AstNodeBiop* rp = nodep->rhsp()->unlinkFrBack()->castNodeBiop();
+	AstNode* rlp = rp->lhsp()->unlinkFrBack();
+	AstNode* rrp = rp->rhsp()->unlinkFrBack();
+	nodep->replaceWith(lp);
+	lp->lhsp(nodep);
+	lp->rhsp(lrp);
+	nodep->lhsp(llp);
+	nodep->rhsp(rlp);
+	rp->deleteTree();
+	rrp->deleteTree();
+	//nodep->dumpTree(cout, "  repShiftSame_new: ");
+    }
     void replaceExtend (AstNode* nodep, AstNode* arg0p) {
 	// -> EXTEND(nodep)
 	// like a AstExtend{$rhsp}, but we need to set the width correctly from base node
@@ -360,7 +580,7 @@ private:
 	AstNode* ap = lhsp->lhsp()->unlinkFrBack();
 	AstNode* bp = lhsp->rhsp()->unlinkFrBack();
 	AstNodeBiop* shift1p = nodep;
-	AstNodeBiop* shift2p = nodep->cloneTree(true)->castNodeBiop();
+	AstNodeBiop* shift2p = nodep->cloneTree(true);
 	shift1p->lhsp(ap); shift1p->rhsp(shiftp->cloneTree(true));
 	shift2p->lhsp(bp); shift2p->rhsp(shiftp);
 	AstNodeBiop* newp = lhsp;
@@ -381,9 +601,11 @@ private:
 	    nodep->accept(*this);	// Further reduce, either node may have more reductions.
 	} else {
 	    // We know shift amounts are constant, but might be a mixed left/right shift
-	    int shift1 = shift1p->castConst()->asInt(); if (lhsp->castShiftR())  shift1=-shift1;
-	    int shift2 = shift2p->castConst()->asInt(); if (nodep->castShiftR()) shift2=-shift2;
+	    int shift1 = shift1p->castConst()->toUInt(); if (lhsp->castShiftR())  shift1=-shift1;
+	    int shift2 = shift2p->castConst()->toUInt(); if (nodep->castShiftR()) shift2=-shift2;
 	    int newshift = shift1+shift2;
+	    shift1p->deleteTree(); shift1p=NULL;
+	    shift2p->deleteTree(); shift1p=NULL;
 	    AstNode* newp;
 	    V3Number mask1 (nodep->fileline(), nodep->width());
 	    V3Number ones (nodep->fileline(), nodep->width());
@@ -437,11 +659,11 @@ private:
 	if (!varNotReferenced(nodep->rhsp(), varref1p->varp())) return false;
 	if (!varNotReferenced(nextp->rhsp(), varref2p->varp())) return false;
 	// Swap?
-	if ((  con1p->asInt() != con2p->asInt() + sel2p->width())
-	    &&(con2p->asInt() != con1p->asInt() + sel1p->width())) return false;
-	bool lsbFirstAssign = (con1p->asInt() < con2p->asInt());
+	if ((  con1p->toSInt() != con2p->toSInt() + sel2p->width())
+	    &&(con2p->toSInt() != con1p->toSInt() + sel1p->width())) return false;
+	bool lsbFirstAssign = (con1p->toUInt() < con2p->toUInt());
 	// If the user already has nice 32-bit divisions, keep them to aid later subdivision
-	//if (VL_BITBIT_I(con1p->asInt()) == 0) return false;
+	//if (VL_BITBIT_I(con1p->toUInt()) == 0) return false;
 	UINFO(4,"replaceAssignMultiSel "<<nodep<<endl);
 	UINFO(4,"                   && "<<nextp<<endl);
 	//nodep->dumpTree(cout, "comb1: ");
@@ -464,7 +686,7 @@ private:
 	return true;
     }
 
-    bool varNotReferenced(AstNode* nodep, AstVar* varp, bool level=0) {
+    bool varNotReferenced(AstNode* nodep, AstVar* varp, int level=0) {
 	// Return true if varp never referenced under node.
 	// Return false if referenced, or tree too deep to be worth it
 	if (!nodep) return true;
@@ -492,10 +714,29 @@ private:
 	    }
 	}
 	else if (!m_cpp && nodep->lhsp()->castConcat()) {
-	    UINFO(4,"  ASSI "<<nodep<<endl);
+	    bool need_temp = false;
+	    if (m_warn && !nodep->castAssignDly()) {  // Is same var on LHS and RHS?
+		// Note only do this (need user4) when m_warn, which is
+		// done as unique visitor
+		AstUser4InUse	m_inuser4;
+		ConstVarMarkVisitor mark(nodep->lhsp());
+		ConstVarFindVisitor find(nodep->rhsp());
+		if (find.found()) need_temp = true;
+	    }
+	    if (need_temp) {
+		// The first time we constify, there may be the same variable on the LHS
+		// and RHS.  In that case, we must use temporaries, or {a,b}={b,a} will break.
+		UINFO(4,"  ASSITEMP "<<nodep<<endl);
+		// ASSIGN(CONCAT(lc1,lc2),rhs) -> ASSIGN(temp1,SEL(rhs,{size})),
+		//				  ASSIGN(temp2,SEL(newrhs,{size}))
+		//                                ASSIGN(lc1,temp1),
+		//				  ASSIGN(lc2,temp2)
+	    } else {
+		UINFO(4,"  ASSI "<<nodep<<endl);
+		// ASSIGN(CONCAT(lc1,lc2),rhs) -> ASSIGN(lc1,SEL(rhs,{size})),
+		//				  ASSIGN(lc2,SEL(newrhs,{size}))
+	    }
 	    if (debug()>=9) nodep->dumpTree(cout,"  Ass_old: ");
-	    // ASSIGN(CONCAT(lc1,lc2),rhs) -> ASSIGN(lc1,SEL(rhs,{size})),
-	    //				      ASSIGN(lc2,SEL(newrhs,{size}))
 	    // Unlink the stuff
 	    AstNode*   lc1p    = nodep->lhsp()->castConcat()->lhsp()->unlinkFrBack();
 	    AstNode*   lc2p    = nodep->lhsp()->castConcat()->rhsp()->unlinkFrBack();
@@ -515,16 +756,53 @@ private:
 	    sel2p->width(msb2-lsb2+1,msb2-lsb2+1);
 	    // Make new assigns of same flavor as old one
 	    //*** Not cloneTree; just one node.
-	    AstNodeAssign* asn1p=nodep->cloneType(lc1p, sel1p)->castNodeAssign();
-	    AstNodeAssign* asn2p=nodep->cloneType(lc2p, sel2p)->castNodeAssign();
-	    asn1p->width(msb1-lsb1+1,msb1-lsb1+1);
-	    asn2p->width(msb2-lsb2+1,msb2-lsb2+1);
-	    nodep->addNextHere(asn1p);
-	    nodep->addNextHere(asn2p);
-	    if (debug()>=9) asn1p->dumpTree(cout,"     _new: ");
-	    if (debug()>=9) asn2p->dumpTree(cout,"     _new: ");
+	    AstNode* newp = NULL;
+	    if (!need_temp) {
+		AstNodeAssign* asn1ap=nodep->cloneType(lc1p, sel1p)->castNodeAssign();
+		AstNodeAssign* asn2ap=nodep->cloneType(lc2p, sel2p)->castNodeAssign();
+		asn1ap->width(msb1-lsb1+1,msb1-lsb1+1);
+		asn2ap->width(msb2-lsb2+1,msb2-lsb2+1);
+		newp = newp->addNext(asn1ap);
+		newp = newp->addNext(asn2ap);
+	    } else {
+		if (!m_modp) nodep->v3fatalSrc("Not under module");
+		// We could create just one temp variable, but we'll get better optimization
+		// if we make one per term.
+		string name1 = ((string)"__Vconcswap"+cvtToStr(m_modp->varNumGetInc()));
+		string name2 = ((string)"__Vconcswap"+cvtToStr(m_modp->varNumGetInc()));
+		AstVar* temp1p = new AstVar(sel1p->fileline(), AstVarType::BLOCKTEMP, name1,
+					    new AstRange(sel1p->fileline(), msb1-lsb1, 0));
+		AstVar* temp2p = new AstVar(sel2p->fileline(), AstVarType::BLOCKTEMP, name2,
+					    new AstRange(sel2p->fileline(), msb2-lsb2, 0));
+		m_modp->addStmtp(temp1p);
+		m_modp->addStmtp(temp2p);
+		AstNodeAssign* asn1ap=nodep->cloneType
+		    (new AstVarRef(sel1p->fileline(), temp1p, true),
+		     sel1p)->castNodeAssign();
+		AstNodeAssign* asn2ap=nodep->cloneType
+		    (new AstVarRef(sel2p->fileline(), temp2p, true),
+		     sel2p)->castNodeAssign();
+		AstNodeAssign* asn1bp=nodep->cloneType
+		    (lc1p, new AstVarRef(sel1p->fileline(), temp1p, false))
+		    ->castNodeAssign();
+		AstNodeAssign* asn2bp=nodep->cloneType
+		    (lc2p, new AstVarRef(sel2p->fileline(), temp2p, false))
+		    ->castNodeAssign();
+		asn1ap->width(msb1-lsb1+1,msb1-lsb1+1);
+		asn1bp->width(msb1-lsb1+1,msb1-lsb1+1);
+		asn2ap->width(msb2-lsb2+1,msb2-lsb2+1);
+		asn2bp->width(msb2-lsb2+1,msb2-lsb2+1);
+		// This order matters
+		newp = newp->addNext(asn1ap);
+		newp = newp->addNext(asn2ap);
+		newp = newp->addNext(asn1bp);
+		newp = newp->addNext(asn2bp);
+	    }
+	    if (debug()>=9) newp->dumpTreeAndNext(cout,"     _new: ");
+	    nodep->addNextHere(newp);
 	    // Cleanup
-	    nodep->unlinkFrBack()->deleteTree();
+	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    conp->deleteTree(); conp=NULL;
 	    // Further reduce, either node may have more reductions.
 	    return true;
 	}
@@ -542,7 +820,7 @@ private:
 	if (!nodep->castAnd()->rhsp()->castShiftR()) return false;
 	AstShiftR* shiftp = nodep->castAnd()->rhsp()->castShiftR();
 	if (!shiftp->rhsp()->castConst()) return false;
-	if ((uint32_t)(nodep->width()) <= shiftp->rhsp()->castConst()->asInt()) return false;
+	if ((uint32_t)(nodep->width()) <= shiftp->rhsp()->castConst()->toUInt()) return false;
 	return true;
     }
     void replaceBoolShift(AstNode* nodep) {
@@ -561,6 +839,26 @@ private:
 	if (debug()>=9) newp->dumpTree(cout,"       _new: ");
     }
 
+    void replaceWithSimulation(AstNode* nodep) {
+	SimulateVisitor simvis;
+	// Run it - may be unoptimizable due to large for loop, etc
+	simvis.mainParamEmulate(nodep);
+	if (!simvis.optimizable()) {
+		    AstNode* errorp = simvis.whyNotNodep(); if (!errorp) errorp = nodep;
+	    nodep->v3error("Expecting expression to be constant, but can't determine constant for "
+			   <<nodep->prettyTypeName()<<endl
+			   <<V3Error::msgPrefix()<<errorp->fileline()<<"... Location of non-constant "
+			   <<errorp->prettyTypeName()<<": "<<simvis.whyNotMessage());
+	    replaceZero(nodep); nodep=NULL;
+	} else {
+	    // Fetch the result
+	    V3Number* outnump = simvis.fetchNumberNull(nodep);
+	    if (!outnump) nodep->v3fatalSrc("No number returned from simulation");
+	    // Replace it
+	    replaceNum(nodep,*outnump); nodep=NULL;
+	}
+    }
+
     //----------------------------------------
 
     // VISITORS
@@ -637,7 +935,8 @@ private:
 	    // If bp was a concat, then we have this exact same form again!
 	    // Recurse rather then calling node->iterate to prevent 2^n recursion!
 	    if (operandConcatMove(abConcp)) moveConcat(abConcp);
-	} else { 
+	    bcConcp->deleteTree(); bcConcp=NULL;
+	} else {
 	    AstConcat* abConcp = nodep->lhsp()->castConcat(); abConcp->unlinkFrBack();
 	    AstNode* ap = abConcp->lhsp()->unlinkFrBack();
 	    AstNode* bp = abConcp->rhsp()->unlinkFrBack();
@@ -647,6 +946,7 @@ private:
 	    nodep->lhsp(ap);
 	    nodep->rhsp(bcConcp);
 	    if (operandConcatMove(bcConcp)) moveConcat(bcConcp);
+	    abConcp->deleteTree(); abConcp=NULL;
 	}
     }
 
@@ -676,7 +976,9 @@ private:
 	AstNode* newlsbp;
 	if (lsb1p->castConst() && lsb2p->castConst()) {
 	    newlsbp = new AstConst(lsb1p->fileline(),
-				   lsb1p->castConst()->asInt() + lsb2p->castConst()->asInt());
+				   lsb1p->castConst()->toUInt() + lsb2p->castConst()->toUInt());
+	    lsb1p->deleteTree(); lsb1p=NULL;
+	    lsb2p->deleteTree(); lsb2p=NULL;
 	} else {
 	    // Width is important, we need the width of the fromp's
 	    // expression, not the potentially smaller lsb1p's width
@@ -741,7 +1043,7 @@ private:
 	AstNode* widthp = nodep->widthp()->unlinkFrBack();
 	AstSel* newp = new AstSel(nodep->fileline(),
 				  fromp,
-				  new AstConst(lsbp->fileline(), lsbp->asInt() % fromp->width()),
+				  new AstConst(lsbp->fileline(), lsbp->toUInt() % fromp->width()),
 				  widthp);
 	newp->widthSignedFrom(nodep);
 	nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
@@ -772,8 +1074,7 @@ private:
     }
     virtual void visit(AstAttrOf* nodep, AstNUser*) {
 	// Don't iterate children, don't want to loose VarRef.
-	if (nodep->attrType()==AstAttrType::SCOPE_TEXT) {
-	} else if (nodep->attrType()==AstAttrType::BITS) {
+	if (nodep->attrType()==AstAttrType::BITS) {
 	    if (!nodep->fromp() || !nodep->fromp()->widthMin()) nodep->v3fatalSrc("Unsized expression");
 	    V3Number num (nodep->fileline(), 32, nodep->fromp()->widthMin());
 	    replaceNum(nodep, num); nodep=NULL;
@@ -797,14 +1098,26 @@ private:
 	    } else nodep->v3fatalSrc("Missing ATTR type case\n");
 	}
     }
+    bool onlySenItemInSenTree(AstNodeSenItem* nodep) {
+	// Only one if it's not in a list
+	return (!nodep->nextp() && nodep->backp()->nextp() != nodep);
+    }
     virtual void visit(AstSenItem* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	if (nodep->sensp()->castConst()
 	    || (nodep->varrefp() && nodep->varrefp()->varp()->isParam())) {
 	    // Constants in sensitivity lists may be removed (we'll simplify later)
-	    AstSenItem* newp = new AstSenItem(nodep->fileline(), AstSenItem::Never());
-	    nodep->replaceWith(newp);
-	    nodep->deleteTree(); nodep=NULL;
+	    if (nodep->isClocked()) {  // A constant can never get a pos/negexge
+		if (onlySenItemInSenTree(nodep)) {
+		    nodep->replaceWith(new AstSenItem(nodep->fileline(), AstSenItem::Never()));
+		    nodep->deleteTree(); nodep=NULL;
+		} else {
+		    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+		}
+	    } else {  // Otherwise it may compute a result that needs to settle out
+		nodep->replaceWith(new AstSenItem(nodep->fileline(), AstSenItem::Combo()));
+		nodep->deleteTree(); nodep=NULL;
+	    }
 	} else if (nodep->sensp()->castNot()) {
 	    // V3Gate may propagate NOTs into clocks... Just deal with it
 	    AstNode* sensp = nodep->sensp();
@@ -824,6 +1137,150 @@ private:
 	    if (nodep->hasVar() && !nodep->varrefp()) nodep->v3fatalSrc("Null sensitivity variable");
 	}
     }
+    virtual void visit(AstSenGate* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+	if (AstConst* constp = nodep->rhsp()->castConst()) {
+	    if (constp->isZero()) {
+		UINFO(4,"SENGATE(...,0)->NEVER"<<endl);
+		if (onlySenItemInSenTree(nodep)) {
+		    nodep->replaceWith(new AstSenItem(nodep->fileline(), AstSenItem::Never()));
+		    nodep->deleteTree(); nodep=NULL;
+		} else {
+		    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+		}
+	    } else {
+		UINFO(4,"SENGATE(SENITEM,0)->ALWAYS SENITEM"<<endl);
+		AstNode* senitemp = nodep->sensesp()->unlinkFrBack();
+		nodep->replaceWith(senitemp);
+		nodep->deleteTree(); nodep=NULL;
+	    }
+	}
+    }
+
+    struct SenItemCmp {
+	inline bool operator () (AstNodeSenItem* lhsp, AstNodeSenItem* rhsp) const {
+	    if (lhsp->type() < rhsp->type()) return true;
+	    if (lhsp->type() > rhsp->type()) return false;
+	    const AstSenItem* litemp = lhsp->castSenItem();
+	    const AstSenItem* ritemp = rhsp->castSenItem();
+	    if (litemp && ritemp) {
+		// Looks visually better if we keep sorted by name
+		if (litemp->edgeType() < ritemp->edgeType()) return true;
+		if (litemp->edgeType() > ritemp->edgeType()) return false;
+		if (!litemp->varrefp() &&  ritemp->varrefp()) return true;
+		if ( litemp->varrefp() && !ritemp->varrefp()) return false;
+		if (litemp->varrefp() && ritemp->varrefp()) {
+		    if (litemp->varrefp()->name() < ritemp->varrefp()->name()) return true;
+		    if (litemp->varrefp()->name() > ritemp->varrefp()->name()) return false;
+		    // But might be same name with different scopes
+		    if (litemp->varrefp()->varScopep() < ritemp->varrefp()->varScopep()) return true;
+		    if (litemp->varrefp()->varScopep() > ritemp->varrefp()->varScopep()) return false;
+		}
+	    }
+	    return false;
+	}
+    };
+
+    virtual void visit(AstSenTree* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+	if (m_expensive) {
+	    //cout<<endl; nodep->dumpTree(cout,"ssin: ");
+	    // Optimize ideas for the future:
+	    //   SENTREE(... SENGATE(x,a), SENGATE(SENITEM(x),b) ...)  => SENGATE(x,OR(a,b))
+
+	    //   SENTREE(... SENITEM(x),   SENGATE(SENITEM(x),*) ...)  => SENITEM(x)
+	    // Do we need the SENITEM's to be identical?  No because we're
+	    // ORing between them; we just need to insure that the result is at
+	    // least as frequently activating.  So we simply
+	    // SENGATE(SENITEM(x)) -> SENITEM(x), then let it collapse with the
+	    // other SENITEM(x).
+	    {
+		AstUser4InUse	m_inuse4;
+		// Mark x in SENITEM(x)
+		for (AstNodeSenItem* senp = nodep->sensesp()->castNodeSenItem();
+		     senp; senp=senp->nextp()->castNodeSenItem()) {
+		    if (AstSenItem* itemp = senp->castSenItem()) {
+			if (itemp->varrefp() && itemp->varrefp()->varScopep()) {
+			    itemp->varrefp()->varScopep()->user4(1);
+			}
+		    }
+		}
+		// Find x in SENTREE(SENITEM(x))
+		for (AstNodeSenItem* nextp, * senp = nodep->sensesp()->castNodeSenItem();
+		     senp; senp=nextp) {
+		    nextp=senp->nextp()->castNodeSenItem();
+		    if (AstSenGate* gatep = senp->castSenGate()) {
+			if (AstSenItem* itemp = gatep->sensesp()->castSenItem()) {
+			    if (itemp->varrefp() && itemp->varrefp()->varScopep()) {
+				if (itemp->varrefp()->varScopep()->user4()) {
+				    // Found, push this item up to the top
+				    itemp->unlinkFrBack();
+				    nodep->addSensesp(itemp);
+				    gatep->unlinkFrBack()->deleteTree(); gatep=NULL; senp=NULL;
+				}
+			    }
+			}
+		    }
+		}
+	    }
+
+	    // Sort the sensitivity names so "posedge a or b" and "posedge b or a" end up together.
+	    // Also, remove duplicate assignments, and fold POS&NEGs into ANYEDGEs
+	    // Make things a little faster; check first if we need a sort
+	    for (AstNodeSenItem* nextp, * senp = nodep->sensesp()->castNodeSenItem();
+		 senp; senp=nextp) {
+		nextp=senp->nextp()->castNodeSenItem();
+		SenItemCmp cmp;
+		if (nextp && !cmp(senp, nextp)) {
+		    // Something's out of order, sort it
+		    senp = NULL;
+		    vector<AstNodeSenItem*> vec;
+		    for (AstNodeSenItem* senp = nodep->sensesp()->castNodeSenItem(); senp; senp=senp->nextp()->castNodeSenItem()) {
+			vec.push_back(senp);
+		    }
+		    sort(vec.begin(), vec.end(), SenItemCmp());
+		    for (vector<AstNodeSenItem*>::iterator it=vec.begin(); it!=vec.end(); ++it) {
+			(*it)->unlinkFrBack();
+		    }
+		    for (vector<AstNodeSenItem*>::iterator it=vec.begin(); it!=vec.end(); ++it) {
+			nodep->addSensesp(*it);
+		    }
+		    break;
+		}
+	    }
+	    
+	    // Pass2, remove dup edges
+	    for (AstNodeSenItem* nextp, * senp = nodep->sensesp()->castNodeSenItem();
+		 senp; senp=nextp) {
+		nextp=senp->nextp()->castNodeSenItem();
+		AstNodeSenItem* cmpp = nextp;
+		AstSenItem* litemp = senp->castSenItem();
+		AstSenItem* ritemp = cmpp->castSenItem();
+		if (litemp && ritemp) {
+		    if ((litemp->varrefp() && ritemp->varrefp() && litemp->varrefp()->sameTree(ritemp->varrefp()))
+			|| (!litemp->varrefp() && !ritemp->varrefp())) {
+			// We've sorted in the order ANY, BOTH, POS, NEG, so we don't need to try opposite orders
+			if ((   litemp->edgeType()==AstEdgeType::ANYEDGE)   // ANY  or {BOTH|POS|NEG} -> ANY
+			    || (litemp->edgeType()==AstEdgeType::BOTHEDGE)  // BOTH or {POS|NEG} -> BOTH
+			    || (litemp->edgeType()==AstEdgeType::POSEDGE    // POS  or NEG -> BOTH
+				&& ritemp->edgeType()==AstEdgeType::NEGEDGE)
+			    || (litemp->edgeType()==ritemp->edgeType())	// Identical edges
+			    ) {
+			    // Fix edge of old node
+			    if (litemp->edgeType()==AstEdgeType::POSEDGE
+				&& ritemp->edgeType()==AstEdgeType::NEGEDGE)
+				litemp->edgeType(AstEdgeType::BOTHEDGE);
+			    // Remove redundant node
+			    ritemp->unlinkFrBack()->deleteTree(); ritemp=NULL; cmpp=NULL;
+			    // Try to collapse again
+			    nextp=litemp;
+			}
+		    }
+		}
+	    }
+	    //nodep->dumpTree(cout,"ssou: ");
+	}
+    }
 
     //-----
     // Zero elimination
@@ -855,7 +1312,7 @@ private:
 				 new AstAssign(nodep->fileline(),
 					       varrefp, exprp));
 	    m_modp->addStmtp(newinitp);
-	    nodep->unlinkFrBack();  nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree();  nodep=NULL;
 	    // Set the initial value right in the variable so we can constant propagate
 	    AstNode* initvaluep = exprp->cloneTree(false);
 	    varrefp->varp()->initp(initvaluep);
@@ -901,7 +1358,7 @@ private:
 		 && nodep->ifsp() && nodep->elsesp()) {
 	    UINFO(4,"IF(NOT {x})  => IF(x) swapped if/else"<<nodep<<endl);
 	    AstNode* condp = nodep->condp()->castNot()->lhsp()->unlinkFrBackWithNext();
-	    AstNode* ifsp = nodep->ifsp()->unlinkFrBackWithNext();	
+	    AstNode* ifsp = nodep->ifsp()->unlinkFrBackWithNext();
 	    AstNode* elsesp = nodep->elsesp()->unlinkFrBackWithNext();
 	    AstIf* ifp = new AstIf(nodep->fileline(), condp, elsesp, ifsp);
 	    ifp->branchPred(nodep->branchPred().invert());
@@ -922,7 +1379,7 @@ private:
 	    nodep->deleteTree(); nodep=NULL;
 	}
 	else if (0	// Disabled, as vpm assertions are faster without due to short-circuiting
-		 && operandIfIf(nodep)) {  
+		 && operandIfIf(nodep)) {
 	    UINFO(0,"IF({a}) IF({b}) => IF({a} && {b})"<<endl);
 	    AstNodeIf* lowerIfp = nodep->ifsp()->castNodeIf();
 	    AstNode* condp = nodep->condp()->unlinkFrBack();
@@ -938,6 +1395,70 @@ private:
 	}
     }
 
+    virtual void visit(AstDisplay* nodep, AstNUser*) {
+	// Substitute constants into displays.  The main point of this is to
+	// simplify assertion methodologies which call functions with display's.
+	// This eliminates a pile of wide temps, and makes the C a whole lot more readable.
+	nodep->iterateChildren(*this);
+	bool anyconst = false;
+	for (AstNode* argp = nodep->exprsp(); argp; argp=argp->nextp()) {
+	    if (argp->castConst()) { anyconst=true; break; }
+	}
+	if (anyconst) {
+	    //UINFO(9,"  Display in  "<<nodep->text()<<endl);
+	    string dispout = "";
+	    string fmt = "";
+	    bool inPct = false;
+	    AstNode* argp = nodep->exprsp();
+	    for (const char* inp = nodep->text().c_str(); *inp; inp++) {
+		char ch = *inp;   // Breaks with iterators...
+		if (!inPct && ch=='%') {
+		    inPct = true;
+		    fmt = ch;
+		} else if (inPct && isdigit(ch)) {
+		    fmt += ch;
+		} else if (inPct) {
+		    inPct = false;
+		    fmt += ch;
+		    switch (tolower(ch)) {
+		    case '%': break;  // %% - just output a %
+		    case 'm': break;  // %m - auto insert "name"
+		    default:  // Most operators, just move to next argument
+			if (argp) {
+			    AstNode* nextp=argp->nextp();
+			    if (argp && argp->castConst()) { // Convert it
+				string out = argp->castConst()->num().displayed(fmt);
+				UINFO(9,"     DispConst: "<<fmt<<" -> "<<out<<"  for "<<argp<<endl);
+				{   // fmt = out w/ replace % with %% as it must be literal.
+				    fmt = "";
+				    for (string::iterator pos = out.begin(); pos != out.end(); pos++) {
+					if (*pos == '%') fmt += '%';
+					fmt += *pos;
+				    }
+				}
+				argp->unlinkFrBack()->deleteTree();
+			    }
+			    argp=nextp;
+			}
+			break;
+		    } // switch
+		    dispout += fmt;
+		} else {
+		    dispout += ch;
+		}
+	    }
+	    nodep->text(dispout);
+	    //UINFO(9,"  Display out "<<nodep->text()<<endl);
+	}
+    }
+
+    virtual void visit(AstFuncRef* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+	if (m_params) {  // Only parameters force us to do constant function call propagation
+	    replaceWithSimulation(nodep);
+	}
+    }
+
     virtual void visit(AstWhile* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	if (nodep->condp()->isZero()) {
@@ -954,11 +1475,20 @@ private:
     // Below lines are magic expressions processed by astgen
     //  "AstNODETYPE {             # bracket not paren
     //                $accessor_name, ...
-    //                             # ,, gets replaced with a , rather then &&
+    //                             # ,, gets replaced with a , rather than &&
     //	             }" 	   # bracket not paren
-    //    ,"function to call"
-    // or ,"AstREPLACEMENT_TYPE{ $accessor }"
-    // or ,"!   		   # Print line number when matches, so can see operations
+    //    ,"what to call"
+    //
+    // Where "what_to_call" is:
+    //		"function to call"
+    //		"AstREPLACEMENT_TYPE{ $accessor }"
+    //		"!   		# Print line number when matches, so can see operations
+    //		"NEVER"		# Print error message
+    //		"DONE"		# Process of matching did the transform already
+
+    // In the future maybe support more complicated match & replace:
+    //   ("AstOr  {%a, AstAnd{AstNot{%b}, %c}} if %a.width1 if %a==%b",	"AstOr{%a,%c}; %b.delete");
+    // Lhs/rhs would be implied; for non math operations you'd need $lhsp etc.
 
     // Lint Checks
     //    v--- *1* These ops are always first, as we warn before replacing
@@ -1032,6 +1562,8 @@ private:
     TREEOP("AstNodeBiCom{!$lhsp.castConst, $rhsp.castConst}",	"swapSides(nodep)");
     TREEOP("AstNodeBiComAsv{operandAsvConst(nodep)}",	"replaceAsv(nodep)");
     TREEOP("AstNodeBiComAsv{operandAsvSame(nodep)}",	"replaceAsv(nodep)");
+    TREEOP("AstNodeBiComAsv{operandAsvLUp(nodep)}",	"replaceAsvLUp(nodep)");
+    TREEOP("AstNodeBiComAsv{operandAsvRUp(nodep)}",	"replaceAsvRUp(nodep)");
     //    v--- *1* as These ops are always first, as we warn before replacing
     TREEOP1("AstLt   {$lhsp, $rhsp.isZero}",		"replaceNumSigned(nodep,0)");
     TREEOP1("AstGte  {$lhsp, $rhsp.isZero}",		"replaceNumSigned(nodep,1)");
@@ -1048,6 +1580,10 @@ private:
     TREEOP ("AstLogNot{$lhsp.castEqCase}",		"AstNeqCase{$lhsp->op1p(),$lhsp->op2p()}");
     TREEOPV("AstNot   {$lhsp.castNeqCase, $lhsp.width1}","AstEqCase {$lhsp->op1p(),$lhsp->op2p()}");
     TREEOP ("AstLogNot{$lhsp.castNeqCase}",		"AstEqCase {$lhsp->op1p(),$lhsp->op2p()}");
+    TREEOPV("AstNot   {$lhsp.castEqWild, $lhsp.width1}","AstNeqWild{$lhsp->op1p(),$lhsp->op2p()}");
+    TREEOP ("AstLogNot{$lhsp.castEqWild}",		"AstNeqWild{$lhsp->op1p(),$lhsp->op2p()}");
+    TREEOPV("AstNot   {$lhsp.castNeqWild, $lhsp.width1}","AstEqWild {$lhsp->op1p(),$lhsp->op2p()}");
+    TREEOP ("AstLogNot{$lhsp.castNeqWild}",		"AstEqWild {$lhsp->op1p(),$lhsp->op2p()}");
     TREEOPV("AstNot   {$lhsp.castEq, $lhsp.width1}",	"AstNeq {$lhsp->op1p(),$lhsp->op2p()}");
     TREEOP ("AstLogNot{$lhsp.castEq}",			"AstNeq {$lhsp->op1p(),$lhsp->op2p()}");
     TREEOPV("AstNot   {$lhsp.castNeq, $lhsp.width1}",	"AstEq  {$lhsp->op1p(),$lhsp->op2p()}");
@@ -1089,6 +1625,7 @@ private:
     TREEOP("AstXor    {operandsSame($lhsp,,$rhsp)}",	"replaceZero(nodep)");
     TREEOP("AstEq     {operandsSame($lhsp,,$rhsp)}",	"replaceNum(nodep,1)");  // We let X==X -> 1, although in a true 4-state sim it's X.
     TREEOP("AstEqCase {operandsSame($lhsp,,$rhsp)}",	"replaceNum(nodep,1)");
+    TREEOP("AstEqWild {operandsSame($lhsp,,$rhsp)}",	"replaceNum(nodep,1)");
     TREEOP("AstGt     {operandsSame($lhsp,,$rhsp)}",	"replaceZero(nodep)");
     TREEOP("AstGtS    {operandsSame($lhsp,,$rhsp)}",	"replaceZero(nodep)");
     TREEOP("AstGte    {operandsSame($lhsp,,$rhsp)}",	"replaceNum(nodep,1)");
@@ -1099,6 +1636,7 @@ private:
     TREEOP("AstLteS   {operandsSame($lhsp,,$rhsp)}",	"replaceNum(nodep,1)");
     TREEOP("AstNeq    {operandsSame($lhsp,,$rhsp)}",	"replaceZero(nodep)");
     TREEOP("AstNeqCase{operandsSame($lhsp,,$rhsp)}",	"replaceZero(nodep)");
+    TREEOP("AstNeqWild{operandsSame($lhsp,,$rhsp)}",	"replaceZero(nodep)");
     TREEOP("AstLogAnd {operandsSame($lhsp,,$rhsp), $lhsp.width1}",	"replaceWLhs(nodep)");
     TREEOP("AstLogOr  {operandsSame($lhsp,,$rhsp), $lhsp.width1}",	"replaceWLhs(nodep)");
     ///=== Verilog operators
@@ -1129,7 +1667,7 @@ private:
     TREEOPV("AstRedXor{$lhsp->castExtend()}",	"AstRedXor{$lhsp->castExtend()->lhsp()}");
     TREEOPV("AstOneHot{$lhsp.width1}",		"replaceWLhs(nodep)");
     TREEOPV("AstOneHot0{$lhsp.width1}",		"replaceNum(nodep,1)");
-    // Binary AND/OR is faster then logical and/or (usually)
+    // Binary AND/OR is faster than logical and/or (usually)
     TREEOPV("AstLogAnd{$lhsp.width1, $rhsp.width1}", "AstAnd{$lhsp,$rhsp}");
     TREEOPV("AstLogOr {$lhsp.width1, $rhsp.width1}", "AstOr{$lhsp,$rhsp}");
     TREEOPV("AstLogNot{$lhsp.width1}",		    "AstNot{$lhsp}");
@@ -1137,6 +1675,14 @@ private:
     // CONCAT({const},CONCAT({const},{c})) -> CONCAT((constifiedCONC{const|const},{c}))
     TREEOPV("AstConcat{operandConcatMove(nodep)}",	"moveConcat(nodep)");
     TREEOPV("AstConcat{$lhsp.isZero, $rhsp}",		"replaceExtend(nodep, nodep->rhsp())");
+    // Common two-level operations that can be simplified
+    TREEOP ("AstAnd {$lhsp.castOr, $rhsp.castOr, operandAndOrSame(nodep)}",	"replaceAndOr(nodep)");
+    TREEOP ("AstOr  {$lhsp.castAnd,$rhsp.castAnd,operandAndOrSame(nodep)}",	"replaceAndOr(nodep)");
+    TREEOP ("AstOr  {matchOrAndNot(nodep)}",		"DONE");
+    TREEOP ("AstAnd {operandShiftSame(nodep)}",		"replaceShiftSame(nodep)");
+    TREEOP ("AstOr  {operandShiftSame(nodep)}",		"replaceShiftSame(nodep)");
+    TREEOP ("AstXor {operandShiftSame(nodep)}",		"replaceShiftSame(nodep)");
+    TREEOP ("AstXnor{operandShiftSame(nodep)}",		"replaceShiftSame(nodep)");
     // Note can't simplify a extend{extends}, extends{extend}, as the sign bits end up in the wrong places
     TREEOPV("AstExtend {$lhsp.castExtend}",		"replaceExtend(nodep, nodep->lhsp()->castExtend()->lhsp())");
     TREEOPV("AstExtendS{$lhsp.castExtendS}",		"replaceExtend(nodep, nodep->lhsp()->castExtendS()->lhsp())");
@@ -1167,7 +1713,7 @@ private:
 	// Default: Just iterate
 	if (m_required) {
 	    nodep->v3error("Expecting expression to be constant, but can't convert a "
-			   <<nodep->typeName()<<" to constant.");
+			   <<nodep->prettyTypeName()<<" to constant.");
 	} else {
 	    // Calculate the width of this operation
 	    if (m_params && !nodep->width()) {
@@ -1180,8 +1726,11 @@ private:
 
 public:
     // CONSTUCTORS
-    ConstVisitor(bool params, bool required, bool warn, bool cpp) {
-	m_params = params; m_required = required; m_warn=warn; m_cpp=cpp;
+    ConstVisitor(bool params, bool expensive, bool warn, bool cpp) {
+	m_params = params; m_required = params;
+	m_expensive = expensive;
+	m_warn = warn;
+	m_cpp = cpp;
 	m_wremove = true;
 	m_modp = NULL;
 	m_scopep = NULL;
@@ -1198,23 +1747,29 @@ public:
 
 void V3Const::constifyParam(AstNode* nodep) {
     //if (debug()>0) nodep->dumpTree(cout,"  forceConPRE : ");
-    if (!nodep->width()) {
-	V3Width::widthParams(nodep);
-	V3Signed::signedParams(nodep);
+    V3Width::widthSignedIfNotAlready(nodep); // Make sure we've sized everything first
+    ConstVisitor visitor (true,false,false,false);
+    if (AstVar* varp=nodep->castVar()) {
+	// If a var wants to be constified, it's really a param, and
+	// we want the value to be constant.  We aren't passed just the
+	// init value because we need widthing above to handle the var's type.
+	if (varp->initp()) visitor.main(varp->initp());
+    } else {
+	visitor.main(nodep);
     }
-    ConstVisitor visitor (true,true,false,false);
-    visitor.main(nodep);
     // Because we do edits, nodep links may get trashed and core dump this.
     //if (debug()>0) nodep->dumpTree(cout,"  forceConDONE: ");
 }
 
 void V3Const::constifyAll(AstNetlist* nodep) {
+    // Only call from Verilator.cpp, as it uses user#'s
     UINFO(2,__FUNCTION__<<": "<<endl);
-    ConstVisitor visitor (false,false,false,false);
+    ConstVisitor visitor (false,true,false,false);
     visitor.main(nodep);
 }
 
 void V3Const::constifyAllLint(AstNetlist* nodep) {
+    // Only call from Verilator.cpp, as it uses user#'s
     UINFO(2,__FUNCTION__<<": "<<endl);
     ConstVisitor visitor (false,false,true,false);
     visitor.main(nodep);
@@ -1231,3 +1786,7 @@ void V3Const::constifyTree(AstNode* nodep) {
     visitor.main(nodep);
 }
 
+void V3Const::constifyTreeExpensive(AstNode* nodep) {
+    ConstVisitor visitor (false,true,false,false);
+    visitor.main(nodep);
+}

src/V3Const.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Propagate constants across AST
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -40,6 +41,8 @@ public:
     static void constifyCpp(AstNetlist* nodep);
     // Only the current node and lower
     static void constifyTree(AstNode* nodep);
+    // Only the current node and lower, with special SenTree optimization
+    static void constifyTreeExpensive(AstNode* nodep);
 };
 
 #endif // Guard

src/V3Coverage.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Netlist (top level) functions
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -31,15 +31,14 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <map>
 
 #include "V3Global.h"
 #include "V3Coverage.h"
 #include "V3Ast.h"
-#include "V3Const.h"
 
 //######################################################################
 // Coverage state, as a visitor of each AstNode
@@ -47,59 +46,198 @@
 class CoverageVisitor : public AstNVisitor {
 private:
     // TYPES
-    typedef map<FileLine*,int>	FileMap;
+    typedef map<string,int>	FileMap;
 
     // STATE
     bool	m_checkBlock;	// Should this block get covered?
     AstModule*	m_modp;		// Current module to add statement to
+    bool	m_inToggleOff;	// In function/task etc
     FileMap	m_fileps;	// Column counts for each fileline
-   
-    //int debug() { return 9; }
+    string	m_beginHier;	// AstBegin hier name for user coverage points
 
     // METHODS
-    AstCoverInc* newCoverInc(FileLine* fl, const string& type, const string& comment) {
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
+    const char* varIgnoreToggle(AstVar* nodep) {
+	// Return true if this shouldn't be traced
+	// See also similar rule in V3TraceDecl::varIgnoreTrace
+	string prettyName = nodep->prettyName();
+	if (!nodep->isToggleCoverable())
+	    return "Not relevant signal type";
+	if (prettyName.c_str()[0] == '_')
+	    return "Leading underscore";
+	if (prettyName.find("._") != string::npos)
+	    return "Inlined leading underscore";
+	if ((nodep->width()*nodep->arrayElements()) > 256) return "Wide bus/array > 256 bits";
+	// We allow this, though tracing doesn't
+	// if (nodep->arrayp(1)) return "Unsupported: Multi-dimensional array";
+	return NULL;
+    }
+
+    AstCoverInc* newCoverInc(FileLine* fl, const string& hier,
+			     const string& page_prefix, const string& comment) {
+	// For line coverage, we may have multiple if's on one line, so disambiguate if
+	// everything is otherwise identical
+	// (Don't set column otherwise as it may result in making bins not match up with
+	// different types of coverage enabled.)
+	string key = fl->filename()+"\001"+cvtToStr(fl->lineno())+"\001"+hier+"\001"+page_prefix+"\001"+comment;
 	int column = 0;
-	FileMap::iterator it = m_fileps.find(fl);
+	FileMap::iterator it = m_fileps.find(key);
 	if (it == m_fileps.end()) {
-	    m_fileps.insert(make_pair(fl,column+1));
+	    m_fileps.insert(make_pair(key,column+1));
 	} else {
 	    column = (it->second)++;
 	}
 
-	AstCoverDecl* declp = new AstCoverDecl(fl, column, type, comment); 
+	// We could use the basename of the filename to the page, but seems better for code
+	// from an include file to be listed under the module using it rather than the include file.
+	// Note the module name could have parameters appended, we'll consider this
+	// a feature as it allows for each parameterized block to be counted separately.
+	// Someday the user might be allowed to specify a different page suffix
+	string page = page_prefix + "/" + m_modp->prettyName();
+
+	AstCoverDecl* declp = new AstCoverDecl(fl, column, page, comment);
+	declp->hier(hier);
 	m_modp->addStmtp(declp);
 
 	return new AstCoverInc(fl, declp);
     }
 
-    // VISITORS
+    // VISITORS - BOTH
     virtual void visit(AstModule* nodep, AstNUser*) {
 	m_modp = nodep;
 	m_fileps.clear();
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
+
+    // VISITORS - TOGGLE COVERAGE
+    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+	bool oldtog = m_inToggleOff;
+	{
+	    m_inToggleOff = true;
+	    nodep->iterateChildren(*this);
+	}
+	m_inToggleOff = oldtog;
+    }
+    virtual void visit(AstVar* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+	if (m_modp && !m_inToggleOff
+	    && nodep->fileline()->coverageOn() && v3Global.opt.coverageToggle()) {
+	    const char* disablep = varIgnoreToggle(nodep);
+	    if (disablep) {
+		UINFO(4, "    Disable Toggle: "<<disablep<<" "<<nodep<<endl);
+	    } else {
+		UINFO(4, "    Toggle: "<<nodep<<endl);
+		// There's several overall ways to approach this
+		//    Treat like tracing, where a end-of-timestamp action sees all changes
+		//	Works ok, but would be quite slow as need to reform vectors before the calls
+		//    Convert to "always @ (posedge signal[#]) coverinc"
+		//	Would mark many signals as clocks, precluding many later optimizations
+		//    Convert to "if (x & !lastx) CoverInc"
+		//	OK, but we couldn't later detect them to schedule where the IFs get called
+		//    Convert to "AstCoverInc(CoverInc...)"
+		//	We'll do this, and make the if(...) coverinc later.
+
+		// Compute size of the problem
+		int dimensions = 0;
+		for (AstRange* arrayp=nodep->arraysp(); arrayp; arrayp = arrayp->nextp()->castRange()) {
+		    dimensions++;
+		}
+
+		// Add signal to hold the old value
+		string newvarname = (string)"__Vtogcov__"+nodep->shortName();
+		AstVar* chgVarp = new AstVar (nodep->fileline(), AstVarType::MODULETEMP, newvarname, nodep);
+		m_modp->addStmtp(chgVarp);
+
+		// Create bucket for each dimension * bit.
+		// This is necessarily an O(n^2) expansion, which is why
+		// we limit coverage to signals with < 256 bits.
+		vector<int> selects_docs;  selects_docs.resize(dimensions);
+		vector<int> selects_code;  selects_code.resize(dimensions);
+		toggleVarRecurse(nodep, chgVarp, nodep->arraysp(),
+				 0, selects_docs, selects_code );
+	    }
+	}
+    }
+
+    void toggleVarRecurse(AstVar* nodep, AstVar* chgVarp, AstRange* arrayp,
+			  int dimension, vector<int>& selects_docs, vector<int>& selects_code) {
+	if (arrayp) {
+	    for (int index=arrayp->lsbConst(); index<=arrayp->msbConst()+1; index++) {
+		// Handle the next dimension, if any
+		selects_docs[dimension] = index;
+		selects_code[dimension] = index - arrayp->lsbConst();
+		toggleVarRecurse(nodep, chgVarp, arrayp->nextp()->castRange(),
+				 dimension+1, selects_docs, selects_code);
+	    }
+	} else {  // No more arraying - just each bit in the width
+	    if (nodep->rangep()) {
+		for (int bitindex_docs=nodep->lsb(); bitindex_docs<nodep->msb()+1; bitindex_docs++) {
+		    toggleVarBottom(nodep, chgVarp,
+				    dimension, selects_docs, selects_code,
+				    true, bitindex_docs);
+		}
+	    } else {
+		toggleVarBottom(nodep, chgVarp,
+				dimension, selects_docs, selects_code,
+				false, 0);
+	    }
+	}
+    }
+    void toggleVarBottom(AstVar* nodep, AstVar* chgVarp,
+			 int dimension, vector<int>& selects_docs, vector<int>& selects_code,
+			 bool bitsel, int bitindex_docs) {
+	string comment = nodep->name();
+	AstNode* varRefp = new AstVarRef(nodep->fileline(), nodep, false);
+	AstNode* chgRefp = new AstVarRef(nodep->fileline(), chgVarp, true);
+	// Now determine the name of, and how to get to the bit of this slice
+	for (int dim=0; dim<dimension; dim++) {
+	    // Comments are strings, not symbols, so we don't need __BRA__ __KET__ 
+	    comment += "["+cvtToStr(selects_docs[dim])+"]";
+	    varRefp = new AstArraySel(nodep->fileline(), varRefp, selects_code[dim]);
+	    chgRefp = new AstArraySel(nodep->fileline(), chgRefp, selects_code[dim]);
+	}
+	if (bitsel) {
+	    comment += "["+cvtToStr(bitindex_docs)+"]";
+	    int bitindex_code = bitindex_docs - nodep->lsb();
+	    varRefp = new AstSel(nodep->fileline(), varRefp, bitindex_code, 1);
+	    chgRefp = new AstSel(nodep->fileline(), chgRefp, bitindex_code, 1);
+	}
+	AstCoverToggle* newp = new AstCoverToggle (nodep->fileline(),
+						   newCoverInc(nodep->fileline(), "", "v_toggle", comment),
+						   varRefp, chgRefp);
+	m_modp->addStmtp(newp);
+    }
+
+    // VISITORS - LINE COVERAGE
     virtual void visit(AstIf* nodep, AstNUser*) {
 	UINFO(4," IF: "<<nodep<<endl);
 	if (m_checkBlock) {
 	    nodep->ifsp()->iterateAndNext(*this);
-	    if (m_checkBlock && v3Global.opt.coverageLine()) {	// if a "if" branch didn't disable it
+	    if (m_checkBlock
+		&& nodep->fileline()->coverageOn() && v3Global.opt.coverageLine()) {	// if a "if" branch didn't disable it
 		if (!nodep->backp()->castIf()
 		    || nodep->backp()->castIf()->elsesp()!=nodep) {  // Ignore if else; did earlier
 		    UINFO(4,"   COVER: "<<nodep<<endl);
-		    nodep->addIfsp(newCoverInc(nodep->fileline(), "block", "if"));
+		    nodep->addIfsp(newCoverInc(nodep->fileline(), "", "v_line", "if"));
 		}
 	    }
 	    // Don't do empty else's, only empty if/case's
 	    if (nodep->elsesp()) {
 		m_checkBlock = true;
 		nodep->elsesp()->iterateAndNext(*this);
-		if (m_checkBlock && v3Global.opt.coverageLine()) {	// if a "else" branch didn't disable it
+		if (m_checkBlock
+		    && nodep->fileline()->coverageOn() && v3Global.opt.coverageLine()) {	// if a "else" branch didn't disable it
 		    UINFO(4,"   COVER: "<<nodep<<endl);
 		    if (nodep->elsesp()->castIf()) {
-			nodep->addElsesp(newCoverInc(nodep->elsesp()->fileline(), "block", "elsif"));
+			nodep->addElsesp(newCoverInc(nodep->elsesp()->fileline(), "", "v_line", "elsif"));
 		    } else {
-			nodep->addElsesp(newCoverInc(nodep->elsesp()->fileline(), "block", "else"));
+			nodep->addElsesp(newCoverInc(nodep->elsesp()->fileline(), "", "v_line", "else"));
 		    }
 		}
 	    }
@@ -108,22 +246,25 @@ private:
     }
     virtual void visit(AstCaseItem* nodep, AstNUser*) {
 	UINFO(4," CASEI: "<<nodep<<endl);
-	if (m_checkBlock && v3Global.opt.coverageLine()) {
+	if (m_checkBlock
+	    && nodep->fileline()->coverageOn() && v3Global.opt.coverageLine()) {
 	    nodep->bodysp()->iterateAndNext(*this);
 	    if (m_checkBlock) {	// if the case body didn't disable it
 		UINFO(4,"   COVER: "<<nodep<<endl);
-		nodep->addBodysp(newCoverInc(nodep->fileline(), "block", "case"));
+		nodep->addBodysp(newCoverInc(nodep->fileline(), "", "v_line", "case"));
 	    }
 	    m_checkBlock = true;  // Reset as a child may have cleared it
 	}
     }
     virtual void visit(AstPslCover* nodep, AstNUser*) {
 	UINFO(4," PSLCOVER: "<<nodep<<endl);
+	m_checkBlock = true;  // Always do cover blocks, even if there's a $stop
 	nodep->iterateChildren(*this);
 	if (!nodep->coverincp()) {
 	    // Note the name may be overridden by V3Assert processing
-	    nodep->coverincp(newCoverInc(nodep->fileline(), "psl_cover", "cover"));
+	    nodep->coverincp(newCoverInc(nodep->fileline(), m_beginHier, "v_user", "cover"));
 	}
+	m_checkBlock = true;  // Reset as a child may have cleared it
     }
     virtual void visit(AstStop* nodep, AstNUser*) {
 	UINFO(4,"  STOP: "<<nodep<<endl);
@@ -135,9 +276,30 @@ private:
 	    UINFO(4,"  OFF: "<<nodep<<endl);
 	    m_checkBlock = false;
 	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	} else {
+	    if (m_checkBlock) nodep->iterateChildren(*this);
 	}
-	if (m_checkBlock) nodep->iterateChildren(*this);
     }
+    virtual void visit(AstBegin* nodep, AstNUser*) {
+	// Record the hierarchy of any named begins, so we can apply to user
+	// coverage points.  This is because there may be cov points inside
+	// generate blocks; each point should get separate consideration.
+	// (Currently ignored for line coverage, since any generate iteration
+	// covers the code in that line.)
+	string oldHier = m_beginHier;
+	bool oldtog = m_inToggleOff;
+	{
+	    m_inToggleOff = true;
+	    if (nodep->name()!="") {
+		m_beginHier = m_beginHier + (m_beginHier!=""?".":"") + nodep->name();
+	    }
+	    nodep->iterateChildren(*this);
+	}
+	m_beginHier = oldHier;
+	m_inToggleOff = oldtog;
+    }
+
+    // VISITORS - BOTH
     virtual void visit(AstNode* nodep, AstNUser*) {
 	// Default: Just iterate
 	if (m_checkBlock) {
@@ -151,6 +313,8 @@ public:
     CoverageVisitor(AstNetlist* rootp) {
 	// Operate on all modules
 	m_checkBlock = true;
+	m_beginHier = "";
+	m_inToggleOff = false;
 	rootp->iterateChildren(*this);
     }
     virtual ~CoverageVisitor() {}

src/V3Coverage.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Coverage modules/signals together
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3CoverageJoin.cpp

@@ -0,0 +1,139 @@
+//*************************************************************************
+// DESCRIPTION: Verilator: Netlist (top level) functions
+//
+// Code available from: http://www.veripool.org/verilator
+//
+// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
+//
+//*************************************************************************
+//
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
+// redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+//
+// 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.
+//
+//*************************************************************************
+// COVERAGEJOIN TRANSFORMATIONS:
+//	If two COVERTOGGLEs have same VARSCOPE, combine them
+//*************************************************************************
+
+
+#include "config_build.h"
+#include "verilatedos.h"
+#include <cstdio>
+#include <cstdarg>
+#include <unistd.h>
+#include <vector>
+
+#include "V3Global.h"
+#include "V3CoverageJoin.h"
+#include "V3Hashed.h"
+#include "V3Stats.h"
+
+//######################################################################
+// CoverageJoin state, as a visitor of each AstNode
+
+class CoverageJoinVisitor : public AstNVisitor {
+private:
+    // NODE STATE
+    // V3Hashed
+    //  AstCoverToggle->VarRef::user4()	// V3Hashed calculation
+
+    //AstUser4InUse	In V3Hashed
+
+    // TYPES
+    typedef vector<AstCoverToggle*> ToggleList;
+
+    // STATE
+    ToggleList		m_toggleps;	// List of of all AstCoverToggle's
+
+    V3Double0		m_statToggleJoins;	// Statistic tracking
+
+    // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
+    void detectDuplicates() {
+	UINFO(9,"Finding duplicates\n");
+	// Note uses user4
+	V3Hashed  hashed;	// Duplicate code detection
+	// Hash all of the original signals we toggle cover
+	for (ToggleList::iterator it = m_toggleps.begin(); it != m_toggleps.end(); ++it) {
+	    AstCoverToggle* nodep = *it;
+	    hashed.hashAndInsert(nodep->origp());
+	}
+	// Find if there are any duplicates
+	for (ToggleList::iterator it = m_toggleps.begin(); it != m_toggleps.end(); ++it) {
+	    AstCoverToggle* nodep = *it;
+	    if (nodep->backp()) {   // nodep->backp() is null if we already detected it's a duplicate and unlinked it
+		// Want to choose a base node, and keep finding duplicates that are identical
+		// This prevents making chains where a->b, then c->d, then b->c, as we'll find a->b, a->c, a->d directly.
+		while (1) {
+		    V3Hashed::iterator dupit = hashed.findDuplicate(nodep->origp());
+		    if (dupit == hashed.end()) break;
+		    //
+		    AstNode* duporigp = hashed.iteratorNodep(dupit);
+		    // Note hashed will point to the original variable (what's duplicated), not the covertoggle,
+		    // but we need to get back to the covertoggle which is immediately above, so:
+		    AstCoverToggle* removep = duporigp->backp()->castCoverToggle();
+		    if (!removep) nodep->v3fatalSrc("CoverageJoin duplicate of wrong type");
+		    UINFO(8,"  Orig "<<nodep<<" -->> "<<nodep->incp()->declp()<<endl);
+		    UINFO(8,"   dup "<<removep<<" -->> "<<removep->incp()->declp()<<endl);
+		    // The CoverDecl the duplicate pointed to now needs to point to the original's data
+		    // IE the duplicate will get the coverage number from the non-duplicate
+		    AstCoverDecl* datadeclp = nodep->incp()->declp()->dataDeclThisp();
+		    removep->incp()->declp()->dataDeclp (datadeclp);
+		    UINFO(8,"   new "<<removep->incp()->declp()<<endl);
+		    // Mark the found node as a duplicate of the first node
+		    // (Not vice-versa as we have the iterator for the found node)
+		    removep->unlinkFrBack();  pushDeletep(removep); removep=NULL;
+		    // Remove node from comparison so don't hit it again
+		    hashed.erase(dupit);
+		    m_statToggleJoins++;
+		}
+	    }
+	}
+    }
+
+    // VISITORS
+    virtual void visit(AstNetlist* nodep, AstNUser*) {
+	// Find all Coverage's
+	nodep->iterateChildren(*this);
+	// Simplify
+	detectDuplicates();
+    }
+    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+	m_toggleps.push_back(nodep);
+	nodep->iterateChildren(*this);
+    }
+    //--------------------
+    virtual void visit(AstNodeMath* nodep, AstNUser*) {}  // Accelerate
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+    }
+
+public:
+    // CONSTUCTORS
+    CoverageJoinVisitor(AstNetlist* nodep) {
+	nodep->accept(*this);
+    }
+    virtual ~CoverageJoinVisitor() {
+	V3Stats::addStat("Coverage, Toggle points joined", m_statToggleJoins);
+    }
+};
+
+//######################################################################
+// Coverage class functions
+
+void V3CoverageJoin::coverageJoin(AstNetlist* rootp) {
+    UINFO(2,__FUNCTION__<<": "<<endl);
+    CoverageJoinVisitor visitor (rootp);
+}

src/V3CoverageJoin.h

@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: Coverage modules/signals together
+//
+// Code available from: http://www.veripool.org/verilator
+//
+// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
+//
+//*************************************************************************
+//
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
+// redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+//
+// Verilator is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+//*************************************************************************
+
+#ifndef _V3COVERAGEJOIN_H_
+#define _V3COVERAGEJOIN_H_ 1
+#include "config_build.h"
+#include "verilatedos.h"
+#include "V3Error.h"
+#include "V3Ast.h"
+
+//============================================================================
+
+class V3CoverageJoin {
+public:
+    // CREATORS
+    static void coverageJoin(AstNetlist* rootp);
+};
+
+#endif // Guard

src/V3Dead.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Dead code elimination
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -21,13 +21,13 @@
 // DEAD TRANSFORMATIONS:
 //	Remove any unreferenced modules
 //	Remove any unreferenced variables
-//	    
+//
 //*************************************************************************
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <vector>
 #include <map>
@@ -46,7 +46,7 @@ private:
     // VISITORS
     virtual void visit(AstCell* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
-	nodep->modp()->user(nodep->modp()->user() - 1);
+	nodep->modp()->user1(nodep->modp()->user1() - 1);
     }
     //-----
     virtual void visit(AstNodeMath* nodep, AstNUser*) {}  // Accelerate
@@ -71,6 +71,7 @@ private:
     //  AstModule::user()	-> int. Count of number of cells referencing this module.
     //  AstVar::user()		-> int. Count of number of references
     //  AstVarScope::user()	-> int. Count of number of references
+    AstUser1InUse	m_inuser1;
 
     // TYPES
     typedef multimap<AstVarScope*,AstNodeAssign*>	AssignMap;
@@ -81,23 +82,27 @@ private:
     AssignMap			m_assignMap;	// List of all simple assignments for each variable
     bool			m_elimUserVars;	// Allow removal of user's vars
     bool			m_sideEffect;	// Side effects discovered in assign RHS
-    //int debug() { return 9; }
 
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
 
     // VISITORS
     virtual void visit(AstCell* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
-	nodep->modp()->user(nodep->modp()->user() + 1);
+	nodep->modp()->user1(nodep->modp()->user1() + 1);
     }
     virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	if (nodep->varScopep()) {
-	    nodep->varScopep()->user(nodep->varScopep()->user() + 1);
-	    nodep->varScopep()->varp()->user(nodep->varScopep()->varp()->user() + 1);
+	    nodep->varScopep()->user1(nodep->varScopep()->user1() + 1);
+	    nodep->varScopep()->varp()->user1(nodep->varScopep()->varp()->user1() + 1);
 	}
 	if (nodep->varp()) {
-	    nodep->varp()->user(nodep->varp()->user() + 1);
+	    nodep->varp()->user1(nodep->varp()->user1() + 1);
 	}
     }
     virtual void visit(AstVarScope* nodep, AstNUser*) {
@@ -143,7 +148,7 @@ private:
 	    AstModule* nextmodp;
 	    for (AstModule* modp = v3Global.rootp()->modulesp(); modp; modp=nextmodp) {
 		nextmodp = modp->nextp()->castModule();
-		if (modp->level()>2	&& modp->user()==0) {
+		if (modp->level()>2	&& modp->user1()==0) {
 		    // > 2 because L1 is the wrapper, L2 is the top user module
 		    UINFO(4,"  Dead module "<<modp<<endl);
 		    // And its children may now be killable too; correct counts
@@ -164,7 +169,7 @@ private:
 	// Delete any unused varscopes
 	for (vector<AstVarScope*>::iterator it = m_vscsp.begin(); it!=m_vscsp.end(); ++it) {
 	    AstVarScope* vscp = *it;
-	    if (vscp->user() == 0 && canElim(vscp->varp())) {
+	    if (vscp->user1() == 0 && canElim(vscp->varp())) {
 		UINFO(4,"  Dead "<<vscp<<endl);
 		pair <AssignMap::iterator,AssignMap::iterator> eqrange = m_assignMap.equal_range(vscp);
 		for (AssignMap::iterator it = eqrange.first; it != eqrange.second; ++it) {
@@ -176,7 +181,7 @@ private:
 	    }
 	}
 	for (vector<AstVar*>::iterator it = m_varsp.begin(); it!=m_varsp.end(); ++it) {
-	    if ((*it)->user() == 0 && canElim((*it))) {
+	    if ((*it)->user1() == 0 && canElim((*it))) {
 		UINFO(4,"  Dead "<<(*it)<<endl);
 		(*it)->unlinkFrBack()->deleteTree(); (*it)=NULL;
 	    }
@@ -189,7 +194,6 @@ public:
 	m_elimUserVars = elimUserVars;
 	m_sideEffect = false;
 	// Operate on whole netlist
-	AstNode::userClearTree();	// userp() used on entire tree
 	nodep->accept(*this);
 	deadCheckVar();
 	// Modules after vars, because might be vars we delete inside a mod we delete

src/V3Dead.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Dead branch elimination
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3Delayed.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Add temporaries, such as for delayed nodes
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,9 +19,9 @@
 //
 //*************************************************************************
 // V3Delayed's Transformations:
-//		
+//
 // Each module:
-//	Replace ASSIGNDLY var, exp 
+//	Replace ASSIGNDLY var, exp
 //	    With   ASSIGNDLY newvar, exp
 //	    At top of block:  VAR  newvar
 //	    At bottom of block: ASSIGNW var newvar
@@ -54,8 +54,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 #include <map>
@@ -73,17 +73,21 @@ class DelayedVisitor : public AstNVisitor {
 private:
     // NODE STATE
     // Cleared each module:
-    //  AstVarScope::userp()	-> AstVarScope*.  Points to temp var created.
+    //  AstVarScope::user1p()	-> AstVarScope*.  Points to temp var created.
     //  AstVarScope::user2p()	-> AstActive*.  Points to activity block of signal
     //  AstVarScope::user4p()	-> AstAlwaysPost*.  Post block for this variable
+    //  AstVar::user1()		-> VarUsage. Tracks delayed vs non-delayed usage
     //  AstVar::user2()		-> bool.  Set true if already made warning
-    //  AstVar::user3()		-> VarUsage. Tracks delayed vs non-delayed usage
     //  AstVar::user4()		-> int.   Vector number, for assignment creation
     //  AstVarRef::user2()	-> bool.  Set true if already processed
     //  AstAlwaysPost::user4()	-> AstIf*.  Last IF (__Vdlyvset__) created under this AlwaysPost
     // Cleared each scope:
-    //  AstAssignDly::user5()	-> AstVarScope*.  __Vdlyvset__ created for this assign
-    //  AstAlwaysPost::user5()	-> AstVarScope*.  __Vdlyvset__ last referenced in IF
+    //  AstAssignDly::user3()	-> AstVarScope*.  __Vdlyvset__ created for this assign
+    //  AstAlwaysPost::user3()	-> AstVarScope*.  __Vdlyvset__ last referenced in IF
+    AstUser1InUse	m_inuser1;
+    AstUser2InUse	m_inuser2;
+    AstUser3InUse	m_inuser3;
+    AstUser4InUse	m_inuser4;
 
     enum VarUsage { VU_NONE=0, VU_DLY=1, VU_NONDLY=2 };
 
@@ -98,30 +102,23 @@ private:
     VarMap		m_modVarMap;	// Table of new var names created under module
     V3Double0		m_statSharedSet;// Statistic tracking
 
-    //static int debug() { return 9; }
 
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     void markVarUsage(AstVar* nodep, uint32_t flags) {
 	//UINFO(4," MVU "<<flags<<" "<<nodep<<endl);
-	nodep->user3( nodep->user3() | flags );
-	if ((nodep->user3() & VU_DLY) && (nodep->user3() & VU_NONDLY)) {
+	nodep->user1( nodep->user1() | flags );
+	if ((nodep->user1() & VU_DLY) && (nodep->user1() & VU_NONDLY)) {
 	    nodep->v3warn(BLKANDNBLK,"Unsupported: Blocked and non-blocking assignments to same variable: "<<nodep->prettyName());
 	}
     }
     AstVarScope* createVarSc(AstVarScope* oldvarscp, string name, int width/*0==fromoldvar*/) {
 	// Because we've already scoped it, we may need to add both the AstVar and the AstVarScope
-	AstRange* rangep = NULL;
-	if (width==0) {
-	    rangep = new AstRange(oldvarscp->fileline(),
-				  oldvarscp->varp()->msb(),
-				  oldvarscp->varp()->lsb());
-	} else if (width==1) {
-	    rangep = NULL;
-	} else {
-	    rangep = new AstRange(oldvarscp->fileline(),
-				  width-1, 0);
-	}
-
 	if (!oldvarscp->scopep()) oldvarscp->v3fatalSrc("Var unscoped");
 	AstVar* varp;
 	AstModule* addmodp = oldvarscp->scopep()->modp();
@@ -131,6 +128,17 @@ private:
 	    // Created module's AstVar earlier under some other scope
 	    varp = iter->second;
 	} else {
+	    AstRange* rangep = NULL;
+	    if (width==0) {
+		rangep = new AstRange(oldvarscp->fileline(),
+				      oldvarscp->varp()->msb(),
+				      oldvarscp->varp()->lsb());
+	    } else if (width==1) {
+		rangep = NULL;
+	    } else {
+		rangep = new AstRange(oldvarscp->fileline(),
+				      width-1, 0);
+	    }
 	    varp = new AstVar (oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, rangep);
 	    if (width==0) varp->widthSignedFrom(oldvarscp);
 	    addmodp->addStmtp(varp);
@@ -181,7 +189,7 @@ private:
 		dimreadps.push_front(dimp);
 	    } else {
 		string bitvarname = (string("__Vdlyvdim")+cvtToStr(dimension)
-				     +"__"+oldvarp->shortName()+"__"+cvtToStr(modVecNum));
+				     +"__"+oldvarp->shortName()+"__v"+cvtToStr(modVecNum));
 		AstVarScope* bitvscp = createVarSc(varrefp->varScopep(), bitvarname, dimp->width());
 		AstAssign* bitassignp
 		    = new AstAssign (nodep->fileline(),
@@ -199,7 +207,7 @@ private:
 	    if (bitselp->fromp()->castConst()) {// vlsb = constant, can just push constant into where we use it
 		bitreadp = lsbvaluep;
 	    } else {
-		string bitvarname = (string("__Vdlyvlsb__")+oldvarp->shortName()+"__"+cvtToStr(modVecNum));
+		string bitvarname = (string("__Vdlyvlsb__")+oldvarp->shortName()+"__v"+cvtToStr(modVecNum));
 		AstVarScope* bitvscp = createVarSc(varrefp->varScopep(), bitvarname, lsbvaluep->width());
 		AstAssign* bitassignp = new AstAssign (nodep->fileline(),
 						       new AstVarRef(nodep->fileline(), bitvscp, true),
@@ -214,7 +222,7 @@ private:
 	if (nodep->rhsp()->castConst()) {	// vval = constant, can just push constant into where we use it
 	    valreadp = nodep->rhsp()->unlinkFrBack();
 	} else {
-	    string valvarname = (string("__Vdlyvval__")+oldvarp->shortName()+"__"+cvtToStr(modVecNum));
+	    string valvarname = (string("__Vdlyvval__")+oldvarp->shortName()+"__v"+cvtToStr(modVecNum));
 	    AstVarScope* valvscp = createVarSc(varrefp->varScopep(), valvarname, nodep->rhsp()->width());
 	    newlhsp = new AstVarRef(nodep->fileline(), valvscp, true);
 	    valreadp = new AstVarRef(nodep->fileline(), valvscp, false);
@@ -224,16 +232,16 @@ private:
 	bool sharedVset = false;
 	AstVarScope* setvscp;
 
-	if (nodep->user5p()) {
+	if (nodep->user3p()) {
 	    // Simplistic optimization.  If the previous statement in same scope was also a =>,
-	    // then we told this nodep->user5 we can use its Vdlyvset rather then making a new one.
+	    // then we told this nodep->user3 we can use its Vdlyvset rather than making a new one.
 	    // This is good for code like:
 	    //    for (i=0; i<5; i++)  vector[i] <= something;
 	    sharedVset = true;
-	    setvscp = nodep->user5p()->castNode()->castVarScope();
+	    setvscp = nodep->user3p()->castNode()->castVarScope();
 	    m_statSharedSet++;
 	} else {  // Create new one
-	    string setvarname = (string("__Vdlyvset__")+oldvarp->shortName()+"__"+cvtToStr(modVecNum));
+	    string setvarname = (string("__Vdlyvset__")+oldvarp->shortName()+"__v"+cvtToStr(modVecNum));
 	    setvscp = createVarSc(varrefp->varScopep(), setvarname, 1);
 	    AstAssignPre* setinitp
 		= new AstAssignPre (nodep->fileline(),
@@ -248,7 +256,7 @@ private:
 	    nodep->addNextHere(setassignp);
 	}
 	if (m_nextDlyp) {  // Tell next assigndly it can share the variable
-	    m_nextDlyp->user5p(setvscp);
+	    m_nextDlyp->user3p(setvscp);
 	}
 	//
 	// Create ALWAYSPOST for delayed variable
@@ -270,12 +278,12 @@ private:
 	AstAlwaysPost* finalp = varrefp->varScopep()->user4p()->castNode()->castAlwaysPost();
 	if (!finalp) {
 	    finalp = new AstAlwaysPost(nodep->fileline(), NULL/*sens*/, NULL/*body*/);
-	    UINFO(9,"     Created "<<finalp<<endl); 
+	    UINFO(9,"     Created "<<finalp<<endl);
 	    m_activep->addStmtsp(finalp);
 	    varrefp->varScopep()->user4p(finalp);
 	}
 	AstIf* postLogicp;
-	if (finalp->user5p()->castNode() == setvscp) {
+	if (finalp->user3p()->castNode() == setvscp) {
 	    // Optimize as above; if sharing Vdlyvset *ON SAME VARIABLE*,
 	    // we can share the IF statement too
 	    postLogicp = finalp->user4p()->castNode()->castIf();
@@ -285,9 +293,9 @@ private:
 				    new AstVarRef(nodep->fileline(), setvscp, false),
 				    NULL,
 				    NULL);
-	    UINFO(9,"     Created "<<postLogicp<<endl); 
+	    UINFO(9,"     Created "<<postLogicp<<endl);
 	    finalp->addBodysp(postLogicp);
-	    finalp->user5p(setvscp);	// Remember IF's vset variable
+	    finalp->user3p(setvscp);	// Remember IF's vset variable
 	    finalp->user4p(postLogicp);	// and the associated IF, as we may be able to reuse it
 	}
 	postLogicp->addIfsp(new AstAssign(nodep->fileline(), selectsp, valreadp));
@@ -299,15 +307,11 @@ private:
     virtual void visit(AstNetlist* nodep, AstNUser*) {
 	//VV*****  We reset all userp() on the netlist
 	m_modVarMap.clear();
-	AstNode::userClearTree();
-	AstNode::user2ClearTree();
-	AstNode::user3ClearTree();
-	AstNode::user4ClearTree();
 	nodep->iterateChildren(*this);
     }
     virtual void visit(AstScope* nodep, AstNUser*) {
 	UINFO(4," MOD   "<<nodep<<endl);
-	AstNode::user5ClearTree();
+	AstNode::user3ClearTree();
 	nodep->iterateChildren(*this);
     }
     virtual void visit(AstCFunc* nodep, AstNUser*) {
@@ -331,7 +335,7 @@ private:
 		&& nodep->lhsp()->castSel()->fromp()->castArraySel())) {
 	    AstNode* lhsp = nodep->lhsp()->unlinkFrBack();
 	    AstNode* newlhsp = createDlyArray(nodep, lhsp);
-	    if (m_inLoop) nodep->v3error("Unsupported: Delayed assignment to array inside for loops (non-delayed is ok - see docs)");
+	    if (m_inLoop) nodep->v3warn(BLKLOOPINIT,"Unsupported: Delayed assignment to array inside for loops (non-delayed is ok - see docs)");
 	    if (newlhsp) {
 		nodep->lhsp(newlhsp);
 	    } else {
@@ -348,7 +352,7 @@ private:
     virtual void visit(AstVarRef* nodep, AstNUser*) {
 	if (!nodep->user2()) {  // Not done yet
 	    nodep->user2(true);
-	    
+
 	    if (m_inDly && nodep->lvalue()) {
 		UINFO(4,"AssignDlyVar: "<<nodep<<endl);
 		markVarUsage(nodep->varp(), VU_DLY);
@@ -356,7 +360,7 @@ private:
 		if (!m_activep->hasClocked()) nodep->v3error("Internal: Blocking <= assignment in non-clocked block, should have converted in V3Active");
 		AstVarScope* oldvscp = nodep->varScopep();
 		if (!oldvscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp\n");
-		AstVarScope* dlyvscp = oldvscp->userp()->castNode()->castVarScope();
+		AstVarScope* dlyvscp = oldvscp->user1p()->castNode()->castVarScope();
 		if (dlyvscp) {  // Multiple use of delayed variable
 		    AstActive* oldactivep = dlyvscp->user2p()->castNode()->castActive();
 		    if (!oldactivep) nodep->v3fatalSrc("<= old dly assignment not put under sensitivity block");
@@ -372,8 +376,8 @@ private:
 			UINFO(4,"  Act: "<<m_activep<<endl);
 			UINFO(4,"  Act: "<<oldactivep<<endl);
 			// Make a new sensitivity list, which is the combination of both blocks
-			AstSenItem* sena = m_activep->sensesp()->sensesp()->cloneTree(true)->castSenItem();
-			AstSenItem* senb = oldactivep->sensesp()->sensesp()->cloneTree(true)->castSenItem();
+			AstNodeSenItem* sena = m_activep->sensesp()->sensesp()->cloneTree(true);
+			AstNodeSenItem* senb = oldactivep->sensesp()->sensesp()->cloneTree(true);
 			AstSenTree* treep = new AstSenTree(m_activep->fileline(), sena);
 			if (senb) treep->addSensesp(senb);
 			if (AstSenTree* storep = oldactivep->sensesStorep()) {
@@ -396,13 +400,13 @@ private:
 					     new AstVarRef(nodep->fileline(), oldvscp, true),
 					     new AstVarRef(nodep->fileline(), dlyvscp, false));
 		    postp->lhsp()->user2(true);	// Don't detect this assignment
-		    oldvscp->userp(dlyvscp);  // So we can find it later
+		    oldvscp->user1p(dlyvscp);  // So we can find it later
 		    // Make new ACTIVE with identical sensitivity tree
 		    AstActive* newactp = new AstActive (nodep->fileline(), "sequentdly",
 							m_activep->sensesp());
 		    newactp->addStmtsp(prep);	// Add to FRONT of statements
 		    newactp->addStmtsp(postp);
-		    m_activep->addNext(newactp);					
+		    m_activep->addNext(newactp);
 		    dlyvscp->user2p(newactp);
 		}
 		AstVarRef* newrefp = new AstVarRef(nodep->fileline(), dlyvscp, true);
@@ -412,6 +416,7 @@ private:
 	    else if (!m_inDly && nodep->lvalue()) {
 		//UINFO(9,"NBA "<<nodep<<endl);
 		if (!m_inInitial) {
+		    UINFO(4,"AssignNDlyVar: "<<nodep<<endl);
 		    markVarUsage(nodep->varp(), VU_NONDLY);
 		}
 	    }
@@ -419,7 +424,7 @@ private:
     }
 
     virtual void visit(AstNodeFor* nodep, AstNUser*) {
-	nodep->v3fatalSrc("For statements should have been converted to while statements in V3Unroll\n");
+	nodep->v3fatalSrc("For statements should have been converted to while statements in V3Begin\n");
     }
     virtual void visit(AstWhile* nodep, AstNUser*) {
 	bool oldloop = m_inLoop;

src/V3Delayed.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Pre C-Emit stage changes
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3Depth.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Prevent very deep expressions
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Depth's Transformations:
-//		
+//
 // Each module:
 //	For each wide OP, assign a temporary variable.
 //	For each deep expression, assign expression to temporary.
@@ -30,8 +30,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 
@@ -40,7 +40,6 @@
 #include "V3Ast.h"
 
 //######################################################################
-// Depth state, as a visitor of each AstNode
 
 class DepthVisitor : public AstNVisitor {
 private:
@@ -53,19 +52,18 @@ private:
     int			m_depth;	// How deep in an expression
     int			m_maxdepth;	// Maximum depth in an expression
 
-    //int debug() { return 9; }
-
-    // MSVC++ has a limit of 100 parenthesis.  We have some operator
-    // defines that use 2 parens.  Thus we can't have a expression deeper
-    // then 50 operators.  We'll add some margin though.
-    enum en { MAX_EXPR_DEPTH = 40 };	// Expressions deeper then this need temp
-
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     void createDeepTemp(AstNode* nodep) {
 	UINFO(6,"  Deep  "<<nodep<<endl);
 	//if (debug()>=9) nodep->dumpTree(cout,"deep:");
 
-	string newvarname = ((string)"__Vdeeptemp__"+cvtToStr(m_modp->varNumGetInc()));
+	string newvarname = ((string)"__Vdeeptemp"+cvtToStr(m_modp->varNumGetInc()));
 	AstVar* varp = new AstVar (nodep->fileline(), AstVarType::STMTTEMP, newvarname,
 				   // Width, not widthMin, as we may be in middle of BITSEL expression which
 				   // though it's one bit wide, needs the mask in the upper bits.
@@ -92,6 +90,7 @@ private:
 	m_modp = nodep;
 	m_funcp = NULL;
 	nodep->iterateChildren(*this);
+	m_modp = NULL;
     }
     virtual void visit(AstCFunc* nodep, AstNUser*) {
 	m_funcp = nodep;
@@ -114,13 +113,15 @@ private:
     virtual void visit(AstNodeTermop* nodep, AstNUser*) {
     }
     virtual void visit(AstNodeMath* nodep, AstNUser*) {
-	m_depth++;
+	// We have some operator defines that use 2 parens, so += 2.
+	m_depth += 2;
 	if (m_depth>m_maxdepth) m_maxdepth=m_depth;
-	nodep->iterateChildren(*this); 
-	m_depth--;
+	nodep->iterateChildren(*this);
+	m_depth -= 2;
 
-	if ((m_maxdepth-m_depth) > MAX_EXPR_DEPTH
-	    && m_stmtp
+	if (m_stmtp
+	    && (v3Global.opt.compLimitParens() >= 1)	// Else compiler doesn't need it
+	    && (m_maxdepth-m_depth) > v3Global.opt.compLimitParens()
 	    && !nodep->backp()->castNodeStmt()  // Not much point if we're about to use it
 	    ) {
 	    m_maxdepth = m_depth;
@@ -137,11 +138,6 @@ private:
 	    m_funcp->isStatic(false);
 	}
     }
-    virtual void visit(AstCoverInc* nodep, AstNUser*) {
-	// OPTIMIZE: For now this needs this->__Vcoverage, but could be globalized
-	needNonStaticFunc(nodep);
-	visitStmt(nodep);
-    }
     virtual void visit(AstUCFunc* nodep, AstNUser*) {
 	needNonStaticFunc(nodep);
 	nodep->iterateChildren(*this);
@@ -167,20 +163,15 @@ public:
 	m_depth=0;
 	m_maxdepth=0;
 	//
-	AstNode::userClearTree();	// userp() used on entire tree
 	nodep->accept(*this);
     }
     virtual ~DepthVisitor() {}
 };
 
-//----------------------------------------------------------------------
-// Top loop
-
 //######################################################################
 // Depth class functions
 
 void V3Depth::depthAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    // We must do it in bottom-up module
     DepthVisitor visitor (nodep);
 }

src/V3Depth.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Prevent very deep expressions
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3DepthBlock.cpp

@@ -0,0 +1,144 @@
+//*************************************************************************
+// DESCRIPTION: Verilator: Prevent very deep expressions
+//
+// Code available from: http://www.veripool.org/verilator
+//
+// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
+//
+//*************************************************************************
+//
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
+// redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+//
+// 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.
+//
+//*************************************************************************
+// V3DepthBlock's Transformations:
+//
+// Each module:
+//	For each deep block, create cfunc including that block.
+//
+//*************************************************************************
+
+#include "config_build.h"
+#include "verilatedos.h"
+#include <cstdio>
+#include <cstdarg>
+#include <unistd.h>
+#include <algorithm>
+
+#include "V3Global.h"
+#include "V3DepthBlock.h"
+#include "V3Ast.h"
+#include "V3EmitCBase.h"
+
+//######################################################################
+
+class DepthBlockVisitor : public AstNVisitor {
+private:
+    // NODE STATE
+
+    // STATE
+    AstModule*		m_modp;		// Current module
+    AstCFunc*		m_funcp;	// Current function
+    int			m_depth;	// How deep in an expression
+    int			m_deepNum;	// How many functions made
+
+    // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
+    AstCFunc* createDeepFunc(AstNode* nodep) {
+	AstNRelinker relinkHandle;
+	nodep->unlinkFrBack(&relinkHandle);
+	// Create function
+	string name = m_funcp->name()+"__deep"+cvtToStr(++m_deepNum);
+	AstCFunc* funcp = new AstCFunc(nodep->fileline(), name, NULL);
+	funcp->argTypes(EmitCBaseVisitor::symClassVar());
+	funcp->symProlog(true);
+	funcp->slow(m_funcp->slow());
+	funcp->addStmtsp(nodep);
+	m_modp->addStmtp(funcp);
+	// Call it at the point where the body was removed from
+	AstCCall* callp = new AstCCall(nodep->fileline(), funcp);
+	callp->argTypes("vlSymsp");
+	UINFO(6,"      New "<<callp<<endl);
+	//
+	relinkHandle.relink(callp);
+	return funcp;
+    }
+
+    // VISITORS
+    virtual void visit(AstModule* nodep, AstNUser*) {
+	UINFO(4," MOD   "<<nodep<<endl);
+	m_modp = nodep;
+	m_deepNum = 0;
+	nodep->iterateChildren(*this);
+	m_modp = NULL;
+    }
+    virtual void visit(AstCFunc* nodep, AstNUser*) {
+	// We recurse into this.
+	int lastDepth = m_depth;
+	AstCFunc* lastFuncp = m_funcp;
+	{
+	    m_depth = 0;
+	    m_funcp = nodep;
+	    nodep->iterateChildren(*this);
+	}
+	m_depth = lastDepth;
+	m_funcp = lastFuncp;
+    }
+    void visitStmt(AstNodeStmt* nodep) {
+	m_depth++;
+	if (m_depth > v3Global.opt.compLimitBlocks()
+	    && !nodep->castCCall()) {   // Already done
+	    UINFO(4, "DeepBlocks "<<m_depth<<" "<<nodep<<endl);
+	    AstNode* backp = nodep->backp();  // Only for debug
+	    if (debug()>=9) backp->dumpTree(cout,"-   pre : ");
+	    AstCFunc* funcp = createDeepFunc(nodep);
+	    funcp->accept(*this);
+	    if (debug()>=9) backp->dumpTree(cout,"-   post: ");
+	    if (debug()>=9) funcp->dumpTree(cout,"-   func: ");
+	} else {
+	    nodep->iterateChildren(*this);
+	}
+	m_depth--;
+    }
+    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+	visitStmt(nodep);
+    }
+
+    virtual void visit(AstNodeMath* nodep, AstNUser*) {}  // Accelerate
+    //--------------------
+    // Default: Just iterate
+    virtual void visit(AstVar* nodep, AstNUser*) {}	// Don't hit varrefs under vars
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+    }
+
+public:
+    // CONSTUCTORS
+    DepthBlockVisitor(AstNode* nodep) {
+	m_modp=NULL;
+	m_depth=0;
+	//
+	nodep->accept(*this);
+    }
+    virtual ~DepthBlockVisitor() {}
+};
+
+//######################################################################
+// DepthBlock class functions
+
+void V3DepthBlock::depthBlockAll(AstNetlist* nodep) {
+    UINFO(2,__FUNCTION__<<": "<<endl);
+    DepthBlockVisitor visitor (nodep);
+}

src/V3DepthBlock.h

@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: Prevent very deep expressions
+//
+// Code available from: http://www.veripool.org/verilator
+//
+// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
+//
+//*************************************************************************
+//
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
+// redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+//
+// Verilator is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+//*************************************************************************
+
+#ifndef _V3DEPTHBLOCK_H_
+#define _V3DEPTHBLOCK_H_ 1
+#include "config_build.h"
+#include "verilatedos.h"
+#include "V3Error.h"
+#include "V3Ast.h"
+
+//============================================================================
+
+class V3DepthBlock {
+public:
+    static void depthBlockAll(AstNetlist* nodep);
+};
+
+#endif // Guard

src/V3Descope.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Rename scope references to module-local references
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -24,13 +24,13 @@
 //		Change varref name() to be relative to current module
 //		Remove varScopep()
 //	    This allows for better V3Combine'ing.
-//	    
+//
 //*************************************************************************
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <map>
 
@@ -46,6 +46,7 @@ private:
     // NODE STATE
     //  Cleared entire netlist
     //   AstCFunc::user()		// bool.  Indicates processing completed
+    AstUser1InUse	m_inuser1;
 
     // TYPES
     typedef multimap<string,AstCFunc*>	FuncMmap;
@@ -55,9 +56,14 @@ private:
     AstScope*		m_scopep;	// Current scope
     bool		m_needThis;	// Add thisp to function
     FuncMmap		m_modFuncs;	// Name of public functions added
-    //int debug() { return 9; }
 
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     string descopedName(AstScope* scopep, bool& hierThisr, AstVar* varp=NULL) {
 	UASSERT(scopep, "Var/Func not scoped\n");
 	hierThisr = true;
@@ -107,7 +113,7 @@ private:
 	    if (moreOfSame1) {
 		// Multiple functions under this name, need a wrapper function
 		UINFO(6,"  Wrapping "<<name<<" multifuncs\n");
-		AstCFunc* newfuncp = topFuncp->cloneTree(false)->castCFunc();
+		AstCFunc* newfuncp = topFuncp->cloneTree(false);
 		if (newfuncp->initsp())  newfuncp->initsp()->unlinkFrBackWithNext()->deleteTree();
 		if (newfuncp->stmtsp())  newfuncp->stmtsp()->unlinkFrBackWithNext()->deleteTree();
 		if (newfuncp->finalsp()) newfuncp->finalsp()->unlinkFrBackWithNext()->deleteTree();
@@ -178,6 +184,7 @@ private:
 	m_modFuncs.clear();
 	nodep->iterateChildren(*this);
 	makePublicFuncWrappers();
+	m_modp = NULL;
     }
     virtual void visit(AstScope* nodep, AstNUser*) {
 	m_scopep = nodep;
@@ -210,10 +217,10 @@ private:
 	// nodep->funcp()->scopep(NULL);
     }
     virtual void visit(AstCFunc* nodep, AstNUser*) {
-	if (!nodep->user()) {
+	if (!nodep->user1()) {
 	    m_needThis = false;
 	    nodep->iterateChildren(*this);
-	    nodep->user(true);
+	    nodep->user1(true);
 	    if (m_needThis) {
 		nodep->v3fatalSrc("old code");
 		// Really we should have more node types for backend optimization of this stuff
@@ -245,7 +252,6 @@ public:
 	m_modp = NULL;
 	m_scopep = NULL;
 	m_needThis = false;
-	AstNode::userClearTree();
 	nodep->accept(*this);
     }
     virtual ~DescopeVisitor() {}

src/V3Descope.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Rename scope references to module-local references
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3EmitC.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Emit C++ code for module tree
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -31,6 +32,7 @@
 class V3EmitC {
 public:
     static void emitc();
+    static void emitcInlines();
     static void emitcSyms();
     static void emitcTrace();
 };

src/V3EmitCBase.h

@@ -1,16 +1,17 @@
-// $Id$ -*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Emit C++ for tree
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -24,10 +25,10 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
-#include <math.h>
+#include <cmath>
 
 #include "V3Global.h"
 #include "V3File.h"
@@ -42,7 +43,7 @@ public:
     V3OutCFile(const string& filename) : V3OutFile(filename) {
 	resetPrivate();
     }
-    virtual ~V3OutCFile() {};
+    virtual ~V3OutCFile() {}
     virtual void putsCellDecl(const string& classname, const string& cellname) {
 	this->printf("%-19s\t%s;\n",
 		     (classname + "*").c_str(),cellname.c_str());
@@ -65,30 +66,36 @@ public:
 class V3OutScFile : public V3OutCFile {
 public:
     V3OutScFile(const string& filename) : V3OutCFile(filename) {}
-    virtual ~V3OutScFile() {};
+    virtual ~V3OutScFile() {}
     virtual void putsHeader() { puts("// Verilated -*- SystemC -*-\n"); }
-    virtual void putsIntTopInclude() { puts("#include \"systemc.h\"\n"); }
+    virtual void putsIntTopInclude() {
+	puts("#include \"systemc.h\"\n");
+	puts("#include \"verilatedsc.h\"\n");
+    }
 };
 
 class V3OutSpFile : public V3OutCFile {
 public:
     V3OutSpFile(const string& filename) : V3OutCFile(filename) {}
-    virtual ~V3OutSpFile() {};
+    virtual ~V3OutSpFile() {}
     virtual void putsHeader() { puts("// Verilated -*- SystemC -*-\n"); }
-    virtual void putsIntTopInclude() { puts("#include \"systemperl.h\"\n"); }
+    virtual void putsIntTopInclude() {
+	puts("#include \"systemperl.h\"\n");
+	puts("#include \"verilatedsc.h\"\n");
+    }
 };
 
-class V3OutVFile : public V3OutCFile {
+class V3OutVFile : public V3OutFile {
 public:
-    V3OutVFile(const string& filename) : V3OutCFile(filename) {}
-    virtual ~V3OutVFile() {};
+    V3OutVFile(const string& filename) : V3OutFile(filename) {}
+    virtual ~V3OutVFile() {}
     virtual void putsHeader() { puts("// Verilated -*- Verilog -*-\n"); }
 };
 
 class V3OutMkFile : public V3OutFile {
 public:
     V3OutMkFile(const string& filename) : V3OutFile(filename) {}
-    virtual ~V3OutMkFile() {};
+    virtual ~V3OutMkFile() {}
     virtual void putsHeader() { puts("# Verilated -*- Makefile -*-\n"); }
     // No automatic indentation yet.
     void puts(const char* strg) { putsNoTracking(strg); }
@@ -103,9 +110,10 @@ public:
     // STATE
     V3OutCFile*	m_ofp;
     // METHODS
-    V3OutCFile*	ofp() const { return m_ofp; };
+    V3OutCFile*	ofp() const { return m_ofp; }
     void puts(const string& str) { ofp()->puts(str); }
     void putbs(const string& str) { ofp()->putbs(str); }
+    void putsQuoted(const string& str) { ofp()->putsQuoted(str); }
     bool optSystemC() { return v3Global.opt.systemC(); }
     bool optSystemPerl() { return v3Global.opt.systemPerl(); }
     static string symClassName() { return v3Global.opt.prefix()+"__Syms"; }
@@ -137,7 +145,7 @@ public:
 };
 
 //######################################################################
-// Fileize state, as a visitor of each AstNode
+// Count operations under the given node, as a visitor of each AstNode
 
 class EmitCBaseCounterVisitor : public AstNVisitor {
 private:

src/V3EmitCInlines.cpp

@@ -0,0 +1,126 @@
+//*************************************************************************
+// DESCRIPTION: Verilator: Emit C++ for tree
+//
+// Code available from: http://www.veripool.org/verilator
+//
+// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
+//
+//*************************************************************************
+//
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
+// redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+//
+// 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.
+//
+//*************************************************************************
+
+#include "config_build.h"
+#include "verilatedos.h"
+#include <cstdio>
+#include <cstdarg>
+#include <unistd.h>
+#include <cmath>
+#include <map>
+#include <vector>
+
+#include "V3Global.h"
+#include "V3EmitC.h"
+#include "V3EmitCBase.h"
+#include "V3Stats.h"
+
+#define EMITCINLINES_NUM_CONSTW	10	// Number of VL_CONST_W_*X's in verilated.h (IE VL_CONST_W_9X is last)
+
+//######################################################################
+
+class EmitCInlines : EmitCBaseVisitor {
+    // STATE
+    vector<V3Double0>	m_wordWidths;	// What sizes are used?
+
+    // METHODS
+    void emitInt();
+
+    // VISITORS
+    virtual void visit(AstVar* nodep, AstNUser*) {
+	// All wide constants load into variables, so we can just hunt for them
+	if (nodep->widthWords() >= EMITCINLINES_NUM_CONSTW ) {
+	    if (int(m_wordWidths.size()) <= nodep->widthWords()) {
+		m_wordWidths.resize(nodep->widthWords()+5);
+	    }
+	    ++ m_wordWidths.at(nodep->widthWords());
+	    v3Global.needHInlines(true);
+	}
+    }
+
+    // NOPs
+    virtual void visit(AstNodeStmt*, AstNUser*) {}
+    // Default
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+    }
+    //---------------------------------------
+    // ACCESSORS
+public:
+    EmitCInlines(AstNetlist* nodep) {
+	nodep->accept(*this);
+	if (v3Global.needHInlines()) {
+	    emitInt();
+	}
+    }
+};
+
+void EmitCInlines::emitInt() {
+    string filename = v3Global.opt.makeDir()+"/"+topClassName()+"__Inlines.h";
+    newCFile(filename, false/*slow*/, false/*source*/);
+    V3OutCFile hf (filename);
+    m_ofp = &hf;
+
+    ofp()->putsHeader();
+    puts("#ifndef _"+topClassName()+"__Inlines_H_\n");
+    puts("#define _"+topClassName()+"__Inlines_H_\n");
+    puts("\n");
+
+    puts("#include \"verilated.h\"\n");
+
+    puts("\n//======================\n\n");
+
+    for (unsigned words=0; words<m_wordWidths.size(); words++) {
+	if (m_wordWidths.at(words)) {
+	    puts("#ifndef VL_HAVE_CONST_W_"+cvtToStr(words)+"X\n");
+	    puts("# define VL_HAVE_CONST_W_"+cvtToStr(words)+"X\n");
+	    puts("static inline WDataOutP VL_CONST_W_"+cvtToStr(words)+"X(int obits, WDataOutP o\n");
+	    puts("\t");
+	    for (int i=words-1; i>=0; --i) {
+		puts(",IData d"+cvtToStr(i));
+		if (i && (i % 8 == 0)) puts("\n\t");
+	    }
+	    puts(") {\n");
+	    puts("   ");
+	    for (int i=words-1; i>=0; --i) {
+		puts(" o["+cvtToStr(i)+"]=d"+cvtToStr(i)+";");
+		if (i && (i % 8 == 0)) puts("\n   ");
+	    }
+	    puts("\n");
+	    puts("    for(int i="+cvtToStr(words)+";i<VL_WORDS_I(obits);i++) o[i] = (IData)0x0;\n");
+	    puts("    return o;\n");
+	    puts("}\n");
+	    puts("#endif\n");
+	    puts("\n");
+	}
+    }
+
+    puts("//======================\n\n");
+    puts("#endif  /*guard*/\n");
+}
+
+//######################################################################
+// EmitC class functions
+
+void V3EmitC::emitcInlines() {
+    UINFO(2,__FUNCTION__<<": "<<endl);
+    EmitCInlines syms (v3Global.rootp());
+}

src/V3EmitCSyms.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Emit C++ for tree
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -21,10 +21,10 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
-#include <math.h>
+#include <cmath>
 #include <map>
 #include <set>
 #include <vector>
@@ -39,11 +39,17 @@
 // Symbol table emitting
 
 class EmitCSyms : EmitCBaseVisitor {
+    // NODE STATE
+    // Cleared on Netlist
+    //  AstModule::user1()	-> bool.  Set true __Vconfigure called
+    AstUser1InUse	m_inuser1;
+
     // STATE
     AstModule*	m_modp;		// Current module
     typedef pair<AstScope*,AstModule*> ScopeModPair;
     vector<ScopeModPair>  m_scopes;	// Every scope by module
     V3LanguageWords 	m_words;	// Reserved word detector
+    int		m_coverBins;		// Coverage bin number
 
     // METHODS
     void emitInt();
@@ -59,7 +65,9 @@ class EmitCSyms : EmitCBaseVisitor {
 	if (nodep->name() != "") {
 	    string rsvd = m_words.isKeyword(nodep->name());
 	    if (rsvd != "") {
-		nodep->v3error("Unsupported: "+rsvd+": "<<nodep->name());
+		// Generally V3Name should find all of these and throw SYMRSVDWORD.
+		// We'll still check here because the compiler errors resulting if we miss this warning are SO nasty
+		nodep->v3error("Symbol matching "+rsvd+" reserved word reached emitter, should have hit SYMRSVDWORD: '"<<nodep->name()<<"'");
 	    }
 	}
     }
@@ -68,9 +76,10 @@ class EmitCSyms : EmitCBaseVisitor {
     virtual void visit(AstNetlist* nodep, AstNUser*) {
 	// Collect list of scopes
 	nodep->iterateChildren(*this);
-	
+
 	// Sort m_scopes by scope name
 	sort(m_scopes.begin(), m_scopes.end(), CmpName());
+
 	// Output
 	emitInt();
 	emitImp();
@@ -79,11 +88,18 @@ class EmitCSyms : EmitCBaseVisitor {
 	nameCheck(nodep);
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
+	m_modp = NULL;
     }
     virtual void visit(AstScope* nodep, AstNUser*) {
 	nameCheck(nodep);
 	m_scopes.push_back(make_pair(nodep, m_modp));
     }
+    virtual void visit(AstCoverDecl* nodep, AstNUser*) {
+	// Assign numbers to all bins, so we know how big of an array to use
+	if (!nodep->dataDeclNullp()) {  // else duplicate we don't need code for
+	    nodep->binNum(m_coverBins++);
+	}
+    }
     // NOPs
     virtual void visit(AstNodeStmt*, AstNUser*) {}
     virtual void visit(AstConst*, AstNUser*) {}
@@ -97,6 +113,7 @@ class EmitCSyms : EmitCBaseVisitor {
 public:
     EmitCSyms(AstNetlist* nodep) {
 	m_modp = NULL;
+	m_coverBins = 0;
 	nodep->accept(*this);
     }
 };
@@ -146,6 +163,12 @@ void EmitCSyms::emitInt() {
 	}
     }
 
+    puts("\n// COVERAGE\n");
+    if (m_coverBins) {
+	ofp()->putAlign(V3OutFile::AL_AUTO, sizeof(uint32_t));
+	puts("uint32_t\t__Vcoverage["); puts(cvtToStr(m_coverBins)); puts("];\n");
+    }
+
     puts("\n// CREATORS\n");
     puts(symClassName()+"("+topClassName()+"* topp, const char* namep);\n");
     puts((string)"~"+symClassName()+"() {};\n");
@@ -187,12 +210,10 @@ void EmitCSyms::emitImp() {
 	AstScope* scopep = it->first;  AstModule* modp = it->second;
 	if (modp->isTop()) {
 	} else {
-	    string arrow = scopep->name();
-	    if (arrow.substr(0,4) == "TOP.") arrow.replace(0,4,".");
 	    ofp()->printf("\t%c %-30s ", comma, scopep->nameDotless().c_str());
-	    puts("(Verilated::catName(topp->name(),\"");
-	    puts(arrow);
-	    puts("\"))\n");
+	    puts("(Verilated::catName(topp->name(),");
+	    putsQuoted("."+scopep->prettyName());
+	    puts("))\n");
 	    comma=',';
 	}
     }
@@ -216,11 +237,16 @@ void EmitCSyms::emitImp() {
 	}
     }
     puts("// Setup each module's pointer back to symbol table (for public functions)\n");
-    puts("TOPp->__Vconfigure(this);\n");
+    puts("TOPp->__Vconfigure(this, true);\n");
     for (vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
 	AstScope* scopep = it->first;  AstModule* modp = it->second;
 	if (!modp->isTop()) {
-	    puts(scopep->nameDotless()+".__Vconfigure(this);\n");
+	    // first is used by AstCoverDecl's call to __vlCoverInsert
+	    bool first = !modp->user1();
+	    modp->user1(true);
+	    puts(scopep->nameDotless()+".__Vconfigure(this, "
+		 +(first?"true":"false")
+		 +");\n");
 	}
     }
 

src/V3EmitMk.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Emit Makefile
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2004-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2004-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -21,10 +21,10 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
-#include <math.h>
+#include <cmath>
 #include <map>
 #include <vector>
 #include <algorithm>
@@ -38,15 +38,21 @@
 
 class EmitMkVisitor : public EmitCBaseVisitor {
 public:
-    //int debug() { return 9; }
 
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     void emitClassMake() {
 	// Generate the makefile
 	V3OutMkFile of (v3Global.opt.makeDir()+"/"+ v3Global.opt.prefix() + "_classes.mk");
 	of.putsHeader();
 	of.puts("\n");
 
+	of.puts("VM_COVERAGE = "); of.puts(v3Global.opt.coverage()?"1":"0"); of.puts("\n");
 	of.puts("VM_TRACE = "); of.puts(v3Global.opt.trace()?"1":"0"); of.puts("\n");
 	of.puts("\n");
 
@@ -79,16 +85,17 @@ public:
 	    of.puts("default: "+v3Global.opt.prefix()+"__ALL.a\n");
 	}
 	of.puts("\n# Constants...\n");
-	of.puts("PERL = "+V3Options::getenvStr("PERL","perl")+"\n");
-	of.puts("VERILATOR_ROOT = "+V3Options::getenvStr("VERILATOR_ROOT","")+"\n");
-	of.puts("SYSTEMPERL = "+V3Options::getenvStr("SYSTEMPERL","")+"\n");
+	of.puts("PERL = "+V3Options::getenvPERL()+"\n");
+	of.puts("VERILATOR_ROOT = "+V3Options::getenvVERILATOR_ROOT()+"\n");
+	of.puts("SYSTEMPERL = "+V3Options::getenvSYSTEMPERL()+"\n");
+	of.puts("SYSTEMPERL_INCLUDE = "+V3Options::getenvSYSTEMPERL_INCLUDE()+"\n");
 
 	of.puts("\n# Switches...\n");
 	of.puts(string("VM_SP = ")+(v3Global.opt.systemPerl()?"1":"0")+"\n");
 	of.puts(string("VM_SC = ")+((v3Global.opt.systemC()&&!v3Global.opt.systemPerl())?"1":"0")+"\n");
 	of.puts(string("VM_SP_OR_SC = ")+(v3Global.opt.systemC()?"1":"0")+"\n");
 	of.puts(string("VM_PCLI = ")+(v3Global.opt.systemC()?"0":"1")+"\n");
-	of.puts(string("VM_SC_TARGET_ARCH = ")+V3Options::getenvStr("SYSTEMC_ARCH","")+"\n");
+	of.puts(string("VM_SC_TARGET_ARCH = ")+V3Options::getenvSYSTEMC_ARCH()+"\n");
 
 	of.puts("\n# Vars...\n");
 	of.puts(string("VM_PREFIX = ")+v3Global.opt.prefix()+"\n");
@@ -138,7 +145,7 @@ public:
 
 	    of.puts("\n# Link rules...\n");
 	    of.puts(v3Global.opt.prefix()+": $(VK_USER_OBJS) $(SP_SRCS) $(VM_PREFIX)__ALL.a\n");
-	    of.puts("\t$(CXX) $(LDFLAGS) $^ $(LOADLIBES) $(LDLIBS) -o $@ $(LIBS) 2>&1 | c++filt\n");
+	    of.puts("\t$(LINK) $(LDFLAGS) $^ $(LOADLIBES) $(LDLIBS) -o $@ $(LIBS) $(SC_LIBS) 2>&1 | c++filt\n");
 	    of.puts("\n");
 	}
 

src/V3EmitMk.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Emit Makefile
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3EmitV.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Emit Verilog from tree
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2004-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2004-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -21,10 +21,10 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
-#include <math.h>
+#include <cmath>
 #include <map>
 #include <vector>
 #include <algorithm>
@@ -36,21 +36,26 @@
 //######################################################################
 // Emit statements and math operators
 
-class EmitVImp : public EmitCBaseVisitor {
-private:
+class EmitVBaseVisitor : public EmitCBaseVisitor {
+    // MEMBERS
     bool	m_suppressSemi;
-    AstModule*	m_modp;
-public:
-    //int debug() { return 9; }
 
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
 
+    virtual void puts(const string& str) = 0;
+    virtual void putbs(const string& str) = 0;
+    virtual void putsNoTracking(const string& str) = 0;
+    
     // VISITORS
     virtual void visit(AstNetlist* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
     }
     virtual void visit(AstModule* nodep, AstNUser*) {
-	m_modp = nodep;
 	putbs("module "+modClassName(nodep)+";\n");
 	nodep->iterateChildren(*this);
 	puts("endmodule\n");
@@ -87,7 +92,7 @@ public:
     virtual void visit(AstAlways* nodep, AstNUser*) {
 	putbs("always ");
 	nodep->sensesp()->iterateAndNext(*this);
-	putbs("begin\n");
+	putbs(" begin\n");
 	nodep->bodysp()->iterateAndNext(*this);
 	puts("end\n");
     }
@@ -118,17 +123,22 @@ public:
 	if (!m_suppressSemi) puts(";\n");
     }
     virtual void visit(AstSenTree* nodep, AstNUser*) {
+	// AstSenItem is called for dumping in isolation by V3Order
 	putbs("@(");
-	nodep->iterateChildren(*this);
-	puts(") ");
+	for (AstNode* expp=nodep->sensesp(); expp; expp = expp->nextp()) {
+	    nodep->iterateChildren(*this);
+	    if (expp->nextp()) puts(" or ");
+	}
+	puts(")");
+    }
+    virtual void visit(AstSenGate* nodep, AstNUser*) {
+	emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->sensesp(), nodep->rhsp());
     }
     virtual void visit(AstSenItem* nodep, AstNUser*) {
 	putbs("");
-	if (nodep->backp()->castSenItem()) puts(" or ");
 	puts(nodep->edgeType().verilogKwd());
-	puts(" ");
+	if (nodep->sensp()) puts(" ");
 	nodep->iterateChildren(*this);
-	puts(" ");
     }
     virtual void visit(AstNodeCase* nodep, AstNUser*) {
 	putbs(nodep->verilogKwd());
@@ -158,25 +168,33 @@ public:
 	puts((string)"// "+nodep->name()+"\n");
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCoverDecl*, AstNUser*) {
-	// N/A
-    }
-    virtual void visit(AstCoverInc*, AstNUser*) {
-	// N/A
-    }
-    virtual void visit(AstDisplay* nodep, AstNUser*) {
+    virtual void visit(AstCoverDecl*, AstNUser*) {}  // N/A
+    virtual void visit(AstCoverInc*, AstNUser*) {}  // N/A
+    virtual void visit(AstCoverToggle*, AstNUser*) {}  // N/A
+
+    void visitNodeDisplay(AstNode* nodep, AstNode* filep, const string& text, AstNode* exprsp) {
 	putbs(nodep->verilogKwd());
 	putbs(" (");
-	if (nodep->filep()) { nodep->filep()->iterateAndNext(*this); putbs(","); }
+	if (filep) { filep->iterateAndNext(*this); putbs(","); }
 	puts("\"");
-	ofp()->putsNoTracking(nodep->text());
+	putsNoTracking(text);   // Not putsQuoted, as display text contains \ already
 	puts("\"");
-	for (AstNode* expp=nodep->exprsp(); expp; expp = expp->nextp()) {
+	for (AstNode* expp=exprsp; expp; expp = expp->nextp()) {
 	    puts(",");
 	    expp->iterateAndNext(*this);
 	}
 	puts(");\n");
     }
+    virtual void visit(AstDisplay* nodep, AstNUser*) {
+	visitNodeDisplay(nodep, nodep->filep(), nodep->text(), nodep->exprsp());
+    }
+    virtual void visit(AstFScanF* nodep, AstNUser*) {
+	visitNodeDisplay(nodep, nodep->filep(), nodep->text(), nodep->exprsp());
+    }
+    virtual void visit(AstSScanF* nodep, AstNUser*) {
+	visitNodeDisplay(nodep, nodep->fromp(), nodep->text(), nodep->exprsp());
+    }
+
     virtual void visit(AstFOpen* nodep, AstNUser*) {
 	putbs(nodep->verilogKwd());
 	putbs(" (");
@@ -193,6 +211,12 @@ public:
 	if (nodep->filep()) nodep->filep()->iterateChildren(*this);
 	puts(");\n");
     }
+    virtual void visit(AstFFlush* nodep, AstNUser*) {
+	putbs(nodep->verilogKwd());
+	putbs(" (");
+	if (nodep->filep()) nodep->filep()->iterateChildren(*this);
+	puts(");\n");
+    }
     virtual void visit(AstReadMem* nodep, AstNUser*) {
 	putbs(nodep->verilogKwd());
 	putbs(" (");
@@ -216,6 +240,13 @@ public:
 	nodep->bodysp()->iterateAndNext(*this);
 	puts("}\n");
     }
+    virtual void visit(AstRepeat* nodep, AstNUser*) {
+	puts("repeat (");
+	nodep->countp()->iterateAndNext(*this);
+	puts(") {\n");
+	nodep->bodysp()->iterateAndNext(*this);
+	puts("}\n");
+    }
     virtual void visit(AstWhile* nodep, AstNUser*) {
 	nodep->precondsp()->iterateAndNext(*this);
 	puts("while (");
@@ -244,7 +275,9 @@ public:
 	putbs("$finish;\n");
     }
     virtual void visit(AstText* nodep, AstNUser*) {
-	ofp()->putsNoTracking(nodep->text());
+	putsNoTracking(nodep->text());
+    }
+    virtual void visit(AstScopeName* nodep, AstNUser*) {
     }
     virtual void visit(AstCStmt* nodep, AstNUser*) {
 	putbs("$_CSTMT(");
@@ -344,11 +377,11 @@ public:
 	    if (nodep->widthp()->isOne()) {
 		nodep->lsbp()->iterateAndNext(*this);
 	    } else {
-		puts(cvtToStr(nodep->lsbp()->castConst()->asInt()
-			      +nodep->widthp()->castConst()->asInt()
+		puts(cvtToStr(nodep->lsbp()->castConst()->toSInt()
+			      +nodep->widthp()->castConst()->toSInt()
 			      -1));
 		puts(":");
-		nodep->lsbp()->iterateAndNext(*this);
+		puts(cvtToStr(nodep->lsbp()->castConst()->toSInt()));
 	    }
 	} else {
 	    nodep->lsbp()->iterateAndNext(*this); puts("+:");
@@ -366,12 +399,12 @@ public:
     // Terminals
     virtual void visit(AstVarRef* nodep, AstNUser*) {
 	puts(nodep->hiername());
- 	puts(nodep->varp()->name());
+	puts(nodep->varp()->name());
     }
     virtual void visit(AstVarXRef* nodep, AstNUser*) {
 	puts(nodep->dotted());
 	puts(".");
- 	puts(nodep->varp()->name());
+	puts(nodep->varp()->name());
     }
     virtual void visit(AstConst* nodep, AstNUser*) {
 	puts(nodep->num().ascii(true,true));
@@ -409,27 +442,56 @@ public:
     virtual void visit(AstCell*, AstNUser*) {}		// Handled outside the Visit class
     // Default
     virtual void visit(AstNode* nodep, AstNUser*) {
-	puts((string)"\n???? // "+nodep->typeName()+"\n");
+	puts((string)"\n???? // "+nodep->prettyTypeName()+"\n");
 	nodep->iterateChildren(*this);
-	nodep->v3fatalSrc("Unknown node type reached emitter: "<<nodep->typeName());
+	nodep->v3fatalSrc("Unknown node type reached emitter: "<<nodep->prettyTypeName());
     }
 
 public:
-    EmitVImp() {
+    EmitVBaseVisitor() {
 	m_suppressSemi = false;
-	m_modp = NULL;
     }
-    void main(AstNode* nodep, V3OutCFile* ofp);
-    virtual ~EmitVImp() {}
+    virtual ~EmitVBaseVisitor() {}
 };
 
 //######################################################################
+// Emit to an output file
 
-void EmitVImp::main(AstNode* modp, V3OutCFile* ofp) {
-    // Output a module, or overall netlist
-    m_ofp = ofp;
-    modp->accept(*this);
-}
+class EmitVFileVisitor : public EmitVBaseVisitor {
+    // MEMBERS
+    V3OutFile*	m_ofp;
+    // METHODS
+    V3OutFile*	ofp() const { return m_ofp; }
+    void puts(const string& str) { ofp()->puts(str); }
+    void putbs(const string& str) { ofp()->putbs(str); }
+    void putsNoTracking(const string& str) { ofp()->putsNoTracking(str); }
+    
+public:
+    EmitVFileVisitor(AstNode* nodep, V3OutFile* ofp) {
+	m_ofp = ofp;
+	nodep->accept(*this);
+    }
+    virtual ~EmitVFileVisitor() {}
+};
+
+//######################################################################
+// Emit to a stream (perhaps stringstream)
+
+class EmitVStreamVisitor : public EmitVBaseVisitor {
+    // MEMBERS
+    ostream&	m_os;
+    // METHODS
+    void puts(const string& str) { m_os<<str; }
+    void putbs(const string& str) { m_os<<str; }
+    void putsNoTracking(const string& str) { m_os<<str; }
+    
+public:
+    EmitVStreamVisitor(AstNode* nodep, ostream& os)
+	: m_os(os) {
+	nodep->accept(*this);
+    }
+    virtual ~EmitVStreamVisitor() {}
+};
 
 //######################################################################
 // EmitV class functions
@@ -440,15 +502,18 @@ void V3EmitV::emitv() {
 	// All-in-one file
 	V3OutVFile of (v3Global.opt.makeDir()+"/"+v3Global.opt.prefix()+"__Vout.v");
 	of.putsHeader();
-	EmitVImp imp;
-	imp.main(v3Global.rootp(), &of);
+	EmitVFileVisitor visitor (v3Global.rootp(), &of);
     } else {
 	// Process each module in turn
 	for (AstModule* modp = v3Global.rootp()->modulesp(); modp; modp=modp->nextp()->castModule()) {
-	    EmitVImp imp;
-	    V3OutVFile of (v3Global.opt.makeDir()+"/"+imp.modClassName(modp)+"__Vout.v");
+	    V3OutVFile of (v3Global.opt.makeDir()
+			   +"/"+EmitCBaseVisitor::modClassName(modp)+"__Vout.v");
 	    of.putsHeader();
-	    imp.main(modp, &of);
+	    EmitVFileVisitor visitor (modp, &of);
 	}
     }
 }
+
+void V3EmitV::verilogForTree(AstNode* nodep, ostream& os) {
+    EmitVStreamVisitor(nodep, os);
+}

src/V3EmitV.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+//-*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Emit Verilog code for module tree
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -31,6 +32,7 @@
 class V3EmitV {
 public:
     static void emitv();
+    static void verilogForTree(AstNode* nodep, ostream& os=cout);
 };
 
 #endif // Guard

src/V3Error.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Error handling
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,9 +19,10 @@
 //
 //*************************************************************************
 
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
+#include <cstdio>
+#include <cstdarg>
+#include <cstring>
+#include <set>
 #include "V3Error.h"
 #ifndef _V3ERROR_NO_GLOBAL_
 # include "V3Ast.h"
@@ -34,8 +35,10 @@
 
 FileLine FileLine::s_defaultFileLine = FileLine(EmptySecret());
 
-int V3Error::s_errcnt = 0;
+int V3Error::s_errCount = 0;
+int V3Error::s_warnCount = 0;
 int V3Error::s_debugDefault = 0;
+int V3Error::s_tellManual = 0;
 ostringstream V3Error::s_errorStr;		// Error string being formed
 V3ErrorCode V3Error::s_errorCode = V3ErrorCode::FATAL;
 bool V3Error::s_describedEachWarn[V3ErrorCode::MAX];
@@ -43,9 +46,9 @@ bool V3Error::s_describedWarnings = false;
 bool V3Error::s_pretendError[V3ErrorCode::MAX];
 
 struct v3errorIniter {
-    v3errorIniter() {  V3Error::init(); };
+    v3errorIniter() {  V3Error::init(); }
 };
-v3errorIniter v3errorInit; 
+v3errorIniter v3errorInit;
 
 //######################################################################
 // ErrorCode class functions
@@ -64,6 +67,17 @@ V3ErrorCode::V3ErrorCode(const char* msgp) {
 //######################################################################
 // FileLine class functions
 
+FileLine::FileLine(FileLine::EmptySecret) {
+    m_lineno=0;
+    m_filename="COMMAND_LINE";
+
+    m_warnOn=0;
+    for (int codei=V3ErrorCode::MIN; codei<V3ErrorCode::MAX; codei++) {
+	V3ErrorCode code = (V3ErrorCode)codei;
+	warnOff(code, code.defaultsOff());
+    }
+}
+
 void FileLine::lineDirective(const char* textp) {
     // Handle `line directive
     // Skip `line
@@ -100,9 +114,16 @@ bool FileLine::warnOff(const string& msg, bool flag) {
     }
 }
 
+void FileLine::warnLintOff(bool flag) {
+    for (int codei=V3ErrorCode::FIRST_WARN; codei<V3ErrorCode::MAX; codei++) {
+	V3ErrorCode code = (V3ErrorCode)codei;
+	if (code.lintError()) warnOff(code, flag);
+    }
+}
+
 FileLine* FileLine::copyOrSameFileLine() {
     // Return this, or a copy of this
-    // There are often more then one token per line, thus we use the
+    // There are often more than one token per line, thus we use the
     // same pointer as long as we're on the same line.
     static FileLine* lastNewp = NULL;
     if (lastNewp && *lastNewp == *this) {
@@ -133,7 +154,7 @@ const string FileLine::profileFuncname() const {
 	   != string::npos) {
 	name.replace(pos, 1, "_");
     }
-    name += "__"+cvtToStr(lineno());
+    name += "__l"+cvtToStr(lineno());
     return name;
 }
 
@@ -145,13 +166,23 @@ ostream& operator<<(ostream& os, FileLine* fileline) {
     return(os);
 }
 
-bool FileLine::warnIsOff(V3ErrorCode code) {
-    if (m_warnOff.test(code)) return true;
+bool FileLine::warnIsOff(V3ErrorCode code) const {
+    if (!m_warnOn.test(code)) return true;
     // UNOPTFLAT implies UNOPT
-    if (code==V3ErrorCode::UNOPT && m_warnOff.test(V3ErrorCode::UNOPTFLAT)) return true;
+    if (code==V3ErrorCode::UNOPT && !m_warnOn.test(V3ErrorCode::UNOPTFLAT)) return true;
     return false;
 }
 
+void FileLine::warnStateInherit(const FileLine& from) {
+    // Any warnings that are off in "from", become off in "this".
+    for (int codei=V3ErrorCode::FIRST_WARN; codei<V3ErrorCode::MAX; codei++) {
+	V3ErrorCode code = (V3ErrorCode)codei;
+	if (from.warnIsOff(code)) {
+	    this->warnOff(code, true);
+	}
+    }
+}
+
 void FileLine::v3errorEnd(ostringstream& str) {
     if (this && m_lineno) {
 	ostringstream nsstr;
@@ -162,6 +193,46 @@ void FileLine::v3errorEnd(ostringstream& str) {
 	V3Error::v3errorEnd(str);
     }
 }
+
+#ifdef VL_LEAK_CHECKS
+typedef set<FileLine*> FileLineCheckSet;
+FileLineCheckSet fileLineLeakChecks;
+
+void* FileLine::operator new(size_t size) {
+    FileLine* objp = static_cast<FileLine*>(::operator new(size));
+    fileLineLeakChecks.insert(objp);
+    return objp;
+}
+
+void FileLine::operator delete(void* objp, size_t size) {
+    if (!objp) return;
+    FileLine* flp = static_cast<FileLine*>(objp);
+    FileLineCheckSet::iterator it = fileLineLeakChecks.find(flp);
+    if (it != fileLineLeakChecks.end()) {
+	fileLineLeakChecks.erase(it);
+    } else {
+	flp->v3fatalSrc("Deleting FileLine object that was never tracked\n");
+    }
+    ::operator delete(objp);
+}
+#endif
+
+void FileLine::deleteAllRemaining() {
+#ifdef VL_LEAK_CHECKS
+    // FileLines are allocated, but never nicely freed, as it's much faster
+    // that way.  Unfortunately this makes our leak checking a big mess, so
+    // only when leak checking we'll track them all and cleanup.
+    while (1) {
+	FileLineCheckSet::iterator it=fileLineLeakChecks.begin();
+	if (it==fileLineLeakChecks.end()) break;
+	delete *it;
+	// Operator delete will remove the iterated object from the list.
+	// Eventually the list will be empty and terminate the loop.
+    }
+    fileLineLeakChecks.clear();
+#endif
+}
+
 //######################################################################
 // V3Error class functions
 
@@ -187,25 +258,48 @@ string V3Error::lineStr (const char* filename, int lineno) {
     return out.str();
 }
 
+void V3Error::incWarnings() {
+    s_warnCount++;
+    // We don't exit on a lot of warnings.
+}
+
 void V3Error::incErrors() {
-    s_errcnt++;
-    if (errorCount() == MAX_ERRORS) {  // Not >= as would otherwise recurse
-	v3fatal ("Exiting due to too many errors encountered\n");
+    s_errCount++;
+    if (errorCount() == v3Global.opt.errorLimit()) {  // Not >= as would otherwise recurse
+	v3fatal ("Exiting due to too many errors encountered; --error-limit="<<errorCount()<<endl);
     }
 }
 
 void V3Error::abortIfErrors() {
     if (errorCount()) {
-	v3fatal ("Exiting due to "<<dec<<errorCount()<<" warning(s)\n");
+	v3fatal ("Exiting due to "<<dec<<errorOrWarnCount()<<" warning(s)\n");
     }
 }
 
+void V3Error::abortIfWarnings() {
+    if (errorOrWarnCount()) {
+	v3fatal ("Exiting due to "<<dec<<errorOrWarnCount()<<" warning(s)\n");
+    }
+}
+
+bool V3Error::isError(V3ErrorCode code) {
+    if (code==V3ErrorCode::SUPPRESS) return false;
+    else if (code==V3ErrorCode::INFO) return false;
+    else if (code==V3ErrorCode::FATAL) return true;
+    else if (code==V3ErrorCode::FATALSRC) return true;
+    else if (code==V3ErrorCode::ERROR) return true;
+    else if (code<V3ErrorCode::FIRST_WARN
+	     || s_pretendError[code]) return true;
+    else return false;
+}
+
 string V3Error::msgPrefix(V3ErrorCode code) {
     if (code==V3ErrorCode::SUPPRESS) return "-arning-suppressed: ";
+    else if (code==V3ErrorCode::INFO) return "-Info: ";
     else if (code==V3ErrorCode::FATAL) return "%Error: ";
+    else if (code==V3ErrorCode::FATALSRC) return "%Error: Internal Error: ";
     else if (code==V3ErrorCode::ERROR) return "%Error: ";
-    else if (code<V3ErrorCode::FIRST_WARN
-	     || s_pretendError[code]) return "%Error-"+(string)code.ascii()+": ";
+    else if (isError(code)) return "%Error-"+(string)code.ascii()+": ";
     else return "%Warning-"+(string)code.ascii()+": ";
 }
 
@@ -239,12 +333,15 @@ void V3Error::v3errorEnd (ostringstream& sstr) {
 #ifdef __COVERITY__
     if (s_errorCode==V3ErrorCode::FATAL) __coverity_panic__(x);
 #endif
-    if (s_errorCode!=V3ErrorCode::SUPPRESS || debug()) {
+    if (s_errorCode!=V3ErrorCode::SUPPRESS
+	// On debug, show only non default-off warning to prevent pages of warnings
+	|| (debug() && !s_errorCode.defaultsOff())) {
 	cerr<<msgPrefix()<<sstr.str();
 	if (sstr.str()[sstr.str().length()-1] != '\n') {
 	    cerr<<endl;
 	}
-	if (s_errorCode!=V3ErrorCode::SUPPRESS) {
+	if (s_errorCode!=V3ErrorCode::SUPPRESS
+	    && s_errorCode!=V3ErrorCode::INFO) {
 	    if (!s_describedEachWarn[s_errorCode]
 		&& !s_pretendError[s_errorCode]) {
 		s_describedEachWarn[s_errorCode] = true;
@@ -258,11 +355,27 @@ void V3Error::v3errorEnd (ostringstream& sstr) {
 		    cerr<<msgPrefix()<<"else you may end up with different sim results."<<endl;
 		}
 	    }
-	    incErrors();
-	    if (s_errorCode==V3ErrorCode::FATAL) {
+	    // If first warning is not the user's fault (internal/unsupported) then give the website
+	    // Not later warnings, as a internal may be caused by an earlier problem
+	    if (s_tellManual == 0) {
+		if (s_errorCode.mentionManual()
+		    || sstr.str().find("Unsupported") != string::npos) {
+		    s_tellManual = 1;
+		} else {
+		    s_tellManual = 2;
+		}
+	    }
+	    if (isError(s_errorCode)) incErrors();
+	    else incWarnings();
+	    if (s_errorCode==V3ErrorCode::FATAL
+		|| s_errorCode==V3ErrorCode::FATALSRC) {
 		static bool inFatal = false;
 		if (!inFatal) {
 		    inFatal = true;
+		    if (s_tellManual==1) {
+			cerr<<msgPrefix()<<"See the manual and http://www.veripool.org/verilator for more assistance."<<endl;
+			s_tellManual = 2;
+		    }
 #ifndef _V3ERROR_NO_GLOBAL_
 		    if (debug()) {
 			v3Global.rootp()->dumpTreeFile(v3Global.debugFilename("final.tree",99));

src/V3Error.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Error handling
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -33,25 +34,38 @@
 class V3ErrorCode {
 public:
     enum en {
+	MIN=0,		// Keep first
+	//
 	SUPPRESS,	// Warning suppressed by user
+	INFO,		// General information out
 	FATAL,		// Kill the program
+	FATALSRC,	// Kill the program, for internal source errors
 	ERROR,		// General error out, can't suppress
+	// Boolean information we track per-line, but aren't errors
+	I_COVERAGE,	// Coverage is on/off from /*verilator coverage_on/off*/
+	I_TRACING,	// Tracing is on/off from /*verilator tracing_on/off*/
 	// Error codes:
 	MULTITOP,	// Error: Multiple top level modules
 	TASKNSVAR,	// Error: Task I/O not simple
+	BLKLOOPINIT,	// Error: Delayed assignment to array inside for loops
 	// Warning codes:
 	FIRST_WARN,	// Just a code so the program knows where to start warnings
 	//
 	BLKANDNBLK,	// Blocked and non-blocking assignments to same variable
 	CASEINCOMPLETE,	// Case statement has missing values
 	CASEOVERLAP,	// Case statements overlap
+	CASEWITHX,	// Case with X values
 	CASEX,		// Casex
 	CMPCONST,	// Comparison is constant due to limited range
 	COMBDLY,	// Combinatorial delayed assignment
+	STMTDLY,	// Delayed statement
+	SYMRSVDWORD,	// Symbol is Reserved Word
 	GENCLK,		// Generated Clock
+	IMPERFECTSCH,	// Imperfect schedule (disabled by default)
 	IMPLICIT,	// Implicit wire
 	IMPURE,		// Impure function not being inlined
 	MULTIDRIVEN,	// Driven from multiple blocks
+	REDEFMACRO,	// Redefining existing define macro
 	UNDRIVEN,	// No drivers
 	UNOPT,		// Unoptimizable block
 	UNOPTFLAT,	// Unoptimizable block after flattening
@@ -59,36 +73,54 @@ public:
 	UNUSED,		// No receivers
 	VARHIDDEN,	// Hiding variable
 	WIDTH,		// Width mismatch
+	WIDTHCONCAT,	// Unsized numbers/parameters in concatenations
 	MAX
 	// ***Add new elements below also***
     };
     enum en m_e;
-    inline V3ErrorCode () {};
-    inline V3ErrorCode (en _e) : m_e(_e) {};
+    inline V3ErrorCode () {}
+    inline V3ErrorCode (en _e) : m_e(_e) {}
     V3ErrorCode (const char* msgp);	// Matching code or ERROR
-    explicit inline V3ErrorCode (int _e) : m_e(static_cast<en>(_e)) {};
-    operator en () const { return m_e; };
+    explicit inline V3ErrorCode (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
     const char* ascii() const {
 	const char* names[] = {
 	    // Leading spaces indicate it can't be disabled.
-	    " SUPPRESS", " FATAL", " ERROR",
-	     "MULTITOP", "TASKNSVAR",
+	    " MIN", " SUPPRESS", " INFO", " FATAL", " FATALSRC", " ERROR",
+	    // Boolean
+	    " I_COVERAGE", " I_TRACING",
+	    // Errors
+	    "MULTITOP", "TASKNSVAR", "BLKLOOPINIT",
+	    // Warnings
 	    " FIRST_WARN",
 	    "BLKANDNBLK",
-	    "CASEINCOMPLETE", "CASEOVERLAP", "CASEX", "CMPCONST",
-	    "COMBDLY", "GENCLK", "IMPLICIT", "IMPURE",
-	    "MULTIDRIVEN",
+	    "CASEINCOMPLETE", "CASEOVERLAP", "CASEWITHX", "CASEX", "CMPCONST",
+	    "COMBDLY", "STMTDLY", "SYMRSVDWORD", "GENCLK", "IMPERFECTSCH", "IMPLICIT", "IMPURE",
+	    "MULTIDRIVEN", "REDEFMACRO",
 	    "UNDRIVEN", "UNOPT", "UNOPTFLAT", "UNSIGNED", "UNUSED",
-	    "VARHIDDEN", "WIDTH",
+	    "VARHIDDEN", "WIDTH", "WIDTHCONCAT",
 	    " MAX"
 	};
 	return names[m_e];
-    };
+    }
+    // Warnings that default to off
+    bool defaultsOff() const { return ( m_e==IMPERFECTSCH ); }
     // Warnings that warn about nasty side effects
-    bool dangerous() const { return ( m_e==COMBDLY );};
+    bool dangerous() const { return ( m_e==COMBDLY ); }
     // Warnings we'll present to the user as errors
     // Later -Werror- options may make more of these.
-    bool pretendError() const { return ( m_e==BLKANDNBLK || m_e==IMPURE); };
+    bool pretendError() const { return ( m_e==BLKANDNBLK || m_e==IMPURE || m_e==SYMRSVDWORD); }
+    // Warnings to mention manual
+    bool mentionManual() const { return ( m_e==FATALSRC || pretendError() ); }
+
+    // Warnings that are lint only
+    bool lintError() const { return ( m_e==CASEINCOMPLETE || m_e==CASEOVERLAP
+				      || m_e==CASEWITHX || m_e==CASEX
+				      || m_e==CMPCONST
+				      || m_e==IMPLICIT
+				      || m_e==UNDRIVEN || m_e==UNSIGNED
+				      || m_e==UNUSED || m_e==VARHIDDEN
+				      || m_e==WIDTH); }
   };
   inline bool operator== (V3ErrorCode lhs, V3ErrorCode rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (V3ErrorCode lhs, V3ErrorCode::en rhs) { return (lhs.m_e == rhs); }
@@ -104,11 +136,12 @@ class V3Error {
     static bool 	s_describedEachWarn[V3ErrorCode::MAX]; // Told user specifics about this warning
     static bool 	s_pretendError[V3ErrorCode::MAX]; // Pretend this warning is an error
     static int		s_debugDefault;		// Default debugging level
-    static int		s_errcnt;		// Error count
+    static int		s_errCount;		// Error count
+    static int		s_warnCount;		// Error count
+    static int 		s_tellManual;		// Tell user to see manual, 0=not yet, 1=doit, 2=disable
     static ostringstream s_errorStr;		// Error string being formed
     static V3ErrorCode	s_errorCode;		// Error string being formed will abort
     enum MaxErrors { 	MAX_ERRORS = 50 };	// Fatal after this may errors
-    static void	incErrors();
 
     V3Error() { cerr<<("Static class"); abort(); }
 
@@ -118,12 +151,18 @@ class V3Error {
     static void		debugDefault(int level) { s_debugDefault = level; }
     static int		debugDefault() { return s_debugDefault; }
     static string	msgPrefix(V3ErrorCode code=s_errorCode);	// returns %Error/%Warn
-    static int		errorCount() { return s_errcnt; }
+    static int		errorCount() { return s_errCount; }
+    static int		warnCount() { return s_warnCount; }
+    static int		errorOrWarnCount() { return errorCount()+warnCount(); }
     // METHODS
+    static void		incErrors();
+    static void		incWarnings();
     static void		init();
     static void		abortIfErrors();
+    static void		abortIfWarnings();
     static void		suppressThisWarning();	// Suppress next %Warn if user has it off
     static void		pretendError(V3ErrorCode code, bool flag) { s_pretendError[code]=flag; }
+    static bool		isError(V3ErrorCode code);
     static string 	v3sform (const char* format, ...);
     static string	lineStr (const char* filename, int lineno);
     static V3ErrorCode	errorCode() { return s_errorCode; }
@@ -143,11 +182,12 @@ inline void v3errorEnd(ostringstream& sstr) { V3Error::v3errorEnd(sstr); }
 
 // These allow errors using << operators: v3error("foo"<<"bar");
 // Careful, you can't put () around msg, as you would in most macro definitions
-#define v3fatal(msg) v3errorEnd(((V3Error::v3errorPrep(V3ErrorCode::FATAL)<<msg),V3Error::v3errorStr()));
-#define v3error(msg) v3errorEnd(((V3Error::v3errorPrep(V3ErrorCode::ERROR)<<msg),V3Error::v3errorStr()));
 #define v3warn(code,msg) v3errorEnd(((V3Error::v3errorPrep(V3ErrorCode::code)<<msg),V3Error::v3errorStr()));
+#define v3info(msg)  v3warn(INFO,msg)
+#define v3fatal(msg) v3warn(FATAL,msg)
+#define v3error(msg) v3warn(ERROR,msg)
 // Use this instead of fatal() to mention the source code line.
-#define v3fatalSrc(msg) v3fatal("Internal Error: "<<__FILE__<<":"<<dec<<__LINE__<<": "<<msg)
+#define v3fatalSrc(msg) v3warn(FATALSRC,__FILE__<<":"<<dec<<__LINE__<<": "<<msg)
 
 #define UINFO(level,stmsg) {if(debug()>=(level)) { cout<<"- "<<V3Error::lineStr(__FILE__,__LINE__)<<stmsg; }}
 #define UINFONL(level,stmsg) {if(debug()>=(level)) { cout<<stmsg; } }
@@ -155,7 +195,7 @@ inline void v3errorEnd(ostringstream& sstr) { V3Error::v3errorEnd(sstr); }
 #define UDEBUGONLY(stmts) {stmts}
 #define UASSERT(condition,stmsg) { if (!(condition)) { v3fatalSrc(stmsg); }}
 // For use in V3Ast static functions only
-#define UASSERT_STATIC(condition,stmsg) { if (!(condition)) { cerr<<"Internal Error: "<<__FILE__<<":"<<dec<<__LINE__<<(stmsg)<<endl; abort(); } }
+#define UASSERT_STATIC(condition,stmsg) { if (!(condition)) { cerr<<"Internal Error: "<<__FILE__<<":"<<dec<<__LINE__<<":"<<(stmsg)<<endl; abort(); } }
 
 #define V3ERROR_NA v3error("Internal: Unexpected Call")
 
@@ -165,13 +205,21 @@ template< class T> std::string cvtToStr (const T& t) {
     ostringstream os; os<<t; return os.str();
 }
 
+inline uint32_t cvtToHash(void* vp) {
+    // We can shove a 64 bit pointer into a 32 bit bucket
+    // On 32 bit systems, lower is always 0, but who cares?
+    union { void* up; struct {uint32_t upper; uint32_t lower;} l;} u;
+    u.l.upper=0; u.l.lower=0; u.up=vp;
+    return u.l.upper^u.l.lower;
+}
+
 //######################################################################
 
 class FileLine {
     // File and line number of an object, mostly for error reporting
     int		m_lineno;
     string	m_filename;
-    bitset<V3ErrorCode::MAX>	m_warnOff;
+    bitset<V3ErrorCode::MAX>	m_warnOn;
     static FileLine s_defaultFileLine;
     struct EmptySecret {};
 protected:
@@ -185,9 +233,14 @@ protected:
     void incLineno() { m_lineno++; }
     FileLine* copyOrSameFileLine();
 public:
-    FileLine (const string& filename, int lineno) { m_lineno=lineno; m_filename = filename; m_warnOff=s_defaultFileLine.m_warnOff;}
-    FileLine (FileLine* fromp) { m_lineno=fromp->lineno(); m_filename = fromp->filename(); m_warnOff=fromp->m_warnOff;};
-    FileLine (EmptySecret) { m_lineno=0; m_filename="COMMAND_LINE"; m_warnOff=0; } // Only for static constructor
+    FileLine (const string& filename, int lineno) { m_lineno=lineno; m_filename = filename; m_warnOn=s_defaultFileLine.m_warnOn; }
+    FileLine (FileLine* fromp) { m_lineno=fromp->lineno(); m_filename = fromp->filename(); m_warnOn=fromp->m_warnOn; }
+    FileLine (EmptySecret);
+    ~FileLine() { }
+#ifdef VL_LEAK_CHECKS
+    static void* operator new(size_t size);
+    static void operator delete(void* obj, size_t size);
+#endif
     static FileLine& defaultFileLine() { return s_defaultFileLine; }
     int lineno () const { return m_lineno; }
     string ascii() const;
@@ -195,13 +248,25 @@ public:
     const string filebasename () const;
     const char* cfilename () const { return m_filename.c_str(); }
     const string profileFuncname() const;
-    void warnOff(V3ErrorCode code, bool flag) { m_warnOff.set(code,flag); }	// Turn on/off warning messages on this line.
+    void warnOff(V3ErrorCode code, bool flag) { m_warnOn.set(code,!flag); }	// Turn on/off warning messages on this line.
     bool warnOff(const string& code, bool flag);  // Returns 1 if ok
-    bool warnIsOff(V3ErrorCode code);
-    void warnResetDefault() { m_warnOff=s_defaultFileLine.m_warnOff; }
+    bool warnIsOff(V3ErrorCode code) const;
+    void warnLintOff(bool flag);
+    void warnStateFrom(const FileLine& from) { m_warnOn=from.m_warnOn; }
+    void warnStateInherit(const FileLine& from);
+    void warnResetDefault() { warnStateFrom(s_defaultFileLine); }
 
+    // Boolean ACCESSORS/METHODS
+    bool coverageOn() const { return m_warnOn.test(V3ErrorCode::I_COVERAGE); }
+    void coverageOn(bool flag) { m_warnOn.set(V3ErrorCode::I_COVERAGE,flag); }
+    bool tracingOn() const { return m_warnOn.test(V3ErrorCode::I_TRACING); }
+    void tracingOn(bool flag) { m_warnOn.set(V3ErrorCode::I_TRACING,flag); }
+
+    // METHODS
     void	v3errorEnd(ostringstream& str);
     inline bool operator==(FileLine rhs) { return (m_lineno==rhs.m_lineno && m_filename==rhs.m_filename); }
+
+    static void deleteAllRemaining();
 };
 ostream& operator<<(ostream& os, FileLine* fileline);
 

src/V3Expand.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Add temporaries, such as for expand nodes
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2004-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2004-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Expand's Transformations:
-//		
+//
 // Each module:
 //	Expand verilated.h macros into internal micro optimizations (RTL)
 //	this will enable later optimizations.
@@ -32,8 +32,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 
@@ -51,9 +51,13 @@ private:
     // STATE
     AstNode*		m_stmtp;	// Current statement
 
-    //int debug() { return 9; }
-
     // METHODS
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+
     int longOrQuadWidth (AstNode* nodep) {
 	// Return 32 or 64...
 	return (nodep->width()+(VL_WORDSIZE-1)) & ~(VL_WORDSIZE-1);
@@ -168,12 +172,12 @@ private:
 	}
 	return newp;
     }
-	
+
     AstNode* newSelBitWord(AstNode* lsbp, int wordAdder) {
 	// Return equation to get the VL_BITWORD of a constant or non-constant
 	if (lsbp->castConst()) {
 	    return new AstConst (lsbp->fileline(),
-				 wordAdder + VL_BITWORD_I(lsbp->castConst()->asInt()));
+				 wordAdder + VL_BITWORD_I(lsbp->castConst()->toUInt()));
 	} else {
 	    AstNode* shiftp = new AstShiftR (lsbp->fileline(),
 					     lsbp->cloneTree(true),
@@ -204,7 +208,7 @@ private:
 	// Return equation to get the VL_BITBIT of a constant or non-constant
 	if (lsbp->castConst()) {
 	    return new AstConst (lsbp->fileline(),
-				 VL_BITBIT_I(lsbp->castConst()->asInt()));
+				 VL_BITBIT_I(lsbp->castConst()->toUInt()));
 	} else {
 	    return new AstAnd   (lsbp->fileline(),
 				 new AstConst(lsbp->fileline(), VL_WORDSIZE-1),
@@ -355,7 +359,7 @@ private:
 	    AstNode* lowwordp = new AstWordSel (nodep->fromp()->fileline(),
 						nodep->fromp()->cloneTree(true),
 						newSelBitWord(nodep->lsbp(), 0));
-	    if (nodep->isQuad() && !lowwordp->isQuad()) lowwordp = new AstCast(nodep->fileline(), lowwordp, nodep); 
+	    if (nodep->isQuad() && !lowwordp->isQuad()) lowwordp = new AstCast(nodep->fileline(), lowwordp, nodep);
 	    AstNode* lowp = new AstShiftR (nodep->fileline(),
 					   lowwordp,
 					   newSelBitBit(nodep->lsbp()),
@@ -368,7 +372,7 @@ private:
 		    new AstWordSel (nodep->fromp()->fileline(),
 				    nodep->fromp()->cloneTree(true),
 				    newSelBitWord(nodep->lsbp(), 1));
-		if (nodep->isQuad() && !midwordp->isQuad()) midwordp = new AstCast(nodep->fileline(), midwordp, nodep); 
+		if (nodep->isQuad() && !midwordp->isQuad()) midwordp = new AstCast(nodep->fileline(), midwordp, nodep);
 		// If we're selecting bit zero, then all 32 bits in word 1 get shifted << by 32 bits
 		// else we need to form the lower word, so we << by 31 or less
 		// nbitsfromlow <= (lsb==0) ? 64-bitbit(lsb) : 32-bitbit(lsb)
@@ -406,7 +410,7 @@ private:
 		    new AstWordSel (nodep->fromp()->fileline(),
 				    nodep->fromp()->cloneTree(true),
 				    newSelBitWord(nodep->lsbp(), 2));
-		if (nodep->isQuad() && !hiwordp->isQuad()) hiwordp = new AstCast(nodep->fileline(), hiwordp, nodep); 
+		if (nodep->isQuad() && !hiwordp->isQuad()) hiwordp = new AstCast(nodep->fileline(), hiwordp, nodep);
 		AstNode* himayp =
 		    new AstShiftL (nodep->fileline(),
 				   hiwordp,
@@ -434,7 +438,7 @@ private:
 	    UINFO(8,"    SEL->SHIFT "<<nodep<<endl);
 	    AstNode* fromp = nodep->fromp()->unlinkFrBack();
 	    AstNode* lsbp = nodep->lsbp()->unlinkFrBack();
-	    if (nodep->isQuad() && !fromp->isQuad()) fromp = new AstCast(nodep->fileline(), fromp, nodep); 
+	    if (nodep->isQuad() && !fromp->isQuad()) fromp = new AstCast(nodep->fileline(), fromp, nodep);
 	    AstNode* newp = new AstShiftR (nodep->fileline(),
 					   fromp,
 					   dropCondBound(lsbp),
@@ -504,7 +508,7 @@ private:
 	bool destwide = lhsp->fromp()->isWide();
 	bool ones = nodep->rhsp()->isAllOnesV();
 	if (lhsp->lsbp()->castConst()) {
-	    // The code should work without this constant test, but it won't 
+	    // The code should work without this constant test, but it won't
 	    // constify as nicely as we'd like.
 	    AstNode* rhsp = nodep->rhsp()->unlinkFrBack();
 	    AstNode* destp = lhsp->fromp()->unlinkFrBack();
@@ -531,6 +535,8 @@ private:
 								  rhsp, lsb)));
 		    }
 		}
+		rhsp->deleteTree(); rhsp=NULL;
+		destp->deleteTree(); destp=NULL;
 	    } else {
 		UINFO(8,"    ASSIGNSEL(const,narrow) "<<nodep<<endl);
 		if (destp->isQuad() && !rhsp->isQuad()) rhsp = new AstCast(nodep->fileline(), rhsp, nodep);
@@ -590,7 +596,7 @@ private:
 		//   For wide destp, we can either form a equation for every destination word,
 		// with the appropriate long equation of if it's being written or not.
 		//   Or, we can use a LHS variable arraysel with non-constant index to set the vector.
-		// Doing the variable arraysel is better for globals and large arrays, 
+		// Doing the variable arraysel is better for globals and large arrays,
 		// doing every word is better for temporaries and if we're setting most words
 		// since it may result in better substitution optimizations later.
 		//   This results in so much code, we're better off leaving a function call.
@@ -628,7 +634,7 @@ private:
 		//newp->dumpTree(cout,"-  new: ");
 		insertBefore(nodep,newp);
 		return true;
-	    }		
+	    }
 	}
     }
 
@@ -639,10 +645,10 @@ private:
 	} else {
 	    UINFO(8,"    CONCAT "<<nodep<<endl);
 	    AstNode* lhsp = nodep->lhsp()->unlinkFrBack();
-	    AstNode* rhsp = nodep->rhsp()->unlinkFrBack();	
+	    AstNode* rhsp = nodep->rhsp()->unlinkFrBack();
 	    int rhsshift = rhsp->widthMin();
-	    if (nodep->isQuad() && !lhsp->isQuad()) lhsp = new AstCast(nodep->fileline(), lhsp, nodep); 
-	    if (nodep->isQuad() && !rhsp->isQuad()) rhsp = new AstCast(nodep->fileline(), rhsp, nodep); 
+	    if (nodep->isQuad() && !lhsp->isQuad()) lhsp = new AstCast(nodep->fileline(), lhsp, nodep);
+	    if (nodep->isQuad() && !rhsp->isQuad()) rhsp = new AstCast(nodep->fileline(), rhsp, nodep);
 	    AstNode* newp = new AstOr (nodep->fileline(),
 				       new AstShiftL (nodep->fileline(),
 						      lhsp,
@@ -655,7 +661,7 @@ private:
     }
     bool expandWide (AstNodeAssign* nodep, AstConcat* rhsp) {
 	UINFO(8,"    Wordize ASSIGN(CONCAT) "<<nodep<<endl);
-	// Lhs or Rhs may be word, long, or quad. 
+	// Lhs or Rhs may be word, long, or quad.
 	// newAstWordSelClone nicely abstracts the difference.
 	int rhsshift = rhsp->rhsp()->widthMin();
 	// Sometimes doing the words backwards is preferrable.
@@ -668,7 +674,7 @@ private:
 						      rhsp->lhsp(), rhsshift),
 				     newAstWordSelClone (rhsp->rhsp(), w)));
 	}
- 	return true;
+	return true;
     }
 
     virtual void visit(AstReplicate* nodep, AstNUser*) {
@@ -687,8 +693,8 @@ private:
 		UINFO(8,"    REPLICATE "<<nodep<<endl);
 		AstConst* constp = nodep->rhsp()->castConst();
 		if (!constp) nodep->v3fatalSrc("Replication value isn't a constant.  Checked earlier!");
-		uint32_t times = constp->asInt();
-		if (nodep->isQuad() && !lhsp->isQuad()) lhsp = new AstCast(nodep->fileline(), lhsp, nodep); 
+		uint32_t times = constp->toUInt();
+		if (nodep->isQuad() && !lhsp->isQuad()) lhsp = new AstCast(nodep->fileline(), lhsp, nodep);
 		newp = lhsp->cloneTree(true);
 		for (unsigned repnum=1; repnum<times; repnum++) {
 		    int rhsshift = repnum*lhswidth;
@@ -712,7 +718,7 @@ private:
 	int lhswidth = lhsp->widthMin();
 	AstConst* constp = rhsp->rhsp()->castConst();
 	if (!constp) rhsp->v3fatalSrc("Replication value isn't a constant.  Checked earlier!");
-	uint32_t times = constp->asInt();
+	uint32_t times = constp->toUInt();
 	for (int w=0; w<rhsp->widthWords(); w++) {
 	    AstNode* newp;
 	    if (lhswidth==1) {
@@ -729,7 +735,7 @@ private:
 	    }
 	    addWordAssign(nodep, w, newp);
 	}
- 	return true;
+	return true;
     }
 
     virtual void visit(AstChangeXor* nodep, AstNUser*) {
@@ -803,7 +809,7 @@ private:
 	    for (int w=0; w<nodep->lhsp()->widthWords(); w++) {
 		AstNode* eqp = newAstWordSelClone (nodep->lhsp(), w);
 		if (w==nodep->lhsp()->widthWords()-1) {
-		    // Rather then doing a (slowish) ==##, we OR in the bits that aren't part of the mask
+		    // Rather than doing a (slowish) ==##, we OR in the bits that aren't part of the mask
 		    eqp = new AstOr (nodep->fileline(),
 				     new AstConst (nodep->fileline(), notWideMask(nodep->lhsp())),
 				     eqp);
@@ -904,7 +910,6 @@ public:
     }
     virtual ~ExpandVisitor() {}
     void main(AstNode* nodep) {
-	AstNode::userClearTree();	// userp() used on entire tree
 	nodep->accept(*this);
     }
 };

src/V3Expand.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Expansion of wide operator macros to C operators
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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

src/V3File.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: File stream wrapper that understands indentation
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -21,8 +21,9 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdarg.h>
+#include <cstdarg>
 #include <sys/stat.h>
+#include <sys/types.h>
 #include <unistd.h>
 #include <iomanip>
 #include <memory>
@@ -61,7 +62,7 @@ class V3FileDependImp {
 		}
 	    }
 	}
-	bool operator<(const DependFile& rhs) const { return filename()<rhs.filename(); };
+	bool operator<(const DependFile& rhs) const { return filename()<rhs.filename(); }
     };
 
     // MEMBERS
@@ -232,12 +233,21 @@ bool V3File::checkTimes(const string& filename, const string& cmdline) {
     return dependImp.checkTimes(filename, cmdline);
 }
 
+void V3File::createMakeDir() {
+    static bool created = false;
+    if (!created) {
+	created = true;
+	mkdir(v3Global.opt.makeDir().c_str(), 0777);
+    }
+}
+
 //######################################################################
 // V3OutFile: A class for printing to a file, with automatic indentation of C++ code.
 
 V3OutFile::V3OutFile(const string& filename)
-    : m_lineno(1), m_column(0), m_nobreak(false), m_prependIndent(true), m_indentLevel(0)
-      , m_declSAlign(0), m_declNSAlign(0), m_declPadNum(0) {
+    : m_filename(filename), m_lineno(1), m_column(0)
+    , m_nobreak(false), m_prependIndent(true), m_indentLevel(0)
+    , m_declSAlign(0), m_declNSAlign(0), m_declPadNum(0) {
     if ((m_fp = V3File::new_fopen_w(filename.c_str())) == NULL) {
 	v3fatal("Cannot write "<<filename);
     }
@@ -421,6 +431,23 @@ void V3OutFile::putBreak () {
     }
 }
 
+void V3OutFile::putsQuoted(const char* strg) {
+    // Quote \ and " for use inside C programs
+    // Don't use to quote a filename for #include - #include doesn't \ escape.
+    putcNoTracking('"');
+    for (const char* cp=strg; *cp; cp++) {
+	if (*cp == '\\') {
+	    putcNoTracking('\\');
+	    putcNoTracking('\\');
+	} else if (*cp == '"') {
+	    putcNoTracking('\\');
+	    putcNoTracking('"');
+	} else {
+	    putcNoTracking (*cp);
+	}
+    }
+    putcNoTracking('"');
+}
 void V3OutFile::putsNoTracking (const char *strg) {
     // Don't track {}'s, probably because it's a $display format string
     for (const char* cp=strg; *cp; cp++) {

src/V3File.h

@@ -1,16 +1,17 @@
-// $Id$ //-*- C++ -*-
+// -*- C++ -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: File stream wrapper that understands indentation
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -24,7 +25,7 @@
 #include "config_build.h"
 #include "verilatedos.h"
 #include "V3Error.h"
-#include <stdio.h>
+#include <cstdio>
 #include <stack>
 #include <set>
 #include <fstream>
@@ -46,6 +47,7 @@ public:
 	return new_ofstream_nodepend (filename, append);
     }
     static ofstream* new_ofstream_nodepend(const string& filename, bool append=false) {
+	if (filename != "/dev/null") createMakeDir();
 	if (append) {
 	    return new ofstream(filename.c_str(), ios::app);
 	} else {
@@ -53,15 +55,20 @@ public:
 	}
     }
     static FILE* new_fopen_w(const string& filename) {
+	if (filename != "/dev/null") createMakeDir();
 	addTgtDepend(filename);
 	return fopen(filename.c_str(),"w");
     }
+
     // Dependencies
     static void addSrcDepend(const string& filename);
     static void addTgtDepend(const string& filename);
     static void writeDepend(const string& filename);
     static void writeTimes(const string& filename, const string& cmdline);
     static bool checkTimes(const string& filename, const string& cmdline);
+
+    // Directory utilities
+    static void createMakeDir();
 };
 
 //============================================================================
@@ -81,6 +88,7 @@ public:
 private:
     // MEMBERS
     FILE*	m_fp;
+    string	m_filename;
     int		m_lineno;
     int		m_column;
     int		m_nobreak;	// Basic operator or begin paren, don't break next
@@ -105,6 +113,8 @@ public:
     void puts(const string& strg) { puts(strg.c_str()); }
     void putsNoTracking(const char* strg);
     void putsNoTracking(const string& strg) { putsNoTracking(strg.c_str()); }
+    void putsQuoted(const char* strg);
+    void putsQuoted(const string& strg) { putsQuoted(strg.c_str()); }
     void putBreak();  // Print linebreak if line is too wide
     void putBreakExpr();  // Print linebreak in expression if line is too wide
     void putAlign(bool isstatic/*AlignClass*/, int align, int size=0/*=align*/, const char* prefix=""); // Declare a variable, with natural alignment
@@ -113,9 +123,10 @@ public:
     bool exceededWidth() const { return m_column > WIDTH; }
     bool tokenStart(const char* cp, const char* cmp);
     bool tokenEnd(const char* cp);
-    void indentInc() { m_indentLevel += INDBLK; };
-    void indentDec() { m_indentLevel -= INDBLK;
-       UASSERT(m_indentLevel>=0,"Underflow of indentation\n");
+    void indentInc() { m_indentLevel += INDBLK; }
+    void indentDec() {
+	m_indentLevel -= INDBLK;
+	UASSERT(m_indentLevel>=0, ": "<<m_filename<<": Underflow of indentation\n");
     }
     void blockInc() { m_parenVec.push(m_indentLevel + INDBLK); }
     void blockDec() { if (!m_parenVec.empty()) m_parenVec.pop(); }

src/V3Gate.cpp

@@ -1,16 +1,16 @@
-// $Id$
 //*************************************************************************
 // DESCRIPTION: Verilator: Gate optimizations, such as wire elimination
 //
-// Code available from: http://www.veripool.com/verilator
+// Code available from: http://www.veripool.org/verilator
 //
 // AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
 //
 //*************************************************************************
 //
-// Copyright 2003-2007 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2009 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// General Public License or the Perl Artistic License.
+// 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
@@ -19,7 +19,7 @@
 //
 //*************************************************************************
 // V3Gate's Transformations:
-//		
+//
 // Extract a graph of the *entire* netlist with cells expanded
 // Perform constant optimization across the graph
 // Create VARSCOPEs for any variables we can rip out
@@ -28,8 +28,8 @@
 
 #include "config_build.h"
 #include "verilatedos.h"
-#include <stdio.h>
-#include <stdarg.h>
+#include <cstdio>
+#include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
 #include <iomanip>
@@ -49,7 +49,11 @@ typedef list<AstNodeVarRef*> GateVarRefList;
 
 class GateBaseVisitor : public AstNVisitor {
 public:
-    //int debug() { return 9; }
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
 };
 
 //######################################################################
@@ -170,7 +174,7 @@ private:
 	// V3Const cleans up any NOTs by flipping the edges for us
 	if (m_buffersOnly
 	    && !(nodep->rhsp()->castVarRef()
-		 // Until NEW_ORDERING, avoid making non-clocked logic into clocked, 
+		 // Until NEW_ORDERING, avoid making non-clocked logic into clocked,
 		 // as it slows down the verilator_sim_benchmark
 		 || (nodep->rhsp()->castNot()
 		     && nodep->rhsp()->castNot()->lhsp()->castVarRef()
@@ -230,8 +234,9 @@ class GateVisitor : public GateBaseVisitor {
 private:
     // NODE STATE
     //Entire netlist:
-    // AstVarScope::userp	-> GateVarVertex* for usage var, 0=not set yet
-    // {statement}Node::userp	-> GateLogicVertex* for this statement
+    // AstVarScope::user1p	-> GateVarVertex* for usage var, 0=not set yet
+    // {statement}Node::user1p	-> GateLogicVertex* for this statement
+    AstUser1InUse	m_inuser1;
 
     // STATE
     V3Graph		m_graph;	// Scoreboard of var usages/dependencies
@@ -263,11 +268,11 @@ private:
     }
 
     GateVarVertex* makeVarVertex(AstVarScope* varscp) {
-	GateVarVertex* vertexp = (GateVarVertex*)(varscp->userp());
+	GateVarVertex* vertexp = (GateVarVertex*)(varscp->user1p());
 	if (!vertexp) {
 	    UINFO(6,"New vertex "<<varscp<<endl);
 	    vertexp = new GateVarVertex(&m_graph, m_scopep, varscp);
-	    varscp->userp(vertexp);
+	    varscp->user1p(vertexp);
 	    if (varscp->varp()->isSigPublic()) {
 		// Public signals shouldn't be changed, pli code might be messing with them
 		vertexp->clearReducible("SigPublic");
@@ -294,8 +299,6 @@ private:
 
     // VISITORS
     virtual void visit(AstNetlist* nodep, AstNUser*) {
-	//VV*****  We reset userp() and user2p
-	AstNode::userClearTree();
 	nodep->iterateChildren(*this);
 	//if (debug()>6) m_graph.dump();
 	if (debug()>6) m_graph.dumpDotFilePrefixed("gate_pre");
@@ -317,6 +320,7 @@ private:
 	m_modp = nodep;
 	m_activeReducible = true;
 	nodep->iterateChildren(*this);
+	m_modp = NULL;
     }
     virtual void visit(AstScope* nodep, AstNUser*) {
 	UINFO(4," SCOPE "<<nodep<<endl);
@@ -341,9 +345,9 @@ private:
 	    if (!varscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp\n");
 	    GateVarVertex* varvertexp = makeVarVertex(varscp);
 	    UINFO(5," VARREF to "<<varscp<<endl);
-	    // We use weight of one; if we ref the var more then once, when we simplify,
+	    // We use weight of one; if we ref the var more than once, when we simplify,
 	    // the weight will increase
-	    if (nodep->lvalue()) {	
+	    if (nodep->lvalue()) {
 		new V3GraphEdge(&m_graph, m_logicVertexp, varvertexp, 1);
 	    } else {
 		new V3GraphEdge(&m_graph, varvertexp, m_logicVertexp, 1);
@@ -357,10 +361,21 @@ private:
 	iterateNewStmt(nodep, "User C Function", "User C Function");
     }
     virtual void visit(AstSenItem* nodep, AstNUser*) {
+	// Note we look at only AstSenItems, not AstSenGate's
+	// The gating term of a AstSenGate is normal logic
 	m_inSenItem = true;
-	iterateNewStmt(nodep, NULL, NULL);
+	if (m_logicVertexp) {  // Already under logic; presumably a SenGate
+	    nodep->iterateChildren(*this);
+	} else {  // Standalone item, probably right under a SenTree
+	    iterateNewStmt(nodep, NULL, NULL);
+	}
 	m_inSenItem = false;
     }
+    virtual void visit(AstSenGate* nodep, AstNUser*) {
+	// First handle the clock part will be handled in a minute by visit AstSenItem
+	// The logic gating term is delt with as logic
+	iterateNewStmt(nodep, "Clock gater", "Clock gater");
+    }
     virtual void visit(AstInitial* nodep, AstNUser*) {
 	bool lastslow = m_inSlow;
 	m_inSlow = true;
@@ -373,6 +388,9 @@ private:
     virtual void visit(AstAssignW* nodep, AstNUser*) {
 	iterateNewStmt(nodep, NULL, NULL);
     }
+    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+	iterateNewStmt(nodep, "CoverToggle", "CoverToggle");
+    }
     virtual void visit(AstTraceInc* nodep, AstNUser*) {
 	bool lastslow = m_inSlow;
 	m_inSlow = true;
@@ -421,7 +439,7 @@ void GateVisitor::optimizeSignals(bool allowMultiIn) {
 		if (!vvertexp->isTop()		// Ok if top inputs are driverless
 		    && !vvertexp->varScp()->varp()->initp()
 		    && !vvertexp->varScp()->varp()->isSigPublic()) {
-		    UINFO(1, "No drivers "<<vvertexp->varScp()<<endl);
+		    UINFO(4, "No drivers "<<vvertexp->varScp()<<endl);
 		    if (0) {
 			// If we warned here after constant propagation, what the user considered
 			// reasonable logic may have disappeared.  Issuing a warning would
@@ -433,7 +451,7 @@ void GateVisitor::optimizeSignals(bool allowMultiIn) {
 		}
 	    }
 	    else if (!vvertexp->inSize1()) {
-		vvertexp->clearReducible("size!1");	// Can't deal with more then one src
+		vvertexp->clearReducible("size!1");	// Can't deal with more than one src
 	    }
 	    // Reduce it?
 	    if (!vvertexp->reducible()) {
@@ -490,7 +508,7 @@ void GateVisitor::optimizeSignals(bool allowMultiIn) {
 			if (debug()>=5) substp->dumpTree(cout,"\t  subst:  ");
 			m_statSigs++;
 			while (V3GraphEdge* edgep = vvertexp->outBeginp()) {
- 			    GateLogicVertex* consumeVertexp = dynamic_cast<GateLogicVertex*>(edgep->top());
+			    GateLogicVertex* consumeVertexp = dynamic_cast<GateLogicVertex*>(edgep->top());
 			    AstNode* consumerp = consumeVertexp->nodep();
 			    optimizeElimVar(vvertexp->varScp(), substp, consumerp);
 			    // If the new replacement referred to a signal,
@@ -565,7 +583,7 @@ void GateVisitor::replaceAssigns() {
 		//if (debug()>9) {vscp->dumpTree(cout, "-vscDone: "); cout<<endl;}
 		if (!vscp->valuep()->castNodeMath()
 		    || vscp->valuep()->nextp()) {
-		    vscp->dumpTree(cout, "vscStrange: ");
+		    vscp->dumpTree(cerr, "vscStrange: ");
 		    vscp->v3fatalSrc("Value of varscope not mathematical\n");
 		}
 	    }