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

test/cctest/wasm/wasm-run-utils.h

 // 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 203 matching lines @@
     // limit number of globals.
     CHECK_LT(global_offset, kMaxGlobalsSize);
     return &module->globals.back();
   }
 };
 
 inline void TestBuildingGraph(Zone* zone, JSGraph* jsgraph, ModuleEnv* module,
                               FunctionSig* sig, const byte* start,
                               const byte* end) {
   compiler::WasmGraphBuilder builder(zone, jsgraph, sig);
-  TreeResult result = BuildTFGraph(&builder, module, sig, start, end);
+  TreeResult result =
+      BuildTFGraph(zone->allocator(), &builder, module, sig, start, end);
   if (result.failed()) {
     ptrdiff_t pc = result.error_pc - result.start;
     ptrdiff_t pt = result.error_pt - result.start;
     std::ostringstream str;
     str << "Verification failed: " << result.error_code << " pc = +" << pc;
     if (result.error_pt) str << ", pt = +" << pt;
     str << ", msg = " << result.error_msg.get();
     FATAL(str.str().c_str());
   }
   builder.Int64LoweringForTesting();
@@ skipping 243 matching lines @@
 
 // A helper class to build graphs from Wasm bytecode, generate machine
 // code, and run that code.
 template <typename ReturnType>
 class WasmRunner {
  public:
   WasmRunner(MachineType p0 = MachineType::None(),
              MachineType p1 = MachineType::None(),
              MachineType p2 = MachineType::None(),
              MachineType p3 = MachineType::None())
-      : compiled_(false),
-
+      : zone(&allocator_),
+        compiled_(false),
         signature_(MachineTypeForC<ReturnType>() == MachineType::None() ? 0 : 1,
                    GetParameterCount(p0, p1, p2, p3), storage_),
         compiler_(&signature_, nullptr) {
     InitSigStorage(p0, p1, p2, p3);
   }
 
   WasmRunner(TestingModule* module, MachineType p0 = MachineType::None(),
              MachineType p1 = MachineType::None(),
              MachineType p2 = MachineType::None(),
              MachineType p3 = MachineType::None())
-      : compiled_(false),
+      : zone(&allocator_),
+        compiled_(false),
         signature_(MachineTypeForC<ReturnType>() == MachineType::None() ? 0 : 1,
                    GetParameterCount(p0, p1, p2, p3), storage_),
         compiler_(&signature_, module) {
     DCHECK(module);
     InitSigStorage(p0, p1, p2, p3);
   }
 
   void InitSigStorage(MachineType p0, MachineType p1, MachineType p2,
                       MachineType p3) {
     int index = 0;
@@ skipping 59 matching lines @@
     ReturnType return_value;
     int32_t result = runner.Call<void*, void*, void*, void*, void*>(
         &p0, &p1, &p2, &p3, &return_value);
     CHECK_EQ(WASM_WRAPPER_RETURN_VALUE, result);
     return return_value;
   }
 
   byte AllocateLocal(LocalType type) { return compiler_.AllocateLocal(type); }
 
  protected:
+  v8::base::AccountingAllocator allocator_;
   Zone zone;
   bool compiled_;
   LocalType storage_[WASM_RUNNER_MAX_NUM_PARAMETERS];
   FunctionSig signature_;
   WasmFunctionCompiler compiler_;
   WasmFunctionWrapper<ReturnType> wrapper_;
 
   static size_t GetParameterCount(MachineType p0, MachineType p1,
                                   MachineType p2, MachineType p3) {
     if (p0 == MachineType::None()) return 0;
     if (p1 == MachineType::None()) return 1;
     if (p2 == MachineType::None()) return 2;
     if (p3 == MachineType::None()) return 3;
     return 4;
   }
 };
 
 }  // namespace
 
 #endif