Add a stubbed-out implementation of FlowGraphCompiler for ia32 and arm.

runtime/vm/compiler.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/compiler.h"
 
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/code_generator.h"
 #include "vm/code_index_table.h"
@@ skipping 105 matching lines @@
     TIMERSCOPE(time_compilation);
     ParsedFunction parsed_function(function);
     const char* function_fullname = function.ToFullyQualifiedCString();
     if (FLAG_trace_compiler) {
       OS::Print("Compiling %sfunction: '%s' @ token %d\n",
                 (optimized ? "optimized " : ""),
                 function_fullname,
                 function.token_index());
     }
     Parser::ParseFunction(&parsed_function);
+
+    CodeIndexTable* code_index_table = isolate->code_index_table();
+    ASSERT(code_index_table != NULL);
+    int code_size = -1;  // Assembled code size needed if --disassemble.
+    bool is_compiled = false;
     if (FLAG_use_new_compiler) {
       ASSERT(!optimized);
       LongJump* old_base = isolate->long_jump_base();
       LongJump bailout_jump;
       isolate->set_long_jump_base(&bailout_jump);
       if (setjmp(*bailout_jump.Set()) == 0) {
         FlowGraphBuilder graph_builder(parsed_function);
         graph_builder.BuildGraph();
 
-        // Try to compile on x64 (only for now).
-#ifdef TARGET_ARCH_X64
-        // TODO(kmillikin): Implement or stub out class FlowGraphCompiler
-        // for other architectures and remove the unsightly ifdef.
         Assembler assembler;
         FlowGraphCompiler graph_compiler(&assembler,
                                          parsed_function,
                                          graph_builder.blocks());
         graph_compiler.CompileGraph();
-#endif
-
+        const Code& code =
+            Code::Handle(Code::FinalizeCode(function_fullname, &assembler));
+        code.set_is_optimized(false);
+        graph_compiler.FinalizePcDescriptors(code);
+        graph_compiler.FinalizeVarDescriptors(code);
+        graph_compiler.FinalizeExceptionHandlers(code);
+        function.set_unoptimized_code(code);
+        function.SetCode(code);
+        ASSERT(CodePatcher::CodeIsPatchable(code));
+        code_index_table->AddFunction(function);
+        is_compiled = true;
+        code_size = assembler.CodeSize();
       } else {
         // We bailed out.
         Error& bailout_error = Error::Handle(
             isolate->object_store()->sticky_error());
         isolate->object_store()->clear_sticky_error();
         if (FLAG_trace_bailout) {
           OS::Print("%s\n", bailout_error.ToErrorCString());
         }
       }
       isolate->set_long_jump_base(old_base);
-      // Currently, always fails and falls through to the old compiler.
     }
