Adjust context level when required before executing inlined finally clauses.

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 95 matching lines @@
 // Base class for a stack of enclosing statements of interest (e.g.,
 // blocks (breakable) and loops (continuable)).
 class NestedStatement : public ValueObject {
  public:
   FlowGraphBuilder* owner() const { return owner_; }
   const SourceLabel* label() const { return label_; }
   NestedStatement* outer() const { return outer_; }
   JoinEntryInstr* break_target() const { return break_target_; }
 
   virtual intptr_t ContextLevel() const;
+  virtual void AdjustContextLevel(intptr_t context_level);
 
   virtual JoinEntryInstr* BreakTargetFor(SourceLabel* label);
   virtual JoinEntryInstr* ContinueTargetFor(SourceLabel* label);
 
  protected:
   NestedStatement(FlowGraphBuilder* owner, const SourceLabel* label)
       : owner_(owner),
         label_(label),
         outer_(owner->nesting_stack_),
         break_target_(NULL),
@@ skipping 19 matching lines @@
   const intptr_t try_index_;
 };
 
 
 intptr_t NestedStatement::ContextLevel() const {
   // Context level is determined by the innermost nested statement having one.
   return (outer() == NULL) ? 0 : outer()->ContextLevel();
 }
 
 
+void NestedStatement::AdjustContextLevel(intptr_t context_level) {
+  // There must be a NestedContextAdjustment on the nesting stack.
+  ASSERT(outer() != NULL);
+  outer()->AdjustContextLevel(context_level);
+}
+
+
 intptr_t FlowGraphBuilder::context_level() const {
   return (nesting_stack() == NULL) ? 0 : nesting_stack()->ContextLevel();
 }
 
 
 JoinEntryInstr* NestedStatement::BreakTargetFor(SourceLabel* label) {
   if (label != label_) return NULL;
   if (break_target_ == NULL) {
     break_target_ =
         new(owner()->zone()) JoinEntryInstr(owner()->AllocateBlockId(),
-                                               owner()->try_index());
+                                            owner()->try_index());
   }
   return break_target_;
 }
 
 
 JoinEntryInstr* NestedStatement::ContinueTargetFor(SourceLabel* label) {
   return NULL;
 }
 
 
@@ skipping 10 matching lines @@
 };
 
 
 intptr_t NestedBlock::ContextLevel() const {
   return ((scope_ == NULL) || (scope_->num_context_variables() == 0))
       ? NestedStatement::ContextLevel()
       : scope_->context_level();
 }
 
 
+// A nested statement reflecting a context level adjustment.
+class NestedContextAdjustment : public NestedStatement {
+ public:
+  NestedContextAdjustment(FlowGraphBuilder* owner, intptr_t context_level)
+      : NestedStatement(owner, NULL), context_level_(context_level) { }
+
+  virtual intptr_t ContextLevel() const { return context_level_; }
+
+  virtual void AdjustContextLevel(intptr_t context_level) {
+    ASSERT(context_level <= context_level_);
+    context_level_ = context_level;
+  }
+
+ private:
+  intptr_t context_level_;
+};
+
+
 // A nested statement that can be the target of a continue as well as a
 // break.
 class NestedLoop : public NestedStatement {
  public:
   NestedLoop(FlowGraphBuilder* owner, SourceLabel* label)
       : NestedStatement(owner, label), continue_target_(NULL) {
     owner->IncrementLoopDepth();
   }
 
   virtual ~NestedLoop() {
@@ skipping 842 matching lines @@
 
 
 // <Statement> ::= Return { value:                <Expression>
 //                          inlined_finally_list: <InlinedFinally>* }
 void EffectGraphVisitor::VisitReturnNode(ReturnNode* node) {
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* return_value = for_value.value();
 
+  NestedContextAdjustment context_adjustment(owner(), owner()->context_level());
+
   if (node->inlined_finally_list_length() > 0) {
     LocalVariable* temp = owner()->parsed_function().finally_return_temp_var();
     ASSERT(temp != NULL);
     Do(BuildStoreLocal(*temp, return_value));
     for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
       InlineBailout("EffectGraphVisitor::VisitReturnNode (exception)");
       EffectGraphVisitor for_effect(owner());
       node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
       Append(for_effect);
       if (!is_open()) {
@@ skipping 1220 matching lines @@
       exit_ = for_test.CreateFalseSuccessor();
     } else {
       for_test.IfFalseGoto(nested_loop.break_target());
       exit_ = nested_loop.break_target();
     }
   }
 }
 
 
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
+  NestedContextAdjustment context_adjustment(owner(), owner()->context_level());
+
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
     EffectGraphVisitor for_effect(owner());
     node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) return;
   }
 
   // Unchain the context(s) up to the outer context level of the scope which
   // contains the destination label.
   SourceLabel* label = node->label();
   ASSERT(label->owner() != NULL);
