diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc
index d2fdd60..5395c71 100644
--- a/runtime/vm/compiler/aot/precompiler.cc
+++ b/runtime/vm/compiler/aot/precompiler.cc
@@ -2774,7 +2774,7 @@
                                   "BuildFlowGraph");
 #endif  // !PRODUCT
         flow_graph =
-            pipeline->BuildFlowGraph(zone, parsed_function(), *ic_data_array,
+            pipeline->BuildFlowGraph(zone, parsed_function(), ic_data_array,
                                      Compiler::kNoOSRDeoptId, optimized());
       }
 
diff --git a/runtime/vm/compiler/backend/flow_graph.h b/runtime/vm/compiler/backend/flow_graph.h
index ba3e046..a027b8a 100644
--- a/runtime/vm/compiler/backend/flow_graph.h
+++ b/runtime/vm/compiler/backend/flow_graph.h
@@ -128,7 +128,9 @@
   }
 
   intptr_t CurrentContextEnvIndex() const {
-    return EnvIndex(parsed_function().current_context_var());
+    return FLAG_use_bytecode_compiler
+               ? -1
+               : EnvIndex(parsed_function().current_context_var());
   }
 
   intptr_t RawTypeArgumentEnvIndex() const {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.cc b/runtime/vm/compiler/backend/flow_graph_compiler.cc
index 0dcc98fb..efb9313 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.cc
@@ -1037,7 +1037,8 @@
 }
 
 void FlowGraphCompiler::FinalizeVarDescriptors(const Code& code) {
-  if (code.is_optimized()) {
+  // TODO(alexmarkov): revise local vars descriptors when compiling bytecode
+  if (code.is_optimized() || FLAG_use_bytecode_compiler) {
     // Optimized code does not need variable descriptors. They are
     // only stored in the unoptimized version.
     code.set_var_descriptors(Object::empty_var_descriptors());
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index 3e94025..63fc9df 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -779,17 +779,21 @@
   }
 }
 
-const NativeFieldDesc* NativeFieldDesc::GetTypeArgumentsFieldFor(
-    Zone* zone,
-    const Class& cls) {
+const NativeFieldDesc* NativeFieldDesc::GetTypeArgumentsField(Zone* zone,
+                                                              intptr_t offset) {
   // TODO(vegorov) consider caching type arguments fields for specific classes
   // in some sort of a flow-graph specific cache.
-  const intptr_t offset = cls.type_arguments_field_offset();
   ASSERT(offset != Class::kNoTypeArguments);
   return new (zone) NativeFieldDesc(kTypeArguments, offset, kDynamicCid,
                                     /*immutable=*/true);
 }
 
+const NativeFieldDesc* NativeFieldDesc::GetTypeArgumentsFieldFor(
+    Zone* zone,
+    const Class& cls) {
+  return GetTypeArgumentsField(zone, cls.type_arguments_field_offset());
+}
+
 RawAbstractType* NativeFieldDesc::type() const {
   if (cid() == kSmiCid) {
     return Type::SmiType();
@@ -1233,7 +1237,10 @@
 }
 
 void Value::AddToList(Value* value, Value** list) {
+  ASSERT(value->next_use() == nullptr);
+  ASSERT(value->previous_use() == nullptr);
   Value* next = *list;
+  ASSERT(value != next);
   *list = value;
   value->set_next_use(next);
   value->set_previous_use(NULL);
@@ -3965,7 +3972,8 @@
   }
 
 #if !defined(TARGET_ARCH_DBC)
-  if (compiler->is_optimizing() && HasICData()) {
+  if ((compiler->is_optimizing() || FLAG_use_bytecode_compiler) &&
+      HasICData()) {
     ASSERT(HasICData());
     if (ic_data()->NumberOfUsedChecks() > 0) {
       const ICData& unary_ic_data =
diff --git a/runtime/vm/compiler/backend/il.h b/runtime/vm/compiler/backend/il.h
index ebac7b6..f7e8350 100644
--- a/runtime/vm/compiler/backend/il.h
+++ b/runtime/vm/compiler/backend/il.h
@@ -1708,10 +1708,10 @@
                        GraphEntryInstr* graph_entry,
                        const Array& handler_types,
                        intptr_t catch_try_index,
-                       const LocalVariable& exception_var,
-                       const LocalVariable& stacktrace_var,
                        bool needs_stacktrace,
                        intptr_t deopt_id,
+                       const LocalVariable* exception_var,
+                       const LocalVariable* stacktrace_var,
                        const LocalVariable* raw_exception_var,
                        const LocalVariable* raw_stacktrace_var)
       : BlockEntryInstr(block_id, try_index, deopt_id),
@@ -1739,8 +1739,8 @@
 
   GraphEntryInstr* graph_entry() const { return graph_entry_; }
 
-  const LocalVariable& exception_var() const { return exception_var_; }
-  const LocalVariable& stacktrace_var() const { return stacktrace_var_; }
+  const LocalVariable* exception_var() const { return exception_var_; }
+  const LocalVariable* stacktrace_var() const { return stacktrace_var_; }
 
   const LocalVariable* raw_exception_var() const { return raw_exception_var_; }
   const LocalVariable* raw_stacktrace_var() const {
@@ -1775,8 +1775,8 @@
   const Array& catch_handler_types_;
   const intptr_t catch_try_index_;
   GrowableArray<Definition*> initial_definitions_;
-  const LocalVariable& exception_var_;
-  const LocalVariable& stacktrace_var_;
+  const LocalVariable* exception_var_;
+  const LocalVariable* stacktrace_var_;
   const LocalVariable* raw_exception_var_;
   const LocalVariable* raw_stacktrace_var_;
   const bool needs_stacktrace_;
@@ -2993,6 +2993,7 @@
     ASSERT(!dst_type.IsNull());
     ASSERT(!dst_type.IsTypeRef());
     ASSERT(!dst_name.IsNull());
+    ASSERT(!dst_type.IsDynamicType());
     SetInputAt(0, value);
     SetInputAt(1, instantiator_type_arguments);
     SetInputAt(2, function_type_arguments);
@@ -5131,6 +5132,8 @@
 
   static const NativeFieldDesc* Get(Kind kind);
   static const NativeFieldDesc* GetLengthFieldForArrayCid(intptr_t array_cid);
+  static const NativeFieldDesc* GetTypeArgumentsField(Zone* zone,
+                                                      intptr_t offset);
   static const NativeFieldDesc* GetTypeArgumentsFieldFor(Zone* zone,
                                                          const Class& cls);
 
diff --git a/runtime/vm/compiler/backend/il_printer.cc b/runtime/vm/compiler/backend/il_printer.cc
index ed6af4d..233b45d 100644
--- a/runtime/vm/compiler/backend/il_printer.cc
+++ b/runtime/vm/compiler/backend/il_printer.cc
@@ -707,7 +707,7 @@
   instantiator_type_arguments()->PrintTo(f);
   f->Print("), function_type_args(");
   function_type_arguments()->PrintTo(f);
-  f->Print(")");
+  f->Print("), instantiator_class(%s)", instantiator_class().ToCString());
 }
 
 void AllocateContextInstr::PrintOperandsTo(BufferFormatter* f) const {
diff --git a/runtime/vm/compiler/backend/inliner.cc b/runtime/vm/compiler/backend/inliner.cc
index 0550ff3..2d35fbd 100644
--- a/runtime/vm/compiler/backend/inliner.cc
+++ b/runtime/vm/compiler/backend/inliner.cc
@@ -973,7 +973,7 @@
             entry_kind = instr->entry_kind();
           }
           kernel::FlowGraphBuilder builder(
-              parsed_function, *ic_data_array, /* not building var desc */ NULL,
+              parsed_function, ic_data_array, /* not building var desc */ NULL,
               exit_collector,
               /* optimized = */ true, Compiler::kNoOSRDeoptId,
               caller_graph_->max_block_id() + 1,
diff --git a/runtime/vm/compiler/backend/type_propagator.cc b/runtime/vm/compiler/backend/type_propagator.cc
index 2dfe032..67ac074 100644
--- a/runtime/vm/compiler/backend/type_propagator.cc
+++ b/runtime/vm/compiler/backend/type_propagator.cc
@@ -938,6 +938,12 @@
     return CompileType::Dynamic();
   }
 
+  if (FLAG_use_bytecode_compiler &&
+      graph_entry->parsed_function().node_sequence() == nullptr) {
+    // TODO(alexmarkov): Consider adding node_sequence() and scope.
+    return CompileType::Dynamic();
+  }
+
   // Parameter is the receiver.
   if ((index() == 0) &&
       (function.IsDynamicFunction() || function.IsGenerativeConstructor())) {
diff --git a/runtime/vm/compiler/call_specializer.cc b/runtime/vm/compiler/call_specializer.cc
index 471b5b9..75e6d4c 100644
--- a/runtime/vm/compiler/call_specializer.cc
+++ b/runtime/vm/compiler/call_specializer.cc
@@ -998,10 +998,8 @@
   }
 
   // Build an AssertAssignable if necessary.
-  if (I->argument_type_checks()) {
-    const AbstractType& dst_type =
-        AbstractType::ZoneHandle(zone(), field.type());
-
+  const AbstractType& dst_type = AbstractType::ZoneHandle(zone(), field.type());
+  if (I->argument_type_checks() && !dst_type.IsTopType()) {
     // Compute if we need to type check the value. Always type check if
     // not in strong mode or if at a dynamic invocation.
     bool needs_check = true;
diff --git a/runtime/vm/compiler/compiler_sources.gni b/runtime/vm/compiler/compiler_sources.gni
index a3f399d..9300603 100644
--- a/runtime/vm/compiler/compiler_sources.gni
+++ b/runtime/vm/compiler/compiler_sources.gni
@@ -78,6 +78,8 @@
   "compiler_state.h",
   "frontend/base_flow_graph_builder.cc",
   "frontend/base_flow_graph_builder.h",
+  "frontend/bytecode_flow_graph_builder.cc",
+  "frontend/bytecode_flow_graph_builder.h",
   "frontend/bytecode_reader.cc",
   "frontend/bytecode_reader.h",
   "frontend/constant_evaluator.cc",
diff --git a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
index 55e3531..af1c0c7 100644
--- a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
+++ b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
@@ -302,6 +302,14 @@
   }
 }
 
+Fragment BaseFlowGraphBuilder::LoadField(const Field& field) {
+  LoadFieldInstr* load = new (Z) LoadFieldInstr(
+      Pop(), &MayCloneField(field), AbstractType::ZoneHandle(Z, field.type()),
+      TokenPosition::kNoSource, parsed_function_);
+  Push(load);
+  return Fragment(load);
+}
+
 Fragment BaseFlowGraphBuilder::LoadField(intptr_t offset, intptr_t class_id) {
   LoadFieldInstr* load = new (Z) LoadFieldInstr(
       Pop(), offset, AbstractType::ZoneHandle(Z), TokenPosition::kNoSource);
@@ -495,14 +503,6 @@
   return variable;
 }
 
-intptr_t BaseFlowGraphBuilder::CurrentTryIndex() {
-  if (try_catch_block_ == NULL) {
-    return CatchClauseNode::kInvalidTryIndex;
-  } else {
-    return try_catch_block_->try_index();
-  }
-}
-
 void BaseFlowGraphBuilder::SetTempIndex(Definition* definition) {
   definition->set_temp_index(
       stack_ == NULL ? 0 : stack_->definition()->temp_index() + 1);
diff --git a/runtime/vm/compiler/frontend/base_flow_graph_builder.h b/runtime/vm/compiler/frontend/base_flow_graph_builder.h
index 190635c..28d4a4b 100644
--- a/runtime/vm/compiler/frontend/base_flow_graph_builder.h
+++ b/runtime/vm/compiler/frontend/base_flow_graph_builder.h
@@ -113,6 +113,7 @@
   BaseFlowGraphBuilder(
       const ParsedFunction* parsed_function,
       intptr_t last_used_block_id,
+      intptr_t osr_id = DeoptId::kNone,
       ZoneGrowableArray<intptr_t>* context_level_array = nullptr,
       InlineExitCollector* exit_collector = nullptr,
       bool inlining_unchecked_entry = false)
@@ -120,10 +121,11 @@
         function_(parsed_function_->function()),
         thread_(Thread::Current()),
         zone_(thread_->zone()),
+        osr_id_(osr_id),
         context_level_array_(context_level_array),
         context_depth_(0),
         last_used_block_id_(last_used_block_id),
-        try_catch_block_(NULL),
+        current_try_index_(CatchClauseNode::kInvalidTryIndex),
         next_used_try_index_(0),
         stack_(NULL),
         pending_argument_count_(0),
@@ -131,6 +133,7 @@
         exit_collector_(exit_collector),
         inlining_unchecked_entry_(inlining_unchecked_entry) {}
 
+  Fragment LoadField(const Field& field);
   Fragment LoadField(intptr_t offset, intptr_t class_id = kDynamicCid);
   Fragment LoadNativeField(const NativeFieldDesc* native_field);
   Fragment LoadIndexed(intptr_t index_scale);
@@ -230,6 +233,12 @@
   }
 
   intptr_t AllocateTryIndex() { return next_used_try_index_++; }
+  intptr_t CurrentTryIndex() const { return current_try_index_; }
+  void SetCurrentTryIndex(intptr_t try_index) {
+    current_try_index_ = try_index;
+  }
+
+  bool IsCompiledForOsr() { return osr_id_ != DeoptId::kNone; }
 
   bool IsInlining() const { return exit_collector_ != nullptr; }
 
@@ -263,20 +272,18 @@
 
  protected:
   intptr_t AllocateBlockId() { return ++last_used_block_id_; }
-  intptr_t CurrentTryIndex();
 
   const ParsedFunction* parsed_function_;
   const Function& function_;
   Thread* thread_;
   Zone* zone_;
+  intptr_t osr_id_;
   // Contains (deopt_id, context_level) pairs.
   ZoneGrowableArray<intptr_t>* context_level_array_;
   intptr_t context_depth_;
   intptr_t last_used_block_id_;
 
-  // A chained list of try-catch blocks. Chaining and lookup is done by the
-  // [TryCatchBlock] class.
-  TryCatchBlock* try_catch_block_;
+  intptr_t current_try_index_;
   intptr_t next_used_try_index_;
 
   Value* stack_;
@@ -286,36 +293,13 @@
 
   const bool inlining_unchecked_entry_;
 
-  friend class TryCatchBlock;
   friend class StreamingFlowGraphBuilder;
+  friend class BytecodeFlowGraphBuilder;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BaseFlowGraphBuilder);
 };
 
-class TryCatchBlock {
- public:
-  explicit TryCatchBlock(BaseFlowGraphBuilder* builder,
-                         intptr_t try_handler_index = -1)
-      : builder_(builder),
-        outer_(builder->try_catch_block_),
-        try_index_(try_handler_index) {
-    if (try_index_ == -1) try_index_ = builder->AllocateTryIndex();
-    builder->try_catch_block_ = this;
-  }
-  ~TryCatchBlock() { builder_->try_catch_block_ = outer_; }
-
-  intptr_t try_index() { return try_index_; }
-  TryCatchBlock* outer() const { return outer_; }
-
- private:
-  BaseFlowGraphBuilder* builder_;
-  TryCatchBlock* outer_;
-  intptr_t try_index_;
-
-  DISALLOW_COPY_AND_ASSIGN(TryCatchBlock);
-};
-
 }  // namespace kernel
 }  // namespace dart
 
diff --git a/runtime/vm/compiler/frontend/bytecode_flow_graph_builder.cc b/runtime/vm/compiler/frontend/bytecode_flow_graph_builder.cc
new file mode 100644
index 0000000..e93787f
--- /dev/null
+++ b/runtime/vm/compiler/frontend/bytecode_flow_graph_builder.cc
@@ -0,0 +1,1361 @@
+// Copyright (c) 2018, 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/compiler/frontend/bytecode_flow_graph_builder.h"
+
+#include "vm/compiler/backend/il_printer.h"
+#include "vm/compiler/frontend/prologue_builder.h"
+#include "vm/compiler/jit/compiler.h"
+#include "vm/object_store.h"
+#include "vm/stack_frame.h"
+#include "vm/stack_frame_kbc.h"
+
+#if !defined(DART_PRECOMPILED_RUNTIME)
+
+#define B (flow_graph_builder_)
+#define Z (zone_)
+
+namespace dart {
+
+DEFINE_FLAG(bool,
+            print_flow_graph_from_bytecode,
+            false,
+            "Print flow graph constructed from bytecode");
+
+namespace kernel {
+
+// 8-bit unsigned operand at bits 8-15.
+BytecodeFlowGraphBuilder::Operand BytecodeFlowGraphBuilder::DecodeOperandA() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  } else {
+    intptr_t value = KernelBytecode::DecodeA(bytecode_instr_);
+    return Operand(value);
+  }
+}
+
+// 8-bit unsigned operand at bits 16-23.
+BytecodeFlowGraphBuilder::Operand BytecodeFlowGraphBuilder::DecodeOperandB() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  } else {
+    intptr_t value = KernelBytecode::DecodeB(bytecode_instr_);
+    return Operand(value);
+  }
+}
+
+// 8-bit unsigned operand at bits 24-31.
+BytecodeFlowGraphBuilder::Operand BytecodeFlowGraphBuilder::DecodeOperandC() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  } else {
+    intptr_t value = KernelBytecode::DecodeC(bytecode_instr_);
+    return Operand(value);
+  }
+}
+
+// 16-bit unsigned operand at bits 16-31.
+BytecodeFlowGraphBuilder::Operand BytecodeFlowGraphBuilder::DecodeOperandD() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  } else {
+    intptr_t value = KernelBytecode::DecodeD(bytecode_instr_);
+    return Operand(value);
+  }
+}
+
+// 16-bit signed operand at bits 16-31.
+BytecodeFlowGraphBuilder::Operand BytecodeFlowGraphBuilder::DecodeOperandX() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  } else {
+    intptr_t value = KernelBytecode::DecodeX(bytecode_instr_);
+    return Operand(value);
+  }
+}
+
+// 24-bit signed operand at bits 8-31.
+BytecodeFlowGraphBuilder::Operand BytecodeFlowGraphBuilder::DecodeOperandT() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  } else {
+    intptr_t value = KernelBytecode::DecodeT(bytecode_instr_);
+    return Operand(value);
+  }
+}
+
+KBCInstr BytecodeFlowGraphBuilder::InstructionAt(
+    intptr_t pc,
+    KernelBytecode::Opcode expect_opcode) {
+  ASSERT(!is_generating_interpreter());
+  ASSERT((0 <= pc) && (pc < bytecode_length_));
+
+  const KBCInstr instr = raw_bytecode_[pc];
+  if (KernelBytecode::DecodeOpcode(instr) != expect_opcode) {
+    FATAL3("Expected bytecode instruction %s, but found %s at %" Pd "",
+           KernelBytecode::NameOf(KernelBytecode::Encode(expect_opcode)),
+           KernelBytecode::NameOf(instr), pc);
+  }
+
+  return instr;
+}
+
+BytecodeFlowGraphBuilder::Constant BytecodeFlowGraphBuilder::ConstantAt(
+    Operand entry_index,
+    intptr_t add_index) {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  } else {
+    const Object& value = Object::ZoneHandle(
+        Z, object_pool_.ObjectAt(entry_index.value() + add_index));
+    return Constant(Z, value);
+  }
+}
+
+void BytecodeFlowGraphBuilder::PushConstant(Constant constant) {
+  if (is_generating_interpreter()) {
+    B->Push(constant.definition());
+  } else {
+    code_ += B->Constant(constant.value());
+  }
+}
+
+BytecodeFlowGraphBuilder::Constant BytecodeFlowGraphBuilder::PopConstant() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  } else {
+    const Object& value = B->stack_->definition()->AsConstant()->value();
+    code_ += B->Drop();
+    return Constant(Z, value);
+  }
+}
+
+void BytecodeFlowGraphBuilder::LoadStackSlots(intptr_t num_slots) {
+  if (B->stack_ != nullptr) {
+    intptr_t stack_depth = B->stack_->definition()->temp_index() + 1;
+    ASSERT(stack_depth >= num_slots);
+    return;
+  }
+
+  ASSERT(is_generating_interpreter());
+  UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+}
+
+void BytecodeFlowGraphBuilder::AllocateLocalVariables(
+    Operand frame_size,
+    intptr_t num_param_locals) {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  } else {
+    // TODO(alexmarkov): Make table of local variables in bytecode and
+    // propagate type, name and positions.
+
+    ASSERT(local_vars_.is_empty());
+
+    const intptr_t num_bytecode_locals = frame_size.value();
+    ASSERT(num_bytecode_locals >= 0);
+
+    intptr_t num_locals = num_bytecode_locals;
+    if (exception_var_ != nullptr) {
+      ++num_locals;
+    }
+    if (stacktrace_var_ != nullptr) {
+      ++num_locals;
+    }
+    if (parsed_function()->has_arg_desc_var()) {
+      ++num_locals;
+    }
+
+    if (num_locals == 0) {
+      return;
+    }
+
+    local_vars_.EnsureLength(num_bytecode_locals, nullptr);
+    for (intptr_t i = num_param_locals; i < num_bytecode_locals; ++i) {
+      String& name =
+          String::ZoneHandle(Z, Symbols::NewFormatted(thread(), "var%" Pd, i));
+      LocalVariable* local = new (Z)
+          LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                        name, Object::dynamic_type());
+      local->set_index(VariableIndex(-i));
+      local_vars_[i] = local;
+    }
+
+    intptr_t idx = num_bytecode_locals;
+    if (exception_var_ != nullptr) {
+      exception_var_->set_index(VariableIndex(-idx));
+      ++idx;
+    }
+    if (stacktrace_var_ != nullptr) {
+      stacktrace_var_->set_index(VariableIndex(-idx));
+      ++idx;
+    }
+    if (parsed_function()->has_arg_desc_var()) {
+      parsed_function()->arg_desc_var()->set_index(VariableIndex(-idx));
+      ++idx;
+    }
+    ASSERT(idx == num_locals);
+
+    ASSERT(parsed_function()->node_sequence() == nullptr);
+    parsed_function()->AllocateBytecodeVariables(num_locals);
+  }
+}
+
+LocalVariable* BytecodeFlowGraphBuilder::AllocateParameter(
+    intptr_t param_index,
+    VariableIndex var_index) {
+  const String& name =
+      String::ZoneHandle(Z, function().ParameterNameAt(param_index));
+  const AbstractType& type =
+      AbstractType::ZoneHandle(Z, function().ParameterTypeAt(param_index));
+
+  LocalVariable* param_var = new (Z) LocalVariable(
+      TokenPosition::kNoSource, TokenPosition::kNoSource, name, type);
+  param_var->set_index(var_index);
+
+  if (var_index.value() <= 0) {
+    local_vars_[-var_index.value()] = param_var;
+  }
+
+  return param_var;
+}
+
+void BytecodeFlowGraphBuilder::AllocateFixedParameters() {
+  if (is_generating_interpreter()) {
+    return;
+  }
+
+  ASSERT(!function().HasOptionalParameters());
+
+  const intptr_t num_fixed_params = function().num_fixed_parameters();
+  auto parameters =
+      new (Z) ZoneGrowableArray<LocalVariable*>(Z, num_fixed_params);
+
+  for (intptr_t i = 0; i < num_fixed_params; ++i) {
+    LocalVariable* param_var =
+        AllocateParameter(i, VariableIndex(num_fixed_params - i));
+    parameters->Add(param_var);
+  }
+
+  parsed_function()->SetRawParameters(parameters);
+}
+
+LocalVariable* BytecodeFlowGraphBuilder::LocalVariableAt(intptr_t local_index) {
+  ASSERT(!is_generating_interpreter());
+  if (local_index < 0) {
+    // Parameter
+    ASSERT(!function().HasOptionalParameters());
+    const intptr_t param_index = local_index +
+                                 function().num_fixed_parameters() +
+                                 kKBCParamEndSlotFromFp;
+    ASSERT((0 <= param_index) &&
+           (param_index < function().num_fixed_parameters()));
+    return parsed_function()->RawParameterVariable(param_index);
+  } else {
+    return local_vars_.At(local_index);
+  }
+}
+
+void BytecodeFlowGraphBuilder::StoreLocal(Operand local_index) {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  } else {
+    LocalVariable* local_var = LocalVariableAt(local_index.value());
+    code_ += B->StoreLocalRaw(position_, local_var);
+  }
+}
+
+void BytecodeFlowGraphBuilder::LoadLocal(Operand local_index) {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  } else {
+    LocalVariable* local_var = LocalVariableAt(local_index.value());
+    code_ += B->LoadLocal(local_var);
+  }
+}
+
+Value* BytecodeFlowGraphBuilder::Pop() {
+  LoadStackSlots(1);
+  return B->Pop();
+}
+
+ArgumentArray BytecodeFlowGraphBuilder::GetArguments(int count) {
+  ArgumentArray arguments =
+      new (Z) ZoneGrowableArray<PushArgumentInstr*>(Z, count);
+  arguments->SetLength(count);
+  for (intptr_t i = count - 1; i >= 0; --i) {
+    Definition* arg_def = B->stack_->definition();
+    ASSERT(!arg_def->HasSSATemp());
+    ASSERT(arg_def->temp_index() >= i);
+
+    PushArgumentInstr* argument = new (Z) PushArgumentInstr(Pop());
+
+    if (code_.current == arg_def) {
+      code_ <<= argument;
+    } else {
+      Instruction* next = arg_def->next();
+      ASSERT(next != nullptr);
+      arg_def->LinkTo(argument);
+      argument->LinkTo(next);
+    }
+
+    arguments->data()[i] = argument;
+  }
+  return arguments;
+}
+
+void BytecodeFlowGraphBuilder::PropagateStackState(intptr_t target_pc) {
+  if (is_generating_interpreter() || (B->stack_ == nullptr)) {
+    return;
+  }
+
+  // Stack state propagation is supported for forward branches only.
+  // Bytecode generation guarantees that expression stack is empty between
+  // statements and backward jumps are only used to transfer control between
+  // statements (e.g. in loop and continue statements).
+  RELEASE_ASSERT(target_pc > pc_);
+
+  Value* current_stack = B->stack_;
+  Value* target_stack = stack_states_.Lookup(target_pc);
+
+  if (target_stack != nullptr) {
+    // Control flow join should observe the same stack state from
+    // all incoming branches.
+    RELEASE_ASSERT(target_stack == current_stack);
+  } else {
+    stack_states_.Insert(target_pc, current_stack);
+  }
+}
+
+void BytecodeFlowGraphBuilder::BuildInstruction(KernelBytecode::Opcode opcode) {
+  switch (opcode) {
+#define BUILD_BYTECODE_CASE(bytecode)                                          \
+  case KernelBytecode::k##bytecode:                                            \
+    Build##bytecode();                                                         \
+    break;
+
+    FOR_EACH_BYTECODE_IN_FLOW_GRAPH_BUILDER(BUILD_BYTECODE_CASE)
+
+#undef BUILD_BYTECODE_CASE
+    default:
+      FATAL1("Unsupported bytecode instruction %s\n",
+             KernelBytecode::NameOf(bytecode_instr_));
+  }
+}
+
+void BytecodeFlowGraphBuilder::BuildEntry() {
+  AllocateLocalVariables(DecodeOperandD());
+  AllocateFixedParameters();
+}
+
+void BytecodeFlowGraphBuilder::BuildEntryFixed() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  const intptr_t num_fixed_params = DecodeOperandA().value();
+  ASSERT(num_fixed_params == function().num_fixed_parameters());
+
+  AllocateLocalVariables(DecodeOperandD());
+  AllocateFixedParameters();
+
+  Fragment check_args;
+
+  ASSERT(throw_no_such_method_ == nullptr);
+  throw_no_such_method_ = B->BuildThrowNoSuchMethod();
+
+  check_args += B->LoadArgDescriptor();
+  check_args += B->LoadField(ArgumentsDescriptor::positional_count_offset());
+  check_args += B->IntConstant(num_fixed_params);
+  TargetEntryInstr *success1, *fail1;
+  check_args += B->BranchIfEqual(&success1, &fail1);
+  check_args = Fragment(check_args.entry, success1);
+
+  check_args += B->LoadArgDescriptor();
+  check_args += B->LoadField(ArgumentsDescriptor::count_offset());
+  check_args += B->IntConstant(num_fixed_params);
+  TargetEntryInstr *success2, *fail2;
+  check_args += B->BranchIfEqual(&success2, &fail2);
+  check_args = Fragment(check_args.entry, success2);
+
+  Fragment(fail1) + B->Goto(throw_no_such_method_);
+  Fragment(fail2) + B->Goto(throw_no_such_method_);
+
+  ASSERT(B->stack_ == nullptr);
+
+  if (!B->IsInlining() && !B->IsCompiledForOsr()) {
+    code_ += check_args;
+  }
+}
+
+void BytecodeFlowGraphBuilder::BuildEntryOptional() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  const intptr_t num_fixed_params = DecodeOperandA().value();
+  const intptr_t num_opt_pos_params = DecodeOperandB().value();
+  const intptr_t num_opt_named_params = DecodeOperandC().value();
+  ASSERT(num_fixed_params == function().num_fixed_parameters());
+  ASSERT(num_opt_pos_params == function().NumOptionalPositionalParameters());
+  ASSERT(num_opt_named_params == function().NumOptionalNamedParameters());
+
+  ASSERT((num_opt_pos_params == 0) || (num_opt_named_params == 0));
+  const intptr_t num_load_const = num_opt_pos_params + 2 * num_opt_named_params;
+
+  const KBCInstr frame_instr =
+      InstructionAt(pc_ + 1 + num_load_const, KernelBytecode::kFrame);
+  const intptr_t num_temps = (num_opt_named_params > 0) ? 1 : 0;
+  const intptr_t num_extra_locals =
+      KernelBytecode::DecodeD(frame_instr) + num_temps;
+  const intptr_t num_params =
+      num_fixed_params + num_opt_pos_params + num_opt_named_params;
+  const intptr_t total_locals = num_params + num_extra_locals;
+
+  AllocateLocalVariables(Operand(total_locals), num_params);
+
+  ZoneGrowableArray<const Instance*>* default_values =
+      new (Z) ZoneGrowableArray<const Instance*>(
+          Z, num_opt_pos_params + num_opt_named_params);
+  ZoneGrowableArray<LocalVariable*>* raw_parameters =
+      new (Z) ZoneGrowableArray<LocalVariable*>(Z, num_params);
+  LocalVariable* temp_var = nullptr;
+
+  intptr_t param = 0;
+  for (; param < num_fixed_params; ++param) {
+    LocalVariable* param_var = AllocateParameter(param, VariableIndex(-param));
+    raw_parameters->Add(param_var);
+  }
+
+  for (intptr_t i = 0; i < num_opt_pos_params; ++i, ++param) {
+    const KBCInstr load_value_instr =
+        InstructionAt(pc_ + 1 + i, KernelBytecode::kLoadConstant);
+    const Object& default_value =
+        ConstantAt(Operand(KernelBytecode::DecodeD(load_value_instr))).value();
+    ASSERT(KernelBytecode::DecodeA(load_value_instr) == param);
+
+    LocalVariable* param_var = AllocateParameter(param, VariableIndex(-param));
+    raw_parameters->Add(param_var);
+    default_values->Add(
+        &Instance::ZoneHandle(Z, Instance::RawCast(default_value.raw())));
+  }
+
+  if (num_opt_named_params > 0) {
+    default_values->EnsureLength(num_opt_named_params, nullptr);
+    raw_parameters->EnsureLength(num_params, nullptr);
+    temp_var = LocalVariableAt(total_locals - 1);
+
+    for (intptr_t i = 0; i < num_opt_named_params; ++i, ++param) {
+      const KBCInstr load_name_instr =
+          InstructionAt(pc_ + 1 + i * 2, KernelBytecode::kLoadConstant);
+      const KBCInstr load_value_instr =
+          InstructionAt(pc_ + 1 + i * 2 + 1, KernelBytecode::kLoadConstant);
+      const String& param_name = String::Cast(
+          ConstantAt(Operand(KernelBytecode::DecodeD(load_name_instr)))
+              .value());
+      ASSERT(param_name.IsSymbol());
+      const Object& default_value =
+          ConstantAt(Operand(KernelBytecode::DecodeD(load_value_instr)))
+              .value();
+
+      intptr_t param_index = num_fixed_params;
+      for (; param_index < num_params; ++param_index) {
+        if (function().ParameterNameAt(param_index) == param_name.raw()) {
+          break;
+        }
+      }
+      ASSERT(param_index < num_params);
+
+      ASSERT(default_values->At(param_index - num_fixed_params) == nullptr);
+      (*default_values)[param_index - num_fixed_params] =
+          &Instance::ZoneHandle(Z, Instance::RawCast(default_value.raw()));
+
+      const intptr_t local_index = KernelBytecode::DecodeA(load_name_instr);
+      ASSERT(local_index == KernelBytecode::DecodeA(load_value_instr));
+
+      LocalVariable* param_var =
+          AllocateParameter(param_index, VariableIndex(-param));
+      ASSERT(raw_parameters->At(param_index) == nullptr);
+      (*raw_parameters)[param_index] = param_var;
+    }
+  }
+
+  parsed_function()->set_default_parameter_values(default_values);
+  parsed_function()->SetRawParameters(raw_parameters);
+
+  Fragment copy_args_prologue;
+
+  // Code generated for EntryOptional is considered a prologue code.
+  // Prologue should span a range of block ids, so start a new block at the
+  // beginning and end a block at the end.
+  JoinEntryInstr* prologue_entry = B->BuildJoinEntry();
+  copy_args_prologue += B->Goto(prologue_entry);
+  copy_args_prologue = Fragment(copy_args_prologue.entry, prologue_entry);
+
+  ASSERT(throw_no_such_method_ == nullptr);
+  throw_no_such_method_ = B->BuildThrowNoSuchMethod();
+
+  PrologueBuilder prologue_builder(parsed_function(), B->last_used_block_id_,
+                                   B->IsCompiledForOsr(), B->IsInlining());
+
+  B->last_used_block_id_ = prologue_builder.last_used_block_id();
+
+  copy_args_prologue += prologue_builder.BuildOptionalParameterHandling(
+      throw_no_such_method_, temp_var);
+
+  JoinEntryInstr* prologue_exit = B->BuildJoinEntry();
+  copy_args_prologue += B->Goto(prologue_exit);
+  copy_args_prologue.current = prologue_exit;
+
+  if (!B->IsInlining() && !B->IsCompiledForOsr()) {
+    code_ += copy_args_prologue;
+  }
+
+  prologue_info_ =
+      PrologueInfo(prologue_entry->block_id(), prologue_exit->block_id() - 1);
+
+  // Skip LoadConstant and Frame instructions.
+  pc_ += num_load_const + 1;
+
+  ASSERT(B->stack_ == nullptr);
+}
+
+void BytecodeFlowGraphBuilder::BuildLoadConstant() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  // Handled in EntryOptional instruction.
+  UNREACHABLE();
+}
+
+void BytecodeFlowGraphBuilder::BuildFrame() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  // Handled in EntryOptional instruction.
+  UNREACHABLE();
+}
+
+void BytecodeFlowGraphBuilder::BuildCheckFunctionTypeArgs() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  const intptr_t expected_num_type_args = DecodeOperandA().value();
+  LocalVariable* type_args_var = LocalVariableAt(DecodeOperandD().value());
+  ASSERT(function().IsGeneric());
+
+  if (throw_no_such_method_ == nullptr) {
+    throw_no_such_method_ = B->BuildThrowNoSuchMethod();
+  }
+
+  Fragment setup_type_args;
+  JoinEntryInstr* done = B->BuildJoinEntry();
+
+  // Type args are always optional, so length can always be zero.
+  // If expect_type_args, a non-zero length must match the declaration length.
+  TargetEntryInstr *then, *fail;
+  setup_type_args += B->LoadArgDescriptor();
+  setup_type_args += B->LoadNativeField(NativeFieldDesc::Get(
+      NativeFieldDesc::kArgumentsDescriptor_type_args_len));
+
+  if (expected_num_type_args != 0) {
+    JoinEntryInstr* join2 = B->BuildJoinEntry();
+
+    LocalVariable* len = B->MakeTemporary();
+
+    TargetEntryInstr* otherwise;
+    setup_type_args += B->LoadLocal(len);
+    setup_type_args += B->IntConstant(0);
+    setup_type_args += B->BranchIfEqual(&then, &otherwise);
+
+    TargetEntryInstr* then2;
+    Fragment check_len(otherwise);
+    check_len += B->LoadLocal(len);
+    check_len += B->IntConstant(expected_num_type_args);
+    check_len += B->BranchIfEqual(&then2, &fail);
+
+    Fragment null_type_args(then);
+    null_type_args += B->NullConstant();
+    null_type_args += B->StoreLocalRaw(TokenPosition::kNoSource, type_args_var);
+    null_type_args += B->Drop();
+    null_type_args += B->Goto(join2);
+
+    Fragment store_type_args(then2);
+    store_type_args += B->LoadArgDescriptor();
+    store_type_args += B->LoadField(ArgumentsDescriptor::count_offset());
+    store_type_args += B->LoadFpRelativeSlot(
+        kWordSize * (1 + compiler_frame_layout.param_end_from_fp));
+    store_type_args +=
+        B->StoreLocalRaw(TokenPosition::kNoSource, type_args_var);
+    store_type_args += B->Drop();
+    store_type_args += B->Goto(join2);
+
+    Fragment(join2) + B->Drop() + B->Goto(done);
+    Fragment(fail) + B->Goto(throw_no_such_method_);
+  } else {
+    setup_type_args += B->IntConstant(0);
+    setup_type_args += B->BranchIfEqual(&then, &fail);
+    Fragment(then) + B->Goto(done);
+    Fragment(fail) + B->Goto(throw_no_such_method_);
+  }
+
+  setup_type_args = Fragment(setup_type_args.entry, done);
+  ASSERT(B->stack_ == nullptr);
+
+  if (expected_num_type_args != 0) {
+    parsed_function()->set_function_type_arguments(type_args_var);
+    parsed_function()->SetRawTypeArgumentsVariable(type_args_var);
+  }
+
+  if (!B->IsInlining() && !B->IsCompiledForOsr()) {
+    code_ += setup_type_args;
+  }
+}
+
+void BytecodeFlowGraphBuilder::BuildCheckStack() {
+  // TODO(alexmarkov): update B->loop_depth_
+  code_ += B->CheckStackOverflow(position_);
+  ASSERT(B->stack_ == nullptr);
+}
+
+void BytecodeFlowGraphBuilder::BuildPushConstant() {
+  PushConstant(ConstantAt(DecodeOperandD()));
+}
+
+void BytecodeFlowGraphBuilder::BuildStoreLocal() {
+  LoadStackSlots(1);
+  const Operand local_index = DecodeOperandX();
+  StoreLocal(local_index);
+}
+
+void BytecodeFlowGraphBuilder::BuildPopLocal() {
+  BuildStoreLocal();
+  code_ += B->Drop();
+}
+
+void BytecodeFlowGraphBuilder::BuildPush() {
+  const Operand local_index = DecodeOperandX();
+  LoadLocal(local_index);
+}
+
+void BytecodeFlowGraphBuilder::BuildIndirectStaticCall() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  const ICData& icdata = ICData::Cast(PopConstant().value());
+
+  const Function& target = Function::ZoneHandle(Z, icdata.GetTargetAt(0));
+  const ArgumentsDescriptor arg_desc(
+      Array::Cast(ConstantAt(DecodeOperandD()).value()));
+  intptr_t argc = DecodeOperandA().value();
+  ASSERT(ic_data_array_->At(icdata.deopt_id())->Original() == icdata.raw());
+
+  ArgumentArray arguments = GetArguments(argc);
+
+  // TODO(alexmarkov): pass ICData::kSuper for super calls
+  // (need to distinguish them in bytecode).
+  StaticCallInstr* call = new (Z) StaticCallInstr(
+      position_, target, arg_desc.TypeArgsLen(),
+      Array::ZoneHandle(Z, arg_desc.GetArgumentNames()), arguments,
+      *ic_data_array_, icdata.deopt_id(), ICData::kStatic);
+
+  // TODO(alexmarkov): add type info
+  // SetResultTypeForStaticCall(call, target, argument_count, result_type);
+
+  code_ <<= call;
+  B->Push(call);
+}
+
+void BytecodeFlowGraphBuilder::BuildInstanceCall() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  const ICData& icdata = ICData::Cast(ConstantAt(DecodeOperandD()).value());
+  ASSERT(ic_data_array_->At(icdata.deopt_id())->Original() == icdata.raw());
+
+  const intptr_t argc = DecodeOperandA().value();
+  const ArgumentsDescriptor arg_desc(
+      Array::Handle(Z, icdata.arguments_descriptor()));
+
+  const String& name = String::ZoneHandle(Z, icdata.target_name());
+  const Token::Kind token_kind =
+      MethodTokenRecognizer::RecognizeTokenKind(name);
+
+  const ArgumentArray arguments = GetArguments(argc);
+
+  // TODO(alexmarkov): store interface_target in bytecode and pass it here.
+
+  InstanceCallInstr* call = new (Z) InstanceCallInstr(
+      position_, name, token_kind, arguments, arg_desc.TypeArgsLen(),
+      Array::ZoneHandle(Z, arg_desc.GetArgumentNames()), icdata.NumArgsTested(),
+      *ic_data_array_, icdata.deopt_id());
+
+  ASSERT(call->ic_data() != nullptr);
+  ASSERT(call->ic_data()->Original() == icdata.raw());
+
+  // TODO(alexmarkov): add type info - call->SetResultType()
+
+  code_ <<= call;
+  B->Push(call);
+}
+
+void BytecodeFlowGraphBuilder::BuildNativeCall() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  // Default flow graph builder is used to compile native methods.
+  UNREACHABLE();
+}
+
+void BytecodeFlowGraphBuilder::BuildAllocate() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  const Class& klass = Class::Cast(ConstantAt(DecodeOperandD()).value());
+
+  const ArgumentArray arguments =
+      new (Z) ZoneGrowableArray<PushArgumentInstr*>(Z, 0);
+
+  AllocateObjectInstr* allocate =
+      new (Z) AllocateObjectInstr(position_, klass, arguments);
+
+  code_ <<= allocate;
+  B->Push(allocate);
+}
+
+void BytecodeFlowGraphBuilder::BuildAllocateT() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  const Class& klass = Class::Cast(PopConstant().value());
+  const ArgumentArray arguments = GetArguments(1);
+
+  AllocateObjectInstr* allocate =
+      new (Z) AllocateObjectInstr(position_, klass, arguments);
+
+  code_ <<= allocate;
+  B->Push(allocate);
+}
+
+void BytecodeFlowGraphBuilder::BuildAllocateContext() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  code_ += B->AllocateContext(DecodeOperandD().value());
+}
+
+void BytecodeFlowGraphBuilder::BuildCloneContext() {
+  LoadStackSlots(1);
+  // TODO(alexmarkov): Pass context_size and use it in compiled mode.
+  CloneContextInstr* clone_instruction = new (Z) CloneContextInstr(
+      TokenPosition::kNoSource, Pop(), CloneContextInstr::kUnknownContextSize,
+      B->GetNextDeoptId());
+  code_ <<= clone_instruction;
+  B->Push(clone_instruction);
+}
+
+void BytecodeFlowGraphBuilder::BuildCreateArrayTOS() {
+  LoadStackSlots(2);
+  code_ += B->CreateArray();
+}
+
+void BytecodeFlowGraphBuilder::BuildStoreFieldTOS() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  LoadStackSlots(2);
+  Operand cp_index = DecodeOperandD();
+
+  const Field& field = Field::Cast(ConstantAt(cp_index, 1).value());
+  ASSERT(Smi::Cast(ConstantAt(cp_index).value()).Value() * kWordSize ==
+         field.Offset());
+
+  if (field.Owner() == isolate()->object_store()->closure_class()) {
+    // Stores to _Closure fields are lower-level.
+    // TODO(alexmarkov): use NativeFieldDesc
+    code_ += B->StoreInstanceField(position_, field.Offset());
+  } else {
+    // The rest of the StoreFieldTOS are for field initializers.
+    // TODO(alexmarkov): Consider adding a flag to StoreFieldTOS or even
+    // adding a separate bytecode instruction.
+    code_ += B->StoreInstanceFieldGuarded(field,
+                                          /* is_initialization_store = */ true);
+  }
+}
+
+void BytecodeFlowGraphBuilder::BuildLoadFieldTOS() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  LoadStackSlots(1);
+  Operand cp_index = DecodeOperandD();
+
+  const Field& field = Field::Cast(ConstantAt(cp_index, 1).value());
+  ASSERT(Smi::Cast(ConstantAt(cp_index).value()).Value() * kWordSize ==
+         field.Offset());
+
+  if (field.Owner() == isolate()->object_store()->closure_class()) {
+    // Loads from _Closure fields are lower-level.
+    // TODO(alexmarkov): use NativeFieldDesc
+    code_ += B->LoadField(field.Offset());
+  } else {
+    code_ += B->LoadField(field);
+  }
+}
+
+void BytecodeFlowGraphBuilder::BuildStoreContextParent() {
+  LoadStackSlots(2);
+
+  // TODO(alexmarkov): use NativeFieldDesc
+  code_ += B->StoreInstanceField(position_, Context::parent_offset());
+}
+
+void BytecodeFlowGraphBuilder::BuildLoadContextParent() {
+  LoadStackSlots(1);
+
+  // TODO(alexmarkov): use NativeFieldDesc
+  code_ += B->LoadField(Context::parent_offset());
+}
+
+void BytecodeFlowGraphBuilder::BuildStoreContextVar() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  LoadStackSlots(2);
+  Operand var_index = DecodeOperandD();
+
+  // TODO(alexmarkov): use NativeFieldDesc
+  code_ += B->StoreInstanceField(position_,
+                                 Context::variable_offset(var_index.value()));
+}
+
+void BytecodeFlowGraphBuilder::BuildLoadContextVar() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  LoadStackSlots(1);
+  Operand var_index = DecodeOperandD();
+
+  // TODO(alexmarkov): use NativeFieldDesc
+  code_ += B->LoadField(Context::variable_offset(var_index.value()));
+}
+
+void BytecodeFlowGraphBuilder::BuildLoadTypeArgumentsField() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  LoadStackSlots(1);
+  const intptr_t offset =
+      Smi::Cast(ConstantAt(DecodeOperandD()).value()).Value() * kWordSize;
+
+  code_ +=
+      B->LoadNativeField(NativeFieldDesc::GetTypeArgumentsField(Z, offset));
+}
+
+void BytecodeFlowGraphBuilder::BuildStoreStaticTOS() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  LoadStackSlots(1);
+  Operand cp_index = DecodeOperandD();
+
+  const Field& field = Field::Cast(ConstantAt(cp_index).value());
+
+  code_ += B->StoreStaticField(position_, field);
+}
+
+void BytecodeFlowGraphBuilder::BuildPushStatic() {
+  // Note: Field object is both pushed into the stack and
+  // available in constant pool entry D.
+  // TODO(alexmarkov): clean this up. If we stop pushing field object
+  // explicitly, we might need the following code to get it from constant
+  // pool: PushConstant(ConstantAt(DecodeOperandD()));
+
+  code_ += B->LoadStaticField();
+}
+
+void BytecodeFlowGraphBuilder::BuildStoreIndexedTOS() {
+  LoadStackSlots(3);
+  code_ += B->StoreIndexed(kArrayCid);
+  code_ += B->Drop();
+}
+
+void BytecodeFlowGraphBuilder::BuildBooleanNegateTOS() {
+  LoadStackSlots(1);
+  code_ += B->BooleanNegate();
+}
+
+void BytecodeFlowGraphBuilder::BuildInstantiateType() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  const AbstractType& type =
+      AbstractType::Cast(ConstantAt(DecodeOperandD()).value());
+
+  LoadStackSlots(2);
+  code_ += B->InstantiateType(type);
+}
+
+void BytecodeFlowGraphBuilder::BuildInstantiateTypeArgumentsTOS() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  const TypeArguments& type_args =
+      TypeArguments::Cast(ConstantAt(DecodeOperandD()).value());
+
+  LoadStackSlots(2);
+  code_ += B->InstantiateTypeArguments(type_args);
+}
+
+void BytecodeFlowGraphBuilder::BuildAssertBoolean() {
+  LoadStackSlots(1);
+  code_ += B->AssertBool(position_);
+}
+
+void BytecodeFlowGraphBuilder::BuildAssertAssignable() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  LoadStackSlots(5);
+
+  const String& dst_name = String::Cast(PopConstant().value());
+  const AbstractType& dst_type = AbstractType::Cast(PopConstant().value());
+
+  Value* function_type_args = Pop();
+  Value* instantiator_type_args = Pop();
+  Value* value = Pop();
+
+  AssertAssignableInstr* instr = new (Z) AssertAssignableInstr(
+      position_, value, instantiator_type_args, function_type_args, dst_type,
+      dst_name, B->GetNextDeoptId());
+
+  code_ <<= instr;
+
+  B->Push(instr);
+}
+
+void BytecodeFlowGraphBuilder::BuildAssertSubtype() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  LoadStackSlots(5);
+
+  const String& dst_name = String::Cast(PopConstant().value());
+  const AbstractType& super_type = AbstractType::Cast(PopConstant().value());
+  const AbstractType& sub_type = AbstractType::Cast(PopConstant().value());
+  Value* function_type_args = Pop();
+  Value* instantiator_type_args = Pop();
+
+  AssertSubtypeInstr* instr = new (Z)
+      AssertSubtypeInstr(position_, instantiator_type_args, function_type_args,
+                         sub_type, super_type, dst_name, B->GetNextDeoptId());
+  code_ <<= instr;
+}
+
+void BytecodeFlowGraphBuilder::BuildJump() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  const intptr_t target_pc = pc_ + DecodeOperandT().value();
+  JoinEntryInstr* join = jump_targets_.Lookup(target_pc);
+  ASSERT(join != nullptr);
+  code_ += B->Goto(join);
+  PropagateStackState(target_pc);
+  B->stack_ = nullptr;
+}
+
+void BytecodeFlowGraphBuilder::BuildJumpIfNoAsserts() {
+  if (!isolate()->asserts()) {
+    BuildJump();
+  }
+}
+
+void BytecodeFlowGraphBuilder::BuildJumpIfNotZeroTypeArgs() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  TargetEntryInstr *is_zero, *is_not_zero;
+  code_ += B->LoadArgDescriptor();
+  code_ += B->LoadNativeField(NativeFieldDesc::Get(
+      NativeFieldDesc::kArgumentsDescriptor_type_args_len));
+  code_ += B->IntConstant(0);
+  code_ += B->BranchIfEqual(&is_zero, &is_not_zero);
+
+  const intptr_t target_pc = pc_ + DecodeOperandT().value();
+  JoinEntryInstr* join = jump_targets_.Lookup(target_pc);
+  ASSERT(join != nullptr);
+  Fragment(is_not_zero) += B->Goto(join);
+  PropagateStackState(target_pc);
+
+  code_ = Fragment(code_.entry, is_zero);
+}
+
+void BytecodeFlowGraphBuilder::BuildIfStrictCompare(Token::Kind cmp_kind) {
+  ASSERT((cmp_kind == Token::kEQ) || (cmp_kind == Token::kNE));
+
+  // TODO(alexmarkov): revise If* bytecodes to include Jump
+  // (and maybe comparison to true/false)
+
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  LoadStackSlots(2);
+
+  TargetEntryInstr* eq_branch = nullptr;
+  TargetEntryInstr* ne_branch = nullptr;
+  code_ += B->BranchIfStrictEqual(&eq_branch, &ne_branch);
+
+  TargetEntryInstr* then_entry =
+      (cmp_kind == Token::kEQ) ? eq_branch : ne_branch;
+  TargetEntryInstr* else_entry =
+      (cmp_kind == Token::kEQ) ? ne_branch : eq_branch;
+
+  // The next bytecode instruction should be a Jump.
+  ++pc_;
+  bytecode_instr_ = InstructionAt(pc_, KernelBytecode::kJump);
+  ASSERT(jump_targets_.Lookup(pc_) == nullptr);
+
+  const intptr_t target_pc = pc_ + DecodeOperandT().value();
+  JoinEntryInstr* join = jump_targets_.Lookup(target_pc);
+  ASSERT(join != nullptr);
+
+  code_ = Fragment(then_entry);
+  code_ += B->Goto(join);
+  PropagateStackState(target_pc);
+
+  code_ = Fragment(else_entry);
+}
+
+void BytecodeFlowGraphBuilder::BuildIfEqStrictTOS() {
+  BuildIfStrictCompare(Token::kEQ);
+}
+
+void BytecodeFlowGraphBuilder::BuildIfNeStrictTOS() {
+  BuildIfStrictCompare(Token::kNE);
+}
+
+void BytecodeFlowGraphBuilder::BuildIfEqNull() {
+  LoadLocal(DecodeOperandA());
+  code_ += B->NullConstant();
+  BuildIfEqStrictTOS();
+}
+
+void BytecodeFlowGraphBuilder::BuildDrop1() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+    // AdjustSP(-1);
+  } else {
+    code_ += B->Drop();
+  }
+}
+
+void BytecodeFlowGraphBuilder::BuildReturnTOS() {
+  LoadStackSlots(1);
+  ASSERT(code_.is_open());
+  code_ += B->Return(position_);
+}
+
+void BytecodeFlowGraphBuilder::BuildTrap() {
+  code_ += Fragment(new (Z) StopInstr("Bytecode Trap instruction")).closed();
+}
+
+void BytecodeFlowGraphBuilder::BuildThrow() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  if (DecodeOperandA().value() == 0) {
+    // throw
+    LoadStackSlots(1);
+    code_ += B->PushArgument();
+    code_ += B->ThrowException(position_);
+  } else {
+    // rethrow
+    LoadStackSlots(2);
+    GetArguments(2);
+    code_ += Fragment(new (Z) ReThrowInstr(position_,
+                                           CatchClauseNode::kInvalidTryIndex,
+                                           B->GetNextDeoptId()))
+                 .closed();
+  }
+
+  ASSERT(code_.is_closed());
+
+  // Empty stack as closed fragment should not leave any values on the stack.
+  while (B->stack_ != nullptr) {
+    B->Pop();
+  }
+}
+
+void BytecodeFlowGraphBuilder::BuildMoveSpecial() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  LocalVariable* special_var = nullptr;
+  switch (DecodeOperandD().value()) {
+    // TODO(alexmarkov): Move these constants to constants_kbc.h
+    case KernelBytecode::kExceptionSpecialIndex:
+      ASSERT(exception_var_ != nullptr);
+      special_var = exception_var_;
+      break;
+    case KernelBytecode::kStackTraceSpecialIndex:
+      ASSERT(stacktrace_var_ != nullptr);
+      special_var = stacktrace_var_;
+      break;
+    default:
+      UNREACHABLE();
+  }
+
+  code_ += B->LoadLocal(special_var);
+  StoreLocal(DecodeOperandA());
+  code_ += B->Drop();
+}
+
+void BytecodeFlowGraphBuilder::BuildSetFrame() {
+  if (is_generating_interpreter()) {
+    UNIMPLEMENTED();  // TODO(alexmarkov): interpreter
+  }
+
+  // No-op in compiled code.
+  ASSERT(B->stack_ == nullptr);
+}
+
+static bool IsICDataEntry(const ObjectPool& object_pool, intptr_t index) {
+  if (object_pool.TypeAt(index) != ObjectPool::kTaggedObject) {
+    return false;
+  }
+  RawObject* entry = object_pool.ObjectAt(index);
+  return entry->IsHeapObject() && entry->IsICData();
+}
+
+// Read ICData entries in object pool, skip deopt_ids and
+// pre-populate ic_data_array_.
+void BytecodeFlowGraphBuilder::ProcessICDataInObjectPool(
+    const ObjectPool& object_pool) {
+  CompilerState& compiler_state = thread()->compiler_state();
+  ASSERT(compiler_state.deopt_id() == 0);
+
+  const intptr_t pool_length = object_pool.Length();
+  for (intptr_t i = 0; i < pool_length; ++i) {
+    if (IsICDataEntry(object_pool, i)) {
+      const ICData& icdata = ICData::CheckedHandle(Z, object_pool.ObjectAt(i));
+      const intptr_t deopt_id = compiler_state.GetNextDeoptId();
+
+      ASSERT(icdata.deopt_id() == deopt_id);
+      ASSERT(ic_data_array_->is_empty() ||
+             (ic_data_array_->At(deopt_id)->Original() == icdata.raw()));
+    }
+  }
+
+  if (ic_data_array_->is_empty()) {
+    const intptr_t len = compiler_state.deopt_id();
+    ic_data_array_->EnsureLength(len, nullptr);
+    for (intptr_t i = 0; i < pool_length; ++i) {
+      if (IsICDataEntry(object_pool, i)) {
+        const ICData& icdata =
+            ICData::CheckedHandle(Z, object_pool.ObjectAt(i));
+        (*ic_data_array_)[icdata.deopt_id()] = &icdata;
+      }
+    }
+  }
+}
+
+intptr_t BytecodeFlowGraphBuilder::GetTryIndex(const PcDescriptors& descriptors,
+                                               intptr_t pc) {
+  const uword pc_offset =
+      KernelBytecode::BytecodePcToOffset(pc, /* is_return_address = */ true);
+  PcDescriptors::Iterator iter(descriptors, RawPcDescriptors::kAnyKind);
+  intptr_t try_index = CatchClauseNode::kInvalidTryIndex;
+  while (iter.MoveNext()) {
+    const intptr_t current_try_index = iter.TryIndex();
+    const uword start_pc = iter.PcOffset();
+    if (pc_offset < start_pc) {
+      break;
+    }
+    const bool has_next = iter.MoveNext();
+    ASSERT(has_next);
+    const uword end_pc = iter.PcOffset();
+    if (start_pc <= pc_offset && pc_offset < end_pc) {
+      ASSERT(try_index < current_try_index);
+      try_index = current_try_index;
+    }
+  }
+  return try_index;
+}
+
+JoinEntryInstr* BytecodeFlowGraphBuilder::EnsureControlFlowJoin(
+    const PcDescriptors& descriptors,
+    intptr_t pc) {
+  ASSERT((0 <= pc) && (pc < bytecode_length_));
+  JoinEntryInstr* join = jump_targets_.Lookup(pc);
+  if (join == nullptr) {
+    join = B->BuildJoinEntry(GetTryIndex(descriptors, pc));
+    jump_targets_.Insert(pc, join);
+  }
+  return join;
+}
+
+void BytecodeFlowGraphBuilder::CollectControlFlow(
+    const PcDescriptors& descriptors,
+    const ExceptionHandlers& handlers,
+    GraphEntryInstr* graph_entry) {
+  for (intptr_t pc = 0; pc < bytecode_length_; ++pc) {
+    const KBCInstr instr = raw_bytecode_[pc];
+    const KernelBytecode::Opcode opcode = KernelBytecode::DecodeOpcode(instr);
+
+    if ((opcode == KernelBytecode::kJump) ||
+        (opcode == KernelBytecode::kJumpIfNoAsserts) ||
+        (opcode == KernelBytecode::kJumpIfNotZeroTypeArgs)) {
+      const intptr_t target = pc + KernelBytecode::DecodeT(instr);
+      EnsureControlFlowJoin(descriptors, target);
+    }
+  }
+
+  PcDescriptors::Iterator iter(descriptors, RawPcDescriptors::kAnyKind);
+  while (iter.MoveNext()) {
+    const intptr_t start_pc = KernelBytecode::OffsetToBytecodePc(
+        iter.PcOffset(), /* is_return_address = */ true);
+    EnsureControlFlowJoin(descriptors, start_pc);
+
+    const bool has_next = iter.MoveNext();
+    ASSERT(has_next);
+    const intptr_t end_pc = KernelBytecode::OffsetToBytecodePc(
+        iter.PcOffset(), /* is_return_address = */ true);
+    EnsureControlFlowJoin(descriptors, end_pc);
+  }
+
+  if (handlers.num_entries() > 0) {
+    B->InlineBailout("kernel::BytecodeFlowGraphBuilder::CollectControlFlow");
+
+    exception_var_ = new (Z)
+        LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                      Symbols::ExceptionVar(), Object::dynamic_type());
+    stacktrace_var_ = new (Z)
+        LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+                      Symbols::StackTraceVar(), Object::dynamic_type());
+  }
+
+  for (intptr_t try_index = 0; try_index < handlers.num_entries();
+       ++try_index) {
+    ExceptionHandlerInfo handler_info;
+    handlers.GetHandlerInfo(try_index, &handler_info);
+
+    const intptr_t handler_pc = KernelBytecode::OffsetToBytecodePc(
+        handler_info.handler_pc_offset, /* is_return_address = */ false);
+    JoinEntryInstr* join = EnsureControlFlowJoin(descriptors, handler_pc);
+
+    const Array& handler_types =
+        Array::ZoneHandle(Z, handlers.GetHandledTypes(try_index));
+
+    CatchBlockEntryInstr* entry = new (Z) CatchBlockEntryInstr(
+        TokenPosition::kNoSource, handler_info.is_generated,
+        B->AllocateBlockId(), handler_info.outer_try_index, graph_entry,
+        handler_types, try_index, handler_info.needs_stacktrace,
+        B->GetNextDeoptId(), nullptr, nullptr, exception_var_, stacktrace_var_);
+    graph_entry->AddCatchEntry(entry);
+
+    code_ = Fragment(entry);
+    code_ += B->Goto(join);
+  }
+}
+
+FlowGraph* BytecodeFlowGraphBuilder::BuildGraph() {
+  if (function().is_native()) {
+    // Use default flow graph builder for native methods.
+    return nullptr;
+  }
+
+  const Code& bytecode = Code::Handle(Z, function().Bytecode());
+
+  object_pool_ = bytecode.object_pool();
+  raw_bytecode_ = reinterpret_cast<KBCInstr*>(bytecode.EntryPoint());
+  bytecode_length_ = bytecode.Size() / sizeof(KBCInstr);
+
+  ProcessICDataInObjectPool(object_pool_);
+
+  TargetEntryInstr* normal_entry = B->BuildTargetEntry();
+  GraphEntryInstr* graph_entry =
+      new (Z) GraphEntryInstr(*parsed_function_, normal_entry, B->osr_id_);
+
+  const PcDescriptors& descriptors =
+      PcDescriptors::Handle(Z, bytecode.pc_descriptors());
+  const ExceptionHandlers& handlers =
+      ExceptionHandlers::Handle(Z, bytecode.exception_handlers());
+
+  CollectControlFlow(descriptors, handlers, graph_entry);
+
+  code_ = Fragment(normal_entry);
+
+  for (pc_ = 0; pc_ < bytecode_length_; ++pc_) {
+    bytecode_instr_ = raw_bytecode_[pc_];
+
+    JoinEntryInstr* join = jump_targets_.Lookup(pc_);
+    if (join != nullptr) {
+      Value* stack_state = stack_states_.Lookup(pc_);
+      if (code_.is_open()) {
+        ASSERT((stack_state == nullptr) || (stack_state == B->stack_));
+        code_ += B->Goto(join);
+      } else {
+        ASSERT(B->stack_ == nullptr);
+        B->stack_ = stack_state;
+      }
+      code_ = Fragment(join);
+      B->SetCurrentTryIndex(join->try_index());
+    } else if (code_.is_closed()) {
+      // Skip unreachable bytecode instructions.
+      continue;
+    }
+
+    BuildInstruction(KernelBytecode::DecodeOpcode(bytecode_instr_));
+
+    if (code_.is_closed()) {
+      ASSERT(B->stack_ == nullptr);
+    }
+  }
+
+  // When compiling for OSR, use a depth first search to find the OSR
+  // entry and make graph entry jump to it instead of normal entry.
+  // Catch entries are always considered reachable, even if they
+  // become unreachable after OSR.
+  if (B->IsCompiledForOsr()) {
+    graph_entry->RelinkToOsrEntry(Z, B->last_used_block_id_ + 1);
+  }
+
+  FlowGraph* flow_graph = new (Z) FlowGraph(
+      *parsed_function_, graph_entry, B->last_used_block_id_, prologue_info_);
+
+  if (FLAG_print_flow_graph_from_bytecode) {
+    FlowGraphPrinter::PrintGraph("Constructed from bytecode", flow_graph);
+  }
+
+  return flow_graph;
+}
+
+}  // namespace kernel
+}  // namespace dart
+
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
diff --git a/runtime/vm/compiler/frontend/bytecode_flow_graph_builder.h b/runtime/vm/compiler/frontend/bytecode_flow_graph_builder.h
new file mode 100644
index 0000000..9bf0b9c
--- /dev/null
+++ b/runtime/vm/compiler/frontend/bytecode_flow_graph_builder.h
@@ -0,0 +1,234 @@
+// Copyright (c) 2018, 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.
+
+#ifndef RUNTIME_VM_COMPILER_FRONTEND_BYTECODE_FLOW_GRAPH_BUILDER_H_
+#define RUNTIME_VM_COMPILER_FRONTEND_BYTECODE_FLOW_GRAPH_BUILDER_H_
+
+#include "vm/compiler/backend/il.h"
+#include "vm/compiler/frontend/base_flow_graph_builder.h"
+#include "vm/constants_kbc.h"
+
+#if !defined(DART_PRECOMPILED_RUNTIME)
+
+namespace dart {
+namespace kernel {
+
+#define FOR_EACH_BYTECODE_IN_FLOW_GRAPH_BUILDER(M)                             \
+  M(Allocate)                                                                  \
+  M(AllocateContext)                                                           \
+  M(AllocateT)                                                                 \
+  M(AssertAssignable)                                                          \
+  M(AssertBoolean)                                                             \
+  M(AssertSubtype)                                                             \
+  M(BooleanNegateTOS)                                                          \
+  M(CheckFunctionTypeArgs)                                                     \
+  M(CheckStack)                                                                \
+  M(CloneContext)                                                              \
+  M(CreateArrayTOS)                                                            \
+  M(Drop1)                                                                     \
+  M(Entry)                                                                     \
+  M(EntryFixed)                                                                \
+  M(EntryOptional)                                                             \
+  M(Frame)                                                                     \
+  M(IfEqNull)                                                                  \
+  M(IfEqStrictTOS)                                                             \
+  M(IfNeStrictTOS)                                                             \
+  M(IndirectStaticCall)                                                        \
+  M(InstanceCall)                                                              \
+  M(InstantiateType)                                                           \
+  M(InstantiateTypeArgumentsTOS)                                               \
+  M(Jump)                                                                      \
+  M(JumpIfNoAsserts)                                                           \
+  M(JumpIfNotZeroTypeArgs)                                                     \
+  M(LoadConstant)                                                              \
+  M(LoadContextParent)                                                         \
+  M(LoadContextVar)                                                            \
+  M(LoadFieldTOS)                                                              \
+  M(LoadTypeArgumentsField)                                                    \
+  M(MoveSpecial)                                                               \
+  M(NativeCall)                                                                \
+  M(PopLocal)                                                                  \
+  M(Push)                                                                      \
+  M(PushConstant)                                                              \
+  M(PushStatic)                                                                \
+  M(ReturnTOS)                                                                 \
+  M(SetFrame)                                                                  \
+  M(StoreContextParent)                                                        \
+  M(StoreContextVar)                                                           \
+  M(StoreFieldTOS)                                                             \
+  M(StoreIndexedTOS)                                                           \
+  M(StoreLocal)                                                                \
+  M(StoreStaticTOS)                                                            \
+  M(Throw)                                                                     \
+  M(Trap)
+
+// This class builds flow graph from bytecode. It is used either to compile
+// from bytecode, or generate bytecode interpreter (the latter is not
+// fully implemented yet).
+// TODO(alexmarkov): extend this class and IL to generate an interpreter in
+// addition to compiling bytecode.
+class BytecodeFlowGraphBuilder {
+ public:
+  BytecodeFlowGraphBuilder(BaseFlowGraphBuilder* flow_graph_builder,
+                           ParsedFunction* parsed_function,
+                           ZoneGrowableArray<const ICData*>* ic_data_array)
+      : flow_graph_builder_(flow_graph_builder),
+        zone_(flow_graph_builder->zone_),
+        is_generating_interpreter_(
+            false),  // TODO(alexmarkov): pass as argument
+        parsed_function_(parsed_function),
+        ic_data_array_(ic_data_array),
+        object_pool_(ObjectPool::Handle(zone_)),
+        raw_bytecode_(nullptr),
+        bytecode_length_(0),
+        pc_(0),
+        bytecode_instr_(KernelBytecode::kTrap),
+        position_(TokenPosition::kNoSource),
+        local_vars_(zone_, 0),
+        parameters_(zone_, 0),
+        exception_var_(nullptr),
+        stacktrace_var_(nullptr),
+        prologue_info_(-1, -1),
+        throw_no_such_method_(nullptr) {}
+
+  FlowGraph* BuildGraph();
+
+ protected:
+  // Returns `true` if building a flow graph for a bytecode interpreter, or
+  // `false` if compiling a function from bytecode.
+  bool is_generating_interpreter() const { return is_generating_interpreter_; }
+
+ private:
+  // Operand of bytecode instruction, either intptr_t value (if compiling
+  // bytecode) or Definition (if generating interpreter).
+  class Operand {
+   public:
+    explicit Operand(Definition* definition)
+        : definition_(definition), value_(0) {
+      ASSERT(definition != nullptr);
+    }
+
+    explicit Operand(intptr_t value) : definition_(nullptr), value_(value) {}
+
+    Definition* definition() const {
+      ASSERT(definition_ != nullptr);
+      return definition_;
+    }
+
+    intptr_t value() const {
+      ASSERT(definition_ == nullptr);
+      return value_;
+    }
+
+   private:
+    Definition* definition_;
+    intptr_t value_;
+  };
+
+  // Constant from a constant pool.
+  // It is either Object (if compiling bytecode) or Definition
+  // (if generating interpreter).
+  class Constant {
+   public:
+    explicit Constant(Definition* definition)
+        : definition_(definition), value_(Object::null_object()) {
+      ASSERT(definition != nullptr);
+    }
+
+    explicit Constant(Zone* zone, const Object& value)
+        : definition_(nullptr), value_(value) {}
+
+    Definition* definition() const {
+      ASSERT(definition_ != nullptr);
+      return definition_;
+    }
+
+    const Object& value() const {
+      ASSERT(definition_ == nullptr);
+      return value_;
+    }
+
+   private:
+    Definition* definition_;
+    const Object& value_;
+  };
+
+  Operand DecodeOperandA();
+  Operand DecodeOperandB();
+  Operand DecodeOperandC();
+  Operand DecodeOperandD();
+  Operand DecodeOperandX();
+  Operand DecodeOperandT();
+  KBCInstr InstructionAt(intptr_t pc, KernelBytecode::Opcode expect_opcode);
+  Constant ConstantAt(Operand entry_index, intptr_t add_index = 0);
+  void PushConstant(Constant constant);
+  Constant PopConstant();
+  void LoadStackSlots(intptr_t num_slots);
+  void AllocateLocalVariables(Operand frame_size,
+                              intptr_t num_param_locals = 0);
+  LocalVariable* AllocateParameter(intptr_t param_index,
+                                   VariableIndex var_index);
+  void AllocateFixedParameters();
+  LocalVariable* LocalVariableAt(intptr_t local_index);
+  void StoreLocal(Operand local_index);
+  void LoadLocal(Operand local_index);
+  Value* Pop();
+  ArgumentArray GetArguments(int count);
+  void PropagateStackState(intptr_t target_pc);
+  void BuildIfStrictCompare(Token::Kind cmp_kind);
+
+  void BuildInstruction(KernelBytecode::Opcode opcode);
+
+#define DECLARE_BUILD_METHOD(bytecode) void Build##bytecode();
+
+  FOR_EACH_BYTECODE_IN_FLOW_GRAPH_BUILDER(DECLARE_BUILD_METHOD)
+#undef DECLARE_BUILD_METHOD
+
+  void ProcessICDataInObjectPool(const ObjectPool& object_pool);
+  intptr_t GetTryIndex(const PcDescriptors& descriptors, intptr_t pc);
+  JoinEntryInstr* EnsureControlFlowJoin(const PcDescriptors& descriptors,
+                                        intptr_t pc);
+  void CollectControlFlow(const PcDescriptors& descriptors,
+                          const ExceptionHandlers& handlers,
+                          GraphEntryInstr* graph_entry);
+
+  Thread* thread() const { return flow_graph_builder_->thread_; }
+  Isolate* isolate() const { return thread()->isolate(); }
+
+  ParsedFunction* parsed_function() {
+    ASSERT(!is_generating_interpreter());
+    return parsed_function_;
+  }
+  const Function& function() { return parsed_function()->function(); }
+
+  BaseFlowGraphBuilder* flow_graph_builder_;
+  Zone* zone_;
+  bool is_generating_interpreter_;
+
+  // The following members are available only when compiling bytecode.
+
+  ParsedFunction* parsed_function_;
+  ZoneGrowableArray<const ICData*>* ic_data_array_;
+  ObjectPool& object_pool_;
+  KBCInstr* raw_bytecode_;
+  intptr_t bytecode_length_;
+  intptr_t pc_;
+  KBCInstr bytecode_instr_;
+  TokenPosition position_;  // TODO(alexmarkov): Set/update.
+  Fragment code_;
+  ZoneGrowableArray<LocalVariable*> local_vars_;
+  ZoneGrowableArray<LocalVariable*> parameters_;
+  LocalVariable* exception_var_;
+  LocalVariable* stacktrace_var_;
+  IntMap<JoinEntryInstr*> jump_targets_;
+  IntMap<Value*> stack_states_;
+  PrologueInfo prologue_info_;
+  JoinEntryInstr* throw_no_such_method_;
+};
+
+}  // namespace kernel
+}  // namespace dart
+
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
+#endif  // RUNTIME_VM_COMPILER_FRONTEND_BYTECODE_FLOW_GRAPH_BUILDER_H_
diff --git a/runtime/vm/compiler/frontend/bytecode_reader.cc b/runtime/vm/compiler/frontend/bytecode_reader.cc
index 75bf359..bac50ed 100644
--- a/runtime/vm/compiler/frontend/bytecode_reader.cc
+++ b/runtime/vm/compiler/frontend/bytecode_reader.cc
@@ -52,7 +52,16 @@
   const intptr_t obj_count = helper_->reader_.ReadListLength();
   const ObjectPool& pool =
       ObjectPool::Handle(helper_->zone_, ObjectPool::New(obj_count));
