Revert Dart_PropagateError until I can track down the problems in

runtime/vm/compiler.cc

 // Copyright (c) 2011, 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"
 #include "vm/code_patcher.h"
 #include "vm/dart_entry.h"
 #include "vm/disassembler.h"
-#include "vm/exceptions.h"
 #include "vm/flags.h"
-#include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/opt_code_generator.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 #include "vm/scanner.h"
 #include "vm/timer.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, disassemble, false, "Disassemble dart code.");
 DEFINE_FLAG(bool, trace_compiler, false, "Trace compiler operations.");
 DEFINE_FLAG(int, deoptimization_counter_threshold, 5,
     "How many times we allow deoptimization before we disallow"
     " certain optimizations");
 
 
 // Compile a function. Should call only if the function has not been compiled.
 //   Arg0: function object.
 DEFINE_RUNTIME_ENTRY(CompileFunction, 1) {
   ASSERT(arguments.Count() == kCompileFunctionRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.At(0));
   ASSERT(!function.HasCode());
-  const Error& error = Error::Handle(Compiler::CompileFunction(function));
-  if (!error.IsNull()) {
-    Exceptions::PropagateError(error);
-  }
+  Compiler::CompileFunction(function);
 }
 
 
 // Extracts IC data associated with a node id.
 // TODO(srdjan): Check performance impact of node id search loop.
 static void ExtractTypeFeedback(const Code& code,
                                 SequenceNode* sequence_node) {
   ASSERT(!code.IsNull() && !code.is_optimized());
   GrowableArray<AstNode*> all_nodes;
   sequence_node->CollectAllNodes(&all_nodes);
   GrowableArray<intptr_t> node_ids;
   GrowableArray<const Array*> arrays;
   code.ExtractIcDataArraysAtCalls(&node_ids, &arrays);
   for (intptr_t i = 0; i < node_ids.length(); i++) {
     intptr_t node_id = node_ids[i];
     bool found_node = false;
     for (intptr_t n = 0; n < all_nodes.length(); n++) {
       if (all_nodes[n]->HasId(node_id)) {
         found_node = true;
         // Make sure we assign ic data array only once.
         ASSERT(all_nodes[n]->ICDataAtId(node_id).NumberOfChecks() == 0);
         all_nodes[n]->SetIcDataArrayAtId(node_id, *arrays[i]);
       }
     }
     ASSERT(found_node);
   }
 }
 
 
-RawError* Compiler::Compile(const Library& library, const Script& script) {
-  Isolate* isolate = Isolate::Current();
-  Error& error = Error::Handle();
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
+void Compiler::Compile(const Library& library, const Script& script) {
+  if (FLAG_trace_compiler) {
+    HANDLESCOPE(Isolate::Current());
+    const String& script_url = String::Handle(script.url());
+    // TODO(iposva): Extract script kind.
+    OS::Print("Compiling %s '%s'\n", "", script_url.ToCString());
+  }
+  const String& library_key = String::Handle(library.private_key());
+  script.Tokenize(library_key);
+  Parser::ParseCompilationUnit(library, script);
+}
+
+
+static void CompileFunctionHelper(const Function& function, bool optimized) {
+  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::Current()->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) {
-      HANDLESCOPE(isolate);
-      const String& script_url = String::Handle(script.url());
-      // TODO(iposva): Extract script kind.
-      OS::Print("Compiling %s '%s'\n", "", script_url.ToCString());
-    }
-    const String& library_key = String::Handle(library.private_key());
-    script.Tokenize(library_key);
-    Parser::ParseCompilationUnit(library, script);
+      OS::Print("--> patching entry 0x%x\n",
+          Code::Handle(function.unoptimized_code()).EntryPoint());
+    }
   } else {
-    error = isolate->object_store()->sticky_error();
-    isolate->object_store()->clear_sticky_error();
-  }
-  isolate->set_long_jump_base(base);
-  return error.raw();
-}
-
-
-static RawError* CompileFunctionHelper(const Function& function,
-                                       bool optimized) {
-  Isolate* isolate = Isolate::Current();
-  Error& error = Error::Handle();
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    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);
-    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);
+    // 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();
-      Code& code = Code::Handle(
-          Code::FinalizeCode(function_fullname, &assembler));
-      code.set_is_optimized(true);
+      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);
-      CodePatcher::PatchEntry(Code::Handle(function.unoptimized_code()));
+    } 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());
+            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());
-        }
+      // 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());
       }
     }
