Allocate and finalize a code object on x64 if the new compiler succeeds.

runtime/vm/flow_graph_compiler_x64.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_generator.h"
 #include "vm/disassembler.h"
 #include "vm/longjump.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, print_ast);
 DECLARE_FLAG(bool, print_scopes);
 DECLARE_FLAG(bool, trace_functions);
-DECLARE_FLAG(bool, disassemble);
 
 void FlowGraphCompiler::Bailout(const char* reason) {
   const char* kFormat = "FlowGraphCompiler Bailout: %s.";
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, reason) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
@@ skipping 147 matching lines @@
 
   __ int3();
   // Emit function patching code. This will be swapped with the first 13 bytes
   // at entry point.
   pc_descriptors_list_->AddDescriptor(PcDescriptors::kPatchCode,
                                       assembler_->CodeSize(),
                                       AstNode::kNoId,
                                       0,
                                       -1);
   __ jmp(&StubCode::FixCallersTargetLabel());
-
-  if (FLAG_disassemble) {
-    const char* function_fullname = function.ToFullyQualifiedCString();
-    OS::Print(";;; Function %s\n", function_fullname);
-    const Code& code = Code::Handle(Code::FinalizeCode("GRAPH", assembler_));
-    const Instructions& instructions =
-        Instructions::Handle(code.instructions());
-    uword start = instructions.EntryPoint();
-    Disassembler::Disassemble(start, start + assembler_->CodeSize());
-    OS::Print("\n");
-  }
 }
 
 
 // Infrastructure copied from class CodeGenerator.
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t node_id,
                                             intptr_t token_index,
                                             const RuntimeEntry& entry) {
   __ CallRuntimeFromDart(entry);
   AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index);
 }
 
 
 // Uses current pc position and try-index.
 void FlowGraphCompiler::AddCurrentDescriptor(PcDescriptors::Kind kind,
                                              intptr_t node_id,
                                              intptr_t token_index) {
   pc_descriptors_list_->AddDescriptor(kind,
                                       assembler_->CodeSize(),
                                       node_id,
                                       token_index,
                                       CatchClauseNode::kInvalidTryIndex);
 }
 
 
+void FlowGraphCompiler::FinalizePcDescriptors(const Code& code) {
+  ASSERT(pc_descriptors_list_ != NULL);
+  const PcDescriptors& descriptors = PcDescriptors::Handle(
+      pc_descriptors_list_->FinalizePcDescriptors(code.EntryPoint()));
+  CodeGenerator::VerifyPcDescriptors(
+      descriptors, parsed_function_.function().is_optimizable());
+  code.set_pc_descriptors(descriptors);
+}
+
+
+void FlowGraphCompiler::FinalizeVarDescriptors(const Code& code) {
+  const LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle(
+          parsed_function_.node_sequence()->scope()->GetVarDescriptors());
+  code.set_var_descriptors(var_descs);
+}
+
+
+void FlowGraphCompiler::FinalizeExceptionHandlers(const Code& code) {
+  // We don't compile exception handlers yet.
+  code.set_exception_handlers(
+      ExceptionHandlers::Handle(ExceptionHandlers::New(0)));
+}
+
+
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64