source_func = call.declaration->definition;
/* Populate referenced_names from the target function so we can rename
- variables from the inlined function that would conflict. */
+ variables from the inlined function that would conflict. Only consider
+ names which declared in blocks linearly related to the target block. */
pass = REFERENCED;
- target_func.visit(*this);
+ tgt_blk.visit(*this);
+ for(const Block *b=&tgt_blk; b; b=b->parent)
+ for(const auto &kvp: b->variables)
+ referenced_names.insert(kvp.first);
/* Inline and rename passes must be interleaved so used variable names are
known when inlining the return statement. */
if(targets_overlap(i->first, assign.target))
i->second->blocked = true;
- expressions.push_back(ExpressionInfo());
+ expressions.emplace_back();
ExpressionInfo &info = expressions.back();
info.target = assign.target;
// Self-referencing assignments can't be inlined without additional work.
analyze and non-trivial expressions could be expensive to inline. */
if((current_block->parent || (constant && r_trivial)) && var.interface.empty())
{
- expressions.push_back(ExpressionInfo());
+ expressions.emplace_back();
ExpressionInfo &info = expressions.back();
info.target = &var;
/* Assume variables declared in an iteration initialization statement
}
-void ConstantConditionEliminator::apply(Stage &stage)
+bool ConstantConditionEliminator::apply(Stage &stage)
{
stage.content.visit(*this);
NodeRemover().apply(stage, nodes_to_remove);
+ return !nodes_to_remove.empty();
}
ConstantConditionEliminator::ConstantStatus ConstantConditionEliminator::check_constant_condition(const Expression &expr)
void UnusedVariableRemover::record_assignment(const Assignment::Target &target, Node &node)
{
- assignments.push_back(AssignmentInfo());
+ assignments.emplace_back();
AssignmentInfo &assign_info = assignments.back();
assign_info.node = &node;
assign_info.target = target;