Expose a lower bound of malloc'd memory via heap statistics

test/cctest/compiler/test-run-native-calls.cc

 // Copyright 2015 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.
 
 #include "src/assembler.h"
 #include "src/codegen.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/raw-machine-assembler.h"
 #include "src/machine-type.h"
 #include "src/register-configuration.h"
@@ skipping 252 matching lines @@
   if (FLAG_print_opt_code) {
     OFStream os(stdout);
     code->Disassemble(name, os);
   }
 #endif
   return code;
 }
 
 
 Handle<Code> WrapWithCFunction(Handle<Code> inner, CallDescriptor* desc) {
-  Zone zone;
+  ZoneForTesting zone;
   MachineSignature* msig =
       const_cast<MachineSignature*>(desc->GetMachineSignature());
   int param_count = static_cast<int>(msig->parameter_count());
   GraphAndBuilders caller(&zone);
   {
     GraphAndBuilders& b = caller;
     Node* start = b.graph()->NewNode(b.common()->Start(param_count + 3));
     b.graph()->SetStart(start);
     Node* target = b.graph()->NewNode(b.common()->HeapConstant(inner));
 
@@ skipping 146 matching lines @@
                   void (*build)(CallDescriptor*, RawMachineAssembler&),
                   CType (*compute)(CallDescriptor*, CType* inputs),
                   int seed = 1) {
     int num_params = ParamCount(desc);
     CHECK_LE(num_params, kMaxParamCount);
     Isolate* isolate = CcTest::InitIsolateOnce();
     HandleScope scope(isolate);
     Handle<Code> inner = Handle<Code>::null();
     {
       // Build the graph for the computation.
-      Zone zone;
+      ZoneForTesting zone;
       Graph graph(&zone);
       RawMachineAssembler raw(isolate, &graph, desc);
       build(desc, raw);
       inner = CompileGraph("Compute", desc, &graph, raw.Export());
     }
 
     CSignature0<int32_t> csig;
     ArgsBuffer<CType> io(num_params, seed);
 
     {
       // constant mode.
       Handle<Code> wrapper = Handle<Code>::null();
       {
         // Wrap the above code with a callable function that passes constants.
-        Zone zone;
+        ZoneForTesting zone;
         Graph graph(&zone);
         CallDescriptor* cdesc = Linkage::GetSimplifiedCDescriptor(&zone, &csig);
         RawMachineAssembler raw(isolate, &graph, cdesc);
         Node* target = raw.HeapConstant(inner);
         Node** args = zone.NewArray<Node*>(num_params);
         for (int i = 0; i < num_params; i++) {
           args[i] = io.MakeConstant(raw, io.input[i]);
         }
 
         Node* call = raw.CallN(desc, target, args);
@@ skipping 11 matching lines @@
       int32_t check_seed = runnable.Call();
       CHECK_EQ(seed, check_seed);
       CHECK_EQ(expected, io.output);
     }
 
     {
       // buffer mode.
       Handle<Code> wrapper = Handle<Code>::null();
       {
         // Wrap the above code with a callable function that loads from {input}.
-        Zone zone;
+        ZoneForTesting zone;
         Graph graph(&zone);
         CallDescriptor* cdesc = Linkage::GetSimplifiedCDescriptor(&zone, &csig);
         RawMachineAssembler raw(isolate, &graph, cdesc);
         Node* base = raw.PointerConstant(io.input);
         Node* target = raw.HeapConstant(inner);
         Node** args = zone.NewArray<Node*>(kMaxParamCount);
         for (int i = 0; i < num_params; i++) {
           args[i] = io.LoadInput(raw, base, i);
         }
 
@@ skipping 17 matching lines @@
     }
   }
 };
 
 }  // namespace
 
 
 static void TestInt32Sub(CallDescriptor* desc) {
   Isolate* isolate = CcTest::InitIsolateOnce();
   HandleScope scope(isolate);
-  Zone zone;
+  ZoneForTesting zone;
   GraphAndBuilders inner(&zone);
   {
     // Build the add function.
     GraphAndBuilders& b = inner;
     Node* start = b.graph()->NewNode(b.common()->Start(5));
     b.graph()->SetStart(start);
     Node* p0 = b.graph()->NewNode(b.common()->Parameter(0), start);
     Node* p1 = b.graph()->NewNode(b.common()->Parameter(1), start);
     Node* add = b.graph()->NewNode(b.machine()->Int32Sub(), p0, p1);
     Node* ret = b.graph()->NewNode(b.common()->Return(), add, start, start);
@@ skipping 20 matching lines @@
 
 static void CopyTwentyInt32(CallDescriptor* desc) {
   const int kNumParams = 20;
   int32_t input[kNumParams];
   int32_t output[kNumParams];
   Isolate* isolate = CcTest::InitIsolateOnce();
   HandleScope scope(isolate);
   Handle<Code> inner = Handle<Code>::null();
   {
     // Writes all parameters into the output buffer.
-    Zone zone;
+    ZoneForTesting zone;
     Graph graph(&zone);
     RawMachineAssembler raw(isolate, &graph, desc);
     Node* base = raw.PointerConstant(output);
     for (int i = 0; i < kNumParams; i++) {
       Node* offset = raw.Int32Constant(i * sizeof(int32_t));
       raw.Store(MachineRepresentation::kWord32, base, offset, raw.Parameter(i),
                 kNoWriteBarrier);
     }
     raw.Return(raw.Int32Constant(42));
     inner = CompileGraph("CopyTwentyInt32", desc, &graph, raw.Export());
   }
 
   CSignature0<int32_t> csig;
   Handle<Code> wrapper = Handle<Code>::null();
   {
     // Loads parameters from the input buffer and calls the above code.
-    Zone zone;
+    ZoneForTesting zone;
     Graph graph(&zone);
     CallDescriptor* cdesc = Linkage::GetSimplifiedCDescriptor(&zone, &csig);
     RawMachineAssembler raw(isolate, &graph, cdesc);
     Node* base = raw.PointerConstant(input);
     Node* target = raw.HeapConstant(inner);
     Node** args = zone.NewArray<Node*>(kNumParams);
     for (int i = 0; i < kNumParams; i++) {
       Node* offset = raw.Int32Constant(i * sizeof(int32_t));
       args[i] = raw.Load(MachineType::Int32(), base, offset);
     }
@@ skipping 18 matching lines @@
 
     for (int j = 0; j < kNumParams; j++) {
       CHECK_EQ(input[j], output[j]);
     }
   }
 }
 
 
 static void Test_RunInt32SubWithRet(int retreg) {
   Int32Signature sig(2);
-  Zone zone;
+  ZoneForTesting zone;
   RegisterPairs pairs;
   while (pairs.More()) {
     int parray[2];
     int rarray[] = {retreg};
     pairs.Next(&parray[0], &parray[1], false);
     Allocator params(parray, 2, nullptr, 0);
     Allocator rets(rarray, 1, nullptr, 0);
     RegisterConfig config(params, rets);
     CallDescriptor* desc = config.Create(&zone, &sig);
     TestInt32Sub(desc);
@@ skipping 30 matching lines @@
 TEST_INT32_SUB_WITH_RET(16)
 TEST_INT32_SUB_WITH_RET(17)
 TEST_INT32_SUB_WITH_RET(18)
 TEST_INT32_SUB_WITH_RET(19)
 
 
 TEST(Run_Int32Sub_all_allocatable_single) {
   Int32Signature sig(2);
   RegisterPairs pairs;
   while (pairs.More()) {
-    Zone zone;
+    ZoneForTesting zone;
     int parray[1];
     int rarray[1];
     pairs.Next(&rarray[0], &parray[0], true);
     Allocator params(parray, 1, nullptr, 0);
     Allocator rets(rarray, 1, nullptr, 0);
     RegisterConfig config(params, rets);
     CallDescriptor* desc = config.Create(&zone, &sig);
     TestInt32Sub(desc);
   }
 }
 
 
 TEST(Run_CopyTwentyInt32_all_allocatable_pairs) {
   Int32Signature sig(20);
   RegisterPairs pairs;
   while (pairs.More()) {
-    Zone zone;
+    ZoneForTesting zone;
     int parray[2];
     int rarray[] = {
         RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
             ->GetAllocatableGeneralCode(0)};
     pairs.Next(&parray[0], &parray[1], false);
     Allocator params(parray, 2, nullptr, 0);
     Allocator rets(rarray, 1, nullptr, 0);
     RegisterConfig config(params, rets);
     CallDescriptor* desc = config.Create(&zone, &sig);
     CopyTwentyInt32(desc);
@@ skipping 31 matching lines @@
     result += static_cast<uint32_t>(input[i]) * coeff[i];
   }
   return static_cast<int32_t>(result);
 }
 
 
 static void Test_Int32_WeightedSum_of_size(int count) {
   Int32Signature sig(count);
   for (int p0 = 0; p0 < Register::kNumRegisters; p0++) {
     if (Register::from_code(p0).IsAllocatable()) {
-      Zone zone;
+      ZoneForTesting zone;
 
       int parray[] = {p0};
       int rarray[] = {
           RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
               ->GetAllocatableGeneralCode(0)};
       Allocator params(parray, 1, nullptr, 0);
       Allocator rets(rarray, 1, nullptr, 0);
       RegisterConfig config(params, rets);
       CallDescriptor* desc = config.Create(&zone, &sig);
       Run_Computation<int32_t>(desc, Build_Int32_WeightedSum,
@@ skipping 47 matching lines @@
   int parray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableGeneralCode(0)};
   int rarray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableGeneralCode(0)};
   Allocator params(parray, 1, nullptr, 0);
   Allocator rets(rarray, 1, nullptr, 0);
   RegisterConfig config(params, rets);
 
-  Zone zone;
+  ZoneForTesting zone;
 
   for (int i = which + 1; i <= 64; i++) {
     Int32Signature sig(i);
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<int32_t, which>(desc);
   }
 }
 
 
 // Separate tests for parallelization.
@@ skipping 21 matching lines @@
           ->num_allocatable_general_registers() < 2)
     return;
   if (kPointerSize < 8) return;  // TODO(titzer): int64 on 32-bit platforms
 
   int rarray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableGeneralCode(0)};
   ArgsBuffer<int64_t>::Sig sig(2);
 
   RegisterPairs pairs;
-  Zone zone;
+  ZoneForTesting zone;
   while (pairs.More()) {
     int parray[2];
     pairs.Next(&parray[0], &parray[1], false);
     Allocator params(parray, 2, nullptr, 0);
     Allocator rets(rarray, 1, nullptr, 0);
     RegisterConfig config(params, rets);
 
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<int64_t, 0>(desc);
     RunSelect<int64_t, 1>(desc);
   }
 }
 
 
 TEST(Float32Select_registers) {
   if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->num_allocatable_double_registers() < 2) {
     return;
   }
 
   int rarray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(0)};
   ArgsBuffer<float32>::Sig sig(2);
 
   Float32RegisterPairs pairs;
-  Zone zone;
+  ZoneForTesting zone;
   while (pairs.More()) {
     int parray[2];
     pairs.Next(&parray[0], &parray[1], false);
     Allocator params(nullptr, 0, parray, 2);
     Allocator rets(nullptr, 0, rarray, 1);
     RegisterConfig config(params, rets);
 
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<float32, 0>(desc);
     RunSelect<float32, 1>(desc);
   }
 }
 
 
 TEST(Float64Select_registers) {
   if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->num_allocatable_double_registers() < 2)
     return;
   if (RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->num_allocatable_general_registers() < 2)
     return;
   int rarray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(0)};
   ArgsBuffer<float64>::Sig sig(2);
 
   Float64RegisterPairs pairs;
