AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Revert of [d8] Fix the shared-library build (patchset #12 id:20002 of https://codereview.chromium.org/2342563002/ )

Browse Source 
Reason for revert:
Unblocking roll

Original issue's description:
> [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
>
> Committed: https://crrev.com/2c10ca8086a4d595ecf9aa843d2031b068470d65
> Cr-Commit-Position: refs/heads/master@{#39503}

TBR=jochen@chromium.org,vogelheim@chromium.org,bmeurer@chromium.org,titzer@chromium.org,jgruber@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=chromium:646337

Review-Url: https://codereview.chromium.org/2356703003
Cr-Commit-Position: refs/heads/master@{#39526}
This commit is contained in:
machenbach 2016-09-20 00:12:39 -07:00 committed by Commit bot
parent d86038db25
commit 298ee9cde1
21 changed files with 202 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
BUILD.gn
View File

@ -115,7 +115,10 @@ config("internal_config") {
include_dirs = [ "." ]
if (is_component_build) {
defines = [ "BUILDING_V8_SHARED" ]
defines = [
"V8_SHARED",
"BUILDING_V8_SHARED",
]
}
}
@ -139,7 +142,10 @@ config("libsampler_config") {
# itself.
config("external_config") {
if (is_component_build) {
defines = [ "USING_V8_SHARED" ]
defines = [
"V8_SHARED",
"USING_V8_SHARED",
]
}
include_dirs = [ "include" ]
if (v8_enable_inspector_override) {
@ -2383,7 +2389,6 @@ if (is_component_build) {
v8_executable("d8") {
sources = [
"$target_gen_dir/d8-js.cc",
"src/d8.cc",
"src/d8.h",
]
@ -2411,6 +2416,9 @@ 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" ]
}

2
include/v8.h
View File

@ -51,7 +51,7 @@
#else // V8_OS_WIN
// Setup for Linux shared library export.
#if V8_HAS_ATTRIBUTE_VISIBILITY
#if V8_HAS_ATTRIBUTE_VISIBILITY && defined(V8_SHARED)
# ifdef BUILDING_V8_SHARED
# define V8_EXPORT __attribute__ ((visibility("default")))
# else

6
src/allocation.h
View File

@ -13,10 +13,10 @@ namespace internal {
// Called when allocation routines fail to allocate.
// This function should not return, but should terminate the current
// processing.
V8_EXPORT_PRIVATE void FatalProcessOutOfMemory(const char* message);
void FatalProcessOutOfMemory(const char* message);
// Superclass for classes managed with new & delete.
class V8_EXPORT_PRIVATE Malloced {
class 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.
V8_EXPORT_PRIVATE char* StrDup(const char* str);
char* StrDup(const char* str);
char* StrNDup(const char* str, int n);

8
src/basic-block-profiler.h
View File

@ -11,7 +11,6 @@
#include <vector>
#include "src/base/macros.h"
#include "src/globals.h"
namespace v8 {
namespace internal {
@ -59,16 +58,15 @@ class BasicBlockProfiler {
const DataList* data_list() { return &data_list_; }
private:
friend V8_EXPORT_PRIVATE std::ostream& operator<<(
std::ostream& os, const BasicBlockProfiler& s);
friend std::ostream& operator<<(std::ostream& os,
const BasicBlockProfiler& s);
DataList data_list_;
DISALLOW_COPY_AND_ASSIGN(BasicBlockProfiler);
};
V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
const BasicBlockProfiler& s);
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
View File

@ -2,14 +2,30 @@
// 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 v8 {
namespace {
const int MB = 1024 * 1024;
#ifndef V8_SHARED
const int kMaxWorkers = 50;
#endif
class ShellArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
@ -82,6 +102,7 @@ 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 {
@ -142,6 +163,7 @@ class PredictablePlatform : public Platform {
DISALLOW_COPY_AND_ASSIGN(PredictablePlatform);
};
#endif // !V8_SHARED
v8::Platform* g_platform = NULL;
@ -154,6 +176,7 @@ 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)) {
@ -179,6 +202,7 @@ Worker* GetWorkerFromInternalField(Isolate* isolate, Local<Object> object) {
return worker;
}
#endif // !V8_SHARED
} // namespace
@ -346,6 +370,7 @@ class PerIsolateData {
};
#ifndef V8_SHARED
CounterMap* Shell::counter_map_;
base::OS::MemoryMappedFile* Shell::counters_file_ = NULL;
CounterCollection Shell::local_counters_;
@ -358,17 +383,20 @@ 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.
@ -509,7 +537,9 @@ 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.
@ -517,11 +547,13 @@ 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;
}
@ -573,6 +605,7 @@ 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().
@ -585,6 +618,7 @@ 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.
@ -855,6 +889,7 @@ 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);
@ -976,13 +1011,16 @@ 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);
}
@ -1003,12 +1041,14 @@ 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();
@ -1052,10 +1092,13 @@ 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++)
@ -1184,6 +1227,7 @@ 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) {
@ -1274,6 +1318,7 @@ 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)
@ -1312,6 +1357,7 @@ 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);
@ -1329,17 +1375,21 @@ 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);
@ -1347,6 +1397,7 @@ 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 =
@ -1364,6 +1415,7 @@ Local<Context> Shell::CreateEvaluationContext(Isolate* isolate) {
.ToLocalChecked(),
Utils::ToLocal(arguments_jsarray))
.FromJust();
#endif // !V8_SHARED
return handle_scope.Escape(context);
}
@ -1377,6 +1429,7 @@ void Shell::Exit(int exit_code) {
}
#ifndef V8_SHARED
struct CounterAndKey {
Counter* counter;
const char* key;
@ -1401,8 +1454,11 @@ 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()) {
@ -1438,6 +1494,7 @@ void Shell::OnExit(v8::Isolate* isolate) {
delete counters_file_;
delete counter_map_;
#endif // !V8_SHARED
}
@ -1571,8 +1628,10 @@ void Shell::RunShell(Isolate* isolate) {
SourceGroup::~SourceGroup() {
#ifndef V8_SHARED
delete thread_;
thread_ = NULL;
#endif // !V8_SHARED
}
@ -1641,6 +1700,7 @@ 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.
@ -1964,6 +2024,7 @@ void Worker::PostMessageOut(const v8::FunctionCallbackInfo<v8::Value>& args) {
delete data;
}
}
#endif // !V8_SHARED
void SetFlagsFromString(const char* flags) {
@ -2019,16 +2080,30 @@ 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;
@ -2094,9 +2169,11 @@ 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);
@ -2111,6 +2188,7 @@ 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();
@ -2119,6 +2197,7 @@ int Shell::RunMain(Isolate* isolate, int argc, char* argv[], bool last_run) {
}
}
CleanupWorkers();
#endif // !V8_SHARED
return 0;
}
@ -2140,12 +2219,17 @@ 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,
@ -2460,11 +2544,14 @@ 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;
@ -2482,9 +2569,13 @@ 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();
@ -2510,6 +2601,7 @@ 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());
@ -2520,6 +2612,7 @@ 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);
@ -2549,15 +2642,21 @@ 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
@ -2573,6 +2672,7 @@ 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++) {
@ -2581,6 +2681,7 @@ 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);
@ -2592,23 +2693,29 @@ 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
View File