-  ReadPoolEntries(function, function, pool, 0);
+
+  {
+    // While reading pool entries, deopt_ids are allocated for
+    // ICData objects.
+    //
+    // TODO(alexmarkov): allocate deopt_ids for closures separately
+    DeoptIdScope deopt_id_scope(H.thread(), 0);
+
+    ReadPoolEntries(function, function, pool, 0);
+  }
 
   // Read bytecode and attach to function.
   const Code& bytecode = Code::Handle(helper_->zone_, ReadBytecode(pool));
@@ -164,14 +173,16 @@
         uint32_t low_bits = helper_->ReadUInt32();
         int64_t value = helper_->ReadUInt32();
         value = (value << 32) | low_bits;
-        obj = Integer::New(value);
+        obj = Integer::New(value, Heap::kOld);
+        obj = H.Canonicalize(Integer::Cast(obj));
       } break;
       case ConstantPoolTag::kDouble: {
         uint32_t low_bits = helper_->ReadUInt32();
         uint64_t bits = helper_->ReadUInt32();
         bits = (bits << 32) | low_bits;
         double value = bit_cast<double, uint64_t>(bits);
-        obj = Double::New(value);
+        obj = Double::New(value, Heap::kOld);
+        obj = H.Canonicalize(Double::Cast(obj));
       } break;
       case ConstantPoolTag::kBool:
         if (helper_->ReadUInt() == 1) {
@@ -229,10 +240,11 @@
             (name.raw() != Symbols::Call().raw())) {
           name = Function::CreateDynamicInvocationForwarderName(name);
         }