-  Zone zone;
+  ZoneForTesting zone;
   while (pairs.More()) {
     int parray[2];
     pairs.Next(&parray[0], &parray[1], false);
     Allocator params(nullptr, 0, parray, 2);
     Allocator rets(nullptr, 0, rarray, 1);
     RegisterConfig config(params, rets);
 
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<float64, 0>(desc);
     RunSelect<float64, 1>(desc);
   }
 }
 
 
 TEST(Float32Select_stack_params_return_reg) {
   int rarray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(0)};
   Allocator params(nullptr, 0, nullptr, 0);
   Allocator rets(nullptr, 0, rarray, 1);
   RegisterConfig config(params, rets);
 
-  Zone zone;
+  ZoneForTesting zone;
   for (int count = 1; count < 6; count++) {
     ArgsBuffer<float32>::Sig sig(count);
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<float32, 0>(desc);
     RunSelect<float32, 1>(desc);
     RunSelect<float32, 2>(desc);
     RunSelect<float32, 3>(desc);
     RunSelect<float32, 4>(desc);
     RunSelect<float32, 5>(desc);
   }
 }
 
 
 TEST(Float64Select_stack_params_return_reg) {
   int rarray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(0)};
   Allocator params(nullptr, 0, nullptr, 0);
   Allocator rets(nullptr, 0, rarray, 1);
   RegisterConfig config(params, rets);
 
