"src/splay-tree.h",
"src/splay-tree-inl.h",
"src/snapshot/snapshot.h",
+ "src/startup-data-util.h",
+ "src/startup-data-util.cc",
"src/string-builder.cc",
"src/string-builder.h",
"src/string-search.cc",
sources = [
"src/d8.cc",
"src/d8.h",
- "src/startup-data-util.h",
- "src/startup-data-util.cc",
]
configs -= [ "//build/config/compiler:chromium_code" ]
#define V8_MAJOR_VERSION 4
#define V8_MINOR_VERSION 5
#define V8_BUILD_NUMBER 103
-#define V8_PATCH_LEVEL 24
+#define V8_PATCH_LEVEL 30
// Use 1 for candidates and 0 otherwise.
// (Boolean macro values are not supported by all preprocessors.)
static bool InitializeICU(const char* icu_data_file = NULL);
/**
+ * Initialize the external startup data. The embedder only needs to
+ * invoke this method when external startup data was enabled in a build.
+ *
+ * If V8 was compiled with the startup data in an external file, then
+ * V8 needs to be given those external files during startup. There are
+ * three ways to do this:
+ * - InitializeExternalStartupData(const char*)
+ * This will look in the given directory for files "natives_blob.bin"
+ * and "snapshot_blob.bin" - which is what the default build calls them.
+ * - InitializeExternalStartupData(const char*, const char*)
+ * As above, but will directly use the two given file names.
+ * - Call SetNativesDataBlob, SetNativesDataBlob.
+ * This will read the blobs from the given data structures and will
+ * not perform any file IO.
+ */
+ static void InitializeExternalStartupData(const char* directory_path);
+ static void InitializeExternalStartupData(const char* natives_blob,
+ const char* snapshot_blob);
+ /**
* Sets the v8::Platform to use. This should be invoked before V8 is
* initialized.
*/
int main(int argc, char* argv[]) {
// Initialize V8.
V8::InitializeICU();
+ V8::InitializeExternalStartupData(argv[0]);
Platform* platform = platform::CreateDefaultPlatform();
V8::InitializePlatform(platform);
V8::Initialize();
int main(int argc, char* argv[]) {
v8::V8::InitializeICU();
+ v8::V8::InitializeExternalStartupData(argv[0]);
v8::Platform* platform = v8::platform::CreateDefaultPlatform();
v8::V8::InitializePlatform(platform);
v8::V8::Initialize();
int main(int argc, char* argv[]) {
v8::V8::InitializeICU();
+ v8::V8::InitializeExternalStartupData(argv[0]);
v8::Platform* platform = v8::platform::CreateDefaultPlatform();
v8::V8::InitializePlatform(platform);
v8::V8::Initialize();
#include "src/simulator.h"
#include "src/snapshot/natives.h"
#include "src/snapshot/snapshot.h"
+#include "src/startup-data-util.h"
#include "src/unicode-inl.h"
#include "src/v8threads.h"
#include "src/version.h"
object_count_(0),
object_size_(0) {}
+
bool v8::V8::InitializeICU(const char* icu_data_file) {
return i::InitializeICU(icu_data_file);
}
+void v8::V8::InitializeExternalStartupData(const char* directory_path) {
+ i::InitializeExternalStartupData(directory_path);
+}
+
+
+void v8::V8::InitializeExternalStartupData(const char* natives_blob,
+ const char* snapshot_blob) {
+ i::InitializeExternalStartupData(natives_blob, snapshot_blob);
+}
+
+
const char* v8::V8::GetVersion() {
return i::Version::GetVersion();
}
if (FLAG_enable_32dregs && cpu.has_vfp3_d32()) supported_ |= 1u << VFP32DREGS;
if (cpu.implementer() == base::CPU::NVIDIA &&
- cpu.variant() == base::CPU::NVIDIA_DENVER) {
+ cpu.variant() == base::CPU::NVIDIA_DENVER &&
+ cpu.part() <= base::CPU::NVIDIA_DENVER_V10) {
supported_ |= 1u << COHERENT_CACHE;
}
#endif
// Probe for runtime features
base::CPU cpu;
if (cpu.implementer() == base::CPU::NVIDIA &&
- cpu.variant() == base::CPU::NVIDIA_DENVER) {
+ cpu.variant() == base::CPU::NVIDIA_DENVER &&
+ cpu.part() <= base::CPU::NVIDIA_DENVER_V10) {
supported_ |= 1u << COHERENT_CACHE;
}
}
static const int ARM_CORTEX_A12 = 0xc0c;
static const int ARM_CORTEX_A15 = 0xc0f;
+ // Denver-specific part code
+ static const int NVIDIA_DENVER_V10 = 0x002;
+
// PPC-specific part codes
enum {
PPC_POWER5,
#include "src/v8.h"
#endif // !V8_SHARED
-#ifdef V8_USE_EXTERNAL_STARTUP_DATA
-#include "src/startup-data-util.h"
-#endif // V8_USE_EXTERNAL_STARTUP_DATA
-
#if !defined(_WIN32) && !defined(_WIN64)
#include <unistd.h> // NOLINT
#else
g_platform = v8::platform::CreateDefaultPlatform();
v8::V8::InitializePlatform(g_platform);
v8::V8::Initialize();
-#ifdef V8_USE_EXTERNAL_STARTUP_DATA
- v8::StartupDataHandler startup_data(argv[0], options.natives_blob,
- options.snapshot_blob);
-#endif
+ if (options.natives_blob || options.snapshot_blob) {
+ v8::V8::InitializeExternalStartupData(options.natives_blob,
+ options.snapshot_blob);
+ } else {
+ v8::V8::InitializeExternalStartupData(argv[0]);
+ }
SetFlagsFromString("--trace-hydrogen-file=hydrogen.cfg");
SetFlagsFromString("--trace-turbo-cfg-file=turbo.cfg");
SetFlagsFromString("--redirect-code-traces-to=code.asm");
'sources': [
'd8.h',
'd8.cc',
- 'startup-data-util.h',
- 'startup-data-util.cc'
],
'conditions': [
[ 'want_separate_host_toolset==1', {
}
-void Heap::FinalizeIncrementalMarkingIfComplete(const char* comment) {
- if (FLAG_overapproximate_weak_closure &&
- (incremental_marking()->IsReadyToOverApproximateWeakClosure() ||
- (!incremental_marking()->weak_closure_was_overapproximated() &&
- mark_compact_collector_.marking_deque()->IsEmpty()))) {
- OverApproximateWeakClosure(comment);
- } else if (incremental_marking()->IsComplete() ||
- (mark_compact_collector_.marking_deque()->IsEmpty())) {
- CollectAllGarbage(kNoGCFlags, comment);
- }
-}
-
-
bool Heap::TryFinalizeIdleIncrementalMarking(
double idle_time_in_ms, size_t size_of_objects,
size_t final_incremental_mark_compact_speed_in_bytes_per_ms) {
intptr_t step_size_in_bytes, double deadline_in_ms,
IncrementalMarking::StepActions step_actions);
- void FinalizeIncrementalMarkingIfComplete(const char* comment);
-
inline void increment_scan_on_scavenge_pages() {
scan_on_scavenge_pages_++;
if (FLAG_gc_verbose) {
bool HasHighFragmentation();
bool HasHighFragmentation(intptr_t used, intptr_t committed);
- bool ShouldOptimizeForMemoryUsage() { return optimize_for_memory_usage_; }
-
protected:
// Methods made available to tests.
if (state_.action == kRun) {
DCHECK(heap()->incremental_marking()->IsStopped());
DCHECK(FLAG_incremental_marking);
+ heap()->StartIdleIncrementalMarking();
if (FLAG_trace_gc_verbose) {
PrintIsolate(heap()->isolate(), "Memory reducer: started GC #%d\n",
state_.started_gcs);
}
- if (heap()->ShouldOptimizeForMemoryUsage()) {
- // Do full GC if memory usage has higher priority than latency. This is
- // important for background tabs that do not send idle notifications.
- heap()->CollectAllGarbage(Heap::kReduceMemoryFootprintMask,
- "memory reducer");
- } else {
- heap()->StartIdleIncrementalMarking();
- }
} else if (state_.action == kWait) {
- if (!heap()->incremental_marking()->IsStopped() &&
- heap()->ShouldOptimizeForMemoryUsage()) {
- // Make progress with pending incremental marking if memory usage has
- // higher priority than latency. This is important for background tabs
- // that do not send idle notifications.
- const int kIncrementalMarkingDelayMs = 500;
- double deadline = heap()->MonotonicallyIncreasingTimeInMs() +
- kIncrementalMarkingDelayMs;
- heap()->AdvanceIncrementalMarking(
- 0, deadline, i::IncrementalMarking::StepActions(
- i::IncrementalMarking::NO_GC_VIA_STACK_GUARD,
- i::IncrementalMarking::FORCE_MARKING,
- i::IncrementalMarking::FORCE_COMPLETION));
- heap()->FinalizeIncrementalMarkingIfComplete(
- "Memory reducer: finalize incremental marking");
- }
// Re-schedule the timer.
ScheduleTimer(state_.next_gc_start_ms - event.time_ms);
if (FLAG_trace_gc_verbose) {
ExpressionT expression =
this->ParseBinaryExpression(4, accept_IN, classifier, CHECK_OK);
if (peek() != Token::CONDITIONAL) return expression;
+ ArrowFormalParametersUnexpectedToken(classifier);
BindingPatternUnexpectedToken(classifier);
Consume(Token::CONDITIONAL);
// In parsing the first assignment expression in conditional
// prec1 >= 4
while (Precedence(peek(), accept_IN) == prec1) {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
Token::Value op = Next();
Scanner::Location op_location = scanner()->location();
int pos = position();
Token::Value op = peek();
if (Token::IsUnaryOp(op)) {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
op = Next();
int pos = position();
return this->BuildUnaryExpression(expression, op, pos, factory());
} else if (Token::IsCountOp(op)) {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
op = Next();
Scanner::Location lhs_location = scanner()->peek_location();
ExpressionT expression = this->ParseUnaryExpression(classifier, CHECK_OK);
if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
Token::IsCountOp(peek())) {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
expression = this->CheckAndRewriteReferenceExpression(
expression, lhs_location, MessageTemplate::kInvalidLhsInPostfixOp,
switch (peek()) {
case Token::LBRACK: {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
Consume(Token::LBRACK);
int pos = position();
ExpressionT index = ParseExpression(true, classifier, CHECK_OK);
case Token::LPAREN: {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
if (is_strong(language_mode()) && this->IsIdentifier(result) &&
this->IsEval(this->AsIdentifier(result))) {
case Token::PERIOD: {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
Consume(Token::PERIOD);
int pos = position();
IdentifierT name = ParseIdentifierName(CHECK_OK);
case Token::TEMPLATE_SPAN:
case Token::TEMPLATE_TAIL: {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
result = ParseTemplateLiteral(result, position(), classifier, CHECK_OK);
break;
}
if (peek() == Token::NEW) {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
Consume(Token::NEW);
int new_pos = position();
ExpressionT result = this->EmptyExpression();
ExpressionT result = this->EmptyExpression();
if (peek() == Token::FUNCTION) {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
Consume(Token::FUNCTION);
int function_token_position = position();
switch (peek()) {
case Token::LBRACK: {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
Consume(Token::LBRACK);
int pos = position();
}
case Token::PERIOD: {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
Consume(Token::PERIOD);
int pos = position();
case Token::TEMPLATE_SPAN:
case Token::TEMPLATE_TAIL: {
BindingPatternUnexpectedToken(classifier);
+ ArrowFormalParametersUnexpectedToken(classifier);
int pos;
if (scanner()->current_token() == Token::IDENTIFIER) {
pos = position();
#include <string.h>
#include "src/base/logging.h"
+#include "src/base/platform/platform.h"
namespace v8 {
+namespace internal {
#ifdef V8_USE_EXTERNAL_STARTUP_DATA
-StartupDataHandler::StartupDataHandler(const char* exec_path,
- const char* natives_blob,
- const char* snapshot_blob) {
- // If we have (at least one) explicitly given blob, use those.
- // If not, use the default blob locations next to the d8 binary.
- if (natives_blob || snapshot_blob) {
- LoadFromFiles(natives_blob, snapshot_blob);
- } else {
- char* natives;
- char* snapshot;
- LoadFromFiles(RelativePath(&natives, exec_path, "natives_blob.bin"),
- RelativePath(&snapshot, exec_path, "snapshot_blob.bin"));
+namespace {
- free(natives);
- free(snapshot);
- }
-}
+v8::StartupData g_natives;
+v8::StartupData g_snapshot;
-StartupDataHandler::~StartupDataHandler() {
- delete[] natives_.data;
- delete[] snapshot_.data;
+void ClearStartupData(v8::StartupData* data) {
+ data->data = nullptr;
+ data->raw_size = 0;
}
-char* StartupDataHandler::RelativePath(char** buffer, const char* exec_path,
- const char* name) {
- DCHECK(exec_path);
- const char* last_slash = strrchr(exec_path, '/');
- if (last_slash) {
- int after_slash = static_cast<int>(last_slash - exec_path + 1);
- int name_length = static_cast<int>(strlen(name));
- *buffer = reinterpret_cast<char*>(calloc(after_slash + name_length + 1, 1));
- strncpy(*buffer, exec_path, after_slash);
- strncat(*buffer, name, name_length);
- } else {
- *buffer = strdup(name);
- }
- return *buffer;
+void DeleteStartupData(v8::StartupData* data) {
+ delete[] data->data;
+ ClearStartupData(data);
}
-void StartupDataHandler::LoadFromFiles(const char* natives_blob,
- const char* snapshot_blob) {
- Load(natives_blob, &natives_, v8::V8::SetNativesDataBlob);
- Load(snapshot_blob, &snapshot_, v8::V8::SetSnapshotDataBlob);
+void FreeStartupData() {
+ DeleteStartupData(&g_natives);
+ DeleteStartupData(&g_snapshot);
}
-void StartupDataHandler::Load(const char* blob_file,
- v8::StartupData* startup_data,
- void (*setter_fn)(v8::StartupData*)) {
- startup_data->data = NULL;
- startup_data->raw_size = 0;
+void Load(const char* blob_file, v8::StartupData* startup_data,
+ void (*setter_fn)(v8::StartupData*)) {
+ ClearStartupData(startup_data);
if (!blob_file) return;
if (startup_data->raw_size == read_size) (*setter_fn)(startup_data);
}
+
+void LoadFromFiles(const char* natives_blob, const char* snapshot_blob) {
+ Load(natives_blob, &g_natives, v8::V8::SetNativesDataBlob);
+ Load(snapshot_blob, &g_snapshot, v8::V8::SetSnapshotDataBlob);
+
+ atexit(&FreeStartupData);
+}
+
+
+char* RelativePath(char** buffer, const char* exec_path, const char* name) {
+ DCHECK(exec_path);
+ int path_separator = static_cast<int>(strlen(exec_path)) - 1;
+ while (path_separator >= 0 &&
+ !base::OS::isDirectorySeparator(exec_path[path_separator])) {
+ path_separator--;
+ }
+ if (path_separator >= 0) {
+ int name_length = static_cast<int>(strlen(name));
+ *buffer =
+ reinterpret_cast<char*>(calloc(path_separator + name_length + 2, 1));
+ *buffer[0] = '\0';
+ strncat(*buffer, exec_path, path_separator + 1);
+ strncat(*buffer, name, name_length);
+ } else {
+ *buffer = strdup(name);
+ }
+ return *buffer;
+}
+
+} // namespace
#endif // V8_USE_EXTERNAL_STARTUP_DATA
+
+void InitializeExternalStartupData(const char* directory_path) {
+#ifdef V8_USE_EXTERNAL_STARTUP_DATA
+ char* natives;
+ char* snapshot;
+ LoadFromFiles(RelativePath(&natives, directory_path, "natives_blob.bin"),
+ RelativePath(&snapshot, directory_path, "snapshot_blob.bin"));
+ free(natives);
+ free(snapshot);
+#endif // V8_USE_EXTERNAL_STARTUP_DATA
+}
+
+
+void InitializeExternalStartupData(const char* natives_blob,
+ const char* snapshot_blob) {
+#ifdef V8_USE_EXTERNAL_STARTUP_DATA
+ LoadFromFiles(natives_blob, snapshot_blob);
+#endif // V8_USE_EXTERNAL_STARTUP_DATA
+}
+
+} // namespace internal
} // namespace v8
#include "include/v8.h"
namespace v8 {
+namespace internal {
-#ifdef V8_USE_EXTERNAL_STARTUP_DATA
-// Helper class to load the startup data files from disk.
+// Helper functions to load external startup data.
//
// This is meant as a convenience for stand-alone binaries like d8, cctest,
// unittest. A V8 embedder would likely either handle startup data on their
// own or just disable the feature if they don't want to handle it at all,
-// while tools like cctest need to work in either configuration. Hence this is
-// not meant for inclusion in the general v8 library.
-class StartupDataHandler {
- public:
- // Load startup data, and call the v8::V8::Set*DataBlob API functions.
- //
- // natives_blob and snapshot_blob will be loaded realitive to exec_path,
- // which would usually be the equivalent of argv[0].
- StartupDataHandler(const char* exec_path, const char* natives_blob,
- const char* snapshot_blob);
- ~StartupDataHandler();
-
- private:
- static char* RelativePath(char** buffer, const char* exec_path,
- const char* name);
-
- void LoadFromFiles(const char* natives_blob, const char* snapshot_blob);
-
- void Load(const char* blob_file, v8::StartupData* startup_data,
- void (*setter_fn)(v8::StartupData*));
-
- v8::StartupData natives_;
- v8::StartupData snapshot_;
-
- // Disallow copy & assign.
- StartupDataHandler(const StartupDataHandler& other);
- void operator=(const StartupDataHandler& other);
-};
-#endif // V8_USE_EXTERNAL_STARTUP_DATA
+// while tools like cctest need to work in either configuration.
+void InitializeExternalStartupData(const char* directory_path);
+
+void InitializeExternalStartupData(const char* natives_blob,
+ const char* snapshot_blob);
+
+} // namespace internal
} // namespace v8
#endif // V8_STARTUP_DATA_UTIL_H_
#include "test/cctest/profiler-extension.h"
#include "test/cctest/trace-extension.h"
-#ifdef V8_USE_EXTERNAL_STARTUP_DATA
-#include "src/startup-data-util.h"
-#endif // V8_USE_EXTERNAL_STARTUP_DATA
-
#if V8_OS_WIN
#include <windows.h> // NOLINT
#if V8_CC_MSVC
v8::V8::InitializePlatform(platform);
v8::internal::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
v8::V8::Initialize();
-#ifdef V8_USE_EXTERNAL_STARTUP_DATA
- v8::StartupDataHandler startup_data(argv[0], NULL, NULL);
-#endif
+ v8::V8::InitializeExternalStartupData(argv[0]);
CcTestArrayBufferAllocator array_buffer_allocator;
CcTest::set_array_buffer_allocator(&array_buffer_allocator);
'test-weakmaps.cc',
'test-weaksets.cc',
'trace-extension.cc',
- '../../src/startup-data-util.h',
- '../../src/startup-data-util.cc'
],
'conditions': [
['v8_target_arch=="ia32"', {
}
+TEST(ErrorsArrowFormalParameters) {
+ const char* context_data[][2] = {
+ { "()", "=>{}" },
+ { "()", "=>{};" },
+ { "var x = ()", "=>{}" },
+ { "var x = ()", "=>{};" },
+
+ { "a", "=>{}" },
+ { "a", "=>{};" },
+ { "var x = a", "=>{}" },
+ { "var x = a", "=>{};" },
+
+ { "(a)", "=>{}" },
+ { "(a)", "=>{};" },
+ { "var x = (a)", "=>{}" },
+ { "var x = (a)", "=>{};" },
+
+ { "(...a)", "=>{}" },
+ { "(...a)", "=>{};" },
+ { "var x = (...a)", "=>{}" },
+ { "var x = (...a)", "=>{};" },
+
+ { "(a,b)", "=>{}" },
+ { "(a,b)", "=>{};" },
+ { "var x = (a,b)", "=>{}" },
+ { "var x = (a,b)", "=>{};" },
+
+ { "(a,...b)", "=>{}" },
+ { "(a,...b)", "=>{};" },
+ { "var x = (a,...b)", "=>{}" },
+ { "var x = (a,...b)", "=>{};" },
+
+ { nullptr, nullptr }
+ };
+ const char* assignment_expression_suffix_data[] = {
+ "?c:d=>{}",
+ "=c=>{}",
+ "()",
+ "(c)",
+ "[1]",
+ "[c]",
+ ".c",
+ "-c",
+ "+c",
+ "c++",
+ "`c`",
+ "`${c}`",
+ "`template-head${c}`",
+ "`${c}template-tail`",
+ "`template-head${c}template-tail`",
+ "`${c}template-tail`",
+ nullptr
+ };
+
+ static const ParserFlag always_flags[] = { kAllowHarmonyArrowFunctions,
+ kAllowHarmonyRestParameters };
+ RunParserSyncTest(context_data, assignment_expression_suffix_data, kError,
+ NULL, 0, always_flags, arraysize(always_flags));
+}
+
+
TEST(ErrorsArrowFunctions) {
// Tests that parser and preparser generate the same kind of errors
// on invalid arrow function syntax.
#include "src/base/compiler-specific.h"
#include "testing/gmock/include/gmock/gmock.h"
-#ifdef V8_USE_EXTERNAL_STARTUP_DATA
-#include "src/startup-data-util.h"
-#endif // V8_USE_EXTERNAL_STARTUP_DATA
-
namespace {
class DefaultPlatformEnvironment final : public ::testing::Environment {
testing::InitGoogleMock(&argc, argv);
testing::AddGlobalTestEnvironment(new DefaultPlatformEnvironment);
v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
-#ifdef V8_USE_EXTERNAL_STARTUP_DATA
- v8::StartupDataHandler startup_data(argv[0], NULL, NULL);
-#endif
+ v8::V8::InitializeExternalStartupData(argv[0]);
return RUN_ALL_TESTS();
}
'run-all-unittests.cc',
'test-utils.h',
'test-utils.cc',
- '../../src/startup-data-util.h',
- '../../src/startup-data-util.cc'
],
'conditions': [
['v8_target_arch=="arm"', {
'../../src/snapshot/snapshot-source-sink.h',
'../../src/splay-tree.h',
'../../src/splay-tree-inl.h',
+ '../../src/startup-data-util.cc',
+ '../../src/startup-data-util.h',
'../../src/string-builder.cc',
'../../src/string-builder.h',
'../../src/string-search.cc',
v8::Platform* platform = v8::platform::CreateDefaultPlatform();
v8::V8::InitializePlatform(platform);
v8::V8::Initialize();
+ v8::V8::InitializeExternalStartupData(argv[0]);
+
Encoding encoding = LATIN1;
std::vector<std::string> fnames;
std::string benchmark;
projects / platform / upstream / nodejs.git / commitdiff