Revert of [d8] Fix the shared-library build

src/d8.cc

Index: src/d8.cc
diff --git a/src/d8.cc b/src/d8.cc
index e0320916ebd52ed495d8b25a2614e182d765e1fe..a8af9de2d17a2b11359bc1d798a27090ba3bb598 100644
--- a/src/d8.cc
+++ b/src/d8.cc
@@ -1,15 +1,31 @@
 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+
+
+// Defined when linking against shared lib on Windows.
+#if defined(USING_V8_SHARED) && !defined(V8_SHARED)
+#define V8_SHARED
+#endif
 
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
+#ifdef V8_SHARED
+#include <assert.h>
+#endif  // V8_SHARED
+
+#ifndef V8_SHARED
 #include <algorithm>
 #include <fstream>
 #include <vector>
+#endif  // !V8_SHARED
+
+#ifdef V8_SHARED
+#include "include/v8-testing.h"
+#endif  // V8_SHARED
 
 #ifdef ENABLE_VTUNE_JIT_INTERFACE
 #include "src/third_party/vtune/v8-vtune.h"
@@ -20,6 +36,7 @@
 
 #include "include/libplatform/libplatform.h"
 #include "include/libplatform/v8-tracing.h"
+#ifndef V8_SHARED
 #include "src/api.h"
 #include "src/base/cpu.h"
 #include "src/base/debug/stack_trace.h"
@@ -31,6 +48,7 @@
 #include "src/snapshot/natives.h"
 #include "src/utils.h"
 #include "src/v8.h"
+#endif  // !V8_SHARED
 
 #if !defined(_WIN32) && !defined(_WIN64)
 #include <unistd.h>  // NOLINT
@@ -54,7 +72,9 @@
 namespace {
 
 const int MB = 1024 * 1024;
+#ifndef V8_SHARED
 const int kMaxWorkers = 50;
+#endif
 
 
 class ShellArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
@@ -82,6 +102,7 @@
 };
 
 
+#ifndef V8_SHARED
 // Predictable v8::Platform implementation. All background and foreground
 // tasks are run immediately, delayed tasks are not executed at all.
 class PredictablePlatform : public Platform {
@@ -142,6 +163,7 @@
 
   DISALLOW_COPY_AND_ASSIGN(PredictablePlatform);
 };
+#endif  // !V8_SHARED
 
 
 v8::Platform* g_platform = NULL;
@@ -154,6 +176,7 @@
 }
 
 
+#ifndef V8_SHARED
 bool FindInObjectList(Local<Object> object, const Shell::ObjectList& list) {
   for (int i = 0; i < list.length(); ++i) {
     if (list[i]->StrictEquals(object)) {
@@ -179,6 +202,7 @@
 
   return worker;
 }
+#endif  // !V8_SHARED
 
 
 }  // namespace
@@ -346,6 +370,7 @@
 };
 
 
+#ifndef V8_SHARED
 CounterMap* Shell::counter_map_;
 base::OS::MemoryMappedFile* Shell::counters_file_ = NULL;
 CounterCollection Shell::local_counters_;
@@ -358,17 +383,20 @@
 bool Shell::allow_new_workers_ = true;
 i::List<Worker*> Shell::workers_;
 i::List<SharedArrayBuffer::Contents> Shell::externalized_shared_contents_;
+#endif  // !V8_SHARED
 
 Global<Context> Shell::evaluation_context_;
 ArrayBuffer::Allocator* Shell::array_buffer_allocator;
 ShellOptions Shell::options;
 base::OnceType Shell::quit_once_ = V8_ONCE_INIT;
 
+#ifndef V8_SHARED
 bool CounterMap::Match(void* key1, void* key2) {
   const char* name1 = reinterpret_cast<const char*>(key1);
   const char* name2 = reinterpret_cast<const char*>(key2);
   return strcmp(name1, name2) == 0;
 }
+#endif  // !V8_SHARED
 
 
 // Converts a V8 value to a C string.
@@ -499,7 +527,9 @@
   }
   DCHECK(!try_catch.HasCaught());
   if (print_result) {
+#if !defined(V8_SHARED)
     if (options.test_shell) {
+#endif
       if (!result->IsUndefined()) {
         // If all went well and the result wasn't undefined then print
         // the returned value.
@@ -507,11 +537,13 @@
         fwrite(*str, sizeof(**str), str.length(), stdout);
         printf("\n");
       }
+#if !defined(V8_SHARED)
     } else {
       v8::String::Utf8Value str(Stringify(isolate, result));
       fwrite(*str, sizeof(**str), str.length(), stdout);
       printf("\n");
     }
+#endif
   }
   return true;
 }
