tools/trace-malloc/types.dat
author Tim Taubert <tim.taubert@gmx.de>
Tue, 24 Apr 2012 11:35:52 -0400
changeset 93562 357da346ceb705d196a46574804c7c4ec44ac186
parent 68123 f54747d3a9087414d41d7c8894b8c67fa52c4474
child 95919 f4157e8c410708d76703f19e4dfb61859bfe32d8
permissions -rw-r--r--
merge m-c to fx-team; a=desktop-only

# ***** BEGIN LICENSE BLOCK *****
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
#
# The contents of this file are subject to the Mozilla Public License Version
# 1.1 (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
# http://www.mozilla.org/MPL/
#
# Software distributed under the License is distributed on an "AS IS" basis,
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
# for the specific language governing rights and limitations under the
# License.
#
# The Original Code is types.dat, released
# Nov 27, 2000.
#
# The Initial Developer of the Original Code is
# Netscape Communications Corporation.
# Portions created by the Initial Developer are Copyright (C) 2000
# the Initial Developer. All Rights Reserved.
#
# Contributor(s):
#   Chris Waterson <waterson@netscape.com>
#
# Alternatively, the contents of this file may be used under the terms of
# either the GNU General Public License Version 2 or later (the "GPL"), or
# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
# in which case the provisions of the GPL or the LGPL are applicable instead
# of those above. If you wish to allow use of your version of this file only
# under the terms of either the GPL or the LGPL, and not to allow others to
# use your version of this file under the terms of the MPL, indicate your
# decision by deleting the provisions above and replace them with the notice
# and other provisions required by the GPL or the LGPL. If you do not delete
# the provisions above, a recipient may use your version of this file under
# the terms of any one of the MPL, the GPL or the LGPL.
#
# ***** END LICENSE BLOCK *****

# This file contains type inference information that is intended to be
# used with TraceMalloc.pm. The format of the file is:
#
#   <InferredType>
#   Stack1
#   Stack2
#   ...
#   StackN
#
# Where Stack1...StackN imply that the object's type is
# InferredType. Note that in many cases, we'll ``roll up'' storage
# that's part of an object's implementation into the object itself.

# Here's a handy regexp for cleaning up strings copied from the
# uncategorized file:
#
#   \(^ *([0-9]+) \|\[.*\]$\)
#

#----------------------------------------------------------------------

<nsStringRecycler>
__builtin_new
__builtin_vec_new
nsDeque::GrowCapacity(void)
nsDeque::Push(void *)
nsStringRecycler::Recycle(nsString *)

#----------------------------------------------------------------------
#
# AtomImpl
#

# Give AtomImpl objects the memory they allocate for storage
<AtomImpl>
__builtin_new
AtomImpl::operator new(unsigned int, basic_nsAReadableString<unsigned short> const &)

# Give AtomImpl objects the memory allocated for their table
<AtomImpl>
PL_DHashAllocTable
PL_DHashTableFinish
PL_DHashTableOperate
NS_NewPermanentAtom(char const *)
NS_NewAtom(nsAString const &)

<AtomImpl>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
NS_NewAtom(nsAString const &)
NS_NewAtom(char const *)

<AtomImpl>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
NS_NewAtom(nsAString const &)
NS_NewAtom(unsigned short const *)

#----------------------------------------------------------------------

<nsCSSSelector>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
nsString::nsString(nsString const &)
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

<nsCSSSelector>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
nsString::nsString(nsString const &)
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

<nsCSSRule>
__builtin_new
nsCSSRule::operator new(unsigned int)

#----------------------------------------------------------------------
#
# CSSLoaderImpl
#

<CSSLoaderImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
CSSLoaderImpl::CSSLoaderImpl(void)

<CSSLoaderImpl>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
nsString::AppendWithConversion(char const *, int)
nsString::AssignWithConversion(char const *)
CSSLoaderImpl::SetCharset(nsString const &)

<CSSLoaderImpl>
PL_strdup
URLKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
CSSLoaderImpl::SheetComplete(nsICSSStyleSheet *, SheetLoadData *)

#----------------------------------------------------------------------

<CSSNameSpaceRuleImpl>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
CSSNameSpaceRuleImpl::SetURLSpec(nsString const &)

#----------------------------------------------------------------------
#
# nsFont
#

<nsFont>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
nsString::nsString(nsString const &)
nsFont::nsFont(nsFont const &)

<nsFont>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
nsString::AppendWithConversion(char const *, int)
nsString::AssignWithConversion(char const *)
nsFont::nsFont(char const *, unsigned char, unsigned char, unsigned short, unsigned char, int, float)

#----------------------------------------------------------------------

<CSSImportantRule>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
CSSImportRuleImpl::SetURLSpec(nsString const &)

<nsClassList>
__builtin_new
nsClassList::ParseClasses(nsClassList **, basic_nsAReadableString<unsigned short> const &)

# ----------------------------------------------------------------------
#
# nsLocalFile
#

<nsLocalFile>
__builtin_new
nsLocalFile::Clone(nsIFile **)

<nsLocalFile>
PR_Malloc
_PR_Getfd
PR_GetConnectStatus
PR_OpenFile
PR_Open
nsLocalFile::OpenNSPRFileDesc(int, int, PRFileDesc **)

<nsLocalFile>
PR_Calloc
PR_LoadLibrary
PR_LoadLibraryWithFlags
PR_LoadLibrary
nsLocalFile::Load(PRLibrary **)

<nsLocalFile>
__strdup
PR_LoadLibrary
PR_LoadLibraryWithFlags
PR_LoadLibrary
nsLocalFile::Load(PRLibrary **)

<nsLocalFile>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewCString(nsACString const &)
nsLocalFile::AppendRelativePath(char const *)

<nsLocalFile>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Clone(void const *, unsigned int)
nsLocalFile::InitWithPath(char const *)

<nsLocalFile>
PL_strdup
nsLocalFile::ParseURL(char const *, char **, char **, char **, char **)

# ----------------------------------------------------------------------

<nsXULAttribute>
__builtin_new
nsXULAttribute::operator new(unsigned int)

<nsXULAttribute>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
ToNewUnicode(nsAString const &)
nsXULAttributeValue::SetValue(nsAString const &, int)

<nsXULAttribute::mValue>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewUnicode(nsAString const &)
nsXULAttributeValue::SetValue(nsAString const &, int)

<nsXULAttributes>
__builtin_new
nsXULAttributes::Create(nsIContent *, nsXULAttributes **)

<nsXULAttributes>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
NS_NewAtom(nsAString const &)
NS_NewAtom(unsigned short const *)
nsClassList::ParseClasses(nsClassList **, nsAString const &)
nsXULAttributes::UpdateClassList(nsAString const &)

<nsXULElement>
__builtin_new
nsXULElement::Create(nsINodeInfo *, nsIContent **)

<nsXULElement>
PR_Realloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsXULElement::EnsureSlots(void)

<nsXULElement>
PR_Realloc
nsVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsXULElement::AppendChildTo(nsIContent *, int, int)

<nsXULElement>
__builtin_new
nsXULElement::EnsureSlots(void)

<nsXULElement>
PR_Malloc
nsVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsXULElement::AppendChildTo(nsIContent *, int, int)

<nsXULElement>
PR_Malloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsXULElement::EnsureSlots(void)

<nsXULElement>
PR_Malloc
nsVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsXULElement::AddBroadcastListener(nsAString const &, nsIDOMElement *)

<sscanf>
iconv_close

<sscanf>
tsearch

<CSSDeclarationImpl>
PR_Realloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
CSSDeclarationImpl::AppendValue(nsCSSProperty, nsCSSValue const &)

<CSSDeclarationImpl>
__builtin_new
CSSDeclarationImpl::AppendValue(nsCSSProperty, nsCSSValue const &)

<CSSDeclarationImpl>
__builtin_new
CSSDeclarationImpl::SetValueImportant(nsCSSProperty)

<CSSDeclarationImpl>
__builtin_new
CSSDeclarationImpl::operator new(unsigned int)

<CSSDeclarationImpl>
PR_Malloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
CSSDeclarationImpl::AppendValue(nsCSSProperty, nsCSSValue const &)

<nsVoidArray>
__builtin_new
__builtin_vec_new
nsVoidArray::InsertElementAt(void *, int)

<nsVoidArray>
__builtin_new
__builtin_vec_new
nsVoidArray::nsVoidArray(int)

<nsVoidArray>
__builtin_new
__builtin_vec_new
nsVoidArray::Compact(void)

<nsVoidArray>
__builtin_new
__builtin_vec_new
nsVoidArray::ReplaceElementAt(void *, int)

<nsGenericHTMLContainerElement>
__builtin_new
nsCheapVoidArray::SwitchToVector(void)
nsCheapVoidArray::AppendElement(void *)
nsGenericHTMLContainerElement::AppendChildTo(nsIContent *, int)

<nsGenericHTMLContainerElement>
PR_Malloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::Compact(void)
nsAutoVoidArray::Compact(void)
nsCheapVoidArray::Compact(void)
nsGenericHTMLContainerElement::Compact(void)

<nsGenericHTMLContainerElement>
PR_Malloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsCheapVoidArray::AppendElement(void *)
nsGenericHTMLContainerElement::AppendChildTo(nsIContent *, int, int)

<nsGenericHTMLContainerElement>
PR_Realloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsCheapVoidArray::AppendElement(void *)
nsGenericHTMLContainerElement::AppendChildTo(nsIContent *, int, int)

<nsGenericAttribute>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
~.*
~.*
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
nsString::nsString(basic_nsAReadableString<unsigned short> const &)
nsGenericAttribute::nsGenericAttribute(nsINodeInfo *, basic_nsAReadableString<unsigned short> const &)

<nsSupportsArray>
__builtin_new
__builtin_vec_new
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

<nsSupportsArray>
__builtin_new
nsSupportsArray::Create(nsISupports *, nsID const &, void **)

<nsZipArchive>
__builtin_new
__builtin_vec_new
nsZipArchive::BuildFileList(void)

<nsZipArchive>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)

<InMemoryDataSource>
__builtin_new
__builtin_vec_new
InMemoryDataSource::AllocTable(void *, unsigned int)

<InMemoryDataSource>
PL_DHashAllocTable
PL_DHashTableFinish
PL_DHashTableOperate
InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)

<InMemoryDataSource>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::AddBucket(unsigned int)
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
InMemoryDataSource::InMemoryDataSource(nsISupports *)

<InMemoryDataSource>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
InMemoryDataSource::AllocEntry(void *, void const *)

<InMemoryDataSource>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
Assertion::operator new(unsigned int, nsFixedSizeAllocator &)

<InMemoryDataSource>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
InMemoryDataSource::AllocEntry(void *, void const *)
PL_HashTableRawAdd
PL_HashTableAdd
InMemoryDataSource::SetReverseArcs(nsIRDFNode *, Assertion *)

<InMemoryDataSource>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
InMemoryDataSource::AllocEntry(void *, void const *)
PL_HashTableRawAdd
PL_HashTableAdd
InMemoryDataSource::SetForwardArcs(nsIRDFResource *, Assertion *)

<InMemoryDataSource>
PL_DHashAllocTable
PL_DHashTableInit
InMemoryDataSource::Init(void)

<RDFXMLDataSource>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsString::nsString(nsAString const &)
nsNameSpaceMap::Put(nsAString const &, nsIAtom *)
RDFXMLDataSourceImpl::AddNameSpace(nsIAtom *, nsString const &)

<xptiTypelibGuts>
__builtin_new
__builtin_vec_new
xptiTypelibGuts::xptiTypelibGuts(XPTHeader *)

# ----------------------------------------------------------------------
#
# nsPluginTag
#

<nsPluginTag>
__builtin_new
__builtin_vec_new
nsPluginTag::nsPluginTag(nsPluginInfo *)

<nsPluginTag>
__builtin_new
__builtin_vec_new
new_str(char const *)
nsPluginTag::nsPluginTag(nsPluginInfo *)

<nsPluginTag>
__builtin_new
__builtin_vec_new
nsPluginTag::nsPluginTag(char const *, char const *, char const *, char const *, char const *const *, char const *const *, char const *const *, int, long long)

<nsPluginTag>
__builtin_new
__builtin_vec_new
nsPluginTag::nsPluginTag(nsPluginTag *)

#----------------------------------------------------------------------
#
# nsXBLInsertionPoint
#

<nsXBLInsertionPoint>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
nsXBLInsertionPoint::AddChild(nsIContent *)

#----------------------------------------------------------------------
#
# nsXBLBinding
#

<nsXBLBinding>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXBLBinding::GetInsertionPointsFor(nsIContent *, nsISupportsArray **)

<nsXBLBinding>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsXBLBinding::GetInsertionPointsFor(nsIContent *, nsISupportsArray **)

<nsXBLBinding>
__builtin_new
nsXBLBinding::GetInsertionPointsFor(nsIContent *, nsISupportsArray **)

<nsXBLBinding>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
NS_NewAtom(nsAString const &)
NS_NewAtom(char const *)
nsXBLBinding::nsXBLBinding(nsIXBLPrototypeBinding *)

# ----------------------------------------------------------------------
#
# nsXBLPrototypeBinding
#

<nsXBLPrototypeBinding>
__builtin_new
nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)

<nsXBLPrototypeBinding>
__builtin_new
nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent *)

<nsXBLPrototypeBinding>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

<nsXBLPrototypeBinding>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
js_LookupProperty
JS_DefinePropertyWithTinyId
JS_LookupProperty
nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)

<nsXBLPrototypeBinding>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent *)

<nsXBLPrototypeBinding>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::AddBucket(unsigned int)
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
nsXBLPrototypeBinding::nsXBLPrototypeBinding(nsCString const &, nsIContent *, nsXBLDocumentInfo *)

<nsXBLPrototypeBinding>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::AddBucket(unsigned int)
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
nsXBLPrototypeBinding::nsXBLPrototypeBinding(basic_nsAReadableString<char> const &, nsIContent *, nsXBLDocumentInfo *)

<nsXBLPrototypeBinding>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

<nsXBLPrototypeBinding>
__builtin_new
nsISupportsKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

<nsXBLPrototypeBinding>
__builtin_new
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

<nsXBLPrototypeBinding>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

<nsXBLPrototypeBinding>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::AddBucket(unsigned int)
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
nsXBLPrototypeBinding::nsXBLPrototypeBinding(nsACString const &, nsXBLDocumentInfo *)

<nsXBLPrototypeBinding>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)

