Inheritance diagram for P4::TypeInference:

[legend]

Classes
struct	Comparison

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

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

TypeInference *	clone () const override

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

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

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

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

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 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::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.

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

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

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

Protected Member Functions
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::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

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::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::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
bool	checkArrays = true

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

bool	errorOnNullDecls = false

bool	readOnly = false

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::ResolutionContext
bool	anyOrder = false

Static Protected Attributes
static constexpr bool	forbidModules = true

static constexpr bool	forbidPackages = true

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

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

cstring	internalName

SplitFlowVisit_base *&	split_link

SplitFlowVisit_base *	split_link_mem = nullptr

Class Documentation

◆ P4::TypeInference::Comparison

struct P4::TypeInference::Comparison

Class Members
const Expression *	left
const Expression *	right

Member Function Documentation

◆ apply_visitor()

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

overridevirtual

Reimplemented from P4::Transform.

◆ assignment()

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

protected

Tries to assign sourceExpression to a destination with type destType. This may rewrite the sourceExpression, in particular converting InfInt values to values with concrete types.

Returns: new sourceExpression.

◆ canonicalize()

const IR::Type * P4::TypeInference::canonicalize ( const IR::Type * type )

protectedvirtual

Converts each type to a canonical representation. Made virtual to enable private midend passes to extend standard IR with custom IR classes.

◆ checkUnderlyingEnumType()

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

protected

Check if the underlying type for enum is bit<> or int<> and emit error if it is not.

Returns: the resolved type, or nullptr if the type is invalid

◆ clone()

TypeInference * P4::TypeInference::clone ( ) const

overridevirtual

Reimplemented from P4::Visitor.

◆ containerInstantiation()

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

protected

Returns: : A pair containing the type returned by the constructor and the new arguments (which may change due to insertion of casts).

◆ 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() [1/3]

const IR::Node * P4::TypeInference::postorder ( IR::Entry * entry )

override

typecheck a table initializer entry

The invariants are:

table keys and entry keys must have the same length
entry key elements must be compile time constants
actionRefs in entries must be in the action list
table keys must have been type checked before entries

Moreover, the EntriesList visitor should have checked for the table invariants.

◆ postorder() [2/3]

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

override

compute the type of table keys. Used to typecheck pre-defined entries.

◆ postorder() [3/3]

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

inlinevirtual

Reimplemented from P4::Transform.

◆ preorder() [1/2]

const IR::Node * P4::TypeInference::preorder ( IR::EntriesList * el )

override

typecheck a table initializer entry list

◆ preorder() [2/2]

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

inlinevirtual

Reimplemented from P4::Transform.

◆ specialize()

const IR::Type * P4::TypeInference::specialize	(	const IR::IMayBeGenericType *	type,
		const IR::Vector< IR::Type > *	arguments,
		const Visitor::Context *	ctxt )

static

Bind the parameters with the specified arguments. For example, given a type void _<T>(T data) it can be specialized to void _<int<32>>(int<32> data);

◆ unifyCast()

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

inlineprotected

Unifies two types. Returns nullptr if unification fails. Populates the typeMap with values for the type variables. This allows an implicit cast from the right type to the left type.

◆ validateActionInitializer()

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

protected

This is used to validate the initializer for the default_action or for actions in the entries list. Returns the action list element on success.

◆ validateFields()

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

protected

Validate the fields of a struct type using the supplied checker. The checker returns "false" when a field is invalid. Return true on success

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Class Documentation

◆ P4::TypeInference::Comparison

Member Function Documentation

◆ apply_visitor()

◆ assignment()

◆ canonicalize()

◆ checkUnderlyingEnumType()

◆ clone()

◆ containerInstantiation()

◆ end_apply()

◆ init_apply()

◆ postorder() [1/3]

◆ postorder() [2/3]

◆ postorder() [3/3]

◆ preorder() [1/2]

◆ preorder() [2/2]

◆ specialize()

◆ unifyCast()

◆ validateActionInitializer()

◆ validateFields()