-        obj = ICData::New(function, name,
-                          array,  // Arguments descriptor.
-                          DeoptId::kNone, checked_argument_count,
-                          ICData::RebindRule::kInstance);
+        obj =
+            ICData::New(function, name,
+                        array,  // Arguments descriptor.
+                        H.thread()->compiler_state().GetNextDeoptId(),
+                        checked_argument_count, ICData::RebindRule::kInstance);
 #if defined(TAG_IC_DATA)
         ICData::Cast(obj).set_tag(ICData::Tag::kInstanceCall);
 #endif
@@ -275,8 +287,8 @@
         array ^= pool.ObjectAt(arg_desc_index);
         obj = ICData::New(function, name,
                           array,  // Arguments descriptor.
-                          DeoptId::kNone, num_args_checked,
-                          ICData::RebindRule::kStatic);
+                          H.thread()->compiler_state().GetNextDeoptId(),
+                          num_args_checked, ICData::RebindRule::kStatic);
         ICData::Cast(obj).AddTarget(Function::Cast(elem));
 #if defined(TAG_IC_DATA)
         ICData::Cast(obj).set_tag(ICData::Tag::kStaticCall);
diff --git a/runtime/vm/compiler/frontend/flow_graph_builder.cc b/runtime/vm/compiler/frontend/flow_graph_builder.cc
index 9336067..3e68c2e 100644
--- a/runtime/vm/compiler/frontend/flow_graph_builder.cc
+++ b/runtime/vm/compiler/frontend/flow_graph_builder.cc
@@ -4167,8 +4167,8 @@
       catch_block->token_pos(), (node->token_pos() == TokenPosition::kNoSource),
       owner()->AllocateBlockId(), catch_handler_index, owner()->graph_entry(),
       catch_block->handler_types(), try_handler_index,
