P4C
The P4 Compiler
Loading...
Searching...
No Matches
Public Member Functions | List of all members
P4::ValidateParsedProgram Class Referencefinal

#include <validateParsedProgram.h>

Inheritance diagram for P4::ValidateParsedProgram:
[legend]

Public Member Functions

void postorder (const IR::Annotations *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 end_apply (const IR::Node *root)
 
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

◆ 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