Add support for interrupting an isolate in the vm. Interrupts are

runtime/vm/code_generator_ia32.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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 192 matching lines @@
   if (FLAG_print_scopes && FLAG_print_ast) {
     // Print the function scope before code generation.
     AstPrinter::PrintFunctionScope(parsed_function_);
   }
   if (FLAG_print_ast) {
     // Print the function ast before code generation.
     AstPrinter::PrintFunctionNodes(parsed_function_);
   }
   if (FLAG_trace_functions) {
     // Preserve ECX (ic-data array or object) and EDX (arguments descriptor).
+    __ nop(2);  // Make sure the code is patchable.
     __ pushl(ECX);
     __ pushl(EDX);
     const Function& function =
         Function::ZoneHandle(parsed_function_.function().raw());
     __ LoadObject(EAX, function);
     __ pushl(EAX);
     GenerateCallRuntime(AstNode::kNoId,
                         0,
                         kTraceFunctionEntryRuntimeEntry);
     __ popl(EAX);
@@ skipping 41 matching lines @@
 
 // Pre entry code is called before the frame has been constructed:
 // - check for stack overflow.
 // - optionally count function invocations.
 // - optionally trigger optimizing compiler if invocation threshold has been
 //   reached.
 // Note that first 5 bytes may be patched with a jump.
 // TODO(srdjan): Add check that no object is inlined in the first
 // 5 bytes (length of a jump instruction).
 void CodeGenerator::GeneratePreEntryCode() {
-  // Stack overflow check.
-  __ cmpl(ESP,
-      Address::Absolute(Isolate::Current()->stack_limit_address()));
-  __ j(BELOW_EQUAL, &StubCode::StackOverflowLabel());
   // Do not optimize if:
   // - we count invocations.
   // - optimization disabled via negative 'optimization_invocation_threshold;
   // - function is marked as non-optimizable.
   // - type checks are enabled.
   const bool may_optimize =
       !FLAG_report_invocation_count &&
       (FLAG_optimization_invocation_threshold >= 0) &&
       !Isolate::Current()->debugger()->IsActive() &&
       parsed_function_.function().is_optimizable();
   // Count invocation and check.
   if (FLAG_report_invocation_count || may_optimize) {
+    // TODO(turnidge): It would be nice to remove this nop.  Right now
+    // we need it to make sure the function is still patchable.
+    __ nop(5);
     const Function& function =
         Function::ZoneHandle(parsed_function_.function().raw());
     __ LoadObject(EAX, function);
     __ movl(EBX, FieldAddress(EAX, Function::invocation_counter_offset()));
     __ incl(EBX);
     if (may_optimize) {
       __ cmpl(EBX, Immediate(FLAG_optimization_invocation_threshold));
       __ j(GREATER, &StubCode::OptimizeInvokedFunctionLabel());
     }
     __ movl(FieldAddress(EAX, Function::invocation_counter_offset()), EBX);
@@ skipping 419 matching lines @@
   // Initialize locals.
   // TODO(regis): For now, always unroll the init loop. Decide later above
   // which threshold to implement a loop.
   // Consider emitting pushes instead of moves.
   for (int index = first_local_index; index > first_free_frame_index; index--) {
     if (index == first_local_index) {
       __ movl(EAX, raw_null);
     }
     __ movl(Address(EBP, index * kWordSize), EAX);
   }
+
+  // Generate stack overflow check.
+  __ cmpl(ESP,
+          Address::Absolute(Isolate::Current()->stack_limit_address()));
+  Label no_stack_overflow;
+  __ j(ABOVE, &no_stack_overflow);
+  GenerateCallRuntime(AstNode::kNoId,
+                      function.token_index(),
+                      kStackOverflowRuntimeEntry);
+  __ Bind(&no_stack_overflow);
 }
 
 
 void CodeGenerator::GenerateReturnEpilog() {
   // Unchain the context(s) up to context level 0.
   int context_level = state()->context_level();
   ASSERT(context_level >= 0);
   while (context_level-- > 0) {
     __ movl(CTX, FieldAddress(CTX, Context::parent_offset()));
   }
@@ skipping 2033 matching lines @@
                         message_buffer, kMessageBufferSize,
                         format, args);
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32