@ -49,18 +49,10 @@
'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" \
@ -71,7 +63,19 @@
'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
View File

@ -5,10 +5,15 @@
#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"
@ -16,6 +21,7 @@
namespace v8 {
#ifndef V8_SHARED
// A single counter in a counter collection.
class Counter {
public:
@ -84,14 +90,17 @@ 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) {}
@ -107,6 +116,7 @@ class SourceGroup {
void Execute(Isolate* isolate);
#ifndef V8_SHARED
void StartExecuteInThread();
void WaitForThread();
void JoinThread();
@ -131,6 +141,7 @@ 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);
@ -140,6 +151,7 @@ class SourceGroup {
int end_offset_;
};
#ifndef V8_SHARED
enum SerializationTag {
kSerializationTagUndefined,
kSerializationTagNull,
@ -255,6 +267,7 @@ class Worker {
char* script_;
base::Atomic32 running_;
};
#endif // !V8_SHARED
class ShellOptions {
@ -311,7 +324,12 @@ 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 };
@ -333,6 +351,7 @@ 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;
@ -353,6 +372,7 @@ 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);
@ -430,6 +450,7 @@ 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
@ -448,6 +469,7 @@ 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[]);

18
src/factory.h
View File

@ -28,8 +28,9 @@ class Factory final {
byte kind);
// Allocates a fixed array initialized with undefined values.
V8_EXPORT_PRIVATE Handle<FixedArray> NewFixedArray(
int size, PretenureFlag pretenure = NOT_TENURED);
Handle<FixedArray> NewFixedArray(
int size,
PretenureFlag pretenure = NOT_TENURED);
// Allocate a new fixed array with non-existing entries (the hole).
Handle<FixedArray> NewFixedArrayWithHoles(
@ -164,8 +165,9 @@ class Factory final {
// UTF8 strings are pretenured when used for regexp literal patterns and
// flags in the parser.
MUST_USE_RESULT V8_EXPORT_PRIVATE MaybeHandle<String> NewStringFromUtf8(
Vector<const char> str, PretenureFlag pretenure = NOT_TENURED);
MUST_USE_RESULT MaybeHandle<String> NewStringFromUtf8(
Vector<const char> str,
PretenureFlag pretenure = NOT_TENURED);
MUST_USE_RESULT MaybeHandle<String> NewStringFromTwoByte(
Vector<const uc16> str,
@ -455,11 +457,11 @@ class Factory final {
}
// Create a JSArray with the given elements.
V8_EXPORT_PRIVATE Handle<JSArray> NewJSArrayWithElements(
Handle<FixedArrayBase> elements, ElementsKind elements_kind, int length,
PretenureFlag pretenure = NOT_TENURED);
Handle<JSArray> NewJSArrayWithElements(Handle<FixedArrayBase> elements,
ElementsKind elements_kind, int length,
PretenureFlag pretenure = NOT_TENURED);
V8_EXPORT_PRIVATE Handle<JSArray> NewJSArrayWithElements(
Handle<JSArray> NewJSArrayWithElements(
Handle<FixedArrayBase> elements,
ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND,
PretenureFlag pretenure = NOT_TENURED) {

11
src/flag-definitions.h
View File

@ -23,21 +23,14 @@
// 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) \
V8_EXPORT_PRIVATE extern ctype FLAG_##nam;
#define FLAG_FULL(ftype, ctype, nam, def, cmt) 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)
#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
#define FLAG_FULL(ftype, ctype, nam, def, cmt) ctype FLAG_##nam = def;
// 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,

26
src/globals.h
View File

@ -14,32 +14,6 @@
#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

2
src/heap/heap.h
View File

@ -2426,7 +2426,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 V8_EXPORT_PRIVATE OldSpaces BASE_EMBEDDED {
class OldSpaces BASE_EMBEDDED {
public:
explicit OldSpaces(Heap* heap) : heap_(heap), counter_(OLD_SPACE) {}
OldSpace* next();

4
src/heap/incremental-marking.h
View File

@ -154,8 +154,8 @@ class IncrementalMarking {
INLINE(void RecordWriteOfCodeEntry(JSFunction* host, Object** slot,
Code* value));
V8_EXPORT_PRIVATE void RecordWriteSlow(HeapObject* obj, Object** slot,
Object* value);
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);

3
src/heap/mark-compact.h
View File

@ -776,7 +776,8 @@ class EvacuationScope BASE_EMBEDDED {
MarkCompactCollector* collector_;
};
V8_EXPORT_PRIVATE const char* AllocationSpaceName(AllocationSpace space);
const char* AllocationSpaceName(AllocationSpace space);
} // namespace internal
} // namespace v8

6
src/heap/spaces.h
View File

@ -463,7 +463,7 @@ class MemoryChunk {
}
inline LocalArrayBufferTracker* local_tracker() { return local_tracker_; }
V8_EXPORT_PRIVATE void AllocateOldToNewSlots();
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 V8_EXPORT_PRIVATE ObjectIterator : public Malloced {
class 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 V8_EXPORT_PRIVATE HeapObjectIterator : public ObjectIterator {
class HeapObjectIterator : public ObjectIterator {
public:
// Creates a new object iterator in a given space.
explicit HeapObjectIterator(PagedSpace* space);

5
src/inspector/BUILD.gn
View File

@ -106,7 +106,10 @@ config("inspector_config") {
]
}
if (is_component_build) {
defines = [ "BUILDING_V8_SHARED" ]
defines = [
"V8_SHARED",
"BUILDING_V8_SHARED",
]
}
}

2
src/interpreter/interpreter.h
View File

@ -56,7 +56,7 @@ class Interpreter {
void TraceCodegen(Handle<Code> code);
const char* LookupNameOfBytecodeHandler(Code* code);
V8_EXPORT_PRIVATE Local<v8::Object> GetDispatchCountersObject();
Local<v8::Object> GetDispatchCountersObject();
Address dispatch_table_address() {
return reinterpret_cast<Address>(&dispatch_table_[0]);

3
src/ostreams.h
View File

@ -13,7 +13,6 @@
#include "include/v8config.h"
#include "src/base/macros.h"
#include "src/globals.h"
namespace v8 {
namespace internal {
@ -34,7 +33,7 @@ class OFStreamBase : public std::streambuf {
// An output stream writing to a file.
class V8_EXPORT_PRIVATE OFStream : public std::ostream {
class OFStream : public std::ostream {
public:
explicit OFStream(FILE* f);
virtual ~OFStream();

7
src/snapshot/natives.h
View File

@ -22,15 +22,8 @@ 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
View File

@ -437,7 +437,7 @@ void init_memcopy_functions(Isolate* isolate);
const int kMinComplexMemCopy = 64;
// Copy memory area. No restrictions.
V8_EXPORT_PRIVATE void MemMove(void* dest, const void* src, size_t size);
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,8 +459,7 @@ 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_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
size_t size) {
V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
memmove(dest, src, size);
}
@ -489,8 +488,7 @@ 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_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
size_t size) {
V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
memmove(dest, src, size);
}
#else
@ -498,8 +496,7 @@ V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
V8_INLINE void MemCopy(void* dest, const void* src, size_t size) {
memcpy(dest, src, size);
}
V8_EXPORT_PRIVATE V8_INLINE void MemMove(void* dest, const void* src,
size_t size) {
V8_INLINE void MemMove(void* dest, const void* src, size_t size) {
memmove(dest, src, size);
}
const int kMinComplexMemCopy = 16 * kPointerSize;

8
src/v8.gyp
View File

@ -61,10 +61,12 @@
'..',
],
'defines': [
'V8_SHARED',
'BUILDING_V8_SHARED',
],
'direct_dependent_settings': {
'defines': [
'V8_SHARED',
'USING_V8_SHARED',
],
},
@ -162,10 +164,12 @@
}],
['component=="shared_library"', {
'defines': [
'V8_SHARED',
'BUILDING_V8_SHARED',
],
'direct_dependent_settings': {
'defines': [
'V8_SHARED',
'USING_V8_SHARED',
],
},
@ -255,6 +259,7 @@
['component=="shared_library"', {
'defines': [
'BUILDING_V8_SHARED',
'V8_SHARED',
],
}],
]
@ -281,10 +286,12 @@
}],
['component=="shared_library"', {
'defines': [
'V8_SHARED',
'BUILDING_V8_SHARED',
],
'direct_dependent_settings': {
'defines': [
'V8_SHARED',
'USING_V8_SHARED',
],
},
@ -1706,6 +1713,7 @@
['component=="shared_library"', {
'defines': [
'BUILDING_V8_SHARED',
'V8_SHARED',
],
}],
['v8_postmortem_support=="true"', {

5
src/wasm/wasm-js.h
View File

@ -5,8 +5,13 @@
#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 {