-      catch_block->exception_var(), catch_block->stacktrace_var(),
       catch_block->needs_stacktrace(), owner()->GetNextDeoptId(),
+      &catch_block->exception_var(), &catch_block->stacktrace_var(),
       &catch_block->exception_var(), &catch_block->stacktrace_var());
   owner()->AddCatchEntry(catch_entry);
   AppendFragment(catch_entry, for_catch);
@@ -4214,8 +4214,8 @@
         true,  // this is not a catch block from user code.
         owner()->AllocateBlockId(), original_handler_index,
         owner()->graph_entry(), types, catch_handler_index,
-        catch_block->exception_var(), catch_block->stacktrace_var(),
         catch_block->needs_stacktrace(), owner()->GetNextDeoptId(),
+        &catch_block->exception_var(), &catch_block->stacktrace_var(),
         &catch_block->exception_var(), &catch_block->stacktrace_var());
     owner()->AddCatchEntry(finally_entry);
     AppendFragment(finally_entry, for_finally);
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
index a330ce7..4392efd 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
@@ -4,6 +4,7 @@
 
 #include "vm/compiler/frontend/kernel_binary_flowgraph.h"
 
+#include "vm/compiler/frontend/bytecode_flow_graph_builder.h"
 #include "vm/compiler/frontend/bytecode_reader.h"
 #include "vm/compiler/frontend/flow_graph_builder.h"  // For dart::FlowGraphBuilder::SimpleInstanceOfType.
 #include "vm/compiler/frontend/prologue_builder.h"