<nsXBLPrototypeBinding>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsCString::SetCapacity(unsigned int)
nsCString::SetLength(unsigned int)
nsACString::do_AssignFromReadable(nsACString const &)
nsACString::AssignFromReadable(nsACString const &)
nsCString::nsCString(nsACString const &)
nsXBLPrototypeBinding::nsXBLPrototypeBinding(nsACString const &, nsXBLDocumentInfo *)

<nsXBLPrototypeBinding>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewCString(nsACString const &)
nsXBLJSClass::nsXBLJSClass(nsCString const &)
nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)

<nsXBLPrototypeBinding>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXBLPrototypeBinding::ConstructInterfaceTable(nsIContent *)

<nsXBLPrototypeBinding>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)

<nsXBLPrototypeBinding>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent *)

<nsXBLPrototypeBinding>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsXBLPrototypeBinding::ConstructInterfaceTable(nsIContent *)

<nsXBLPrototypeBinding>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsXBLAttributeEntry::Create(nsIAtom *, nsIAtom *, nsIContent *)
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

#----------------------------------------------------------------------
#
# <nsXBLPrototypeProperty>
#

<nsXBLPrototypeProperty>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsIAtom *&, nsAString &) const
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsAString &) const
nsXBLPrototypeProperty::ParseProperty(nsIScriptContext *)

<nsXBLPrototypeProperty>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsIAtom *&, nsAString &) const
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsAString &) const
nsXBLPrototypeProperty::ParseMethod(nsIScriptContext *)

<nsXBLPrototypeProperty>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsIAtom *&, nsAString &) const
nsGenericContainerElement::GetAttr(int, nsIAtom *, nsAString &) const
nsXBLPrototypeProperty::ParseField(nsIScriptContext *)

<nsXBLPrototypeProperty>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AppendFromReadable(nsAString const &)
nsAString::AppendFromReadable(nsAString const &)
nsXBLPrototypeProperty::ParseField(nsIScriptContext *)

<nsXBLPrototypeProperty>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsCString::SetCapacity(unsigned int)
nsCString::SetLength(unsigned int)
nsACString::do_AppendFromReadable(nsACString const &)
nsACString::do_AppendFromElementPtr(char const *)
nsXBLPrototypeBinding::GetBindingURI(nsCString &)
nsXBLPrototypeProperty::ConstructProperty(nsIContent *, nsIContent *)

<nsXBLPrototypeProperty>
JS_DHashAllocTable
JS_DHashTableFinish
JS_DHashTableOperate
js_AddRootRT
JS_AddNamedRootRT
NS_NewXBLPrototypeBinding(nsACString const &, nsIContent *, nsXBLDocumentInfo *, nsIXBLPrototypeBinding **)
nsXBLPrototypeProperty::ParseMethod(nsIScriptContext *)

# ----------------------------------------------------------------------
#
# The frame arena
#

<FrameArena>
PR_Malloc
PL_ArenaAllocate
FrameArena::AllocateFrame(unsigned int, void **)

<PresShell>
PR_Malloc
PL_ArenaAllocate
nsDST::NodeArena::AllocLeafNode(void)
nsDST::Insert(void *, void *, void **)
PresShell::SetSubShellFor(nsIContent *, nsISupports *)

<PresShell>
PR_Malloc
nsVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
PresShell::AppendReflowCommandInternal(nsIReflowCommand *, nsVoidArray &)

# The anonymous content table in the PresShell
<PresShell.mAnonymousContentTable>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)

<PresShell.mAnonymousContentTable>
__builtin_new
nsISupportsKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)

<PresShell.mAnonymousContentTable>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)

<PresShell.mAnonymousContentTable>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)

# ----------------------------------------------------------------------
#
# StackArena
#

<StackArena>
PR_Malloc
StackArena::StackArena(void)

<StackArena>
PR_Malloc
StackArena::Allocate(unsigned int, void **)

<StackArena>
PR_Malloc
StackBlock::StackBlock(void)
StackArena::StackArena(void)

<StackArena>
__builtin_new
__builtin_vec_new
StackArena::StackArena(void)

<StackArena>
PR_Malloc
StackArena::Allocate(unsigned int, void **)

# The following will only show up if you turn off the FrameArena
<nsBoxLayoutState>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsBoxLayoutState::Allocate(unsigned int, nsIPresShell *)


# ----------------------------------------------------------------------
#
# nsFrameManager
#

<FrameManager>
PR_Malloc
PL_ArenaAllocate
nsDST::NodeArena::AllocLeafNode(void)
nsDST::LeafNode::operator new(unsigned int, nsDST::NodeArena *)
nsDST::Insert(void *, void *, void **)

<FrameManager>
PR_Malloc
PL_ArenaAllocate
nsDST::NodeArena::AllocTwoNode(void)
nsDST::ConvertToTwoNode(nsDST::LeafNode **)
nsDST::Insert(void *, void *, void **)
FrameManager::SetFrameProperty(nsIFrame *, nsIAtom *, void *, void (*)(nsIPresContext *, nsIFrame *, nsIAtom *, void *))

<FrameManager>
PR_Malloc
PL_ArenaAllocate
nsDST::NodeArena::AllocTwoNode(void)
nsDST::TwoNode::operator new(unsigned int, nsDST::NodeArena *)
nsDST::ConvertToTwoNode(nsDST::LeafNode **)
nsDST::Insert(void *, void *, void **)
FrameManager::SetPrimaryFrameFor(nsIContent *, nsIFrame *)

<FrameManager>
PR_Malloc
PL_ArenaAllocate
nsDST::NodeArena::AllocTwoNode(void)
nsDST::TwoNode::operator new(unsigned int, nsDST::NodeArena *)
nsDST::ConvertToTwoNode(nsDST::LeafNode **)
nsDST::Insert(void *, void *, void **)
FrameManager::SetFrameProperty(nsIFrame *, nsIAtom *, void *, void (*)(nsIPresContext *, nsIFrame *, nsIAtom *, void *))

<FrameManager>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
FrameHashTable::Put(void *, void *)
FrameManager::SetPlaceholderFrameFor(nsIFrame *, nsIFrame *)

<FrameManager>
__builtin_new
nsDST::NewMemoryArena(unsigned int)
FrameManager::Init(nsIPresShell *, nsIStyleSet *)

<FrameManager>
PR_Malloc
PL_ArenaAllocate
nsDST::NodeArena::AllocTwoNode(void)
nsDST::ConvertToTwoNode(nsDST::LeafNode **)
nsDST::Insert(void *, void *, void **)
FrameManager::SetPrimaryFrameFor(nsIContent *, nsIFrame *)

<FrameManager>
PR_Malloc
PL_ArenaAllocate
nsDST::NodeArena::AllocLeafNode(void)
nsDST::Insert(void *, void *, void **)
FrameManager::SetFrameProperty(nsIFrame *, nsIAtom *, void *, void (*)(nsIPresContext *, nsIFrame *, nsIAtom *, void *))

<FrameManager>
PR_Malloc
PL_ArenaAllocate
nsDST::NodeArena::AllocLeafNode(void)
nsDST::Insert(void *, void *, void **)
FrameManager::SetPrimaryFrameFor(nsIContent *, nsIFrame *)

<UndisplayedMap>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
UndisplayedMap::AppendNodeFor(UndisplayedNode *, nsIContent *)

<UndisplayedMap>
__builtin_new
UndisplayedMap::AddNodeFor(nsIContent *, nsIContent *, nsIStyleContext *)

<UndisplayedMap>
PR_Malloc
PL_ArenaFinish
PL_NewHashTable
UndisplayedMap::UndisplayedMap(unsigned int)

<PRLock>
PR_Calloc
PR_NewLock

<PRMonitor>
PR_Calloc
PR_NewMonitor

# ----------------------------------------------------------------------
#
# RDFServiceImpl
#

<RDFServiceImpl>
PR_Malloc
PL_ArenaFinish
PL_NewHashTable
RDFServiceImpl::Init(void)

<RDFServiceImpl>
PR_Malloc
nsRDFParserUtils::GetQuotedAttributeValue(nsString const &, nsString const &, nsString &)
PL_HashTableRawAdd
PL_HashTableAdd
RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int)

<RDFServiceImpl>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
RDFServiceImpl::RegisterResource(nsIRDFResource *, int)

<RDFServiceImpl>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
PL_HashTableAdd
RDFServiceImpl::RegisterLiteral(nsIRDFLiteral *, int)

<RDFServiceImpl>
PR_Malloc
nsRDFParserUtils::IsJavaScriptLanguage(nsString const &, char const **)
PL_NewHashTable
RDFServiceImpl::Init(void)

<RDFServiceImpl>
PR_Malloc
nsRDFParserUtils::IsJavaScriptLanguage(nsString const &, char const **)
PL_HashTableRawAdd
PL_HashTableAdd
RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int)

<RDFServiceImpl>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawRemove
RDFServiceImpl::UnregisterResource(nsIRDFResource *)

<RDFServiceImpl>
PL_strdup
RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int)

# ----------------------------------------------------------------------

<nsRDFResource>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsRDFResource::Init(char const *)

<nsHTMLImageLoader>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
~.*
~.*
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
nsString::operator=(nsString const &)
nsHTMLImageLoader::SetURL(nsString const &)

<nsHTMLEntities>
__builtin_new
__builtin_vec_new
nsHTMLEntities::AddRefTable(void)

<nsHTMLEntities>
__builtin_new
nsAVLTree::AddItem(void *)
nsHTMLEntities::AddRefTable(void)

<nsStaticCaseInsensitiveNameTable>
__builtin_new
__builtin_vec_new
nsStaticCaseInsensitiveNameTable::Init(char const **, int)

<CNavDTD>
__builtin_new
CNavDTD::CNavDTD(void)

<CNavDTD>
__builtin_new
__builtin_vec_new
InitializeElementTable(void)
CNavDTD::CNavDTD(void)

<CNavDTD>
__builtin_new
__builtin_vec_new
nsDeque::GrowCapacity(void)
nsDeque::Push(void *)
CNodeRecycler::RecycleNode(nsCParserNode *)
CNavDTD::CloseContainersTo(int, nsHTMLTag, int)

<COtherDTD>
__builtin_new
COtherDTD::COtherDTD(void)

<nsScanner>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsScanner::Append(char const *, unsigned int)

<nsScanner>
__builtin_new
nsSlidingString::AppendBuffer(unsigned short *, unsigned short *, unsigned short *)
nsScanner::AppendToBuffer(unsigned short *, unsigned short *, unsigned short *)

<nsScanner>
__builtin_new
nsScanner::AppendToBuffer(unsigned short *, unsigned short *, unsigned short *)

<nsScanner>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
unsigned short * AllocateStringCopy<unsigned short, unsigned short>(basic_nsAReadableString<unsigned short> const &, unsigned short *)
ToNewUnicode(basic_nsAReadableString<unsigned short> const &)
nsScanner::Append(basic_nsAReadableString<unsigned short> const &)

<nsScanner>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
CopyUnicodeTo(nsReadingIterator<unsigned short> const &, nsReadingIterator<unsigned short> const &, basic_nsAWritableString<unsigned short> &)
nsScanner::CopyUnusedData(nsString &)

<nsScanner>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
nsString::nsString(nsString const &)
nsScanner::nsScanner(nsString &, int, nsString const &, nsCharsetSource)

<nsHTMLTokenizer>
__builtin_new
__builtin_vec_new
nsDeque::GrowCapacity(void)
nsDeque::Push(void *)
nsHTMLTokenizer::ScanDocStructure(int)

<nsHTMLTokenizer>
__builtin_new
__builtin_vec_new
nsDeque::GrowCapacity(void)
nsDeque::Push(void *)
nsHTMLTokenizer::AddToken(CToken *&, unsigned int, nsDeque *, nsTokenAllocator *)

<nsTokenAllocator>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
CToken::operator new(unsigned int, nsFixedSizeAllocator &)
nsTokenAllocator::CreateTokenOfType(eHTMLTokenTypes, nsHTMLTag)

<nsNodeAllocator>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::AddBucket(unsigned int)
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
nsNodeAllocator::nsNodeAllocator(void)

# ----------------------------------------------------------------------
#
# xptiWorkingSet
#

<xptiWorkingSet>
__builtin_new
__builtin_vec_new
xptiWorkingSet::NewFileArray(unsigned int)

<xptiWorkingSet>
__builtin_new
__builtin_vec_new
xptiWorkingSet::ExtendFileArray(unsigned int)

# ----------------------------------------------------------------------

<HTMLContentSink>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
HTMLContentSink::OnStreamComplete(nsIStreamLoader *, nsISupports *, unsigned int, unsigned int, char const *)

<HTMLContentSink>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
nsString::nsString(nsString const &)
HTMLContentSink::SetTitle(nsString const &)

<DeviceContextImpl>
__builtin_new
__builtin_vec_new
DeviceContextImpl::DeviceContextImpl(void)

<DeviceContextImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
DeviceContextImpl::CreateFontAliasTable(void)

<DeviceContextImpl>
__builtin_new
FontAliasKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
DeviceContextImpl::AliasFont(nsString const &, nsString const &, nsString const &, int)

<nsCompressedMap>
__builtin_new
__builtin_vec_new
nsCompressedMap::nsCompressedMap(unsigned short *, unsigned int)

<nsHTMLDocument>
__builtin_new
__builtin_vec_new
nsHTMLDocument::nsHTMLDocument(void)

<nsHTMLDocument>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsHTMLDocument::nsHTMLDocument(void)

<nsHTMLDocument>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsHTMLDocument::InvalidateHashTables(void)

<nsHTMLDocument.mReferrer>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
~.*
~.*
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
nsString::nsString(basic_nsAReadableString<unsigned short> const &)
nsHTMLDocument::SetReferrer(basic_nsAReadableString<unsigned short> const &)

<nsHTMLDocument.mLastModified>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
~.*
~.*
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
nsString::nsString(basic_nsAReadableString<unsigned short> const &)
nsHTMLDocument::SetLastModified(basic_nsAReadableString<unsigned short> const &)

<nsHTMLDocument.mTitle>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
~.*
~.*
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
nsString::nsString(basic_nsAReadableString<unsigned short> const &)
nsHTMLDocument::SetTitle(basic_nsAReadableString<unsigned short> const &)

<nsDOMDocumentType>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsString::nsString(nsAString const &)
nsDOMDocumentType::nsDOMDocumentType(nsAString const &, nsIDOMNamedNodeMap *, nsIDOMNamedNodeMap *, nsAString const &, nsAString const &, nsAString const &)

