Inheritance diagram for P4::TypeInference:

[legend]

Public Member Functions
	TypeInference (TypeMap *typeMap, bool readOnly=true, bool checkArrays=true, bool errorOnNullDecls=false)

const IR::Node *	apply_visitor (const IR::Node , const char name=nullptr) override

void	end_apply (const IR::Node *Node) override

Visitor::profile_t	init_apply (const IR::Node *node) override

const IR::Node *	postorder (IR::ActionList *al) override

const IR::Node *	postorder (IR::ActionListElement *elem) override

const IR::Node *	postorder (IR::Add *expression) override

const IR::Node *	postorder (IR::AddSat *expression) override

const IR::Node *	postorder (IR::Annotation *annotation) override

const IR::Node *	postorder (IR::Argument *arg) override

const IR::Node *	postorder (IR::ArrayIndex *expression) override

const IR::Node *	postorder (IR::AssignmentStatement *stat) override

const IR::Node *	postorder (IR::AttribLocal *local) override

const IR::Node *	postorder (IR::BAnd *expression) override

const IR::Node *	postorder (IR::BoolLiteral *expression) override

const IR::Node *	postorder (IR::BOr *expression) override

const IR::Node *	postorder (IR::BXor *expression) override

const IR::Node *	postorder (IR::Cast *expression) override

const IR::Node *	postorder (IR::Cmpl *expression) override

const IR::Node *	postorder (IR::Concat *expression) override

const IR::Node *	postorder (IR::Constant *expression) override

const IR::Node *	postorder (IR::ConstructorCallExpression *expression) override

const IR::Node *	postorder (IR::Declaration_Constant *constant) override

const IR::Node *	postorder (IR::Declaration_MatchKind *decl) override

const IR::Node *	postorder (IR::Declaration_Variable *decl) override

const IR::Node *	postorder (IR::DefaultExpression *expression) override

const IR::Node *	postorder (IR::Div *expression) override

const IR::Node *	postorder (IR::Dots *expression) override

const IR::Node *	postorder (IR::Entry *e) override

const IR::Node *	postorder (IR::ForInStatement *stat) override

const IR::Node *	postorder (IR::HeaderStackExpression *expression) override

const IR::Node *	postorder (IR::IfStatement *stat) override

const IR::Node *	postorder (IR::Invalid *expression) override

const IR::Node *	postorder (IR::InvalidHeader *expression) override

const IR::Node *	postorder (IR::InvalidHeaderUnion *expression) override

const IR::Node *	postorder (IR::Key *key) override

const IR::Node *	postorder (IR::KeyElement *elem) override

const IR::Node *	postorder (IR::LAnd *expression) override

const IR::Node *	postorder (IR::ListExpression *expression) override

const IR::Node *	postorder (IR::LNot *expression) override

const IR::Node *	postorder (IR::LOr *expression) override

const IR::Node *	postorder (IR::Mask *expression) override

const IR::Node *	postorder (IR::Member *expression) override

const IR::Node *	postorder (IR::Method *method) override

const IR::Node *	postorder (IR::MethodCallExpression *expression) override

const IR::Node *	postorder (IR::MethodCallStatement *mcs) override

const IR::Node *	postorder (IR::Mod *expression) override

const IR::Node *	postorder (IR::Mul *expression) override

const IR::Node *	postorder (IR::Mux *expression) override

const IR::Node *	postorder (IR::Neg *expression) override

virtual const IR::Node *	postorder (IR::Node *n)

const IR::Node *	postorder (IR::Operation_Relation *expression) override

const IR::Node *	postorder (IR::P4Action *type) override

const IR::Node *	postorder (IR::P4Control *cont) override

const IR::Node *	postorder (IR::P4ListExpression *expression) override

const IR::Node *	postorder (IR::P4Parser *cont) override

const IR::Node *	postorder (IR::P4Table *type) override

const IR::Node *	postorder (IR::P4ValueSet *type) override

const IR::Node *	postorder (IR::Parameter *param) override

const IR::Node *	postorder (IR::PathExpression *expression) override

const IR::Node *	postorder (IR::Property *elem) override

const IR::Node *	postorder (IR::Range *expression) override

const IR::Node *	postorder (IR::ReturnStatement *stat) override

const IR::Node *	postorder (IR::SelectCase *elem) override

const IR::Node *	postorder (IR::SelectExpression *expression) override

const IR::Node *	postorder (IR::SerEnumMember *member) override

const IR::Node *	postorder (IR::Shl *expression) override

const IR::Node *	postorder (IR::Shr *expression) override