@@ -1242,7 +1243,7 @@
   // entry and make graph entry jump to it instead of normal entry.
   // Catch entries are always considered reachable, even if they
   // become unreachable after OSR.
-  if (flow_graph_builder_->osr_id_ != Compiler::kNoOSRDeoptId) {
+  if (flow_graph_builder_->IsCompiledForOsr()) {
     graph_entry->RelinkToOsrEntry(Z,
                                   flow_graph_builder_->last_used_block_id_ + 1);
   }
@@ -1877,7 +1878,7 @@
   // entry and make graph entry jump to it instead of normal entry.
   // Catch entries are always considered reachable, even if they
   // become unreachable after OSR.
-  if (flow_graph_builder_->osr_id_ != Compiler::kNoOSRDeoptId) {
+  if (flow_graph_builder_->IsCompiledForOsr()) {
     graph_entry->RelinkToOsrEntry(Z,
                                   flow_graph_builder_->last_used_block_id_ + 1);
   }
@@ -1906,9 +1907,7 @@
 
   SetOffset(kernel_offset);
 
-  // TODO(regis): Clean up this logic of when to compile.
-  // If the bytecode was previously loaded, we really want to compile.
-  if (FLAG_enable_interpreter && !function.HasBytecode()) {
+  if (FLAG_enable_interpreter || FLAG_use_bytecode_compiler) {
     // TODO(regis): For now, we skip bytecode loading for functions that were
     // synthesized and that do not have bytecode. Since they inherited the
     // kernel offset of a concrete function, the wrong bytecode would be loaded.
@@ -1921,10 +1920,29 @@
       case RawFunction::kDynamicInvocationForwarder:
       case RawFunction::kImplicitClosureFunction:
         break;
+      case RawFunction::kImplicitStaticFinalGetter:
+        if (!IsFieldInitializer(function, Z)) {
+          break;
+        }
+        // Fallthrough.
       default: {
-        bytecode_metadata_helper_.ReadMetadata(function);
+        // TODO(regis): Clean up this logic of when to compile.
+        // If the bytecode was previously loaded, we really want to compile.
+        if (!function.HasBytecode()) {
+          bytecode_metadata_helper_.ReadMetadata(function);
+        }
         if (function.HasBytecode()) {
-          return NULL;
+          if (FLAG_use_bytecode_compiler) {
+            BytecodeFlowGraphBuilder bytecode_compiler(
+                flow_graph_builder_, parsed_function(),
+                &(flow_graph_builder_->ic_data_array_));
+            FlowGraph* flow_graph = bytecode_compiler.BuildGraph();
+            if (flow_graph != nullptr) {
+              return flow_graph;
+            }
+          } else {
+            return nullptr;
+          }
         }
       }
     }
@@ -2580,7 +2598,7 @@
   AlternativeReadingScope alt(&reader_);
 
   TryFinallyBlock* const saved_block = B->try_finally_block_;
-  TryCatchBlock* const saved_try_catch_block = B->try_catch_block_;
+  TryCatchBlock* const saved_try_catch_block = B->CurrentTryCatchBlock();
   const intptr_t saved_depth = B->context_depth_;
   const intptr_t saved_try_depth = B->try_depth_;
 
@@ -2601,7 +2619,7 @@
     bool changed_try_index = false;
     intptr_t target_try_index = B->try_finally_block_->try_index();
     while (B->CurrentTryIndex() != target_try_index) {
-      B->try_catch_block_ = B->try_catch_block_->outer();
+      B->SetCurrentTryCatchBlock(B->CurrentTryCatchBlock()->outer());
       changed_try_index = true;
     }
     if (changed_try_index) {
@@ -2628,7 +2646,7 @@
   }
 
   B->try_finally_block_ = saved_block;
-  B->try_catch_block_ = saved_try_catch_block;
+  B->SetCurrentTryCatchBlock(saved_try_catch_block);
   B->context_depth_ = saved_depth;
   B->try_depth_ = saved_try_depth;
 
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index c81353c..fff48a9 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -30,7 +30,7 @@
 
 FlowGraphBuilder::FlowGraphBuilder(
     ParsedFunction* parsed_function,
-    const ZoneGrowableArray<const ICData*>& ic_data_array,
+    ZoneGrowableArray<const ICData*>* ic_data_array,
     ZoneGrowableArray<intptr_t>* context_level_array,
     InlineExitCollector* exit_collector,
     bool optimizing,
@@ -39,6 +39,7 @@
     bool inlining_unchecked_entry)
     : BaseFlowGraphBuilder(parsed_function,
                            first_block_id - 1,
+                           osr_id,
                            context_level_array,
                            exit_collector,
                            inlining_unchecked_entry),
@@ -47,8 +48,7 @@
       zone_(translation_helper_.zone()),
       parsed_function_(parsed_function),
       optimizing_(optimizing),
-      osr_id_(osr_id),
-      ic_data_array_(ic_data_array),
+      ic_data_array_(*ic_data_array),
       next_function_id_(0),
       try_depth_(0),
       catch_depth_(0),
@@ -57,6 +57,7 @@
       scopes_(NULL),
       breakable_block_(NULL),
       switch_block_(NULL),
+      try_catch_block_(NULL),
       try_finally_block_(NULL),
       catch_block_(NULL) {
   const Script& script =
@@ -245,8 +246,8 @@
       TokenPosition::kNoSource,  // Token position of catch block.
       is_synthesized,  // whether catch block was synthesized by FE compiler
       AllocateBlockId(), CurrentTryIndex(), graph_entry_, handler_types,
-      handler_index, *exception_var, *stacktrace_var, needs_stacktrace,
-      GetNextDeoptId(), raw_exception_var, raw_stacktrace_var);
+      handler_index, needs_stacktrace, GetNextDeoptId(), exception_var,
+      stacktrace_var, raw_exception_var, raw_stacktrace_var);
   graph_entry_->AddCatchEntry(entry);
 
   Fragment instructions(entry);
@@ -416,18 +417,6 @@
   return Fragment(load);
 }
 
-Fragment FlowGraphBuilder::LoadField(const Field& field) {
-  LoadFieldInstr* load = new (Z) LoadFieldInstr(
-      Pop(), &MayCloneField(field), AbstractType::ZoneHandle(Z, field.type()),
-      TokenPosition::kNoSource, parsed_function_);
-  Push(load);
-  return Fragment(load);
-}
-
-Fragment FlowGraphBuilder::LoadField(intptr_t offset, intptr_t class_id) {
-  return BaseFlowGraphBuilder::LoadField(offset, class_id);
-}
-
 Fragment FlowGraphBuilder::LoadLocal(LocalVariable* variable) {
   if (variable->is_captured()) {
     Fragment instructions;
@@ -1381,6 +1370,13 @@
                            prologue_info);
 }
 
+void FlowGraphBuilder::SetCurrentTryCatchBlock(TryCatchBlock* try_catch_block) {
+  try_catch_block_ = try_catch_block;
+  SetCurrentTryIndex(try_catch_block == nullptr
+                         ? CatchClauseNode::kInvalidTryIndex
+                         : try_catch_block->try_index());
+}
+
 }  // namespace kernel
 }  // namespace dart
 
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.h b/runtime/vm/compiler/frontend/kernel_to_il.h
index 9f6b524..eeecd74 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.h
+++ b/runtime/vm/compiler/frontend/kernel_to_il.h
@@ -22,13 +22,13 @@
 
 namespace kernel {
 
-class BaseFlowGraphBuilder;
 class StreamingFlowGraphBuilder;
 struct InferredTypeMetadata;
 class BreakableBlock;
 class CatchBlock;
 class FlowGraphBuilder;
 class SwitchBlock;
+class TryCatchBlock;
 class TryFinallyBlock;
 
 struct YieldContinuation {
@@ -45,7 +45,7 @@
 class FlowGraphBuilder : public BaseFlowGraphBuilder {
  public:
   FlowGraphBuilder(ParsedFunction* parsed_function,
-                   const ZoneGrowableArray<const ICData*>& ic_data_array,
+                   ZoneGrowableArray<const ICData*>* ic_data_array,
                    ZoneGrowableArray<intptr_t>* context_level_array,
                    InlineExitCollector* exit_collector,
                    bool optimizing,
@@ -114,8 +114,6 @@
 
   Fragment RethrowException(TokenPosition position, int catch_try_index);
   Fragment LoadClassId();
-  Fragment LoadField(intptr_t offset, intptr_t class_id = kDynamicCid);
-  Fragment LoadField(const Field& field);
   Fragment LoadLocal(LocalVariable* variable);
   Fragment InitStaticField(const Field& field);
   Fragment NativeCall(const String* name, const Function* function);
@@ -172,16 +170,13 @@
 
   LocalVariable* LookupVariable(intptr_t kernel_offset);
 
-  bool IsCompiledForOsr() { return osr_id_ != DeoptId::kNone; }
-
   TranslationHelper translation_helper_;
   Thread* thread_;
   Zone* zone_;
 
   ParsedFunction* parsed_function_;
   const bool optimizing_;
-  intptr_t osr_id_;
-  const ZoneGrowableArray<const ICData*>& ic_data_array_;
+  ZoneGrowableArray<const ICData*>& ic_data_array_;
 
   intptr_t next_function_id_;
   intptr_t AllocateFunctionId() { return next_function_id_++; }
@@ -212,6 +207,10 @@
     return scopes_->catch_context_variables[try_depth_];
   }
 
+  TryCatchBlock* CurrentTryCatchBlock() const { return try_catch_block_; }
+
+  void SetCurrentTryCatchBlock(TryCatchBlock* try_catch_block);
+
   // A chained list of breakable blocks. Chaining and lookup is done by the
   // [BreakableBlock] class.
   BreakableBlock* breakable_block_;
@@ -220,6 +219,10 @@
   // [SwitchBlock] class.
   SwitchBlock* switch_block_;
 
+  // A chained list of try-catch blocks. Chaining and lookup is done by the
+  // [TryCatchBlock] class.
+  TryCatchBlock* try_catch_block_;
+
   // A chained list of try-finally blocks. Chaining and lookup is done by the
   // [TryFinallyBlock] class.
   TryFinallyBlock* try_finally_block_;
@@ -235,6 +238,7 @@
   friend class ConstantEvaluator;
   friend class StreamingFlowGraphBuilder;
   friend class SwitchBlock;
+  friend class TryCatchBlock;
   friend class TryFinallyBlock;
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphBuilder);
@@ -321,6 +325,30 @@
   intptr_t try_index_;
 };
 
+class TryCatchBlock {
+ public:
+  explicit TryCatchBlock(FlowGraphBuilder* builder,
+                         intptr_t try_handler_index = -1)
+      : builder_(builder),
+        outer_(builder->CurrentTryCatchBlock()),
+        try_index_(try_handler_index == -1 ? builder->AllocateTryIndex()
+                                           : try_handler_index) {
+    builder->SetCurrentTryCatchBlock(this);
+  }
+
+  ~TryCatchBlock() { builder_->SetCurrentTryCatchBlock(outer_); }
+
+  intptr_t try_index() { return try_index_; }
+  TryCatchBlock* outer() const { return outer_; }
+
+ private:
+  FlowGraphBuilder* const builder_;
+  TryCatchBlock* const outer_;
+  intptr_t const try_index_;
+
+  DISALLOW_COPY_AND_ASSIGN(TryCatchBlock);
+};
+
 class TryFinallyBlock {
  public:
   TryFinallyBlock(FlowGraphBuilder* builder, intptr_t finalizer_kernel_offset)
diff --git a/runtime/vm/compiler/frontend/prologue_builder.cc b/runtime/vm/compiler/frontend/prologue_builder.cc
index 88490a4..a63ae30 100644
--- a/runtime/vm/compiler/frontend/prologue_builder.cc
+++ b/runtime/vm/compiler/frontend/prologue_builder.cc
@@ -34,8 +34,6 @@
 
 BlockEntryInstr* PrologueBuilder::BuildPrologue(BlockEntryInstr* entry,
                                                 PrologueInfo* prologue_info) {
-  const bool strong = FLAG_strong;
-
   // We always have to build the graph, but we only link it sometimes.
   const bool link = !is_inlining_ && !compiling_for_osr_;
 
@@ -52,14 +50,15 @@
     nsm = BuildThrowNoSuchMethod();
   }
   if (check_arguments) {
-    Fragment f = BuildTypeArgumentsLengthCheck(strong, nsm, expect_type_args);
+    Fragment f = BuildTypeArgumentsLengthCheck(nsm, expect_type_args);
     if (link) prologue += f;
   }
   if (load_optional_arguments) {
-    Fragment f = BuildOptionalParameterHandling(strong, nsm);
+    Fragment f = BuildOptionalParameterHandling(
+        nsm, parsed_function_->expression_temp_var());
     if (link) prologue += f;
   } else if (check_arguments) {
-    Fragment f = BuildFixedParameterLengthChecks(strong, nsm);
+    Fragment f = BuildFixedParameterLengthChecks(nsm);
     if (link) prologue += f;
   }
   if (function_.IsClosureFunction()) {
@@ -87,8 +86,7 @@
   }
 }
 
-Fragment PrologueBuilder::BuildTypeArgumentsLengthCheck(bool strong,
-                                                        JoinEntryInstr* nsm,
+Fragment PrologueBuilder::BuildTypeArgumentsLengthCheck(JoinEntryInstr* nsm,
                                                         bool expect_type_args) {
   Fragment check_type_args;
   JoinEntryInstr* done = BuildJoinEntry();
@@ -130,8 +128,9 @@
   return Fragment(check_type_args.entry, done);
 }
 
-Fragment PrologueBuilder::BuildOptionalParameterHandling(bool strong,
-                                                         JoinEntryInstr* nsm) {
+Fragment PrologueBuilder::BuildOptionalParameterHandling(
+    JoinEntryInstr* nsm,
+    LocalVariable* temp_var) {
   Fragment copy_args_prologue;
   const int num_fixed_params = function_.num_fixed_parameters();
   const int num_opt_pos_params = function_.NumOptionalPositionalParameters();
@@ -244,13 +243,12 @@
         ArgumentsDescriptor::first_named_entry_offset() - Array::data_offset();
 
     // Start by alphabetically sorting the names of the optional parameters.
-    LocalVariable** opt_param = new LocalVariable*[num_opt_named_params];
-    int* opt_param_position = new int[num_opt_named_params];
-    SortOptionalNamedParametersInto(opt_param, opt_param_position,
-                                    num_fixed_params, num_params);
+    int* opt_param_position = Z->Alloc<int>(num_opt_named_params);
+    SortOptionalNamedParametersInto(opt_param_position, num_fixed_params,
+                                    num_params);
 
-    LocalVariable* optional_count_vars_processed =
-        parsed_function_->expression_temp_var();
+    ASSERT(temp_var != nullptr);
+    LocalVariable* optional_count_vars_processed = temp_var;
     copy_args_prologue += IntConstant(0);
     copy_args_prologue +=
         StoreLocalRaw(TokenPosition::kNoSource, optional_count_vars_processed);
@@ -274,8 +272,10 @@
       copy_args_prologue += LoadIndexed(/* index_scale = */ kWordSize);
 
       // first name in sorted list of all names
-      ASSERT(opt_param[i]->name().IsSymbol());
-      copy_args_prologue += Constant(opt_param[i]->name());
+      const String& param_name = String::ZoneHandle(
+          Z, function_.ParameterNameAt(opt_param_position[i]));
+      ASSERT(param_name.IsSymbol());
+      copy_args_prologue += Constant(param_name);
 
       // Compare the two names: Note that the ArgumentDescriptor array always
       // terminates with a "null" name (i.e. kNullCid), which will prevent us
@@ -337,9 +337,6 @@
       copy_args_prologue += Drop();  // tuple_diff
     }
 
-    delete[] opt_param;
-    delete[] opt_param_position;
-
     // If there are more arguments from the caller we haven't processed, go
     // NSM.
     TargetEntryInstr *done, *unknown_named_arg_passed;
@@ -361,8 +358,7 @@
   return copy_args_prologue;
 }
 
-Fragment PrologueBuilder::BuildFixedParameterLengthChecks(bool strong,
-                                                          JoinEntryInstr* nsm) {
+Fragment PrologueBuilder::BuildFixedParameterLengthChecks(JoinEntryInstr* nsm) {
   Fragment check_args;
   JoinEntryInstr* done = BuildJoinEntry();
 
@@ -448,24 +444,21 @@
   return handling;
 }
 
-void PrologueBuilder::SortOptionalNamedParametersInto(LocalVariable** opt_param,
-                                                      int* opt_param_position,
+void PrologueBuilder::SortOptionalNamedParametersInto(int* opt_param_position,
                                                       int num_fixed_params,
                                                       int num_params) {
-  LocalScope* scope = parsed_function_->node_sequence()->scope();
+  String& name = String::Handle(Z);
+  String& name_i = String::Handle(Z);
   for (int pos = num_fixed_params; pos < num_params; pos++) {
-    LocalVariable* parameter = scope->VariableAt(pos);
-    const String& opt_param_name = parameter->name();
+    name = function_.ParameterNameAt(pos);
     int i = pos - num_fixed_params;
     while (--i >= 0) {
-      LocalVariable* param_i = opt_param[i];
-      const intptr_t result = opt_param_name.CompareTo(param_i->name());
+      name_i = function_.ParameterNameAt(opt_param_position[i]);
+      const intptr_t result = name.CompareTo(name_i);
       ASSERT(result != 0);
       if (result > 0) break;
-      opt_param[i + 1] = opt_param[i];
       opt_param_position[i + 1] = opt_param_position[i];
     }
-    opt_param[i + 1] = parameter;
     opt_param_position[i + 1] = pos;
   }
 }
diff --git a/runtime/vm/compiler/frontend/prologue_builder.h b/runtime/vm/compiler/frontend/prologue_builder.h
index 30623d8..3f58e13 100644
--- a/runtime/vm/compiler/frontend/prologue_builder.h
+++ b/runtime/vm/compiler/frontend/prologue_builder.h
@@ -47,19 +47,19 @@
   BlockEntryInstr* BuildPrologue(BlockEntryInstr* entry,
                                  PrologueInfo* prologue_info);
 
+  Fragment BuildOptionalParameterHandling(JoinEntryInstr* nsm,
+                                          LocalVariable* temp_var);
+
   static bool HasEmptyPrologue(const Function& function);
   static bool PrologueSkippableOnUncheckedEntry(const Function& function);
 
   intptr_t last_used_block_id() const { return last_used_block_id_; }
 
  private:
-  Fragment BuildTypeArgumentsLengthCheck(bool strong,
-                                         JoinEntryInstr* nsm,
+  Fragment BuildTypeArgumentsLengthCheck(JoinEntryInstr* nsm,
                                          bool expect_type_args);
 
-  Fragment BuildOptionalParameterHandling(bool strong, JoinEntryInstr* nsm);
-
-  Fragment BuildFixedParameterLengthChecks(bool strong, JoinEntryInstr* nsm);
+  Fragment BuildFixedParameterLengthChecks(JoinEntryInstr* nsm);
 
   Fragment BuildClosureContextHandling();
 
@@ -79,8 +79,7 @@
     return Instance::null_instance();
   }
 
-  void SortOptionalNamedParametersInto(LocalVariable** opt_param,
-                                       int* opt_param_position,
+  void SortOptionalNamedParametersInto(int* opt_param_position,
                                        int num_fixed_params,
                                        int num_params);
 
diff --git a/runtime/vm/compiler/jit/compiler.cc b/runtime/vm/compiler/jit/compiler.cc
index e84b28d..50ff623 100644
--- a/runtime/vm/compiler/jit/compiler.cc
+++ b/runtime/vm/compiler/jit/compiler.cc
@@ -140,6 +140,7 @@
 bool UseKernelFrontEndFor(ParsedFunction* parsed_function) {
   const Function& function = parsed_function->function();
   return (function.kernel_offset() > 0) ||
+         (FLAG_use_bytecode_compiler && function.HasBytecode()) ||
          (function.kind() == RawFunction::kNoSuchMethodDispatcher) ||
          (function.kind() == RawFunction::kInvokeFieldDispatcher);
 }
@@ -154,7 +155,7 @@
 FlowGraph* DartCompilationPipeline::BuildFlowGraph(
     Zone* zone,
     ParsedFunction* parsed_function,
-    const ZoneGrowableArray<const ICData*>& ic_data_array,
+    ZoneGrowableArray<const ICData*>* ic_data_array,
     intptr_t osr_id,
     bool optimized) {
   if (UseKernelFrontEndFor(parsed_function)) {
@@ -167,7 +168,7 @@
                                parsed_function->function().HasBytecode()));
     return graph;
   }
-  FlowGraphBuilder builder(*parsed_function, ic_data_array,
+  FlowGraphBuilder builder(*parsed_function, *ic_data_array,
                            /* not building var desc */ NULL,
                            /* not inlining */ NULL, osr_id);
 
@@ -207,13 +208,13 @@
 FlowGraph* IrregexpCompilationPipeline::BuildFlowGraph(
     Zone* zone,
     ParsedFunction* parsed_function,
-    const ZoneGrowableArray<const ICData*>& ic_data_array,
+    ZoneGrowableArray<const ICData*>* ic_data_array,
     intptr_t osr_id,
     bool optimized) {
   // Compile to the dart IR.
   RegExpEngine::CompilationResult result =
       RegExpEngine::CompileIR(parsed_function->regexp_compile_data(),
-                              parsed_function, ic_data_array, osr_id);
+                              parsed_function, *ic_data_array, osr_id);
   backtrack_goto_ = result.backtrack_goto;
 
   // Allocate variables now that we know the number of locals.
@@ -826,7 +827,7 @@
         NOT_IN_PRODUCT(TimelineDurationScope tds(thread(), compiler_timeline,
                                                  "BuildFlowGraph"));
         flow_graph = pipeline->BuildFlowGraph(
-            zone, parsed_function(), *ic_data_array, osr_id(), optimized());
+            zone, parsed_function(), ic_data_array, osr_id(), optimized());
       }
 
       // TODO(regis): Revisit.
@@ -1377,7 +1378,7 @@
     } else {
       parsed_function->EnsureKernelScopes();
       kernel::FlowGraphBuilder builder(
-          parsed_function, *ic_data_array, context_level_array,
+          parsed_function, ic_data_array, context_level_array,
           /* not inlining */ NULL, false, Compiler::kNoOSRDeoptId);
       builder.BuildGraph();
     }
diff --git a/runtime/vm/compiler/jit/compiler.h b/runtime/vm/compiler/jit/compiler.h
index d938450..1636109 100644
--- a/runtime/vm/compiler/jit/compiler.h
+++ b/runtime/vm/compiler/jit/compiler.h
@@ -38,7 +38,7 @@
   virtual FlowGraph* BuildFlowGraph(
       Zone* zone,
       ParsedFunction* parsed_function,
-      const ZoneGrowableArray<const ICData*>& ic_data_array,
+      ZoneGrowableArray<const ICData*>* ic_data_array,
       intptr_t osr_id,
       bool optimized) = 0;
   virtual void FinalizeCompilation(FlowGraph* flow_graph) = 0;
@@ -47,32 +47,30 @@
 
 class DartCompilationPipeline : public CompilationPipeline {
  public:
-  virtual void ParseFunction(ParsedFunction* parsed_function);
+  void ParseFunction(ParsedFunction* parsed_function) override;
 
-  virtual FlowGraph* BuildFlowGraph(
-      Zone* zone,
-      ParsedFunction* parsed_function,
-      const ZoneGrowableArray<const ICData*>& ic_data_array,
-      intptr_t osr_id,
-      bool optimized);
+  FlowGraph* BuildFlowGraph(Zone* zone,
+                            ParsedFunction* parsed_function,
+                            ZoneGrowableArray<const ICData*>* ic_data_array,
+                            intptr_t osr_id,
+                            bool optimized) override;
 
-  virtual void FinalizeCompilation(FlowGraph* flow_graph);
+  void FinalizeCompilation(FlowGraph* flow_graph) override;
 };
 
 class IrregexpCompilationPipeline : public CompilationPipeline {
  public:
   IrregexpCompilationPipeline() : backtrack_goto_(NULL) {}
 
-  virtual void ParseFunction(ParsedFunction* parsed_function);
+  void ParseFunction(ParsedFunction* parsed_function) override;
 
-  virtual FlowGraph* BuildFlowGraph(
-      Zone* zone,
-      ParsedFunction* parsed_function,
-      const ZoneGrowableArray<const ICData*>& ic_data_array,
-      intptr_t osr_id,
-      bool optimized);
+  FlowGraph* BuildFlowGraph(Zone* zone,
+                            ParsedFunction* parsed_function,
+                            ZoneGrowableArray<const ICData*>* ic_data_array,
+                            intptr_t osr_id,
+                            bool optimized) override;
 
-  virtual void FinalizeCompilation(FlowGraph* flow_graph);
+  void FinalizeCompilation(FlowGraph* flow_graph) override;
 
  private:
   IndirectGotoInstr* backtrack_goto_;
diff --git a/runtime/vm/constants_kbc.h b/runtime/vm/constants_kbc.h
index a7b8922..8142e11 100644
--- a/runtime/vm/constants_kbc.h
+++ b/runtime/vm/constants_kbc.h
@@ -588,7 +588,7 @@
 //    If B is not 0 then EntryOptional bytecode is followed by B LoadConstant
 //    bytecodes specifying default values for optional arguments.
 //
-//    If C is not 0 then EntryOptional is followed by 2 * B LoadConstant
+//    If C is not 0 then EntryOptional is followed by 2 * C LoadConstant
 //    bytecodes.
 //    Bytecode at 2 * i specifies name of the i-th named argument and at
 //    2 * i + 1 default value. rA part of the LoadConstant bytecode specifies
@@ -597,7 +597,8 @@
 //    prologues are implemented on other architectures.
 //
 //    Note: Unlike Entry bytecode EntryOptional does not setup the frame for
-//    local variables this is done by a separate bytecode Frame.
+//    local variables this is done by a separate bytecode Frame, which should
+//    follow EntryOptional and its LoadConstant instructions.
 //
 //  - EntryOptimized rD
 //
@@ -1037,6 +1038,12 @@
     return names[DecodeOpcode(instr)];
   }
 
+  enum SpecialIndex {
+    kExceptionSpecialIndex,
+    kStackTraceSpecialIndex,
+    kSpecialIndexCount
+  };
+
   static const intptr_t kOpShift = 0;
   static const intptr_t kAShift = 8;
   static const intptr_t kAMask = 0xFF;
@@ -1048,6 +1055,7 @@
   static const intptr_t kDMask = 0xFFFF;
   static const intptr_t kYShift = 24;
   static const intptr_t kYMask = 0xFF;
+  static const intptr_t kTShift = 8;
 
   static KBCInstr Encode(Opcode op, uintptr_t a, uintptr_t b, uintptr_t c) {
     ASSERT((a & kAMask) == a);
@@ -1083,10 +1091,22 @@
     return (bc >> kBShift) & kBMask;
   }
 
+  DART_FORCE_INLINE static uint8_t DecodeC(KBCInstr bc) {
+    return (bc >> kCShift) & kCMask;
+  }
+
   DART_FORCE_INLINE static uint16_t DecodeD(KBCInstr bc) {
     return (bc >> kDShift) & kDMask;
   }
 
+  DART_FORCE_INLINE static int16_t DecodeX(KBCInstr bc) {
+    return static_cast<int16_t>((bc >> kDShift) & kDMask);
+  }
+
+  DART_FORCE_INLINE static int32_t DecodeT(KBCInstr bc) {
+    return static_cast<int32_t>(bc) >> kTShift;
+  }
+
   DART_FORCE_INLINE static Opcode DecodeOpcode(KBCInstr bc) {
     return static_cast<Opcode>(bc & 0xFF);
   }
diff --git a/runtime/vm/dart.cc b/runtime/vm/dart.cc
index d2dcdb2..18bb9b2 100644
--- a/runtime/vm/dart.cc
+++ b/runtime/vm/dart.cc
@@ -136,6 +136,12 @@
   }
 #endif
 
+  if (FLAG_use_bytecode_compiler) {
+    // Interpreter is not able to trigger compilation yet.
+    // TODO(alexmarkov): Revise
+    FLAG_enable_interpreter = false;
+  }
+
   if (FLAG_enable_interpreter) {
 #if defined(USING_SIMULATOR) || defined(TARGET_ARCH_DBC)
     return strdup(
diff --git a/runtime/vm/dart_entry.cc b/runtime/vm/dart_entry.cc
index 435fb26..a49749d 100644
--- a/runtime/vm/dart_entry.cc
+++ b/runtime/vm/dart_entry.cc
@@ -339,6 +339,26 @@
   return NameAt(index) == other.raw();
 }
 
+RawArray* ArgumentsDescriptor::GetArgumentNames() const {
+  const intptr_t num_named_args = NamedCount();
+  if (num_named_args == 0) {
+    return Array::null();
+  }
+
+  Zone* zone = Thread::Current()->zone();
+  const Array& names =
+      Array::Handle(zone, Array::New(num_named_args, Heap::kOld));
+  String& name = String::Handle(zone);
+  const intptr_t num_pos_args = PositionalCount();
+  for (intptr_t i = 0; i < num_named_args; ++i) {
+    const intptr_t index = PositionAt(i) - num_pos_args;
+    name = NameAt(i);
+    ASSERT(names.At(index) == Object::null());
+    names.SetAt(index, name);
+  }
+  return names.raw();
+}
+
 intptr_t ArgumentsDescriptor::type_args_len_offset() {
   return Array::element_offset(kTypeArgsLenIndex);
 }
diff --git a/runtime/vm/dart_entry.h b/runtime/vm/dart_entry.h
index 0898a93..cfcd404 100644
--- a/runtime/vm/dart_entry.h
+++ b/runtime/vm/dart_entry.h
@@ -45,6 +45,8 @@
   RawString* NameAt(intptr_t i) const;
   intptr_t PositionAt(intptr_t i) const;
   bool MatchesNameAt(intptr_t i, const String& other) const;
+  // Returns array of argument names in the arguments order.
+  RawArray* GetArgumentNames() const;
 
   // Generated code support.
   static intptr_t type_args_len_offset();
diff --git a/runtime/vm/flag_list.h b/runtime/vm/flag_list.h
index 4704064..8ce163e 100644
--- a/runtime/vm/flag_list.h
+++ b/runtime/vm/flag_list.h
@@ -185,6 +185,7 @@
   D(trace_zones, bool, false, "Traces allocation sizes in the zone.")          \
   P(truncating_left_shift, bool, true,                                         \
     "Optimize left shift to truncate if possible")                             \
+  C(use_bytecode_compiler, false, false, bool, false, "Compile from bytecode") \
   P(use_compactor, bool, false, "Compact the heap during old-space GC.")       \
   P(use_cha_deopt, bool, true,                                                 \
     "Use class hierarchy analysis even if it can cause deoptimization.")       \
diff --git a/runtime/vm/interpreter.cc b/runtime/vm/interpreter.cc
index 63a9372..466b216 100644
--- a/runtime/vm/interpreter.cc
+++ b/runtime/vm/interpreter.cc
@@ -1524,7 +1524,7 @@
                   exit_fp);                                                    \
       }                                                                        \
       ASSERT(reinterpret_cast<uword>(fp_) < stack_limit());                    \
