Version 1.1.0-dev.5.2

dart/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/block_scheduler.h"
@@ skipping 56 matching lines @@
   const Error& error = Error::Handle(Compiler::CompileFunction(function));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
   }
 }
 
 
 RawError* Compiler::Compile(const Library& library, const Script& script) {
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
+  LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     if (FLAG_trace_compiler) {
       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);
-    isolate->set_long_jump_base(base);
     return Error::null();
   } else {
     Error& error = Error::Handle();
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
-    isolate->set_long_jump_base(base);
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
 static void AddRelatedClassesToList(const Class& cls,
                                     const GrowableObjectArray& parse_list,
                                     const GrowableObjectArray& patch_list) {
@@ skipping 55 matching lines @@
   // also allows us to reset the marked_for_parsing state in case we see an
   // error.
   Class& parse_class = Class::Handle();
   const GrowableObjectArray& parse_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(4));
   const GrowableObjectArray& patch_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(4));
 
   // Parse the class and all the interfaces it implements and super classes.
   StackZone zone(isolate);
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
+  LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     if (FLAG_trace_compiler) {
       OS::Print("Compiling Class %s '%s'\n", "", cls.ToCString());
     }
 
     // Add the primary class which needs to be parsed to the parse list.
     // Mark the class as parsed so that we don't recursively add the same
     // class back into the list.
     parse_list.Add(cls);
     cls.set_is_marked_for_parsing();
@@ skipping 24 matching lines @@
     }
 
     // Finalize these classes.
     for (intptr_t i = (parse_list.Length() - 1); i >=0 ; i--) {
       parse_class ^= parse_list.At(i);
       ASSERT(!parse_class.IsNull());
       ClassFinalizer::FinalizeClass(parse_class);
       parse_class.reset_is_marked_for_parsing();
     }
 