#----------------------------------------------------------------------
#
# XPC stuff
#

<Native2WrappedNativeMap>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
Native2WrappedNativeMap::Native2WrappedNativeMap(int)

<ClassInfo2WrappedNativeProtoMap>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
ClassInfo2WrappedNativeProtoMap::ClassInfo2WrappedNativeProtoMap(int)

<IID2NativeInterfaceMap>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
IID2NativeInterfaceMap::IID2NativeInterfaceMap(int)

<IID2WrappedJSClassMap>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
IID2WrappedJSClassMap::IID2WrappedJSClassMap(int)

<IID2ThisTranslatorMap>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
IID2ThisTranslatorMap::IID2ThisTranslatorMap(int)

<XPCNativeScriptableSharedMap>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
XPCNativeScriptableSharedMap::XPCNativeScriptableSharedMap(int)

<XPCNativeScriptableSharedMap>
__builtin_new
XPCNativeScriptableSharedMap::GetNewOrUsed(unsigned int, char *, XPCNativeScriptableInfo *)

<JSContext2XPCContextMap>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
JSContext2XPCContextMap::JSContext2XPCContextMap(int)

<NativeSetMap>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
NativeSetMap::NativeSetMap(int)

<JSObject2WrappedJSMap>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
JSObject2WrappedJSMap::JSObject2WrappedJSMap(int)

<nsXPCWrappedJS>
JS_DHashAllocTable
JS_DHashTableFinish
JS_DHashTableOperate
nsXPCWrappedJS::GetNewOrUsed(XPCCallContext &, JSObject *, nsID const &, nsISupports *, nsXPCWrappedJS **)

<XPCWrappedNativeProtoMap>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
XPCWrappedNativeProtoMap::XPCWrappedNativeProtoMap(int)

<XPCWrappedNativeProto>
JS_DHashAllocTable
JS_DHashTableFinish
JS_DHashTableOperate
XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)

<XPCWrappedNativeProto>
__builtin_new
XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)

<XPCWrappedNativeProto>
__builtin_new
__builtin_vec_new
XPCNativeSet::NewInstance(XPCCallContext &, XPCNativeInterface **, unsigned short)
XPCNativeSet::GetNewOrUsed(XPCCallContext &, nsIClassInfo *)
XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)

<XPCWrappedNativeProto>
__builtin_new
XPCNativeScriptableInfo::Construct(XPCCallContext &, XPCNativeScriptableCreateInfo const *)
XPCWrappedNativeProto::Init(XPCCallContext &, XPCNativeScriptableCreateInfo const *)

<XPCWrappedNativeProto>
JS_DHashAllocTable
JS_DHashTableFinish
JS_DHashTableOperate
XPCNativeSet::GetNewOrUsed(XPCCallContext &, nsIClassInfo *)
XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)

<XPCWrappedNative>
JS_DHashAllocTable
JS_DHashTableFinish
JS_DHashTableOperate
XPCWrappedNative::~XPCWrappedNative(void)

<XPCWrappedNative>
__builtin_new
XPCWrappedNative::FindTearOff(XPCCallContext &, XPCNativeInterface *, int, unsigned int *)

<XPCWrappedNative>
JS_DHashAllocTable
JS_DHashTableFinish
JS_DHashTableOperate
XPCWrappedNative::GetNewOrUsed(XPCCallContext &, nsISupports *, XPCWrappedNativeScope *, XPCNativeInterface *, XPCWrappedNative **)

<XPCWrappedNativeScope>
JS_DHashAllocTable
JS_DHashTableInit
JS_NewDHashTable
js_LookupProperty
js_GetProperty
XPCWrappedNativeScope::SetGlobal(XPCCallContext &, JSObject *)

<nsXPCWrappedNativeClass>
__builtin_new
__builtin_vec_new
nsXPCWrappedNativeClass::BuildMemberDescriptors(XPCContext *)

#----------------------------------------------------------------------

<nsNetModuleMgr>
__builtin_new
__builtin_vec_new
nsNetModRegEntry::nsNetModRegEntry(char const *, nsINetNotify *, unsigned int *)
nsNetModuleMgr::RegisterModule(char const *, nsINetNotify *)

<nsProxyObjectManager>
__builtin_new
nsProxyObjectManager::nsProxyObjectManager(void)

<nsProxyObjectManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsProxyObjectManager::nsProxyObjectManager(void)

<nsProxyEventClass>
__builtin_new
__builtin_vec_new
nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *)

<nsProxyEventClass>
__builtin_new
nsHashtable::Put(nsHashKey *, void *)
nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *)

<nsProxyEventClass>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *)

<nsProxyEventObject>
__builtin_new
nsProxyEventKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsProxyEventObject::GetNewOrUsedProxy(nsIEventQueue *, int, nsISupports *, nsID const &)

<nsProxyEventObject>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsProxyEventObject::GetNewOrUsedProxy(nsIEventQueue *, int, nsISupports *, nsID const &)

# ----------------------------------------------------------------------
#
# nsComponentManagerImpl
#

<nsComponentManagerImpl>
__builtin_new
nsComponentManagerImpl::Init(void)

<nsComponentManagerImpl>
__builtin_new
nsComponentManagerImpl::GetServiceByContractID(char const *, nsID const &, void **)

<nsComponentManagerImpl>
__builtin_new
nsComponentManagerImpl::GetService(nsID const &, nsID const &, void **)

<nsComponentManagerImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsComponentManagerImpl::Init(void)

<nsComponentManagerImpl>
__builtin_vec_new
nsComponentManagerImpl::Init(void)

<nsComponentManagerImpl>
__builtin_new
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

<nsComponentManagerImpl>
__builtin_new
nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)

<nsComponentManagerImpl>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

<nsComponentManagerImpl>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::HashContractID(char const *, nsID const &)

<nsComponentManagerImpl>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsComponentManagerImpl::Init(void)

<nsComponentManagerImpl>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsComponentManagerImpl::GetLoaderForType(char const *, nsIComponentLoader **)

<nsComponentManagerImpl>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::ContractIDToClassID(char const *, nsID *)

<nsComponentManagerImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

<nsComponentManagerImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)

<nsComponentManagerImpl>
__builtin_new
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

<nsComponentManagerImpl>
__builtin_new
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)

<nsComponentManagerImpl>
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

<nsComponentManagerImpl>
PR_Malloc
bufio_SetBufferSize
nsXPTCStubBase::Sentinel9(void)
NR_RegSetBufferSize
nsRegistry::SetBufferSize(int)
nsComponentManagerImpl::AutoRegister(int, nsIFile *)

<nsComponentManagerImpl>
__builtin_new
nsComponentManagerImpl::HashContractID(char const *, nsID const &)

<nsComponentManagerImpl>
__builtin_new
nsComponentManagerImpl::RegisterComponentCommon(nsID const &, char const *, char const *, char const *, int, int, char const *)

<nsComponentManagerImpl>
__builtin_new
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::RegisterComponentCommon(nsID const &, char const *, char const *, char const *, int, int, char const *)

<nsComponentManagerImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::HashContractID(char const *, nsID const &)

<nsComponentManagerImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)

<nsComponentManagerImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::ContractIDToClassID(char const *, nsID *)

<nsComponentManagerImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::HashContractID(char const *, nsFactoryEntry *)

<nsComponentManagerImpl>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsComponentManagerImpl::HashContractID(char const *, nsFactoryEntry *)

<nsComponentManagerImpl>
__builtin_new
nsComponentManagerImpl::GetService(char const *, nsID const &, nsISupports **, nsIShutdownListener *)

<nsComponentManagerImpl>
__builtin_new
nsComponentManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)

<nsComponentManagerImpl>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsCString::SetCapacity(unsigned int)
nsCString::SetLength(unsigned int)
nsACString::do_AssignFromReadable(nsACString const &)
nsACString::do_AssignFromElementPtr(char const *)
nsCString::nsCString(char const *)
nsFactoryEntry::nsFactoryEntry(nsID const &, char const *, int)
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

<nsComponentManagerImpl>
PL_strdup
nsComponentManagerImpl::HashContractID(char const *, nsFactoryEntry *)

<nsComponentManagerImpl>
PL_strdup
nsFactoryEntry::nsFactoryEntry(nsID const &, char const *, int)
nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

<nsComponentManagerImpl>
PL_DHashAllocTable
PL_DHashTableInit
nsComponentManagerImpl::Init(void)

# ----------------------------------------------------------------------

<nsZipArchive>
__builtin_new
nsZipArchive::BuildFileList(void)

<nsStaticCaseInsensitiveNameTable>
__builtin_new
nsStaticCaseInsensitiveNameTable::Init(char const **, int)

<nsStaticCaseInsensitiveNameTable>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsStaticCaseInsensitiveNameTable::Init(char const **, int)

<nsStaticCaseInsensitiveNameTable>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsStaticCaseInsensitiveNameTable::Init(char const **, int)

# ----------------------------------------------------------------------
#
# nsDrawingSurfaceGTK
#

<nsDrawingSurfaceGTK>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int)

<nsDrawingSurfaceGTK>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int)

<nsDrawingSurfaceGTK>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsDrawingSurfaceGTK type_info function

<nsDrawingSurfaceGTK>
PR_Malloc
nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int)

# ----------------------------------------------------------------------
#
# nsNativeComponentLoader
#

<nsNativeComponentLoader>
__builtin_new
nsNativeComponentLoader::Init(nsIComponentManager *, nsISupports *)

<nsNativeComponentLoader>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
nsNativeComponentLoader::Init(nsIComponentManager *, nsISupports *)

<nsNativeComponentLoader>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsNativeComponentLoader::CreateDll

<nsNativeComponentLoader>
__builtin_new
nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)

<nsNativeComponentLoader>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)

<nsNativeComponentLoader>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)

<nsNativeComponentLoader>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)

<nsNativeComponentLoader>
PL_strdup
nsDll::nsDll(nsIFile *, char const *, long long *, long long *)
nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)

# ----------------------------------------------------------------------

<nsDirectoryService>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsDirectoryService::Set(char const *, nsISupports *)

<nsDirectoryService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsDirectoryService::Init(void)

<nsDirectoryService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsDirectoryService::Set(char const *, nsISupports *)

<nsDirectoryService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsDirectoryService::Init(char const *)

<nsDirectoryService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsDirectoryService::Init(void)

#----------------------------------------------------------------------
#
# nsResProtocolHandler
#

<nsResProtocolHandler>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsResProtocolHandler::AppendSubstitution(char const *, char const *)

<nsResProtocolHandler>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsResProtocolHandler::nsResProtocolHandler(void)

<nsResProtocolHandler>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsResProtocolHandler::AppendSubstitution(char const *, char const *)

<nsResProtocolHandler>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsResProtocolHandler::SetSubstitution(char const *, nsIURI *)

# ----------------------------------------------------------------------
#
# nsChromeRegistry
#

<nsChromeRegistry>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)

<nsChromeRegistry>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)

<nsChromeRegistry>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)

<nsChromeRegistry>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewCString(nsACString const &)
nsStdURL::GetSpec(char **)
RDFXMLDataSourceImpl::Init(char const *)
nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)

<nsChromeRegistry>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)

# ----------------------------------------------------------------------

<nsZipReaderCache>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)

<nsZipReaderCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)

<nsZipReaderCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsZipReaderCache::nsZipReaderCache(void)

<nsZipReaderCache>
__builtin_new
nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)

# ----------------------------------------------------------------------
#
# nsXBLDocumentInfo
#

<nsXBLDocumentInfo>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)

<nsXBLDocumentInfo>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)

<nsXBLDocumentInfo>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXBLDocumentInfo::SetPrototypeBinding(nsCString const &, nsIXBLPrototypeBinding *)

<nsXBLDocumentInfo>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXBLDocumentInfo::SetPrototypeBinding(basic_nsAReadableString<char> const &, nsIXBLPrototypeBinding *)

<nsXBLDocumentInfo>
__builtin_new
nsXBLDocumentInfo::SetPrototypeBinding(nsCString const &, nsIXBLPrototypeBinding *)

<nsXBLDocumentInfo>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXBLDocumentInfo::SetPrototypeBinding(nsCString const &, nsIXBLPrototypeBinding *)

<nsXBLDocumentInfo>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsXBLDocumentInfo::SetPrototypeBinding(basic_nsAReadableString<char> const &, nsIXBLPrototypeBinding *)

<nsXBLDocumentInfo>
__builtin_new
nsXBLDocumentInfo::SetPrototypeBinding(basic_nsAReadableString<char> const &, nsIXBLPrototypeBinding *)

<nsXBLDocumentInfo>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsCString::SetCapacity(unsigned int)
nsCString::SetLength(unsigned int)
~.*
~.*
basic_nsAWritableString<char>::Assign(char const *)
nsCString::operator=(char const *)
nsXBLDocumentInfo::nsXBLDocumentInfo(char const *, nsIDocument *)

<nsXBLDocumentInfo>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)

<nsXBLDocumentInfo>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsCString::SetCapacity(unsigned int)
nsCString::SetLength(unsigned int)
nsACString::do_AssignFromReadable(nsACString const &)
nsACString::do_AssignFromElementPtr(char const *)
nsXBLDocumentInfo::nsXBLDocumentInfo(char const *, nsIDocument *)

<nsXBLDocumentInfo>
__builtin_new
nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)

# ----------------------------------------------------------------------
#
# nsXULPrototypeCache
#

<nsXULPrototypeCache>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXULPrototypeCache::PutXBLDocumentInfo(nsXBLDocumentInfo *)

<nsXULPrototypeCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXULPrototypeCache::PutPrototype(nsIXULPrototypeDocument *)

<nsXULPrototypeCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsXULPrototypeCache::nsXULPrototypeCache(void)

<nsXULPrototypeCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXULPrototypeCache::PutXBLDocumentInfo(nsXBLDocumentInfo *)

<nsXULPrototypeCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXULPrototypeCache::PutStyleSheet(nsICSSStyleSheet *)

<nsXULPrototypeCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsXULPrototypeCache::nsXULPrototypeCache(void)

<nsXULPrototypeCache>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXULPrototypeCache::PutXBLDocumentInfo(nsXBLDocumentInfo *)

<nsXULPrototypeCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsXULPrototypeCache::PutScript(nsIURI *, void *)

# nsXULPrototypeElement
<nsXULPrototypeCache>
__builtin_new
XULContentSinkImpl::CreateElement(nsINodeInfo *, nsXULPrototypeElement **)