@@ -563,6 +595,7 @@
 }
 
 
+#ifndef V8_SHARED
 // performance.now() returns a time stamp as double, measured in milliseconds.
 // When FLAG_verify_predictable mode is enabled it returns result of
 // v8::Platform::MonotonicallyIncreasingTime().
@@ -575,6 +608,7 @@
     args.GetReturnValue().Set(delta.InMillisecondsF());
   }
 }
+#endif  // !V8_SHARED
 
 
 // Realm.current() returns the index of the currently active realm.
@@ -845,6 +879,7 @@
 }
 
 
+#ifndef V8_SHARED
 void Shell::WorkerNew(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Isolate* isolate = args.GetIsolate();
   HandleScope handle_scope(isolate);
@@ -966,13 +1001,16 @@
 
   worker->Terminate();
 }
+#endif  // !V8_SHARED
 
 
 void Shell::QuitOnce(v8::FunctionCallbackInfo<v8::Value>* args) {
   int exit_code = (*args)[0]
                       ->Int32Value(args->GetIsolate()->GetCurrentContext())
                       .FromMaybe(0);
+#ifndef V8_SHARED
   CleanupWorkers();
+#endif  // !V8_SHARED
   OnExit(args->GetIsolate());
   Exit(exit_code);
 }
@@ -993,12 +1031,14 @@
 
 void Shell::ReportException(Isolate* isolate, v8::TryCatch* try_catch) {
   HandleScope handle_scope(isolate);
+#ifndef V8_SHARED
   Local<Context> context;
   bool enter_context = !isolate->InContext();
   if (enter_context) {
     context = Local<Context>::New(isolate, evaluation_context_);
     context->Enter();
   }
+#endif  // !V8_SHARED
   v8::String::Utf8Value exception(try_catch->Exception());
   const char* exception_string = ToCString(exception);
   Local<Message> message = try_catch->Message();
@@ -1042,10 +1082,13 @@
     }
   }
   printf("\n");
+#ifndef V8_SHARED
   if (enter_context) context->Exit();
-}
-
-
+#endif  // !V8_SHARED
+}
+
+
+#ifndef V8_SHARED
 int32_t* Counter::Bind(const char* name, bool is_histogram) {
   int i;
   for (i = 0; i < kMaxNameSize - 1 && name[i]; i++)
@@ -1174,6 +1217,7 @@
   if (result.IsEmpty()) return String::Empty(isolate);
   return result.ToLocalChecked().As<String>();
 }
+#endif  // !V8_SHARED
 
 
 Local<ObjectTemplate> Shell::CreateGlobalTemplate(Isolate* isolate) {
@@ -1264,6 +1308,7 @@
           .ToLocalChecked(),
       realm_template);
 
+#ifndef V8_SHARED
   Local<ObjectTemplate> performance_template = ObjectTemplate::New(isolate);
   performance_template->Set(
       String::NewFromUtf8(isolate, "now", NewStringType::kNormal)
@@ -1302,6 +1347,7 @@
       String::NewFromUtf8(isolate, "Worker", NewStringType::kNormal)
           .ToLocalChecked(),
       worker_fun_template);
+#endif  // !V8_SHARED
 
   Local<ObjectTemplate> os_templ = ObjectTemplate::New(isolate);
   AddOSMethods(isolate, os_templ);
@@ -1319,17 +1365,21 @@
 }
 
 void Shell::Initialize(Isolate* isolate) {
+#ifndef V8_SHARED
   // Set up counters
   if (i::StrLength(i::FLAG_map_counters) != 0)
     MapCounters(isolate, i::FLAG_map_counters);
+#endif  // !V8_SHARED
   // Disable default message reporting.
   isolate->AddMessageListener(EmptyMessageCallback);
 }
 
 
 Local<Context> Shell::CreateEvaluationContext(Isolate* isolate) {
+#ifndef V8_SHARED
   // This needs to be a critical section since this is not thread-safe
   base::LockGuard<base::Mutex> lock_guard(context_mutex_.Pointer());
+#endif  // !V8_SHARED
   // Initialize the global objects
   Local<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
   EscapableHandleScope handle_scope(isolate);
@@ -1337,6 +1387,7 @@
   DCHECK(!context.IsEmpty());
   Context::Scope scope(context);
 
+#ifndef V8_SHARED
   i::Factory* factory = reinterpret_cast<i::Isolate*>(isolate)->factory();
   i::JSArguments js_args = i::FLAG_js_arguments;
   i::Handle<i::FixedArray> arguments_array =
@@ -1354,6 +1405,7 @@
                 .ToLocalChecked(),
             Utils::ToLocal(arguments_jsarray))
       .FromJust();