const IR::Node *	postorder (IR::Slice *expression) override

const IR::Node *	postorder (IR::StringLiteral *expression) override

const IR::Node *	postorder (IR::StructExpression *expression) override

const IR::Node *	postorder (IR::StructField *field) override

const IR::Node *	postorder (IR::Sub *expression) override

const IR::Node *	postorder (IR::SubSat *expression) override

const IR::Node *	postorder (IR::SwitchStatement *stat) override

const IR::Node *	postorder (IR::This *expression) override

const IR::Node *	postorder (IR::Type_Action *type) override

const IR::Node *	postorder (IR::Type_ActionEnum *type) override

const IR::Node *	postorder (IR::Type_ArchBlock *type) override

const IR::Node *	postorder (IR::Type_Base *type) override

const IR::Node *	postorder (IR::Type_Enum *type) override

const IR::Node *	postorder (IR::Type_Error *decl) override

const IR::Node *	postorder (IR::Type_Extern *type) override

const IR::Node *	postorder (IR::Type_Header *type) override

const IR::Node *	postorder (IR::Type_HeaderUnion *type) override

const IR::Node *	postorder (IR::Type_InfInt *type) override

const IR::Node *	postorder (IR::Type_List *type) override

const IR::Node *	postorder (IR::Type_Method *type) override

const IR::Node *	postorder (IR::Type_Name *type) override

const IR::Node *	postorder (IR::Type_Newtype *type) override

const IR::Node *	postorder (IR::Type_P4List *type) override

const IR::Node *	postorder (IR::Type_Package *type) override

const IR::Node *	postorder (IR::Type_Set *type) override

const IR::Node *	postorder (IR::Type_Specialized *type) override

const IR::Node *	postorder (IR::Type_SpecializedCanonical *type) override

const IR::Node *	postorder (IR::Type_Stack *type) override

const IR::Node *	postorder (IR::Type_Struct *type) override

const IR::Node *	postorder (IR::Type_Table *type) override

const IR::Node *	postorder (IR::Type_Tuple *type) override

const IR::Node *	postorder (IR::Type_Type *type) override

const IR::Node *	postorder (IR::Type_Typedef *type) override

const IR::Node *	postorder (IR::Type_Var *type) override

const IR::Node *	postorder (IR::TypeNameExpression *expression) override

const IR::Node *	postorder (IR::UPlus *expression) override

const IR::Node *	preorder (IR::Declaration_Instance *decl) override

const IR::Node *	preorder (IR::EntriesList *el) override

const IR::Node *	preorder (IR::Expression *expression) override

const IR::Node *	preorder (IR::Function *function) override

virtual const IR::Node *	preorder (IR::Node *n)

const IR::Node *	preorder (IR::P4Program *program) override

const IR::Node *	preorder (IR::Type *type) override

const IR::Node *	preorder (IR::Type_SerEnum *type) override

const IR::Node *	pruneIfDone (const IR::Node *node)

Public Member Functions inherited from P4::Transform
virtual void	loop_revisit (const IR::Node *)

void	prune ()

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

void	revisit_visited ()

bool	visit_in_progress (const IR::Node *) 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

Public Member Functions inherited from P4::TypeInferenceBase
	TypeInferenceBase (TypeMap *typeMap, bool readOnly=false, bool checkArrays=true, bool errorOnNullDecls=false)

bool	compare (const IR::Node errorPosition, const IR::Type ltype, const IR::Type rtype, Comparison compare)

void	finish (const IR::Node *Node)

bool	learn (const IR::Node node, Visitor caller, const Visitor::Context *ctxt)

const IR::Node *	postorder (const IR::ActionList *al)

const IR::Node *	postorder (const IR::ActionListElement *elem)

const IR::Node *	postorder (const IR::Add *expression)

const IR::Node *	postorder (const IR::AddSat *expression)

const IR::Node *	postorder (const IR::Annotation *annotation)

const IR::Node *	postorder (const IR::Argument *arg)

const IR::Node *	postorder (const IR::ArrayIndex *expression)

const IR::Node *	postorder (const IR::AssignmentStatement *stat)

const IR::Node *	postorder (const IR::AttribLocal *local)

const IR::Node *	postorder (const IR::BAnd *expression)

const IR::Node *	postorder (const IR::BoolLiteral *expression)

const IR::Node *	postorder (const IR::BOr *expression)

const IR::Node *	postorder (const IR::BXor *expression)

const IR::Node *	postorder (const IR::Cast *expression)

const IR::Node *	postorder (const IR::Cmpl *expression)