# nsXULPrototypeNode
<nsXULPrototypeCache>
__builtin_new
__builtin_vec_new
XULContentSinkImpl::CloseContainer(nsIParserNode const &)

# nsXULPrototypeScript
<nsXULPrototypeCache>
__builtin_new
XULContentSinkImpl::OpenScript(nsIParserNode const &)

# ----------------------------------------------------------------------
#
# nsExternalHelperAppService
#

<nsExternalHelperAppService>
__builtin_new
nsExternalHelperAppService::nsExternalHelperAppService(void)

<nsExternalHelperAppService>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)

<nsExternalHelperAppService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)

<nsExternalHelperAppService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)

<nsExternalHelperAppService>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)

<nsExternalHelperAppService>
PR_Malloc
nsVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsTArray<nsCString>::InsertElementAt(int, nsCString const &)
nsMIMEInfoImpl::SetFileExtensions(char const *)
nsExternalHelperAppService::AddDefaultMimeTypesToCache(void)
 
# ----------------------------------------------------------------------
#
# nsCategoryManager
#

<nsCategoryManager>
__builtin_new
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

<nsCategoryManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

<nsCategoryManager>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

<nsCategoryManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

<nsCategoryManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
CategoryNode::CategoryNode(void)
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

<nsCategoryManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
nsCategoryManager::nsCategoryManager(void)

<nsCategoryManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
CategoryNode::CategoryNode(void)
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

<nsCategoryManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
nsCategoryManager::nsCategoryManager(void)

<nsCategoryManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

<nsCategoryManager>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

<nsCategoryManager>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

<nsCategoryManager>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsCString::SetCapacity(unsigned int)
nsCString::SetLength(unsigned int)
nsACString::do_AssignFromReadable(nsACString const &)
nsACString::do_AssignFromElementPtr(char const *)
nsCString::nsCString(char const *)
nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

# ----------------------------------------------------------------------
#
# nsScriptNameSpaceManager
#

<nsScriptNameSpaceManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsScriptNameSpaceManager::RegisterClassName(char const *, int)

<nsScriptNameSpaceManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsScriptNameSpaceManager::FillHashWithDOMInterfaces(void)

<nsScriptNameSpaceManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsScriptNameSpaceManager::FillHash(nsICategoryManager *, char const *, nsGlobalNameStruct::nametype)

<nsScriptNameSpaceManager>
__builtin_new
nsScriptNameSpaceManager::RegisterClassName(char const *, int)

# ----------------------------------------------------------------------
#
# nsScriptSecurityManager
#

<nsScriptSecurityManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsScriptSecurityManager::InitPolicies(unsigned int, char const **, nsISecurityPref *)

<nsScriptSecurityManager>
__builtin_new
nsScriptSecurityManager::EnumeratePolicyCallback(char const *, void *)

<nsScriptSecurityManager>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsScriptSecurityManager::EnumeratePolicyCallback(char const *, void *)

<nsScriptSecurityManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsScriptSecurityManager::InitPrefs(void)

<nsScriptSecurityManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
nsScriptSecurityManager::EnumeratePolicyCallback(char const *, void *)

<nsScriptSecurityManager>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsScriptSecurityManager::InitPolicies(unsigned int, char const **, nsISecurityPref *)

# ----------------------------------------------------------------------
#
# nsStringBundleService
#

<nsStringBundleService>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)

<nsStringBundleService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)

<nsStringBundleService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsStringBundleService::nsStringBundleService(void)

<nsStringBundleService>
PR_Malloc
PL_ArenaAllocate
nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)

<nsStringBundleService>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)

# ----------------------------------------------------------------------

<CSSStyleSheetImpl>
__builtin_new
CSSStyleSheetImpl::CSSStyleSheetImpl(void)

<CSSStyleSheetImpl>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
CSSStyleSheetImpl::AppendStyleRule(nsICSSRule *)

<CSSStyleSheetImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
CSSStyleSheetImpl::CheckRuleForAttributes(nsICSSRule *)

<CSSStyleSheetImpl>
__builtin_new
AtomKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
CSSStyleSheetImpl::CheckRuleForAttributes(nsICSSRule *)

<CSSStyleSheetImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
CSSStyleSheetImpl::CheckRuleForAttributes(nsICSSRule *)

<CSSStyleSheetInner>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
CSSStyleSheetInner::CSSStyleSheetInner(nsICSSStyleSheet *)

<HTMLStyleSheetImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
HTMLStyleSheetImpl::HTMLStyleSheetImpl(void)

<HTMLStyleSheetImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawRemove
nsHashtable::Remove(nsHashKey *)
HTMLStyleSheetImpl::DropMappedAttributes(nsIHTMLMappedAttributes *)

<HTMLStyleSheetImpl>
__builtin_new
AttributeKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
HTMLStyleSheetImpl::UniqueMappedAttributes(nsIHTMLMappedAttributes *, nsIHTMLMappedAttributes *&)

<HTMLStyleSheetImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
HTMLStyleSheetImpl::UniqueMappedAttributes(nsIHTMLMappedAttributes *, nsIHTMLMappedAttributes *&)

<nsStyleContextData>
__builtin_new
nsStyleContextData::Create(nsIPresContext *)

<nsStyleContent>
__builtin_new
__builtin_vec_new
nsStyleContent::AllocateCounterResets(unsigned int)

<nsStyleContent>
__builtin_new
__builtin_vec_new
nsStyleContent::AllocateContents(unsigned int)

<xptiManifest>
__builtin_new
xptiManifest::Read(xptiInterfaceInfoManager *, xptiWorkingSet *)

<xptiManifest>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
PL_HashTableAdd
xptiManifest::Read(xptiInterfaceInfoManager *, xptiWorkingSet *)

<CSSParserImpl>
__builtin_new
SelectorList::AddSelector(nsCSSSelector const &)
CSSParserImpl::ParseSelectorGroup(int &, SelectorList *&)

<CSSParserImpl>
__builtin_new
CSSParserImpl::ParseContent(int &, nsICSSDeclaration *, int &)

# ----------------------------------------------------------------------
#
# RuleHash
#

<RuleHash>
__builtin_new
RuleHash::AppendRuleToTable(nsHashtable &, int, nsICSSStyleRule *)

<RuleHash>
__builtin_new
RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *)

<RuleHash>
__builtin_new
RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *, int)

<RuleHash>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
RuleHash::AppendRuleToTable(nsHashtable &, int, nsICSSStyleRule *)

<RuleHash>
__builtin_new
AtomKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *)

<RuleHash>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
RuleHash::RuleHash(void)

<RuleHash>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *)

<RuleHash>
__builtin_new
__builtin_vec_new
RuleHash::EnumerateAllRules(nsIAtom *, nsIAtom *, nsVoidArray const &, void (*)(nsICSSStyleRule *, void *), void *)

<RuleHash>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *, int)

# ----------------------------------------------------------------------
#
# nsCSSSelector
#

<nsCSSSelector>
__builtin_new
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

<nsCSSSelector>
__builtin_new
nsAtomList::nsAtomList(nsAtomList const &)
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

<nsCSSSelector>
__builtin_new
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

<nsCSSSelector>
__builtin_new
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
nsAttrSelector::nsAttrSelector(nsAttrSelector const &)
nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

# ----------------------------------------------------------------------
#
# StyleSetImpl
#

<StyleSetImpl>
__builtin_new
CSSStyleSheetImpl::GetStyleRuleProcessor(nsIStyleRuleProcessor *&, nsIStyleRuleProcessor *)
StyleSetImpl::ClearOverrideRuleProcessors(void)

<StyleSetImpl>
__builtin_new
CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)
CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIStyleContext *, nsIRuleWalker *)
StyleSetImpl::ReplaceBackstopStyleSheets(nsISupportsArray *)

<StyleSetImpl>
__builtin_new
CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)
CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIAtom *, nsIStyleContext *, nsICSSPseudoComparator *, nsIRuleWalker *)
StyleSetImpl::ResolveStyleFor(nsIPresContext *, nsIContent *, nsIStyleContext *, int)

<StyleSetImpl>
__builtin_new
nsSupportsArray::Create(nsISupports *, nsID const &, void **)
NS_NewISupportsArray(nsISupportsArray **)
StyleSetImpl::EnsureArray(nsISupportsArray **)

<StyleSetImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)
nsRuleWalker::Forward(nsIStyleRule *)
StyleSetImpl::AddImportantRules(nsIRuleNode *)

<StyleSetImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)
nsRuleWalker::Forward(nsIStyleRule *)
nsHTMLBodyElement::WalkInlineStyleRules(nsIRuleWalker *)
HTMLCSSStyleSheetImpl::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIStyleContext *, nsIRuleWalker *)
StyleSetImpl::ReplaceBackstopStyleSheets(nsISupportsArray *)

<StyleSetImpl>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)
nsSupportsArray::EnumerateBackwards(int (*)(nsISupports *, void *), void *)
CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)
CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)
CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIStyleContext *, nsIRuleWalker *)
StyleSetImpl::ReplaceBackstopStyleSheets(nsISupportsArray *)

<StyleSetImpl>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
CSSRuleProcessor::AppendStyleSheet(nsICSSStyleSheet *)
CSSStyleSheetImpl::GetStyleRuleProcessor(nsIStyleRuleProcessor *&, nsIStyleRuleProcessor *)
StyleSetImpl::ClearOverrideRuleProcessors(void)

//----------------------------------------------------------------------

<StyleListImpl>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
~.*
~.*
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
nsString::operator=(nsString const &)
StyleListImpl::ResetFrom(nsStyleList const *, nsIPresContext *)

<StyleListImpl>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)
nsSupportsArray::EnumerateBackwards(int (*)(nsISupports *, void *), void *)
CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)
CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)
CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIAtom *, nsIStyleContext *, nsICSSPseudoComparator *, nsIRuleWalker *)
StyleSetImpl::ResolveStyleFor(nsIPresContext *, nsIContent *, nsIStyleContext *, int)

<StyleListImpl>
PR_Malloc
nsVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
CSSRuleProcessor::ClearRuleCascades(void)
nsSupportsArray::EnumerateBackwards(int (*)(nsISupports *, void *), void *)
CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)
CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIAtom *, nsIStyleContext *, nsICSSPseudoComparator *, nsIRuleWalker *)
StyleSetImpl::ResolveStyleFor(nsIPresContext *, nsIContent *, nsIStyleContext *, int)

# ----------------------------------------------------------------------

<StyleContextCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
StyleContextCache::VerifyList(unsigned int)

<StyleContextCache>
__builtin_new
StyleContextCache::AllocateList(void)

# ----------------------------------------------------------------------
#
# nsPersistentProperties
#

<nsPersistentProperties>
__builtin_new
nsPersistentProperties::Create(nsISupports *, nsID const &, void **)

<nsPersistentProperties>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
nsPersistentProperties::SetStringProperty(nsAString const &, nsAString &, nsAString &)
nsPersistentProperties::Load(nsIInputStream *)

<nsPersistentProperties>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCppSharedAllocator<unsigned short>::allocate(unsigned int, void const *)
nsCRT::strndup(unsigned short const *, unsigned int)
nsCRT::strdup(unsigned short const *)
nsString::ToNewUnicode(void) const
nsPersistentProperties::SetStringProperty(nsString const &, nsString &, nsString &)

<nsPersistentProperties>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
nsPersistentProperties::SetStringProperty(nsString const &, nsString &, nsString &)

<nsPersistentProperties>
PR_Malloc
PL_ArenaFinish
PL_NewHashTable
nsPersistentProperties::nsPersistentProperties(void)

<nsPersistentProperties>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewUnicode(nsAString const &)
nsPersistentProperties::SetStringProperty(nsAString const &, nsAString &, nsAString &)

<nsPersistentProperties>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
ToNewUnicode(nsAString const &)
nsPersistentProperties::SetStringProperty(nsAString const &, nsAString &, nsAString &)

# ----------------------------------------------------------------------
#
# nsCSSValue
#

<nsCSSValue>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCppSharedAllocator<unsigned short>::allocate(unsigned int, void const *)
nsCRT::strndup(unsigned short const *, unsigned int)
nsCRT::strdup(unsigned short const *)
nsString::ToNewUnicode(void) const
nsCSSValue::operator=(nsCSSValue const &)

<nsCSSValue>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewUnicode(nsAString const &)
nsCSSValue::SetStringValue(nsAString const &, nsCSSUnit)

<nsCSSValue>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
ToNewUnicode(nsAString const &)
nsCSSValue::SetStringValue(nsAString const &, nsCSSUnit)

# ----------------------------------------------------------------------

<nsStringKey>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStringKey::Clone(void) const

#----------------------------------------------------------------------
#
# nsTextFragment
#

<nsTextFragment>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsTextFragment::SetTo(unsigned short const *, int)

<nsTextFragment>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewCString(nsAString const &)
nsTextFragment::operator=(nsAString const &)

<nsTextFragment>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
char * AllocateStringCopy<unsigned short, char>(basic_nsAReadableString<unsigned short> const &, char *)
ToNewCString(basic_nsAReadableString<unsigned short> const &)
nsTextFragment::operator=(basic_nsAReadableString<unsigned short> const &)

#----------------------------------------------------------------------
#
# nsTextBoxFrame
#

<nsTextBoxFrame>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsTextBoxFrame::UpdateAttributes(nsIPresContext *, nsIAtom *, int &, int &)

<nsTextBoxFrame>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsTextBoxFrame::CalculateTitleForWidth(nsIPresContext *, nsRenderingContext &, int)

# ----------------------------------------------------------------------
#
# nsPopupSetFrame
#

<nsPopupSetFrame>
__builtin_new
nsPopupSetFrame::AddPopupFrame(nsIFrame *)

#----------------------------------------------------------------------

<nsStdURL>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewCString(nsACString const &)
nsStdURL::GetSpec(char **)

<nsSimpleURI>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsString::ToNewCString(void) const
nsSimpleURI::SetSpec(char const *)

<nsSimpleURI>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewCString(nsAString const &)
nsSimpleURI::SetSpec(char const *)

<nsNodeInfoManager>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
PL_HashTableAdd
nsNodeInfoManager::GetNodeInfo(nsIAtom *, nsIAtom *, int, nsINodeInfo *&)

<nsNodeInfoManager>
PR_Malloc
PL_ArenaFinish
PL_NewHashTable
nsNodeInfoManager::nsNodeInfoManager(void)

<nsNodeInfoManager>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawRemove
PL_HashTableRemove
nsNodeInfoManager::RemoveNodeInfo(nsNodeInfo *)

