1 // Copyright 2006-2009 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 //
28 // Tests of logging functions from log.h
29
30 #ifdef __linux__
31 #include <pthread.h>
32 #include <signal.h>
33 #include <unistd.h>
34 #include <cmath>
35 #endif // __linux__
36
37 #include "src/v8.h"
38
39 #include "src/log.h"
40 #include "src/log-utils.h"
41 #include "src/profiler/cpu-profiler.h"
42 #include "src/snapshot/natives.h"
43 #include "src/utils.h"
44 #include "src/v8threads.h"
45 #include "src/version.h"
46 #include "src/vm-state-inl.h"
47 #include "test/cctest/cctest.h"
48
49 using v8::internal::Address;
50 using v8::internal::EmbeddedVector;
51 using v8::internal::Logger;
52 using v8::internal::StrLength;
53
54 namespace {
55
56
57 #define SETUP_FLAGS() \
58 bool saved_log = i::FLAG_log; \
59 bool saved_prof = i::FLAG_prof; \
60 i::FLAG_log = true; \
61 i::FLAG_prof = true; \
62 i::FLAG_logfile = i::Log::kLogToTemporaryFile; \
63 i::FLAG_logfile_per_isolate = false
64
65
66 class ScopedLoggerInitializer {
67 public:
ScopedLoggerInitializer(bool saved_log,bool saved_prof,v8::Isolate * isolate)68 ScopedLoggerInitializer(bool saved_log, bool saved_prof, v8::Isolate* isolate)
69 : saved_log_(saved_log),
70 saved_prof_(saved_prof),
71 temp_file_(NULL),
72 isolate_(isolate),
73 isolate_scope_(isolate),
74 scope_(isolate),
75 env_(v8::Context::New(isolate)),
76 logger_(reinterpret_cast<i::Isolate*>(isolate)->logger()) {
77 env_->Enter();
78 }
79
~ScopedLoggerInitializer()80 ~ScopedLoggerInitializer() {
81 env_->Exit();
82 logger_->TearDown();
83 if (temp_file_ != NULL) fclose(temp_file_);
84 i::FLAG_prof = saved_prof_;
85 i::FLAG_log = saved_log_;
86 }
87
env()88 v8::Local<v8::Context>& env() { return env_; }
89
isolate()90 v8::Isolate* isolate() { return isolate_; }
91
logger()92 Logger* logger() { return logger_; }
93
StopLoggingGetTempFile()94 FILE* StopLoggingGetTempFile() {
95 temp_file_ = logger_->TearDown();
96 CHECK(temp_file_);
97 fflush(temp_file_);
98 rewind(temp_file_);
99 return temp_file_;
100 }
101
102 private:
103 const bool saved_log_;
104 const bool saved_prof_;
105 FILE* temp_file_;
106 v8::Isolate* isolate_;
107 v8::Isolate::Scope isolate_scope_;
108 v8::HandleScope scope_;
109 v8::Local<v8::Context> env_;
110 Logger* logger_;
111
112 DISALLOW_COPY_AND_ASSIGN(ScopedLoggerInitializer);
113 };
114
115 } // namespace
116
117
StrNStr(const char * s1,const char * s2,int n)118 static const char* StrNStr(const char* s1, const char* s2, int n) {
119 if (s1[n] == '\0') return strstr(s1, s2);
120 i::ScopedVector<char> str(n + 1);
121 i::StrNCpy(str, s1, static_cast<size_t>(n));
122 str[n] = '\0';
123 char* found = strstr(str.start(), s2);
124 return found != NULL ? s1 + (found - str.start()) : NULL;
125 }
126
127
128 // BUG(913). Need to implement support for profiling multiple VM threads.
129 #if 0
130
131 namespace {
132
133 class LoopingThread : public v8::internal::Thread {
134 public:
135 explicit LoopingThread(v8::internal::Isolate* isolate)
136 : v8::internal::Thread(isolate),
137 semaphore_(new v8::internal::Semaphore(0)),
138 run_(true) {
139 }
140
141 virtual ~LoopingThread() { delete semaphore_; }
142
143 void Run() {
144 self_ = pthread_self();
145 RunLoop();
146 }
147
148 void SendSigProf() { pthread_kill(self_, SIGPROF); }
149
150 void Stop() { run_ = false; }
151
152 bool WaitForRunning() { return semaphore_->Wait(1000000); }
153
154 protected:
155 bool IsRunning() { return run_; }
156
157 virtual void RunLoop() = 0;
158
159 void SetV8ThreadId() {
160 v8_thread_id_ = v8::V8::GetCurrentThreadId();
161 }
162
163 void SignalRunning() { semaphore_->Signal(); }
164
165 private:
166 v8::internal::Semaphore* semaphore_;
167 bool run_;
168 pthread_t self_;
169 int v8_thread_id_;
170 };
171
172
173 class LoopingJsThread : public LoopingThread {
174 public:
175 explicit LoopingJsThread(v8::internal::Isolate* isolate)
176 : LoopingThread(isolate) { }
177 void RunLoop() {
178 v8::Locker locker;
179 CHECK(CcTest::i_isolate() != NULL);
180 CHECK_GT(CcTest::i_isolate()->thread_manager()->CurrentId(), 0);
181 SetV8ThreadId();
182 while (IsRunning()) {
183 v8::HandleScope scope;
184 v8::Persistent<v8::Context> context = v8::Context::New();
185 CHECK(!context.IsEmpty());
186 {
187 v8::Context::Scope context_scope(context);
188 SignalRunning();
189 CompileRun(
190 "var j; for (var i=0; i<10000; ++i) { j = Math.sin(i); }");
191 }
192 context.Dispose();
193 i::OS::Sleep(v8::base::TimeDelta::FromMilliseconds(1));
194 }
195 }
196 };
197
198
199 class LoopingNonJsThread : public LoopingThread {
200 public:
201 explicit LoopingNonJsThread(v8::internal::Isolate* isolate)
202 : LoopingThread(isolate) { }
203 void RunLoop() {
204 v8::Locker locker;
205 v8::Unlocker unlocker;
206 // Now thread has V8's id, but will not run VM code.
207 CHECK(CcTest::i_isolate() != NULL);
208 CHECK_GT(CcTest::i_isolate()->thread_manager()->CurrentId(), 0);
209 double i = 10;
210 SignalRunning();
211 while (IsRunning()) {
212 i = std::sin(i);
213 i::OS::Sleep(v8::base::TimeDelta::FromMilliseconds(1));
214 }
215 }
216 };
217
218
219 class TestSampler : public v8::internal::Sampler {
220 public:
221 explicit TestSampler(v8::internal::Isolate* isolate)
222 : Sampler(isolate, 0, true, true),
223 semaphore_(new v8::internal::Semaphore(0)),
224 was_sample_stack_called_(false) {
225 }
226
227 ~TestSampler() { delete semaphore_; }
228
229 void SampleStack(v8::internal::TickSample*) {
230 was_sample_stack_called_ = true;
231 }
232
233 void Tick(v8::internal::TickSample*) { semaphore_->Signal(); }
234
235 bool WaitForTick() { return semaphore_->Wait(1000000); }
236
237 void Reset() { was_sample_stack_called_ = false; }
238
239 bool WasSampleStackCalled() { return was_sample_stack_called_; }
240
241 private:
242 v8::internal::Semaphore* semaphore_;
243 bool was_sample_stack_called_;
244 };
245
246
247 } // namespace
248
249 TEST(ProfMultipleThreads) {
250 TestSampler* sampler = NULL;
251 {
252 v8::Locker locker;
253 sampler = new TestSampler(CcTest::i_isolate());
254 sampler->Start();
255 CHECK(sampler->IsActive());
256 }
257
258 LoopingJsThread jsThread(CcTest::i_isolate());
259 jsThread.Start();
260 LoopingNonJsThread nonJsThread(CcTest::i_isolate());
261 nonJsThread.Start();
262
263 CHECK(!sampler->WasSampleStackCalled());
264 jsThread.WaitForRunning();
265 jsThread.SendSigProf();
266 CHECK(sampler->WaitForTick());
267 CHECK(sampler->WasSampleStackCalled());
268 sampler->Reset();
269 CHECK(!sampler->WasSampleStackCalled());
270 nonJsThread.WaitForRunning();
271 nonJsThread.SendSigProf();
272 CHECK(!sampler->WaitForTick());
273 CHECK(!sampler->WasSampleStackCalled());
274 sampler->Stop();
275
276 jsThread.Stop();
277 nonJsThread.Stop();
278 jsThread.Join();
279 nonJsThread.Join();
280
281 delete sampler;
282 }
283
284 #endif // __linux__
285
286
287 // Test for issue http://crbug.com/23768 in Chromium.
288 // Heap can contain scripts with already disposed external sources.
289 // We need to verify that LogCompiledFunctions doesn't crash on them.
290 namespace {
291
292 class SimpleExternalString : public v8::String::ExternalStringResource {
293 public:
SimpleExternalString(const char * source)294 explicit SimpleExternalString(const char* source)
295 : utf_source_(StrLength(source)) {
296 for (int i = 0; i < utf_source_.length(); ++i)
297 utf_source_[i] = source[i];
298 }
~SimpleExternalString()299 virtual ~SimpleExternalString() {}
length() const300 virtual size_t length() const { return utf_source_.length(); }
data() const301 virtual const uint16_t* data() const { return utf_source_.start(); }
302 private:
303 i::ScopedVector<uint16_t> utf_source_;
304 };
305
306 } // namespace
307
TEST(Issue23768)308 TEST(Issue23768) {
309 v8::HandleScope scope(CcTest::isolate());
310 v8::Local<v8::Context> env = v8::Context::New(CcTest::isolate());
311 env->Enter();
312
313 SimpleExternalString source_ext_str("(function ext() {})();");
314 v8::Local<v8::String> source =
315 v8::String::NewExternalTwoByte(CcTest::isolate(), &source_ext_str)
316 .ToLocalChecked();
317 // Script needs to have a name in order to trigger InitLineEnds execution.
318 v8::Local<v8::String> origin =
319 v8::String::NewFromUtf8(CcTest::isolate(), "issue-23768-test",
320 v8::NewStringType::kNormal)
321 .ToLocalChecked();
322 v8::Local<v8::Script> evil_script = CompileWithOrigin(source, origin);
323 CHECK(!evil_script.IsEmpty());
324 CHECK(!evil_script->Run(env).IsEmpty());
325 i::Handle<i::ExternalTwoByteString> i_source(
326 i::ExternalTwoByteString::cast(*v8::Utils::OpenHandle(*source)));
327 // This situation can happen if source was an external string disposed
328 // by its owner.
329 i_source->set_resource(NULL);
330
331 // Must not crash.
332 CcTest::i_isolate()->logger()->LogCompiledFunctions();
333 }
334
335
ObjMethod1(const v8::FunctionCallbackInfo<v8::Value> & args)336 static void ObjMethod1(const v8::FunctionCallbackInfo<v8::Value>& args) {
337 }
338
339
TEST(LogCallbacks)340 TEST(LogCallbacks) {
341 SETUP_FLAGS();
342 v8::Isolate::CreateParams create_params;
343 create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
344 v8::Isolate* isolate = v8::Isolate::New(create_params);
345 {
346 ScopedLoggerInitializer initialize_logger(saved_log, saved_prof, isolate);
347 Logger* logger = initialize_logger.logger();
348
349 v8::Local<v8::FunctionTemplate> obj = v8::Local<v8::FunctionTemplate>::New(
350 isolate, v8::FunctionTemplate::New(isolate));
351 obj->SetClassName(v8_str("Obj"));
352 v8::Local<v8::ObjectTemplate> proto = obj->PrototypeTemplate();
353 v8::Local<v8::Signature> signature = v8::Signature::New(isolate, obj);
354 proto->Set(v8_str("method1"),
355 v8::FunctionTemplate::New(isolate, ObjMethod1,
356 v8::Local<v8::Value>(), signature),
357 static_cast<v8::PropertyAttribute>(v8::DontDelete));
358
359 initialize_logger.env()
360 ->Global()
361 ->Set(initialize_logger.env(), v8_str("Obj"),
362 obj->GetFunction(initialize_logger.env()).ToLocalChecked())
363 .FromJust();
364 CompileRun("Obj.prototype.method1.toString();");
365
366 logger->LogCompiledFunctions();
367
368 bool exists = false;
369 i::Vector<const char> log(
370 i::ReadFile(initialize_logger.StopLoggingGetTempFile(), &exists, true));
371 CHECK(exists);
372
373 i::EmbeddedVector<char, 100> ref_data;
374 i::SNPrintF(ref_data,
375 "code-creation,Callback,-2,0x%" V8PRIxPTR ",1,\"method1\"",
376 reinterpret_cast<intptr_t>(ObjMethod1));
377
378 CHECK(StrNStr(log.start(), ref_data.start(), log.length()));
379 log.Dispose();
380 }
381 isolate->Dispose();
382 }
383
384
Prop1Getter(v8::Local<v8::String> property,const v8::PropertyCallbackInfo<v8::Value> & info)385 static void Prop1Getter(v8::Local<v8::String> property,
386 const v8::PropertyCallbackInfo<v8::Value>& info) {
387 }
388
Prop1Setter(v8::Local<v8::String> property,v8::Local<v8::Value> value,const v8::PropertyCallbackInfo<void> & info)389 static void Prop1Setter(v8::Local<v8::String> property,
390 v8::Local<v8::Value> value,
391 const v8::PropertyCallbackInfo<void>& info) {
392 }
393
Prop2Getter(v8::Local<v8::String> property,const v8::PropertyCallbackInfo<v8::Value> & info)394 static void Prop2Getter(v8::Local<v8::String> property,
395 const v8::PropertyCallbackInfo<v8::Value>& info) {
396 }
397
398
TEST(LogAccessorCallbacks)399 TEST(LogAccessorCallbacks) {
400 SETUP_FLAGS();
401 v8::Isolate::CreateParams create_params;
402 create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
403 v8::Isolate* isolate = v8::Isolate::New(create_params);
404 {
405 ScopedLoggerInitializer initialize_logger(saved_log, saved_prof, isolate);
406 Logger* logger = initialize_logger.logger();
407
408 v8::Local<v8::FunctionTemplate> obj = v8::Local<v8::FunctionTemplate>::New(
409 isolate, v8::FunctionTemplate::New(isolate));
410 obj->SetClassName(v8_str("Obj"));
411 v8::Local<v8::ObjectTemplate> inst = obj->InstanceTemplate();
412 inst->SetAccessor(v8_str("prop1"), Prop1Getter, Prop1Setter);
413 inst->SetAccessor(v8_str("prop2"), Prop2Getter);
414
415 logger->LogAccessorCallbacks();
416
417 bool exists = false;
418 i::Vector<const char> log(
419 i::ReadFile(initialize_logger.StopLoggingGetTempFile(), &exists, true));
420 CHECK(exists);
421
422 EmbeddedVector<char, 100> prop1_getter_record;
423 i::SNPrintF(prop1_getter_record,
424 "code-creation,Callback,-2,0x%" V8PRIxPTR ",1,\"get prop1\"",
425 reinterpret_cast<intptr_t>(Prop1Getter));
426 CHECK(StrNStr(log.start(), prop1_getter_record.start(), log.length()));
427
428 EmbeddedVector<char, 100> prop1_setter_record;
429 i::SNPrintF(prop1_setter_record,
430 "code-creation,Callback,-2,0x%" V8PRIxPTR ",1,\"set prop1\"",
431 reinterpret_cast<intptr_t>(Prop1Setter));
432 CHECK(StrNStr(log.start(), prop1_setter_record.start(), log.length()));
433
434 EmbeddedVector<char, 100> prop2_getter_record;
435 i::SNPrintF(prop2_getter_record,
436 "code-creation,Callback,-2,0x%" V8PRIxPTR ",1,\"get prop2\"",
437 reinterpret_cast<intptr_t>(Prop2Getter));
438 CHECK(StrNStr(log.start(), prop2_getter_record.start(), log.length()));
439 log.Dispose();
440 }
441 isolate->Dispose();
442 }
443
444
445 typedef i::NativesCollection<i::TEST> TestSources;
446
447
448 // Test that logging of code create / move events is equivalent to traversal of
449 // a resulting heap.
TEST(EquivalenceOfLoggingAndTraversal)450 TEST(EquivalenceOfLoggingAndTraversal) {
451 // This test needs to be run on a "clean" V8 to ensure that snapshot log
452 // is loaded. This is always true when running using tools/test.py because
453 // it launches a new cctest instance for every test. To be sure that launching
454 // cctest manually also works, please be sure that no tests below
455 // are using V8.
456
457 // Start with profiling to capture all code events from the beginning.
458 SETUP_FLAGS();
459 v8::Isolate::CreateParams create_params;
460 create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
461 v8::Isolate* isolate = v8::Isolate::New(create_params);
462 {
463 ScopedLoggerInitializer initialize_logger(saved_log, saved_prof, isolate);
464 Logger* logger = initialize_logger.logger();
465
466 // Compile and run a function that creates other functions.
467 CompileRun(
468 "(function f(obj) {\n"
469 " obj.test =\n"
470 " (function a(j) { return function b() { return j; } })(100);\n"
471 "})(this);");
472 logger->StopProfiler();
473 reinterpret_cast<i::Isolate*>(isolate)->heap()->CollectAllGarbage(
474 i::Heap::kMakeHeapIterableMask);
475 logger->StringEvent("test-logging-done", "");
476
477 // Iterate heap to find compiled functions, will write to log.
478 logger->LogCompiledFunctions();
479 logger->StringEvent("test-traversal-done", "");
480
481 bool exists = false;
482 i::Vector<const char> log(
483 i::ReadFile(initialize_logger.StopLoggingGetTempFile(), &exists, true));
484 CHECK(exists);
485 v8::Local<v8::String> log_str =
486 v8::String::NewFromUtf8(isolate, log.start(),
487 v8::NewStringType::kNormal, log.length())
488 .ToLocalChecked();
489 initialize_logger.env()
490 ->Global()
491 ->Set(initialize_logger.env(), v8_str("_log"), log_str)
492 .FromJust();
493
494 i::Vector<const char> source = TestSources::GetScriptsSource();
495 v8::Local<v8::String> source_str =
496 v8::String::NewFromUtf8(isolate, source.start(),
497 v8::NewStringType::kNormal, source.length())
498 .ToLocalChecked();
499 v8::TryCatch try_catch(isolate);
500 v8::Local<v8::Script> script = CompileWithOrigin(source_str, "");
501 if (script.IsEmpty()) {
502 v8::String::Utf8Value exception(try_catch.Exception());
503 printf("compile: %s\n", *exception);
504 CHECK(false);
505 }
506 v8::Local<v8::Value> result;
507 if (!script->Run(initialize_logger.env()).ToLocal(&result)) {
508 v8::String::Utf8Value exception(try_catch.Exception());
509 printf("run: %s\n", *exception);
510 CHECK(false);
511 }
512 // The result either be a "true" literal or problem description.
513 if (!result->IsTrue()) {
514 v8::Local<v8::String> s =
515 result->ToString(initialize_logger.env()).ToLocalChecked();
516 i::ScopedVector<char> data(s->Utf8Length() + 1);
517 CHECK(data.start());
518 s->WriteUtf8(data.start());
519 printf("%s\n", data.start());
520 // Make sure that our output is written prior crash due to CHECK failure.
521 fflush(stdout);
522 CHECK(false);
523 }
524 }
525 isolate->Dispose();
526 }
527
528
TEST(LogVersion)529 TEST(LogVersion) {
530 SETUP_FLAGS();
531 v8::Isolate::CreateParams create_params;
532 create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
533 v8::Isolate* isolate = v8::Isolate::New(create_params);
534 {
535 ScopedLoggerInitializer initialize_logger(saved_log, saved_prof, isolate);
536 bool exists = false;
537 i::Vector<const char> log(
538 i::ReadFile(initialize_logger.StopLoggingGetTempFile(), &exists, true));
539 CHECK(exists);
540 i::EmbeddedVector<char, 100> ref_data;
541 i::SNPrintF(ref_data, "v8-version,%d,%d,%d,%d,%d", i::Version::GetMajor(),
542 i::Version::GetMinor(), i::Version::GetBuild(),
543 i::Version::GetPatch(), i::Version::IsCandidate());
544 CHECK(StrNStr(log.start(), ref_data.start(), log.length()));
545 log.Dispose();
546 }
547 isolate->Dispose();
548 }
549
550
551 // https://crbug.com/539892
552 // CodeCreateEvents with really large names should not crash.
TEST(Issue539892)553 TEST(Issue539892) {
554 class : public i::CodeEventLogger {
555 public:
556 virtual void CodeMoveEvent(Address from, Address to) {}
557 virtual void CodeDeleteEvent(Address from) {}
558 virtual void CodeDisableOptEvent(i::Code* code,
559 i::SharedFunctionInfo* shared) {}
560
561 private:
562 virtual void LogRecordedBuffer(i::Code* code, i::SharedFunctionInfo* shared,
563 const char* name, int length) {}
564 } code_event_logger;
565 SETUP_FLAGS();
566 v8::Isolate::CreateParams create_params;
567 create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
568 v8::Isolate* isolate = v8::Isolate::New(create_params);
569
570 {
571 ScopedLoggerInitializer initialize_logger(saved_log, saved_prof, isolate);
572 Logger* logger = initialize_logger.logger();
573 logger->addCodeEventListener(&code_event_logger);
574
575 // Function with a really large name.
576 const char* source_text =
577 "(function "
578 "baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
579 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
580 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
581 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
582 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
583 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
584 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
585 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
586 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
587 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
588 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
589 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
590 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
591 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
592 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
593 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
594 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac"
595 "(){})();";
596
597 CompileRun(source_text);
598
599 // Must not crash.
600 logger->LogCompiledFunctions();
601 }
602 isolate->Dispose();
603 }
604