-      return special_[kExceptionSpecialIndex];                                 \
+      return special_[KernelBytecode::kExceptionSpecialIndex];                 \
     }                                                                          \
     goto DispatchAfterException;                                               \
   } while (0)
@@ -1544,7 +1544,7 @@
       thread->set_top_exit_frame_info(exit_fp);                                \
       thread->set_top_resource(top_resource);                                  \
       thread->set_vm_tag(vm_tag);                                              \
-      return special_[kExceptionSpecialIndex];                                 \
+      return special_[KernelBytecode::kExceptionSpecialIndex];                 \
     }                                                                          \
     goto DispatchAfterException;                                               \
   } while (0)
@@ -4837,8 +4837,8 @@
     ASSERT(raw_exception != Object::null());
     thread->set_active_exception(Object::null_object());
     thread->set_active_stacktrace(Object::null_object());
-    special_[kExceptionSpecialIndex] = raw_exception;
-    special_[kStackTraceSpecialIndex] = raw_stacktrace;
+    special_[KernelBytecode::kExceptionSpecialIndex] = raw_exception;
+    special_[KernelBytecode::kStackTraceSpecialIndex] = raw_stacktrace;
     pc_ = thread->resume_pc();
   } else {
     pc_ = pc;
diff --git a/runtime/vm/interpreter.h b/runtime/vm/interpreter.h
index c49c3b5..3d98670 100644
--- a/runtime/vm/interpreter.h
+++ b/runtime/vm/interpreter.h
@@ -91,12 +91,6 @@
     return intrinsics_[id] != NULL;
   }
 