<xptiInterfaceInfo>
XPT_ArenaMalloc
xptiInterfaceInfo::CopyName(char const *, xptiWorkingSet *)

<xptiInterfaceInfo>
__builtin_new
xptiInterfaceInfo::PartiallyResolveLocked(XPTInterfaceDescriptor *, xptiWorkingSet *)

<xpti-unclassified>
XPT_ArenaMalloc

<pthread-unclassified>
siglongjmp
pthread_create

<X-unclassified>
XkbAllocClientMap

<X-unclassified>
_XiCheckExtInit

<X-unclassified>
_XAllocScratch

<X-unclassified>
XUnlockDisplay

<X-unclassified>
_XlcCreateLC

<X-unclassified>
XkbUseExtension

<X-unclassified>
_XimServerDestroy

<X-unclassified>
_XlcAddCharSet

<X-unclassified>
XInitExtension

<X-unclassified>
_XlcGenericLoader

<X-unclassified>
_XwcDefaultDrawImageString

<X-unclassified>
_XlcAddCT

<X-unclassified>
XShmCreateImage

<X-unclassified>
_XFreeAtomTable

<X-unclassified>
XCreateRegion

<X-unclassified>
XIntersectRegion

<X-unclassified>
_XlcCreateLocaleDataBase

<X-unclassified>
_XUpdateAtomCache

<X-unclassified>
XrmMergeDatabases

<X-unclassified>
XrmParseCommand

<X-unclassified>
XOpenDisplay

<X-unclassified>
XCreateGC

<X-unclassified>
_XlcResetConverter

<X-unclassified>
_XEnq

<X-unclassified>
_XimLcctstowcs

<X-unclassified>
XtMalloc

<X-unclassified>
XtCalloc

<X-unclassified>
Xpermalloc

<X-unclassified>
_XlcCreateDefaultCharSet

<X-unclassified>
_XimLocalSetICValues

<X-unclassified>
_XimLocalCreateIC

<X-unclassified>
_XlcSetConverter

<X-unclassified>
_XkbGetCharset

<gtk-unclassified>
g_malloc

<gtk-unclassified>
g_realloc

<gtk-unclassified>
g_malloc0

<gtk-unclassified>
_XimLcctstoutf8

<gdk_imlib_load_image>
loader_png
gdk_imlib_load_image

<gdk_imlib_save_image>
loader_png
gdk_imlib_save_image

<dl-unclassified>
_dl_lookup_versioned_symbol_skip

<dl-unclassified>
_dl_dst_substitute

<dl-unclassified>
_dl_map_object_deps

<dl-unclassified>
_dl_map_object

<dl-unclassified>
_dl_debug_message

<nsRegistry>
PR_Malloc
bufio_SetBufferSize
nsXPTCStubBase::Sentinel9(void)
NR_RegSetBufferSize
nsRegistry::SetBufferSize(int)

<nsXBLService>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::AddBucket(unsigned int)
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
nsXBLService::nsXBLService(void)

<nsXBLService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsXBLService::nsXBLService(void)

<InMemoryDataSource>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
InMemoryAssertionEnumeratorImpl::operator new(unsigned int, nsFixedSizeAllocator &)

<nsGenericModule>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsGenericModule::nsGenericModule(char const *, unsigned int, nsModuleComponentInfo *, unsigned int (*)(nsIModule *), void (*)(nsIModule *))

<nsGenericModule>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsGenericModule::GetClassObject(nsIComponentManager *, nsID const &, nsID const &, void **)

<nsGenericModule>
__builtin_new
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsGenericModule::GetClassObject(nsIComponentManager *, nsID const &, nsID const &, void **)

<nsGenericModule>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsGenericModule::nsGenericModule(char const *, unsigned int, nsModuleComponentInfo *, void (*)(nsIModule *))

<nsGenericModule>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::nsHashtable(unsigned int, int)
nsGenericModule::nsGenericModule(char const *, unsigned int, nsModuleComponentInfo *, unsigned int (*)(nsIModule *), void (*)(nsIModule *))

<nsUNIXCharset>
gettext
gettext
setlocale
setlocale
nsUNIXCharset::nsUNIXCharset(void)

# ----------------------------------------------------------------------
#
# nsLocaleService
#

<nsLocaleService>
textdomain
textdomain
setlocale
setlocale
nsLocaleService::nsLocaleService(void)

<nsLocaleService>
setlocale
setlocale
setlocale
nsLocaleService::nsLocaleService(void)

<nsLocaleService>
PR_Malloc
PL_ArenaFinish
PL_NewHashTable
nsLocale::nsLocale(void)

<nsLocaleServie>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
PL_HashTableAdd
nsLocale::AddCategory(unsigned short const *, unsigned short const *)

<nsLocaleService>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::do_AssignFromElementPtr(unsigned short const *)
nsString::nsString(unsigned short const *)
nsLocale::AddCategory(unsigned short const *, unsigned short const *)

# ----------------------------------------------------------------------
#
# nsServiceManagerImpl (obsolete?)
#

<nsServiceManagerImpl>
__builtin_new
nsServiceManagerImpl::nsServiceManagerImpl(void)
NS_NewServiceManager(nsIServiceManager **)

<nsServiceManagerImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
nsServiceManagerImpl::nsServiceManagerImpl(void)

<nsServiceManagerImpl>
__builtin_new
nsHashtable::Put(nsHashKey *, void *)
nsServiceManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)

<nsServiceManagerImpl>
__builtin_new
nsServiceManagerImpl::nsServiceManagerImpl(void)
NS_NewServiceManager(nsIServiceManager **)

<nsServiceManagerImpl>
__builtin_new
nsServiceManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)

<nsServiceManagerImpl>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsServiceManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)

#----------------------------------------------------------------------
#
# nsXMLElement
#

<nsXMLElement>
__builtin_new
nsGenericContainerElement::SetAttribute(nsINodeInfo *, basic_nsAReadableString<unsigned short> const &, int)
nsGenericXMLElement::SetAttribute(nsINodeInfo *, basic_nsAReadableString<unsigned short> const &, int)

<nsXMLElement>
__builtin_new
nsGenericContainerElement::SetAttribute(nsINodeInfo *, basic_nsAReadableString<unsigned short> const &, int)
nsXMLElement::SetAttribute(nsINodeInfo *, basic_nsAReadableString<unsigned short> const &, int)

<nsXMLElement>
__builtin_new
nsGenericContainerElement::SetAttr(nsINodeInfo *, nsAString const &, int)
nsXMLElement::SetAttr(nsINodeInfo *, nsAString const &, int)

<nsXMLElement>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsString::nsString(nsAString const &)
nsGenericContainerElement::SetAttr(nsINodeInfo *, nsAString const &, int)
nsXMLElement::SetAttr(nsINodeInfo *, nsAString const &, int)

<nsXMLElement>
PR_Malloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsCheapVoidArray::AppendElement(void *)
nsGenericContainerElement::AppendChildTo(nsIContent *, int, int)
nsXMLContentSink::AddContentAsLeaf(nsIContent *)

#----------------------------------------------------------------------
#
# nsXMLDocument
#

<nsXMLDocument>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsDocument::nsDocument(void)
nsMarkupDocument::nsMarkupDocument(void)
nsXMLDocument::nsXMLDocument(void)

<nsXMLDocument>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
nsString::AppendWithConversion(char const *, int)
nsString::AssignWithConversion(char const *)
nsDocument::StartDocumentLoad(char const *, nsIChannel *, nsILoadGroup *, nsISupports *, nsIStreamListener **, int)
nsXMLDocument::StartDocumentLoad(char const *, nsIChannel *, nsILoadGroup *, nsISupports *, nsIStreamListener **, int)

#----------------------------------------------------------------------

<nsGCCache>
__builtin_new
nsGCCache::nsGCCache(void)

#----------------------------------------------------------------------
#
# prefs
#

<nsPref>
_init
PL_HashTableRawAdd
PL_HashTableAdd
pref_HashPref

<nsPref>
_init
PL_NewHashTable
PREF_Init

<nsPref>
pref_HashPref

<nsPref>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsPref::nsPref(void)

<nsPref>
PREF_RegisterCallback

<nsPref>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
nsCString::nsCString(nsCString const &)
nsTArray<nsCString>::InsertElementAt(int, nsCString const &)
nsPrefBranch::AddObserver(char const *, nsIObserver *)

#----------------------------------------------------------------------

<nsThread>
PR_Calloc
PR_SetThreadPrivate
nsThread::RegisterThreadSelf(void)

<nsFontGTK>
XFreeFont

<nsFontGTK>
__builtin_new
nsFontGTK::operator new(unsigned int)

<nsGenericContainerElement>
__builtin_new
nsCheapVoidArray::SwitchToVector(void)
nsCheapVoidArray::AppendElement(void *)
nsGenericContainerElement::AppendChildTo(nsIContent *, int)

<nsGenericContainerElement>
PR_Realloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsCheapVoidArray::AppendElement(void *)
nsGenericContainerElement::AppendChildTo(nsIContent *, int, int)

#----------------------------------------------------------------------
#
# nsObserverService
#

<nsObserverService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsObserverService::GetObserverList(unsigned short const *, nsIObserverList **)

<nsObserverService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
nsObserverService::GetObserverList(unsigned short const *, nsIObserverList **)

<nsObserverService>
__builtin_new
nsStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsObserverService::GetObserverList(nsString const &, nsIObserverList **)

<nsObserverService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
nsObserverService::GetObserverList(nsString const &, nsIObserverList **)

<nsObserverService>
__builtin_new
NS_NewObserverList(nsIObserverList **)
nsObserverService::GetObserverList(nsString const &, nsIObserverList **)

<nsObserverService>
__builtin_new
nsObserverService::GetObserverList(nsString const &, nsIObserverList **)

<nsObserverService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsObserverService::GetObserverList(nsString const &, nsIObserverList **)

<nsObserverService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
nsObserverService::GetObserverList(char const *, nsObserverList **)

<nsObserverService>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
nsObserverList::AddObserver(nsIObserver *, int)

#----------------------------------------------------------------------

<nsViewManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsViewManager::nsViewManager(void)

<nsViewManager2>
__builtin_new
nsViewManager2::AddToDisplayList(int *, nsIView *, nsRect &, nsRect &, unsigned int, int, int)

# ----------------------------------------------------------------------
#
# nsBindingManager
#

<nsBindingManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsBindingManager::SetContentListFor(nsIContent *, nsISupportsArray *)

<nsBindingManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)

<nsBindingManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsBindingManager::SetAnonymousNodesFor(nsIContent *, nsISupportsArray *)

<nsBindingManager>
__builtin_new
nsISupportsKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)

<nsBindingManager>
__builtin_new
nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)

<nsBindingManager>
__builtin_new
nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)

<nsBindingManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)

<nsBindingManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)

<nsBindingManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)

<nsBindingManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)

<nsBindingManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsBindingManager::SetWrappedJS(nsIContent *, nsIXPConnectWrappedJS *)

<nsBindingManager>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
nsBindingManager::AddToAttachedQueue(nsIXBLBinding *)

# ----------------------------------------------------------------------

<NameSpaceManagerImpl>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsString::nsString(nsAString const &)
NameSpaceManagerImpl::RegisterNameSpace(nsAString const &, int &)

<NameSpaceManagerImpl>
__builtin_new
nsStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsLayoutUtils::GetDynamicScriptContext(JSContext *, nsIScriptContext **)
NameSpaceManagerImpl::NameSpaceManagerImpl(void)

<NameSpaceManagerImpl>
__builtin_new
nsStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
NameSpaceManagerImpl::RegisterNameSpace(basic_nsAReadableString<unsigned short> const &, int &)

<NameSpaceManagerImpl>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)
nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)
nsString::nsString(nsString const &)
nsLayoutUtils::CopyNewlineNormalizedUnicodeTo(nsReadingIterator<unsigned short> &, nsReadingIterator<unsigned short> const &, basic_nsAWritableString<unsigned short> &)
NameSpaceManagerImpl::NameSpaceManagerImpl(void)

<nsErrorService>
__builtin_new
nsErrorService::Create(nsISupports *, nsID const &, void **)

<nsErrorService>
__builtin_new
nsVoidKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsInt2StrHashtable::Put(unsigned int, char const *)
nsErrorService::RegisterErrorStringBundleKey(unsigned int, char const *)

<nsErrorService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsInt2StrHashtable::Put(unsigned int, char const *)
nsErrorService::RegisterErrorStringBundleKey(unsigned int, char const *)

<nsDocument>
__builtin_new
ArenaImpl::Create(nsISupports *, nsID const &, void **)
NS_NewHeapArena(nsIArena **, unsigned int)
nsDocument::Init(void)

<nsDocument>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsDocument::nsDocument(void)

<nsDocument>
__builtin_new
nsDocument::SetHeaderData(nsIAtom *, basic_nsAReadableString<unsigned short> const &)

<nsDocument::mContentWrapperHash>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsDocument::AddReference(void *, nsISupports *)

<nsDocHeaderData>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
~.*
~.*
basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)
nsDocHeaderData::nsDocHeaderData(nsIAtom *, basic_nsAReadableString<unsigned short> const &)

<XPCContext>
__builtin_new
XPCContext::newXPCContext(XPCJSRuntime *, JSContext *)

<nsEventQueueService>
__builtin_new
nsEventQueueServiceImpl::Create(nsISupports *, nsID const &, void **)

<nsEventQueueService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsEventQueueServiceImpl::nsEventQueueServiceImpl(void)

<nsEventListenerManager>
PR_Realloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)

<nsEventListenerManager>
PR_Malloc
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)
nsEventListenerManager::SetJSEventListener(nsIScriptContext *, nsISupports *, nsIAtom *, int)
nsEventListenerManager::AddScriptEventListener(nsIScriptContext *, nsISupports *, nsIAtom *, nsAString const &, int)

<nsEventListenerManager>
PR_Malloc
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)
nsEventListenerManager::AddEventListenerByType(nsIDOMEventListener *, nsAString const &, int)

<nsEventListenerManager>
PR_Malloc
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)
nsEventListenerManager::AddEventListenerByIID(nsIDOMEventListener *, nsID const &, int)

<nsEventListenerManager>
PR_Malloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::ReplaceElementAt(void *, int)
nsEventListenerManager::GetListenersByType(EventArrayType, nsHashKey *, int)