+#endif  // !V8_SHARED
   return handle_scope.Escape(context);
 }
 
@@ -1367,6 +1419,7 @@
 }
 
 
+#ifndef V8_SHARED
 struct CounterAndKey {
   Counter* counter;
   const char* key;
@@ -1391,8 +1444,11 @@
       JSON::Stringify(context, dispatch_counters).ToLocalChecked());
 }
 
+#endif  // !V8_SHARED
+
 
 void Shell::OnExit(v8::Isolate* isolate) {
+#ifndef V8_SHARED
   if (i::FLAG_dump_counters) {
     int number_of_counters = 0;
     for (CounterMap::Iterator i(counter_map_); i.More(); i.Next()) {
@@ -1428,6 +1484,7 @@
 
   delete counters_file_;
   delete counter_map_;
+#endif  // !V8_SHARED
 }
 
 
@@ -1561,8 +1618,10 @@
 
 
 SourceGroup::~SourceGroup() {
+#ifndef V8_SHARED
   delete thread_;
   thread_ = NULL;
+#endif  // !V8_SHARED
 }
 
 
@@ -1631,6 +1690,7 @@
 }
 
 
+#ifndef V8_SHARED
 base::Thread::Options SourceGroup::GetThreadOptions() {
   // 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.
@@ -1954,6 +2014,7 @@
     delete data;
   }
 }
+#endif  // !V8_SHARED
 
 
 void SetFlagsFromString(const char* flags) {
@@ -2009,16 +2070,30 @@
       // JavaScript engines.
       continue;
     } else if (strcmp(argv[i], "--isolate") == 0) {
+#ifdef V8_SHARED
+      printf("D8 with shared library does not support multi-threading\n");
+      return false;
+#endif  // V8_SHARED
       options.num_isolates++;
     } else if (strcmp(argv[i], "--dump-heap-constants") == 0) {
+#ifdef V8_SHARED
+      printf("D8 with shared library does not support constant dumping\n");
+      return false;
+#else
       options.dump_heap_constants = true;
       argv[i] = NULL;
+#endif  // V8_SHARED
     } else if (strcmp(argv[i], "--throws") == 0) {
       options.expected_to_throw = true;
       argv[i] = NULL;
     } else if (strncmp(argv[i], "--icu-data-file=", 16) == 0) {
       options.icu_data_file = argv[i] + 16;
       argv[i] = NULL;
+#ifdef V8_SHARED
+    } else if (strcmp(argv[i], "--dump-counters") == 0) {
+      printf("D8 with shared library does not include counters\n");
+      return false;
+#endif  // V8_SHARED
 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
     } else if (strncmp(argv[i], "--natives_blob=", 15) == 0) {
       options.natives_blob = argv[i] + 15;
@@ -2084,9 +2159,11 @@
 
 
 int Shell::RunMain(Isolate* isolate, int argc, char* argv[], bool last_run) {
+#ifndef V8_SHARED
   for (int i = 1; i < options.num_isolates; ++i) {
     options.isolate_sources[i].StartExecuteInThread();
   }
+#endif  // !V8_SHARED
   {
     HandleScope scope(isolate);
     Local<Context> context = CreateEvaluationContext(isolate);
@@ -2101,6 +2178,7 @@
     }
   }
   CollectGarbage(isolate);
+#ifndef V8_SHARED
   for (int i = 1; i < options.num_isolates; ++i) {
     if (last_run) {
       options.isolate_sources[i].JoinThread();
@@ -2109,6 +2187,7 @@
     }
   }
   CleanupWorkers();
+#endif  // !V8_SHARED
   return 0;
 }
 
@@ -2130,12 +2209,17 @@
 
 
 void Shell::EmptyMessageQueues(Isolate* isolate) {
+#ifndef V8_SHARED
   if (!i::FLAG_verify_predictable) {
+#endif
     while (v8::platform::PumpMessageLoop(g_platform, isolate)) continue;
-  }
-}
-
-
+#ifndef V8_SHARED
+  }
+#endif
+}
+
+
+#ifndef V8_SHARED
 bool Shell::SerializeValue(Isolate* isolate, Local<Value> value,
                            const ObjectList& to_transfer,
                            ObjectList* seen_objects,
@@ -2450,11 +2534,14 @@
   printf("}\n");
 #undef ROOT_LIST_CASE
 }
