[d8] Fix the shared-library build
This commit ensures that the d8 shared library build uses the same logic as the standard static build by exporting relevant functions and classes. BUG=chromium:646337 Review-Url: https://codereview.chromium.org/2342563002 Cr-Commit-Position: refs/heads/master@{#39503}
This commit is contained in:
jgruber
Commit bot
parent
48faea070f
commit
2c10ca8086
14
BUILD.gn
14
BUILD.gn
@ -115,10 +115,7 @@ config("internal_config") {
|
||||
include_dirs = [ "." ]
|
||||
|
||||
if (is_component_build) {
|
||||
defines = [
|
||||
"V8_SHARED",
|
||||
"BUILDING_V8_SHARED",
|
||||
]
|
||||
defines = [ "BUILDING_V8_SHARED" ]
|
||||
}
|
||||
}
|
||||
|
||||
@ -142,10 +139,7 @@ config("libsampler_config") {
|
||||
# itself.
|
||||
config("external_config") {
|
||||
if (is_component_build) {
|
||||
defines = [
|
||||
"V8_SHARED",
|
||||
"USING_V8_SHARED",
|
||||
]
|
||||
defines = [ "USING_V8_SHARED" ]
|
||||
}
|
||||
include_dirs = [ "include" ]
|
||||
if (v8_enable_inspector_override) {
|
||||
@ -2389,6 +2383,7 @@ if (is_component_build) {
|
||||
|
||||
v8_executable("d8") {
|
||||
sources = [
|
||||
"$target_gen_dir/d8-js.cc",
|
||||
"src/d8.cc",
|
||||
"src/d8.h",
|
||||
]
|
||||
@ -2416,9 +2411,6 @@ v8_executable("d8") {
|
||||
sources += [ "src/d8-windows.cc" ]
|
||||
}
|
||||
|
||||
if (!is_component_build) {
|
||||
sources += [ "$target_gen_dir/d8-js.cc" ]
|
||||
}
|
||||
if (v8_enable_i18n_support) {
|
||||
deps += [ "//third_party/icu" ]
|
||||
}
|
||||
|
||||
@ -51,7 +51,7 @@
|
||||
#else // V8_OS_WIN
|
||||
|
||||
// Setup for Linux shared library export.
|
||||
#if V8_HAS_ATTRIBUTE_VISIBILITY && defined(V8_SHARED)
|
||||
#if V8_HAS_ATTRIBUTE_VISIBILITY
|
||||
# ifdef BUILDING_V8_SHARED
|
||||
# define V8_EXPORT __attribute__ ((visibility("default")))
|
||||
# else
|
||||
|
||||
@ -13,10 +13,10 @@ namespace internal {
|
||||
// Called when allocation routines fail to allocate.
|
||||
// This function should not return, but should terminate the current
|
||||
// processing.
|
||||
void FatalProcessOutOfMemory(const char* message);
|
||||
V8_EXPORT_PRIVATE void FatalProcessOutOfMemory(const char* message);
|
||||
|
||||
// Superclass for classes managed with new & delete.
|
||||
class Malloced {
|
||||
class V8_EXPORT_PRIVATE Malloced {
|
||||
public:
|
||||
void* operator new(size_t size) { return New(size); }
|
||||
void operator delete(void* p) { Delete(p); }
|
||||
@ -72,7 +72,7 @@ void DeleteArray(T* array) {
|
||||
// The normal strdup functions use malloc. These versions of StrDup
|
||||
// and StrNDup uses new and calls the FatalProcessOutOfMemory handler
|
||||
// if allocation fails.
|
||||
char* StrDup(const char* str);
|
||||
V8_EXPORT_PRIVATE char* StrDup(const char* str);
|
||||
char* StrNDup(const char* str, int n);
|
||||
|
||||
|
||||
|
||||
@ -11,6 +11,7 @@
|
||||
#include <vector>
|
||||
|
||||
#include "src/base/macros.h"
|
||||
#include "src/globals.h"
|
||||
|
||||
namespace v8 {
|
||||
namespace internal {
|
||||
@ -58,15 +59,16 @@ class BasicBlockProfiler {
|
||||
const DataList* data_list() { return &data_list_; }
|
||||
|
||||
private:
|
||||
friend std::ostream& operator<<(std::ostream& os,
|
||||
const BasicBlockProfiler& s);
|
||||
friend V8_EXPORT_PRIVATE std::ostream& operator<<(
|
||||
std::ostream& os, const BasicBlockProfiler& s);
|
||||
|
||||
DataList data_list_;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(BasicBlockProfiler);
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const BasicBlockProfiler& s);
|
||||
V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
|
||||
const BasicBlockProfiler& s);
|
||||
std::ostream& operator<<(std::ostream& os, const BasicBlockProfiler::Data& s);
|
||||
|
||||
} // namespace internal
|
||||
|
||||
107
src/d8.cc
107
src/d8.cc
@ -2,30 +2,14 @@
|
||||
// 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"
|
||||
@ -36,7 +20,6 @@
|
||||
|
||||
#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"
|
||||
@ -48,7 +31,6 @@
|
||||
#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
|
||||
@ -72,9 +54,7 @@ namespace v8 {
|
||||
namespace {
|
||||
|
||||
const int MB = 1024 * 1024;
|
||||
#ifndef V8_SHARED
|
||||
const int kMaxWorkers = 50;
|
||||
#endif
|
||||
|
||||
|
||||
class ShellArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
|
||||
@ -102,7 +82,6 @@ class MockArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
|
||||
};
|
||||
|
||||
|
||||
#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 {
|
||||
@ -163,7 +142,6 @@ class PredictablePlatform : public Platform {
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(PredictablePlatform);
|
||||
};
|
||||
#endif // !V8_SHARED
|
||||
|
||||
|
||||
v8::Platform* g_platform = NULL;
|
||||
@ -176,7 +154,6 @@ static Local<Value> Throw(Isolate* isolate, const char* message) {
|
||||
}
|
||||
|
||||
|
||||
#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)) {
|
||||
@ -202,7 +179,6 @@ Worker* GetWorkerFromInternalField(Isolate* isolate, Local<Object> object) {
|
||||
|
||||
return worker;
|
||||
}
|
||||
#endif // !V8_SHARED
|
||||
|
||||
|
||||
} // namespace
|
||||
@ -370,7 +346,6 @@ class PerIsolateData {
|
||||
};
|
||||
|
||||
|
||||
#ifndef V8_SHARED
|
||||
CounterMap* Shell::counter_map_;
|
||||
base::OS::MemoryMappedFile* Shell::counters_file_ = NULL;
|
||||
CounterCollection Shell::local_counters_;
|
||||
@ -383,20 +358,17 @@ base::LazyMutex Shell::workers_mutex_;
|
||||
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.
|
||||
@ -537,9 +509,7 @@ bool Shell::ExecuteString(Isolate* isolate, Local<String> source,
|
||||
}
|
||||
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.
|
||||
@ -547,13 +517,11 @@ bool Shell::ExecuteString(Isolate* isolate, Local<String> source,
|
||||
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;
|
||||
}
|
||||
@ -605,7 +573,6 @@ int PerIsolateData::RealmIndexOrThrow(
|
||||
}
|
||||
|
||||
|
||||
#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().
|
||||
@ -618,7 +585,6 @@ void Shell::PerformanceNow(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
||||
args.GetReturnValue().Set(delta.InMillisecondsF());
|
||||
}
|
||||
}
|
||||
#endif // !V8_SHARED
|
||||
|
||||
|
||||
// Realm.current() returns the index of the currently active realm.
|
||||
@ -889,7 +855,6 @@ void Shell::Load(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
||||
}
|
||||
|
||||
|
||||
#ifndef V8_SHARED
|
||||
void Shell::WorkerNew(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
||||
Isolate* isolate = args.GetIsolate();
|
||||
HandleScope handle_scope(isolate);
|
||||
@ -1011,16 +976,13 @@ void Shell::WorkerTerminate(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
||||
|
||||
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);
|
||||
}
|
||||
@ -1041,14 +1003,12 @@ void Shell::Version(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
||||
|
||||
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();
|
||||
@ -1092,13 +1052,10 @@ void Shell::ReportException(Isolate* isolate, v8::TryCatch* try_catch) {
|
||||
}
|
||||
}
|
||||
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++)
|
||||
@ -1227,7 +1184,6 @@ Local<String> Shell::Stringify(Isolate* isolate, Local<Value> value) {
|
||||
if (result.IsEmpty()) return String::Empty(isolate);
|
||||
return result.ToLocalChecked().As<String>();
|
||||
}
|
||||
#endif // !V8_SHARED
|
||||
|
||||
|
||||
Local<ObjectTemplate> Shell::CreateGlobalTemplate(Isolate* isolate) {
|
||||
@ -1318,7 +1274,6 @@ Local<ObjectTemplate> Shell::CreateGlobalTemplate(Isolate* isolate) {
|
||||
.ToLocalChecked(),
|
||||
realm_template);
|
||||
|
||||
#ifndef V8_SHARED
|
||||
Local<ObjectTemplate> performance_template = ObjectTemplate::New(isolate);
|
||||
performance_template->Set(
|
||||
String::NewFromUtf8(isolate, "now", NewStringType::kNormal)
|
||||
@ -1357,7 +1312,6 @@ Local<ObjectTemplate> Shell::CreateGlobalTemplate(Isolate* isolate) {
|
||||
String::NewFromUtf8(isolate, "Worker", NewStringType::kNormal)
|
||||
.ToLocalChecked(),
|
||||
worker_fun_template);
|
||||
#endif // !V8_SHARED
|
||||
|
||||
Local<ObjectTemplate> os_templ = ObjectTemplate::New(isolate);
|
||||
AddOSMethods(isolate, os_templ);
|
||||
@ -1375,21 +1329,17 @@ static void EmptyMessageCallback(Local<Message> message, Local<Value> error) {
|
||||
}
|
||||
|
||||
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);
|
||||
@ -1397,7 +1347,6 @@ Local<Context> Shell::CreateEvaluationContext(Isolate* isolate) {
|
||||
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 =
|
||||
@ -1415,7 +1364,6 @@ Local<Context> Shell::CreateEvaluationContext(Isolate* isolate) {
|
||||
.ToLocalChecked(),
|
||||
Utils::ToLocal(arguments_jsarray))
|
||||
.FromJust();
|
||||
#endif // !V8_SHARED
|
||||
return handle_scope.Escape(context);
|
||||
}
|
||||
|
||||
@ -1429,7 +1377,6 @@ void Shell::Exit(int exit_code) {
|
||||
}
|
||||
|
||||
|
||||
#ifndef V8_SHARED
|
||||
struct CounterAndKey {
|
||||
Counter* counter;
|
||||
const char* key;
|
||||
@ -1454,11 +1401,8 @@ void Shell::WriteIgnitionDispatchCountersFile(v8::Isolate* isolate) {
|
||||
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()) {
|
||||
@ -1494,7 +1438,6 @@ void Shell::OnExit(v8::Isolate* isolate) {
|
||||
|
||||
delete counters_file_;
|
||||
delete counter_map_;
|
||||
#endif // !V8_SHARED
|
||||
}
|
||||
|
||||
|
||||
@ -1628,10 +1571,8 @@ void Shell::RunShell(Isolate* isolate) {
|
||||
|
||||
|
||||
SourceGroup::~SourceGroup() {
|
||||
#ifndef V8_SHARED
|
||||
delete thread_;
|
||||
thread_ = NULL;
|
||||
#endif // !V8_SHARED
|
||||
}
|
||||
|
||||
|
||||
@ -1700,7 +1641,6 @@ Local<String> SourceGroup::ReadFile(Isolate* isolate, const char* name) {
|
||||
}
|
||||
|
||||
|
||||
#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.
|
||||
@ -2024,7 +1964,6 @@ void Worker::PostMessageOut(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
||||
delete data;
|
||||
}
|
||||
}
|
||||
#endif // !V8_SHARED
|
||||
|
||||
|
||||
void SetFlagsFromString(const char* flags) {
|
||||
@ -2080,30 +2019,16 @@ bool Shell::SetOptions(int argc, char* argv[]) {
|
||||
// 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;
|
||||
@ -2169,11 +2094,9 @@ bool Shell::SetOptions(int argc, char* argv[]) {
|
||||
|
||||
|
||||
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);
|
||||
@ -2188,7 +2111,6 @@ int Shell::RunMain(Isolate* isolate, int argc, char* argv[], bool last_run) {
|
||||
}
|
||||
}
|
||||
CollectGarbage(isolate);
|
||||
#ifndef V8_SHARED
|
||||
for (int i = 1; i < options.num_isolates; ++i) {
|
||||
if (last_run) {
|
||||
options.isolate_sources[i].JoinThread();
|
||||
@ -2197,7 +2119,6 @@ int Shell::RunMain(Isolate* isolate, int argc, char* argv[], bool last_run) {
|
||||
}
|
||||
}
|
||||
CleanupWorkers();
|
||||
#endif // !V8_SHARED
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -2219,17 +2140,12 @@ void Shell::CollectGarbage(Isolate* isolate) {
|
||||
|
||||
|
||||
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,
|
||||
@ -2544,14 +2460,11 @@ static void DumpHeapConstants(i::Isolate* isolate) {
|
||||
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;
|
||||
@ -2569,13 +2482,9 @@ int Shell::Main(int argc, char* argv[]) {
|
||||
#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();
|
||||
@ -2601,7 +2510,6 @@ int Shell::Main(int argc, char* argv[]) {
|
||||
#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());
|
||||
@ -2612,7 +2520,6 @@ int Shell::Main(int argc, char* argv[]) {
|
||||
create_params.create_histogram_callback = CreateHistogram;
|
||||
create_params.add_histogram_sample_callback = AddHistogramSample;
|
||||
}
|
||||
#endif
|
||||
Isolate* isolate = Isolate::New(create_params);
|
||||
{
|
||||
Isolate::Scope scope(isolate);
|
||||
@ -2642,21 +2549,15 @@ int Shell::Main(int argc, char* argv[]) {
|
||||
}
|
||||
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
|
||||
@ -2672,7 +2573,6 @@ int Shell::Main(int argc, char* argv[]) {
|
||||
}
|
||||
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++) {
|
||||
@ -2681,7 +2581,6 @@ int Shell::Main(int argc, char* argv[]) {
|
||||
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);
|
||||
@ -2693,29 +2592,23 @@ int Shell::Main(int argc, char* argv[]) {
|
||||
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();
|
||||
|
||||
20
src/d8.gyp
20
src/d8.gyp
@ -49,10 +49,18 @@
|
||||
'sources': [
|
||||
'd8.h',
|
||||
'd8.cc',
|
||||
'<(SHARED_INTERMEDIATE_DIR)/d8-js.cc',
|
||||
],
|
||||
'conditions': [
|
||||
[ 'want_separate_host_toolset==1', {
|
||||
'toolsets': [ 'target', ],
|
||||
'dependencies': [
|
||||
'd8_js2c#host',
|
||||
],
|
||||
}, {
|
||||
'dependencies': [
|
||||
'd8_js2c',
|
||||
],
|
||||
}],
|
||||
['(OS=="linux" or OS=="mac" or OS=="freebsd" or OS=="netbsd" \
|
||||
or OS=="openbsd" or OS=="solaris" or OS=="android" \
|
||||
@ -63,19 +71,7 @@
|
||||
'sources': [ 'd8-windows.cc', ]
|
||||
}],
|
||||
[ 'component!="shared_library"', {
|
||||
'sources': [
|
||||
'<(SHARED_INTERMEDIATE_DIR)/d8-js.cc',
|
||||
],
|
||||
'conditions': [
|
||||
[ 'want_separate_host_toolset==1', {
|
||||
'dependencies': [
|
||||
'd8_js2c#host',
|
||||
],
|
||||
}, {
|
||||
'dependencies': [
|
||||
'd8_js2c',
|
||||
],
|
||||
}],
|
||||
[ 'v8_postmortem_support=="true"', {
|
||||
'xcode_settings': {
|
||||
'OTHER_LDFLAGS': [
|
||||
|
||||
22
src/d8.h
22
src/d8.h
@ -5,15 +5,10 @@
|
||||
#ifndef V8_D8_H_
|
||||
#define V8_D8_H_
|
||||
|
||||
#ifndef V8_SHARED
|
||||
#include "src/allocation.h"
|
||||
#include "src/base/hashmap.h"
|
||||
#include "src/base/platform/time.h"
|
||||
#include "src/list.h"
|
||||
#else
|
||||
#include "include/v8.h"
|
||||
#include "src/base/compiler-specific.h"
|
||||
#endif // !V8_SHARED
|
||||
|
||||
#include "src/base/once.h"
|
||||
|
||||
@ -21,7 +16,6 @@
|
||||
namespace v8 {
|
||||
|
||||
|
||||
#ifndef V8_SHARED
|
||||
// A single counter in a counter collection.
|
||||
class Counter {
|
||||
public:
|
||||
@ -90,17 +84,14 @@ class CounterMap {
|
||||
static bool Match(void* key1, void* key2);
|
||||
base::HashMap hash_map_;
|
||||
};
|
||||
#endif // !V8_SHARED
|
||||
|
||||
|
||||
class SourceGroup {
|
||||
public:
|
||||
SourceGroup() :
|
||||
#ifndef V8_SHARED
|
||||
next_semaphore_(0),
|
||||
done_semaphore_(0),
|
||||
thread_(NULL),
|
||||
#endif // !V8_SHARED
|
||||
argv_(NULL),
|
||||
begin_offset_(0),
|
||||
end_offset_(0) {}
|
||||
@ -116,7 +107,6 @@ class SourceGroup {
|
||||
|
||||
void Execute(Isolate* isolate);
|
||||
|
||||
#ifndef V8_SHARED
|
||||
void StartExecuteInThread();
|
||||
void WaitForThread();
|
||||
void JoinThread();
|
||||
@ -141,7 +131,6 @@ class SourceGroup {
|
||||
base::Semaphore next_semaphore_;
|
||||
base::Semaphore done_semaphore_;
|
||||
base::Thread* thread_;
|
||||
#endif // !V8_SHARED
|
||||
|
||||
void ExitShell(int exit_code);
|
||||
Local<String> ReadFile(Isolate* isolate, const char* name);
|
||||
@ -151,7 +140,6 @@ class SourceGroup {
|
||||
int end_offset_;
|
||||
};
|
||||
|
||||
#ifndef V8_SHARED
|
||||
enum SerializationTag {
|
||||
kSerializationTagUndefined,
|
||||
kSerializationTagNull,
|
||||
@ -267,7 +255,6 @@ class Worker {
|
||||
char* script_;
|
||||
base::Atomic32 running_;
|
||||
};
|
||||
#endif // !V8_SHARED
|
||||
|
||||
|
||||
class ShellOptions {
|
||||
@ -324,12 +311,7 @@ class ShellOptions {
|
||||
const char* trace_config;
|
||||
};
|
||||
|
||||
#ifdef V8_SHARED
|
||||
class Shell {
|
||||
#else
|
||||
class Shell : public i::AllStatic {
|
||||
#endif // V8_SHARED
|
||||
|
||||
public:
|
||||
enum SourceType { SCRIPT, MODULE };
|
||||
|
||||
@ -351,7 +333,6 @@ class Shell : public i::AllStatic {
|
||||
static void CollectGarbage(Isolate* isolate);
|
||||
static void EmptyMessageQueues(Isolate* isolate);
|
||||
|
||||
#ifndef V8_SHARED
|
||||
// TODO(binji): stupid implementation for now. Is there an easy way to hash an
|
||||
// object for use in base::HashMap? By pointer?
|
||||
typedef i::List<Local<Object>> ObjectList;
|
||||
@ -372,7 +353,6 @@ class Shell : public i::AllStatic {
|
||||
static void MapCounters(v8::Isolate* isolate, const char* name);
|
||||
|
||||
static void PerformanceNow(const v8::FunctionCallbackInfo<v8::Value>& args);
|
||||
#endif // !V8_SHARED
|
||||
|
||||
static void RealmCurrent(const v8::FunctionCallbackInfo<v8::Value>& args);
|
||||
static void RealmOwner(const v8::FunctionCallbackInfo<v8::Value>& args);
|
||||
@ -450,7 +430,6 @@ class Shell : public i::AllStatic {
|
||||
private:
|
||||
static Global<Context> evaluation_context_;
|
||||
static base::OnceType quit_once_;
|
||||
#ifndef V8_SHARED
|
||||
static Global<Function> stringify_function_;
|
||||
static CounterMap* counter_map_;
|
||||
// We statically allocate a set of local counters to be used if we
|
||||
@ -469,7 +448,6 @@ class Shell : public i::AllStatic {
|
||||
static void WriteIgnitionDispatchCountersFile(v8::Isolate* isolate);
|
||||
static Counter* GetCounter(const char* name, bool is_histogram);
|
||||
static Local<String> Stringify(Isolate* isolate, Local<Value> value);
|
||||
#endif // !V8_SHARED
|
||||
static void Initialize(Isolate* isolate);
|
||||
static void RunShell(Isolate* isolate);
|
||||
static bool SetOptions(int argc, char* argv[]);
|
||||
|
||||
@ -28,9 +28,8 @@ class Factory final {
|
||||
byte kind);
|
||||
|
||||
// Allocates a fixed array initialized with undefined values.
|
||||
Handle<FixedArray> NewFixedArray(
|
||||
int size,
|
||||
PretenureFlag pretenure = NOT_TENURED);
|
||||
V8_EXPORT_PRIVATE Handle<FixedArray> NewFixedArray(
|
||||
int size, PretenureFlag pretenure = NOT_TENURED);
|
||||
|
||||
// Allocate a new fixed array with non-existing entries (the hole).
|
||||
Handle<FixedArray> NewFixedArrayWithHoles(
|
||||
@ -165,9 +164,8 @@ class Factory final {
|
||||
|
||||
// UTF8 strings are pretenured when used for regexp literal patterns and
|
||||
// flags in the parser.
|
||||
MUST_USE_RESULT MaybeHandle<String> NewStringFromUtf8(
|
||||
Vector<const char> str,
|
||||
PretenureFlag pretenure = NOT_TENURED);
|
||||
MUST_USE_RESULT V8_EXPORT_PRIVATE MaybeHandle<String> NewStringFromUtf8(
|
||||
Vector<const char> str, PretenureFlag pretenure = NOT_TENURED);
|
||||
|
||||
MUST_USE_RESULT MaybeHandle<String> NewStringFromTwoByte(
|
||||
Vector<const uc16> str,
|
||||
@ -457,11 +455,11 @@ class Factory final {
|
||||
}
|
||||
|
||||
// Create a JSArray with the given elements.
|
||||
Handle<JSArray> NewJSArrayWithElements(Handle<FixedArrayBase> elements,
|
||||
ElementsKind elements_kind, int length,
|
||||
PretenureFlag pretenure = NOT_TENURED);
|
||||
V8_EXPORT_PRIVATE Handle<JSArray> NewJSArrayWithElements(
|
||||
Handle<FixedArrayBase> elements, ElementsKind elements_kind, int length,
|
||||
PretenureFlag pretenure = NOT_TENURED);
|
||||
|
||||
Handle<JSArray> NewJSArrayWithElements(
|
||||
V8_EXPORT_PRIVATE Handle<JSArray> NewJSArrayWithElements(
|
||||
Handle<FixedArrayBase> elements,
|
||||
ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND,
|
||||
PretenureFlag pretenure = NOT_TENURED) {
|
||||
|
||||
@ -23,14 +23,21 @@
|
||||
// this will just be an extern declaration, but for a readonly flag we let the
|
||||
// compiler make better optimizations by giving it the value.
|
||||
#if defined(FLAG_MODE_DECLARE)
|
||||
#define FLAG_FULL(ftype, ctype, nam, def, cmt) extern ctype FLAG_##nam;
|
||||
#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
|
||||
V8_EXPORT_PRIVATE extern ctype FLAG_##nam;
|
||||
#define FLAG_READONLY(ftype, ctype, nam, def, cmt) \
|
||||
static ctype const FLAG_##nam = def;
|
||||
|
||||
// We want to supply the actual storage and value for the flag variable in the
|
||||
// .cc file. We only do this for writable flags.
|
||||
#elif defined(FLAG_MODE_DEFINE)
|
||||
#define FLAG_FULL(ftype, ctype, nam, def, cmt) ctype FLAG_##nam = def;
|
||||
#ifdef USING_V8_SHARED
|
||||
#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
|
||||
V8_EXPORT_PRIVATE extern ctype FLAG_##nam;
|
||||
#else
|
||||
#define FLAG_FULL(ftype, ctype, nam, def, cmt) \
|
||||
V8_EXPORT_PRIVATE ctype FLAG_##nam = def;
|
||||
#endif
|
||||
|
||||
// We need to define all of our default values so that the Flag structure can
|
||||
// access them by pointer. These are just used internally inside of one .cc,
|
||||
|
||||
@ -14,6 +14,32 @@
|
||||
#include "src/base/logging.h"
|
||||
#include "src/base/macros.h"
|
||||
|
||||
#ifdef V8_OS_WIN
|
||||
|
||||
// Setup for Windows shared library export.
|
||||
#ifdef BUILDING_V8_SHARED
|
||||
#define V8_EXPORT_PRIVATE __declspec(dllexport)
|
||||
#elif USING_V8_SHARED
|
||||
#define V8_EXPORT_PRIVATE __declspec(dllimport)
|
||||
#else
|
||||
#define V8_EXPORT_PRIVATE
|
||||
#endif // BUILDING_V8_SHARED
|
||||
|
||||
#else // V8_OS_WIN
|
||||
|
||||
// Setup for Linux shared library export.
|
||||
#if V8_HAS_ATTRIBUTE_VISIBILITY
|
||||
#ifdef BUILDING_V8_SHARED
|
||||
#define V8_EXPORT_PRIVATE __attribute__((visibility("default")))
|
||||
#else
|
||||
#define V8_EXPORT_PRIVATE
|
||||
#endif
|
||||
#else
|
||||
#define V8_EXPORT_PRIVATE
|
||||
#endif
|
||||
|
||||
#endif // V8_OS_WIN
|
||||
|
||||
// Unfortunately, the INFINITY macro cannot be used with the '-pedantic'
|
||||
// warning flag and certain versions of GCC due to a bug:
|
||||
// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=11931
|
||||
|
||||
@ -2425,7 +2425,7 @@ class AllSpaces BASE_EMBEDDED {
|
||||
|
||||
// Space iterator for iterating over all old spaces of the heap: Old space
|
||||
// and code space. Returns each space in turn, and null when it is done.
|
||||
class OldSpaces BASE_EMBEDDED {
|
||||
class V8_EXPORT_PRIVATE OldSpaces BASE_EMBEDDED {
|
||||
public:
|
||||
explicit OldSpaces(Heap* heap) : heap_(heap), counter_(OLD_SPACE) {}
|
||||
OldSpace* next();
|
||||
|
||||
@ -154,8 +154,8 @@ class IncrementalMarking {
|
||||
INLINE(void RecordWriteOfCodeEntry(JSFunction* host, Object** slot,
|
||||
Code* value));
|
||||
|
||||
|
||||
void RecordWriteSlow(HeapObject* obj, Object** slot, Object* value);
|
||||
V8_EXPORT_PRIVATE void RecordWriteSlow(HeapObject* obj, Object** slot,
|
||||
Object* value);
|
||||
void RecordWriteIntoCodeSlow(Code* host, RelocInfo* rinfo, Object* value);
|
||||
void RecordWriteOfCodeEntrySlow(JSFunction* host, Object** slot, Code* value);
|
||||
void RecordCodeTargetPatch(Code* host, Address pc, HeapObject* value);
|
||||
|
||||
@ -776,8 +776,7 @@ class EvacuationScope BASE_EMBEDDED {
|
||||
MarkCompactCollector* collector_;
|
||||
};
|
||||
|
||||
|
||||
const char* AllocationSpaceName(AllocationSpace space);
|
||||
V8_EXPORT_PRIVATE const char* AllocationSpaceName(AllocationSpace space);
|
||||
} // namespace internal
|
||||
} // namespace v8
|
||||
|
||||
|
||||
@ -463,7 +463,7 @@ class MemoryChunk {
|
||||
}
|
||||
inline LocalArrayBufferTracker* local_tracker() { return local_tracker_; }
|
||||
|
||||
void AllocateOldToNewSlots();
|
||||
V8_EXPORT_PRIVATE void AllocateOldToNewSlots();
|
||||
void ReleaseOldToNewSlots();
|
||||
void AllocateOldToOldSlots();
|
||||
void ReleaseOldToOldSlots();
|
||||
@ -1430,7 +1430,7 @@ class MemoryAllocator {
|
||||
// method which is used to avoid using virtual functions
|
||||
// iterating a specific space.
|
||||
|
||||
class ObjectIterator : public Malloced {
|
||||
class V8_EXPORT_PRIVATE ObjectIterator : public Malloced {
|
||||
public:
|
||||
virtual ~ObjectIterator() {}
|
||||
virtual HeapObject* Next() = 0;
|
||||
@ -1481,7 +1481,7 @@ class PageRange {
|
||||
// If objects are allocated in the page during iteration the iterator may
|
||||
// or may not iterate over those objects. The caller must create a new
|
||||
// iterator in order to be sure to visit these new objects.
|
||||
class HeapObjectIterator : public ObjectIterator {
|
||||
class V8_EXPORT_PRIVATE HeapObjectIterator : public ObjectIterator {
|
||||
public:
|
||||
// Creates a new object iterator in a given space.
|
||||
explicit HeapObjectIterator(PagedSpace* space);
|
||||
|
||||
@ -106,10 +106,7 @@ config("inspector_config") {
|
||||
]
|
||||
}
|
||||
if (is_component_build) {
|
||||
defines = [
|
||||
"V8_SHARED",
|
||||
"BUILDING_V8_SHARED",
|
||||
]
|
||||
defines = [ "BUILDING_V8_SHARED" ]
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -56,7 +56,7 @@ class Interpreter {
|
||||
void TraceCodegen(Handle<Code> code);
|
||||
const char* LookupNameOfBytecodeHandler(Code* code);
|
||||
|
||||
Local<v8::Object> GetDispatchCountersObject();
|
||||
V8_EXPORT_PRIVATE Local<v8::Object> GetDispatchCountersObject();
|
||||
|
||||
Address dispatch_table_address() {
|
||||
return reinterpret_cast<Address>(&dispatch_table_[0]);
|
||||
|
||||
@ -13,6 +13,7 @@
|
||||
|
||||
#include "include/v8config.h"
|
||||
#include "src/base/macros.h"
|
||||
#include "src/globals.h"
|
||||
|
||||
namespace v8 {
|
||||
namespace internal {
|
||||
@ -33,7 +34,7 @@ class OFStreamBase : public std::streambuf {
|
||||
|
||||
|
||||
// An output stream writing to a file.
|
||||
class OFStream : public std::ostream {
|
||||
class V8_EXPORT_PRIVATE OFStream : public std::ostream {
|
||||
public:
|
||||
explicit OFStream(FILE* f);
|
||||
virtual ~OFStream();
|
||||
|
||||
@ -22,8 +22,15 @@ enum NativeType {
|
||||
TEST
|
||||
};
|
||||
|
||||
// Extra handling for V8_EXPORT_PRIVATE in combination with USING_V8_SHARED
|
||||
// since definition of methods of classes marked as dllimport is not allowed.
|
||||
template <NativeType type>
|
||||
#ifdef USING_V8_SHARED
|
||||
class NativesCollection {
|
||||
#else
|
||||
class V8_EXPORT_PRIVATE NativesCollection {
|
||||
#endif // USING_V8_SHARED
|
||||
|
||||
public:
|
||||
// The following methods are implemented in js2c-generated code:
|
||||
|
||||
|
||||
11
src/utils.h
11
src/utils.h
@ -437,7 +437,7 @@ void init_memcopy_functions(Isolate* isolate);
|
||||
const int kMinComplexMemCopy = 64;
|
||||
|
||||
// Copy memory area. No restrictions.
|
||||
void MemMove(void* dest, const void* src, size_t size);
|
||||
V8_EXPORT_PRIVATE void MemMove(void* dest, const void* src, size_t size);
|
||||
typedef void (*MemMoveFunction)(void* dest, const void* src, size_t size);
|
||||
|
||||
// Keep the distinction of "move" vs. "copy" for the benefit of other
|
||||
@ -459,7 +459,8 @@ V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
|
||||
(*memcopy_uint8_function)(reinterpret_cast<uint8_t*>(dest),
|
||||
reinterpret_cast<const uint8_t*>(src), size);
|
||||
}
|
||||
V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
|
||||
V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
|
||||
size_t size) {
|
||||
memmove(dest, src, size);
|
||||
}
|
||||
|
||||
@ -488,7 +489,8 @@ V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
|
||||
(*memcopy_uint8_function)(reinterpret_cast<uint8_t*>(dest),
|
||||
reinterpret_cast<const uint8_t*>(src), size);
|
||||
}
|
||||
V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
|
||||
V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
|
||||
size_t size) {
|
||||
memmove(dest, src, size);
|
||||
}
|
||||
#else
|
||||
@ -496,7 +498,8 @@ V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
|
||||
V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
|
||||
memcpy(dest, src, size);
|
||||
}
|
||||
V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
|
||||
V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
|
||||
size_t size) {
|
||||
memmove(dest, src, size);
|
||||
}
|
||||
const int kMinComplexMemCopy = 16 * kPointerSize;
|
||||
|
||||
@ -61,12 +61,10 @@
|
||||
'..',
|
||||
],
|
||||
'defines': [
|
||||
'V8_SHARED',
|
||||
'BUILDING_V8_SHARED',
|
||||
],
|
||||
'direct_dependent_settings': {
|
||||
'defines': [
|
||||
'V8_SHARED',
|
||||
'USING_V8_SHARED',
|
||||
],
|
||||
},
|
||||
@ -164,12 +162,10 @@
|
||||
}],
|
||||
['component=="shared_library"', {
|
||||
'defines': [
|
||||
'V8_SHARED',
|
||||
'BUILDING_V8_SHARED',
|
||||
],
|
||||
'direct_dependent_settings': {
|
||||
'defines': [
|
||||
'V8_SHARED',
|
||||
'USING_V8_SHARED',
|
||||
],
|
||||
},
|
||||
@ -259,7 +255,6 @@
|
||||
['component=="shared_library"', {
|
||||
'defines': [
|
||||
'BUILDING_V8_SHARED',
|
||||
'V8_SHARED',
|
||||
],
|
||||
}],
|
||||
]
|
||||
@ -286,12 +281,10 @@
|
||||
}],
|
||||
['component=="shared_library"', {
|
||||
'defines': [
|
||||
'V8_SHARED',
|
||||
'BUILDING_V8_SHARED',
|
||||
],
|
||||
'direct_dependent_settings': {
|
||||
'defines': [
|
||||
'V8_SHARED',
|
||||
'USING_V8_SHARED',
|
||||
],
|
||||
},
|
||||
@ -1713,7 +1706,6 @@
|
||||
['component=="shared_library"', {
|
||||
'defines': [
|
||||
'BUILDING_V8_SHARED',
|
||||
'V8_SHARED',
|
||||
],
|
||||
}],
|
||||
['v8_postmortem_support=="true"', {
|
||||
|
||||
@ -5,13 +5,8 @@
|
||||
#ifndef V8_WASM_JS_H_
|
||||
#define V8_WASM_JS_H_
|
||||
|
||||
#ifndef V8_SHARED
|
||||
#include "src/allocation.h"
|
||||
#include "src/base/hashmap.h"
|
||||
#else
|
||||
#include "include/v8.h"
|
||||
#include "src/base/compiler-specific.h"
|
||||
#endif // !V8_SHARED
|
||||
|
||||
namespace v8 {
|
||||
namespace internal {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user