<nsEventListenerManager>
PR_Malloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::ReplaceElementAt(void *, int)
nsEventListenerManager::GetListenersByType(EventArrayType, nsHashKey *, int)

<nsEventListenerManager>
__builtin_new
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, nsID const &, int, int)

<nsEventListenerManager>
PR_Malloc
nsEventListenerManager::AddEventListener(nsIDOMEventListener *, nsID const &, int, int)

<nsCParserNode>
__builtin_new
nsCParserNode::AddAttribute(CToken *)

<nsCParserNode>
__builtin_new
__builtin_vec_new
nsDeque::GrowCapacity(void)
nsDeque::Push(void *)
nsCParserNode::AddAttribute(CToken *)

<nsSocketTransportService>
PR_Malloc
nsSocketTransportService::Init(void)

<nsSocketTransport>
PR_Malloc
nsSocketTransport::AsyncWrite(nsIInputStream *, nsIStreamObserver *, nsISupports *)

<nsSocketTransport>
PR_Malloc
_PR_Getfd
PR_GetConnectStatus
PR_Socket
PR_OpenTCPSocket
nsSocketTransport::doConnection(short)

<CompositeDataSourceImpl>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::AddBucket(unsigned int)
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
CompositeDataSourceImpl::CompositeDataSourceImpl(void)

<CompositeDataSourceImpl>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
CompositeDataSourceImpl::GetTargets(nsIRDFResource *, nsIRDFResource *, int, nsISimpleEnumerator **)

<CompositeDataSourceImpl>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
CompositeDataSourceImpl::ArcLabelsIn(nsIRDFNode *, nsISimpleEnumerator **)

<CompositeDataSourceImpl>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
CompositeDataSourceImpl::ArcLabelsOut(nsIRDFResource *, nsISimpleEnumerator **)

# ----------------------------------------------------------------------
#
# nsHTMLValue
#

<nsHTMLValue>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
unsigned short * AllocateStringCopy<unsigned short, unsigned short>(basic_nsAReadableString<unsigned short> const &, unsigned short *)
ToNewUnicode(basic_nsAReadableString<unsigned short> const &)
nsHTMLValue::nsHTMLValue(basic_nsAReadableString<unsigned short> const &, nsHTMLUnit)

<nsHTMLValue>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewUnicode(nsAString const &)
nsHTMLValue::SetStringValue(nsAString const &, nsHTMLUnit)

<nsHTMLValue>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
ToNewUnicode(nsAString const &)
nsHTMLValue::nsHTMLValue(nsAString const &, nsHTMLUnit)

<nsHTMLValue>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
ToNewUnicode(nsAString const &)
nsHTMLValue::SetStringValue(nsAString const &, nsHTMLUnit)

# ----------------------------------------------------------------------

<nsMemCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)

<nsMemCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsMemCache::Init(void)

<nsMemCache>
__builtin_new
nsOpaqueKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)

<nsMemCache>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsOpaqueKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)

<nsMemCache>
__builtin_new
nsOpaqueKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)

<nsMemCache>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsOpaqueKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)

<nsMemCacheRecord>
__builtin_new
__builtin_vec_new
nsMemCacheRecord::SetMetaData(unsigned int, char const *)

<nsMemCacheRecord>
__builtin_new
__builtin_vec_new
nsMemCacheRecord::Init(char const *, unsigned int, unsigned int, nsMemCache *)

<nsTextFormatter>
PR_Realloc
nsXPIDLString type_info function
nsXPIDLString type_info function
nsTextFormatter::vsmprintf(unsigned short const *, void *)
nsTextFormatter::smprintf(unsigned short const *,...)

<nsTextFormatter>
PR_Malloc
nsXPIDLString type_info function
nsXPIDLString type_info function
nsTextFormatter::vsmprintf(unsigned short const *, void *)

<nsTextFormatter>
PR_Realloc
nsXPIDLString type_info function
nsXPIDLString type_info function
nsTextFormatter::vsmprintf(unsigned short const *, void *)

#----------------------------------------------------------------------
#
# nsPresContext
#

<nsPresContext>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsPresContext::nsPresContext(void)

<nsPresContext>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsPresContext::LoadImage(nsString const &, nsIFrame *, imgIRequest **)

#----------------------------------------------------------------------
#
# nsPresState
#

<nsPresState>
__builtin_new
nsPresState::SetStateProperty(nsAString const &, nsAString const &)

<nsPresState>
__builtin_new
nsPresState::SetStatePropertyAsSupports(nsAString const &, nsISupports *)

<nsPresState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsPresState::SetStatePropertyAsSupports(basic_nsAReadableString<unsigned short> const &, nsISupports *)

<nsPresState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)

<nsPresState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsPresState::SetStatePropertyAsSupports(basic_nsAReadableString<unsigned short> const &, nsISupports *)

<nsPresState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)

<nsPresState>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsSupportsWStringImpl::SetDataWithLength(unsigned int, unsigned short const *)
nsSupportsWStringImpl::SetData(unsigned short const *)
nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)

<nsPresState>
__builtin_new
nsStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsPresState::SetStatePropertyAsSupports(basic_nsAReadableString<unsigned short> const &, nsISupports *)

<nsPresState>
__builtin_new
nsStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)

<nsPresState>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsSupportsWStringImpl::SetDataWithLength(unsigned int, unsigned short const *)
nsSupportsWStringImpl::SetData(unsigned short const *)
nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)

<nsPresState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsPresState::SetStateProperty(nsAString const &, nsAString const &)

<nsPresState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsPresState::SetStatePropertyAsSupports(nsAString const &, nsISupports *)

<nsPresState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsPresState::SetStateProperty(nsAString const &, nsAString const &)

<nsPresState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsPresState::SetStatePropertyAsSupports(nsAString const &, nsISupports *)

<nsPresState>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsSupportsStringImpl::SetDataWithLength(unsigned int, char const *)
nsSupportsStringImpl::SetData(char const *)
nsPresState::SetStateProperty(nsAString const &, nsAString const &)

# ----------------------------------------------------------------------
#
# Prefs stuff
#

<prefs-unclassified>
PL_strdup
pref_HashPref

<prefs-unclassified>
PL_strdup
PREF_LockPref

<prefs-unclassified>
PL_strdup
PREF_RegisterCallback

#----------------------------------------------------------------------
#
# Imagelib Stuff
#

<imgRequest>
PR_Malloc
nsVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
imgRequest::AddProxy(imgRequestProxy *)

<ImageRequestImpl>
__builtin_new
ImageRequestImpl::AddObserver(nsIImageRequestObserver *)

<ImageRequestImpl>
PR_Malloc
XP_AddObserver
ImageRequestImpl::Init(void *, char const *, nsIImageRequestObserver *, unsigned int const *, unsigned int, unsigned int, unsigned int, ilINetContext *)

<imglib-unclassified>
__builtin_new
ImageNetContextImpl::GetURL(ilIURL *, ImgCachePolicy, ilINetReader *, int)

# il_group_notify() is really a call to a static rounting il_init_scaling()
<imglib-scaling>
PR_Malloc
il_group_notify(_IL_GroupContext *, long)
il_size(il_container_struct *)
ImgDCallbk::ImgDCBImageSize(void)

<imglib-gifdecode>
PR_Calloc
il_gif_write(il_container_struct *, unsigned char const *, int)

<imglib-gifdecode>
PR_Malloc
il_gif_write(il_container_struct *, unsigned char const *, int)

<gif_struct>
PR_Calloc
il_gif_init(il_container_struct *)

<IL_ImageReq>
PR_Calloc
IL_GetImage

<imglib-container-stuff>
PR_Calloc
il_get_container(_IL_GroupContext *, ImgCachePolicy, char const *, _NI_IRGB *, IL_DitherMode, int, int, int)

<IL_ColorSpace>
PR_Calloc
IL_CreateTrueColorSpace

<IL_Pixmap>
PR_Calloc
il_size(il_container_struct *)
ImgDCallbk::ImgDCBImageSize(void)

<IL_ColorSpace>
PR_Calloc
IL_CreateGreyScaleColorSpace

<imglib-gifcompat>
PR_Malloc
il_BACat(char **, unsigned int, char const *, unsigned int)

<imglib-gifcompat>
PR_Realloc
il_BACat(char **, unsigned int, char const *, unsigned int)

<ImageConsumer>
PR_Malloc
ImageConsumer::OnStartRequest(nsIChannel *, nsISupports *)

# These are really called from `static' routines in ilclient.cpp,
# *not* ImgDCallbk::CreateInstance()
<imglib-list>
PR_Calloc
ImgDCallbk::CreateInstance(nsID const &, il_container_struct *, nsID const &, void **)

#----------------------------------------------------------------------

<nsImageGTK>
__builtin_new
__builtin_vec_new
nsImageGTK::Init(int, int, int, nsMaskRequirements)

#----------------------------------------------------------------------
#
# nsLayoutHistoryState
#

<nsLayoutHistoryState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsLayoutHistoryState::nsLayoutHistoryState(void)

<nsLayoutHistoryState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsLayoutHistoryState::nsLayoutHistoryState(void)

<nsLayoutHistoryState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsLayoutHistoryState::AddState(unsigned int, nsIPresState *, nsIStatefulFrame::StateType)

<nsLayoutHistoryState>
__builtin_new
nsVoidKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsLayoutHistoryState::AddState(unsigned int, nsIPresState *, nsIStatefulFrame::StateType)

<nsLayoutHistoryState>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsLayoutHistoryState::AddState(nsCString const &, nsIPresState *)

<nsLayoutHistoryState>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsLayoutHistoryState::AddState(nsCString const &, nsIPresState *)

# ----------------------------------------------------------------------
#
# nsCookieService
#

<nsCookieService>
PR_Realloc
Local_SACat(char **, char const *)
COOKIE_GetCookie(char *)

<nsCookieService>
PR_Malloc
cookie_IsFromHost(_cookie_CookieStruct *, char *)

<nsCookieService>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewCString(nsAString const &)
COOKIE_Read(void)
nsCookieService::Init(void)

# ----------------------------------------------------------------------

<nsReplacementPolicy>
PR_Realloc
nsMemoryImpl::Realloc(void *, unsigned int)
nsMemory::Realloc(void *, unsigned int)
nsReplacementPolicy::AssociateCacheEntryWithRecord(nsINetDataCacheRecord *, nsINetDataCache *, nsCachedNetData **)

<nsReplacementPolicy>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsReplacementPolicy::Init(unsigned int)

<nsHTTPHeaderArray>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsCString::SetCapacity(unsigned int)
nsCString::SetLength(unsigned int)
nsACString::do_AssignFromReadable(nsACString const &)
nsACString::do_AssignFromElementPtr(char const *)
nsHttpHeaderArray::SetHeader(nsHttpAtom, char const *)

<nsHTTPHandler>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsHTTPHandler::SetServerCapabilities(char const *, int, unsigned int)

<nsHTTPHandler>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsHTTPHandler::nsHTTPHandler(void)

<nsHTTPHandler>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsHTTPHandler::SetServerCapabilities(char const *, int, unsigned int)

<nsCachedNetData>
PR_Malloc
PL_ArenaAllocate
ArenaImpl::Alloc(unsigned int)
nsCachedNetData::operator new(unsigned int, nsIArena *)

<ns4xPluginStreamListener>
PR_Malloc
ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo *, nsIInputStream *, unsigned int)

<nsSegmentedBuffer>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsSegmentedBuffer::AppendNewSegment(void)

<nsAuthURLParser>
PL_strndup
ExtractString

<nsJAR>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
__17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii
nsJAR::nsJAR(void)

<nsJAR>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
nsJAR::nsJAR(void)

<nsJARURI>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewCString(nsACString const &)
nsIOService::ResolveRelativePath(char const *, char const *, char **)
nsJARURI::SetSpec(char const *)

<nsStreamConverterService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsStreamConverterService::Init(void)

<nsLayoutUtils>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsLayoutUtils::GetDynamicScriptContext(JSContext *, nsIScriptContext **)

<nsDNSService>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsDNSService::GetLookupEntry(char const *, nsDNSLookup **)

<nsDNSService>
PL_DHashAllocTable
PL_DHashTableInit
nsDNSService::Init(void)

<nsDNSService>
__builtin_new
nsDNSService::GetLookupEntry(char const *, nsDNSLookup **)

<nsDNSService>
__builtin_new
nsDNSService::Lookup(char const *, nsIDNSListener *, nsISupports *, nsIRequest **)

<nsDNSService>
__builtin_new
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsDNSService::GetLookupEntry(char const *, nsDNSLookup **)

<nsDNSLookup>
gethostbyname2
PR_GetIPNodeByName
nsDNSLookup::InitiateLookup(void)

<nsDNSLookup>
__builtin_new
nsSupportsArray::Create(nsISupports *, nsID const &, void **)
NS_NewISupportsArray(nsISupportsArray **)
nsDNSLookup::Init(char const *)

<nsDNSLookup>
__builtin_new
nsDNSLookup::Create(char const *)

# ----------------------------------------------------------------------
#
# nsFormControlList
#

<nsFormControlList>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsFormControlList::AddElementToTable(nsIFormControl *, basic_nsAReadableString<unsigned short> const &)

<nsFormControlList>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsFormControlList::nsFormControlList(nsIDOMHTMLFormElement *)

<nsFormControlList>
__builtin_new
nsFormControlList::AddElementToTable(nsIFormControl *, basic_nsAReadableString<unsigned short> const &)

<nsFormControlList>
__builtin_new
nsStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsFormControlList::AddElementToTable(nsIFormControl *, basic_nsAReadableString<unsigned short> const &)

<nsFormControlList>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsFormControlList::AddElementToTable(nsIFormControl *, basic_nsAReadableString<unsigned short> const &)

<nsFormControlList>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsFormControlList::AddElementToTable(nsIFormControl *, nsAString const &)

# ----------------------------------------------------------------------
#
# nsControllerCommandManager
#

<nsControllerCommandManager>
__builtin_new
__builtin_vec_new
NS_NewControllerCommandManager(nsIControllerCommandManager **)

<nsControllerCommandManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsControllerCommandManager::nsControllerCommandManager(void)

<nsControllerCommandManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsControllerCommandManager::RegisterCommand(nsAString const &, nsIControllerCommand *)

<nsControllerCommandManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsControllerCommandManager::RegisterCommand(unsigned short const *, nsIControllerCommand *)

<nsControllerCommandManager>
__builtin_new
nsStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsControllerCommandManager::RegisterCommand(unsigned short const *, nsIControllerCommand *)