const IR::Node *	postorder (const IR::Concat *expression)

const IR::Node *	postorder (const IR::Constant *expression)

const IR::Node *	postorder (const IR::ConstructorCallExpression *expression)

const IR::Node *	postorder (const IR::Declaration_Constant *constant)

const IR::Node *	postorder (const IR::Declaration_MatchKind *decl)

const IR::Node *	postorder (const IR::Declaration_Variable *decl)

const IR::Node *	postorder (const IR::DefaultExpression *expression)

const IR::Node *	postorder (const IR::Div *expression)

const IR::Node *	postorder (const IR::Dots *expression)

const IR::Node *	postorder (const IR::Entry *e)

const IR::Node *	postorder (const IR::ForInStatement *stat)

const IR::Node *	postorder (const IR::HeaderStackExpression *expression)

const IR::Node *	postorder (const IR::IfStatement *stat)

const IR::Node *	postorder (const IR::Invalid *expression)

const IR::Node *	postorder (const IR::InvalidHeader *expression)

const IR::Node *	postorder (const IR::InvalidHeaderUnion *expression)

const IR::Node *	postorder (const IR::Key *key)

const IR::Node *	postorder (const IR::KeyElement *elem)

const IR::Node *	postorder (const IR::LAnd *expression)

const IR::Node *	postorder (const IR::ListExpression *expression)

const IR::Node *	postorder (const IR::LNot *expression)

const IR::Node *	postorder (const IR::LOr *expression)

const IR::Node *	postorder (const IR::Mask *expression)

const IR::Node *	postorder (const IR::Member *expression)

const IR::Node *	postorder (const IR::Method *method)

const IR::Node *	postorder (const IR::MethodCallExpression *expression)

const IR::Node *	postorder (const IR::MethodCallStatement *mcs)

const IR::Node *	postorder (const IR::Mod *expression)

const IR::Node *	postorder (const IR::Mul *expression)

const IR::Node *	postorder (const IR::Mux *expression)

const IR::Node *	postorder (const IR::Neg *expression)

const IR::Node *	postorder (const IR::Operation_Relation *expression)

const IR::Node *	postorder (const IR::P4Action *type)

const IR::Node *	postorder (const IR::P4Control *cont)

const IR::Node *	postorder (const IR::P4ListExpression *expression)

const IR::Node *	postorder (const IR::P4Parser *cont)

const IR::Node *	postorder (const IR::P4Table *type)

const IR::Node *	postorder (const IR::P4ValueSet *type)

const IR::Node *	postorder (const IR::Parameter *param)

const IR::Node *	postorder (const IR::PathExpression *expression)

const IR::Node *	postorder (const IR::Property *elem)

const IR::Node *	postorder (const IR::Range *expression)

const IR::Node *	postorder (const IR::ReturnStatement *stat)

const IR::Node *	postorder (const IR::SelectCase *elem)

const IR::Node *	postorder (const IR::SelectExpression *expression)

const IR::Node *	postorder (const IR::SerEnumMember *member)

const IR::Node *	postorder (const IR::Shl *expression)

const IR::Node *	postorder (const IR::Shr *expression)

const IR::Node *	postorder (const IR::Slice *expression)

const IR::Node *	postorder (const IR::StringLiteral *expression)

const IR::Node *	postorder (const IR::StructExpression *expression)

const IR::Node *	postorder (const IR::StructField *field)

const IR::Node *	postorder (const IR::Sub *expression)

const IR::Node *	postorder (const IR::SubSat *expression)

const IR::Node *	postorder (const IR::SwitchStatement *stat)

const IR::Node *	postorder (const IR::This *expression)

const IR::Node *	postorder (const IR::Type_Action *type)

const IR::Node *	postorder (const IR::Type_ActionEnum *type)

const IR::Node *	postorder (const IR::Type_ArchBlock *type)

const IR::Node *	postorder (const IR::Type_Base *type)

const IR::Node *	postorder (const IR::Type_Enum *type)

const IR::Node *	postorder (const IR::Type_Error *decl)

const IR::Node *	postorder (const IR::Type_Extern *type)

const IR::Node *	postorder (const IR::Type_Header *type)

const IR::Node *	postorder (const IR::Type_HeaderUnion *type)

const IR::Node *	postorder (const IR::Type_InfInt *type)

const IR::Node *	postorder (const IR::Type_List *type)

const IR::Node *	postorder (const IR::Type_Method *type)

const IR::Node *	postorder (const IR::Type_Name *type)

