luke
/
iverilog
mirror of https://github.com/steveicarus/iverilog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
iverilog/PExpr.h

860 lines
28 KiB
C
Raw Normal View History

Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
#ifndef __PExpr_H
#define __PExpr_H
/*
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
* Copyright (c) 1998-2011 Stephen Williams <steve@icarus.com>
Add packages and their own scope. This makes <pkg>::<name> work properly, and also makes the package descriptions available through VPI.
2013-02-17 23:42:07 +01:00
* Copyright CERN 2013 / Stephen Williams (steve@icarus.com)
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
*
* This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU
* General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
updated FSF-address
2012-08-29 03:41:23 +02:00
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
*/
# include <string>
Allow part selects of memory words in l-values.
2006-02-02 03:43:57 +01:00
# include <vector>
Elaborate concatenation expression put tested widths to use. Concatenation expressions need to use the tested widths of its argument expressions during elaboration.
2008-11-19 01:52:05 +01:00
# include <valarray>
Parse OR of event expressions.
1999-04-29 04:16:26 +02:00
# include "netlist.h"
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
# include "verinum.h"
Add memories to the parse and elaboration phases.
1999-04-19 03:59:36 +02:00
# include "LineInfo.h"
Rework the heirarchical identifier parse syntax and pform to handle more general combinations of heirarch and bit selects.
2007-05-24 06:07:11 +02:00
# include "pform_types.h"
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
class Design;
Redo constant expression detection to happen after parsing. Parse more operators and expressions.
1999-05-16 07:08:42 +02:00
class Module;
Fix for pr2924354. Creation of implicit nets requires knowledge of whether an identifier has been declared before it is used. Currently implicit nets are created during elaboration, but by this stage the order of declaration and use is not known. This patch moves the creation of implicit nets into the parser stage.
2010-01-12 21:11:01 +01:00
class LexicalScope;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
class NetNet;
class NetExpr;
Redesign the implementation of scopes and parameters. I now generate the scopes and notice the parameters in a separate pass over the pform. Once the scopes are generated, I can process overrides and evalutate paremeters before elaboration begins.
2000-03-08 05:36:53 +01:00
class NetScope;
Add packages and their own scope. This makes <pkg>::<name> work properly, and also makes the package descriptions available through VPI.
2013-02-17 23:42:07 +01:00
class PPackage;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
/*
* The PExpr class hierarchy supports the description of
* expressions. The parser can generate expression objects from the
* source, possibly reducing things that it knows how to reduce.
*/
Add memories to the parse and elaboration phases.
1999-04-19 03:59:36 +02:00
class PExpr : public LineInfo {
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
public:
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
enum width_mode_t { SIZED, EXPAND, LOSSLESS, UNSIZED };
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
// Flag values that can be passed to elaborate_expr.
static const unsigned NO_FLAGS = 0x0;
static const unsigned NEED_CONST = 0x1;
static const unsigned SYS_TASK_ARG = 0x2;
Allow specparam declarations outside specify blocks. This patch extends the compiler to support all specparam declarations allowed by the 1364-2005 standard. For compatibility with other simulators, it allows specparam values to be used in any constant expression, but outputs a warning message and disables run-time annotation of a specparam if it is used in an expression that must be evaluated at compile time.
2012-05-07 00:11:26 +02:00
static const unsigned ANNOTATABLE = 0x4;
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
PExpr();
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
virtual ~PExpr();
virtual void dump(ostream&) const;
separate assign lval elaboration for error checking.
1999-09-15 06:17:52 +02:00
Fix for pr2924354. Creation of implicit nets requires knowledge of whether an identifier has been declared before it is used. Currently implicit nets are created during elaboration, but by this stage the order of declaration and use is not known. This patch moves the creation of implicit nets into the parser stage.
2010-01-12 21:11:01 +01:00
// This method tests whether the expression contains any identifiers
// that have not been previously declared in the specified scope or
// in any containing scope. Any such identifiers are added to the
// specified scope as scalar nets of the specified type.
//
// This operation must be performed by the parser, to ensure that
// subsequent declarations do not affect the decision to create an
// implicit net.
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type);
Checks for illegal use of automatically allocated variables. This patch adds a number of compile and run-time checks for illegal uses of variables declared in automatic tasks and functions. It also adds a check for event expressions in automatic tasks that use features not yet supported in VVP.
2008-11-09 01:26:55 +01:00
// This method tests whether the expression contains any
// references to automatically allocated variables.
virtual bool has_aa_term(Design*des, NetScope*scope) const;
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
// This method tests the type and width that the expression wants
// to be. It should be called before elaborating an expression to
// figure out the type and width of the expression. It also figures
// out the minimum width that can be used to evaluate the expression
// without changing the result. This allows the expression width to
// be pruned when not all bits of the result are used.
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
//
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
// Normally mode should be initialised to SIZED before starting to
// test the width of an expression. In SIZED mode the expression
// width will be calculated strictly according to the IEEE standard
// rules for expression width.
// If the expression contains an unsized literal, mode will be
// changed to LOSSLESS. In LOSSLESS mode the expression width will
// be calculated as the minimum width necessary to avoid arithmetic
// overflow or underflow.
// If the expression both contains an unsized literal and contains
// an operation that coerces a vector operand to a different type
// (signed <-> unsigned), mode is changed to UNSIZED. UNSIZED mode
// is the same as LOSSLESS, except that the final expression width
// will be forced to be at least integer_width. This is necessary
// to ensure compatibility with the IEEE standard, which requires
// unsized literals to be treated as having the same width as an
// integer. The lossless width calculation is inadequate in this
// case because coercing an operand to a different type means that
// the expression no longer obeys the normal rules of arithmetic.
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
//
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
// If mode is initialised to EXPAND instead of SIZED, the expression
// width will be calculated as the minimum width necessary to avoid
// arithmetic overflow or underflow, even if it contains no unsized
// literals. mode will be changed LOSSLESS or UNSIZED as described
// above. This supports a non-standard mode of expression width
// calculation.
Include a calculation of the expression type in test_width methods. The type of the sub-expression is sometimes needed by clients of the test_width methods, so add that as an output.
2008-09-27 07:20:11 +02:00
//
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
// When the final value of mode is UNSIZED, the width returned by
// this method is the calculated lossless width, but the width
// returned by a subsequent call to the expr_width method will be
// the final expression width.
Fix spacing problems. This patch fixes spacing problems in the source code, space/tab at the end of line and space before tab.
2011-03-03 05:23:02 +01:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
The test_width methods scan and mark expressions with type and size. Later passes need the intermediate results for width and size so that some special cases, were self-determined arguments occur, can be processed properly during elaboration. This can be especially tricky and interesting for ternary expressions.
2008-10-11 05:42:07 +02:00
// After the test_width method is complete, these methods
// return valid results.
ivl_variable_type_t expr_type() const { return expr_type_; }
unsigned expr_width() const { return expr_width_; }
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned min_width() const { return min_width_; }
bool has_sign() const { return signed_flag_; }
// This method allows the expression type (signed/unsigned)
// to be propagated down to any context-dependant operands.
void cast_signed(bool flag) { signed_flag_ = flag; }
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
Get some type information to the "new" expression for darrays.
2012-10-01 03:03:10 +02:00
// This is the more generic form of the elaborate_expr method
// below. The plan is to replace the simpler elaborate_expr
// method with this version, which can handle more advanced
// types. But for now, this is only implemented in special cases.
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const;
Make elaborate_expr methods aware of the width that the context requires of it. In the process, fix sizing of the width of unary minus is context determined sizes.
2006-06-02 06:48:49 +02:00
// Procedural elaboration of the expression. The expr_width is
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
// the required width of the expression.
Evaluate parameter expressions losslessly Make sure parameter expressions are evaluated losslessly, as if the l-value is unsigned and thus virtually infinite.
2007-06-28 07:05:36 +02:00
//
// The sys_task_arg flag is true if expressions are allowed to
// be incomplete.
Detect missing indices to memories (PR#421)
2002-04-13 04:33:17 +02:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
Redesign the implementation of scopes and parameters. I now generate the scopes and notice the parameters in a separate pass over the pform. Once the scopes are generated, I can process overrides and evalutate paremeters before elaboration begins.
2000-03-08 05:36:53 +01:00
separate assign lval elaboration for error checking.
1999-09-15 06:17:52 +02:00
// This method elaborates the expression as gates, but
// restricted for use as l-values of continuous assignments.
Move implicit net creation from elaboration to elaborate_sig If implicit nets are declared during elaboration, then the success of binding during elaboration will depend on the order of the code in the source file.
2008-03-19 04:50:40 +01:00
virtual NetNet* elaborate_lnet(Design*des, NetScope*scope) const;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
Implement bi-directional part selects.
2005-08-06 19:58:16 +02:00
// This is similar to elaborate_lnet, except that the
// expression is evaluated to be bi-directional. This is
// useful for arguments to inout ports of module instances and
// ports of tran primitives.
virtual NetNet* elaborate_bi_net(Design*des, NetScope*scope) const;
move lval elaboration to PExpr virtual methods.
2000-09-09 17:21:26 +02:00
// Expressions that can be in the l-value of procedural
Unify elaboration of l-values for all proceedural assignments, including assing, cassign and force. Generate NetConcat devices for gate outputs that feed into a vector results. Use this to hande gate arrays. Also let gate arrays handle vectors of gates when the outputs allow for it.
2004-12-30 00:55:43 +01:00
// assignments can be elaborated with this method. If the
// is_force flag is true, then the set of valid l-value types
Spelling fixes mostly comments, but includes some identifiers and message text
2008-01-25 22:34:51 +01:00
// is slightly modified to accommodate the Verilog force
Unify elaboration of l-values for all proceedural assignments, including assing, cassign and force. Generate NetConcat devices for gate outputs that feed into a vector results. Use this to hande gate arrays. Also let gate arrays handle vectors of gates when the outputs allow for it.
2004-12-30 00:55:43 +01:00
// statement
virtual NetAssign_* elaborate_lval(Design*des,
NetScope*scope,
bool is_force) const;
move lval elaboration to PExpr virtual methods.
2000-09-09 17:21:26 +02:00
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
// This attempts to evaluate a constant expression, and return
// a verinum as a result. If the expression cannot be
// evaluated, return 0.
Build errors in picky GCC compilers.
2007-06-04 21:14:06 +02:00
virtual verinum* eval_const(Design*des, NetScope*sc) const;
Check net ranges in declarations.
1998-11-11 01:01:51 +01:00
Fix for pr3194155. Currently the compiler coerces input ports to inout ports whenever there is an internal driver connected to the internal port net. This generates an error if the port is externally connected to something other than a structural net. This patch modifies the compiler to ensure port coercion only occurs in valid cases.
2011-03-13 14:29:42 +01:00
// This method returns true if the expression represents a
// structural net that can have multiple drivers. This is
// used to test whether an input port connection can be
// collapsed to a single wire.
virtual bool is_collapsible_net(Design*des, NetScope*scope) const;
Check net ranges in declarations.
1998-11-11 01:01:51 +01:00
// This method returns true if that expression is the same as
// this expression. This method is used for comparing
// expressions that must be structurally "identical".
virtual bool is_the_same(const PExpr*that) const;
Redo constant expression detection to happen after parsing. Parse more operators and expressions.
1999-05-16 07:08:42 +02:00
The test_width methods scan and mark expressions with type and size. Later passes need the intermediate results for width and size so that some special cases, were self-determined arguments occur, can be processed properly during elaboration. This can be especially tricky and interesting for ternary expressions.
2008-10-11 05:42:07 +02:00
protected:
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned fix_width_(width_mode_t mode);
The test_width methods scan and mark expressions with type and size. Later passes need the intermediate results for width and size so that some special cases, were self-determined arguments occur, can be processed properly during elaboration. This can be especially tricky and interesting for ternary expressions.
2008-10-11 05:42:07 +02:00
// The derived class test_width methods should fill these in.
ivl_variable_type_t expr_type_;
unsigned expr_width_;
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned min_width_;
bool signed_flag_;
The test_width methods scan and mark expressions with type and size. Later passes need the intermediate results for width and size so that some special cases, were self-determined arguments occur, can be processed properly during elaboration. This can be especially tricky and interesting for ternary expressions.
2008-10-11 05:42:07 +02:00
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
private: // not implemented
PExpr(const PExpr&);
PExpr& operator= (const PExpr&);
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
};
ostream& operator << (ostream&, const PExpr&);
Parse and elaborate the concatenate operator in structural contexts, Replace vector<PExpr*> and list<PExpr*> with svector<PExpr*>, evaluate constant expressions with parameters, handle memories as lvalues. Parse task declarations, integer types.
1999-05-10 02:16:57 +02:00
class PEConcat : public PExpr {
public:
Remove some uses of the svector template. I'm adding more uses of the make_range_from_width function, so it seems like time to get rid of its use of the svector template. This thread led to a lot of other uses of svector that had to also be removed.
2010-10-26 04:36:44 +02:00
PEConcat(const list<PExpr*>&p, PExpr*r =0);
Add support for the Ternary operator, Add support for repeat concatenation, Correct some seg faults cause by elaboration errors, Parse the casex anc casez statements.
1999-06-10 06:03:52 +02:00
~PEConcat();
Parse and elaborate the concatenate operator in structural contexts, Replace vector<PExpr*> and list<PExpr*> with svector<PExpr*>, evaluate constant expressions with parameters, handle memories as lvalues. Parse task declarations, integer types.
1999-05-10 02:16:57 +02:00
Build errors in picky GCC compilers.
2007-06-04 21:14:06 +02:00
virtual verinum* eval_const(Design*des, NetScope*sc) const;
Parse and elaborate the concatenate operator in structural contexts, Replace vector<PExpr*> and list<PExpr*> with svector<PExpr*>, evaluate constant expressions with parameters, handle memories as lvalues. Parse task declarations, integer types.
1999-05-10 02:16:57 +02:00
virtual void dump(ostream&) const;
Check lvalue of procedural continuous assign (PR#29)
2000-12-06 07:31:09 +01:00
Fix for pr2924354. Creation of implicit nets requires knowledge of whether an identifier has been declared before it is used. Currently implicit nets are created during elaboration, but by this stage the order of declaration and use is not known. This patch moves the creation of implicit nets into the parser stage.
2010-01-12 21:11:01 +01:00
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type);
Checks for illegal use of automatically allocated variables. This patch adds a number of compile and run-time checks for illegal uses of variables declared in automatic tasks and functions. It also adds a check for event expressions in automatic tasks that use features not yet supported in VVP.
2008-11-09 01:26:55 +01:00
virtual bool has_aa_term(Design*des, NetScope*scope) const;
Clean up some handling of test_width for ternary expressions. The condition expression needs its width tested, even if the width is not used. Also clean up some handling of widths/types for other expression types.
2008-10-19 07:00:22 +02:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
Clean up some handling of test_width for ternary expressions. The condition expression needs its width tested, even if the width is not used. Also clean up some handling of widths/types for other expression types.
2008-10-19 07:00:22 +02:00
Move implicit net creation from elaboration to elaborate_sig If implicit nets are declared during elaboration, then the success of binding during elaboration will depend on the order of the code in the source file.
2008-03-19 04:50:40 +01:00
virtual NetNet* elaborate_lnet(Design*des, NetScope*scope) const;
Allow concatenations as arguments to inout ports.
2006-04-28 06:28:35 +02:00
virtual NetNet* elaborate_bi_net(Design*des, NetScope*scope) const;
Detect missing indices to memories (PR#421)
2002-04-13 04:33:17 +02:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
Unify elaboration of l-values for all proceedural assignments, including assing, cassign and force. Generate NetConcat devices for gate outputs that feed into a vector results. Use this to hande gate arrays. Also let gate arrays handle vectors of gates when the outputs allow for it.
2004-12-30 00:55:43 +01:00
virtual NetAssign_* elaborate_lval(Design*des,
NetScope*scope,
bool is_force) const;
Fix for pr3194155. Currently the compiler coerces input ports to inout ports whenever there is an internal driver connected to the internal port net. This generates an error if the port is externally connected to something other than a structural net. This patch modifies the compiler to ensure port coercion only occurs in valid cases.
2011-03-13 14:29:42 +01:00
virtual bool is_collapsible_net(Design*des, NetScope*scope) const;
Allow concatenations as arguments to inout ports.
2006-04-28 06:28:35 +02:00
private:
NetNet* elaborate_lnet_common_(Design*des, NetScope*scope,
bool bidirectional_flag) const;
Parse and elaborate the concatenate operator in structural contexts, Replace vector<PExpr*> and list<PExpr*> with svector<PExpr*>, evaluate constant expressions with parameters, handle memories as lvalues. Parse task declarations, integer types.
1999-05-10 02:16:57 +02:00
private:
Remove some uses of the svector template. I'm adding more uses of the make_range_from_width function, so it seems like time to get rid of its use of the svector template. This thread led to a lot of other uses of svector that had to also be removed.
2010-10-26 04:36:44 +02:00
vector<PExpr*>parms_;
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
std::valarray<width_mode_t>width_modes_;
Elaborate concatenation expression put tested widths to use. Concatenation expressions need to use the tested widths of its argument expressions during elaboration.
2008-11-19 01:52:05 +01:00
Add support for the Ternary operator, Add support for repeat concatenation, Correct some seg faults cause by elaboration errors, Parse the casex anc casez statements.
1999-06-10 06:03:52 +02:00
PExpr*repeat_;
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
NetScope*tested_scope_;
unsigned repeat_count_;
Parse and elaborate the concatenate operator in structural contexts, Replace vector<PExpr*> and list<PExpr*> with svector<PExpr*>, evaluate constant expressions with parameters, handle memories as lvalues. Parse task declarations, integer types.
1999-05-10 02:16:57 +02:00
};
Named events as far as the pform.
2000-04-01 21:31:57 +02:00
/*
* Event expressions are expressions that can be combined with the
* event "or" operator. These include "posedge foo" and similar, and
* also include named events. "edge" events are associated with an
* expression, whereas named events simply have a name, which
* represents an event variable.
*/
Parse OR of event expressions.
1999-04-29 04:16:26 +02:00
class PEEvent : public PExpr {
public:
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
enum edge_t {ANYEDGE, POSEDGE, NEGEDGE, POSITIVE};
Named events as far as the pform.
2000-04-01 21:31:57 +02:00
// Use this constructor to create events based on edges or levels.
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
PEEvent(edge_t t, PExpr*e);
Named events as far as the pform.
2000-04-01 21:31:57 +02:00
~PEEvent();
Parse OR of event expressions.
1999-04-29 04:16:26 +02:00
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
edge_t type() const;
PExpr* expr() const;
Clean up spurious trailing white space.
2004-10-04 03:10:51 +02:00
Parse OR of event expressions.
1999-04-29 04:16:26 +02:00
virtual void dump(ostream&) const;
Checks for illegal use of automatically allocated variables. This patch adds a number of compile and run-time checks for illegal uses of variables declared in automatic tasks and functions. It also adds a check for event expressions in automatic tasks that use features not yet supported in VVP.
2008-11-09 01:26:55 +01:00
virtual bool has_aa_term(Design*des, NetScope*scope) const;
Parse OR of event expressions.
1999-04-29 04:16:26 +02:00
private:
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
edge_t type_;
PExpr *expr_;
Parse OR of event expressions.
1999-04-29 04:16:26 +02:00
};
Support decimal constants in behavioral delays.
2000-12-10 23:01:35 +01:00
/*
* This holds a floating point constant in the source.
*/
class PEFNumber : public PExpr {
public:
explicit PEFNumber(verireal*vp);
~PEFNumber();
const verireal& value() const;
/* The eval_const method as applied to a floating point number
gets the *integer* value of the number. This accounts for
any rounding that is needed to get the value. */
Build errors in picky GCC compilers.
2007-06-04 21:14:06 +02:00
virtual verinum* eval_const(Design*des, NetScope*sc) const;
Support decimal constants in behavioral delays.
2000-12-10 23:01:35 +01:00
Handle widths of real value arguments to user functions. The arguments to user defined functions are self-determined. And if the result is real valued, we can call them lossless self-determined. Treat these arguments like r-value elaboration for assignments. Also clean up the binary divide elaboration a little bit. Also, floating point literals are unsized with width==1.
2008-09-26 05:37:18 +02:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
Detect missing indices to memories (PR#421)
2002-04-13 04:33:17 +02:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
Generalize the evaluation of floating point delays, and get it working with delay assignment statements. Allow parameters to be referenced by hierarchical name.
2001-01-15 00:04:55 +01:00
Support decimal constants in behavioral delays.
2000-12-10 23:01:35 +01:00
virtual void dump(ostream&) const;
private:
verireal*value_;
};
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
class PEIdent : public PExpr {
public:
Allow connecting module instance using implicit named port connections. This is part of the 1800-2009 standard (Section 23.3.2.3) and allows ports of module instances to be declared like: modname instance(.foo, .bar); instead of modname instead(.foo(foo), .bar(bar)); The only tricky part about this is the implicit port connection shall not create an implicit net declaration. To make this happen, the path of least resistance was to add a bool to PEIdent indicating that it should not implicitely create a net. This does not rely on the generation flag to be 2009, following the trend that new port naming convention (like ANSI style ports) work regardless of the generation.
2009-11-26 07:10:53 +01:00
explicit PEIdent(perm_string, bool no_implicit_sig=false);
Add packages and their own scope. This makes <pkg>::<name> work properly, and also makes the package descriptions available through VPI.
2013-02-17 23:42:07 +01:00
explicit PEIdent(PPackage*pkg, perm_string name);
Rework the heirarchical identifier parse syntax and pform to handle more general combinations of heirarch and bit selects.
2007-05-24 06:07:11 +02:00
explicit PEIdent(const pform_name_t&);
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
~PEIdent();
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
Spelling fixes mostly comments, but includes some identifiers and message text
2008-01-25 22:34:51 +01:00
// Add another name to the string of hierarchy that is the
Rework the heirarchical identifier parse syntax and pform to handle more general combinations of heirarch and bit selects.
2007-05-24 06:07:11 +02:00
// current identifier.
void append_name(perm_string);
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
virtual void dump(ostream&) const;
Checks for illegal use of automatically allocated variables. This patch adds a number of compile and run-time checks for illegal uses of variables declared in automatic tasks and functions. It also adds a check for event expressions in automatic tasks that use features not yet supported in VVP.
2008-11-09 01:26:55 +01:00
Fix for pr2924354. Creation of implicit nets requires knowledge of whether an identifier has been declared before it is used. Currently implicit nets are created during elaboration, but by this stage the order of declaration and use is not known. This patch moves the creation of implicit nets into the parser stage.
2010-01-12 21:11:01 +01:00
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type);
Checks for illegal use of automatically allocated variables. This patch adds a number of compile and run-time checks for illegal uses of variables declared in automatic tasks and functions. It also adds a check for event expressions in automatic tasks that use features not yet supported in VVP.
2008-11-09 01:26:55 +01:00
virtual bool has_aa_term(Design*des, NetScope*scope) const;
Remove last bits of relax_width methods, and use test_width to calculate the width of an r-value expression that may contain unsized numbers.
2006-11-04 07:19:24 +01:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
separate assign lval elaboration for error checking.
1999-09-15 06:17:52 +02:00
// Identifiers are allowed (with restrictions) is assign l-values.
Move implicit net creation from elaboration to elaborate_sig If implicit nets are declared during elaboration, then the success of binding during elaboration will depend on the order of the code in the source file.
2008-03-19 04:50:40 +01:00
virtual NetNet* elaborate_lnet(Design*des, NetScope*scope) const;
separate assign lval elaboration for error checking.
1999-09-15 06:17:52 +02:00
Implement bi-directional part selects.
2005-08-06 19:58:16 +02:00
virtual NetNet* elaborate_bi_net(Design*des, NetScope*scope) const;
move lval elaboration to PExpr virtual methods.
2000-09-09 17:21:26 +02:00
// Identifiers are also allowed as procedural assignment l-values.
Unify elaboration of l-values for all proceedural assignments, including assing, cassign and force. Generate NetConcat devices for gate outputs that feed into a vector results. Use this to hande gate arrays. Also let gate arrays handle vectors of gates when the outputs allow for it.
2004-12-30 00:55:43 +01:00
virtual NetAssign_* elaborate_lval(Design*des,
NetScope*scope,
bool is_force) const;
move lval elaboration to PExpr virtual methods.
2000-09-09 17:21:26 +02:00
Handle class-type identifier expressions.
2012-11-22 20:08:13 +01:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const;
Detect missing indices to memories (PR#421)
2002-04-13 04:33:17 +02:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
separate assign lval elaboration for error checking.
1999-09-15 06:17:52 +02:00
Module ports are really special PEIdent expressions, because a name can be used many places in the port list.
2000-05-16 06:05:15 +02:00
// Elaborate the PEIdent as a port to a module. This method
// only applies to Ident expressions.
Extend VPI and build to for SIMetrix cosimulation Added: basic vpiPort VPI Objects for vpiModulkes vpiDirection, vpiPortIndex, vpiName, vpiSize attributes Since ports do not exist as net-like entities (nets either side module instance boundaries are in effect connect directly in the language front-ends internal representation) the port information is effectively just meta-data passed through t-dll interface and output as a additional annotation of module scopes in vvp. Added: vpiLocalParam attribute for vpiParameter VPI objects Added: support build for 32-bit target on 64-bit host (--with-m32 option to configure.in and minor tweaks to Makefiles and systemc-vpi).
2012-06-04 21:43:33 +02:00
NetNet* elaborate_subport(Design*des, NetScope*sc) const;
Module ports are really special PEIdent expressions, because a name can be used many places in the port list.
2000-05-16 06:05:15 +02:00
Build errors in picky GCC compilers.
2007-06-04 21:14:06 +02:00
verinum* eval_const(Design*des, NetScope*sc) const;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
Fix for pr3194155. Currently the compiler coerces input ports to inout ports whenever there is an internal driver connected to the internal port net. This generates an error if the port is externally connected to something other than a structural net. This patch modifies the compiler to ensure port coercion only occurs in valid cases.
2011-03-13 14:29:42 +01:00
virtual bool is_collapsible_net(Design*des, NetScope*scope) const;
Rework the heirarchical identifier parse syntax and pform to handle more general combinations of heirarch and bit selects.
2007-05-24 06:07:11 +02:00
const pform_name_t& path() const { return path_; }
private:
Add packages and their own scope. This makes <pkg>::<name> work properly, and also makes the package descriptions available through VPI.
2013-02-17 23:42:07 +01:00
PPackage*package_;
Rework the heirarchical identifier parse syntax and pform to handle more general combinations of heirarch and bit selects.
2007-05-24 06:07:11 +02:00
pform_name_t path_;
Allow connecting module instance using implicit named port connections. This is part of the 1800-2009 standard (Section 23.3.2.3) and allows ports of module instances to be declared like: modname instance(.foo, .bar); instead of modname instead(.foo(foo), .bar(bar)); The only tricky part about this is the implicit port connection shall not create an implicit net declaration. To make this happen, the path of least resistance was to add a bool to PEIdent indicating that it should not implicitely create a net. This does not rely on the generation flag to be 2009, following the trend that new port naming convention (like ANSI style ports) work regardless of the generation.
2009-11-26 07:10:53 +01:00
bool no_implicit_sig_;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
Remove last bits of relax_width methods, and use test_width to calculate the width of an r-value expression that may contain unsized numbers.
2006-11-04 07:19:24 +01:00
private:
Handle part selects with bad (xz) bits. Part selects need to be fully defined. If not, then the resulting expression is 'bx no matter what. The same for bit selects, when the bit select expression is constant.
2009-01-02 01:20:41 +01:00
// Common functions to calculate parts of part/bit
// selects. These methods return true if the expressions
// elaborate/calculate, or false if there is some sort of
// source error.
Improve net bit select calculations.
2012-04-30 20:48:33 +02:00
bool calculate_bits_(Design*, NetScope*, long&msb, bool&defined) const;
Handle part selects with bad (xz) bits. Part selects need to be fully defined. If not, then the resulting expression is 'bx no matter what. The same for bit selects, when the bit select expression is constant.
2009-01-02 01:20:41 +01:00
// The calculate_parts_ method calculates the range
// expressions of a part select for the current object. The
// part select expressions are elaborated and evaluated, and
// the values written to the msb/lsb arguments. If there are
// invalid bits (xz) in either expression, then the defined
// flag is set to *false*.
bool calculate_parts_(Design*, NetScope*, long&msb, long&lsb, bool&defined) const;
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
NetExpr* calculate_up_do_base_(Design*, NetScope*, bool need_const) const;
Fix up parameter name part select Part select of parameter names is fixed up to be structurally similar to part select of signals, and also to behave similarly. (Though not identically, for reason.)
2008-06-08 16:34:45 +02:00
bool calculate_param_range_(Design*, NetScope*,
const NetExpr*msb_ex, long&msb,
Fix some constant bit/part select bugs and add warnings. This patch fixes a few bugs in constant bit/part selects and adds optional warnings for out of bound or undefined selects.
2010-01-10 04:57:01 +01:00
const NetExpr*lsb_ex, long&lsb,
long length) const;
Fix up parameter name part select Part select of parameter names is fixed up to be structurally similar to part select of signals, and also to behave similarly. (Though not identically, for reason.)
2008-06-08 16:34:45 +02:00
Remove last bits of relax_width methods, and use test_width to calculate the width of an r-value expression that may contain unsized numbers.
2006-11-04 07:19:24 +01:00
bool calculate_up_do_width_(Design*, NetScope*, unsigned long&wid) const;
Get packed signals working through to simulation in some situations. When dynamic indexing of early dimensions is not needed, we can get pretty far with getting packed arrays to work.
2012-02-11 02:17:59 +01:00
// Evaluate the prefix indices. All but the final index in a
// chain of indices must be a single value and must evaluate
// to constants at compile time. For example:
// [x] - OK
// [1][2][x] - OK
// [1][x:y] - OK
// [2:0][x] - BAD
// [y][x] - BAD
// Leave the last index for special handling.
bool calculate_packed_indices_(Design*des, NetScope*scope, NetNet*net,
std::list<long>&prefix_indices) const;
Fix part selects in l-values.
2006-04-16 02:15:43 +02:00
private:
Elaborate class task and function methods. The parse of class methods already works, this patch forms the methods into their own scopes, and elaborates those scopes. The "this"
2013-03-15 04:08:32 +01:00
NetAssign_*elaborate_lval_method_class_member_(Design*, NetScope*) const;
Major rework of array handling. Memories are replaced with the more general concept of arrays. The NetMemory and NetEMemory classes are removed from the ivl core program, and the IVL_LPM_RAM lpm type is removed from the ivl_target API.
2007-01-16 06:44:14 +01:00
NetAssign_*elaborate_lval_net_word_(Design*, NetScope*, NetNet*) const;
Allow l-value part select to be out of bounds. It is legal (though worthy of a warning, I think) for the part select of an l-value to me out of bounds, so replace the error message with a warning, and generate the appropriate code. In the process, clean up some of the code for signal l-values to divide out the various kinds of processing that can be done. This cleans things up a bit.
2008-06-15 06:22:55 +02:00
bool elaborate_lval_net_bit_(Design*, NetScope*, NetAssign_*) const;
Major rework of array handling. Memories are replaced with the more general concept of arrays. The NetMemory and NetEMemory classes are removed from the ivl core program, and the IVL_LPM_RAM lpm type is removed from the ivl_target API.
2007-01-16 06:44:14 +01:00
bool elaborate_lval_net_part_(Design*, NetScope*, NetAssign_*) const;
More array fixes and down indexed part selects can be a lval. Here are some more array fixes. They are mostly better error messages instead of just asserting and some code cleanup. The one new thing that probably should have been a separate submission is that down indexed part select [base -: width] can now be a lvalue.
2007-11-07 20:26:56 +01:00
bool elaborate_lval_net_idx_(Design*, NetScope*, NetAssign_*,
index_component_t::ctype_t) const;
Flesh out class type elaboration Add properties to the classes, and elaborate expressions that have class properties. Describe class object property references all the way down to the stub target.
2012-11-25 19:13:05 +01:00
bool elaborate_lval_net_class_member_(Design*, NetScope*,
NetAssign_*,
const perm_string&) const;
Packed struct members in behavioral assign l-values.
2012-01-04 02:38:08 +01:00
bool elaborate_lval_net_packed_member_(Design*, NetScope*,
NetAssign_*,
const perm_string&) const;
Elaborate dynamic array expressions (lval/rval) down to ivl_target.h
2012-07-21 17:59:29 +02:00
bool elaborate_lval_darray_bit_(Design*, NetScope*,
NetAssign_*) const;
Fix part selects in l-values.
2006-04-16 02:15:43 +02:00
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
private:
Elaborate of PGAssign always passes calculated width. the PGAssign elaborate method used the test_width to get the width of the r-value expression. This should be completely sufficient to get the width of the expression, so always use a defined width to elaborate the expression.
2008-09-21 04:23:54 +02:00
NetExpr*elaborate_expr_param_(Design*des,
NetScope*scope,
const NetExpr*par,
Fix the compiler to keep the original file/line information. For a parameter we want to keep the base definition file/line information not the file/line information for the override.
2012-01-02 19:11:56 +01:00
NetScope*found_in,
Elaborate of PGAssign always passes calculated width. the PGAssign elaborate method used the test_width to get the width of the r-value expression. This should be completely sufficient to get the width of the expression, so always use a defined width to elaborate the expression.
2008-09-21 04:23:54 +02:00
const NetExpr*par_msb,
const NetExpr*par_lsb,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned expr_wid,
unsigned flags) const;
Fix up parameter name part select Part select of parameter names is fixed up to be structurally similar to part select of signals, and also to behave similarly. (Though not identically, for reason.)
2008-06-08 16:34:45 +02:00
NetExpr*elaborate_expr_param_part_(Design*des,
NetScope*scope,
const NetExpr*par,
Fix the compiler to keep the original file/line information. For a parameter we want to keep the base definition file/line information not the file/line information for the override.
2012-01-02 19:11:56 +01:00
NetScope*found_in,
Fix up parameter name part select Part select of parameter names is fixed up to be structurally similar to part select of signals, and also to behave similarly. (Though not identically, for reason.)
2008-06-08 16:34:45 +02:00
const NetExpr*par_msb,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
const NetExpr*par_lsb,
unsigned expr_wid) const;
Rework parameter indexed part select up. Indexed part select reworked to be more compact and more like the part select.
2008-06-09 04:29:00 +02:00
NetExpr*elaborate_expr_param_idx_up_(Design*des,
NetScope*scope,
const NetExpr*par,
Fix the compiler to keep the original file/line information. For a parameter we want to keep the base definition file/line information not the file/line information for the override.
2012-01-02 19:11:56 +01:00
NetScope*found_in,
Rework parameter indexed part select up. Indexed part select reworked to be more compact and more like the part select.
2008-06-09 04:29:00 +02:00
const NetExpr*par_msb,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
const NetExpr*par_lsb,
bool need_const) const;
Major rewrite of indexed part selects. This patch is a major rewrite of the indexed part selects (+: and -:). It made the following enhancements: 1. Make indexed part selects work correctly with both big and little endian vectors. 2. Add a warning flag that warns about constant out of bounds/or 'bx indexed selects. 3. Moved the -: parameter code to its own routine. 4. Added support for straddling before part selects in a CA. 5. Added more assert(! number_is_unknown) statements. 6. Add warning for &PV<> select with a signed index signal that is less than the width of an int. This will be fixed later. 7. Add support for loading a 'bx/'bz constant into a numeric register. 8. Add a number of signed value fixes to the compiler/code generator. 9. Major fix of draw_select_expr() in the code generator.
2009-08-29 01:50:59 +02:00
NetExpr*elaborate_expr_param_idx_do_(Design*des,
NetScope*scope,
const NetExpr*par,
Fix the compiler to keep the original file/line information. For a parameter we want to keep the base definition file/line information not the file/line information for the override.
2012-01-02 19:11:56 +01:00
NetScope*found_in,
Major rewrite of indexed part selects. This patch is a major rewrite of the indexed part selects (+: and -:). It made the following enhancements: 1. Make indexed part selects work correctly with both big and little endian vectors. 2. Add a warning flag that warns about constant out of bounds/or 'bx indexed selects. 3. Moved the -: parameter code to its own routine. 4. Added support for straddling before part selects in a CA. 5. Added more assert(! number_is_unknown) statements. 6. Add warning for &PV<> select with a signed index signal that is less than the width of an int. This will be fixed later. 7. Add support for loading a 'bx/'bz constant into a numeric register. 8. Add a number of signed value fixes to the compiler/code generator. 9. Major fix of draw_select_expr() in the code generator.
2009-08-29 01:50:59 +02:00
const NetExpr*par_msb,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
const NetExpr*par_lsb,
bool need_const) const;
Reorganize signal part select handling, and add support for indexed part selects. Expand expression constant propagation to eliminate extra sums in certain cases.
2005-11-10 14:28:11 +01:00
NetExpr*elaborate_expr_net(Design*des,
Major rework of array handling. Memories are replaced with the more general concept of arrays. The NetMemory and NetEMemory classes are removed from the ivl core program, and the IVL_LPM_RAM lpm type is removed from the ivl_target API.
2007-01-16 06:44:14 +01:00
NetScope*scope,
NetNet*net,
NetScope*found,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
Major rework of array handling. Memories are replaced with the more general concept of arrays. The NetMemory and NetEMemory classes are removed from the ivl core program, and the IVL_LPM_RAM lpm type is removed from the ivl_target API.
2007-01-16 06:44:14 +01:00
NetExpr*elaborate_expr_net_word_(Design*des,
NetScope*scope,
NetNet*net,
NetScope*found,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
Reorganize signal part select handling, and add support for indexed part selects. Expand expression constant propagation to eliminate extra sums in certain cases.
2005-11-10 14:28:11 +01:00
NetExpr*elaborate_expr_net_part_(Design*des,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
NetScope*scope,
NetESignal*net,
NetScope*found,
unsigned expr_wid) const;
Reorganize signal part select handling, and add support for indexed part selects. Expand expression constant propagation to eliminate extra sums in certain cases.
2005-11-10 14:28:11 +01:00
NetExpr*elaborate_expr_net_idx_up_(Design*des,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
NetScope*scope,
NetESignal*net,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
NetScope*found,
bool need_const) const;
Reorganize signal part select handling, and add support for indexed part selects. Expand expression constant propagation to eliminate extra sums in certain cases.
2005-11-10 14:28:11 +01:00
NetExpr*elaborate_expr_net_idx_do_(Design*des,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
NetScope*scope,
NetESignal*net,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
NetScope*found,
bool need_const) const;
Reorganize signal part select handling, and add support for indexed part selects. Expand expression constant propagation to eliminate extra sums in certain cases.
2005-11-10 14:28:11 +01:00
NetExpr*elaborate_expr_net_bit_(Design*des,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
NetScope*scope,
NetESignal*net,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
NetScope*found,
bool need_const) const;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
Elaborate class task and function methods. The parse of class methods already works, this patch forms the methods into their own scopes, and elaborates those scopes. The "this"
2013-03-15 04:08:32 +01:00
NetExpr*elaborate_expr_class_member_(Design*des,
NetScope*scope,
unsigned expr_wid,
unsigned flags) const;
Add support for memory words in l-value of blocking assignments, and remove the special NetAssignMem class.
2002-06-04 07:38:43 +02:00
private:
Implement bi-directional part selects.
2005-08-06 19:58:16 +02:00
NetNet* elaborate_lnet_common_(Design*des, NetScope*scope,
bool bidirectional_flag) const;
Use PartSelect/PV and VP to handle part selects through ports.
2005-01-09 21:16:00 +01:00
bool eval_part_select_(Design*des, NetScope*scope, NetNet*sig,
Handle part selects of nets that fall of the ends of the identifier. The Verilog LRM specifies that it is legal to give constant part selects that are beyond the bounds of the identifier being selected. But elaboration was flagging that as an error. This patch changes it to a warning, and handles the cases by generating 'bx bits as needed.
2008-05-10 02:42:37 +02:00
long&midx, long&lidx) const;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
};
Parse support for dynamic arrays. This includes limited support for dynamic arrays down to the code generator, and some stubs in the vvp code generator and vvp run time.
2012-07-14 03:41:41 +02:00
class PENew : public PExpr {
public:
explicit PENew (PExpr*s);
~PENew();
virtual void dump(ostream&) const;
Support the new[] operator for arrays Implement through the ivl core to the ivl_target.h API. Also draft implementation of creating and storing arrays in the vvp runtime and code generator.
2012-07-16 05:44:07 +02:00
virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode);
Get some type information to the "new" expression for darrays.
2012-10-01 03:03:10 +02:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const;
Support the new[] operator for arrays Implement through the ivl core to the ivl_target.h API. Also draft implementation of creating and storing arrays in the vvp runtime and code generator.
2012-07-16 05:44:07 +02:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid,
unsigned flags) const;
Parse support for dynamic arrays. This includes limited support for dynamic arrays down to the code generator, and some stubs in the vvp code generator and vvp run time.
2012-07-14 03:41:41 +02:00
private:
PExpr*size_;
};
Elaborate class_new and (null) expressions This gets the types right for class_new and null expressions, and elaborate them down to the ivl_target.h API.
2012-11-12 02:42:31 +01:00
class PENewClass : public PExpr {
public:
explicit PENewClass ();
~PENewClass();
virtual void dump(ostream&) const;
// Class objects don't have a useful width, but the expression
// is IVL_VT_CLASS.
virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode);
// Note that class (new) expressions only appear in context
// that uses this form of the elaborate_expr method. In fact,
// the type argument is going to be a netclas_t object.
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const;
private:
};
Stub to pform class properties and null expressions.
2012-11-04 01:41:11 +01:00
class PENull : public PExpr {
public:
explicit PENull();
~PENull();
virtual void dump(ostream&) const;
Elaborate class_new and (null) expressions This gets the types right for class_new and null expressions, and elaborate them down to the ivl_target.h API.
2012-11-12 02:42:31 +01:00
virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode);
Handle null objects in general.
2012-11-22 02:48:46 +01:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const;
Elaborate class_new and (null) expressions This gets the types right for class_new and null expressions, and elaborate them down to the ivl_target.h API.
2012-11-12 02:42:31 +01:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid,
unsigned flags) const;
Stub to pform class properties and null expressions.
2012-11-04 01:41:11 +01:00
};
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
class PENumber : public PExpr {
public:
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
explicit PENumber(verinum*vp);
~PENumber();
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
const verinum& value() const;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
virtual void dump(ostream&) const;
Remove last bits of relax_width methods, and use test_width to calculate the width of an r-value expression that may contain unsized numbers.
2006-11-04 07:19:24 +01:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
Add support for darrays as class properties.
2013-01-27 21:30:38 +01:00
virtual NetEConst*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const;
Detect missing indices to memories (PR#421)
2002-04-13 04:33:17 +02:00
virtual NetEConst*elaborate_expr(Design*des, NetScope*,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned expr_wid, unsigned) const;
Unify elaboration of l-values for all proceedural assignments, including assing, cassign and force. Generate NetConcat devices for gate outputs that feed into a vector results. Use this to hande gate arrays. Also let gate arrays handle vectors of gates when the outputs allow for it.
2004-12-30 00:55:43 +01:00
virtual NetAssign_* elaborate_lval(Design*des,
NetScope*scope,
bool is_force) const;
Constant expressions are not l-values for task ports.
2002-03-09 05:02:26 +01:00
Build errors in picky GCC compilers.
2007-06-04 21:14:06 +02:00
virtual verinum* eval_const(Design*des, NetScope*sc) const;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
Check net ranges in declarations.
1998-11-11 01:01:51 +01:00
virtual bool is_the_same(const PExpr*that) const;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
private:
verinum*const value_;
};
Support elaborate_net for PEString objects.
2001-12-30 22:32:03 +01:00
/*
* This represents a string constant in an expression.
*
* The s parameter to the PEString constructor is a C string that this
* class instance will take for its own. The caller should not delete
* the string, the destructor will do it.
*/
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
class PEString : public PExpr {
public:
Support elaborate_net for PEString objects.
2001-12-30 22:32:03 +01:00
explicit PEString(char*s);
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
~PEString();
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
Named events really should be expressed with PEIdent objects in the pform, Handle named events within the mix of net events and edges. As a unified lot they get caught together. wait statements are broken into more complex statements that include a conditional. Do not generate NetPEvent or NetNEvent objects in elaboration. NetEvent, NetEvWait and NetEvProbe take over those functions in the netlist.
2000-04-12 06:23:57 +02:00
string value() const;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
virtual void dump(ostream&) const;
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
Add test_width methods for PETernary and PEString.
2006-11-10 05:54:26 +01:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
Add test_width methods for PETernary and PEString.
2006-11-10 05:54:26 +01:00
Detect missing indices to memories (PR#421)
2002-04-13 04:33:17 +02:00
virtual NetEConst*elaborate_expr(Design*des, NetScope*,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned expr_wid, unsigned) const;
Build errors in picky GCC compilers.
2007-06-04 21:14:06 +02:00
verinum* eval_const(Design*, NetScope*) const;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
private:
Support elaborate_net for PEString objects.
2001-12-30 22:32:03 +01:00
char*text_;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
};
class PEUnary : public PExpr {
public:
Allow unary operators in constant expressions.
2000-06-30 17:50:20 +02:00
explicit PEUnary(char op, PExpr*ex);
~PEUnary();
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
virtual void dump(ostream&out) const;
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
Fix for pr2924354. Creation of implicit nets requires knowledge of whether an identifier has been declared before it is used. Currently implicit nets are created during elaboration, but by this stage the order of declaration and use is not known. This patch moves the creation of implicit nets into the parser stage.
2010-01-12 21:11:01 +01:00
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type);
Checks for illegal use of automatically allocated variables. This patch adds a number of compile and run-time checks for illegal uses of variables declared in automatic tasks and functions. It also adds a check for event expressions in automatic tasks that use features not yet supported in VVP.
2008-11-09 01:26:55 +01:00
virtual bool has_aa_term(Design*des, NetScope*scope) const;
Real valued nets are signed, and pform unary expression have width. Real valued nets should ne treated as signed no matter what. Also, PEUnary nary expressions need a useful test_width method.
2008-08-16 07:03:19 +02:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
Real valued nets are signed, and pform unary expression have width. Real valued nets should ne treated as signed no matter what. Also, PEUnary nary expressions need a useful test_width method.
2008-08-16 07:03:19 +02:00
Precalculate unary - if possible.
2002-04-14 05:55:25 +02:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
Build errors in picky GCC compilers.
2007-06-04 21:14:06 +02:00
virtual verinum* eval_const(Design*des, NetScope*sc) const;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
Implement increment/decrement statements. During parse/pform processing, convert increment statements to the equivalent compressed assignment statement. This is less weird for elaboration processing and better expresses what is going on.
2012-02-20 03:54:58 +01:00
public:
inline char get_op() const { return op_; }
inline PExpr*get_expr() const { return expr_; }
Pad the subexpression of unary not. The operand of unary not needs to be padded to the expression width before the operator itself. Otherwise, the high (pad) bits will come out wrong.
2008-10-13 06:38:07 +02:00
private:
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
NetExpr* elaborate_expr_bits_(NetExpr*operand, unsigned expr_wid) const;
Pad the subexpression of unary not. The operand of unary not needs to be padded to the expression width before the operator itself. Otherwise, the high (pad) bits will come out wrong.
2008-10-13 06:38:07 +02:00
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
private:
char op_;
PExpr*expr_;
};
class PEBinary : public PExpr {
public:
Support more real arithmetic in delay constants.
2001-11-06 07:11:55 +01:00
explicit PEBinary(char op, PExpr*l, PExpr*r);
~PEBinary();
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
virtual void dump(ostream&out) const;
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
Fix for pr2924354. Creation of implicit nets requires knowledge of whether an identifier has been declared before it is used. Currently implicit nets are created during elaboration, but by this stage the order of declaration and use is not known. This patch moves the creation of implicit nets into the parser stage.
2010-01-12 21:11:01 +01:00
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type);
Checks for illegal use of automatically allocated variables. This patch adds a number of compile and run-time checks for illegal uses of variables declared in automatic tasks and functions. It also adds a check for event expressions in automatic tasks that use features not yet supported in VVP.
2008-11-09 01:26:55 +01:00
virtual bool has_aa_term(Design*des, NetScope*scope) const;
Remove last bits of relax_width methods, and use test_width to calculate the width of an r-value expression that may contain unsized numbers.
2006-11-04 07:19:24 +01:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
Fix left shift of unsized constants in sef-determined context. When left-shifting unsized constants in self-determined contexts, the constant value is normally pared down to its minimum required width. But this practically guarantees loss of bits. Instead, detect this special case and give the unsized constant a width of an integer. Still allow for the super-special case that the shifted value and the shift amount are constants. In that case, the result width (and value) can be calculated precisely and there is no need to resort to default widths.
2008-04-22 20:23:24 +02:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
Build errors in picky GCC compilers.
2007-06-04 21:14:06 +02:00
virtual verinum* eval_const(Design*des, NetScope*sc) const;
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
protected:
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
char op_;
PExpr*left_;
PExpr*right_;
Include subtraction in LPM_ADD_SUB device.
1999-10-31 21:08:24 +01:00
Fix the signed-ness calculations of +- in parameter expressions. This fixes up the elaboration of binary expressions found in parameter expressions. Parameter expressions are special because they elaborate early, before all the other parameters are necessarily completed.
2008-12-19 06:33:31 +01:00
NetExpr*elaborate_expr_base_(Design*, NetExpr*lp, NetExpr*rp,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid) const;
Fix the signed-ness calculations of +- in parameter expressions. This fixes up the elaboration of binary expressions found in parameter expressions. Parameter expressions are special because they elaborate early, before all the other parameters are necessarily completed.
2008-12-19 06:33:31 +01:00
NetExpr*elaborate_eval_expr_base_(Design*, NetExpr*lp, NetExpr*rp,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid) const;
Binary and unary operators in parameter expressions.
2000-03-12 19:22:11 +01:00
Cleanup after parameter expression rework. This patch removes some code made redundant by the rework of parameter expression evaluation. It also documents the new -g option.
2010-12-05 23:35:30 +01:00
NetExpr*elaborate_expr_base_bits_(Design*, NetExpr*lp, NetExpr*rp,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid) const;
Fix the signed-ness calculations of +- in parameter expressions. This fixes up the elaboration of binary expressions found in parameter expressions. Parameter expressions are special because they elaborate early, before all the other parameters are necessarily completed.
2008-12-19 06:33:31 +01:00
NetExpr*elaborate_expr_base_div_(Design*, NetExpr*lp, NetExpr*rp,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid) const;
Fix the signed-ness calculations of +- in parameter expressions. This fixes up the elaboration of binary expressions found in parameter expressions. Parameter expressions are special because they elaborate early, before all the other parameters are necessarily completed.
2008-12-19 06:33:31 +01:00
NetExpr*elaborate_expr_base_mult_(Design*, NetExpr*lp, NetExpr*rp,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid) const;
Fix the signed-ness calculations of +- in parameter expressions. This fixes up the elaboration of binary expressions found in parameter expressions. Parameter expressions are special because they elaborate early, before all the other parameters are necessarily completed.
2008-12-19 06:33:31 +01:00
NetExpr*elaborate_expr_base_add_(Design*, NetExpr*lp, NetExpr*rp,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid) const;
Process shift by constant amounts early in expression elaboration. The expr:::synthesize methods need not deal with saturating left or right shifts if they are dealt with early, in elaborate_expr methods. So the elaborate_expr for shift takes on much more responsibility.
2008-08-21 06:47:07 +02:00
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
};
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
/*
Spelling fixes mostly comments, but includes some identifiers and message text
2008-01-25 22:34:51 +01:00
* Here are a few specialized classes for handling specific binary
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
* operators.
*/
class PEBComp : public PEBinary {
public:
explicit PEBComp(char op, PExpr*l, PExpr*r);
~PEBComp();
Elaborate logical and/or to account for special properties. The arguments of logical and/or are self determined, and the width is fixed as 1 bit. Account for this special behavior by creating the PEBLogic class.
2008-10-30 04:31:26 +01:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
Elaborate logical and/or to account for special properties. The arguments of logical and/or are self determined, and the width is fixed as 1 bit. Account for this special behavior by creating the PEBLogic class.
2008-10-30 04:31:26 +01:00
NetExpr* elaborate_expr(Design*des, NetScope*scope,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned expr_wid, unsigned flags) const;
Account for unsized arguments to comparisons. Comparison expressions have sorta-self-determined arguments. Handle the special cause that some of the arguments may be themselves unsized, and so expecting to be even wider then otherwise.
2010-04-27 20:55:59 +02:00
private:
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned l_width_;
unsigned r_width_;
Elaborate logical and/or to account for special properties. The arguments of logical and/or are self determined, and the width is fixed as 1 bit. Account for this special behavior by creating the PEBLogic class.
2008-10-30 04:31:26 +01:00
};
/*
* This derived class is for handling logical expressions: && and ||.
*/
class PEBLogic : public PEBinary {
public:
explicit PEBLogic(char op, PExpr*l, PExpr*r);
~PEBLogic();
Remove last bits of relax_width methods, and use test_width to calculate the width of an r-value expression that may contain unsized numbers.
2006-11-04 07:19:24 +01:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
Fix left shift of unsized constants in sef-determined context. When left-shifting unsized constants in self-determined contexts, the constant value is normally pared down to its minimum required width. But this practically guarantees loss of bits. Instead, detect this special case and give the unsized constant a width of an integer. Still allow for the super-special case that the shifted value and the shift amount are constants. In that case, the result width (and value) can be calculated precisely and there is no need to resort to default widths.
2008-04-22 20:23:24 +02:00
NetExpr* elaborate_expr(Design*des, NetScope*scope,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned expr_wid, unsigned flags) const;
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
};
Rework shift and power PExpr nodes for their special needs. The power (**) and shift operators are different from other binary operators because their expression width calculations rely only on their left operand, with their right operand self-determined. Get the handling of these operators out of the PEBinary base class to prevent confusion.
2008-11-28 23:40:25 +01:00
/*
* A couple of the binary operands have a special sub-expression rule
* where the expression width is carried entirely by the left
* expression, and the right operand is self-determined.
*/
class PEBLeftWidth : public PEBinary {
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
public:
Rework shift and power PExpr nodes for their special needs. The power (**) and shift operators are different from other binary operators because their expression width calculations rely only on their left operand, with their right operand self-determined. Get the handling of these operators out of the PEBinary base class to prevent confusion.
2008-11-28 23:40:25 +01:00
explicit PEBLeftWidth(char op, PExpr*l, PExpr*r);
~PEBLeftWidth() =0;
virtual NetExpr*elaborate_expr_leaf(Design*des, NetExpr*lp, NetExpr*rp,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid) const =0;
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
Rework shift and power PExpr nodes for their special needs. The power (**) and shift operators are different from other binary operators because their expression width calculations rely only on their left operand, with their right operand self-determined. Get the handling of these operators out of the PEBinary base class to prevent confusion.
2008-11-28 23:40:25 +01:00
protected:
Remove last bits of relax_width methods, and use test_width to calculate the width of an r-value expression that may contain unsized numbers.
2006-11-04 07:19:24 +01:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
Rework shift and power PExpr nodes for their special needs. The power (**) and shift operators are different from other binary operators because their expression width calculations rely only on their left operand, with their right operand self-determined. Get the handling of these operators out of the PEBinary base class to prevent confusion.
2008-11-28 23:40:25 +01:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
Rework shift and power PExpr nodes for their special needs. The power (**) and shift operators are different from other binary operators because their expression width calculations rely only on their left operand, with their right operand self-determined. Get the handling of these operators out of the PEBinary base class to prevent confusion.
2008-11-28 23:40:25 +01:00
};
class PEBPower : public PEBLeftWidth {
public:
explicit PEBPower(char op, PExpr*l, PExpr*r);
~PEBPower();
NetExpr*elaborate_expr_leaf(Design*des, NetExpr*lp, NetExpr*rp,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid) const;
Rework shift and power PExpr nodes for their special needs. The power (**) and shift operators are different from other binary operators because their expression width calculations rely only on their left operand, with their right operand self-determined. Get the handling of these operators out of the PEBinary base class to prevent confusion.
2008-11-28 23:40:25 +01:00
};
class PEBShift : public PEBLeftWidth {
public:
explicit PEBShift(char op, PExpr*l, PExpr*r);
~PEBShift();
NetExpr*elaborate_expr_leaf(Design*des, NetExpr*lp, NetExpr*rp,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid) const;
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
};
Add support for the Ternary operator, Add support for repeat concatenation, Correct some seg faults cause by elaboration errors, Parse the casex anc casez statements.
1999-06-10 06:03:52 +02:00
/*
* This class supports the ternary (?:) operator. The operator takes
* three expressions, the test, the true result and the false result.
*/
class PETernary : public PExpr {
public:
netlist support for ternary operator.
1999-07-17 21:50:59 +02:00
explicit PETernary(PExpr*e, PExpr*t, PExpr*f);
Add support for the Ternary operator, Add support for repeat concatenation, Correct some seg faults cause by elaboration errors, Parse the casex anc casez statements.
1999-06-10 06:03:52 +02:00
~PETernary();
netlist support for ternary operator.
1999-07-17 21:50:59 +02:00
virtual void dump(ostream&out) const;
Checks for illegal use of automatically allocated variables. This patch adds a number of compile and run-time checks for illegal uses of variables declared in automatic tasks and functions. It also adds a check for event expressions in automatic tasks that use features not yet supported in VVP.
2008-11-09 01:26:55 +01:00
Fix for pr2924354. Creation of implicit nets requires knowledge of whether an identifier has been declared before it is used. Currently implicit nets are created during elaboration, but by this stage the order of declaration and use is not known. This patch moves the creation of implicit nets into the parser stage.
2010-01-12 21:11:01 +01:00
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type);
Checks for illegal use of automatically allocated variables. This patch adds a number of compile and run-time checks for illegal uses of variables declared in automatic tasks and functions. It also adds a check for event expressions in automatic tasks that use features not yet supported in VVP.
2008-11-09 01:26:55 +01:00
virtual bool has_aa_term(Design*des, NetScope*scope) const;
Add test_width methods for PETernary and PEString.
2006-11-10 05:54:26 +01:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
Add test_width methods for PETernary and PEString.
2006-11-10 05:54:26 +01:00
Short-circuit elaboration of ternary expressions. When the condition expression of a ternary is constant 1 or 0, we can short-circuit the elaboration by only processing the clause (true or false) that we need. This saves compile time and execution time.
2008-08-23 19:50:24 +02:00
virtual NetExpr*elaborate_expr(Design*des, NetScope*,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
Build errors in picky GCC compilers.
2007-06-04 21:14:06 +02:00
virtual verinum* eval_const(Design*des, NetScope*sc) const;
netlist support for ternary operator.
1999-07-17 21:50:59 +02:00
Handle ternary expressions with mixed argument types. If the true and false alternatives are mixed types, then vectored arguments are treated as if in a self-determined context then cast to REAL.
2009-01-06 04:44:52 +01:00
private:
NetExpr* elab_and_eval_alternative_(Design*des, NetScope*scope,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
PExpr*expr, unsigned expr_wid,
Handle implicit cast when short-circuiting ternary expression. If a ternary expression with mixed logic and real operands is short-circuited and the logic value is selected, that value should be cast to a real value.
2013-03-02 00:01:15 +01:00
unsigned flags, bool short_cct) const;
Handle ternary expressions with mixed argument types. If the true and false alternatives are mixed types, then vectored arguments are treated as if in a self-determined context then cast to REAL.
2009-01-06 04:44:52 +01:00
Add support for the Ternary operator, Add support for repeat concatenation, Correct some seg faults cause by elaboration errors, Parse the casex anc casez statements.
1999-06-10 06:03:52 +02:00
private:
PExpr*expr_;
PExpr*tru_;
PExpr*fal_;
};
Parse system function calls.
1999-09-25 04:57:29 +02:00
/*
Add infrastructure for system functions, move $time to that structure and add $random.
2000-05-04 05:37:58 +02:00
* This class represents a parsed call to a function, including calls
Add the NetUserFunc netlist node.
2002-03-09 03:10:22 +01:00
* to system functions. The parameters in the parms list are the
* expressions that are passed as input to the ports of the function.
Parse system function calls.
1999-09-25 04:57:29 +02:00
*/
Add functions up to elaboration (Ed Carter)
1999-07-31 21:14:47 +02:00
class PECallFunction : public PExpr {
Parse system function calls.
1999-09-25 04:57:29 +02:00
public:
Parse contribution statements as far as pform. Contribution statements have an l-value and r-value. Parse those expressions into pform so that elaboration has something to work with. In this process, this patch also changes the PECallFunction class to use the vector template instead of the svector template. The latter doesn't add anything over the STL vector template, so this is a start of working the svector out.
2008-07-27 23:22:19 +02:00
explicit PECallFunction(const pform_name_t&n, const vector<PExpr *> &parms);
Spelling fixes mostly comments, but includes some identifiers and message text
2008-01-25 22:34:51 +01:00
// Call of system function (name is not hierarchical)
Parse contribution statements as far as pform. Contribution statements have an l-value and r-value. Parse those expressions into pform so that elaboration has something to work with. In this process, this patch also changes the PECallFunction class to use the vector template instead of the svector template. The latter doesn't add anything over the STL vector template, so this is a start of working the svector out.
2008-07-27 23:22:19 +02:00
explicit PECallFunction(perm_string n, const vector<PExpr *> &parms);
Rework the heirarchical identifier parse syntax and pform to handle more general combinations of heirarch and bit selects.
2007-05-24 06:07:11 +02:00
explicit PECallFunction(perm_string n);
Parse contribution statements as far as pform. Contribution statements have an l-value and r-value. Parse those expressions into pform so that elaboration has something to work with. In this process, this patch also changes the PECallFunction class to use the vector template instead of the svector template. The latter doesn't add anything over the STL vector template, so this is a start of working the svector out.
2008-07-27 23:22:19 +02:00
// svector versions. Should be removed!
Remove some uses of the svector template. I'm adding more uses of the make_range_from_width function, so it seems like time to get rid of its use of the svector template. This thread led to a lot of other uses of svector that had to also be removed.
2010-10-26 04:36:44 +02:00
explicit PECallFunction(const pform_name_t&n, const list<PExpr *> &parms);
explicit PECallFunction(perm_string n, const list<PExpr *> &parms);
Parse contribution statements as far as pform. Contribution statements have an l-value and r-value. Parse those expressions into pform so that elaboration has something to work with. In this process, this patch also changes the PECallFunction class to use the vector template instead of the svector template. The latter doesn't add anything over the STL vector template, so this is a start of working the svector out.
2008-07-27 23:22:19 +02:00
Parse system function calls.
1999-09-25 04:57:29 +02:00
~PECallFunction();
Add functions up to elaboration (Ed Carter)
1999-07-31 21:14:47 +02:00
virtual void dump(ostream &) const;
Expression widths with unsized literals are pseudo-infinite width.
2006-10-30 06:44:49 +01:00
Fix for pr2924354. Creation of implicit nets requires knowledge of whether an identifier has been declared before it is used. Currently implicit nets are created during elaboration, but by this stage the order of declaration and use is not known. This patch moves the creation of implicit nets into the parser stage.
2010-01-12 21:11:01 +01:00
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type);
Checks for illegal use of automatically allocated variables. This patch adds a number of compile and run-time checks for illegal uses of variables declared in automatic tasks and functions. It also adds a check for event expressions in automatic tasks that use features not yet supported in VVP.
2008-11-09 01:26:55 +01:00
virtual bool has_aa_term(Design*des, NetScope*scope) const;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
Add functions up to elaboration (Ed Carter)
1999-07-31 21:14:47 +02:00
test_width method for functions in expressions In expressions, user defined functions have a clearly defined width and the test_width expression needs to express that. Note that the $signed/$unsigned functions are special and magical. Signed-off-by: Stephen Williams <steve@icarus.com>
2007-10-02 05:38:20 +02:00
virtual unsigned test_width(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
test_width method for functions in expressions In expressions, user defined functions have a clearly defined width and the test_width expression needs to express that. Note that the $signed/$unsigned functions are special and magical. Signed-off-by: Stephen Williams <steve@icarus.com>
2007-10-02 05:38:20 +02:00
Parse system function calls.
1999-09-25 04:57:29 +02:00
private:
Rework the heirarchical identifier parse syntax and pform to handle more general combinations of heirarch and bit selects.
2007-05-24 06:07:11 +02:00
pform_name_t path_;
Parse contribution statements as far as pform. Contribution statements have an l-value and r-value. Parse those expressions into pform so that elaboration has something to work with. In this process, this patch also changes the PECallFunction class to use the vector template instead of the svector template. The latter doesn't add anything over the STL vector template, so this is a start of working the svector out.
2008-07-27 23:22:19 +02:00
vector<PExpr *> parms_;
Parse system function calls.
1999-09-25 04:57:29 +02:00
Add the NetUserFunc netlist node.
2002-03-09 03:10:22 +01:00
bool check_call_matches_definition_(Design*des, NetScope*dscope) const;
Detect and implement string.len() method, and string[index] expressions Implement the string.len() method in the system.vpi, and implement the string[index] method in vvp.
2012-07-01 02:05:25 +02:00
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
NetExpr* cast_to_width_(NetExpr*expr, unsigned wid) const;
Fix for pr2922063. When handling the $signed/$unsigned system functions, the compiler was applying the new signed/unsigned property to the NetExpr object representing the input argument. This caused the input argument to be evaluated incorrectly. This patch fixes this by applying the new property to the NetExpr object created to pad the result to the required size. In testing this fix, it was also discovered that the width of the input argument expression was not being calculated correctly. This patch also fixes this issue.
2010-01-17 15:20:18 +01:00
Parse support for dynamic arrays. This includes limited support for dynamic arrays down to the code generator, and some stubs in the vvp code generator and vvp run time.
2012-07-14 03:41:41 +02:00
NetExpr*elaborate_expr_method_(Design*des, NetScope*scope,
unsigned expr_wid) const;
#if 0
NetExpr*elaborate_expr_string_method_(Design*des, NetScope*scope) const;
Detect and implement string.len() method, and string[index] expressions Implement the string.len() method in the system.vpi, and implement the string[index] method in vvp.
2012-07-01 02:05:25 +02:00
NetExpr*elaborate_expr_enum_method_(Design*des, NetScope*scope,
unsigned expr_wid) const;
Parse support for dynamic arrays. This includes limited support for dynamic arrays down to the code generator, and some stubs in the vvp code generator and vvp run time.
2012-07-14 03:41:41 +02:00
#endif
Detect and implement string.len() method, and string[index] expressions Implement the string.len() method in the system.vpi, and implement the string[index] method in vvp.
2012-07-01 02:05:25 +02:00
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
NetExpr* elaborate_sfunc_(Design*des, NetScope*scope,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned expr_wid,
unsigned flags) const;
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
NetExpr* elaborate_access_func_(Design*des, NetScope*scope, ivl_nature_t,
unsigned expr_wid) const;
test_width method for functions in expressions In expressions, user defined functions have a clearly defined width and the test_width expression needs to express that. Note that the $signed/$unsigned functions are special and magical. Signed-off-by: Stephen Williams <steve@icarus.com>
2007-10-02 05:38:20 +02:00
unsigned test_width_sfunc_(Design*des, NetScope*scope,
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
width_mode_t&mode);
Parse support for dynamic arrays. This includes limited support for dynamic arrays down to the code generator, and some stubs in the vvp code generator and vvp run time.
2012-07-14 03:41:41 +02:00
unsigned test_width_method_(Design*des, NetScope*scope,
width_mode_t&mode);
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
};
Support SystemVerilog size cast.
2011-09-19 04:21:46 +02:00
/*
* Support the SystemVerilog cast to size.
*/
class PECastSize : public PExpr {
public:
explicit PECastSize(unsigned expr_wid, PExpr*base);
~PECastSize();
void dump(ostream &out) const;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
unsigned expr_wid,
unsigned flags) const;
virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode);
private:
unsigned size_;
PExpr* base_;
};
Expression width rework. This patch is a major rework of expression elaboration and evaluation in the compiler, aimed at better compliance with the IEEE standard.
2011-02-26 23:59:52 +01:00
/*
* This class is used for error recovery. All methods do nothing and return
* null or default values.
*/
class PEVoid : public PExpr {
public:
explicit PEVoid();
~PEVoid();
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
unsigned expr_wid,
Rework of constant expression error reporting. This patch changes the method used to signal that a constant expression is being elaborated from flags stored in global variables to flags passed down the call chain. It also generates more informative error messages when variable references are found in a constant expression.
2011-03-27 12:08:33 +02:00
unsigned flags) const;
Add functions up to elaboration (Ed Carter)
1999-07-31 21:14:47 +02:00
};
Introduce verilog to CVS.
1998-11-04 00:28:49 +01:00
#endif