1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
// Copyright 2016 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.
// Test specific cases of the lazy/eager-parse decision.
//
// Note that presently most unit tests for parsing are found in
// cctest/test-parsing.cc.
#include <unordered_map>
#include "include/v8.h"
#include "src/api-inl.h"
#include "src/handles-inl.h"
#include "src/isolate.h"
#include "src/objects-inl.h"
#include "src/utils.h"
#include "test/cctest/cctest.h"
namespace v8 {
namespace internal {
namespace {
// Record the 'compiled' state of all top level functions.
void GetTopLevelFunctionInfo(
v8::Local<v8::Script> script,
std::unordered_map<std::string, bool>* is_compiled) {
// Get the v8::internal::Script object from the API v8::Script.
// The API object 'wraps' the compiled top-level function, not the i::Script.
Handle<JSFunction> toplevel_fn = v8::Utils::OpenHandle(*script);
SharedFunctionInfo::ScriptIterator iterator(
toplevel_fn->GetIsolate(), Script::cast(toplevel_fn->shared()->script()));
for (SharedFunctionInfo shared = iterator.Next(); !shared.is_null();
shared = iterator.Next()) {
std::unique_ptr<char[]> name = String::cast(shared->Name())->ToCString();
is_compiled->insert(std::make_pair(name.get(), shared->is_compiled()));
}
}
} // anonymous namespace
TEST(GetTopLevelFunctionInfo) {
if (!FLAG_lazy) return;
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
LocalContext env;
const char src[] = "function foo() { var a; }\n";
std::unordered_map<std::string, bool> is_compiled;
GetTopLevelFunctionInfo(v8_compile(src), &is_compiled);
// Test that our helper function GetTopLevelFunctionInfo does what it claims:
DCHECK(is_compiled.find("foo") != is_compiled.end());
DCHECK(is_compiled.find("bar") == is_compiled.end());
}
TEST(EagerlyCompileImmediateUseFunctions) {
if (!FLAG_lazy) return;
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
LocalContext env;
// Test parenthesized, exclaimed, and regular functions. Make sure these
// occur both intermixed and after each other, to make sure the 'reset'
// mechanism works.
const char src[] =
"function normal() { var a; }\n" // Normal: Should lazy parse.
"(function parenthesized() { var b; })()\n" // Parenthesized: Pre-parse.
"!function exclaimed() { var c; }() \n" // Exclaimed: Pre-parse.
"function normal2() { var d; }\n"
"(function parenthesized2() { var e; })()\n"
"function normal3() { var f; }\n"
"!function exclaimed2() { var g; }() \n"
"function normal4() { var h; }\n";
std::unordered_map<std::string, bool> is_compiled;
GetTopLevelFunctionInfo(v8_compile(src), &is_compiled);
DCHECK(is_compiled["parenthesized"]);
DCHECK(is_compiled["parenthesized2"]);
DCHECK(is_compiled["exclaimed"]);
DCHECK(is_compiled["exclaimed2"]);
DCHECK(!is_compiled["normal"]);
DCHECK(!is_compiled["normal2"]);
DCHECK(!is_compiled["normal3"]);
DCHECK(!is_compiled["normal4"]);
}
TEST(CommaFunctionSequence) {
if (!FLAG_lazy) return;
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
LocalContext env;
const char src[] = "!function a(){}(),function b(){}(),function c(){}();";
std::unordered_map<std::string, bool> is_compiled;
GetTopLevelFunctionInfo(v8_compile(src), &is_compiled);
DCHECK(is_compiled["a"]);
DCHECK(is_compiled["b"]);
DCHECK(is_compiled["c"]);
}
} // namespace internal
} // namespace v8
|