-  Zone zone;
+  ZoneForTesting zone;
   for (int count = 1; count < 6; count++) {
     ArgsBuffer<float64>::Sig sig(count);
     CallDescriptor* desc = config.Create(&zone, &sig);
     RunSelect<float64, 0>(desc);
     RunSelect<float64, 1>(desc);
     RunSelect<float64, 2>(desc);
     RunSelect<float64, 3>(desc);
     RunSelect<float64, 4>(desc);
     RunSelect<float64, 5>(desc);
   }
 }
 
 
 template <typename CType, int which>
 static void Build_Select_With_Call(CallDescriptor* desc,
                                    RawMachineAssembler& raw) {
   Handle<Code> inner = Handle<Code>::null();
   int num_params = ParamCount(desc);
   CHECK_LE(num_params, kMaxParamCount);
   {
     Isolate* isolate = CcTest::InitIsolateOnce();
     // Build the actual select.
-    Zone zone;
+    ZoneForTesting zone;
     Graph graph(&zone);
     RawMachineAssembler raw(isolate, &graph, desc);
     raw.Return(raw.Parameter(which));
     inner = CompileGraph("Select-indirection", desc, &graph, raw.Export());
     CHECK(!inner.is_null());
     CHECK(inner->IsCode());
   }
 
   {
     // Build a call to the function that does the select.
     Node* target = raw.HeapConstant(inner);
     Node** args = raw.zone()->NewArray<Node*>(num_params);
     for (int i = 0; i < num_params; i++) {
       args[i] = raw.Parameter(i);
     }
 
     Node* call = raw.CallN(desc, target, args);
     raw.Return(call);
   }
 }
 
 
 TEST(Float64StackParamsToStackParams) {
   int rarray[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(0)};
   Allocator params(nullptr, 0, nullptr, 0);
   Allocator rets(nullptr, 0, rarray, 1);
 
-  Zone zone;
+  ZoneForTesting zone;
   ArgsBuffer<float64>::Sig sig(2);
   RegisterConfig config(params, rets);
   CallDescriptor* desc = config.Create(&zone, &sig);
 
   Run_Computation<float64>(desc, Build_Select_With_Call<float64, 0>,
                            Compute_Select<float64, 0>, 1098);
 
   Run_Computation<float64>(desc, Build_Select_With_Call<float64, 1>,
                            Compute_Select<float64, 1>, 1099);
 }