-    CodeIndexTable* code_index_table = isolate->code_index_table();
-    ASSERT(code_index_table != NULL);
-    Assembler assembler;
-    if (optimized) {
-      // Transition to optimized code only from unoptimized code ... for now.
-      ASSERT(function.HasCode());
-      ASSERT(!Code::Handle(function.code()).is_optimized());
-      // Do not use type feedback to optimize a function that was deoptimized.
-      if (parsed_function.function().deoptimization_counter() <
-          FLAG_deoptimization_counter_threshold) {
-        ExtractTypeFeedback(Code::Handle(parsed_function.function().code()),
-                            parsed_function.node_sequence());
-      }
-      OptimizingCodeGenerator code_gen(&assembler, parsed_function);
-      code_gen.GenerateCode();
-      Code& code = Code::Handle(
-          Code::FinalizeCode(function_fullname, &assembler));
-      code.set_is_optimized(true);
-      code_gen.FinalizePcDescriptors(code);
-      code_gen.FinalizeExceptionHandlers(code);
-      function.SetCode(code);
-      code_index_table->AddFunction(function);
-      CodePatcher::PatchEntry(Code::Handle(function.unoptimized_code()));
-      if (FLAG_trace_compiler) {
-        OS::Print("--> patching entry 0x%x\n",
-                  Code::Handle(function.unoptimized_code()).EntryPoint());
-      }
-    } else {
-      // Unoptimized code.
-      if (Code::Handle(function.unoptimized_code()).IsNull()) {
-        ASSERT(Code::Handle(function.code()).IsNull());
-        // Compiling first time.
-        CodeGenerator code_gen(&assembler, parsed_function);
+
+    if (!is_compiled) {
+      Assembler assembler;
+      if (optimized) {
+        // Transition to optimized code only from unoptimized code ...
+        // for now.
+        ASSERT(function.HasCode());
+        ASSERT(!Code::Handle(function.code()).is_optimized());
+        // Do not use type feedback to optimize a function that was
+        // deoptimized.
+        if (parsed_function.function().deoptimization_counter() <
+            FLAG_deoptimization_counter_threshold) {
+          ExtractTypeFeedback(Code::Handle(parsed_function.function().code()),
+                              parsed_function.node_sequence());
+        }
+        OptimizingCodeGenerator code_gen(&assembler, parsed_function);
         code_gen.GenerateCode();
-        const Code& code =
-            Code::Handle(Code::FinalizeCode(function_fullname, &assembler));
-        code.set_is_optimized(false);
+        Code& code = Code::Handle(
+            Code::FinalizeCode(function_fullname, &assembler));
+        code.set_is_optimized(true);
         code_gen.FinalizePcDescriptors(code);
-        code_gen.FinalizeVarDescriptors(code);
         code_gen.FinalizeExceptionHandlers(code);
-        function.set_unoptimized_code(code);
         function.SetCode(code);
-        ASSERT(CodePatcher::CodeIsPatchable(code));
         code_index_table->AddFunction(function);
-      } else {
-        // Disable optimized code.
-        const Code& optimized_code = Code::Handle(function.code());
-        ASSERT(optimized_code.is_optimized());
-        CodePatcher::PatchEntry(Code::Handle(function.code()));
+        CodePatcher::PatchEntry(Code::Handle(function.unoptimized_code()));
         if (FLAG_trace_compiler) {
           OS::Print("--> patching entry 0x%x\n",
                     Code::Handle(function.unoptimized_code()).EntryPoint());
         }
-        // Use previously compiled code.
-        function.SetCode(Code::Handle(function.unoptimized_code()));
-        CodePatcher::RestoreEntry(Code::Handle(function.unoptimized_code()));
-        if (FLAG_trace_compiler) {
-          OS::Print("--> restoring entry at 0x%x\n",
-                    Code::Handle(function.unoptimized_code()).EntryPoint());
+      } else {
+        // Unoptimized code.
+        if (Code::Handle(function.unoptimized_code()).IsNull()) {
+          ASSERT(Code::Handle(function.code()).IsNull());
+          // Compiling first time.
+          CodeGenerator code_gen(&assembler, parsed_function);
+          code_gen.GenerateCode();
+          const Code& code =
+              Code::Handle(Code::FinalizeCode(function_fullname, &assembler));
+          code.set_is_optimized(false);
+          code_gen.FinalizePcDescriptors(code);
+          code_gen.FinalizeVarDescriptors(code);
+          code_gen.FinalizeExceptionHandlers(code);
+          function.set_unoptimized_code(code);
+          function.SetCode(code);
+          ASSERT(CodePatcher::CodeIsPatchable(code));
+          code_index_table->AddFunction(function);
+        } else {
+          // Disable optimized code.
+          const Code& optimized_code = Code::Handle(function.code());
+          ASSERT(optimized_code.is_optimized());
+          CodePatcher::PatchEntry(Code::Handle(function.code()));
+          if (FLAG_trace_compiler) {
+            OS::Print("--> patching entry 0x%x\n",
+                      Code::Handle(function.unoptimized_code()).EntryPoint());
+          }
+          // Use previously compiled code.
+          function.SetCode(Code::Handle(function.unoptimized_code()));
+          CodePatcher::RestoreEntry(Code::Handle(function.unoptimized_code()));
+          if (FLAG_trace_compiler) {
+            OS::Print("--> restoring entry at 0x%x\n",
+                      Code::Handle(function.unoptimized_code()).EntryPoint());
+          }
         }
       }
+      code_size = assembler.CodeSize();
     }
     if (FLAG_trace_compiler) {
       OS::Print("--> '%s' entry: 0x%x\n",
                 function_fullname, Code::Handle(function.code()).EntryPoint());
     }
     if (FLAG_disassemble) {
       OS::Print("Code for %sfunction '%s' {\n",
                 optimized ? "optimized " : "", function_fullname);
       const Code& code = Code::Handle(function.code());
       const Instructions& instructions =
           Instructions::Handle(code.instructions());
       uword start = instructions.EntryPoint();
-      Disassembler::Disassemble(start, start + assembler.CodeSize());
+      Disassembler::Disassemble(start, start + code_size);
       OS::Print("}\n");
       OS::Print("Pointer offsets for function: {\n");
       for (intptr_t i = 0; i < code.pointer_offsets_length(); i++) {
         const uword addr = code.GetPointerOffsetAt(i) + code.EntryPoint();
         Object& obj = Object::Handle();
         obj = *reinterpret_cast<RawObject**>(addr);
         OS::Print(" %d : 0x%x '%s'\n",
                   code.GetPointerOffsetAt(i), addr, obj.ToCString());
       }
       OS::Print("}\n");
@@ skipping 133 matching lines @@
   } else {
     result = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
   }
   isolate->set_long_jump_base(base);
   return result.raw();
 }
 
 
 }  // namespace dart