const IR::Node *	postorder (const IR::Type_Newtype *type)

const IR::Node *	postorder (const IR::Type_P4List *type)

const IR::Node *	postorder (const IR::Type_Package *type)

const IR::Node *	postorder (const IR::Type_Set *type)

const IR::Node *	postorder (const IR::Type_Specialized *type)

const IR::Node *	postorder (const IR::Type_SpecializedCanonical *type)

const IR::Node *	postorder (const IR::Type_Stack *type)

const IR::Node *	postorder (const IR::Type_Struct *type)

const IR::Node *	postorder (const IR::Type_Table *type)

const IR::Node *	postorder (const IR::Type_Tuple *type)

const IR::Node *	postorder (const IR::Type_Type *type)

const IR::Node *	postorder (const IR::Type_Typedef *type)

const IR::Node *	postorder (const IR::Type_Var *type)

const IR::Node *	postorder (const IR::TypeNameExpression *expression)

const IR::Node *	postorder (const IR::UPlus *expression)

PreorderResult	preorder (const IR::Declaration_Instance *decl)

PreorderResult	preorder (const IR::EntriesList *el)

PreorderResult	preorder (const IR::Function *function)

PreorderResult	preorder (const IR::P4Program *program)

PreorderResult	preorder (const IR::Type_SerEnum *type)

PreorderResult	preorder (IR::Declaration_Instance *decl)

PreorderResult	preorder (IR::Function *function)

ReadOnlyTypeInference *	readOnlyClone () const

void	start (const IR::Node *node)

Public Member Functions inherited from P4::ResolutionContext
const IR::IDeclaration *	getDeclaration (const IR::Path *path, bool notNull=false) const

const IR::IDeclaration *	getDeclaration (const IR::This *, bool notNull=false) const

auto	getDeclarations (const IR::INamespace *ns) const
	Returns the set of decls that exist in the given namespace.

auto	getDeclsByName (const IR::INamespace *ns, cstring name) const
	Returns the set of decls with the given name that exist in the given namespace.

std::vector< const IR::IDeclaration * >	resolve (const IR::ID &name, ResolutionType type) const
	Resolve references for `name`, restricted to `type` declarations.

virtual const IR::IDeclaration *	resolvePath (const IR::Path *path, bool isType) const

const IR::Type *	resolveType (const IR::Type *type) const
	Resolve a refrence to a type `type`.

const IR::IDeclaration *	resolveUnique (const IR::ID &name, ResolutionType type, const IR::INamespace *=nullptr) const
	Resolve reference for `name`, restricted to `type` declarations, and expect one result.

Public Member Functions inherited from P4::DeclarationLookup

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

Public Types inherited from P4::TypeInferenceBase
using	PreorderResult = std::pair<const IR::Node *, bool>

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

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

Static Public Member Functions inherited from P4::TypeInferenceBase
static const IR::Type *	specialize (const IR::IMayBeGenericType type, const IR::Vector< IR::Type > arguments, const Visitor::Context *ctxt)

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::Transform
const IR::Node *	transform_child (const IR::Node *child)

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 Member Functions inherited from P4::TypeInferenceBase
	TypeInferenceBase (TypeMap *typeMap, std::shared_ptr< MinimalNameGenerator > nameGen)

const IR::Expression *	actionCall (bool inActionList, const IR::MethodCallExpression *actionCall)

void	addSubstitutions (const TypeVariableSubstitution *tvs)

const IR::Expression *	assignment (const IR::Node errorPosition, const IR::Type destType, const IR::Expression *sourceExpression)

const IR::Node *	binaryArith (const IR::Operation_Binary *op)

const IR::Node *	binaryBool (const IR::Operation_Binary *op)

bool	canCastBetween (const IR::Type dest, const IR::Type src) const

virtual const IR::Type *	canonicalize (const IR::Type *type)

template<class Ctor >
const IR::Type *	canonicalizeFields (const IR::Type_StructLike *type, Ctor constructor)

virtual const IR::ParameterList *	canonicalizeParameters (const IR::ParameterList *params)

bool	checkAbstractMethods (const IR::Declaration_Instance inst, const IR::Type_Extern type)

std::pair< const IR::Type , const IR::Vector< IR::Argument > >	checkExternConstructor (const IR::Node errorPosition, const IR::Type_Extern ext, const IR::Vector< IR::Argument > *arguments)

bool	checkParameters (const IR::ParameterList *paramList, bool forbidModules=false, bool forbidPackage=false) const

const IR::Type_Bits *	checkUnderlyingEnumType (const IR::Type *enumType)

