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

test/unittests/wasm/ast-decoder-unittest.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 "test/unittests/test-utils.h"
 
 #include "src/v8.h"
 
 #include "test/cctest/wasm/test-signatures.h"
 
@@ skipping 62 matching lines @@
   void AddLocals(LocalType type, uint32_t count) {
     local_decls.AddLocals(count, type);
   }
 
   // Preprends local variable declarations and renders nice error messages for
   // verification failures.
   void Verify(ErrorCode expected, FunctionSig* sig, const byte* start,
               const byte* end) {
     local_decls.Prepend(&start, &end);
     // Verify the code.
-    TreeResult result = VerifyWasmCode(module, sig, start, end);
+    TreeResult result =
+        VerifyWasmCode(zone()->allocator(), module, sig, start, end);
 
     if (result.error_code != expected) {
       ptrdiff_t pc = result.error_pc - result.start;
       ptrdiff_t pt = result.error_pt - result.start;
       std::ostringstream str;
       if (expected == kSuccess) {
         str << "Verification failed: " << result.error_code << " pc = +" << pc;
         if (result.error_pt) str << ", pt = +" << pt;
         str << ", msg = " << result.error_msg.get();
       } else {
@@ skipping 2110 matching lines @@
                    size_t count) {
     for (size_t i = 0; i < count; i++) {
       EXPECT_EQ(expected, map->at(pos++));
     }
     return pos;
   }
 };
 
 TEST_F(LocalDeclDecoderTest, NoLocals) {
   static const byte data[] = {0};
-  LocalTypeMap map = DecodeLocalDeclsForTesting(data, data + sizeof(data));
+  base::AccountingAllocator allocator;
+  LocalTypeMap map =
+      DecodeLocalDeclsForTesting(&allocator, data, data + sizeof(data));
   EXPECT_EQ(0, map->size());
   if (map) delete map;
 }
 
 TEST_F(LocalDeclDecoderTest, OneLocal) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalType type = kLocalTypes[i];
     const byte data[] = {
         1, 1, static_cast<byte>(WasmOpcodes::LocalTypeCodeFor(type))};
-    LocalTypeMap map = DecodeLocalDeclsForTesting(data, data + sizeof(data));
+    base::AccountingAllocator allocator;
+    LocalTypeMap map =
+        DecodeLocalDeclsForTesting(&allocator, data, data + sizeof(data));
     EXPECT_EQ(1, map->size());
     EXPECT_EQ(type, map->at(0));
     if (map) delete map;
   }
 }
 
 TEST_F(LocalDeclDecoderTest, FiveLocals) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalType type = kLocalTypes[i];
     const byte data[] = {
         1, 5, static_cast<byte>(WasmOpcodes::LocalTypeCodeFor(type))};
-    LocalTypeMap map = DecodeLocalDeclsForTesting(data, data + sizeof(data));
+    base::AccountingAllocator allocator;
+    LocalTypeMap map =
+        DecodeLocalDeclsForTesting(&allocator, data, data + sizeof(data));
     EXPECT_EQ(5, map->size());
     ExpectRun(map, 0, type, 5);
     if (map) delete map;
   }
 }
 
 TEST_F(LocalDeclDecoderTest, MixedLocals) {
   for (byte a = 0; a < 3; a++) {
     for (byte b = 0; b < 3; b++) {
       for (byte c = 0; c < 3; c++) {
         for (byte d = 0; d < 3; d++) {
           const byte data[] = {4, a,         kLocalI32, b,        kLocalI64,
                                c, kLocalF32, d,         kLocalF64};
+          base::AccountingAllocator allocator;
           LocalTypeMap map =
-              DecodeLocalDeclsForTesting(data, data + sizeof(data));
+              DecodeLocalDeclsForTesting(&allocator, data, data + sizeof(data));
           EXPECT_EQ(a + b + c + d, map->size());
 
           size_t pos = 0;
           pos = ExpectRun(map, pos, kAstI32, a);
           pos = ExpectRun(map, pos, kAstI64, b);
           pos = ExpectRun(map, pos, kAstF32, c);
           pos = ExpectRun(map, pos, kAstF64, d);
 
           if (map) delete map;
         }
       }
     }
   }
 }
 
 TEST_F(LocalDeclDecoderTest, UseEncoder) {
   const byte* data = nullptr;
   const byte* end = nullptr;
   LocalDeclEncoder local_decls;
 
   local_decls.AddLocals(5, kAstF32);
   local_decls.AddLocals(1337, kAstI32);
   local_decls.AddLocals(212, kAstI64);
   local_decls.Prepend(&data, &end);
 
-  LocalTypeMap map = DecodeLocalDeclsForTesting(data, end);
+  base::AccountingAllocator allocator;
+  LocalTypeMap map = DecodeLocalDeclsForTesting(&allocator, data, end);
   size_t pos = 0;
   pos = ExpectRun(map, pos, kAstF32, 5);
   pos = ExpectRun(map, pos, kAstI32, 1337);
   pos = ExpectRun(map, pos, kAstI64, 212);
 
   if (map) delete map;
   delete[] data;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8