+#endif  // !V8_SHARED
 
 
 int Shell::Main(int argc, char* argv[]) {
   std::ofstream trace_file;
+#ifndef V8_SHARED
   v8::base::debug::EnableInProcessStackDumping();
+#endif
 #if (defined(_WIN32) || defined(_WIN64))
   UINT new_flags =
       SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX;
@@ -2472,9 +2559,13 @@
 #endif  // defined(_WIN32) || defined(_WIN64)
   if (!SetOptions(argc, argv)) return 1;
   v8::V8::InitializeICUDefaultLocation(argv[0], options.icu_data_file);
+#ifndef V8_SHARED
   g_platform = i::FLAG_verify_predictable
                    ? new PredictablePlatform()
                    : v8::platform::CreateDefaultPlatform();
+#else
+  g_platform = v8::platform::CreateDefaultPlatform();
+#endif  // !V8_SHARED
 
   v8::V8::InitializePlatform(g_platform);
   v8::V8::Initialize();
@@ -2500,6 +2591,7 @@
 #ifdef ENABLE_VTUNE_JIT_INTERFACE
   create_params.code_event_handler = vTune::GetVtuneCodeEventHandler();
 #endif
+#ifndef V8_SHARED
   create_params.constraints.ConfigureDefaults(
       base::SysInfo::AmountOfPhysicalMemory(),
       base::SysInfo::AmountOfVirtualMemory());
@@ -2510,6 +2602,7 @@
     create_params.create_histogram_callback = CreateHistogram;
     create_params.add_histogram_sample_callback = AddHistogramSample;
   }
+#endif
   Isolate* isolate = Isolate::New(create_params);
   {
     Isolate::Scope scope(isolate);
@@ -2539,15 +2632,21 @@
       }
       tracing_controller->Initialize(trace_buffer);
       tracing_controller->StartTracing(trace_config);
+#ifndef V8_SHARED
       if (!i::FLAG_verify_predictable) {
         platform::SetTracingController(g_platform, tracing_controller);
       }
-    }
-
+#else
+      platform::SetTracingController(g_platform, tracing_controller);
+#endif
+    }
+
+#ifndef V8_SHARED
     if (options.dump_heap_constants) {
       DumpHeapConstants(reinterpret_cast<i::Isolate*>(isolate));
       return 0;
     }
+#endif
 
     if (options.stress_opt || options.stress_deopt) {
       Testing::SetStressRunType(options.stress_opt
@@ -2563,6 +2662,7 @@
       }
       printf("======== Full Deoptimization =======\n");
       Testing::DeoptimizeAll(isolate);
+#if !defined(V8_SHARED)
     } else if (i::FLAG_stress_runs > 0) {
       options.stress_runs = i::FLAG_stress_runs;
       for (int i = 0; i < options.stress_runs && result == 0; i++) {
@@ -2571,6 +2671,7 @@
         bool last_run = i == options.stress_runs - 1;
         result = RunMain(isolate, argc, argv, last_run);
       }
+#endif
     } else {
       bool last_run = true;
       result = RunMain(isolate, argc, argv, last_run);
@@ -2582,23 +2683,29 @@
       RunShell(isolate);
     }
 
+#ifndef V8_SHARED
     if (i::FLAG_ignition && i::FLAG_trace_ignition_dispatches &&
         i::FLAG_trace_ignition_dispatches_output_file != nullptr) {
       WriteIgnitionDispatchCountersFile(isolate);
     }
+#endif
 
     // Shut down contexts and collect garbage.
     evaluation_context_.Reset();
+#ifndef V8_SHARED
     stringify_function_.Reset();
+#endif  // !V8_SHARED
     CollectGarbage(isolate);
   }
   OnExit(isolate);
+#ifndef V8_SHARED
   // Dump basic block profiling data.
   if (i::BasicBlockProfiler* profiler =
           reinterpret_cast<i::Isolate*>(isolate)->basic_block_profiler()) {
     i::OFStream os(stdout);
     os << *profiler;
   }
+#endif  // !V8_SHARED
   isolate->Dispose();
   V8::Dispose();
   V8::ShutdownPlatform();