statically evaluates many constant expressions. More...

Inheritance diagram for P4::DoConstantFolding:

Public Member Functions
	DoConstantFolding (const ReferenceMap refMap, const TypeMap typeMap, bool warnings=true, ConstantFoldingPolicy *policy=nullptr)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const IR::Node *	preorder (IR::ArrayIndex *e) override

const IR::Node *	preorder (IR::AssignmentStatement *statement) override

const IR::BlockStatement *	preorder (IR::BlockStatement *bs) override

Public Member Functions inherited from Transform
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 const IR::Node *	postorder (IR::Node *n)

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

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 Visitor
virtual bool	check_global (cstring)

virtual void	clear_globals ()

virtual Visitor *	clone () const

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 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 = typename std::enable_if<std::is_base_of<Util::IHasSourceInfo, T>::value>::type, 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 = typename std::enable_if<std::is_base_of<Util::IHasSourceInfo, T>::value>::type, class... Args>
void	warn (const int kind, const char format, const T node, Args... args)

bool	warning_enabled (int warning_kind) const

Protected Types
enum class	Result { Yes , No , DontKnow }
	Result type for setContains.

Protected Member Functions
const IR::Node *	binary (const IR::Operation_Binary *op, std::function< big_int(big_int, big_int)> func, bool saturating=false)
	Statically evaluate binary operation `e` implemented by `func`.

const IR::Constant *	cast (const IR::Constant node, unsigned base, const IR::Type_Bits type) const
	Statically cast constant `node` to `type` represented in the specified `base`.

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

const IR::Expression *	getConstant (const IR::Expression *expr) const

Result	setContains (const IR::Expression keySet, const IR::Expression constant) const

const IR::Node *	shift (const IR::Operation_Binary *op)
	Statically evaluate shift operation `e`.

Protected Member Functions inherited from Transform
const IR::Node *	transform_child (const IR::Node *child)

Protected Member Functions inherited from 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
bool	assignmentTarget

std::map< const IR::Declaration_Constant , const IR::Expression >	constants
	Maps declaration constants to constant expressions.

ConstantFoldingPolicy *	policy

const ReferenceMap *	refMap

const TypeMap *	typeMap

bool	typesKnown
	Set to `true` iff `typeMap` is not `nullptr`.

bool	warnings
	If `true` then emit warnings.

Protected Attributes inherited from Visitor
bool	dontForwardChildrenBeforePreorder = false

bool	joinFlows = false

bool	visitDagOnce = true

Additional Inherited Members
Public Types inherited from Visitor
typedef Visitor_Context	Context

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

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

Public Attributes inherited from Visitor
const Visitor *	called_by = nullptr

cstring	internalName

SplitFlowVisit_base *&	split_link

SplitFlowVisit_base *	split_link_mem = nullptr

Detailed Description

statically evaluates many constant expressions.

This pass can be invoked either with or without the refMap and typeMap. When type information is not available, constant folding is not performed for many IR nodes.

Precondition: : typeMap is up-to-date if not nullptr and similarly for refMap

Postcondition: : Ensures

most expressions that can be statically shown to evaluate to a constant are replaced with the constant value.
operations that involve constant InfInt operands are evaluated to an InfInt value
if typeMap and refMap are not nullptr then IR::Declaration_Constant nodes are initialized with compile-time known constants.

Member Function Documentation

◆ compare()

const IR::Node * P4::DoConstantFolding::compare ( const IR::Operation_Binary * op )

protected

Statically evaluate comparison operation e. Note that this only handles the case where e represents == or !=.

◆ getConstant()

const IR::Expression * P4::DoConstantFolding::getConstant ( const IR::Expression * expr ) const

protected

Returns: a constant equivalent to expr or nullptr

◆ setContains()

DoConstantFolding::Result P4::DoConstantFolding::setContains	(	const IR::Expression *	keySet,
		const IR::Expression *	constant
	)		const

protected

Statically evaluate case in select expression.

Returns

Result::Yes
Result::No
Result::DontKnow

depending on whether constant is contained in keyset.

Member Data Documentation

◆ refMap

const ReferenceMap* P4::DoConstantFolding::refMap

protected

Used to resolve IR nodes to declarations. If nullptr, then const values cannot be resolved.

◆ typeMap

const TypeMap* P4::DoConstantFolding::typeMap

protected

Used to resolve nodes to their types. If nullptr, then type information is not available.

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ compare()

◆ getConstant()

◆ setContains()

Member Data Documentation

◆ refMap

◆ typeMap