-    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());
-      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");
-      OS::Print("PC Descriptors for function '%s' {\n", function_fullname);
-      OS::Print("(pc, kind, id, try-index, token-index)\n");
-      const PcDescriptors& descriptors =
-          PcDescriptors::Handle(code.pc_descriptors());
-      OS::Print("%s", descriptors.ToCString());
-      OS::Print("}\n");
-      OS::Print("Variable Descriptors for function '%s' {\n",
-                function_fullname);
-      const LocalVarDescriptors& var_descriptors =
-          LocalVarDescriptors::Handle(code.var_descriptors());
-      intptr_t var_desc_length =
-          var_descriptors.IsNull() ? 0 : var_descriptors.Length();
-      String& var_name = String::Handle();
-      for (intptr_t i = 0; i < var_desc_length; i++) {
-        var_name = var_descriptors.GetName(i);
-        intptr_t scope_id, begin_pos, end_pos;
-        var_descriptors.GetScopeInfo(i, &scope_id, &begin_pos, &end_pos);
-        intptr_t slot = var_descriptors.GetSlotIndex(i);
-        OS::Print("  var %s scope %ld (valid %d-%d) offset %ld\n",
-                  var_name.ToCString(), scope_id, begin_pos, end_pos, slot);
-      }
-      OS::Print("}\n");
-      OS::Print("Exception Handlers for function '%s' {\n", function_fullname);
-      const ExceptionHandlers& handlers =
-          ExceptionHandlers::Handle(code.exception_handlers());
-      OS::Print("%s", handlers.ToCString());
-      OS::Print("}\n");
-    }
-  } else {
-    // We got an error during compilation.
-    error = isolate->object_store()->sticky_error();
-    isolate->object_store()->clear_sticky_error();
-  }
-  isolate->set_long_jump_base(base);
-  return error.raw();
-}
-
-
-RawError* Compiler::CompileFunction(const Function& function) {
-  return CompileFunctionHelper(function, false);
-}
-
-
-RawError* Compiler::CompileOptimizedFunction(const Function& function) {
-  return CompileFunctionHelper(function, true);
-}
-
-
-RawError* Compiler::CompileAllFunctions(const Class& cls) {
-  Isolate* isolate = Isolate::Current();
-  Error& error = Error::Handle();
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    Array& functions = Array::Handle(cls.functions());
-    Function& func = Function::Handle();
-    for (int i = 0; i < functions.Length(); i++) {
-      func ^= functions.At(i);
-      ASSERT(!func.IsNull());
-      if (!func.HasCode() && !func.IsAbstract()) {
-        const Error& error = Error::Handle(CompileFunction(func));
-        if (!error.IsNull()) {
-          return error.raw();
-        }
-      }
-    }
-  } else {
-    error = isolate->object_store()->sticky_error();
-    isolate->object_store()->clear_sticky_error();
-  }
-  isolate->set_long_jump_base(base);
-  return error.raw();
-}
-
-
-RawObject* Compiler::ExecuteOnce(SequenceNode* fragment) {
-  Isolate* isolate = Isolate::Current();
-  Object& result = Object::Handle();
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    if (FLAG_trace_compiler) {
-      OS::Print("compiling expression: ");
-      AstPrinter::PrintNode(fragment);
-    }
-
-    // Create a dummy function object for the code generator.
-    const char* kEvalConst = "eval_const";
-    const Function& func = Function::Handle(Function::New(
-        String::Handle(String::NewSymbol(kEvalConst)),
-        RawFunction::kConstImplicitGetter,
-        true,  // static function.
-        false,  // not const function.
-        fragment->token_index()));
-
-    func.set_result_type(Type::Handle(Type::DynamicType()));
-    func.set_num_fixed_parameters(0);
-    func.set_num_optional_parameters(0);
-
-    // The function needs to be associated with a named Class: the interface
-    // Function fits the bill.
-    func.set_owner(Class::Handle(
-        Type::Handle(Type::FunctionInterface()).type_class()));
-
-    // We compile the function here, even though InvokeStatic() below
-    // would compile func automatically. We are checking fewer invariants
-    // here.
-    ParsedFunction parsed_function(func);
-    parsed_function.set_node_sequence(fragment);
-    parsed_function.set_default_parameter_values(Array::Handle());
-
-    Assembler assembler;
-    CodeGenerator code_gen(&assembler, parsed_function);
-    code_gen.GenerateCode();
-    const Code& code = Code::Handle(Code::FinalizeCode(kEvalConst, &assembler));
-
-    func.SetCode(code);
-    CodeIndexTable* code_index_table = isolate->code_index_table();
-    ASSERT(code_index_table != NULL);
-    code_index_table->AddFunction(func);
-    // TODO(hausner): We need a way to remove these one-time execution
-    // functions from the global code description (PC mapping) tables so
-    // we don't pollute the system unnecessarily with stale data.
-    code_gen.FinalizePcDescriptors(code);
-    code_gen.FinalizeExceptionHandlers(code);
-
-    GrowableArray<const Object*> arguments;  // no arguments.
-    const Array& kNoArgumentNames = Array::Handle();
-    result = DartEntry::InvokeStatic(func,
-                                     arguments,
-                                     kNoArgumentNames);
-  } else {
-    result = isolate->object_store()->sticky_error();
-    isolate->object_store()->clear_sticky_error();
-  }
-  isolate->set_long_jump_base(base);
+  }
+  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());
+    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");
+    OS::Print("PC Descriptors for function '%s' {\n", function_fullname);
+    OS::Print("(pc, kind, id, try-index, token-index)\n");
+    const PcDescriptors& descriptors =
+        PcDescriptors::Handle(code.pc_descriptors());
+    OS::Print("%s", descriptors.ToCString());
+    OS::Print("}\n");
+    OS::Print("Variable Descriptors for function '%s' {\n", function_fullname);
+    const LocalVarDescriptors& var_descriptors =
+        LocalVarDescriptors::Handle(code.var_descriptors());
+    intptr_t var_desc_length =
+        var_descriptors.IsNull() ? 0 : var_descriptors.Length();
+    String& var_name = String::Handle();
+    for (intptr_t i = 0; i < var_desc_length; i++) {
+      var_name = var_descriptors.GetName(i);
+      intptr_t scope_id, begin_pos, end_pos;
+      var_descriptors.GetScopeInfo(i, &scope_id, &begin_pos, &end_pos);
+      intptr_t slot = var_descriptors.GetSlotIndex(i);
+      OS::Print("  var %s scope %ld (valid %d-%d) offset %ld\n",
+                var_name.ToCString(), scope_id, begin_pos, end_pos, slot);
+    }
+    OS::Print("}\n");
+    OS::Print("Exception Handlers for function '%s' {\n", function_fullname);
+    const ExceptionHandlers& handlers =
+        ExceptionHandlers::Handle(code.exception_handlers());
+    OS::Print("%s", handlers.ToCString());
+    OS::Print("}\n");
+  }
+}
+
+
+void Compiler::CompileFunction(const Function& function) {
+  CompileFunctionHelper(function, false);
+}
+
+
+void Compiler::CompileOptimizedFunction(const Function& function) {
+  CompileFunctionHelper(function, true);
+}
+
+
+void Compiler::CompileAllFunctions(const Class& cls) {
+  Array& functions = Array::Handle(cls.functions());
+  Function& func = Function::Handle();
+  for (int i = 0; i < functions.Length(); i++) {
+    func ^= functions.At(i);
+    ASSERT(!func.IsNull());
+    if (!func.HasCode() && !func.IsAbstract()) {
+      CompileFunction(func);
+    }
+  }
+}
+
+
+RawInstance* Compiler::ExecuteOnce(SequenceNode* fragment) {
+  if (FLAG_trace_compiler) {
+    OS::Print("compiling expression: ");
+    AstPrinter::PrintNode(fragment);
+  }
+
+  // Create a dummy function object for the code generator.
+  const char* kEvalConst = "eval_const";
+  const Function& func = Function::Handle(Function::New(
+      String::Handle(String::NewSymbol(kEvalConst)),
+      RawFunction::kConstImplicitGetter,
+      true,  // static function.
+      false,  // not const function.
+      fragment->token_index()));
+
+  func.set_result_type(Type::Handle(Type::DynamicType()));
+  func.set_num_fixed_parameters(0);
+  func.set_num_optional_parameters(0);
+
+  // The function needs to be associated with a named Class: the interface
+  // Function fits the bill.
+  func.set_owner(Class::Handle(
+      Type::Handle(Type::FunctionInterface()).type_class()));
+
+  // We compile the function here, even though InvokeStatic() below
+  // would compile func automatically. We are checking fewer invariants
+  // here.
+  ParsedFunction parsed_function(func);
+  parsed_function.set_node_sequence(fragment);
+  parsed_function.set_default_parameter_values(Array::Handle());
+
+  Assembler assembler;
+  CodeGenerator code_gen(&assembler, parsed_function);
+  code_gen.GenerateCode();
+  const Code& code = Code::Handle(Code::FinalizeCode(kEvalConst, &assembler));
+
+  func.SetCode(code);
+  CodeIndexTable* code_index_table = Isolate::Current()->code_index_table();
+  ASSERT(code_index_table != NULL);
+  code_index_table->AddFunction(func);
+  // TODO(hausner): We need a way to remove these one-time execution
+  // functions from the global code description (PC mapping) tables so
+  // we don't pollute the system unnecessarily with stale data.
+  code_gen.FinalizePcDescriptors(code);
+  code_gen.FinalizeExceptionHandlers(code);
+
+  GrowableArray<const Object*> arguments;  // no arguments.
+  const Array& kNoArgumentNames = Array::Handle();
+  Instance& result = Instance::Handle(
+      DartEntry::InvokeStatic(func,
+                              arguments,
+                              kNoArgumentNames));
+  if (result.IsUnhandledException()) {
+    // TODO(srdjan): implement proper exit from compiler.
+    UNIMPLEMENTED();
+  }
   return result.raw();
 }
 
 
 }  // namespace dart