#include <validateParsedProgram.h>

Inheritance diagram for P4::ValidateParsedProgram:

Public Member Functions
void	end_apply (const IR::Node *) override

void	postorder (const IR::Annotation *annotations) override
	Structured annotations cannot reuse names.

void	postorder (const IR::BreakStatement *s) override
	Check that continue and break statements are only used in the context of a for statement.

void	postorder (const IR::Constant *c) override
	Check that the type of a constant is either bit<>, int<> or int.

void	postorder (const IR::ConstructorCallExpression *expression) override
	Cannot invoke constructors in actions.

void	postorder (const IR::ContinueStatement *s) override

void	postorder (const IR::Declaration_Constant *decl) override
	Constant names cannot be underscore.

void	postorder (const IR::Declaration_Instance *inst) override

void	postorder (const IR::Declaration_Variable *decl) override
	Variable names cannot be underscore.

void	postorder (const IR::Dots *dots) override

void	postorder (const IR::EntriesList *l) override

void	postorder (const IR::ExitStatement *statement) override
	Exit statements are not allowed in parsers or functions.

void	postorder (const IR::Method *t) override

void	postorder (const IR::P4Control *control) override

void	postorder (const IR::P4Parser *parser) override

void	postorder (const IR::P4Program *program) override

void	postorder (const IR::P4Table *t) override
	Tables must have an 'actions' property.

void	postorder (const IR::ParserState *s) override
	The accept and reject states cannot be implemented.

void	postorder (const IR::ReturnStatement *statement) override
	Return statements are not allowed in parsers.

void	postorder (const IR::StructField *f) override
	Struct field names cannot be underscore.

void	postorder (const IR::SwitchStatement *statement) override
	Default label in switch statement is always the last one.

void	postorder (const IR::Type_Bits *type) override
	Width of a bit<> or int<> type is greater than 0.

void	postorder (const IR::Type_Package *package) override

void	postorder (const IR::Type_Varbits *type) override

Public Member Functions inherited from P4::Inspector
const IR::Node *	apply_visitor (const IR::Node , const char name=0) override

profile_t	init_apply (const IR::Node *root) override

virtual void	loop_revisit (const IR::Node *)

virtual void	postorder (const IR::Node *)

virtual bool	preorder (const IR::Node *)

virtual void	revisit (const IR::Node *)

void	revisit_visited ()

bool	visit_in_progress (const IR::Node *n) const

void	visitAgain () const override

void	visitOnce () const override

Public Member Functions inherited from P4::Visitor
virtual bool	check_global (cstring)

virtual void	clear_globals ()

virtual Visitor *	clone () const

virtual ControlFlowVisitor *	controlFlowVisitor ()

virtual void	end_apply ()

virtual void	erase_global (cstring)

template<class T >
const T *	findContext () const

template<class T >
const T *	findContext (const Context *&c) const

template<class T >
const T *	findOrigCtxt () const

template<class T >
const T *	findOrigCtxt (const Context *&c) const

virtual Visitor &	flow_clone ()

virtual void	flow_merge (Visitor &)

virtual bool	flow_merge_closure (Visitor &)

virtual void	flow_merge_global_from (cstring)

virtual void	flow_merge_global_to (cstring)

const Context *	getChildContext () const

int	getChildrenVisited () const

const Context *	getContext () const

int	getContextDepth () const

const IR::Node *	getCurrentNode () const

template<class T >
const T *	getCurrentNode () const

const IR::Node *	getOriginal () const

template<class T >
const T *	getOriginal () const

template<class T >
const T *	getParent () const

virtual bool	has_flow_joins () const

profile_t	init_apply (const IR::Node root, const Context parent_context)

bool	isInContext (const IR::Node *n) const

virtual const char *	name () const

template<class T >
void	parallel_visit (const IR::Vector< T > &v, const char *name, int cidx)

template<class T >
void	parallel_visit (const IR::Vector< T > &v, const char *name=0)

template<class T >
void	parallel_visit (IR::Vector< T > &v, const char *name, int cidx)

template<class T >
void	parallel_visit (IR::Vector< T > &v, const char *name=0)

void	print_context () const

const Visitor &	setCalledBy (const Visitor *visitor)

void	setName (const char *name)

void	visit (const IR::Node &n, const char *name, int cidx)

void	visit (const IR::Node &n, const char *name=0)

void	visit (const IR::Node &n, const char name, int cidx)

void	visit (const IR::Node &n, const char name=0)

void	visit (const IR::Node const &n, const char name, int cidx)

void	visit (const IR::Node const &n, const char name=0)

void	visit (IR::Node &n, const char *name, int cidx)

void	visit (IR::Node &n, const char *name=0)

void	visit (IR::Node &, const char =0, int=0)

template<class T , typename = std::enable_if_t<Util::has_SourceInfo_v<T> && !std::is_pointer_v<T>>, class... Args>
void	warn (const int kind, const char *format, const T &node, Args &&...args)
	The const ref variant of the above.

template<class T , typename = std::enable_if_t<Util::has_SourceInfo_v<T>>, class... Args>
void	warn (const int kind, const char format, const T node, Args &&...args)

bool	warning_enabled (int warning_kind) const

Additional Inherited Members
Public Types inherited from P4::Visitor
typedef Visitor_Context	Context

Static Public Member Functions inherited from P4::Visitor
static cstring	demangle (const char *)

static bool	warning_enabled (const Visitor *visitor, int warning_kind)

Public Attributes inherited from P4::Visitor
const Visitor *	called_by = nullptr

cstring	internalName

SplitFlowVisit_base *&	split_link

SplitFlowVisit_base *	split_link_mem = nullptr

Protected Member Functions inherited from P4::Visitor
virtual void	init_join_flows (const IR::Node *)

virtual bool	join_flows (const IR::Node *)

virtual void	post_join_flows (const IR::Node , const IR::Node )

void	visit_children (const IR::Node *, std::function< void()> fn)

Protected Attributes inherited from P4::Visitor
bool	dontForwardChildrenBeforePreorder = false

bool	joinFlows = false

bool	visitDagOnce = true

Detailed Description

This pass performs some simple semantic checks on the program; since the grammar accepts many programs that are actually illegal, this pass does some additional validation.

This pass is run immediately after parsing. There is no type information at this point, so it only does simple checks.

integer constants have valid types
don't care _ is not used as a name for methods, fields, variables, instances
width of bit<> types is positive
width of int<> types is larger than 1
no parser state is named 'accept' or 'reject'
constructor parameters are direction-less
tables have an actions property
instantiations appear at the top-level only
the default label of a switch statement appears last
instantiations do not occur in actions
constructors are not invoked in actions
returns and exits do not appear in parsers
exits do not appear in functions
extern constructors have the same name as the enclosing extern
names of all parameters are distinct
no duplicate declarations in toplevel program
Dots are the last field
continue and break statements are only used in the context of a for statement

Member Function Documentation

◆ end_apply()

void P4::ValidateParsedProgram::end_apply ( const IR::Node * )

inlineoverridevirtual

Reimplemented from P4::Visitor.

◆ postorder() [1/2]

void P4::ValidateParsedProgram::postorder ( const IR::Declaration_Instance * decl )

override

Instance names cannot be don't care Do not declare instances in apply {} blocks, parser states or actions

◆ postorder() [2/2]

void P4::ValidateParsedProgram::postorder ( const IR::Method * m )

override

Check that underscore is not a method name Check that constructors do not have a return type Check that extern constructor names match the enclosing extern

Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ end_apply()

◆ postorder() [1/2]

◆ postorder() [2/2]