<nsControllerCommandManager>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)
nsControllerCommandManager::nsControllerCommandManager(void)

<nsConsoleService>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsConsoleService::nsConsoleService(void)

<nsGenericElement>
__builtin_new
nsGenericElement::GetDOMSlots(void)

<HTMLAttribute>
__builtin_new
HTMLAttribute::CopyHTMLAttributes(HTMLAttribute *, HTMLAttribute **)

# ----------------------------------------------------------------------
#
# HTMLAttributesImpl
#

<HTMLAttributesImpl>
__builtin_new
HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsAString const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *)

<HTMLAttributesImpl>
__builtin_new
HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsHTMLValue const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *, int &)

<HTMLAttributesImpl>
__builtin_new
__builtin_vec_new
HTMLAttributesImpl::SetAttributeName(nsIAtom *, int &)

<HTMLAttributesImpl>
__builtin_new
nsHTMLMappedAttributes::SetAttribute(nsIAtom *, nsHTMLValue const &)
HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsHTMLValue const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *, int &)

<HTMLAttributesImpl>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCRT::strndup(unsigned short const *, unsigned int)
nsCRT::strdup(unsigned short const *)
nsHTMLValue::nsHTMLValue(nsHTMLValue const &)
HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsHTMLValue const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *, int &)

<HTMLAttributesImpl>
__builtin_new
nsHTMLMappedAttributes::nsHTMLMappedAttributes(nsHTMLMappedAttributes const &)
nsHTMLMappedAttributes::Clone(nsHTMLMappedAttributes **) const
HTMLAttributesImpl::EnsureSingleMappedFor(nsIHTMLContent *, nsIHTMLStyleSheet *, int)

# ----------------------------------------------------------------------

<nsEntityConverter>
__builtin_new
__builtin_vec_new
nsEntityConverter::LoadVersionPropertyFile(void)

<nsTableFrame>
__builtin_new
__builtin_vec_new
nsTableFrame::nsTableFrame(void)

<nsTableFrame>
__builtin_new
__builtin_vec_new
nsTableFrame::BalanceColumnWidths(nsIPresContext *, nsHTMLReflowState const &, nsSize const &, nsSize *)

<nsTableFrame>
__builtin_new
nsTableFrame::Init(nsIPresContext *, nsIContent *, nsIFrame *, nsIStyleContext *, nsIFrame *)

<nsTableCellFrame>
__builtin_new
nsTableCellFrame::GetFrameName(nsString &) const

<nsCellMap>
__builtin_new
nsCellMap::AppendCell(nsTableCellMap &, nsTableCellFrame &, int, int)

<nsCellMap>
__builtin_new
nsCellMap::Grow(nsTableCellMap &, int, int)

<nsCellMap>
PR_Malloc
nsVoidArray::SizeTo(int)
nsVoidArray::nsVoidArray(int)
nsCellMap::Grow(nsTableCellMap &, int, int)

<nsTableCellMap>
__builtin_new
nsTableCellMap::InsertGroupCellMap(nsTableRowGroupFrame &, nsTableRowGroupFrame *&)

<nsTableCellMap>
__builtin_new
nsTableCellMap::AddColsAtEnd(unsigned int)

<nsEncoderSupport>
__builtin_new
__builtin_vec_new
nsEncoderSupport::nsEncoderSupport(void)

<nsFrameImageLoader>
__builtin_new
Init__18nsFrameImageLoaderP14nsIPresContextP13nsIImageGroupRC8nsStringPCUiPC6nsSizeP8nsIFrame16nsImageAnimationPFP14nsIPresContextP19nsIFrameImageLoaderP8nsIFramePvUi_UiPvT9

<nsFrameImageLoader>
__builtin_new
AddFrame__18nsFrameImageLoaderP8nsIFramePFP14nsIPresContextP19nsIFrameImageLoaderP8nsIFramePvUi_UiPvT3


<nsFloaterCacheFreeList>
__builtin_new
nsFloaterCacheFreeList::Alloc(void)

<nsDocLoaderImpl>
__builtin_new
nsDocLoaderImpl::AddChannelInfo(nsIChannel *)

<nsDocLoaderImpl>
__builtin_new
nsDocLoaderImpl::AddRequestInfo(nsIRequest *)

<nsTokenAllocator>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::AddBucket(unsigned int)
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
nsTokenAllocator::nsTokenAllocator(void)

<SinkContext>
__builtin_new
__builtin_vec_new
SinkContext::AddText(basic_nsAReadableString<unsigned short> const &)

<SinkContext>
__builtin_new
__builtin_vec_new
SinkContext::GrowStack(void)

<nsScanner>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsScanner::Append(char const *, unsigned int)

<nsParser>
__builtin_new
nsParser::Parse(nsIURI *, nsIStreamObserver *, int, void *, nsDTDMode)

<nsParser>
__builtin_new
nsParser::Parse(basic_nsAReadableString<unsigned short> const &, void *, nsString const &, int, int, nsDTDMode)

<nsParser>
__builtin_new
__builtin_vec_new
nsParser::OnDataAvailable(nsIChannel *, nsISupports *, nsIInputStream *, unsigned int, unsigned int)

<nsParserModule>
__builtin_new
__builtin_vec_new
InitializeElementTable(void)

<nsStorageStream>
__builtin_new
nsStorageStream::Init(unsigned int, unsigned int, nsIMemory *)

<nsEntryStack>
__builtin_new
__builtin_vec_new
nsEntryStack::EnsureCapacityFor(int, int)

<nsCacheManager>
__builtin_new
nsCacheManager::Init(void)

<nsScriptError>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
~.*
~.*
basic_nsAWritableString<unsigned short>::Assign(unsigned short const *)
nsScriptError::Init(unsigned short const *, unsigned short const *, unsigned short const *, unsigned int, unsigned int, unsigned int, char const *)

<nsScriptError>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsCString::SetCapacity(unsigned int)
nsCString::SetLength(unsigned int)
~.*
~.*
basic_nsAWritableString<char>::Assign(char const *)
nsScriptError::Init(unsigned short const *, unsigned short const *, unsigned short const *, unsigned int, unsigned int, unsigned int, char const *)

<registry-Buffer>
PR_Malloc
bufio_SetBufferSize

<nsString::PRUnichar*>
PR_Malloc
nsMemoryImpl::Alloc
nsMemory::Alloc
ToNewUnicode

<nsString::char*>
PR_Malloc
nsMemoryImpl::Alloc
nsMemory::Alloc
nsStr::Alloc

<nsDiskCacheMap>
__builtin_new
nsDiskCacheDevice::Init(void)

<nsXULPrototypeAttribute>
__builtin_new
__builtin_vec_new
XULContentSinkImpl::AddAttributes(nsIParserNode const &, nsXULPrototypeElement *)

#
# XPCNativeInterface::NewInstance allocates an array of XPCNativeMember
# objects, and it also allocates an array of bytes to use for
# XPCNativeInterface objects.  Trace would be the same for each.
#
<XPCNativeInterface>
__builtin_new
__builtin_vec_new
XPCNativeInterface::NewInstance(XPCCallContext &, nsIInterfaceInfo *)

<XPCNativeInterface>
JS_DHashAllocTable
JS_DHashTableFinish
JS_DHashTableOperate
XPCNativeInterface::GetNewOrUsed(XPCCallContext &, nsID const *)

<nsDiskCacheBlockFile::mBitmap>
__builtin_new
__builtin_vec_new
nsDiskCacheBlockFile::Open(nsILocalFile *, unsigned int)

#----------------------------------------------------------------------
#
# nsConflictSet
#

<nsConflictSet::mBindingDependencies>
__builtin_new
__builtin_vec_new
nsConflictSet::AllocBindingTable(void *, unsigned int)

<nsConflictSet::mBindingDependencies>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsConflictSet::AllocBindingEntry(void *, void const *)

<nsConflictSet::mClusters>
__builtin_new
__builtin_vec_new
nsConflictSet::AllocClusterTable(void *, unsigned int)

<nsConflictSet::mClusters>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsConflictSet::AllocClusterEntry(void *, void const *)

<nsConflictSet::mSupport>
__builtin_new
__builtin_vec_new
nsConflictSet::AllocSupportTable(void *, unsigned int)

<nsConflictSet::mSupport>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsConflictSet::AllocSupportEntry(void *, void const *)

<nsConflictSet::mSupport>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsRDFConMemberTestNode::Element::Clone(void *) const

<nsConflictSet::mSupport>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsRDFConInstanceTestNode::Element::Clone(void *) const

<nsConflictSet::mSupport>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsRDFConInstanceTestNode::FilterInstantiations(InstantiationSet &, void *) const

<nsConflictSet::mSupport>
__builtin_new
MemoryElementSet::Add(MemoryElement *)

<nsConflictSet>
PL_DHashAllocTable
PL_DHashTableFinish
PL_DHashTableOperate
nsTemplateMatchRefSet::AddToTable(nsTemplateMatch *)
nsTemplateMatchRefSet::Add(nsTemplateMatch const *)
nsConflictSet::Add(nsTemplateMatch *)

<nsConflictSet>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::AddBucket(unsigned int)
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
nsConflictSet::Init(void)

<nsConflictSet>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsConflictSet::SupportEntry::Create(nsFixedSizeAllocator &)

<nsConflictSet>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsConflictSet::ClusterEntry::Create(nsFixedSizeAllocator &)

#----------------------------------------------------------------------

<nsAssignmentSet>
__builtin_new
nsAssignmentSet::Add(nsAssignment const &)

#----------------------------------------------------------------------
#
# nsXULTemplateBuilder
#

<nsXULTemplateBuilder>
__builtin_new
nsXULTemplateBuilder::CompileSimpleRule(nsIContent *, int, InnerNode *)

<nsXULTemplateBuilder>
PL_DHashAllocTable
PL_DHashTableInit
nsXULContentBuilder::nsXULContentBuilder(void)

<nsXULTemplateBuilder>
PL_DHashAllocTable
PL_DHashTableInit
nsContentSupportMap::Init(void)

<nsXULTemplateBuilder>
PL_DHashAllocTable
PL_DHashTableFinish
PL_DHashTableOperate
nsXULContentBuilder::BuildContentFromTemplate(nsIContent *, nsIContent *, nsIContent *, int, nsIRDFResource *, int, nsTemplateMatch *, nsIContent **, int *)

<nsXULTemplateBuilder>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCRT::strndup(unsigned short const *, unsigned int)
nsCRT::strdup(unsigned short const *)
nsXULTemplateBuilder::AddBindingsFor(nsXULTemplateBuilder *, nsAString const &, void *)

#----------------------------------------------------------------------
#
# nsRuleNetwork
#

<nsRuleNetwork>
PL_DHashAllocTable
PL_DHashTableInit
nsRuleNetwork::Init(void)

#----------------------------------------------------------------------
#
# nsTemplateRule
#

<nsTemplateRule>
__builtin_new
nsTemplateRule::AddBinding(int, nsIRDFResource *, int)

#----------------------------------------------------------------------
#
# nsTemplateMatch
#

<nsTemplateMatch>
__builtin_new
nsAssignmentSet::Add(nsAssignment const &)
nsTemplateRule::ComputeAssignmentFor(nsConflictSet &, nsTemplateMatch *, int, Value *) const
nsTemplateMatch::GetAssignmentFor(nsConflictSet &, int, Value *)

<nsTemplateMatch>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsInstantiationNode::Propagate(InstantiationSet const &, void *)

<nsTemplateMatch>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsRDFConMemberTestNode::FilterInstantiations(InstantiationSet &, void *) const

<nsTemplateMatch>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsTemplateMatch::Create(nsFixedSizeAllocator &, nsTemplateRule const *, Instantiation const &, nsAssignmentSet const &)

#----------------------------------------------------------------------

<ReteNodeSet::mNodes>
__builtin_new
__builtin_vec_new
ReteNodeSet::Add(ReteNode *)

#----------------------------------------------------------------------

<StaticModuleInfo>
__builtin_new
__builtin_vec_new
nsStaticComponentLoader::GetModuleInfo(void)

<RuleValue*>
__builtin_new
__builtin_vec_new
RuleHash::EnumerateAllRules(int, nsIAtom *, nsIAtom *, nsVoidArray const &, void (*)(nsICSSStyleRule *, void *), void *)

<XPCNativeSet>
__builtin_new
__builtin_vec_new
XPCNativeSet::NewInstance(XPCCallContext &, nsIInterfaceInfo *)

<XPCNativeSet>
JS_DHashAllocTable
JS_DHashTableFinish
JS_DHashTableOperate
XPCNativeSet::ClearCacheEntryForClassInfo(nsIClassInfo *)

<XPCNativeSet>
__builtin_new
__builtin_vec_new
XPCNativeSet::NewInstanceMutate(XPCNativeSet *, XPCNativeInterface *, unsigned short)

<nsIRDFResource*>
__builtin_new
__builtin_vec_new
nsResourceSet::Add(nsIRDFResource *)

<nsXPCWrappedJSClass::mDescriptors>
__builtin_new
__builtin_vec_new
nsXPCWrappedJSClass::nsXPCWrappedJSClass(XPCCallContext &, nsID const &, nsIInterfaceInfo *)

<orkin-unclassified>
__builtin_new
orkinHeap::Alloc(nsIMdbEnv *, unsigned int, void **)

<nsGenericAttribute>
__builtin_new
nsGenericContainerElement::SetAttribute(nsINodeInfo *, nsAString const &, int)

#
# Space for LiteralImpl is allocated using global operator new so
# that extra space can be allocated for its string value.
#
<LiteralImpl>
__builtin_new
LiteralImpl::Create

<nsXULContentSinkImpl::mText>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
XULContentSinkImpl::FlushText(int)

<nsPersistentProperties>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCRT::strndup(unsigned short const *, unsigned int)
nsCRT::strdup(unsigned short const *)
nsString::ToNewUnicode(void) const
nsPersistentProperties::SetStringProperty(nsString const &, nsString &, nsString &)

<nsCSSValue>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCRT::strndup(unsigned short const *, unsigned int)
nsCRT::strdup(unsigned short const *)
nsCSSValue::operator=(nsCSSValue const &)

#----------------------------------------------------------------------
#
# nsXULDocument
#

<nsXULDocument>
PR_Realloc
nsVoidArray::SizeTo(int)
nsAutoVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsXULDocument::AddObserver(nsIDocumentObserver *)

<nsXULDocument::mBoxObjectTable>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXULDocument::SetBoxObjectFor(nsIDOMElement *, nsIBoxObject *)