-  enum SpecialIndex {
-    kExceptionSpecialIndex,
-    kStackTraceSpecialIndex,
-    kSpecialIndexCount
-  };
-
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
  private:
@@ -113,7 +107,7 @@
   RawObjectPool* pp_;  // Pool Pointer.
   RawArray* argdesc_;  // Arguments Descriptor: used to pass information between
                        // call instruction and the function entry.
-  RawObject* special_[kSpecialIndexCount];
+  RawObject* special_[KernelBytecode::kSpecialIndexCount];
 
   static IntrinsicHandler intrinsics_[kIntrinsicCount];
 
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 434de7b..98ecf52 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -5971,8 +5971,10 @@
   // We should not have loaded the bytecode if the function had code.
   ASSERT(!HasCode());
 
-  // Set the code entry_point to InterpretCall stub.
-  SetInstructions(Code::Handle(StubCode::InterpretCall_entry()->code()));
+  if (!FLAG_use_bytecode_compiler) {
+    // Set the code entry_point to InterpretCall stub.
+    SetInstructions(Code::Handle(StubCode::InterpretCall_entry()->code()));
+  }
 }
 
 bool Function::HasBytecode() const {
@@ -6002,9 +6004,7 @@
   ASSERT(Thread::Current()->IsMutatorThread());
 
   StorePointer(&raw_ptr()->unoptimized_code_, Code::null());
-  if (FLAG_enable_interpreter) {
-    StorePointer(&raw_ptr()->bytecode_, Code::null());
-  }
+  StorePointer(&raw_ptr()->bytecode_, Code::null());
 
   SetInstructions(Code::Handle(StubCode::LazyCompile_entry()->code()));
 #endif  // defined(DART_PRECOMPILED_RUNTIME)
diff --git a/runtime/vm/parser.cc b/runtime/vm/parser.cc
index 1ec727e..0e7670e 100644
--- a/runtime/vm/parser.cc
+++ b/runtime/vm/parser.cc
@@ -337,7 +337,8 @@
   // parameters array, which can be used to access the raw parameters (i.e. not
   // the potentially variables which are in the context)
 
-  for (intptr_t param = 0; param < function().NumParameters(); ++param) {
+  raw_parameters_ = new (Z) ZoneGrowableArray<LocalVariable*>(Z, num_params);
+  for (intptr_t param = 0; param < num_params; ++param) {
     LocalVariable* raw_parameter = scope->VariableAt(param);
     if (raw_parameter->is_captured()) {
       String& tmp = String::ZoneHandle(Z);
@@ -366,7 +367,7 @@
             VariableIndex(function().NumParameters() - param));
       }
     }
-    raw_parameters_.Add(raw_parameter);
+    raw_parameters_->Add(raw_parameter);
   }
   if (function_type_arguments_ != NULL) {
     LocalVariable* raw_type_args_parameter = function_type_arguments_;
@@ -445,6 +446,12 @@
   num_stack_locals_ = num_stack_locals;
 }
 