@@ skipping 45 matching lines @@
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(1)};
   int rarray_fp[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(0)};
   Allocator palloc(parray_gp, 2, parray_fp, 2);
   Allocator ralloc(rarray_gp, 1, rarray_fp, 1);
   RegisterConfig config(palloc, ralloc);
 
   for (int which = 0; which < num_params; which++) {
-    Zone zone;
+    ZoneForTesting zone;
     HandleScope scope(isolate);
     MachineSignature::Builder builder(&zone, 1, num_params);
     builder.AddReturn(params[which]);
     for (int j = 0; j < num_params; j++) builder.AddParam(params[j]);
     MachineSignature* sig = builder.Build();
     CallDescriptor* desc = config.Create(&zone, sig);
 
     Handle<Code> select;
     {
       // build the select.
-      Zone zone;
+      ZoneForTesting zone;
       Graph graph(&zone);
       RawMachineAssembler raw(isolate, &graph, desc);
       raw.Return(raw.Parameter(which));
       select = CompileGraph("Compute", desc, &graph, raw.Export());
     }
 
     {
       // call the select.
       Handle<Code> wrapper = Handle<Code>::null();
       int32_t expected_ret;
       char bytes[kDoubleSize];
       V8_ALIGNED(8) char output[kDoubleSize];
       int expected_size = 0;
       CSignature0<int32_t> csig;
       {
         // Wrap the select code with a callable function that passes constants.
-        Zone zone;
+        ZoneForTesting zone;
         Graph graph(&zone);
         CallDescriptor* cdesc = Linkage::GetSimplifiedCDescriptor(&zone, &csig);
         RawMachineAssembler raw(isolate, &graph, cdesc);
         Node* target = raw.HeapConstant(select);
         Node** args = zone.NewArray<Node*>(num_params);
         int64_t constant = 0x0102030405060708;
         for (int i = 0; i < num_params; i++) {
           MachineType param_type = sig->GetParam(i);
           Node* konst = nullptr;
           if (param_type == MachineType::Int32()) {
@@ skipping 72 matching lines @@
           ->GetAllocatableDoubleCode(0),
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(1)};
   int rarray_fp[] = {
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN)
           ->GetAllocatableDoubleCode(0)};
   Allocator palloc(parray_gp, 2, parray_fp, 2);
   Allocator ralloc(rarray_gp, 1, rarray_fp, 1);
   RegisterConfig config(palloc, ralloc);
 
-  Zone zone;
+  ZoneForTesting zone;
   HandleScope scope(isolate);
   MachineSignature::Builder builder(&zone, 1, 12);
   builder.AddReturn(MachineType::Int32());
   for (int i = 0; i < 10; i++) {
     builder.AddParam(MachineType::Int32());
   }
   builder.AddParam(slot_type);
   builder.AddParam(MachineType::Pointer());
   MachineSignature* sig = builder.Build();
   CallDescriptor* desc = config.Create(&zone, sig);
@@ skipping 43 matching lines @@
   TestStackSlot(MachineType::Float32(), magic);
 }
 
 TEST(RunStackSlotFloat64) {
   double magic = 3456.375;
   TestStackSlot(MachineType::Float64(), magic);
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8