#include <midend.h>

Inheritance diagram for P4::P4Tools::MidEnd:

Public Member Functions
	MidEnd (const CompilerOptions &)

virtual void	addDefaultPasses ()

virtual void	addNonTypeCheckingPasses ()

P4::ReferenceMap *	getRefMap ()
	Retrieve the reference map used in the mid end.

P4::TypeMap *	getTypeMap ()
	Retrieve the type map used in the mid end.

Public Member Functions inherited from P4::PassManager
	PassManager (const PassManager &)=default

	PassManager (const std::initializer_list< VisitorRef > &init)

	PassManager (PassManager &&)=default

void	addDebugHook (DebugHook h, bool recursive=false)

void	addDebugHooks (std::vector< DebugHook > hooks, bool recursive=false)

void	addPasses (const std::initializer_list< VisitorRef > &init)

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

bool	backtrack (trigger &trig) override

PassManager *	clone () const override

void	early_exit ()

void	listPasses (std::ostream &, cstring sep) const

bool	never_backtracks () override

void	removePasses (const std::vector< cstring > &exclude)

void	setStopOnError (bool stop)

Public Member Functions inherited from P4::Visitor
virtual bool	check_clone (const Visitor *a)

virtual bool	check_global (cstring)

virtual void	clear_globals ()

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

Public Member Functions inherited from P4::Backtrack

Protected Member Functions
virtual bool	localCopyPropPolicy (const Visitor::Context ctx, const IR::Expression expr)

virtual Visitor *	mkConvertEnums ()

virtual P4::ChooseEnumRepresentation *	mkConvertEnumsPolicy ()

virtual P4::ChooseErrorRepresentation *	mkConvertErrorPolicy ()

virtual Visitor *	mkConvertErrors ()

virtual Visitor *	mkConvertKeys ()
	Provides a target-specific pass that simplifies keys in table calls under a custom policy.

Protected Member Functions inherited from P4::PassManager
profile_t	init_apply (const IR::Node *root) override

void	runDebugHooks (const char visitorName, const IR::Node node)

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)

virtual void	visitAgain () const

virtual void	visitOnce () const

Protected Attributes
P4::ReferenceMap	refMap

P4::TypeMap	typeMap

Protected Attributes inherited from P4::PassManager
safe_vector< DebugHook >	debugHooks

safe_vector< Visitor * >	passes

bool	running = false

unsigned	seqNo = 0

bool	stop_on_error = true

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

bool	joinFlows = false

bool	visitDagOnce = true

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

Detailed Description

Implements a generic mid end for all targets. If needed, targets can customize this to implement things like targets-specific conversion of P4 enums to bit<n>.

Mid-end implementations must establish certain invariants in the IR.

TODO: Document these invariants. So far, we have:

controls and parsers are inlined
function arguments are propagated into function bodies where possible
fully type-checked

Member Function Documentation

◆ addDefaultPasses()

void P4::P4Tools::MidEnd::addDefaultPasses ( )

virtual

Add the list of default passes to the mid end. This is not part of the initializer because some targets may add their own passes to the beginning of the pass list.

◆ addNonTypeCheckingPasses()

void P4::P4Tools::MidEnd::addNonTypeCheckingPasses ( )

virtual

Add passes that break type checking. These passes may involve IR modifications the front end type checker does not recognize.

◆ localCopyPropPolicy()

bool P4::P4Tools::MidEnd::localCopyPropPolicy	(	const Visitor::Context *	ctx,
		const IR::Expression *	expr )

protectedvirtual

Provides a target-specific policy for determining when to do local copy propagation. Implementations should return @false if local copy propagation should not be performed on the given expression. The default implementation enables local copy propagation everywhere by always returning @true.

◆ mkConvertEnums()

Visitor * P4::P4Tools::MidEnd::mkConvertEnums ( )

protectedvirtual

Provides a target-specific pass that converts P4 enums to bit<n>. The default implementation returns P4::ConvertEnums, instantiated with the policy provided by @mkChooseEnumRepresentation.

◆ mkConvertEnumsPolicy()

P4::ChooseEnumRepresentation * P4::P4Tools::MidEnd::mkConvertEnumsPolicy ( )

protectedvirtual

Provides a target-specific policy for converting P4 enums to bit<n>. The default implementation converts all enums to bit<32>.

Implements the default enum-conversion policy, which converts all enums to bit<32>.

◆ mkConvertErrorPolicy()

P4::ChooseErrorRepresentation * P4::P4Tools::MidEnd::mkConvertErrorPolicy ( )

protectedvirtual

Provides a target-specific policy for converting P4 error to bit<n>. The default implementation converts all errors to bit<32>.

Implements the default enum-conversion policy, which converts all enums to bit<32>.

◆ mkConvertErrors()

Visitor * P4::P4Tools::MidEnd::mkConvertErrors ( )

protectedvirtual

Provides a target-specific pass that converts P4 errors to bit<n>. The default implementation returns P4Tools::ConvertErrors, instantiated with the policy provided by @mkChooseEnumRepresentation.

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ addDefaultPasses()

◆ addNonTypeCheckingPasses()

◆ localCopyPropPolicy()

◆ mkConvertEnums()

◆ mkConvertEnumsPolicy()

◆ mkConvertErrorPolicy()

◆ mkConvertErrors()