[Isolates] Use _exit() instead of exit() in shell to avoid shutdown

samples/shell.cc

 // Copyright 2009 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 23 matching lines @@
 #include <stdlib.h>
 
 #include "../src/v8.h"
 
 // TODO(isolates):
 //   o Either use V8 internal platform stuff for every platform or
 //     re-implement it.
 //   o Do not assume not WIN32 implies pthreads.
 #ifndef WIN32
 #include <pthread.h>  // NOLINT
+#include <unistd.h>  // NOLINT
 #endif
 
+static void ExitShell(int exit_code) {
+  // Use _exit instead of exit to avoid races between isolate
+  // threads and static destructors.
+  fflush(stdout);
+  fflush(stderr);
+  _exit(exit_code);
+}
+
 v8::Persistent<v8::Context> CreateShellContext();
 void RunShell(v8::Handle<v8::Context> context);
 bool ExecuteString(v8::Handle<v8::String> source,
                    v8::Handle<v8::Value> name,
                    bool print_result,
                    bool report_exceptions);
 v8::Handle<v8::Value> Print(const v8::Arguments& args);
 v8::Handle<v8::Value> Read(const v8::Arguments& args);
 v8::Handle<v8::Value> Load(const v8::Arguments& args);
 v8::Handle<v8::Value> Quit(const v8::Arguments& args);
@@ skipping 31 matching lines @@
 
   void Execute() {
     for (int i = begin_offset_; i < end_offset_; ++i) {
       const char* arg = argv_[i];
       if (strcmp(arg, "-e") == 0 && i + 1 < end_offset_) {
         // Execute argument given to -e option directly.
         v8::HandleScope handle_scope;
         v8::Handle<v8::String> file_name = v8::String::New("unnamed");
         v8::Handle<v8::String> source = v8::String::New(argv_[i + 1]);
         if (!ExecuteString(source, file_name, false, true)) {
-          exit(1);
+          ExitShell(1);
           return;
         }
         ++i;
       } else if (arg[0] == '-') {
         // Ignore other options. They have been parsed already.
       } else {
         // Use all other arguments as names of files to load and run.
         v8::HandleScope handle_scope;
         v8::Handle<v8::String> file_name = v8::String::New(arg);
         v8::Handle<v8::String> source = ReadFile(arg);
         if (source.IsEmpty()) {
           printf("Error reading '%s'\n", arg);
         }
         if (!ExecuteString(source, file_name, false, true)) {
-          exit(1);
+          ExitShell(1);
           return;
         }
       }
     }
   }
 
 #ifdef WIN32
   void StartExecuteInThread() { ExecuteInThread(); }
   void WaitForThread() {}
 
 #else
   void StartExecuteInThread() {
     if (thread_ == 0) {
       pthread_attr_t attr;
       // On some systems (OSX 10.6) the stack size default is 0.5Mb or less
       // which is not enough to parse the big literal expressions used in tests.
       // The stack size should be at least StackGuard::kLimitSize + some
       // OS-specific padding for thread startup code.
       size_t stacksize = 2 << 20;  // 2 Mb seems to be enough
       pthread_attr_init(&attr);
       pthread_attr_setstacksize(&attr, stacksize);
       int error = pthread_create(&thread_, &attr, &IsolateThreadEntry, this);
       if (error != 0) {
-        printf("Error creating isolate thread.\n");
-        exit(1);
+        fprintf(stderr, "Error creating isolate thread.\n");
+        ExitShell(1);
       }
     }
     next_semaphore_->Signal();
   }
 
   void WaitForThread() {
     if (thread_ == 0) return;
     if (last_run) {
       pthread_join(thread_, NULL);
       thread_ = 0;
@@ skipping 227 matching lines @@
   return v8::Undefined();
 }
 
 
 // The callback that is invoked by v8 whenever the JavaScript 'quit'
 // function is called.  Quits.
 v8::Handle<v8::Value> Quit(const v8::Arguments& args) {
   // If not arguments are given args[0] will yield undefined which
   // converts to the integer value 0.
   int exit_code = args[0]->Int32Value();
-  exit(exit_code);
+  ExitShell(exit_code);
   return v8::Undefined();
 }
 
 
 v8::Handle<v8::Value> Version(const v8::Arguments& args) {
   return v8::String::New(v8::V8::GetVersion());
 }
 
 
 // Reads a file into a v8 string.
@@ skipping 104 matching lines @@
       printf("^");
     }
     printf("\n");
     v8::String::Utf8Value stack_trace(try_catch->StackTrace());
     if (stack_trace.length() > 0) {
       const char* stack_trace_string = ToCString(stack_trace);
       printf("%s\n", stack_trace_string);
     }
   }
 }