Convert expressions so that each expression contains at most one side effect. More...

Inheritance diagram for P4::DoSimplifyExpressions:

[legend]

Public Member Functions
	DoSimplifyExpressions (ReferenceMap refMap, TypeMap typeMap, std::set< const IR::Expression * > *added)

void	end_apply (const IR::Node *) override

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

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

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

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

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

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

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

const IR::Node *	postorder (IR::ParserState *state) override

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

const IR::Node *	preorder (IR::Annotation *anno) override

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

const IR::Node *	preorder (IR::ConstructorCallExpression *cce) override

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

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

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

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

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

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

const IR::Node *	preorder (IR::MethodCallExpression *mce) override

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

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

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

const IR::Node *	preorder (IR::Property *prop) override

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

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

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

const IR::Node *	shortCircuit (IR::Operation_Binary *expression)

Detailed Description

Convert expressions so that each expression contains at most one side effect.

Left-values are converted to contain no side-effects. An important consequence of this pass is that it converts function calls so that no two parameters (one of which is output) can alias. This makes the job of the inliner simpler. For example:

The expression a[f(x)] = b; is converted to tmp = f(x); a[tmp] = b;
And m(n()) is converted to tmp = n(); m(tmp)

This is especially tricky for handling out and inout arguments. Consider two function prototypes, bit f(inout T a, in T b); T g(inout T c);. The expression a[g(w)].x = f(a[1].x, g(a[1].x)); is translated as

T tmp1 = g(w);           // modifies w
T tmp2 = a[1].x;         // save a[1].x
T tmp3 = g(a[1].x);      // modifies a[1].x
T tmp4 = f(tmp2, tmp3);  // modifies tmp2
a[1].x = tmp2;           // copy tmp2 to a[1].x - out argument
a[tmp1].x = tmp4;        // assign result of call of f to actual left value

Translating function calls proceeds as follows:

arguments are evaluated in order
inout and out arguments produce left-values—these are "saved"
function is called with temporaries for all arguments
out and inout temporaries are copied to the saved left-values in order

For assignment statements e = e1; the left hand side is evaluated first.

Public Member Functions

Detailed Description