Add m-esr52 at 52.6.0

1 files changed, 247 insertions, 0 deletions

diff --git a/layout/base/nsPresArena.cpp b/layout/base/nsPresArena.cpp
new file mode 100644
index 000000000..2b1f072df
--- /dev/null
+++ b/layout/base/nsPresArena.cpp
@@ -0,0 +1,247 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: set ts=2 sw=2 et tw=78:
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/* arena allocation for the frame tree and closely-related objects */
+
+// Even on 32-bit systems, we allocate objects from the frame arena
+// that require 8-byte alignment.  The cast to uintptr_t is needed
+// because plarena isn't as careful about mask construction as it
+// ought to be.
+#define ALIGN_SHIFT 3
+#define PL_ARENA_CONST_ALIGN_MASK ((uintptr_t(1) << ALIGN_SHIFT) - 1)
+#include "plarena.h"
+// plarena.h needs to be included first to make it use the above
+// PL_ARENA_CONST_ALIGN_MASK in this file.
+
+#include "nsPresArena.h"
+
+#include "mozilla/Poison.h"
+#include "nsDebug.h"
+#include "nsArenaMemoryStats.h"
+#include "nsPrintfCString.h"
+#include "nsStyleContext.h"
+
+#include <inttypes.h>
+
+using namespace mozilla;
+
+// Size to use for PLArena block allocations.
+static const size_t ARENA_PAGE_SIZE = 8192;
+
+nsPresArena::nsPresArena()
+{
+  PL_INIT_ARENA_POOL(&mPool, "PresArena", ARENA_PAGE_SIZE);
+}
+
+nsPresArena::~nsPresArena()
+{
+  ClearArenaRefPtrs();
+
+#if defined(MOZ_HAVE_MEM_CHECKS)
+  for (auto iter = mFreeLists.Iter(); !iter.Done(); iter.Next()) {
+    FreeList* entry = iter.Get();
+    nsTArray<void*>::index_type len;
+    while ((len = entry->mEntries.Length())) {
+      void* result = entry->mEntries.ElementAt(len - 1);
+      entry->mEntries.RemoveElementAt(len - 1);
+      MOZ_MAKE_MEM_UNDEFINED(result, entry->mEntrySize);
+    }
+  }
+#endif
+
+  PL_FinishArenaPool(&mPool);
+}
+
+/* inline */ void
+nsPresArena::ClearArenaRefPtrWithoutDeregistering(void* aPtr,
+                                                  ArenaObjectID aObjectID)
+{
+  switch (aObjectID) {
+#define PRES_ARENA_OBJECT_WITH_ARENAREFPTR_SUPPORT(name_)                     \
+    case eArenaObjectID_##name_:                                              \
+      static_cast<ArenaRefPtr<name_>*>(aPtr)->ClearWithoutDeregistering();    \
+      return;
+#include "nsPresArenaObjectList.h"
+#undef PRES_ARENA_OBJECT_WITH_ARENAREFPTR_SUPPORT
+    default:
+      break;
+  }
+  switch (aObjectID) {
+#define PRES_ARENA_OBJECT_WITHOUT_ARENAREFPTR_SUPPORT(name_)                  \
+    case eArenaObjectID_##name_:                                              \
+      MOZ_ASSERT(false, #name_ " must be declared in nsPresArenaObjectList.h "\
+                        "with PRES_ARENA_OBJECT_SUPPORTS_ARENAREFPTR");       \
+      break;
+#include "nsPresArenaObjectList.h"
+#undef PRES_ARENA_OBJECT_WITHOUT_ARENAREFPTR_SUPPORT
+    default:
+      MOZ_ASSERT(false, "unexpected ArenaObjectID value");
+      break;
+  }
+}
+
+void
+nsPresArena::ClearArenaRefPtrs()
+{
+  for (auto iter = mArenaRefPtrs.Iter(); !iter.Done(); iter.Next()) {
+    void* ptr = iter.Key();
+    ArenaObjectID id = iter.UserData();
+    ClearArenaRefPtrWithoutDeregistering(ptr, id);
+  }
+  mArenaRefPtrs.Clear();
+}
+
+void
+nsPresArena::ClearArenaRefPtrs(ArenaObjectID aObjectID)
+{
+  for (auto iter = mArenaRefPtrs.Iter(); !iter.Done(); iter.Next()) {
+    void* ptr = iter.Key();
+    ArenaObjectID id = iter.UserData();
+    if (id == aObjectID) {
+      ClearArenaRefPtrWithoutDeregistering(ptr, id);
+      iter.Remove();
+    }
+  }
+}
+
+void*
+nsPresArena::Allocate(uint32_t aCode, size_t aSize)
+{
+  MOZ_ASSERT(aSize > 0, "PresArena cannot allocate zero bytes");
+
+  // We only hand out aligned sizes
+  aSize = PL_ARENA_ALIGN(&mPool, aSize);
+
+  // If there is no free-list entry for this type already, we have
+  // to create one now, to record its size.
+  FreeList* list = mFreeLists.PutEntry(aCode);
+
+  nsTArray<void*>::index_type len = list->mEntries.Length();
+  if (list->mEntrySize == 0) {
+    MOZ_ASSERT(len == 0, "list with entries but no recorded size");
+    list->mEntrySize = aSize;
+  } else {
+    MOZ_ASSERT(list->mEntrySize == aSize,
+               "different sizes for same object type code");
+  }
+
+  void* result;
+  if (len > 0) {
+    // LIFO behavior for best cache utilization
+    result = list->mEntries.ElementAt(len - 1);
+    list->mEntries.RemoveElementAt(len - 1);
+#if defined(DEBUG)
+    {
+      MOZ_MAKE_MEM_DEFINED(result, list->mEntrySize);
+      char* p = reinterpret_cast<char*>(result);
+      char* limit = p + list->mEntrySize;
+      for (; p < limit; p += sizeof(uintptr_t)) {
+        uintptr_t val = *reinterpret_cast<uintptr_t*>(p);
+        if (val != mozPoisonValue()) {
+          MOZ_ReportAssertionFailure(
+            nsPrintfCString("PresArena: poison overwritten; "
+                            "wanted %.16" PRIx64 " "
+                            "found %.16" PRIx64 " "
+                            "errors in bits %.16" PRIx64 " ",
+                            uint64_t(mozPoisonValue()),
+                            uint64_t(val),
+                            uint64_t(mozPoisonValue() ^ val)).get(),
+            __FILE__, __LINE__);
+          MOZ_CRASH();
+        }
+      }
+    }
+#endif
+    MOZ_MAKE_MEM_UNDEFINED(result, list->mEntrySize);
+    return result;
+  }
+
+  // Allocate a new chunk from the arena
+  list->mEntriesEverAllocated++;
+  PL_ARENA_ALLOCATE(result, &mPool, aSize);
+  if (!result) {
+    NS_ABORT_OOM(aSize);
+  }
+  return result;
+}
+
+void
+nsPresArena::Free(uint32_t aCode, void* aPtr)
+{
+  // Try to recycle this entry.
+  FreeList* list = mFreeLists.GetEntry(aCode);
+  MOZ_ASSERT(list, "no free list for pres arena object");
+  MOZ_ASSERT(list->mEntrySize > 0, "PresArena cannot free zero bytes");
+
+  mozWritePoison(aPtr, list->mEntrySize);
+
+  MOZ_MAKE_MEM_NOACCESS(aPtr, list->mEntrySize);
+  list->mEntries.AppendElement(aPtr);
+}
+
+void
+nsPresArena::AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                                    nsArenaMemoryStats* aArenaStats)
+{
+  // We do a complicated dance here because we want to measure the
+  // space taken up by the different kinds of objects in the arena,
+  // but we don't have pointers to those objects.  And even if we did,
+  // we wouldn't be able to use aMallocSizeOf on them, since they were
+  // allocated out of malloc'd chunks of memory.  So we compute the
+  // size of the arena as known by malloc and we add up the sizes of
+  // all the objects that we care about.  Subtracting these two
+  // quantities gives us a catch-all "other" number, which includes
+  // slop in the arena itself as well as the size of objects that
+  // we've not measured explicitly.
+
+  size_t mallocSize = PL_SizeOfArenaPoolExcludingPool(&mPool, aMallocSizeOf);
+  mallocSize += mFreeLists.SizeOfExcludingThis(aMallocSizeOf);
+
+  size_t totalSizeInFreeLists = 0;
+  for (auto iter = mFreeLists.Iter(); !iter.Done(); iter.Next()) {
+    FreeList* entry = iter.Get();
+
+    // Note that we're not measuring the size of the entries on the free
+    // list here.  The free list knows how many objects we've allocated
+    // ever (which includes any objects that may be on the FreeList's
+    // |mEntries| at this point) and we're using that to determine the
+    // total size of objects allocated with a given ID.
+    size_t totalSize = entry->mEntrySize * entry->mEntriesEverAllocated;
+    size_t* p;
+
+    switch (NS_PTR_TO_INT32(entry->mKey)) {
+#define FRAME_ID(classname)                               \
+      case nsQueryFrame::classname##_id:                  \
+        p = &aArenaStats->FRAME_ID_STAT_FIELD(classname); \
+        break;
+#include "nsFrameIdList.h"
+#undef FRAME_ID
+      case eArenaObjectID_nsLineBox:
+        p = &aArenaStats->mLineBoxes;
+        break;
+      case eArenaObjectID_nsRuleNode:
+        p = &aArenaStats->mRuleNodes;
+        break;
+      case eArenaObjectID_nsStyleContext:
+        p = &aArenaStats->mStyleContexts;
+        break;
+#define STYLE_STRUCT(name_, checkdata_cb_)      \
+        case eArenaObjectID_nsStyle##name_:
+#include "nsStyleStructList.h"
+#undef STYLE_STRUCT
+        p = &aArenaStats->mStyleStructs;
+        break;
+      default:
+        continue;
+    }
+
+    *p += totalSize;
+    totalSizeInFreeLists += totalSize;
+  }
+
+  aArenaStats->mOther += mallocSize - totalSizeInFreeLists;
+}