Pass ArrayBuffer::Allocator via Isolate::CreateParams

test/cctest/test-deoptimization.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 331 matching lines @@
   CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
   CHECK_EQ(14, env->Global()->Get(v8_str("result"))->Int32Value());
   CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(CcTest::i_isolate()));
 }
 
 
 UNINITIALIZED_TEST(DeoptimizeBinaryOperationADDString) {
   i::FLAG_turbo_deoptimization = true;
   i::FLAG_concurrent_recompilation = false;
   AllowNativesSyntaxNoInlining options;
-  v8::Isolate* isolate = v8::Isolate::New();
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+  v8::Isolate* isolate = v8::Isolate::New(create_params);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   isolate->Enter();
   {
     LocalContext env(isolate);
     v8::HandleScope scope(env->GetIsolate());
 
     const char* f_source = "function f(x, y) { return x + y; };";
 
     {
       // Compile function f and collect to type feedback to insert binary op
@@ skipping 81 matching lines @@
   CompileRun("deopt = true;"
              "var result = f(7, new X());");
   NonIncrementalGC(i_isolate);
   CHECK(!GetJSFunction((*env)->Global(), "f")->IsOptimized());
 }
 
 
 UNINITIALIZED_TEST(DeoptimizeBinaryOperationADD) {
   i::FLAG_turbo_deoptimization = true;
   i::FLAG_concurrent_recompilation = false;
-  v8::Isolate* isolate = v8::Isolate::New();
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+  v8::Isolate* isolate = v8::Isolate::New(create_params);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   isolate->Enter();
   {
     LocalContext env(isolate);
     v8::HandleScope scope(env->GetIsolate());
 
     TestDeoptimizeBinaryOpHelper(&env, "+");
 
     CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
     CHECK_EQ(15, env->Global()->Get(v8_str("result"))->Int32Value());
     CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(i_isolate));
   }
   isolate->Exit();
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_TEST(DeoptimizeBinaryOperationSUB) {
   i::FLAG_turbo_deoptimization = true;
   i::FLAG_concurrent_recompilation = false;
-  v8::Isolate* isolate = v8::Isolate::New();
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+  v8::Isolate* isolate = v8::Isolate::New(create_params);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   isolate->Enter();
   {
     LocalContext env(isolate);
     v8::HandleScope scope(env->GetIsolate());
 
     TestDeoptimizeBinaryOpHelper(&env, "-");
 
     CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
     CHECK_EQ(-1, env->Global()->Get(v8_str("result"))->Int32Value());
     CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(i_isolate));
   }
   isolate->Exit();
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_TEST(DeoptimizeBinaryOperationMUL) {
   i::FLAG_turbo_deoptimization = true;
   i::FLAG_concurrent_recompilation = false;
-  v8::Isolate* isolate = v8::Isolate::New();
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+  v8::Isolate* isolate = v8::Isolate::New(create_params);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   isolate->Enter();
   {
     LocalContext env(isolate);
     v8::HandleScope scope(env->GetIsolate());
 
     TestDeoptimizeBinaryOpHelper(&env, "*");
 
     CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
     CHECK_EQ(56, env->Global()->Get(v8_str("result"))->Int32Value());
     CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(i_isolate));
   }
   isolate->Exit();
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_TEST(DeoptimizeBinaryOperationDIV) {
   i::FLAG_turbo_deoptimization = true;
   i::FLAG_concurrent_recompilation = false;
-  v8::Isolate* isolate = v8::Isolate::New();
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+  v8::Isolate* isolate = v8::Isolate::New(create_params);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   isolate->Enter();
   {
     LocalContext env(isolate);
     v8::HandleScope scope(env->GetIsolate());
 
     TestDeoptimizeBinaryOpHelper(&env, "/");
 
     CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
     CHECK_EQ(0, env->Global()->Get(v8_str("result"))->Int32Value());
     CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(i_isolate));
   }
   isolate->Exit();
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_TEST(DeoptimizeBinaryOperationMOD) {
   i::FLAG_turbo_deoptimization = true;
   i::FLAG_concurrent_recompilation = false;
-  v8::Isolate* isolate = v8::Isolate::New();
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+  v8::Isolate* isolate = v8::Isolate::New(create_params);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   isolate->Enter();
   {
     LocalContext env(isolate);
     v8::HandleScope scope(env->GetIsolate());
 
     TestDeoptimizeBinaryOpHelper(&env, "%");
 
     CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
     CHECK_EQ(7, env->Global()->Get(v8_str("result"))->Int32Value());
     CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(i_isolate));
   }
   isolate->Exit();
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_TEST(DeoptimizeCompare) {
   i::FLAG_turbo_deoptimization = true;
   i::FLAG_concurrent_recompilation = false;
-  v8::Isolate* isolate = v8::Isolate::New();
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+  v8::Isolate* isolate = v8::Isolate::New(create_params);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   isolate->Enter();
   {
     LocalContext env(isolate);
     v8::HandleScope scope(env->GetIsolate());
 
     const char* f_source = "function f(x, y) { return x < y; };";
 
     {
       AllowNativesSyntaxNoInlining options;
@@ skipping 34 matching lines @@
     CHECK_EQ(0, Deoptimizer::GetDeoptimizedCodeCount(i_isolate));
   }
   isolate->Exit();
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_TEST(DeoptimizeLoadICStoreIC) {
   i::FLAG_turbo_deoptimization = true;
   i::FLAG_concurrent_recompilation = false;
-  v8::Isolate* isolate = v8::Isolate::New();
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+  v8::Isolate* isolate = v8::Isolate::New(create_params);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   isolate->Enter();
   {
     LocalContext env(isolate);
     v8::HandleScope scope(env->GetIsolate());
 
     // Functions to generate load/store/keyed load/keyed store IC calls.
     const char* f1_source = "function f1(x) { return x.y; };";
     const char* g1_source = "function g1(x) { x.y = 1; };";
     const char* f2_source = "function f2(x, y) { return x[y]; };";
@@ skipping 70 matching lines @@
     CHECK_EQ(13, env->Global()->Get(v8_str("result"))->Int32Value());
   }
   isolate->Exit();
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_TEST(DeoptimizeLoadICStoreICNested) {
   i::FLAG_turbo_deoptimization = true;
   i::FLAG_concurrent_recompilation = false;
-  v8::Isolate* isolate = v8::Isolate::New();
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+  v8::Isolate* isolate = v8::Isolate::New(create_params);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   isolate->Enter();
   {
     LocalContext env(isolate);
     v8::HandleScope scope(env->GetIsolate());
 
     // Functions to generate load/store/keyed load/keyed store IC calls.
     const char* f1_source = "function f1(x) { return x.y; };";
     const char* g1_source = "function g1(x) { x.y = 1; };";
     const char* f2_source = "function f2(x, y) { return x[y]; };";
@@ skipping 66 matching lines @@
     CHECK(!GetJSFunction(env->Global(), "f1")->IsOptimized());
     CHECK(!GetJSFunction(env->Global(), "g1")->IsOptimized());
     CHECK(!GetJSFunction(env->Global(), "f2")->IsOptimized());
     CHECK(!GetJSFunction(env->Global(), "g2")->IsOptimized());
     CHECK_EQ(1, env->Global()->Get(v8_str("count"))->Int32Value());
     CHECK_EQ(13, env->Global()->Get(v8_str("result"))->Int32Value());
   }
   isolate->Exit();
   isolate->Dispose();
 }