Initialize the async jump variable with a smi to avoid polymorphic comparison.

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 1437 matching lines @@
   }
   return new(I) AssertAssignableInstr(token_pos,
                                       value,
                                       instantiator,
                                       instantiator_type_arguments,
                                       dst_type,
                                       dst_name);
 }
 
 
-void EffectGraphVisitor::BuildAwaitJump(LocalScope* lookup_scope,
+void EffectGraphVisitor::BuildAwaitJump(LocalVariable* old_context,
+                                        LocalVariable* continuation_result,
+                                        LocalVariable* continuation_error,
                                         const intptr_t old_ctx_level,
                                         JoinEntryInstr* target) {
   // Building a jump consists of the following actions:
   // * Record the current continuation result in a temporary.
   // * Restore the old context.
   // * Overwrite the old context's continuation result with the temporary.
   // * Append a Goto to the target's join.
-  LocalVariable* old_ctx = lookup_scope->LookupVariable(
-      Symbols::AwaitContextVar(), false);
-  LocalVariable* continuation_result = lookup_scope->LookupVariable(
-      Symbols::AsyncOperationParam(), false);
-  LocalVariable* continuation_error = lookup_scope->LookupVariable(
-      Symbols::AsyncOperationErrorParam(), false);
   ASSERT((continuation_result != NULL) && continuation_result->is_captured());
   ASSERT((continuation_error != NULL) && continuation_error->is_captured());
-  ASSERT((old_ctx != NULL) && old_ctx->is_captured());
+  ASSERT((old_context != NULL) && old_context->is_captured());
   // Before restoring the continuation context we need to temporary save the
   // result and error parameter.
   LocalVariable* temp_result_var = EnterTempLocalScope(
       Bind(BuildLoadLocal(*continuation_result)));
   LocalVariable* temp_error_var = EnterTempLocalScope(
       Bind(BuildLoadLocal(*continuation_error)));
   // Restore the saved continuation context.
-  BuildRestoreContext(*old_ctx);
+  BuildRestoreContext(*old_context);
 
   // Pass over the continuation result.
 
   // FlowGraphBuilder is at top context level, but the await target has possibly
   // been recorded in a nested context (old_ctx_level). We need to unroll
   // manually here.
   intptr_t delta = old_ctx_level -
                    continuation_result->owner()->context_level();
   ASSERT(delta >= 0);
   Value* context = Bind(new(I) CurrentContextInstr());
@@ skipping 2382 matching lines @@
 
     Instruction* saved_entry = entry_;
     Instruction* saved_exit = exit_;
     entry_ = NULL;
     exit_ = NULL;
 
     LoadLocalNode* load_jump_cnt = new(I) LoadLocalNode(
         Scanner::kNoSourcePos, jump_var);
     ComparisonNode* check_jump_cnt;
     const intptr_t num_await_states = owner()->await_joins()->length();
+    LocalVariable* old_context = top_scope->LookupVariable(
+        Symbols::AwaitContextVar(), false);
+    LocalVariable* continuation_result = top_scope->LookupVariable(
+        Symbols::AsyncOperationParam(), false);
+    LocalVariable* continuation_error = top_scope->LookupVariable(
+        Symbols::AsyncOperationErrorParam(), false);
     for (intptr_t i = 0; i < num_await_states; i++) {
       check_jump_cnt = new(I) ComparisonNode(
           Scanner::kNoSourcePos,
           Token::kEQ,
           load_jump_cnt,
           new(I) LiteralNode(
               Scanner::kNoSourcePos, Smi::ZoneHandle(I, Smi::New(i))));
       TestGraphVisitor for_test(owner(), Scanner::kNoSourcePos);
       check_jump_cnt->Visit(&for_test);
       EffectGraphVisitor for_true(owner());
       EffectGraphVisitor for_false(owner());
 
-      for_true.BuildAwaitJump(top_scope,
+      for_true.BuildAwaitJump(old_context,
+                              continuation_result,
+                              continuation_error,
                               (*owner()->await_levels())[i],
                               (*owner()->await_joins())[i]);
       Join(for_test, for_true, for_false);
 
       if (i == 0) {
         // Manually link up the preamble start.
         preamble_start->previous()->set_next(for_test.entry());
         for_test.entry()->set_previous(preamble_start->previous());
       }
       if (i == (num_await_states - 1)) {
@@ skipping 377 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