<nsXULDocument::mTemplateBuilderTable>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXULDocument::SetTemplateBuilderFor(nsIContent *, nsIXULTemplateBuilder *)

# ----------------------------------------------------------------------

<nsXULDocument::mElementMap>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewUnicode(nsAString const &)
nsElementMap::Add(nsAString const &, nsIContent *)
nsXULDocument::AddElementToMap(nsIContent *)

<nsXULDocument::mElementMap>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewUnicode(nsAString const &)
nsElementMap::Add(nsAString const &, nsIContent *)
nsXULDocument::AddElementForID(nsAString const &, nsIContent *)

<nsXULDocument::mElementMap>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsXULTreeElement::SelectCallback(nsITimer *, void *)
PL_HashTableRawAdd
PL_HashTableAdd
nsElementMap::Add(nsAString const &, nsIContent *)

<nsXULDocument::mElementMap>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
NS_NewControllerCommandManager(nsIControllerCommandManager **)
PL_HashTableRawAdd
PL_HashTableAdd
nsElementMap::Add(nsAString const &, nsIContent *)

<nsXULDocument::mElementMap>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsElementMap::Add(nsAString const &, nsIContent *)

<nsXULDocument::mElementMap>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::AddBucket(unsigned int)
nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)
nsElementMap::nsElementMap(void)

<nsXULDocument::mElementMap>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)
ToNewUnicode(nsAString const &)
nsElementMap::Add(nsAString const &, nsIContent *)

<nsXULDocument::mContentWrapperHash>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsXULDocument::AddReference(void *, nsISupports *)

<nsXULDocument>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
nsXULDocument::PrepareToWalk(void)

<nsXULDocument>
PL_DHashAllocTable
PL_DHashTableInit
PL_NewDHashTable
nsXULDocument::AddBroadcastListenerFor(nsIDOMElement *, nsIDOMElement *, nsAString const &)

#----------------------------------------------------------------------

<nsHTMLValue::mValue.mString>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ToNewUnicode(nsAString const &)
nsHTMLValue::nsHTMLValue(nsAString const &, nsHTMLUnit)

<nsCSSValue>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ExtractURLScheme
nsStdURL::Resolve(char const *, char **)
CSSParserImpl::ParseURL(int &, nsCSSValue &)

<url-unclassified>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
ExtractURLScheme
nsStdURL::Resolve(char const *, char **)

<css-unclassified>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)
nsRuleWalker::Forward(nsIStyleRule *)

#
# Doesn't inherit nsISupports
#
<nsSupportsHashtable>
__builtin_new
nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)

#
# No vtable.
#
<nsClassList>
__builtin_new
nsClassList::ParseClasses(nsClassList **, nsAString const &)

#
# Doesn't inherit nsISupports
#
<nsVoidArray>
__builtin_new
nsCheapVoidArray::SwitchToVector(void)

<nsEventListenerManager>
__builtin_new
nsEventListenerManager::GetListenersByType(EventArrayType, nsHashKey *, int)

#----------------------------------------------------------------------

<nsServiceModule::mServices>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)
nsHashtable::nsHashtable(unsigned int, int)
nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)
nsServiceManagerImpl::nsServiceManagerImpl(void)

<nsImportedStringHandle>
__builtin_new
nsXPIDLCString::PrepareForUseAsOutParam(void)

<nsXBLJSClass>
__builtin_new
nsXBLBinding::InitClass

<Assertion>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)

<nsXBLAttributeEntry>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

#----------------------------------------------------------------------
#
# nsRuleNode
#

<nsRuleNode>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)
nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)

<nsRuleNode>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AppendFromReadable(nsAString const &)
nsAString::do_AppendFromElementPtr(unsigned short const *)
nsRuleNode::ComputeDisplayData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AppendFromReadable(nsAString const &)
nsAString::do_AppendFromElementPtr(unsigned short const *)
nsRuleNode::ComputeBackgroundData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AppendFromReadable(nsAString const &)
nsAString::do_AppendFromElementPtr(unsigned short const *)
nsRuleNode::ComputeListData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

# ----------------------------------------------------------------------

# This stuff will only show off if you've turned off the FrameArena
# in nsPresShell.cpp
<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeOutlineData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeContentData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeTableData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeUIResetData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeXULData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::SetDefaultOnRoot(nsStyleStructID, nsIStyleContext *)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeListData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeTextData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeTextResetData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputePaddingData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeFontData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeVisibilityData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsRuleNode>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeColorData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

# ----------------------------------------------------------------------
#
# nsBookmarksService
#

<nsBookmarksService>
PL_DHashAllocTable
PL_DHashTableFinish
PL_DHashTableOperate
InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
InMemoryDataSource::Assert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
BookmarkParser::updateAtom(nsIRDFDataSource *, nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int *)

<nsBookmarksService>
PR_Malloc
PL_ArenaAllocate
nsFixedSizeAllocator::Alloc(unsigned int)
Assertion::Create(nsFixedSizeAllocator &, nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
InMemoryDataSource::Assert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)
BookmarkParser::updateAtom(nsIRDFDataSource *, nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int *)

# ----------------------------------------------------------------------
#
# The following types will only be visible if nsPresShell.cpp is compiled
# with the DEBUG_TRACEMALLOC_FRAMEARENA defined.
#

<nsStyleContext>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsStyleContext::SetStyle(nsStyleStructID, nsStyleStruct const &)

<nsStyleBorder>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsStyleBorder::operator new(unsigned int, nsIPresContext *)

# XXX This one is a bit sloppy, and may include some of the other
# style data structs.
<nsResetStyleData>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeDisplayData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsResetStyleData>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsStyleContext::SetStyle(nsStyleStructID, nsStyleStruct const &)

<nsResetStyleData>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeBorderData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsStyleUserInterface>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeUIData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsStylePosition>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputePositionData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsStylePadding>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsStylePadding::operator new(unsigned int, nsIPresContext *)

<nsStyleMargin>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsStyleMargin::operator new(unsigned int, nsIPresContext *)

<nsStyleBackground>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeBackgroundData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsStyleBackground>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsStyleBackground::nsStyleBackground(nsStyleBackground const &)

# XXX this'll may be subsumed as nsResetStyleData
<nsStyleDisplay>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsRuleNode::ComputeDisplayData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

<nsStyleDisplay>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
nsStyleDisplay::nsStyleDisplay(nsStyleDisplay const &)

# ----------------------------------------------------------------------
# The following will only show up if you turn off the FrameArena
# in nsPresShell.cpp
<nsStyleContext>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsStyleContext::GetUniqueStyleData(nsIPresContext *, nsStyleStructID const &)

<nsStyleFont>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsPresContext::AllocateFromShell(unsigned int, void **)
nsStyleFont::operator new(unsigned int, nsIPresContext *)

# ----------------------------------------------------------------------
#
# Frames
#

<nsLineBox>
__builtin_new
nsLineBox::SetCombinedArea(nsRect const &)

# This will only appear when the FrameArena is off.
<nsLineBox>
PR_Malloc
FrameArena::AllocateFrame(unsigned int, void **)
PresShell::AllocateFrame(unsigned int, void **)
nsLineBox::operator new(unsigned int, nsIPresShell *)

# ----------------------------------------------------------------------
#
# nsCacheService
#

<nsCacheService>
__builtin_new
nsCacheService::ActivateEntry(nsCacheRequest *, nsCacheEntry **)

<nsCacheService>
__builtin_new
nsCacheEntry::CreateDescriptor(nsCacheRequest *, int, nsICacheEntryDescriptor **)
nsCacheService::ProcessRequest(nsCacheRequest *, int, nsICacheEntryDescriptor **)

<nsCacheService>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsCString::SetCapacity(unsigned int)
nsCString::SetLength(unsigned int)
nsACString::do_AppendFromReadable(nsACString const &)
nsACString::do_AppendFromElementPtr(char const *)
nsCacheService::CreateRequest(nsCacheSession *, char const *, int, int, nsICacheListener *, nsCacheRequest **)

<nsCacheService>
PL_DHashAllocTable
PL_DHashTableFinish
PL_DHashTableOperate
nsCacheEntryHashTable::AddEntry(nsCacheEntry *)
nsCacheService::ActivateEntry(nsCacheRequest *, nsCacheEntry **)

<nsCacheService>
PL_DHashAllocTable
PL_DHashTableFinish
PL_DHashTableOperate
nsCacheEntryHashTable::RemoveEntry(nsCacheEntry *)

# ----------------------------------------------------------------------

<nsCacheMetaData>
PL_DHashAllocTable
PL_DHashTableInit
nsCacheMetaData::Init(void)

# ----------------------------------------------------------------------
#
# nsXMLMIMEDataSource
#

<nsXMLMIMEDataSource>
PR_Malloc
PL_ArenaFinish
PL_HashTableRawAdd
PL_HashTableAdd
nsXMLMIMEDataSource::InitFromFile(nsIFile *)

<nsXMLMIMEDataSource>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)

<nsXMLMIMEDataSource>
PR_Malloc
nsVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
nsTArray<nsCString>::InsertElementAt(int, nsCString const &)
nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)

<nsXMLMIMEDataSource>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)

<nsXMLMIMEDataSource>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsCStringKey::Clone(void) const
nsHashtable::Put(nsHashKey *, void *)
nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)

#----------------------------------------------------------------------
#
# nsRegion
#

<nsRegion>
__builtin_new
__builtin_vec_new
RgnRectMemoryAllocator::RgnRectMemoryAllocator(unsigned int)
nsRegion::Offset(int, int)

<nsRegion>
__builtin_new
__builtin_vec_new
RgnRectMemoryAllocator::Alloc(void)
nsRegion::Or(nsRegion const &, nsRectFast const &)

<nsRegion>
__builtin_new
__builtin_vec_new
RgnRectMemoryAllocator::Alloc(void)
nsRegion::SetToElements(unsigned int)

#----------------------------------------------------------------------
#
# nsCharsetMenu
#

<nsCharsetMenu>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
nsCharsetConverterManager::GetRegistryEnumeration2(char *, int, nsISupportsArray **)
nsCharsetConverterManager::GetEncoderList(nsISupportsArray **)
nsCharsetMenu::InitResources(void)

<nsCharsetMenu>
__builtin_new
nsCharsetMenu::AddCharsetToItemArray(nsVoidArray *, nsIAtom *, nsMenuEntry **, int)

<nsCharsetMenu>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
nsCharsetConverterManager::GetRegistryEnumeration2(char *, int, nsISupportsArray **)
nsCharsetConverterManager::GetDecoderList(nsISupportsArray **)
nsCharsetMenu::InitResources(void)

<nsCharsetMenu>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
InMemoryDataSource::AddObserver(nsIRDFObserver *)
nsCharsetMenu::AddObserver(nsIRDFObserver *)

#----------------------------------------------------------------------
#
# nsLoadGroup
#

<nsLoadGroup>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
nsLoadGroup::AddRequest(nsIRequest *, nsISupports *)

#----------------------------------------------------------------------
#
# Wallet
#

<Wallet>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
Wallet_Decrypt2

<Wallet>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::AssignFromReadable(nsAString const &)
Wallet_RandomName

<Wallet>
PR_Malloc
nsVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
Wallet_RandomName

<Wallet>
__builtin_new
__builtin_vec_new
Wallet_Decrypt2

<Wallet>
__builtin_new
Wallet_RandomName

<Wallet>
PR_Realloc
nsVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
Wallet_Decrypt2

<Wallet>
PR_Realloc
nsVoidArray::SizeTo(int)
nsVoidArray::GrowArrayBy(int)
nsVoidArray::InsertElementAt(void *, int)
Wallet_RandomName

#----------------------------------------------------------------------
#
# nsMemoryCacheDevice
#

<nsMemCacheRecord>
PL_DHashAllocTable
PL_DHashTableFinish
PL_DHashTableOperate
nsCacheEntryHashTable::RemoveEntry(nsCacheEntry *)
nsMemoryCacheDevice::EvictEntry(nsCacheEntry *)

#----------------------------------------------------------------------
#
# nsSHEntry
#

<nsSHEntry>
PR_Malloc
nsMemoryImpl::Alloc(unsigned int)
nsMemory::Alloc(unsigned int)
nsStr::Alloc(nsStr &, unsigned int)
nsStr::Realloc(nsStr &, unsigned int)
nsStr::EnsureCapacity(nsStr &, unsigned int)
nsStr::GrowCapacity(nsStr &, unsigned int)
nsString::SetCapacity(unsigned int)
nsString::SetLength(unsigned int)
nsAString::do_AssignFromReadable(nsAString const &)
nsAString::do_AssignFromElementPtr(unsigned short const *)
nsSHEntry::SetTitle(unsigned short const *)

# ----------------------------------------------------------------------

<nsOutlinerStyleCache>
PR_Malloc
PL_HashTableFinalize(PLHashTable *)
PL_HashTableRawAdd
nsHashtable::Put(nsHashKey *, void *)
nsOutlinerStyleCache::GetStyleContext(nsICSSPseudoComparator *, nsIPresContext *, nsIContent *, nsIStyleContext *, nsIAtom *, nsISupportsArray *, nsIStyleContext **)

# ----------------------------------------------------------------------
#
# nsMsgDatabase
#

<nsMsgDatabase>
PL_DHashAllocTable
PL_DHashTableFinish
PL_DHashTableOperate
nsMsgDatabase::AddHdrToCache(nsIMsgDBHdr *, unsigned int)

<nsMsgDatabase>
PL_DHashAllocTable
PL_DHashTableFinish
PL_DHashTableOperate
nsMsgDatabase::AddHdrToUseCache(nsIMsgDBHdr *, unsigned int)

# ----------------------------------------------------------------------
#
# nsMsgFolderDataSource
#

<nsMsgFolderDataSource>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
nsMsgFolderDataSource::getFolderArcLabelsOut(nsISupportsArray **)

# ----------------------------------------------------------------------
#
# singsign
#

<SINGSIGN>
__builtin_new
SI_DeletePersistentUserData

# ----------------------------------------------------------------------
#
# LocalStoreImpl
#

<LocalStoreImpl>
__builtin_new
__builtin_vec_new
nsSupportsArray::GrowArrayBy(int)
nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)
nsSupportsArray::AppendElement(nsISupports *)
LocalStoreImpl::AddObserver(nsIRDFObserver *)

# ----------------------------------------------------------------------
#
# NSS
#

<NSS>
PR_Malloc
PL_ArenaAllocate
PORT_ArenaAlloc

<NSS>
PR_Malloc
PL_ArenaAllocate
nss_ZAlloc