+void ParsedFunction::AllocateBytecodeVariables(intptr_t num_stack_locals) {
+  ASSERT(!function().IsIrregexpFunction());
+  first_parameter_index_ = VariableIndex(function().num_fixed_parameters());
+  num_stack_locals_ = num_stack_locals;
+}
+
 struct Parser::Block : public ZoneAllocated {
   Block(Block* outer_block, LocalScope* local_scope, SequenceNode* seq)
       : parent(outer_block), scope(local_scope), statements(seq) {
diff --git a/runtime/vm/parser.h b/runtime/vm/parser.h
index 2383ce2..712e5c3 100644
--- a/runtime/vm/parser.h
+++ b/runtime/vm/parser.h
@@ -200,6 +200,7 @@
 
   void AllocateVariables();
   void AllocateIrregexpVariables(intptr_t num_stack_locals);
+  void AllocateBytecodeVariables(intptr_t num_stack_locals);
 
   void record_await() { have_seen_await_expr_ = true; }
   bool have_seen_await() const { return have_seen_await_expr_; }
@@ -229,8 +230,16 @@
     return raw_type_arguments_var_;
   }
 
+  void SetRawTypeArgumentsVariable(LocalVariable* raw_type_arguments_var) {
+    raw_type_arguments_var_ = raw_type_arguments_var;
+  }
+
+  void SetRawParameters(ZoneGrowableArray<LocalVariable*>* raw_parameters) {
+    raw_parameters_ = raw_parameters;
+  }
+
   LocalVariable* RawParameterVariable(intptr_t i) const {
-    return raw_parameters_[i];
+    return raw_parameters_->At(i);
   }
 
  private:
@@ -252,7 +261,7 @@
   ZoneGrowableArray<const Instance*>* default_parameter_values_;
 
   LocalVariable* raw_type_arguments_var_;
-  ZoneGrowableArray<LocalVariable*> raw_parameters_;
+  ZoneGrowableArray<LocalVariable*>* raw_parameters_ = nullptr;
 
   VariableIndex first_parameter_index_;
   int num_stack_locals_;
diff --git a/runtime/vm/stack_frame_kbc.h b/runtime/vm/stack_frame_kbc.h
index 8a6063e..8bfe809 100644
--- a/runtime/vm/stack_frame_kbc.h
+++ b/runtime/vm/stack_frame_kbc.h
@@ -46,6 +46,7 @@
 static const int kKBCCallerSpSlotFromFp = -kKBCDartFrameFixedSize - 1;
 static const int kKBCPcMarkerSlotFromFp = -3;
 static const int kKBCFunctionSlotFromFp = -4;
+static const int kKBCParamEndSlotFromFp = 4;
 
 // Entry and exit frame layout.
 static const int kKBCEntrySavedSlots = 3;