-  int target_context_level = 0;
-  LocalScope* target_scope = label->owner();
-  if (target_scope->num_context_variables() > 0) {
-    // The scope of the target label allocates a context, therefore its outer
-    // scope is at a lower context level.
-    target_context_level = target_scope->context_level() - 1;
-  } else {
-    // The scope of the target label does not allocate a context, so its outer
-    // scope is at the same context level. Find it.
-    while ((target_scope != NULL) &&
-           (target_scope->num_context_variables() == 0)) {
-      target_scope = target_scope->parent();
-    }
-    if (target_scope != NULL) {
-      target_context_level = target_scope->context_level();
-    }
-  }
-  ASSERT(target_context_level >= 0);
-  intptr_t current_context_level = owner()->context_level();
-  ASSERT(current_context_level >= target_context_level);
-  UnchainContexts(current_context_level - target_context_level);
+  AdjustContextLevel(label->owner());
 
   JoinEntryInstr* jump_target = NULL;
   NestedStatement* current = owner()->nesting_stack();
   while (current != NULL) {
     jump_target = (node->kind() == Token::kBREAK)
         ? current->BreakTargetFor(node->label())
         : current->ContinueTargetFor(node->label());
     if (jump_target != NULL) break;
     current = current->outer();
   }
@@ skipping 1520 matching lines @@
                                 Context::parent_offset(),
                                 // Not an instance, no type.
                                 Type::ZoneHandle(Z, Type::null()),
                                 Scanner::kNoSourcePos));
     }
     Do(BuildStoreContext(context));
   }
 }
 
 
+void EffectGraphVisitor::AdjustContextLevel(LocalScope* target_scope) {
+  ASSERT(target_scope != NULL);
+  intptr_t target_context_level = 0;
+  if (target_scope->num_context_variables() > 0) {
+    // The scope of the target label allocates a context, therefore its outer
+    // scope is at a lower context level.
+    target_context_level = target_scope->context_level() - 1;
+  } else {
+    // The scope of the target label does not allocate a context, so its outer
+    // scope is at the same context level. Find it.
+    while ((target_scope != NULL) &&
+           (target_scope->num_context_variables() == 0)) {
+      target_scope = target_scope->parent();
+    }
+    if (target_scope != NULL) {
+      target_context_level = target_scope->context_level();
+    }
+  }
+  ASSERT(target_context_level >= 0);
+  intptr_t current_context_level = owner()->context_level();
+  ASSERT(current_context_level >= target_context_level);
+  UnchainContexts(current_context_level - target_context_level);
+  // Record adjusted context level.
+  owner()->nesting_stack()->AdjustContextLevel(target_context_level);
+}
+
+
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   LocalScope* scope = node->scope();
   const Function& function = owner()->function();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   const bool is_top_level_sequence =
       node == owner()->parsed_function().node_sequence();
@@ skipping 519 matching lines @@
   const intptr_t try_index = owner()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
     intptr_t outer_try_index = node->try_index();
     owner()->set_try_index(outer_try_index);
   }
 
   // Note: do not restore the saved_try_context here since the inlined
-  // code is running at he context level of the return or jump instruction
-  // that follows the inlined code. See issue 22822.
+  // code is not reached via an exception handler, therefore the context is
+  // always properly set on entry. In other words, the inlined finally clause is
+  // never the target of a long jump that would find an uninitialized current
+  // context variable.
 
   JoinEntryInstr* finally_entry =
       new(Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
   EffectGraphVisitor for_finally_block(owner());
+  for_finally_block.AdjustContextLevel(node->finally_block()->scope());
   node->finally_block()->Visit(&for_finally_block);
 
   if (try_index >= 0) {
     owner()->set_try_index(try_index);
   }
 
   if (for_finally_block.is_open()) {
     JoinEntryInstr* after_finally =
         new(Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
     for_finally_block.Goto(after_finally);
@@ skipping 57 matching lines @@
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart