From e76254815c3adfff1c086beb6a4cfa46c49ac3b3 Mon Sep 17 00:00:00 2001 From: Stan Cox Date: Mon, 19 May 2008 15:39:55 -0400 Subject: Optimize away assignments in other contexts. --- elaborate.cxx | 62 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) (limited to 'elaborate.cxx') diff --git a/elaborate.cxx b/elaborate.cxx index 9a817cba..4bc43832 100644 --- a/elaborate.cxx +++ b/elaborate.cxx @@ -1696,6 +1696,10 @@ struct dead_assignment_remover: public traversing_visitor // called with null current_expr. void visit_assignment (assignment* e); + void visit_arrayindex (arrayindex* e); + void visit_functioncall (functioncall* e); + void visit_if_statement (if_statement* e); + void visit_for_loop (for_loop* e); }; @@ -1720,6 +1724,10 @@ dead_assignment_remover::visit_assignment (assignment* e) *current_expr == e && // we're not nested any deeper than expected leftvar) // not unresolved $target; intended sideeffect cannot be elided { + expression** last_expr = current_expr; + e->left->visit (this); + e->right->visit (this); + current_expr = last_expr; if (vut.read.find(leftvar) == vut.read.end()) // var never read? { // NB: Not so fast! The left side could be an array whose @@ -1750,6 +1758,60 @@ dead_assignment_remover::visit_assignment (assignment* e) } } +void +dead_assignment_remover::visit_arrayindex (arrayindex *e) +{ + symbol *array = NULL; + hist_op *hist = NULL; + classify_indexable(e->base, array, hist); + + if (array) + { + expression** last_expr = current_expr; + for (unsigned i=0; i < e->indexes.size(); i++) + { + current_expr = & e->indexes[i]; + e->indexes[i]->visit (this); + } + current_expr = last_expr; + } +} + +void +dead_assignment_remover::visit_functioncall (functioncall* e) +{ + expression** last_expr = current_expr; + for (unsigned i=0; iargs.size(); i++) + { + current_expr = & e->args[i]; + e->args[i]->visit (this); + } + current_expr = last_expr; +} + +void +dead_assignment_remover::visit_if_statement (if_statement* s) +{ + expression** last_expr = current_expr; + current_expr = & s->condition; + s->condition->visit (this); + s->thenblock->visit (this); + if (s->elseblock) + s->elseblock->visit (this); + current_expr = last_expr; +} + +void +dead_assignment_remover::visit_for_loop (for_loop* s) +{ + expression** last_expr = current_expr; + if (s->init) s->init->visit (this); + current_expr = & s->cond; + s->cond->visit (this); + if (s->incr) s->incr->visit (this); + s->block->visit (this); + current_expr = last_expr; +} // Let's remove assignments to variables that are never read. We // rewrite "(foo = expr)" as "(expr)". This makes foo a candidate to -- cgit From 27d24ae2a4beddefc1aace0baf25f17ff92e22eb Mon Sep 17 00:00:00 2001 From: "Frank Ch. Eigler" Date: Tue, 20 May 2008 17:34:07 -0400 Subject: PR6538: warn about read-only variables --- elaborate.cxx | 32 +++++++++++++++++++++++++++++--- 1 file changed, 29 insertions(+), 3 deletions(-) (limited to 'elaborate.cxx') diff --git a/elaborate.cxx b/elaborate.cxx index 4bc43832..f8bfabdb 100644 --- a/elaborate.cxx +++ b/elaborate.cxx @@ -1624,7 +1624,13 @@ void semantic_pass_opt2 (systemtap_session& s, bool& relaxed_p) // don't increment j } else - j++; + { + if (vut.written.find (l) == vut.written.end()) + if (! s.suppress_warnings) + clog << "WARNING: read-only local variable " << *l->tok << endl; + + j++; + } } for (unsigned i=0; ilocals.size(); /* see below */) @@ -1649,7 +1655,12 @@ void semantic_pass_opt2 (systemtap_session& s, bool& relaxed_p) // don't increment j } else - j++; + { + if (vut.written.find (l) == vut.written.end()) + if (! s.suppress_warnings) + clog << "WARNING: read-only local variable " << *l->tok << endl; + j++; + } } for (unsigned i=0; itok << endl; + i++; + } } } @@ -1834,6 +1850,8 @@ void semantic_pass_opt3 (systemtap_session& s, bool& relaxed_p) for (unsigned i=0; ibody->visit (& dar); // The rewrite operation is performed within the visitor. + + // XXX: we could also zap write-only globals here } @@ -2057,6 +2075,8 @@ void semantic_pass_opt4 (systemtap_session& s, bool& relaxed_p) p->body = new null_statement(); p->body->tok = p->tok; + + // XXX: possible duplicate warnings; see below } } for (unsigned i=0; ibody = new null_statement(); fn->body->tok = fn->tok; + + // XXX: the next iteration of the outer optimization loop may + // take this new null_statement away again, and thus give us a + // fresh warning. It would be better if this fixup was performed + // only after the relaxation iterations. + // XXX: or else see bug #6469. } } } -- cgit From fcc7aafa64338bdbac356dd509acd20f35563ef5 Mon Sep 17 00:00:00 2001 From: Stan Cox Date: Wed, 21 May 2008 09:22:17 -0400 Subject: Optimize compound and binary expression assignments. --- elaborate.cxx | 13 +++++++++++++ 1 file changed, 13 insertions(+) (limited to 'elaborate.cxx') diff --git a/elaborate.cxx b/elaborate.cxx index 4bc43832..87deb9cf 100644 --- a/elaborate.cxx +++ b/elaborate.cxx @@ -1696,6 +1696,7 @@ struct dead_assignment_remover: public traversing_visitor // called with null current_expr. void visit_assignment (assignment* e); + void visit_binary_expression (binary_expression* e); void visit_arrayindex (arrayindex* e); void visit_functioncall (functioncall* e); void visit_if_statement (if_statement* e); @@ -1726,6 +1727,7 @@ dead_assignment_remover::visit_assignment (assignment* e) { expression** last_expr = current_expr; e->left->visit (this); + current_expr = &e->right; e->right->visit (this); current_expr = last_expr; if (vut.read.find(leftvar) == vut.read.end()) // var never read? @@ -1758,6 +1760,17 @@ dead_assignment_remover::visit_assignment (assignment* e) } } +void +dead_assignment_remover::visit_binary_expression (binary_expression* e) +{ + expression** last_expr = current_expr; + current_expr = &e->left; + e->left->visit (this); + current_expr = &e->right; + e->right->visit (this); + current_expr = last_expr; +} + void dead_assignment_remover::visit_arrayindex (arrayindex *e) { -- cgit From d0c4107b0e02c31acb062de829c6d104cb6918df Mon Sep 17 00:00:00 2001 From: "Frank Ch. Eigler" Date: Wed, 21 May 2008 11:42:51 -0400 Subject: PR6538: fix treatment of initialized globals --- elaborate.cxx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'elaborate.cxx') diff --git a/elaborate.cxx b/elaborate.cxx index f8bfabdb..26786c00 100644 --- a/elaborate.cxx +++ b/elaborate.cxx @@ -1683,7 +1683,8 @@ void semantic_pass_opt2 (systemtap_session& s, bool& relaxed_p) } else { - if (vut.written.find (l) == vut.written.end()) + if (vut.written.find (l) == vut.written.end() && + ! l->init) // no initializer if (! s.suppress_warnings) clog << "WARNING: read-only global variable " << *l->tok << endl; i++; -- cgit