const IR::Type *	cloneWithFreshTypeVariables (const IR::IMayBeGenericType *type)

const IR::Expression *	constantFold (const IR::Expression *expression)

std::pair< const IR::Type , const IR::Vector< IR::Argument > >	containerInstantiation (const IR::Node node, const IR::Vector< IR::Argument > args, const IR::IContainer *container)

bool	containsActionEnum (const IR::Type *type) const

bool	containsHeader (const IR::Type *canonType)

bool	done () const

const IR::Node *	getInitialNode () const

const IR::Type *	getType (const IR::Node *element) const

const IR::Type *	getTypeType (const IR::Node *element) const

bool	isCompileTimeConstant (const IR::Expression *expression) const

bool	isLeftValue (const IR::Expression *expression) const

const IR::SelectCase *	matchCase (const IR::SelectExpression select, const IR::Type_BaseList selectType, const IR::SelectCase selectCase, const IR::Type caseType)

bool	onlyBitsOrBitStructs (const IR::Type *type) const

template<class Node >
PreorderResult	preorderDeclarationInstanceImpl (Node *decl)

template<class Node >
PreorderResult	preorderFunctionImpl (Node *function)

void	setCompileTimeConstant (const IR::Expression *expression)

void	setLeftValue (const IR::Expression *expression)

void	setType (const IR::Node element, const IR::Type type)

virtual const IR::Type *	setTypeType (const IR::Type *type, bool learn=true)

const IR::Node *	shift (const IR::Operation_Binary *op)

const IR::Node *	typeSet (const IR::Operation_Binary *op)

TypeVariableSubstitution *	unify (const IR::Node errorPosition, const IR::Type destType, const IR::Type srcType, std::string_view errorFormat={}, std::initializer_list< const IR::Node > errorArgs={})
	Same as above, not allowing casts.

TypeVariableSubstitution *	unifyBase (bool allowCasts, const IR::Node errorPosition, const IR::Type destType, const IR::Type srcType, std::string_view errorFormat, std::initializer_list< const IR::Node > errorArgs)

TypeVariableSubstitution *	unifyCast (const IR::Node errorPosition, const IR::Type destType, const IR::Type srcType, std::string_view errorFormat={}, std::initializer_list< const IR::Node > errorArgs={})

const IR::Node *	unsBinaryArith (const IR::Operation_Binary *op)

const IR::ActionListElement *	validateActionInitializer (const IR::Expression *actionCall)

bool	validateFields (const IR::Type type, std::function< bool(const IR::Type )> checker) const

Protected Member Functions inherited from P4::ResolutionContext
	ResolutionContext (bool ao)

std::vector< const IR::IDeclaration * >	lookup (const IR::INamespace *ns, const IR::ID &name, ResolutionType type) const

std::vector< const IR::IDeclaration * >	lookupMatchKind (const IR::ID &name) const

const IR::Vector< IR::Argument > *	methodArguments (cstring name) const
	We are resolving a method call. Find the arguments from the context.

Protected Attributes inherited from P4::Transform
bool	forceClone = false

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

bool	joinFlows = false

bool	visitDagOnce = true

Protected Attributes inherited from P4::TypeInferenceBase
bool	checkArrays = true

const IR::ActionList *	currentActionList
	Action list of the current table.

bool	errorOnNullDecls = false

bool	readOnly = false

Protected Attributes inherited from P4::ResolutionContext
bool	anyOrder = false

Static Protected Attributes inherited from P4::TypeInferenceBase
static constexpr bool	forbidModules = true

static constexpr bool	forbidPackages = true

Member Function Documentation

◆ apply_visitor()

const IR::Node * P4::TypeInference::apply_visitor	(	const IR::Node *	orig,
		const char *	name = nullptr )

overridevirtual

Reimplemented from P4::Transform.

◆ end_apply()

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

overridevirtual

Reimplemented from P4::Visitor.

◆ init_apply()

Visitor::profile_t P4::TypeInference::init_apply ( const IR::Node * node )

overridevirtual

Reimplemented from P4::Transform.

◆ postorder()

virtual const IR::Node * P4::Transform::postorder ( IR::Node * n )

inlinevirtual

Reimplemented from P4::Transform.

◆ preorder()

virtual const IR::Node * P4::Transform::preorder ( IR::Node * n )

inlinevirtual

Reimplemented from P4::Transform.

Public Member Functions

Additional Inherited Members

Member Function Documentation

◆ apply_visitor()

◆ end_apply()

◆ init_apply()

◆ postorder()

◆ preorder()