-    isolate->set_long_jump_base(base);
     return Error::null();
   } else {
     // Reset the marked for parsing flags.
     for (intptr_t i = 0; i < parse_list.Length(); i++) {
       parse_class ^= parse_list.At(i);
       if (parse_class.is_marked_for_parsing()) {
         parse_class.reset_is_marked_for_parsing();
       }
     }
     for (intptr_t i = 0; i < patch_list.Length(); i++) {
       parse_class ^= patch_list.At(i);
       if (parse_class.is_marked_for_parsing()) {
         parse_class.reset_is_marked_for_parsing();
       }
     }
 
     Error& error = Error::Handle();
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
-    isolate->set_long_jump_base(base);
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
 static void InstallUnoptimizedCode(const Function& function) {
   // Disable optimized code.
   ASSERT(function.HasOptimizedCode());
@@ skipping 27 matching lines @@
   // done is set to false, and use_far_branches is set to true if there is a
   // longjmp from the ARM or MIPS assemblers. In all other paths through this
   // while loop, done is set to true. use_far_branches is always false on ia32
   // and x64.
   bool done = false;
   // volatile because the variable may be clobbered by a longjmp.
   volatile bool use_far_branches = false;
   while (!done) {
     const intptr_t prev_deopt_id = isolate->deopt_id();
     isolate->set_deopt_id(0);
-    LongJump* old_base = isolate->long_jump_base();
-    LongJump bailout_jump;
-    isolate->set_long_jump_base(&bailout_jump);
-    if (setjmp(*bailout_jump.Set()) == 0) {
+    LongJumpScope jump;
+    if (setjmp(*jump.Set()) == 0) {
       FlowGraph* flow_graph = NULL;
       // TimerScope needs an isolate to be properly terminated in case of a
       // LongJump.
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphbuilder_timer,
                          isolate);
         Array& ic_data_array = Array::Handle();
         if (optimized) {
           ASSERT(function.HasCode());
@@ skipping 301 matching lines @@
           OS::Print("%s\n", bailout_error.ToErrorCString());
         }
         done = true;
         ASSERT(optimized);
       }
 
       isolate->object_store()->clear_sticky_error();
       is_compiled = false;
     }
     // Reset global isolate state.
-    isolate->set_long_jump_base(old_base);
     isolate->set_deopt_id(prev_deopt_id);
   }
   return is_compiled;
 }
 
 
 static void DisassembleCode(const Function& function, bool optimized) {
   const char* function_fullname = function.ToFullyQualifiedCString();
   OS::Print("Code for %sfunction '%s' {\n",
             optimized ? "optimized " : "",
@@ skipping 116 matching lines @@
     OS::Print("}\n");
   }
 }
 
 
 static RawError* CompileFunctionHelper(const Function& function,
                                        bool optimized,
                                        intptr_t osr_id) {
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
+  LongJumpScope jump;
   // Make sure unoptimized code is not collected while we are compiling.
   const Code& unoptimized_code = Code::ZoneHandle(function.unoptimized_code());
   // Skips parsing if we need to only install unoptimized code.
   if (!optimized && !unoptimized_code.IsNull()) {
     InstallUnoptimizedCode(function);
-    isolate->set_long_jump_base(base);
     return Error::null();
   }
   if (setjmp(*jump.Set()) == 0) {
     TIMERSCOPE(time_compilation);
     Timer per_compile_timer(FLAG_trace_compiler, "Compilation time");
     per_compile_timer.Start();
     ParsedFunction* parsed_function =
         new ParsedFunction(Function::ZoneHandle(function.raw()));
     if (FLAG_trace_compiler) {
       OS::Print("Compiling %s%sfunction: '%s' @ token %" Pd ", size %" Pd "\n",
@@ skipping 13 matching lines @@
         CompileParsedFunctionHelper(parsed_function, optimized, osr_id);
     if (optimized && !success) {
       // Optimizer bailed out. Disable optimizations and to never try again.
       if (FLAG_trace_compiler) {
         OS::Print("--> disabling optimizations for '%s'\n",
                   function.ToFullyQualifiedCString());
       } else if (FLAG_trace_failed_optimization_attempts) {
         OS::Print("Cannot optimize: %s\n", function.ToFullyQualifiedCString());
       }
       function.SetIsOptimizable(false);
-      isolate->set_long_jump_base(base);
       return Error::null();
     }
 
     ASSERT(success);
     per_compile_timer.Stop();
 
     if (FLAG_trace_compiler) {
       OS::Print("--> '%s' entry: %#" Px " size: %" Pd " time: %" Pd64 " us\n",
                 function.ToFullyQualifiedCString(),
                 Code::Handle(function.CurrentCode()).EntryPoint(),
                 Code::Handle(function.CurrentCode()).Size(),
                 per_compile_timer.TotalElapsedTime());
     }
 
     isolate->debugger()->NotifyCompilation(function);
 
     if (FLAG_disassemble) {
       DisassembleCode(function, optimized);
     } else if (FLAG_disassemble_optimized && optimized) {
       // TODO(fschneider): Print unoptimized code along with the optimized code.
       OS::Print("*** BEGIN CODE\n");
       DisassembleCode(function, true);
       OS::Print("*** END CODE\n");
     }
 
-    isolate->set_long_jump_base(base);
     return Error::null();
   } else {
     Error& error = Error::Handle();
     // 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();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
 RawError* Compiler::CompileFunction(const Function& function) {
   return CompileFunctionHelper(function, false, Isolate::kNoDeoptId);
 }
 
 
 RawError* Compiler::CompileOptimizedFunction(const Function& function,
                                              intptr_t osr_id) {
   return CompileFunctionHelper(function, true, osr_id);
 }
 
 
 RawError* Compiler::CompileParsedFunction(
     ParsedFunction* parsed_function) {
   Isolate* isolate = Isolate::Current();
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
+  LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Non-optimized code generator.
     CompileParsedFunctionHelper(parsed_function, false, Isolate::kNoDeoptId);
     if (FLAG_disassemble) {
       DisassembleCode(parsed_function->function(), false);
     }
-    isolate->set_long_jump_base(base);
     return Error::null();
   } else {
     Error& error = Error::Handle();
     // 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();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
 RawError* Compiler::CompileAllFunctions(const Class& cls) {
   Error& error = Error::Handle();
   Array& functions = Array::Handle(cls.functions());
@@ skipping 32 matching lines @@
         }
       }
     }
   }
   return error.raw();
 }
 
 
 RawObject* Compiler::ExecuteOnce(SequenceNode* fragment) {
   Isolate* isolate = Isolate::Current();
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
+  LongJumpScope 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.
     // The function needs to be associated with a named Class: the interface
     // Function fits the bill.
     const char* kEvalConst = "eval_const";
@@ skipping 22 matching lines @@
     parsed_function->set_default_parameter_values(Object::null_array());
     parsed_function->EnsureExpressionTemp();
     fragment->scope()->AddVariable(parsed_function->expression_temp_var());
     parsed_function->AllocateVariables();
 
     // Non-optimized code generator.
     CompileParsedFunctionHelper(parsed_function, false, Isolate::kNoDeoptId);
 
     const Object& result = Object::Handle(
         DartEntry::InvokeFunction(func, Object::empty_array()));
-    isolate->set_long_jump_base(base);
     return result.raw();
   } else {
     const Object& result =
       Object::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
-    isolate->set_long_jump_base(base);
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart