VM: [Kernel] Ensure we have correct try-index on join blocks for break destinations

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 716 matching lines @@
 
 
 class BreakableBlock {
  public:
   BreakableBlock(FlowGraphBuilder* builder, LabeledStatement* statement)
       : builder_(builder),
         labeled_statement_(statement),
         outer_(builder->breakable_block_),
         destination_(NULL),
         outer_finally_(builder->try_finally_block_),
-        context_depth_(builder->context_depth_) {
+        context_depth_(builder->context_depth_),
+        try_index_(builder->CurrentTryIndex()) {
     builder_->breakable_block_ = this;
   }
   ~BreakableBlock() { builder_->breakable_block_ = outer_; }
 
   bool HadJumper() { return destination_ != NULL; }
 
   JoinEntryInstr* destination() { return destination_; }
 
   JoinEntryInstr* BreakDestination(LabeledStatement* label,
                                    TryFinallyBlock** outer_finally,
                                    intptr_t* context_depth) {
     BreakableBlock* block = builder_->breakable_block_;
     while (block->labeled_statement_ != label) {
       block = block->outer_;
     }
     ASSERT(block != NULL);
     *outer_finally = block->outer_finally_;
     *context_depth = block->context_depth_;
     return block->EnsureDestination();
   }
 
  private:
   JoinEntryInstr* EnsureDestination() {
     if (destination_ == NULL) {
-      destination_ = builder_->BuildJoinEntry();
+      destination_ = builder_->BuildJoinEntry(try_index_);
     }
     return destination_;
   }
 
   FlowGraphBuilder* builder_;
   LabeledStatement* labeled_statement_;
   BreakableBlock* outer_;
   JoinEntryInstr* destination_;
   TryFinallyBlock* outer_finally_;
   intptr_t context_depth_;
+  intptr_t try_index_;

[Vyacheslav Egorov (Google), 2017/01/17 22:24:08]

const?

 };
 
 
 class SwitchBlock {
  public:
   SwitchBlock(FlowGraphBuilder* builder, SwitchStatement* switch_stmt)
       : builder_(builder),
         outer_(builder->switch_block_),
         outer_finally_(builder->try_finally_block_),
         switch_statement_(switch_stmt),
-        context_depth_(builder->context_depth_) {
+        context_depth_(builder->context_depth_),
+        try_index_(builder->CurrentTryIndex()) {
     builder_->switch_block_ = this;
   }
   ~SwitchBlock() { builder_->switch_block_ = outer_; }
 
   bool HadJumper(SwitchCase* switch_case) {
     return destinations_.Lookup(switch_case) != NULL;
   }
 
   JoinEntryInstr* Destination(SwitchCase* label,
                               TryFinallyBlock** outer_finally = NULL,
@@ skipping 15 matching lines @@
     // Ensure there's [JoinEntryInstr] for that [SwitchCase].
     return block->EnsureDestination(label);
   }
 
  private:
   typedef std::set<SwitchCase*> DestinationSwitches;
 
   JoinEntryInstr* EnsureDestination(SwitchCase* switch_case) {
     JoinEntryInstr* cached_inst = destinations_.Lookup(switch_case);
     if (cached_inst == NULL) {
-      JoinEntryInstr* inst = builder_->BuildJoinEntry();
+      JoinEntryInstr* inst = builder_->BuildJoinEntry(try_index_);
       destinations_.Insert(switch_case, inst);
       return inst;
     }
     return cached_inst;
   }
 
   void EnsureSwitchCaseMapping() {
     if (destination_switches_.begin() == destination_switches_.end()) {
       List<SwitchCase>& cases = switch_statement_->cases();
       for (intptr_t i = 0; i < cases.length(); i++) {
         destination_switches_.insert(cases[i]);
       }
     }
   }
 
   bool Contains(SwitchCase* sc) {
     return destination_switches_.find(sc) != destination_switches_.end();
   }
 
   FlowGraphBuilder* builder_;
   SwitchBlock* outer_;
 
   Map<SwitchCase, JoinEntryInstr*> destinations_;
   DestinationSwitches destination_switches_;
 
   TryFinallyBlock* outer_finally_;
   SwitchStatement* switch_statement_;
   intptr_t context_depth_;
+  intptr_t try_index_;

[Vyacheslav Egorov (Google), 2017/01/17 22:24:08]

const?

 };
 
 
 class TryFinallyBlock {
  public:
   TryFinallyBlock(FlowGraphBuilder* builder, Statement* finalizer)
       : builder_(builder),
         outer_(builder->try_finally_block_),
         finalizer_(finalizer),
         context_depth_(builder->context_depth_),
@@ skipping 2866 matching lines @@
     parsed_function_->set_default_parameter_values(default_values);
   }
 }
 
 
 TargetEntryInstr* FlowGraphBuilder::BuildTargetEntry() {
   return new (Z) TargetEntryInstr(AllocateBlockId(), CurrentTryIndex());
 }
 
 
+JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry(intptr_t try_index) {
+  return new (Z) JoinEntryInstr(AllocateBlockId(), try_index);
+}
+
+
 JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry() {
   return new (Z) JoinEntryInstr(AllocateBlockId(), CurrentTryIndex());
 }
 
 
 Fragment FlowGraphBuilder::TranslateInitializers(
     Class* kernel_klass,
     List<Initializer>* initializers) {
   Fragment instructions;
 
@@ skipping 2234 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)