* Make stack/preemption guard faster on ARM by putting stack...

src/execution.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 216 matching lines @@
     // they indicate a pending interruption. The interrupt limit will be
     // temporarily reset through the code below and reestablished if the
     // interrupt flags indicate that an interrupt is pending.
     ASSERT(thread_local_.jslimit_ == kIllegalLimit ||
            (thread_local_.jslimit_ == kInterruptLimit &&
             thread_local_.interrupt_flags_ != 0));
     ASSERT(thread_local_.climit_ == kIllegalLimit ||
            (thread_local_.climit_ == kInterruptLimit &&
             thread_local_.interrupt_flags_ != 0));
 
-    thread_local_.initial_jslimit_ = thread_local_.jslimit_ =
-        GENERATED_CODE_STACK_LIMIT(kLimitSize);
+    uintptr_t limit = GENERATED_CODE_STACK_LIMIT(kLimitSize);
+    thread_local_.initial_jslimit_ = thread_local_.jslimit_ = limit;
+    Heap::SetStackLimit(limit);
     // NOTE: The check for overflow is not safe as there is no guarantee that
     // the running thread has its stack in all memory up to address 0x00000000.
     thread_local_.initial_climit_ = thread_local_.climit_ =
         reinterpret_cast<uintptr_t>(this) >= kLimitSize ?
             reinterpret_cast<uintptr_t>(this) - kLimitSize : 0;
 
     if (thread_local_.interrupt_flags_ != 0) {
       set_limits(kInterruptLimit, access);
     }
   }
@@ skipping 27 matching lines @@
   }
 }
 
 
 void StackGuard::SetStackLimit(uintptr_t limit) {
   ExecutionAccess access;
   // If the current limits are special (eg due to a pending interrupt) then
   // leave them alone.
   if (thread_local_.jslimit_ == thread_local_.initial_jslimit_) {
     thread_local_.jslimit_ = limit;
+    Heap::SetStackLimit(limit);
   }
   if (thread_local_.climit_ == thread_local_.initial_climit_) {
     thread_local_.climit_ = limit;
   }
   thread_local_.initial_climit_ = limit;
   thread_local_.initial_jslimit_ = limit;
 }
 
 
 void StackGuard::DisableInterrupts() {
@@ skipping 94 matching lines @@
   memcpy(to, reinterpret_cast<char*>(&thread_local_), sizeof(ThreadLocal));
   ThreadLocal blank;
   thread_local_ = blank;
   return to + sizeof(ThreadLocal);
 }
 
 
 char* StackGuard::RestoreStackGuard(char* from) {
   ExecutionAccess access;
   memcpy(reinterpret_cast<char*>(&thread_local_), from, sizeof(ThreadLocal));
+  Heap::SetStackLimit(thread_local_.jslimit_);
   return from + sizeof(ThreadLocal);
 }
 
 
 // --- C a l l s   t o   n a t i v e s ---
 
 #define RETURN_NATIVE_CALL(name, argc, argv, has_pending_exception) \
   do {                                                              \
     Object** args[argc] = argv;                                     \
     ASSERT(has_pending_exception != NULL);                          \
@@ skipping 269 matching lines @@
   // All allocation spaces other than NEW_SPACE have the same effect.
   Heap::CollectAllGarbage(false);
   return v8::Undefined();
 }
 
 
 static GCExtension kGCExtension;
 v8::DeclareExtension kGCExtensionDeclaration(&kGCExtension);
 
 } }  // namespace v8::internal