P4C
The P4 Compiler
Loading...
Searching...
No Matches
Classes | Public Member Functions | List of all members
P4::DoLocalCopyPropagation Class Reference

#include <local_copyprop.h>

Inheritance diagram for P4::DoLocalCopyPropagation:
[legend]

Classes

class  ElimDead
 
class  RewriteTableKeys
 

Public Member Functions

 DoLocalCopyPropagation (ReferenceMap *refMap, TypeMap *typeMap, std::function< bool(const Context *, const IR::Expression *)> policy, bool eut)
 
- Public Member Functions inherited from P4::ControlFlowVisitor
bool check_global (cstring key) override
 
void clear_globals () override
 
ControlFlowVisitor * controlFlowVisitor () override
 
void erase_global (cstring key) override
 
ControlFlowVisitor & flow_clone () override
 
const flow_join_info_t * flow_join_status (const IR::Node *n) const
 
void flow_merge_global_from (cstring key) override
 
void flow_merge_global_to (cstring key) override
 
bool has_flow_joins () const override
 
bool isUnreachable ()
 
bool operator!= (const ControlFlowVisitor &v) const
 
void restore_global (std::pair< cstring, ControlFlowVisitor * > saved)
 
std::pair< cstring, ControlFlowVisitor * > save_global (cstring key)
 
void setUnreachable ()
 
- Public Member Functions inherited from P4::Visitor
virtual void end_apply ()
 
virtual void end_apply (const IR::Node *root)
 
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 bool flow_merge_closure (Visitor &)
 
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
 
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 Types inherited from P4::ControlFlowVisitor
typedef std::map< const IR::Node *, flow_join_info_t > flow_join_points_t
 
- Protected Member Functions inherited from P4::ControlFlowVisitor
virtual void applySetupJoinPoints (const IR::Node *root)
 
virtual bool filter_join_point (const IR::Node *)
 
void init_join_flows (const IR::Node *root) override
 
bool join_flows (const IR::Node *n) override
 
void post_join_flows (const IR::Node *, const IR::Node *) override
 
- Protected Member Functions inherited from P4::Visitor
void visit_children (const IR::Node *, std::function< void()> fn)
 
- Protected Attributes inherited from P4::ControlFlowVisitor
bool BackwardsCompatibleBroken = false
 
flow_join_points_t * flow_join_points = 0
 
bool unreachable = false
 
- Protected Attributes inherited from P4::Visitor
bool dontForwardChildrenBeforePreorder = false
 
bool joinFlows = false
 
bool visitDagOnce = true
 

Detailed Description

Local copy propagation and dead code elimination within a single pass. This pass is designed to be run after all declarations have received unique internal names. This is important because the locals map uses only the declaration name, and not the full path.

Precondition
Requires expression types be stored inline in the expression (obtained by running Typechecking(updateProgram = true)).

Requires that all declaration names be globally unique (obtained by running UniqueNames).

Requires that all variable declarations are at the top-level control scope (obtained using MoveDeclarations).

Parameters
policy

This predicate function will be called for any expression that could be copy-propagated to determine if it should be. It will only be called for expressions that are legal to propagate (so no side effects, or dependencies that would change the meaning), so the policy should only evaluate the potential cost of propagating, as propagated expressions may be evaluated mulitple times. The default policy just returns true – always propagate if legal to do so.