The Tor Browser: tools/trace-malloc/types.dat@97036ab72558

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

     1 # This Source Code Form is subject to the terms of the Mozilla Public

     2 # License, v. 2.0. If a copy of the MPL was not distributed with this

     3 # file, You can obtain one at http://mozilla.org/MPL/2.0/.

     5 # This file contains type inference information that is intended to be

     6 # used with TraceMalloc.pm. The format of the file is:

7 #

     8 #   <InferredType>

     9 #   Stack1

    10 #   Stack2

    11 #   ...

    12 #   StackN

    13 #

    14 # Where Stack1...StackN imply that the object's type is

    15 # InferredType. Note that in many cases, we'll ``roll up'' storage

    16 # that's part of an object's implementation into the object itself.

    18 # Here's a handy regexp for cleaning up strings copied from the

    19 # uncategorized file:

    20 #

    21 #   \(^ *([0-9]+) \|\[.*\]$\)

    22 #

    24 #----------------------------------------------------------------------

    26 <nsStringRecycler>

    27 __builtin_new

    28 __builtin_vec_new

    29 nsDeque::GrowCapacity(void)

    30 nsDeque::Push(void *)

    31 nsStringRecycler::Recycle(nsString *)

    33 #----------------------------------------------------------------------

    34 #

    35 # AtomImpl

    36 #

    38 # Give AtomImpl objects the memory they allocate for storage

    39 <AtomImpl>

    40 __builtin_new

    41 AtomImpl::operator new(unsigned int, basic_nsAReadableString<unsigned short> const &)

    43 # Give AtomImpl objects the memory allocated for their table

    44 <AtomImpl>

    45 PL_DHashAllocTable

    46 PL_DHashTableFinish

    47 PL_DHashTableOperate

    48 NS_NewPermanentAtom(char const *)

    49 NS_NewAtom(nsAString const &)

    51 <AtomImpl>

    52 PR_Malloc

    53 PL_ArenaFinish

    54 PL_HashTableRawAdd

    55 NS_NewAtom(nsAString const &)

    56 NS_NewAtom(char const *)

    58 <AtomImpl>

    59 PR_Malloc

    60 PL_ArenaFinish

    61 PL_HashTableRawAdd

    62 NS_NewAtom(nsAString const &)

    63 NS_NewAtom(unsigned short const *)

    65 #----------------------------------------------------------------------

    67 <nsCSSSelector>

    68 PR_Malloc

    69 nsMemoryImpl::Alloc(unsigned int)

    70 nsMemory::Alloc(unsigned int)

    71 nsStr::Alloc(nsStr &, unsigned int)

    72 nsStr::Realloc(nsStr &, unsigned int)

    73 nsStr::EnsureCapacity(nsStr &, unsigned int)

    74 nsStr::GrowCapacity(nsStr &, unsigned int)

    75 nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)

    76 nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)

    77 nsString::nsString(nsString const &)

    78 nsAttrSelector::nsAttrSelector(nsAttrSelector const &)

    79 nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

    81 <nsCSSSelector>

    82 PR_Malloc

    83 nsMemoryImpl::Alloc(unsigned int)

    84 nsMemory::Alloc(unsigned int)

    85 nsStr::Alloc(nsStr &, unsigned int)

    86 nsStr::Realloc(nsStr &, unsigned int)

    87 nsStr::EnsureCapacity(nsStr &, unsigned int)

    88 nsStr::GrowCapacity(nsStr &, unsigned int)

    89 nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)

    90 nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)

    91 nsString::nsString(nsString const &)

    92 nsAttrSelector::nsAttrSelector(nsAttrSelector const &)

    93 nsAttrSelector::nsAttrSelector(nsAttrSelector const &)

    94 nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

    96 <nsCSSRule>

    97 __builtin_new

    98 nsCSSRule::operator new(unsigned int)

   100 #----------------------------------------------------------------------

   101 #

   102 # CSSLoaderImpl

   103 #

   105 <CSSLoaderImpl>

   106 PR_Malloc

   107 PL_HashTableFinalize(PLHashTable *)

   108 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

   109 nsHashtable::nsHashtable(unsigned int, int)

   110 CSSLoaderImpl::CSSLoaderImpl(void)

   112 <CSSLoaderImpl>

   113 PR_Malloc

   114 nsMemoryImpl::Alloc(unsigned int)

   115 nsMemory::Alloc(unsigned int)

   116 nsStr::Alloc(nsStr &, unsigned int)

   117 nsStr::Realloc(nsStr &, unsigned int)

   118 nsStr::EnsureCapacity(nsStr &, unsigned int)

   119 nsStr::GrowCapacity(nsStr &, unsigned int)

   120 nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)

   121 nsString::AppendWithConversion(char const *, int)

   122 nsString::AssignWithConversion(char const *)

   123 CSSLoaderImpl::SetCharset(nsString const &)

   125 <CSSLoaderImpl>

   126 PL_strdup

   127 URLKey::Clone(void) const

   128 nsHashtable::Put(nsHashKey *, void *)

   129 CSSLoaderImpl::SheetComplete(nsICSSStyleSheet *, SheetLoadData *)

   131 #----------------------------------------------------------------------

   133 <CSSNameSpaceRuleImpl>

   134 PR_Malloc

   135 nsMemoryImpl::Alloc(unsigned int)

   136 nsMemory::Alloc(unsigned int)

   137 nsStr::Alloc(nsStr &, unsigned int)

   138 nsStr::Realloc(nsStr &, unsigned int)

   139 nsStr::EnsureCapacity(nsStr &, unsigned int)

   140 nsStr::GrowCapacity(nsStr &, unsigned int)

   141 nsString::SetCapacity(unsigned int)

   142 nsString::SetLength(unsigned int)

   143 nsAString::do_AssignFromReadable(nsAString const &)

   144 nsAString::AssignFromReadable(nsAString const &)

   145 CSSNameSpaceRuleImpl::SetURLSpec(nsString const &)

   147 #----------------------------------------------------------------------

   148 #

   149 # nsFont

   150 #

   152 <nsFont>

   153 PR_Malloc

   154 nsMemoryImpl::Alloc(unsigned int)

   155 nsMemory::Alloc(unsigned int)

   156 nsStr::Alloc(nsStr &, unsigned int)

   157 nsStr::Realloc(nsStr &, unsigned int)

   158 nsStr::EnsureCapacity(nsStr &, unsigned int)

   159 nsStr::GrowCapacity(nsStr &, unsigned int)

   160 nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)

   161 nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)

   162 nsString::nsString(nsString const &)

   163 nsFont::nsFont(nsFont const &)

   165 <nsFont>

   166 PR_Malloc

   167 nsMemoryImpl::Alloc(unsigned int)

   168 nsMemory::Alloc(unsigned int)

   169 nsStr::Alloc(nsStr &, unsigned int)

   170 nsStr::Realloc(nsStr &, unsigned int)

   171 nsStr::EnsureCapacity(nsStr &, unsigned int)

   172 nsStr::GrowCapacity(nsStr &, unsigned int)

   173 nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)

   174 nsString::AppendWithConversion(char const *, int)

   175 nsString::AssignWithConversion(char const *)

   176 nsFont::nsFont(char const *, unsigned char, unsigned char, unsigned short, unsigned char, int, float)

   178 #----------------------------------------------------------------------

   180 <CSSImportantRule>

   181 PR_Malloc

   182 nsMemoryImpl::Alloc(unsigned int)

   183 nsMemory::Alloc(unsigned int)

   184 nsStr::Alloc(nsStr &, unsigned int)

   185 nsStr::Realloc(nsStr &, unsigned int)

   186 nsStr::EnsureCapacity(nsStr &, unsigned int)

   187 nsStr::GrowCapacity(nsStr &, unsigned int)

   188 nsString::SetCapacity(unsigned int)

   189 nsString::SetLength(unsigned int)

   190 nsAString::do_AssignFromReadable(nsAString const &)

   191 nsAString::AssignFromReadable(nsAString const &)

   192 CSSImportRuleImpl::SetURLSpec(nsString const &)

   194 <nsClassList>

   195 __builtin_new

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

   198 # ----------------------------------------------------------------------

   199 #

   200 # nsLocalFile

   201 #

   203 <nsLocalFile>

   204 __builtin_new

   205 nsLocalFile::Clone(nsIFile **)

   207 <nsLocalFile>

   208 PR_Malloc

   209 _PR_Getfd

   210 PR_GetConnectStatus

   211 PR_OpenFile

   212 PR_Open

   213 nsLocalFile::OpenNSPRFileDesc(int, int, PRFileDesc **)

   215 <nsLocalFile>

   216 PR_Calloc

   217 PR_LoadLibrary

   218 PR_LoadLibraryWithFlags

   219 PR_LoadLibrary

   220 nsLocalFile::Load(PRLibrary **)

   222 <nsLocalFile>

   223 __strdup

   224 PR_LoadLibrary

   225 PR_LoadLibraryWithFlags

   226 PR_LoadLibrary

   227 nsLocalFile::Load(PRLibrary **)

   229 <nsLocalFile>

   230 PR_Malloc

   231 nsMemoryImpl::Alloc(unsigned int)

   232 nsMemory::Alloc(unsigned int)

   233 ToNewCString(nsACString const &)

   234 nsLocalFile::AppendRelativePath(char const *)

   236 <nsLocalFile>

   237 PR_Malloc

   238 nsMemoryImpl::Alloc(unsigned int)

   239 nsMemory::Clone(void const *, unsigned int)

   240 nsLocalFile::InitWithPath(char const *)

   242 <nsLocalFile>

   243 PL_strdup

   244 nsLocalFile::ParseURL(char const *, char **, char **, char **, char **)

   246 # ----------------------------------------------------------------------

   248 <nsXULAttribute>

   249 __builtin_new

   250 nsXULAttribute::operator new(unsigned int)

   252 <nsXULAttribute>

   253 PR_Malloc

   254 nsMemoryImpl::Alloc(unsigned int)

   255 nsMemory::Alloc(unsigned int)

   256 unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)

   257 ToNewUnicode(nsAString const &)

   258 nsXULAttributeValue::SetValue(nsAString const &, int)

   260 <nsXULAttribute::mValue>

   261 PR_Malloc

   262 nsMemoryImpl::Alloc(unsigned int)

   263 nsMemory::Alloc(unsigned int)

   264 ToNewUnicode(nsAString const &)

   265 nsXULAttributeValue::SetValue(nsAString const &, int)

   267 <nsXULAttributes>

   268 __builtin_new

   269 nsXULAttributes::Create(nsIContent *, nsXULAttributes **)

   271 <nsXULAttributes>

   272 PR_Malloc

   273 PL_ArenaFinish

   274 PL_HashTableRawAdd

   275 NS_NewAtom(nsAString const &)

   276 NS_NewAtom(unsigned short const *)

   277 nsClassList::ParseClasses(nsClassList **, nsAString const &)

   278 nsXULAttributes::UpdateClassList(nsAString const &)

   280 <nsXULElement>

   281 __builtin_new

   282 nsXULElement::Create(nsINodeInfo *, nsIContent **)

   284 <nsXULElement>

   285 PR_Realloc

   286 nsVoidArray::SizeTo(int)

   287 nsAutoVoidArray::SizeTo(int)

   288 nsVoidArray::GrowArrayBy(int)

   289 nsVoidArray::InsertElementAt(void *, int)

   290 nsXULElement::EnsureSlots(void)

   292 <nsXULElement>

   293 PR_Realloc

   294 nsVoidArray::SizeTo(int)

   295 nsVoidArray::GrowArrayBy(int)

   296 nsVoidArray::InsertElementAt(void *, int)

   297 nsXULElement::AppendChildTo(nsIContent *, int, int)

   299 <nsXULElement>

   300 __builtin_new

   301 nsXULElement::EnsureSlots(void)

   303 <nsXULElement>

   304 PR_Malloc

   305 nsVoidArray::SizeTo(int)

   306 nsVoidArray::GrowArrayBy(int)

   307 nsVoidArray::InsertElementAt(void *, int)

   308 nsXULElement::AppendChildTo(nsIContent *, int, int)

   310 <nsXULElement>

   311 PR_Malloc

   312 nsVoidArray::SizeTo(int)

   313 nsAutoVoidArray::SizeTo(int)

   314 nsVoidArray::GrowArrayBy(int)

   315 nsVoidArray::InsertElementAt(void *, int)

   316 nsXULElement::EnsureSlots(void)

   318 <nsXULElement>

   319 PR_Malloc

   320 nsVoidArray::SizeTo(int)

   321 nsVoidArray::GrowArrayBy(int)

   322 nsVoidArray::InsertElementAt(void *, int)

   323 nsXULElement::AddBroadcastListener(nsAString const &, nsIDOMElement *)

   325 <sscanf>

   326 iconv_close

   328 <sscanf>

   329 tsearch

   331 <CSSDeclarationImpl>

   332 PR_Realloc

   333 nsVoidArray::SizeTo(int)

   334 nsAutoVoidArray::SizeTo(int)

   335 nsVoidArray::GrowArrayBy(int)

   336 nsVoidArray::InsertElementAt(void *, int)

   337 CSSDeclarationImpl::AppendValue(nsCSSProperty, nsCSSValue const &)

   339 <CSSDeclarationImpl>

   340 __builtin_new

   341 CSSDeclarationImpl::AppendValue(nsCSSProperty, nsCSSValue const &)

   343 <CSSDeclarationImpl>

   344 __builtin_new

   345 CSSDeclarationImpl::SetValueImportant(nsCSSProperty)

   347 <CSSDeclarationImpl>

   348 __builtin_new

   349 CSSDeclarationImpl::operator new(unsigned int)

   351 <CSSDeclarationImpl>

   352 PR_Malloc

   353 nsVoidArray::SizeTo(int)

   354 nsAutoVoidArray::SizeTo(int)

   355 nsVoidArray::GrowArrayBy(int)

   356 nsVoidArray::InsertElementAt(void *, int)

   357 CSSDeclarationImpl::AppendValue(nsCSSProperty, nsCSSValue const &)

   359 <nsVoidArray>

   360 __builtin_new

   361 __builtin_vec_new

   362 nsVoidArray::InsertElementAt(void *, int)

   364 <nsVoidArray>

   365 __builtin_new

   366 __builtin_vec_new

   367 nsVoidArray::nsVoidArray(int)

   369 <nsVoidArray>

   370 __builtin_new

   371 __builtin_vec_new

   372 nsVoidArray::Compact(void)

   374 <nsVoidArray>

   375 __builtin_new

   376 __builtin_vec_new

   377 nsVoidArray::ReplaceElementAt(void *, int)

   379 <nsGenericHTMLContainerElement>

   380 __builtin_new

   381 nsCheapVoidArray::SwitchToVector(void)

   382 nsCheapVoidArray::AppendElement(void *)

   383 nsGenericHTMLContainerElement::AppendChildTo(nsIContent *, int)

   385 <nsGenericHTMLContainerElement>

   386 PR_Malloc

   387 nsVoidArray::SizeTo(int)

   388 nsAutoVoidArray::SizeTo(int)

   389 nsVoidArray::Compact(void)

   390 nsAutoVoidArray::Compact(void)

   391 nsCheapVoidArray::Compact(void)

   392 nsGenericHTMLContainerElement::Compact(void)

   394 <nsGenericHTMLContainerElement>

   395 PR_Malloc

   396 nsVoidArray::SizeTo(int)

   397 nsAutoVoidArray::SizeTo(int)

   398 nsVoidArray::GrowArrayBy(int)

   399 nsVoidArray::InsertElementAt(void *, int)

   400 nsCheapVoidArray::AppendElement(void *)

   401 nsGenericHTMLContainerElement::AppendChildTo(nsIContent *, int, int)

   403 <nsGenericHTMLContainerElement>

   404 PR_Realloc

   405 nsVoidArray::SizeTo(int)

   406 nsAutoVoidArray::SizeTo(int)

   407 nsVoidArray::GrowArrayBy(int)

   408 nsVoidArray::InsertElementAt(void *, int)

   409 nsCheapVoidArray::AppendElement(void *)

   410 nsGenericHTMLContainerElement::AppendChildTo(nsIContent *, int, int)

   412 <nsGenericAttribute>

   413 PR_Malloc

   414 nsMemoryImpl::Alloc(unsigned int)

   415 nsMemory::Alloc(unsigned int)

   416 nsStr::Alloc(nsStr &, unsigned int)

   417 nsStr::Realloc(nsStr &, unsigned int)

   418 nsStr::EnsureCapacity(nsStr &, unsigned int)

   419 nsStr::GrowCapacity(nsStr &, unsigned int)

   420 nsString::SetCapacity(unsigned int)

   421 nsString::SetLength(unsigned int)

   422 ~.*

   423 ~.*

   424 basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)

   425 nsString::nsString(basic_nsAReadableString<unsigned short> const &)

   426 nsGenericAttribute::nsGenericAttribute(nsINodeInfo *, basic_nsAReadableString<unsigned short> const &)

   428 <nsSupportsArray>

   429 __builtin_new

   430 __builtin_vec_new

   431 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

   433 <nsSupportsArray>

   434 __builtin_new

   435 nsSupportsArray::Create(nsISupports *, nsID const &, void **)

   437 <nsZipArchive>

   438 __builtin_new

   439 __builtin_vec_new

   440 nsZipArchive::BuildFileList(void)

   442 <nsZipArchive>

   443 PR_Malloc

   444 nsMemoryImpl::Alloc(unsigned int)

   445 nsMemory::Alloc(unsigned int)

   446 nsCStringKey::Clone(void) const

   447 nsHashtable::Put(nsHashKey *, void *)

   448 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

   449 nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)

   451 <InMemoryDataSource>

   452 __builtin_new

   453 __builtin_vec_new

   454 InMemoryDataSource::AllocTable(void *, unsigned int)

   456 <InMemoryDataSource>

   457 PL_DHashAllocTable

   458 PL_DHashTableFinish

   459 PL_DHashTableOperate

   460 InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)

   462 <InMemoryDataSource>

   463 PR_Malloc

   464 PL_ArenaAllocate

   465 nsFixedSizeAllocator::AddBucket(unsigned int)

   466 nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)

   467 InMemoryDataSource::InMemoryDataSource(nsISupports *)

   469 <InMemoryDataSource>

   470 PR_Malloc

   471 PL_ArenaAllocate

   472 nsFixedSizeAllocator::Alloc(unsigned int)

   473 InMemoryDataSource::AllocEntry(void *, void const *)

   475 <InMemoryDataSource>

   476 PR_Malloc

   477 PL_ArenaAllocate

   478 nsFixedSizeAllocator::Alloc(unsigned int)

   479 Assertion::operator new(unsigned int, nsFixedSizeAllocator &)

   481 <InMemoryDataSource>

   482 PR_Malloc

   483 PL_ArenaAllocate

   484 nsFixedSizeAllocator::Alloc(unsigned int)

   485 InMemoryDataSource::AllocEntry(void *, void const *)

   486 PL_HashTableRawAdd

   487 PL_HashTableAdd

   488 InMemoryDataSource::SetReverseArcs(nsIRDFNode *, Assertion *)

   490 <InMemoryDataSource>

   491 PR_Malloc

   492 PL_ArenaAllocate

   493 nsFixedSizeAllocator::Alloc(unsigned int)

   494 InMemoryDataSource::AllocEntry(void *, void const *)

   495 PL_HashTableRawAdd

   496 PL_HashTableAdd

   497 InMemoryDataSource::SetForwardArcs(nsIRDFResource *, Assertion *)

   499 <InMemoryDataSource>

   500 PL_DHashAllocTable

   501 PL_DHashTableInit

   502 InMemoryDataSource::Init(void)

   504 <RDFXMLDataSource>

   505 PR_Malloc

   506 nsMemoryImpl::Alloc(unsigned int)

   507 nsMemory::Alloc(unsigned int)

   508 nsStr::Alloc(nsStr &, unsigned int)

   509 nsStr::Realloc(nsStr &, unsigned int)

   510 nsStr::EnsureCapacity(nsStr &, unsigned int)

   511 nsStr::GrowCapacity(nsStr &, unsigned int)

   512 nsString::SetCapacity(unsigned int)

   513 nsString::SetLength(unsigned int)

   514 nsAString::do_AssignFromReadable(nsAString const &)

   515 nsAString::AssignFromReadable(nsAString const &)

   516 nsString::nsString(nsAString const &)

   517 nsNameSpaceMap::Put(nsAString const &, nsIAtom *)

   518 RDFXMLDataSourceImpl::AddNameSpace(nsIAtom *, nsString const &)

   520 <xptiTypelibGuts>

   521 __builtin_new

   522 __builtin_vec_new

   523 xptiTypelibGuts::xptiTypelibGuts(XPTHeader *)

   525 # ----------------------------------------------------------------------

   526 #

   527 # nsPluginTag

   528 #

   530 <nsPluginTag>

   531 __builtin_new

   532 __builtin_vec_new

   533 nsPluginTag::nsPluginTag(nsPluginInfo *)

   535 <nsPluginTag>

   536 __builtin_new

   537 __builtin_vec_new

   538 new_str(char const *)

   539 nsPluginTag::nsPluginTag(nsPluginInfo *)

   541 <nsPluginTag>

   542 __builtin_new

   543 __builtin_vec_new

   544 nsPluginTag::nsPluginTag(char const *, char const *, char const *, char const *, char const *const *, char const *const *, char const *const *, int, long long)

   546 <nsPluginTag>

   547 __builtin_new

   548 __builtin_vec_new

   549 nsPluginTag::nsPluginTag(nsPluginTag *)

   551 #----------------------------------------------------------------------

   552 #

   553 # nsXBLInsertionPoint

   554 #

   556 <nsXBLInsertionPoint>

   557 __builtin_new

   558 __builtin_vec_new

   559 nsSupportsArray::GrowArrayBy(int)

   560 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

   561 nsSupportsArray::AppendElement(nsISupports *)

   562 nsXBLInsertionPoint::AddChild(nsIContent *)

   564 #----------------------------------------------------------------------

   565 #

   566 # nsXBLBinding

   567 #

   569 <nsXBLBinding>

   570 PR_Malloc

   571 PL_HashTableFinalize(PLHashTable *)

   572 PL_HashTableRawAdd

   573 nsHashtable::Put(nsHashKey *, void *)

   574 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

   575 nsXBLBinding::GetInsertionPointsFor(nsIContent *, nsISupportsArray **)

   577 <nsXBLBinding>

   578 PR_Malloc

   579 PL_HashTableFinalize(PLHashTable *)

   580 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

   581 nsHashtable::nsHashtable(unsigned int, int)

   582 nsXBLBinding::GetInsertionPointsFor(nsIContent *, nsISupportsArray **)

   584 <nsXBLBinding>

   585 __builtin_new

   586 nsXBLBinding::GetInsertionPointsFor(nsIContent *, nsISupportsArray **)

   588 <nsXBLBinding>

   589 PR_Malloc

   590 PL_ArenaFinish

   591 PL_HashTableRawAdd

   592 NS_NewAtom(nsAString const &)

   593 NS_NewAtom(char const *)

   594 nsXBLBinding::nsXBLBinding(nsIXBLPrototypeBinding *)

   596 # ----------------------------------------------------------------------

   597 #

   598 # nsXBLPrototypeBinding

   599 #

   601 <nsXBLPrototypeBinding>

   602 __builtin_new

   603 nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)

   605 <nsXBLPrototypeBinding>

   606 __builtin_new

   607 nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent *)

   609 <nsXBLPrototypeBinding>

   610 PR_Malloc

   611 PL_HashTableFinalize(PLHashTable *)

   612 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

   613 nsHashtable::nsHashtable(unsigned int, int)

   614 nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

   616 <nsXBLPrototypeBinding>

   617 JS_DHashAllocTable

   618 JS_DHashTableInit

   619 JS_NewDHashTable

   620 js_LookupProperty

   621 JS_DefinePropertyWithTinyId

   622 JS_LookupProperty

   623 nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)

   625 <nsXBLPrototypeBinding>

   626 PR_Malloc

   627 PL_HashTableFinalize(PLHashTable *)

   628 PL_HashTableRawAdd

   629 nsHashtable::Put(nsHashKey *, void *)

   630 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

   631 nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent *)

   633 <nsXBLPrototypeBinding>

   634 PR_Malloc

   635 PL_ArenaAllocate

   636 nsFixedSizeAllocator::AddBucket(unsigned int)

   637 nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)

   638 nsXBLPrototypeBinding::nsXBLPrototypeBinding(nsCString const &, nsIContent *, nsXBLDocumentInfo *)

   640 <nsXBLPrototypeBinding>

   641 PR_Malloc

   642 PL_ArenaAllocate

   643 nsFixedSizeAllocator::AddBucket(unsigned int)

   644 nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)

   645 nsXBLPrototypeBinding::nsXBLPrototypeBinding(basic_nsAReadableString<char> const &, nsIContent *, nsXBLDocumentInfo *)

   647 <nsXBLPrototypeBinding>

   648 PR_Malloc

   649 PL_HashTableFinalize(PLHashTable *)

   650 PL_HashTableRawAdd

   651 nsHashtable::Put(nsHashKey *, void *)

   652 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

   653 nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

   655 <nsXBLPrototypeBinding>

   656 __builtin_new

   657 nsISupportsKey::Clone(void) const

   658 nsHashtable::Put(nsHashKey *, void *)

   659 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

   660 nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

   662 <nsXBLPrototypeBinding>

   663 __builtin_new

   664 nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

   666 <nsXBLPrototypeBinding>

   667 PR_Malloc

   668 PL_HashTableFinalize(PLHashTable *)

   669 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

   670 nsHashtable::nsHashtable(unsigned int, int)

   671 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

   672 nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

   674 <nsXBLPrototypeBinding>

   675 PR_Malloc

   676 PL_ArenaAllocate

   677 nsFixedSizeAllocator::AddBucket(unsigned int)

   678 nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)

   679 nsXBLPrototypeBinding::nsXBLPrototypeBinding(nsACString const &, nsXBLDocumentInfo *)

   681 <nsXBLPrototypeBinding>

   682 PR_Malloc

   683 nsMemoryImpl::Alloc(unsigned int)

   684 nsMemory::Alloc(unsigned int)

   685 nsCStringKey::Clone(void) const

   686 nsHashtable::Put(nsHashKey *, void *)

   687 nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)

   689 <nsXBLPrototypeBinding>

   690 PR_Malloc

   691 nsMemoryImpl::Alloc(unsigned int)

   692 nsMemory::Alloc(unsigned int)

   693 nsStr::Alloc(nsStr &, unsigned int)

   694 nsStr::Realloc(nsStr &, unsigned int)

   695 nsStr::EnsureCapacity(nsStr &, unsigned int)

   696 nsStr::GrowCapacity(nsStr &, unsigned int)

   697 nsCString::SetCapacity(unsigned int)

   698 nsCString::SetLength(unsigned int)

   699 nsACString::do_AssignFromReadable(nsACString const &)

   700 nsACString::AssignFromReadable(nsACString const &)

   701 nsCString::nsCString(nsACString const &)

   702 nsXBLPrototypeBinding::nsXBLPrototypeBinding(nsACString const &, nsXBLDocumentInfo *)

   704 <nsXBLPrototypeBinding>

   705 PR_Malloc

   706 nsMemoryImpl::Alloc(unsigned int)

   707 nsMemory::Alloc(unsigned int)

   708 ToNewCString(nsACString const &)

   709 nsXBLJSClass::nsXBLJSClass(nsCString const &)

   710 nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)

   712 <nsXBLPrototypeBinding>

   713 PR_Malloc

   714 PL_HashTableFinalize(PLHashTable *)

   715 PL_HashTableRawAdd

   716 nsHashtable::Put(nsHashKey *, void *)

   717 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

   718 nsXBLPrototypeBinding::ConstructInterfaceTable(nsIContent *)

   720 <nsXBLPrototypeBinding>

   721 PR_Malloc

   722 PL_HashTableFinalize(PLHashTable *)

   723 PL_HashTableRawAdd

   724 nsHashtable::Put(nsHashKey *, void *)

   725 nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **)

   727 <nsXBLPrototypeBinding>

   728 PR_Malloc

   729 PL_HashTableFinalize(PLHashTable *)

   730 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

   731 nsHashtable::nsHashtable(unsigned int, int)

   732 nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent *)

   734 <nsXBLPrototypeBinding>

   735 PR_Malloc

   736 PL_HashTableFinalize(PLHashTable *)

   737 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

   738 nsHashtable::nsHashtable(unsigned int, int)

   739 nsXBLPrototypeBinding::ConstructInterfaceTable(nsIContent *)

   741 <nsXBLPrototypeBinding>

   742 PR_Malloc

   743 PL_ArenaAllocate

   744 nsFixedSizeAllocator::Alloc(unsigned int)

   745 nsXBLAttributeEntry::Create(nsIAtom *, nsIAtom *, nsIContent *)

   746 nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

   748 #----------------------------------------------------------------------

   749 #

   750 # <nsXBLPrototypeProperty>

   751 #

   753 <nsXBLPrototypeProperty>

   754 PR_Malloc

   755 nsMemoryImpl::Alloc(unsigned int)

   756 nsMemory::Alloc(unsigned int)

   757 nsStr::Alloc(nsStr &, unsigned int)

   758 nsStr::Realloc(nsStr &, unsigned int)

   759 nsStr::EnsureCapacity(nsStr &, unsigned int)

   760 nsStr::GrowCapacity(nsStr &, unsigned int)

   761 nsString::SetCapacity(unsigned int)

   762 nsString::SetLength(unsigned int)

   763 nsAString::do_AssignFromReadable(nsAString const &)

   764 nsAString::AssignFromReadable(nsAString const &)

   765 nsGenericContainerElement::GetAttr(int, nsIAtom *, nsIAtom *&, nsAString &) const

   766 nsGenericContainerElement::GetAttr(int, nsIAtom *, nsAString &) const

   767 nsXBLPrototypeProperty::ParseProperty(nsIScriptContext *)

   769 <nsXBLPrototypeProperty>

   770 PR_Malloc

   771 nsMemoryImpl::Alloc(unsigned int)

   772 nsMemory::Alloc(unsigned int)

   773 nsStr::Alloc(nsStr &, unsigned int)

   774 nsStr::Realloc(nsStr &, unsigned int)

   775 nsStr::EnsureCapacity(nsStr &, unsigned int)

   776 nsStr::GrowCapacity(nsStr &, unsigned int)

   777 nsString::SetCapacity(unsigned int)

   778 nsString::SetLength(unsigned int)

   779 nsAString::do_AssignFromReadable(nsAString const &)

   780 nsAString::AssignFromReadable(nsAString const &)

   781 nsGenericContainerElement::GetAttr(int, nsIAtom *, nsIAtom *&, nsAString &) const

   782 nsGenericContainerElement::GetAttr(int, nsIAtom *, nsAString &) const

   783 nsXBLPrototypeProperty::ParseMethod(nsIScriptContext *)

   785 <nsXBLPrototypeProperty>

   786 PR_Malloc

   787 nsMemoryImpl::Alloc(unsigned int)

   788 nsMemory::Alloc(unsigned int)

   789 nsStr::Alloc(nsStr &, unsigned int)

   790 nsStr::Realloc(nsStr &, unsigned int)

   791 nsStr::EnsureCapacity(nsStr &, unsigned int)

   792 nsStr::GrowCapacity(nsStr &, unsigned int)

   793 nsString::SetCapacity(unsigned int)

   794 nsString::SetLength(unsigned int)

   795 nsAString::do_AssignFromReadable(nsAString const &)

   796 nsAString::AssignFromReadable(nsAString const &)

   797 nsGenericContainerElement::GetAttr(int, nsIAtom *, nsIAtom *&, nsAString &) const

   798 nsGenericContainerElement::GetAttr(int, nsIAtom *, nsAString &) const

   799 nsXBLPrototypeProperty::ParseField(nsIScriptContext *)

   801 <nsXBLPrototypeProperty>

   802 PR_Malloc

   803 nsMemoryImpl::Alloc(unsigned int)

   804 nsMemory::Alloc(unsigned int)

   805 nsStr::Alloc(nsStr &, unsigned int)

   806 nsStr::Realloc(nsStr &, unsigned int)

   807 nsStr::EnsureCapacity(nsStr &, unsigned int)

   808 nsStr::GrowCapacity(nsStr &, unsigned int)

   809 nsString::SetCapacity(unsigned int)

   810 nsString::SetLength(unsigned int)

   811 nsAString::do_AppendFromReadable(nsAString const &)

   812 nsAString::AppendFromReadable(nsAString const &)

   813 nsXBLPrototypeProperty::ParseField(nsIScriptContext *)

   815 <nsXBLPrototypeProperty>

   816 PR_Malloc

   817 nsMemoryImpl::Alloc(unsigned int)

   818 nsMemory::Alloc(unsigned int)

   819 nsStr::Alloc(nsStr &, unsigned int)

   820 nsStr::Realloc(nsStr &, unsigned int)

   821 nsStr::EnsureCapacity(nsStr &, unsigned int)

   822 nsStr::GrowCapacity(nsStr &, unsigned int)

   823 nsCString::SetCapacity(unsigned int)

   824 nsCString::SetLength(unsigned int)

   825 nsACString::do_AppendFromReadable(nsACString const &)

   826 nsACString::do_AppendFromElementPtr(char const *)

   827 nsXBLPrototypeBinding::GetBindingURI(nsCString &)

   828 nsXBLPrototypeProperty::ConstructProperty(nsIContent *, nsIContent *)

   830 <nsXBLPrototypeProperty>

   831 JS_DHashAllocTable

   832 JS_DHashTableFinish

   833 JS_DHashTableOperate

   834 js_AddRootRT

   835 JS_AddNamedRootRT

   836 NS_NewXBLPrototypeBinding(nsACString const &, nsIContent *, nsXBLDocumentInfo *, nsIXBLPrototypeBinding **)

   837 nsXBLPrototypeProperty::ParseMethod(nsIScriptContext *)

   839 # ----------------------------------------------------------------------

   840 #

   841 # The frame arena

   842 #

   844 <FrameArena>

   845 PR_Malloc

   846 PL_ArenaAllocate

   847 FrameArena::AllocateFrame(unsigned int, void **)

   849 <PresShell>

   850 PR_Malloc

   851 PL_ArenaAllocate

   852 nsDST::NodeArena::AllocLeafNode(void)

   853 nsDST::Insert(void *, void *, void **)

   854 PresShell::SetSubShellFor(nsIContent *, nsISupports *)

   856 <PresShell>

   857 PR_Malloc

   858 nsVoidArray::SizeTo(int)

   859 nsVoidArray::GrowArrayBy(int)

   860 nsVoidArray::InsertElementAt(void *, int)

   861 PresShell::AppendReflowCommandInternal(nsIReflowCommand *, nsVoidArray &)

   863 # The anonymous content table in the PresShell

   864 <PresShell.mAnonymousContentTable>

   865 PR_Malloc

   866 PL_HashTableFinalize(PLHashTable *)

   867 PL_HashTableRawAdd

   868 nsHashtable::Put(nsHashKey *, void *)

   869 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

   870 PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)

   872 <PresShell.mAnonymousContentTable>

   873 __builtin_new

   874 nsISupportsKey::Clone(void) const

   875 nsHashtable::Put(nsHashKey *, void *)

   876 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

   877 PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)

   879 <PresShell.mAnonymousContentTable>

   880 PR_Malloc

   881 PL_HashTableFinalize(PLHashTable *)

   882 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

   883 nsHashtable::nsHashtable(unsigned int, int)

   884 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

   885 PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)

   887 <PresShell.mAnonymousContentTable>

   888 PR_Malloc

   889 PL_HashTableFinalize(PLHashTable *)

   890 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

   891 nsHashtable::nsHashtable(unsigned int, int)

   892 PresShell::SetAnonymousContentFor(nsIContent *, nsISupportsArray *)

   894 # ----------------------------------------------------------------------

   895 #

   896 # StackArena

   897 #

   899 <StackArena>

   900 PR_Malloc

   901 StackArena::StackArena(void)

   903 <StackArena>

   904 PR_Malloc

   905 StackArena::Allocate(unsigned int, void **)

   907 <StackArena>

   908 PR_Malloc

   909 StackBlock::StackBlock(void)

   910 StackArena::StackArena(void)

   912 <StackArena>

   913 __builtin_new

   914 __builtin_vec_new

   915 StackArena::StackArena(void)

   917 <StackArena>

   918 PR_Malloc

   919 StackArena::Allocate(unsigned int, void **)

   921 # The following will only show up if you turn off the FrameArena

   922 <nsBoxLayoutState>

   923 PR_Malloc

   924 FrameArena::AllocateFrame(unsigned int, void **)

   925 PresShell::AllocateFrame(unsigned int, void **)

   926 nsBoxLayoutState::Allocate(unsigned int, nsIPresShell *)

   929 # ----------------------------------------------------------------------

   930 #

   931 # nsFrameManager

   932 #

   934 <FrameManager>

   935 PR_Malloc

   936 PL_ArenaAllocate

   937 nsDST::NodeArena::AllocLeafNode(void)

   938 nsDST::LeafNode::operator new(unsigned int, nsDST::NodeArena *)

   939 nsDST::Insert(void *, void *, void **)

   941 <FrameManager>

   942 PR_Malloc

   943 PL_ArenaAllocate

   944 nsDST::NodeArena::AllocTwoNode(void)

   945 nsDST::ConvertToTwoNode(nsDST::LeafNode **)

   946 nsDST::Insert(void *, void *, void **)

   947 FrameManager::SetFrameProperty(nsIFrame *, nsIAtom *, void *, void (*)(nsIPresContext *, nsIFrame *, nsIAtom *, void *))

   949 <FrameManager>

   950 PR_Malloc

   951 PL_ArenaAllocate

   952 nsDST::NodeArena::AllocTwoNode(void)

   953 nsDST::TwoNode::operator new(unsigned int, nsDST::NodeArena *)

   954 nsDST::ConvertToTwoNode(nsDST::LeafNode **)

   955 nsDST::Insert(void *, void *, void **)

   956 FrameManager::SetPrimaryFrameFor(nsIContent *, nsIFrame *)

   958 <FrameManager>

   959 PR_Malloc

   960 PL_ArenaAllocate

   961 nsDST::NodeArena::AllocTwoNode(void)

   962 nsDST::TwoNode::operator new(unsigned int, nsDST::NodeArena *)

   963 nsDST::ConvertToTwoNode(nsDST::LeafNode **)

   964 nsDST::Insert(void *, void *, void **)

   965 FrameManager::SetFrameProperty(nsIFrame *, nsIAtom *, void *, void (*)(nsIPresContext *, nsIFrame *, nsIAtom *, void *))

   967 <FrameManager>

   968 PR_Malloc

   969 PL_ArenaFinish

   970 PL_HashTableRawAdd

   971 FrameHashTable::Put(void *, void *)

   972 FrameManager::SetPlaceholderFrameFor(nsIFrame *, nsIFrame *)

   974 <FrameManager>

   975 __builtin_new

   976 nsDST::NewMemoryArena(unsigned int)

   977 FrameManager::Init(nsIPresShell *, nsIStyleSet *)

   979 <FrameManager>

   980 PR_Malloc

   981 PL_ArenaAllocate

   982 nsDST::NodeArena::AllocTwoNode(void)

   983 nsDST::ConvertToTwoNode(nsDST::LeafNode **)

   984 nsDST::Insert(void *, void *, void **)

   985 FrameManager::SetPrimaryFrameFor(nsIContent *, nsIFrame *)

   987 <FrameManager>

   988 PR_Malloc

   989 PL_ArenaAllocate

   990 nsDST::NodeArena::AllocLeafNode(void)

   991 nsDST::Insert(void *, void *, void **)

   992 FrameManager::SetFrameProperty(nsIFrame *, nsIAtom *, void *, void (*)(nsIPresContext *, nsIFrame *, nsIAtom *, void *))

   994 <FrameManager>

   995 PR_Malloc

   996 PL_ArenaAllocate

   997 nsDST::NodeArena::AllocLeafNode(void)

   998 nsDST::Insert(void *, void *, void **)

   999 FrameManager::SetPrimaryFrameFor(nsIContent *, nsIFrame *)

  1001 <UndisplayedMap>

  1002 PR_Malloc

  1003 PL_ArenaFinish

  1004 PL_HashTableRawAdd

  1005 UndisplayedMap::AppendNodeFor(UndisplayedNode *, nsIContent *)

  1007 <UndisplayedMap>

  1008 __builtin_new

  1009 UndisplayedMap::AddNodeFor(nsIContent *, nsIContent *, nsIStyleContext *)

  1011 <UndisplayedMap>

  1012 PR_Malloc

  1013 PL_ArenaFinish

  1014 PL_NewHashTable

  1015 UndisplayedMap::UndisplayedMap(unsigned int)

  1017 <PRLock>

  1018 PR_Calloc

  1019 PR_NewLock

  1021 <PRMonitor>

  1022 PR_Calloc

  1023 PR_NewMonitor

  1025 # ----------------------------------------------------------------------

  1026 #

  1027 # RDFServiceImpl

  1028 #

  1030 <RDFServiceImpl>

  1031 PR_Malloc

  1032 PL_ArenaFinish

  1033 PL_NewHashTable

  1034 RDFServiceImpl::Init(void)

  1036 <RDFServiceImpl>

  1037 PR_Malloc

  1038 nsRDFParserUtils::GetQuotedAttributeValue(nsString const &, nsString const &, nsString &)

  1039 PL_HashTableRawAdd

  1040 PL_HashTableAdd

  1041 RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int)

  1043 <RDFServiceImpl>

  1044 PR_Malloc

  1045 PL_ArenaFinish

  1046 PL_HashTableRawAdd

  1047 RDFServiceImpl::RegisterResource(nsIRDFResource *, int)

  1049 <RDFServiceImpl>

  1050 PR_Malloc

  1051 PL_ArenaFinish

  1052 PL_HashTableRawAdd

  1053 PL_HashTableAdd

  1054 RDFServiceImpl::RegisterLiteral(nsIRDFLiteral *, int)

  1056 <RDFServiceImpl>

  1057 PR_Malloc

  1058 nsRDFParserUtils::IsJavaScriptLanguage(nsString const &, char const **)

  1059 PL_NewHashTable

  1060 RDFServiceImpl::Init(void)

  1062 <RDFServiceImpl>

  1063 PR_Malloc

  1064 nsRDFParserUtils::IsJavaScriptLanguage(nsString const &, char const **)

  1065 PL_HashTableRawAdd

  1066 PL_HashTableAdd

  1067 RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int)

  1069 <RDFServiceImpl>

  1070 PR_Malloc

  1071 PL_ArenaFinish

  1072 PL_HashTableRawRemove

  1073 RDFServiceImpl::UnregisterResource(nsIRDFResource *)

  1075 <RDFServiceImpl>

  1076 PL_strdup

  1077 RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int)

  1079 # ----------------------------------------------------------------------

  1081 <nsRDFResource>

  1082 PR_Malloc

  1083 nsMemoryImpl::Alloc(unsigned int)

  1084 nsMemory::Alloc(unsigned int)

  1085 nsRDFResource::Init(char const *)

  1087 <nsHTMLImageLoader>

  1088 PR_Malloc

  1089 nsMemoryImpl::Alloc(unsigned int)

  1090 nsMemory::Alloc(unsigned int)

  1091 nsStr::Alloc(nsStr &, unsigned int)

  1092 nsStr::Realloc(nsStr &, unsigned int)

  1093 nsStr::EnsureCapacity(nsStr &, unsigned int)

  1094 nsStr::GrowCapacity(nsStr &, unsigned int)

  1095 nsString::SetCapacity(unsigned int)

  1096 nsString::SetLength(unsigned int)

  1097 ~.*

  1098 ~.*

  1099 basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)

  1100 nsString::operator=(nsString const &)

  1101 nsHTMLImageLoader::SetURL(nsString const &)

  1103 <nsHTMLEntities>

  1104 __builtin_new

  1105 __builtin_vec_new

  1106 nsHTMLEntities::AddRefTable(void)

  1108 <nsHTMLEntities>

  1109 __builtin_new

  1110 nsAVLTree::AddItem(void *)

  1111 nsHTMLEntities::AddRefTable(void)

  1113 <nsStaticCaseInsensitiveNameTable>

  1114 __builtin_new

  1115 __builtin_vec_new

  1116 nsStaticCaseInsensitiveNameTable::Init(char const **, int)

  1118 <CNavDTD>

  1119 __builtin_new

  1120 CNavDTD::CNavDTD(void)

  1122 <CNavDTD>

  1123 __builtin_new

  1124 __builtin_vec_new

  1125 InitializeElementTable(void)

  1126 CNavDTD::CNavDTD(void)

  1128 <CNavDTD>

  1129 __builtin_new

  1130 __builtin_vec_new

  1131 nsDeque::GrowCapacity(void)

  1132 nsDeque::Push(void *)

  1133 CNodeRecycler::RecycleNode(nsCParserNode *)

  1134 CNavDTD::CloseContainersTo(int, nsHTMLTag, int)

  1136 <COtherDTD>

  1137 __builtin_new

  1138 COtherDTD::COtherDTD(void)

  1140 <nsScanner>

  1141 PR_Malloc

  1142 nsMemoryImpl::Alloc(unsigned int)

  1143 nsMemory::Alloc(unsigned int)

  1144 nsScanner::Append(char const *, unsigned int)

  1146 <nsScanner>

  1147 __builtin_new

  1148 nsSlidingString::AppendBuffer(unsigned short *, unsigned short *, unsigned short *)

  1149 nsScanner::AppendToBuffer(unsigned short *, unsigned short *, unsigned short *)

  1151 <nsScanner>

  1152 __builtin_new

  1153 nsScanner::AppendToBuffer(unsigned short *, unsigned short *, unsigned short *)

  1155 <nsScanner>

  1156 PR_Malloc

  1157 nsMemoryImpl::Alloc(unsigned int)

  1158 nsMemory::Alloc(unsigned int)

  1159 unsigned short * AllocateStringCopy<unsigned short, unsigned short>(basic_nsAReadableString<unsigned short> const &, unsigned short *)

  1160 ToNewUnicode(basic_nsAReadableString<unsigned short> const &)

  1161 nsScanner::Append(basic_nsAReadableString<unsigned short> const &)

  1163 <nsScanner>

  1164 PR_Malloc

  1165 nsMemoryImpl::Alloc(unsigned int)

  1166 nsMemory::Alloc(unsigned int)

  1167 nsStr::Alloc(nsStr &, unsigned int)

  1168 nsStr::Realloc(nsStr &, unsigned int)

  1169 nsStr::EnsureCapacity(nsStr &, unsigned int)

  1170 nsStr::GrowCapacity(nsStr &, unsigned int)

  1171 nsString::SetCapacity(unsigned int)

  1172 nsString::SetLength(unsigned int)

  1173 CopyUnicodeTo(nsReadingIterator<unsigned short> const &, nsReadingIterator<unsigned short> const &, basic_nsAWritableString<unsigned short> &)

  1174 nsScanner::CopyUnusedData(nsString &)

  1176 <nsScanner>

  1177 PR_Malloc

  1178 nsMemoryImpl::Alloc(unsigned int)

  1179 nsMemory::Alloc(unsigned int)

  1180 nsStr::Alloc(nsStr &, unsigned int)

  1181 nsStr::Realloc(nsStr &, unsigned int)

  1182 nsStr::EnsureCapacity(nsStr &, unsigned int)

  1183 nsStr::GrowCapacity(nsStr &, unsigned int)

  1184 nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)

  1185 nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)

  1186 nsString::nsString(nsString const &)

  1187 nsScanner::nsScanner(nsString &, int, nsString const &, nsCharsetSource)

  1189 <nsHTMLTokenizer>

  1190 __builtin_new

  1191 __builtin_vec_new

  1192 nsDeque::GrowCapacity(void)

  1193 nsDeque::Push(void *)

  1194 nsHTMLTokenizer::ScanDocStructure(int)

  1196 <nsHTMLTokenizer>

  1197 __builtin_new

  1198 __builtin_vec_new

  1199 nsDeque::GrowCapacity(void)

  1200 nsDeque::Push(void *)

  1201 nsHTMLTokenizer::AddToken(CToken *&, unsigned int, nsDeque *, nsTokenAllocator *)

  1203 <nsTokenAllocator>

  1204 PR_Malloc

  1205 PL_ArenaAllocate

  1206 nsFixedSizeAllocator::Alloc(unsigned int)

  1207 CToken::operator new(unsigned int, nsFixedSizeAllocator &)

  1208 nsTokenAllocator::CreateTokenOfType(eHTMLTokenTypes, nsHTMLTag)

  1210 <nsNodeAllocator>

  1211 PR_Malloc

  1212 PL_ArenaAllocate

  1213 nsFixedSizeAllocator::AddBucket(unsigned int)

  1214 nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)

  1215 nsNodeAllocator::nsNodeAllocator(void)

  1217 # ----------------------------------------------------------------------

  1218 #

  1219 # xptiWorkingSet

  1220 #

  1222 <xptiWorkingSet>

  1223 __builtin_new

  1224 __builtin_vec_new

  1225 xptiWorkingSet::NewFileArray(unsigned int)

  1227 <xptiWorkingSet>

  1228 __builtin_new

  1229 __builtin_vec_new

  1230 xptiWorkingSet::ExtendFileArray(unsigned int)

  1232 # ----------------------------------------------------------------------

  1234 <HTMLContentSink>

  1235 PR_Malloc

  1236 nsMemoryImpl::Alloc(unsigned int)

  1237 nsMemory::Alloc(unsigned int)

  1238 nsStr::Alloc(nsStr &, unsigned int)

  1239 nsStr::Realloc(nsStr &, unsigned int)

  1240 nsStr::EnsureCapacity(nsStr &, unsigned int)

  1241 nsStr::GrowCapacity(nsStr &, unsigned int)

  1242 nsString::SetCapacity(unsigned int)

  1243 HTMLContentSink::OnStreamComplete(nsIStreamLoader *, nsISupports *, unsigned int, unsigned int, char const *)

  1245 <HTMLContentSink>

  1246 PR_Malloc

  1247 nsMemoryImpl::Alloc(unsigned int)

  1248 nsMemory::Alloc(unsigned int)

  1249 nsStr::Alloc(nsStr &, unsigned int)

  1250 nsStr::Realloc(nsStr &, unsigned int)

  1251 nsStr::EnsureCapacity(nsStr &, unsigned int)

  1252 nsStr::GrowCapacity(nsStr &, unsigned int)

  1253 nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)

  1254 nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)

  1255 nsString::nsString(nsString const &)

  1256 HTMLContentSink::SetTitle(nsString const &)

  1258 <DeviceContextImpl>

  1259 __builtin_new

  1260 __builtin_vec_new

  1261 DeviceContextImpl::DeviceContextImpl(void)

  1263 <DeviceContextImpl>

  1264 PR_Malloc

  1265 PL_HashTableFinalize(PLHashTable *)

  1266 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1267 nsHashtable::nsHashtable(unsigned int, int)

  1268 DeviceContextImpl::CreateFontAliasTable(void)

  1270 <DeviceContextImpl>

  1271 __builtin_new

  1272 FontAliasKey::Clone(void) const

  1273 nsHashtable::Put(nsHashKey *, void *)

  1274 DeviceContextImpl::AliasFont(nsString const &, nsString const &, nsString const &, int)

  1276 <nsCompressedMap>

  1277 __builtin_new

  1278 __builtin_vec_new

  1279 nsCompressedMap::nsCompressedMap(unsigned short *, unsigned int)

  1281 <nsHTMLDocument>

  1282 __builtin_new

  1283 __builtin_vec_new

  1284 nsHTMLDocument::nsHTMLDocument(void)

  1286 <nsHTMLDocument>

  1287 PR_Malloc

  1288 PL_HashTableFinalize(PLHashTable *)

  1289 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1290 nsHashtable::nsHashtable(unsigned int, int)

  1291 nsHTMLDocument::nsHTMLDocument(void)

  1293 <nsHTMLDocument>

  1294 PR_Malloc

  1295 PL_HashTableFinalize(PLHashTable *)

  1296 PL_HashTableRawAdd

  1297 nsHashtable::Put(nsHashKey *, void *)

  1298 nsHTMLDocument::InvalidateHashTables(void)

  1300 <nsHTMLDocument.mReferrer>

  1301 PR_Malloc

  1302 nsMemoryImpl::Alloc(unsigned int)

  1303 nsMemory::Alloc(unsigned int)

  1304 nsStr::Alloc(nsStr &, unsigned int)

  1305 nsStr::Realloc(nsStr &, unsigned int)

  1306 nsStr::EnsureCapacity(nsStr &, unsigned int)

  1307 nsStr::GrowCapacity(nsStr &, unsigned int)

  1308 nsString::SetCapacity(unsigned int)

  1309 nsString::SetLength(unsigned int)

  1310 ~.*

  1311 ~.*

  1312 basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)

  1313 nsString::nsString(basic_nsAReadableString<unsigned short> const &)

  1314 nsHTMLDocument::SetReferrer(basic_nsAReadableString<unsigned short> const &)

  1316 <nsHTMLDocument.mLastModified>

  1317 PR_Malloc

  1318 nsMemoryImpl::Alloc(unsigned int)

  1319 nsMemory::Alloc(unsigned int)

  1320 nsStr::Alloc(nsStr &, unsigned int)

  1321 nsStr::Realloc(nsStr &, unsigned int)

  1322 nsStr::EnsureCapacity(nsStr &, unsigned int)

  1323 nsStr::GrowCapacity(nsStr &, unsigned int)

  1324 nsString::SetCapacity(unsigned int)

  1325 nsString::SetLength(unsigned int)

  1326 ~.*

  1327 ~.*

  1328 basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)

  1329 nsString::nsString(basic_nsAReadableString<unsigned short> const &)

  1330 nsHTMLDocument::SetLastModified(basic_nsAReadableString<unsigned short> const &)

  1332 <nsHTMLDocument.mTitle>

  1333 PR_Malloc

  1334 nsMemoryImpl::Alloc(unsigned int)

  1335 nsMemory::Alloc(unsigned int)

  1336 nsStr::Alloc(nsStr &, unsigned int)

  1337 nsStr::Realloc(nsStr &, unsigned int)

  1338 nsStr::EnsureCapacity(nsStr &, unsigned int)

  1339 nsStr::GrowCapacity(nsStr &, unsigned int)

  1340 nsString::SetCapacity(unsigned int)

  1341 nsString::SetLength(unsigned int)

  1342 ~.*

  1343 ~.*

  1344 basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)

  1345 nsString::nsString(basic_nsAReadableString<unsigned short> const &)

  1346 nsHTMLDocument::SetTitle(basic_nsAReadableString<unsigned short> const &)

  1348 <mozilla::dom::DocumentType>

  1349 PR_Malloc

  1350 nsMemoryImpl::Alloc(unsigned int)

  1351 nsMemory::Alloc(unsigned int)

  1352 nsStr::Alloc(nsStr &, unsigned int)

  1353 nsStr::Realloc(nsStr &, unsigned int)

  1354 nsStr::EnsureCapacity(nsStr &, unsigned int)

  1355 nsStr::GrowCapacity(nsStr &, unsigned int)

  1356 nsString::SetCapacity(unsigned int)

  1357 nsString::SetLength(unsigned int)

  1358 nsAString::do_AssignFromReadable(nsAString const &)

  1359 nsAString::AssignFromReadable(nsAString const &)

  1360 nsString::nsString(nsAString const &)

  1361 mozilla::dom::DocumentType::DocumentType(nsAString const &, nsIDOMNamedNodeMap *, nsIDOMNamedNodeMap *, nsAString const &, nsAString const &, nsAString const &)

  1363 #----------------------------------------------------------------------

  1364 #

  1365 # XPC stuff

  1366 #

  1368 <Native2WrappedNativeMap>

  1369 JS_DHashAllocTable

  1370 JS_DHashTableInit

  1371 JS_NewDHashTable

  1372 Native2WrappedNativeMap::Native2WrappedNativeMap(int)

  1374 <ClassInfo2WrappedNativeProtoMap>

  1375 JS_DHashAllocTable

  1376 JS_DHashTableInit

  1377 JS_NewDHashTable

  1378 ClassInfo2WrappedNativeProtoMap::ClassInfo2WrappedNativeProtoMap(int)

  1380 <IID2NativeInterfaceMap>

  1381 JS_DHashAllocTable

  1382 JS_DHashTableInit

  1383 JS_NewDHashTable

  1384 IID2NativeInterfaceMap::IID2NativeInterfaceMap(int)

  1386 <IID2WrappedJSClassMap>

  1387 JS_DHashAllocTable

  1388 JS_DHashTableInit

  1389 JS_NewDHashTable

  1390 IID2WrappedJSClassMap::IID2WrappedJSClassMap(int)

  1392 <IID2ThisTranslatorMap>

  1393 JS_DHashAllocTable

  1394 JS_DHashTableInit

  1395 JS_NewDHashTable

  1396 IID2ThisTranslatorMap::IID2ThisTranslatorMap(int)

  1398 <XPCNativeScriptableSharedMap>

  1399 JS_DHashAllocTable

  1400 JS_DHashTableInit

  1401 JS_NewDHashTable

  1402 XPCNativeScriptableSharedMap::XPCNativeScriptableSharedMap(int)

  1404 <XPCNativeScriptableSharedMap>

  1405 __builtin_new

  1406 XPCNativeScriptableSharedMap::GetNewOrUsed(unsigned int, char *, XPCNativeScriptableInfo *)

  1408 <JSContext2XPCContextMap>

  1409 JS_DHashAllocTable

  1410 JS_DHashTableInit

  1411 JS_NewDHashTable

  1412 JSContext2XPCContextMap::JSContext2XPCContextMap(int)

  1414 <NativeSetMap>

  1415 JS_DHashAllocTable

  1416 JS_DHashTableInit

  1417 JS_NewDHashTable

  1418 NativeSetMap::NativeSetMap(int)

  1420 <JSObject2WrappedJSMap>

  1421 JS_DHashAllocTable

  1422 JS_DHashTableInit

  1423 JS_NewDHashTable

  1424 JSObject2WrappedJSMap::JSObject2WrappedJSMap(int)

  1426 <nsXPCWrappedJS>

  1427 JS_DHashAllocTable

  1428 JS_DHashTableFinish

  1429 JS_DHashTableOperate

  1430 nsXPCWrappedJS::GetNewOrUsed(XPCCallContext &, JSObject *, nsID const &, nsISupports *, nsXPCWrappedJS **)

  1432 <XPCWrappedNativeProtoMap>

  1433 JS_DHashAllocTable

  1434 JS_DHashTableInit

  1435 JS_NewDHashTable

  1436 XPCWrappedNativeProtoMap::XPCWrappedNativeProtoMap(int)

  1438 <XPCWrappedNativeProto>

  1439 JS_DHashAllocTable

  1440 JS_DHashTableFinish

  1441 JS_DHashTableOperate

  1442 XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)

  1444 <XPCWrappedNativeProto>

  1445 __builtin_new

  1446 XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)

  1448 <XPCWrappedNativeProto>

  1449 __builtin_new

  1450 __builtin_vec_new

  1451 XPCNativeSet::NewInstance(XPCCallContext &, XPCNativeInterface **, unsigned short)

  1452 XPCNativeSet::GetNewOrUsed(XPCCallContext &, nsIClassInfo *)

  1453 XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)

  1455 <XPCWrappedNativeProto>

  1456 __builtin_new

  1457 XPCNativeScriptableInfo::Construct(XPCCallContext &, XPCNativeScriptableCreateInfo const *)

  1458 XPCWrappedNativeProto::Init(XPCCallContext &, XPCNativeScriptableCreateInfo const *)

  1460 <XPCWrappedNativeProto>

  1461 JS_DHashAllocTable

  1462 JS_DHashTableFinish

  1463 JS_DHashTableOperate

  1464 XPCNativeSet::GetNewOrUsed(XPCCallContext &, nsIClassInfo *)

  1465 XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int)

  1467 <XPCWrappedNative>

  1468 JS_DHashAllocTable

  1469 JS_DHashTableFinish

  1470 JS_DHashTableOperate

  1471 XPCWrappedNative::~XPCWrappedNative(void)

  1473 <XPCWrappedNative>

  1474 __builtin_new

  1475 XPCWrappedNative::FindTearOff(XPCCallContext &, XPCNativeInterface *, int, unsigned int *)

  1477 <XPCWrappedNative>

  1478 JS_DHashAllocTable

  1479 JS_DHashTableFinish

  1480 JS_DHashTableOperate

  1481 XPCWrappedNative::GetNewOrUsed(XPCCallContext &, nsISupports *, XPCWrappedNativeScope *, XPCNativeInterface *, XPCWrappedNative **)

  1483 <XPCWrappedNativeScope>

  1484 JS_DHashAllocTable

  1485 JS_DHashTableInit

  1486 JS_NewDHashTable

  1487 js_LookupProperty

  1488 js_GetProperty

  1489 XPCWrappedNativeScope::SetGlobal(XPCCallContext &, JSObject *)

  1491 <nsXPCWrappedNativeClass>

  1492 __builtin_new

  1493 __builtin_vec_new

  1494 nsXPCWrappedNativeClass::BuildMemberDescriptors(XPCContext *)

  1496 #----------------------------------------------------------------------

  1498 <nsNetModuleMgr>

  1499 __builtin_new

  1500 __builtin_vec_new

  1501 nsNetModRegEntry::nsNetModRegEntry(char const *, nsINetNotify *, unsigned int *)

  1502 nsNetModuleMgr::RegisterModule(char const *, nsINetNotify *)

  1504 <nsProxyObjectManager>

  1505 __builtin_new

  1506 nsProxyObjectManager::nsProxyObjectManager(void)

  1508 <nsProxyObjectManager>

  1509 PR_Malloc

  1510 PL_HashTableFinalize(PLHashTable *)

  1511 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1512 nsHashtable::nsHashtable(unsigned int, int)

  1513 nsProxyObjectManager::nsProxyObjectManager(void)

  1515 <nsProxyEventClass>

  1516 __builtin_new

  1517 __builtin_vec_new

  1518 nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *)

  1520 <nsProxyEventClass>

  1521 __builtin_new

  1522 nsHashtable::Put(nsHashKey *, void *)

  1523 nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *)

  1525 <nsProxyEventClass>

  1526 PR_Malloc

  1527 PL_HashTableFinalize(PLHashTable *)

  1528 PL_HashTableRawAdd

  1529 nsHashtable::Put(nsHashKey *, void *)

  1530 nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *)

  1532 <nsProxyEventObject>

  1533 __builtin_new

  1534 nsProxyEventKey::Clone(void) const

  1535 nsHashtable::Put(nsHashKey *, void *)

  1536 nsProxyEventObject::GetNewOrUsedProxy(nsIEventQueue *, int, nsISupports *, nsID const &)

  1538 <nsProxyEventObject>

  1539 PR_Malloc

  1540 PL_HashTableFinalize(PLHashTable *)

  1541 PL_HashTableRawAdd

  1542 nsHashtable::Put(nsHashKey *, void *)

  1543 nsProxyEventObject::GetNewOrUsedProxy(nsIEventQueue *, int, nsISupports *, nsID const &)

  1545 # ----------------------------------------------------------------------

  1546 #

  1547 # nsComponentManagerImpl

  1548 #

  1550 <nsComponentManagerImpl>

  1551 __builtin_new

  1552 nsComponentManagerImpl::Init(void)

  1554 <nsComponentManagerImpl>

  1555 __builtin_new

  1556 nsComponentManagerImpl::GetServiceByContractID(char const *, nsID const &, void **)

  1558 <nsComponentManagerImpl>

  1559 __builtin_new

  1560 nsComponentManagerImpl::GetService(nsID const &, nsID const &, void **)

  1562 <nsComponentManagerImpl>

  1563 PR_Malloc

  1564 PL_HashTableFinalize(PLHashTable *)

  1565 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1566 nsHashtable::nsHashtable(unsigned int, int)

  1567 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  1568 nsComponentManagerImpl::Init(void)

  1570 <nsComponentManagerImpl>

  1571 __builtin_vec_new

  1572 nsComponentManagerImpl::Init(void)

  1574 <nsComponentManagerImpl>

  1575 __builtin_new

  1576 nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

  1578 <nsComponentManagerImpl>

  1579 __builtin_new

  1580 nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)

  1582 <nsComponentManagerImpl>

  1583 __builtin_new

  1584 nsCStringKey::Clone(void) const

  1585 nsHashtable::Put(nsHashKey *, void *)

  1586 nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

  1588 <nsComponentManagerImpl>

  1589 __builtin_new

  1590 nsCStringKey::Clone(void) const

  1591 nsHashtable::Put(nsHashKey *, void *)

  1592 nsComponentManagerImpl::HashContractID(char const *, nsID const &)

  1594 <nsComponentManagerImpl>

  1595 __builtin_new

  1596 nsCStringKey::Clone(void) const

  1597 nsHashtable::Put(nsHashKey *, void *)

  1598 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1599 nsComponentManagerImpl::Init(void)

  1601 <nsComponentManagerImpl>

  1602 __builtin_new

  1603 nsCStringKey::Clone(void) const

  1604 nsHashtable::Put(nsHashKey *, void *)

  1605 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1606 nsComponentManagerImpl::GetLoaderForType(char const *, nsIComponentLoader **)

  1608 <nsComponentManagerImpl>

  1609 __builtin_new

  1610 nsCStringKey::Clone(void) const

  1611 nsHashtable::Put(nsHashKey *, void *)

  1612 nsComponentManagerImpl::ContractIDToClassID(char const *, nsID *)

  1614 <nsComponentManagerImpl>

  1615 PR_Malloc

  1616 PL_HashTableFinalize(PLHashTable *)

  1617 PL_HashTableRawAdd

  1618 nsHashtable::Put(nsHashKey *, void *)

  1619 nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

  1621 <nsComponentManagerImpl>

  1622 PR_Malloc

  1623 PL_HashTableFinalize(PLHashTable *)

  1624 PL_HashTableRawAdd

  1625 nsHashtable::Put(nsHashKey *, void *)

  1626 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1627 nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)

  1629 <nsComponentManagerImpl>

  1630 __builtin_new

  1631 nsHashtable::Put(nsHashKey *, void *)

  1632 nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

  1634 <nsComponentManagerImpl>

  1635 __builtin_new

  1636 nsHashtable::Put(nsHashKey *, void *)

  1637 nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)

  1639 <nsComponentManagerImpl>

  1640 nsMemoryImpl::Alloc(unsigned int)

  1641 nsMemory::Alloc(unsigned int)

  1642 nsCStringKey::Clone(void) const

  1643 nsHashtable::Put(nsHashKey *, void *)

  1644 nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

  1646 <nsComponentManagerImpl>

  1647 PR_Malloc

  1648 bufio_SetBufferSize

  1649 nsXPTCStubBase::Sentinel9(void)

  1650 NR_RegSetBufferSize

  1651 nsRegistry::SetBufferSize(int)

  1652 nsComponentManagerImpl::AutoRegister(int, nsIFile *)

  1654 <nsComponentManagerImpl>

  1655 __builtin_new

  1656 nsComponentManagerImpl::HashContractID(char const *, nsID const &)

  1658 <nsComponentManagerImpl>

  1659 __builtin_new

  1660 nsComponentManagerImpl::RegisterComponentCommon(nsID const &, char const *, char const *, char const *, int, int, char const *)

  1662 <nsComponentManagerImpl>

  1663 __builtin_new

  1664 nsHashtable::Put(nsHashKey *, void *)

  1665 nsComponentManagerImpl::RegisterComponentCommon(nsID const &, char const *, char const *, char const *, int, int, char const *)

  1667 <nsComponentManagerImpl>

  1668 PR_Malloc

  1669 PL_HashTableFinalize(PLHashTable *)

  1670 PL_HashTableRawAdd

  1671 nsHashtable::Put(nsHashKey *, void *)

  1672 nsComponentManagerImpl::HashContractID(char const *, nsID const &)

  1674 <nsComponentManagerImpl>

  1675 PR_Malloc

  1676 PL_HashTableFinalize(PLHashTable *)

  1677 PL_HashTableRawAdd

  1678 nsHashtable::Put(nsHashKey *, void *)

  1679 nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int)

  1681 <nsComponentManagerImpl>

  1682 PR_Malloc

  1683 PL_HashTableFinalize(PLHashTable *)

  1684 PL_HashTableRawAdd

  1685 nsHashtable::Put(nsHashKey *, void *)

  1686 nsComponentManagerImpl::ContractIDToClassID(char const *, nsID *)

  1688 <nsComponentManagerImpl>

  1689 PR_Malloc

  1690 PL_HashTableFinalize(PLHashTable *)

  1691 PL_HashTableRawAdd

  1692 nsHashtable::Put(nsHashKey *, void *)

  1693 nsComponentManagerImpl::HashContractID(char const *, nsFactoryEntry *)

  1695 <nsComponentManagerImpl>

  1696 PR_Malloc

  1697 nsMemoryImpl::Alloc(unsigned int)

  1698 nsMemory::Alloc(unsigned int)

  1699 nsCStringKey::Clone(void) const

  1700 nsHashtable::Put(nsHashKey *, void *)

  1701 nsComponentManagerImpl::HashContractID(char const *, nsFactoryEntry *)

  1703 <nsComponentManagerImpl>

  1704 __builtin_new

  1705 nsComponentManagerImpl::GetService(char const *, nsID const &, nsISupports **, nsIShutdownListener *)

  1707 <nsComponentManagerImpl>

  1708 __builtin_new

  1709 nsComponentManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)

  1711 <nsComponentManagerImpl>

  1712 PR_Malloc

  1713 nsMemoryImpl::Alloc(unsigned int)

  1714 nsMemory::Alloc(unsigned int)

  1715 nsStr::Alloc(nsStr &, unsigned int)

  1716 nsStr::Realloc(nsStr &, unsigned int)

  1717 nsStr::EnsureCapacity(nsStr &, unsigned int)

  1718 nsStr::GrowCapacity(nsStr &, unsigned int)

  1719 nsCString::SetCapacity(unsigned int)

  1720 nsCString::SetLength(unsigned int)

  1721 nsACString::do_AssignFromReadable(nsACString const &)

  1722 nsACString::do_AssignFromElementPtr(char const *)

  1723 nsCString::nsCString(char const *)

  1724 nsFactoryEntry::nsFactoryEntry(nsID const &, char const *, int)

  1725 nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

  1727 <nsComponentManagerImpl>

  1728 PL_strdup

  1729 nsComponentManagerImpl::HashContractID(char const *, nsFactoryEntry *)

  1731 <nsComponentManagerImpl>

  1732 PL_strdup

  1733 nsFactoryEntry::nsFactoryEntry(nsID const &, char const *, int)

  1734 nsComponentManagerImpl::PlatformPrePopulateRegistry(void)

  1736 <nsComponentManagerImpl>

  1737 PL_DHashAllocTable

  1738 PL_DHashTableInit

  1739 nsComponentManagerImpl::Init(void)

  1741 # ----------------------------------------------------------------------

  1743 <nsZipArchive>

  1744 __builtin_new

  1745 nsZipArchive::BuildFileList(void)

  1747 <nsStaticCaseInsensitiveNameTable>

  1748 __builtin_new

  1749 nsStaticCaseInsensitiveNameTable::Init(char const **, int)

  1751 <nsStaticCaseInsensitiveNameTable>

  1752 __builtin_new

  1753 nsCStringKey::Clone(void) const

  1754 nsHashtable::Put(nsHashKey *, void *)

  1755 nsStaticCaseInsensitiveNameTable::Init(char const **, int)

  1757 <nsStaticCaseInsensitiveNameTable>

  1758 PR_Malloc

  1759 PL_HashTableFinalize(PLHashTable *)

  1760 PL_HashTableRawAdd

  1761 nsHashtable::Put(nsHashKey *, void *)

  1762 nsStaticCaseInsensitiveNameTable::Init(char const **, int)

  1764 # ----------------------------------------------------------------------

  1765 #

  1766 # nsDrawingSurfaceGTK

  1767 #

  1769 <nsDrawingSurfaceGTK>

  1770 PR_Malloc

  1771 PL_HashTableFinalize(PLHashTable *)

  1772 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1773 nsHashtable::nsHashtable(unsigned int, int)

  1774 nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int)

  1776 <nsDrawingSurfaceGTK>

  1777 PR_Malloc

  1778 PL_HashTableFinalize(PLHashTable *)

  1779 PL_HashTableRawAdd

  1780 nsHashtable::Put(nsHashKey *, void *)

  1781 nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int)

  1783 <nsDrawingSurfaceGTK>

  1784 __builtin_new

  1785 nsCStringKey::Clone(void) const

  1786 nsHashtable::Put(nsHashKey *, void *)

  1787 nsDrawingSurfaceGTK type_info function

  1789 <nsDrawingSurfaceGTK>

  1790 PR_Malloc

  1791 nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int)

  1793 # ----------------------------------------------------------------------

  1794 #

  1795 # nsNativeComponentLoader

  1796 #

  1798 <nsNativeComponentLoader>

  1799 __builtin_new

  1800 nsNativeComponentLoader::Init(nsIComponentManager *, nsISupports *)

  1802 <nsNativeComponentLoader>

  1803 PR_Malloc

  1804 PL_HashTableFinalize(PLHashTable *)

  1805 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1806 nsHashtable::nsHashtable(unsigned int, int)

  1807 nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)

  1808 nsNativeComponentLoader::Init(nsIComponentManager *, nsISupports *)

  1810 <nsNativeComponentLoader>

  1811 __builtin_new

  1812 nsCStringKey::Clone(void) const

  1813 nsHashtable::Put(nsHashKey *, void *)

  1814 nsNativeComponentLoader::CreateDll

  1816 <nsNativeComponentLoader>

  1817 __builtin_new

  1818 nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)

  1820 <nsNativeComponentLoader>

  1821 __builtin_new

  1822 nsCStringKey::Clone(void) const

  1823 nsHashtable::Put(nsHashKey *, void *)

  1824 nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)

  1826 <nsNativeComponentLoader>

  1827 PR_Malloc

  1828 PL_HashTableFinalize(PLHashTable *)

  1829 PL_HashTableRawAdd

  1830 nsHashtable::Put(nsHashKey *, void *)

  1831 nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)

  1833 <nsNativeComponentLoader>

  1834 PR_Malloc

  1835 nsMemoryImpl::Alloc(unsigned int)

  1836 nsMemory::Alloc(unsigned int)

  1837 nsCStringKey::Clone(void) const

  1838 nsHashtable::Put(nsHashKey *, void *)

  1839 nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)

  1841 <nsNativeComponentLoader>

  1842 PL_strdup

  1843 nsDll::nsDll(nsIFile *, char const *, long long *, long long *)

  1844 nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **)

  1846 # ----------------------------------------------------------------------

  1848 <nsDirectoryService>

  1849 __builtin_new

  1850 nsCStringKey::Clone(void) const

  1851 nsHashtable::Put(nsHashKey *, void *)

  1852 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1853 nsDirectoryService::Set(char const *, nsISupports *)

  1855 <nsDirectoryService>

  1856 PR_Malloc

  1857 PL_HashTableFinalize(PLHashTable *)

  1858 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1859 nsHashtable::nsHashtable(unsigned int, int)

  1860 nsDirectoryService::Init(void)

  1862 <nsDirectoryService>

  1863 PR_Malloc

  1864 PL_HashTableFinalize(PLHashTable *)

  1865 PL_HashTableRawAdd

  1866 nsHashtable::Put(nsHashKey *, void *)

  1867 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1868 nsDirectoryService::Set(char const *, nsISupports *)

  1870 <nsDirectoryService>

  1871 PR_Malloc

  1872 PL_HashTableFinalize(PLHashTable *)

  1873 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1874 nsHashtable::nsHashtable(unsigned int, int)

  1875 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  1876 nsDirectoryService::Init(char const *)

  1878 <nsDirectoryService>

  1879 PR_Malloc

  1880 PL_HashTableFinalize(PLHashTable *)

  1881 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1882 nsHashtable::nsHashtable(unsigned int, int)

  1883 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  1884 nsDirectoryService::Init(void)

  1886 #----------------------------------------------------------------------

  1887 #

  1888 # nsResProtocolHandler

  1889 #

  1891 <nsResProtocolHandler>

  1892 __builtin_new

  1893 nsCStringKey::Clone(void) const

  1894 nsHashtable::Put(nsHashKey *, void *)

  1895 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1896 nsResProtocolHandler::AppendSubstitution(char const *, char const *)

  1898 <nsResProtocolHandler>

  1899 PR_Malloc

  1900 PL_HashTableFinalize(PLHashTable *)

  1901 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1902 nsHashtable::nsHashtable(unsigned int, int)

  1903 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  1904 nsResProtocolHandler::nsResProtocolHandler(void)

  1906 <nsResProtocolHandler>

  1907 PR_Malloc

  1908 PL_HashTableFinalize(PLHashTable *)

  1909 PL_HashTableRawAdd

  1910 nsHashtable::Put(nsHashKey *, void *)

  1911 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1912 nsResProtocolHandler::AppendSubstitution(char const *, char const *)

  1914 <nsResProtocolHandler>

  1915 PR_Malloc

  1916 PL_HashTableFinalize(PLHashTable *)

  1917 PL_HashTableRawAdd

  1918 nsHashtable::Put(nsHashKey *, void *)

  1919 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1920 nsResProtocolHandler::SetSubstitution(char const *, nsIURI *)

  1922 # ----------------------------------------------------------------------

  1923 #

  1924 # nsChromeRegistry

  1925 #

  1927 <nsChromeRegistry>

  1928 __builtin_new

  1929 nsCStringKey::Clone(void) const

  1930 nsHashtable::Put(nsHashKey *, void *)

  1931 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1932 nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)

  1934 <nsChromeRegistry>

  1935 PR_Malloc

  1936 PL_HashTableFinalize(PLHashTable *)

  1937 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1938 nsHashtable::nsHashtable(unsigned int, int)

  1939 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  1940 nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)

  1942 <nsChromeRegistry>

  1943 PR_Malloc

  1944 PL_HashTableFinalize(PLHashTable *)

  1945 PL_HashTableRawAdd

  1946 nsHashtable::Put(nsHashKey *, void *)

  1947 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1948 nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)

  1950 <nsChromeRegistry>

  1951 PR_Malloc

  1952 nsMemoryImpl::Alloc(unsigned int)

  1953 nsMemory::Alloc(unsigned int)

  1954 ToNewCString(nsACString const &)

  1955 nsStdURL::GetSpec(char **)

  1956 RDFXMLDataSourceImpl::Init(char const *)

  1957 nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)

  1959 <nsChromeRegistry>

  1960 PR_Malloc

  1961 nsMemoryImpl::Alloc(unsigned int)

  1962 nsMemory::Alloc(unsigned int)

  1963 nsCStringKey::Clone(void) const

  1964 nsHashtable::Put(nsHashKey *, void *)

  1965 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1966 nsChromeRegistry::LoadDataSource(nsCString const &, nsIRDFDataSource **, int, char const *)

  1968 # ----------------------------------------------------------------------

  1970 <nsZipReaderCache>

  1971 __builtin_new

  1972 nsCStringKey::Clone(void) const

  1973 nsHashtable::Put(nsHashKey *, void *)

  1974 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1975 nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)

  1977 <nsZipReaderCache>

  1978 PR_Malloc

  1979 PL_HashTableFinalize(PLHashTable *)

  1980 PL_HashTableRawAdd

  1981 nsHashtable::Put(nsHashKey *, void *)

  1982 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  1983 nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)

  1985 <nsZipReaderCache>

  1986 PR_Malloc

  1987 PL_HashTableFinalize(PLHashTable *)

  1988 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  1989 nsHashtable::nsHashtable(unsigned int, int)

  1990 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  1991 nsZipReaderCache::nsZipReaderCache(void)

  1993 <nsZipReaderCache>

  1994 __builtin_new

  1995 nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **)

  1997 # ----------------------------------------------------------------------

  1998 #

  1999 # nsXBLDocumentInfo

  2000 #

  2002 <nsXBLDocumentInfo>

  2003 PR_Malloc

  2004 PL_HashTableFinalize(PLHashTable *)

  2005 PL_HashTableRawAdd

  2006 nsHashtable::Put(nsHashKey *, void *)

  2007 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2008 nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)

  2010 <nsXBLDocumentInfo>

  2011 PR_Malloc

  2012 PL_HashTableFinalize(PLHashTable *)

  2013 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2014 nsHashtable::nsHashtable(unsigned int, int)

  2015 nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)

  2017 <nsXBLDocumentInfo>

  2018 __builtin_new

  2019 nsCStringKey::Clone(void) const

  2020 nsHashtable::Put(nsHashKey *, void *)

  2021 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2022 nsXBLDocumentInfo::SetPrototypeBinding(nsCString const &, nsIXBLPrototypeBinding *)

  2024 <nsXBLDocumentInfo>

  2025 PR_Malloc

  2026 PL_HashTableFinalize(PLHashTable *)

  2027 PL_HashTableRawAdd

  2028 nsHashtable::Put(nsHashKey *, void *)

  2029 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

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

  2032 <nsXBLDocumentInfo>

  2033 __builtin_new

  2034 nsXBLDocumentInfo::SetPrototypeBinding(nsCString const &, nsIXBLPrototypeBinding *)

  2036 <nsXBLDocumentInfo>

  2037 PR_Malloc

  2038 PL_HashTableFinalize(PLHashTable *)

  2039 PL_HashTableRawAdd

  2040 nsHashtable::Put(nsHashKey *, void *)

  2041 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2042 nsXBLDocumentInfo::SetPrototypeBinding(nsCString const &, nsIXBLPrototypeBinding *)

  2044 <nsXBLDocumentInfo>

  2045 PR_Malloc

  2046 PL_HashTableFinalize(PLHashTable *)

  2047 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2048 nsHashtable::nsHashtable(unsigned int, int)

  2049 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

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

  2052 <nsXBLDocumentInfo>

  2053 __builtin_new

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

  2056 <nsXBLDocumentInfo>

  2057 PR_Malloc

  2058 nsMemoryImpl::Alloc(unsigned int)

  2059 nsMemory::Alloc(unsigned int)

  2060 nsStr::Alloc(nsStr &, unsigned int)

  2061 nsStr::Realloc(nsStr &, unsigned int)

  2062 nsStr::EnsureCapacity(nsStr &, unsigned int)

  2063 nsStr::GrowCapacity(nsStr &, unsigned int)

  2064 nsCString::SetCapacity(unsigned int)

  2065 nsCString::SetLength(unsigned int)

  2066 ~.*

  2067 ~.*

  2068 basic_nsAWritableString<char>::Assign(char const *)

  2069 nsCString::operator=(char const *)

  2070 nsXBLDocumentInfo::nsXBLDocumentInfo(char const *, nsIDocument *)

  2072 <nsXBLDocumentInfo>

  2073 PR_Malloc

  2074 nsMemoryImpl::Alloc(unsigned int)

  2075 nsMemory::Alloc(unsigned int)

  2076 nsCStringKey::Clone(void) const

  2077 nsHashtable::Put(nsHashKey *, void *)

  2078 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2079 nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)

  2081 <nsXBLDocumentInfo>

  2082 PR_Malloc

  2083 nsMemoryImpl::Alloc(unsigned int)

  2084 nsMemory::Alloc(unsigned int)

  2085 nsStr::Alloc(nsStr &, unsigned int)

  2086 nsStr::Realloc(nsStr &, unsigned int)

  2087 nsStr::EnsureCapacity(nsStr &, unsigned int)

  2088 nsStr::GrowCapacity(nsStr &, unsigned int)

  2089 nsCString::SetCapacity(unsigned int)

  2090 nsCString::SetLength(unsigned int)

  2091 nsACString::do_AssignFromReadable(nsACString const &)

  2092 nsACString::do_AssignFromElementPtr(char const *)

  2093 nsXBLDocumentInfo::nsXBLDocumentInfo(char const *, nsIDocument *)

  2095 <nsXBLDocumentInfo>

  2096 __builtin_new

  2097 nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *)

  2099 # ----------------------------------------------------------------------

  2100 #

  2101 # nsXULPrototypeCache

  2102 #

  2104 <nsXULPrototypeCache>

  2105 __builtin_new

  2106 nsCStringKey::Clone(void) const

  2107 nsHashtable::Put(nsHashKey *, void *)

  2108 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2109 nsXULPrototypeCache::PutXBLDocumentInfo(nsXBLDocumentInfo *)

  2111 <nsXULPrototypeCache>

  2112 PR_Malloc

  2113 PL_HashTableFinalize(PLHashTable *)

  2114 PL_HashTableRawAdd

  2115 nsHashtable::Put(nsHashKey *, void *)

  2116 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2117 nsXULPrototypeCache::PutPrototype(nsIXULPrototypeDocument *)

  2119 <nsXULPrototypeCache>

  2120 PR_Malloc

  2121 PL_HashTableFinalize(PLHashTable *)

  2122 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2123 nsHashtable::nsHashtable(unsigned int, int)

  2124 nsXULPrototypeCache::nsXULPrototypeCache(void)

  2126 <nsXULPrototypeCache>

  2127 PR_Malloc

  2128 PL_HashTableFinalize(PLHashTable *)

  2129 PL_HashTableRawAdd

  2130 nsHashtable::Put(nsHashKey *, void *)

  2131 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2132 nsXULPrototypeCache::PutXBLDocumentInfo(nsXBLDocumentInfo *)

  2134 <nsXULPrototypeCache>

  2135 PR_Malloc

  2136 PL_HashTableFinalize(PLHashTable *)

  2137 PL_HashTableRawAdd

  2138 nsHashtable::Put(nsHashKey *, void *)

  2139 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2140 nsXULPrototypeCache::PutStyleSheet(nsICSSStyleSheet *)

  2142 <nsXULPrototypeCache>

  2143 PR_Malloc

  2144 PL_HashTableFinalize(PLHashTable *)

  2145 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2146 nsHashtable::nsHashtable(unsigned int, int)

  2147 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  2148 nsXULPrototypeCache::nsXULPrototypeCache(void)

  2150 <nsXULPrototypeCache>

  2151 PR_Malloc

  2152 nsMemoryImpl::Alloc(unsigned int)

  2153 nsMemory::Alloc(unsigned int)

  2154 nsCStringKey::Clone(void) const

  2155 nsHashtable::Put(nsHashKey *, void *)

  2156 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2157 nsXULPrototypeCache::PutXBLDocumentInfo(nsXBLDocumentInfo *)

  2159 <nsXULPrototypeCache>

  2160 PR_Malloc

  2161 PL_HashTableFinalize(PLHashTable *)

  2162 PL_HashTableRawAdd

  2163 nsHashtable::Put(nsHashKey *, void *)

  2164 nsXULPrototypeCache::PutScript(nsIURI *, void *)

  2166 # nsXULPrototypeElement

  2167 <nsXULPrototypeCache>

  2168 __builtin_new

  2169 XULContentSinkImpl::CreateElement(nsINodeInfo *, nsXULPrototypeElement **)

  2171 # nsXULPrototypeNode

  2172 <nsXULPrototypeCache>

  2173 __builtin_new

  2174 __builtin_vec_new

  2175 XULContentSinkImpl::CloseContainer(nsIParserNode const &)

  2177 # nsXULPrototypeScript

  2178 <nsXULPrototypeCache>

  2179 __builtin_new

  2180 XULContentSinkImpl::OpenScript(nsIParserNode const &)

  2182 # ----------------------------------------------------------------------

  2183 #

  2184 # nsExternalHelperAppService

  2185 #

  2187 <nsExternalHelperAppService>

  2188 __builtin_new

  2189 nsExternalHelperAppService::nsExternalHelperAppService(void)

  2191 <nsExternalHelperAppService>

  2192 __builtin_new

  2193 nsCStringKey::Clone(void) const

  2194 nsHashtable::Put(nsHashKey *, void *)

  2195 nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)

  2197 <nsExternalHelperAppService>

  2198 PR_Malloc

  2199 PL_HashTableFinalize(PLHashTable *)

  2200 PL_HashTableRawAdd

  2201 nsHashtable::Put(nsHashKey *, void *)

  2202 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2203 nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)

  2205 <nsExternalHelperAppService>

  2206 PR_Malloc

  2207 PL_HashTableFinalize(PLHashTable *)

  2208 PL_HashTableRawAdd

  2209 nsHashtable::Put(nsHashKey *, void *)

  2210 nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)

  2212 <nsExternalHelperAppService>

  2213 PR_Malloc

  2214 nsMemoryImpl::Alloc(unsigned int)

  2215 nsMemory::Alloc(unsigned int)

  2216 nsCStringKey::Clone(void) const

  2217 nsHashtable::Put(nsHashKey *, void *)

  2218 nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *)

  2220 <nsExternalHelperAppService>

  2221 PR_Malloc

  2222 nsVoidArray::SizeTo(int)

  2223 nsVoidArray::GrowArrayBy(int)

  2224 nsVoidArray::InsertElementAt(void *, int)

  2225 nsTArray<nsCString>::InsertElementAt(int, nsCString const &)

  2226 nsMIMEInfoImpl::SetFileExtensions(char const *)

  2227 nsExternalHelperAppService::AddDefaultMimeTypesToCache(void)

  2229 # ----------------------------------------------------------------------

  2230 #

  2231 # nsCategoryManager

  2232 #

  2234 <nsCategoryManager>

  2235 __builtin_new

  2236 nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

  2238 <nsCategoryManager>

  2239 PR_Malloc

  2240 PL_HashTableFinalize(PLHashTable *)

  2241 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2242 nsHashtable::nsHashtable(unsigned int, int)

  2243 nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)

  2244 nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

  2246 <nsCategoryManager>

  2247 __builtin_new

  2248 nsCStringKey::Clone(void) const

  2249 nsHashtable::Put(nsHashKey *, void *)

  2250 nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

  2252 <nsCategoryManager>

  2253 PR_Malloc

  2254 PL_HashTableFinalize(PLHashTable *)

  2255 PL_HashTableRawAdd

  2256 nsHashtable::Put(nsHashKey *, void *)

  2257 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2258 nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

  2260 <nsCategoryManager>

  2261 PR_Malloc

  2262 PL_HashTableFinalize(PLHashTable *)

  2263 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2264 nsHashtable::nsHashtable(unsigned int, int)

  2265 __17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii

  2266 CategoryNode::CategoryNode(void)

  2267 nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

  2269 <nsCategoryManager>

  2270 PR_Malloc

  2271 PL_HashTableFinalize(PLHashTable *)

  2272 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2273 nsHashtable::nsHashtable(unsigned int, int)

  2274 __17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii

  2275 nsCategoryManager::nsCategoryManager(void)

  2277 <nsCategoryManager>

  2278 PR_Malloc

  2279 PL_HashTableFinalize(PLHashTable *)

  2280 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2281 nsHashtable::nsHashtable(unsigned int, int)

  2282 __17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii

  2283 CategoryNode::CategoryNode(void)

  2284 nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

  2286 <nsCategoryManager>

  2287 PR_Malloc

  2288 PL_HashTableFinalize(PLHashTable *)

  2289 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2290 nsHashtable::nsHashtable(unsigned int, int)

  2291 __17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii

  2292 nsCategoryManager::nsCategoryManager(void)

  2294 <nsCategoryManager>

  2295 PR_Malloc

  2296 PL_HashTableFinalize(PLHashTable *)

  2297 PL_HashTableRawAdd

  2298 nsHashtable::Put(nsHashKey *, void *)

  2299 nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

  2301 <nsCategoryManager>

  2302 PR_Malloc

  2303 nsMemoryImpl::Alloc(unsigned int)

  2304 nsMemory::Alloc(unsigned int)

  2305 nsCStringKey::Clone(void) const

  2306 nsHashtable::Put(nsHashKey *, void *)

  2307 nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

  2309 <nsCategoryManager>

  2310 PR_Malloc

  2311 nsMemoryImpl::Alloc(unsigned int)

  2312 nsMemory::Alloc(unsigned int)

  2313 nsCStringKey::Clone(void) const

  2314 nsHashtable::Put(nsHashKey *, void *)

  2315 nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

  2317 <nsCategoryManager>

  2318 PR_Malloc

  2319 nsMemoryImpl::Alloc(unsigned int)

  2320 nsMemory::Alloc(unsigned int)

  2321 nsStr::Alloc(nsStr &, unsigned int)

  2322 nsStr::Realloc(nsStr &, unsigned int)

  2323 nsStr::EnsureCapacity(nsStr &, unsigned int)

  2324 nsStr::GrowCapacity(nsStr &, unsigned int)

  2325 nsCString::SetCapacity(unsigned int)

  2326 nsCString::SetLength(unsigned int)

  2327 nsACString::do_AssignFromReadable(nsACString const &)

  2328 nsACString::do_AssignFromElementPtr(char const *)

  2329 nsCString::nsCString(char const *)

  2330 nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **)

  2332 # ----------------------------------------------------------------------

  2333 #

  2334 # nsScriptNameSpaceManager

  2335 #

  2337 <nsScriptNameSpaceManager>

  2338 PR_Malloc

  2339 PL_HashTableFinalize(PLHashTable *)

  2340 PL_HashTableRawAdd

  2341 nsHashtable::Put(nsHashKey *, void *)

  2342 nsScriptNameSpaceManager::RegisterClassName(char const *, int)

  2344 <nsScriptNameSpaceManager>

  2345 PR_Malloc

  2346 PL_HashTableFinalize(PLHashTable *)

  2347 PL_HashTableRawAdd

  2348 nsHashtable::Put(nsHashKey *, void *)

  2349 nsScriptNameSpaceManager::FillHashWithDOMInterfaces(void)

  2351 <nsScriptNameSpaceManager>

  2352 PR_Malloc

  2353 PL_HashTableFinalize(PLHashTable *)

  2354 PL_HashTableRawAdd

  2355 nsHashtable::Put(nsHashKey *, void *)

  2356 nsScriptNameSpaceManager::FillHash(nsICategoryManager *, char const *, nsGlobalNameStruct::nametype)

  2358 <nsScriptNameSpaceManager>

  2359 __builtin_new

  2360 nsScriptNameSpaceManager::RegisterClassName(char const *, int)

  2362 # ----------------------------------------------------------------------

  2363 #

  2364 # nsScriptSecurityManager

  2365 #

  2367 <nsScriptSecurityManager>

  2368 PR_Malloc

  2369 PL_HashTableFinalize(PLHashTable *)

  2370 PL_HashTableRawAdd

  2371 nsHashtable::Put(nsHashKey *, void *)

  2372 nsScriptSecurityManager::InitPolicies(unsigned int, char const **, nsISecurityPref *)

  2374 <nsScriptSecurityManager>

  2375 __builtin_new

  2376 nsScriptSecurityManager::EnumeratePolicyCallback(char const *, void *)

  2378 <nsScriptSecurityManager>

  2379 __builtin_new

  2380 nsCStringKey::Clone(void) const

  2381 nsHashtable::Put(nsHashKey *, void *)

  2382 nsScriptSecurityManager::EnumeratePolicyCallback(char const *, void *)

  2384 <nsScriptSecurityManager>

  2385 PR_Malloc

  2386 PL_HashTableFinalize(PLHashTable *)

  2387 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2388 nsHashtable::nsHashtable(unsigned int, int)

  2389 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  2390 nsScriptSecurityManager::InitPrefs(void)

  2392 <nsScriptSecurityManager>

  2393 PR_Malloc

  2394 PL_HashTableFinalize(PLHashTable *)

  2395 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2396 nsHashtable::nsHashtable(unsigned int, int)

  2397 __17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii

  2398 nsScriptSecurityManager::EnumeratePolicyCallback(char const *, void *)

  2400 <nsScriptSecurityManager>

  2401 PR_Malloc

  2402 nsMemoryImpl::Alloc(unsigned int)

  2403 nsMemory::Alloc(unsigned int)

  2404 nsCStringKey::Clone(void) const

  2405 nsHashtable::Put(nsHashKey *, void *)

  2406 nsScriptSecurityManager::InitPolicies(unsigned int, char const **, nsISecurityPref *)

  2408 # ----------------------------------------------------------------------

  2409 #

  2410 # nsStringBundleService

  2411 #

  2413 <nsStringBundleService>

  2414 __builtin_new

  2415 nsCStringKey::Clone(void) const

  2416 nsHashtable::Put(nsHashKey *, void *)

  2417 nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)

  2419 <nsStringBundleService>

  2420 PR_Malloc

  2421 PL_HashTableFinalize(PLHashTable *)

  2422 PL_HashTableRawAdd

  2423 nsHashtable::Put(nsHashKey *, void *)

  2424 nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)

  2426 <nsStringBundleService>

  2427 PR_Malloc

  2428 PL_HashTableFinalize(PLHashTable *)

  2429 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2430 nsHashtable::nsHashtable(unsigned int, int)

  2431 nsStringBundleService::nsStringBundleService(void)

  2433 <nsStringBundleService>

  2434 PR_Malloc

  2435 PL_ArenaAllocate

  2436 nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)

  2438 <nsStringBundleService>

  2439 PR_Malloc

  2440 nsMemoryImpl::Alloc(unsigned int)

  2441 nsMemory::Alloc(unsigned int)

  2442 nsCStringKey::Clone(void) const

  2443 nsHashtable::Put(nsHashKey *, void *)

  2444 nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *)

  2446 # ----------------------------------------------------------------------

  2448 <CSSStyleSheetImpl>

  2449 __builtin_new

  2450 CSSStyleSheetImpl::CSSStyleSheetImpl(void)

  2452 <CSSStyleSheetImpl>

  2453 __builtin_new

  2454 __builtin_vec_new

  2455 nsSupportsArray::GrowArrayBy(int)

  2456 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  2457 nsSupportsArray::AppendElement(nsISupports *)

  2458 CSSStyleSheetImpl::AppendStyleRule(nsICSSRule *)

  2460 <CSSStyleSheetImpl>

  2461 PR_Malloc

  2462 PL_HashTableFinalize(PLHashTable *)

  2463 PL_HashTableRawAdd

  2464 nsHashtable::Put(nsHashKey *, void *)

  2465 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  2466 CSSStyleSheetImpl::CheckRuleForAttributes(nsICSSRule *)

  2468 <CSSStyleSheetImpl>

  2469 __builtin_new

  2470 AtomKey::Clone(void) const

  2471 nsHashtable::Put(nsHashKey *, void *)

  2472 CSSStyleSheetImpl::CheckRuleForAttributes(nsICSSRule *)

  2474 <CSSStyleSheetImpl>

  2475 PR_Malloc

  2476 PL_HashTableFinalize(PLHashTable *)

  2477 PL_HashTableRawAdd

  2478 nsHashtable::Put(nsHashKey *, void *)

  2479 CSSStyleSheetImpl::CheckRuleForAttributes(nsICSSRule *)

  2481 <CSSStyleSheetInner>

  2482 PR_Malloc

  2483 PL_HashTableFinalize(PLHashTable *)

  2484 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2485 nsHashtable::nsHashtable(unsigned int, int)

  2486 CSSStyleSheetInner::CSSStyleSheetInner(nsICSSStyleSheet *)

  2488 <HTMLStyleSheetImpl>

  2489 PR_Malloc

  2490 PL_HashTableFinalize(PLHashTable *)

  2491 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2492 nsHashtable::nsHashtable(unsigned int, int)

  2493 HTMLStyleSheetImpl::HTMLStyleSheetImpl(void)

  2495 <HTMLStyleSheetImpl>

  2496 PR_Malloc

  2497 PL_HashTableFinalize(PLHashTable *)

  2498 PL_HashTableRawRemove

  2499 nsHashtable::Remove(nsHashKey *)

  2500 HTMLStyleSheetImpl::DropMappedAttributes(nsIHTMLMappedAttributes *)

  2502 <HTMLStyleSheetImpl>

  2503 __builtin_new

  2504 AttributeKey::Clone(void) const

  2505 nsHashtable::Put(nsHashKey *, void *)

  2506 HTMLStyleSheetImpl::UniqueMappedAttributes(nsIHTMLMappedAttributes *, nsIHTMLMappedAttributes *&)

  2508 <HTMLStyleSheetImpl>

  2509 PR_Malloc

  2510 PL_HashTableFinalize(PLHashTable *)

  2511 PL_HashTableRawAdd

  2512 nsHashtable::Put(nsHashKey *, void *)

  2513 HTMLStyleSheetImpl::UniqueMappedAttributes(nsIHTMLMappedAttributes *, nsIHTMLMappedAttributes *&)

  2515 <nsStyleContextData>

  2516 __builtin_new

  2517 nsStyleContextData::Create(nsIPresContext *)

  2519 <nsStyleContent>

  2520 __builtin_new

  2521 __builtin_vec_new

  2522 nsStyleContent::AllocateCounterResets(unsigned int)

  2524 <nsStyleContent>

  2525 __builtin_new

  2526 __builtin_vec_new

  2527 nsStyleContent::AllocateContents(unsigned int)

  2529 <xptiManifest>

  2530 __builtin_new

  2531 xptiManifest::Read(xptiInterfaceInfoManager *, xptiWorkingSet *)

  2533 <xptiManifest>

  2534 PR_Malloc

  2535 PL_ArenaFinish

  2536 PL_HashTableRawAdd

  2537 PL_HashTableAdd

  2538 xptiManifest::Read(xptiInterfaceInfoManager *, xptiWorkingSet *)

  2540 <CSSParserImpl>

  2541 __builtin_new

  2542 SelectorList::AddSelector(nsCSSSelector const &)

  2543 CSSParserImpl::ParseSelectorGroup(int &, SelectorList *&)

  2545 <CSSParserImpl>

  2546 __builtin_new

  2547 CSSParserImpl::ParseContent(int &, nsICSSDeclaration *, int &)

  2549 # ----------------------------------------------------------------------

  2550 #

  2551 # RuleHash

  2552 #

  2554 <RuleHash>

  2555 __builtin_new

  2556 RuleHash::AppendRuleToTable(nsHashtable &, int, nsICSSStyleRule *)

  2558 <RuleHash>

  2559 __builtin_new

  2560 RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *)

  2562 <RuleHash>

  2563 __builtin_new

  2564 RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *, int)

  2566 <RuleHash>

  2567 PR_Malloc

  2568 PL_HashTableFinalize(PLHashTable *)

  2569 PL_HashTableRawAdd

  2570 nsHashtable::Put(nsHashKey *, void *)

  2571 RuleHash::AppendRuleToTable(nsHashtable &, int, nsICSSStyleRule *)

  2573 <RuleHash>

  2574 __builtin_new

  2575 AtomKey::Clone(void) const

  2576 nsHashtable::Put(nsHashKey *, void *)

  2577 RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *)

  2579 <RuleHash>

  2580 PR_Malloc

  2581 PL_HashTableFinalize(PLHashTable *)

  2582 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2583 nsHashtable::nsHashtable(unsigned int, int)

  2584 RuleHash::RuleHash(void)

  2586 <RuleHash>

  2587 PR_Malloc

  2588 PL_HashTableFinalize(PLHashTable *)

  2589 PL_HashTableRawAdd

  2590 nsHashtable::Put(nsHashKey *, void *)

  2591 RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *)

  2593 <RuleHash>

  2594 __builtin_new

  2595 __builtin_vec_new

  2596 RuleHash::EnumerateAllRules(nsIAtom *, nsIAtom *, nsVoidArray const &, void (*)(nsICSSStyleRule *, void *), void *)

  2598 <RuleHash>

  2599 PR_Malloc

  2600 PL_HashTableFinalize(PLHashTable *)

  2601 PL_HashTableRawAdd

  2602 nsHashtable::Put(nsHashKey *, void *)

  2603 RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *, int)

  2605 # ----------------------------------------------------------------------

  2606 #

  2607 # nsCSSSelector

  2608 #

  2610 <nsCSSSelector>

  2611 __builtin_new

  2612 nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

  2614 <nsCSSSelector>

  2615 __builtin_new

  2616 nsAtomList::nsAtomList(nsAtomList const &)

  2617 nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

  2619 <nsCSSSelector>

  2620 __builtin_new

  2621 nsAttrSelector::nsAttrSelector(nsAttrSelector const &)

  2622 nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

  2624 <nsCSSSelector>

  2625 __builtin_new

  2626 nsAttrSelector::nsAttrSelector(nsAttrSelector const &)

  2627 nsAttrSelector::nsAttrSelector(nsAttrSelector const &)

  2628 nsCSSSelector::nsCSSSelector(nsCSSSelector const &)

  2630 # ----------------------------------------------------------------------

  2631 #

  2632 # StyleSetImpl

  2633 #

  2635 <StyleSetImpl>

  2636 __builtin_new

  2637 CSSStyleSheetImpl::GetStyleRuleProcessor(nsIStyleRuleProcessor *&, nsIStyleRuleProcessor *)

  2638 StyleSetImpl::ClearOverrideRuleProcessors(void)

  2640 <StyleSetImpl>

  2641 __builtin_new

  2642 CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)

  2643 CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIStyleContext *, nsIRuleWalker *)

  2644 StyleSetImpl::ReplaceBackstopStyleSheets(nsISupportsArray *)

  2646 <StyleSetImpl>

  2647 __builtin_new

  2648 CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)

  2649 CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIAtom *, nsIStyleContext *, nsICSSPseudoComparator *, nsIRuleWalker *)

  2650 StyleSetImpl::ResolveStyleFor(nsIPresContext *, nsIContent *, nsIStyleContext *, int)

  2652 <StyleSetImpl>

  2653 __builtin_new

  2654 nsSupportsArray::Create(nsISupports *, nsID const &, void **)

  2655 NS_NewISupportsArray(nsISupportsArray **)

  2656 StyleSetImpl::EnsureArray(nsISupportsArray **)

  2658 <StyleSetImpl>

  2659 PR_Malloc

  2660 PL_HashTableFinalize(PLHashTable *)

  2661 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2662 nsHashtable::nsHashtable(unsigned int, int)

  2663 nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)

  2664 nsRuleWalker::Forward(nsIStyleRule *)

  2665 StyleSetImpl::AddImportantRules(nsIRuleNode *)

  2667 <StyleSetImpl>

  2668 PR_Malloc

  2669 PL_HashTableFinalize(PLHashTable *)

  2670 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  2671 nsHashtable::nsHashtable(unsigned int, int)

  2672 nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)

  2673 nsRuleWalker::Forward(nsIStyleRule *)

  2674 nsHTMLBodyElement::WalkInlineStyleRules(nsIRuleWalker *)

  2675 HTMLCSSStyleSheetImpl::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIStyleContext *, nsIRuleWalker *)

  2676 StyleSetImpl::ReplaceBackstopStyleSheets(nsISupportsArray *)

  2678 <StyleSetImpl>

  2679 __builtin_new

  2680 __builtin_vec_new

  2681 nsSupportsArray::GrowArrayBy(int)

  2682 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  2683 nsSupportsArray::AppendElement(nsISupports *)

  2684 CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)

  2685 nsSupportsArray::EnumerateBackwards(int (*)(nsISupports *, void *), void *)

  2686 CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)

  2687 CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)

  2688 CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIStyleContext *, nsIRuleWalker *)

  2689 StyleSetImpl::ReplaceBackstopStyleSheets(nsISupportsArray *)

  2691 <StyleSetImpl>

  2692 __builtin_new

  2693 __builtin_vec_new

  2694 nsSupportsArray::GrowArrayBy(int)

  2695 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  2696 nsSupportsArray::AppendElement(nsISupports *)

  2697 CSSRuleProcessor::AppendStyleSheet(nsICSSStyleSheet *)

  2698 CSSStyleSheetImpl::GetStyleRuleProcessor(nsIStyleRuleProcessor *&, nsIStyleRuleProcessor *)

  2699 StyleSetImpl::ClearOverrideRuleProcessors(void)

  2701 //----------------------------------------------------------------------

  2703 <StyleListImpl>

  2704 PR_Malloc

  2705 nsMemoryImpl::Alloc(unsigned int)

  2706 nsMemory::Alloc(unsigned int)

  2707 nsStr::Alloc(nsStr &, unsigned int)

  2708 nsStr::Realloc(nsStr &, unsigned int)

  2709 nsStr::EnsureCapacity(nsStr &, unsigned int)

  2710 nsStr::GrowCapacity(nsStr &, unsigned int)

  2711 nsString::SetCapacity(unsigned int)

  2712 nsString::SetLength(unsigned int)

  2713 ~.*

  2714 ~.*

  2715 basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)

  2716 nsString::operator=(nsString const &)

  2717 StyleListImpl::ResetFrom(nsStyleList const *, nsIPresContext *)

  2719 <StyleListImpl>

  2720 __builtin_new

  2721 __builtin_vec_new

  2722 nsSupportsArray::GrowArrayBy(int)

  2723 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  2724 nsSupportsArray::AppendElement(nsISupports *)

  2725 CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)

  2726 nsSupportsArray::EnumerateBackwards(int (*)(nsISupports *, void *), void *)

  2727 CSSRuleProcessor::CascadeSheetRulesInto(nsISupports *, void *)

  2728 CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)

  2729 CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIAtom *, nsIStyleContext *, nsICSSPseudoComparator *, nsIRuleWalker *)

  2730 StyleSetImpl::ResolveStyleFor(nsIPresContext *, nsIContent *, nsIStyleContext *, int)

  2732 <StyleListImpl>

  2733 PR_Malloc

  2734 nsVoidArray::SizeTo(int)

  2735 nsVoidArray::GrowArrayBy(int)

  2736 nsVoidArray::InsertElementAt(void *, int)

  2737 CSSRuleProcessor::ClearRuleCascades(void)

  2738 nsSupportsArray::EnumerateBackwards(int (*)(nsISupports *, void *), void *)

  2739 CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *)

  2740 CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIAtom *, nsIStyleContext *, nsICSSPseudoComparator *, nsIRuleWalker *)

  2741 StyleSetImpl::ResolveStyleFor(nsIPresContext *, nsIContent *, nsIStyleContext *, int)

  2743 # ----------------------------------------------------------------------

  2745 <StyleContextCache>

  2746 PR_Malloc

  2747 PL_HashTableFinalize(PLHashTable *)

  2748 PL_HashTableRawAdd

  2749 nsHashtable::Put(nsHashKey *, void *)

  2750 StyleContextCache::VerifyList(unsigned int)

  2752 <StyleContextCache>

  2753 __builtin_new

  2754 StyleContextCache::AllocateList(void)

  2756 # ----------------------------------------------------------------------

  2757 #

  2758 # nsPersistentProperties

  2759 #

  2761 <nsPersistentProperties>

  2762 __builtin_new

  2763 nsPersistentProperties::Create(nsISupports *, nsID const &, void **)

  2765 <nsPersistentProperties>

  2766 PR_Malloc

  2767 PL_ArenaFinish

  2768 PL_HashTableRawAdd

  2769 nsPersistentProperties::SetStringProperty(nsAString const &, nsAString &, nsAString &)

  2770 nsPersistentProperties::Load(nsIInputStream *)

  2772 <nsPersistentProperties>

  2773 PR_Malloc

  2774 nsMemoryImpl::Alloc(unsigned int)

  2775 nsMemory::Alloc(unsigned int)

  2776 nsCppSharedAllocator<unsigned short>::allocate(unsigned int, void const *)

  2777 nsCRT::strndup(unsigned short const *, unsigned int)

  2778 nsCRT::strdup(unsigned short const *)

  2779 nsString::ToNewUnicode(void) const

  2780 nsPersistentProperties::SetStringProperty(nsString const &, nsString &, nsString &)

  2782 <nsPersistentProperties>

  2783 PR_Malloc

  2784 PL_ArenaFinish

  2785 PL_HashTableRawAdd

  2786 nsPersistentProperties::SetStringProperty(nsString const &, nsString &, nsString &)

  2788 <nsPersistentProperties>

  2789 PR_Malloc

  2790 PL_ArenaFinish

  2791 PL_NewHashTable

  2792 nsPersistentProperties::nsPersistentProperties(void)

  2794 <nsPersistentProperties>

  2795 PR_Malloc

  2796 nsMemoryImpl::Alloc(unsigned int)

  2797 nsMemory::Alloc(unsigned int)

  2798 ToNewUnicode(nsAString const &)

  2799 nsPersistentProperties::SetStringProperty(nsAString const &, nsAString &, nsAString &)

  2801 <nsPersistentProperties>

  2802 PR_Malloc

  2803 nsMemoryImpl::Alloc(unsigned int)

  2804 nsMemory::Alloc(unsigned int)

  2805 unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)

  2806 ToNewUnicode(nsAString const &)

  2807 nsPersistentProperties::SetStringProperty(nsAString const &, nsAString &, nsAString &)

  2809 # ----------------------------------------------------------------------

  2810 #

  2811 # nsCSSValue

  2812 #

  2814 <nsCSSValue>

  2815 PR_Malloc

  2816 nsMemoryImpl::Alloc(unsigned int)

  2817 nsMemory::Alloc(unsigned int)

  2818 nsCppSharedAllocator<unsigned short>::allocate(unsigned int, void const *)

  2819 nsCRT::strndup(unsigned short const *, unsigned int)

  2820 nsCRT::strdup(unsigned short const *)

  2821 nsString::ToNewUnicode(void) const

  2822 nsCSSValue::operator=(nsCSSValue const &)

  2824 <nsCSSValue>

  2825 PR_Malloc

  2826 nsMemoryImpl::Alloc(unsigned int)

  2827 nsMemory::Alloc(unsigned int)

  2828 ToNewUnicode(nsAString const &)

  2829 nsCSSValue::SetStringValue(nsAString const &, nsCSSUnit)

  2831 <nsCSSValue>

  2832 PR_Malloc

  2833 nsMemoryImpl::Alloc(unsigned int)

  2834 nsMemory::Alloc(unsigned int)

  2835 unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)

  2836 ToNewUnicode(nsAString const &)

  2837 nsCSSValue::SetStringValue(nsAString const &, nsCSSUnit)

  2839 # ----------------------------------------------------------------------

  2841 <nsStringKey>

  2842 PR_Malloc

  2843 nsMemoryImpl::Alloc(unsigned int)

  2844 nsMemory::Alloc(unsigned int)

  2845 nsStringKey::Clone(void) const

  2847 #----------------------------------------------------------------------

  2848 #

  2849 # nsTextFragment

  2850 #

  2852 <nsTextFragment>

  2853 PR_Malloc

  2854 nsMemoryImpl::Alloc(unsigned int)

  2855 nsMemory::Alloc(unsigned int)

  2856 nsTextFragment::SetTo(unsigned short const *, int)

  2858 <nsTextFragment>

  2859 PR_Malloc

  2860 nsMemoryImpl::Alloc(unsigned int)

  2861 nsMemory::Alloc(unsigned int)

  2862 ToNewCString(nsAString const &)

  2863 nsTextFragment::operator=(nsAString const &)

  2865 <nsTextFragment>

  2866 PR_Malloc

  2867 nsMemoryImpl::Alloc(unsigned int)

  2868 nsMemory::Alloc(unsigned int)

  2869 char * AllocateStringCopy<unsigned short, char>(basic_nsAReadableString<unsigned short> const &, char *)

  2870 ToNewCString(basic_nsAReadableString<unsigned short> const &)

  2871 nsTextFragment::operator=(basic_nsAReadableString<unsigned short> const &)

  2873 #----------------------------------------------------------------------

  2874 #

  2875 # nsTextBoxFrame

  2876 #

  2878 <nsTextBoxFrame>

  2879 PR_Malloc

  2880 nsMemoryImpl::Alloc(unsigned int)

  2881 nsMemory::Alloc(unsigned int)

  2882 nsStr::Alloc(nsStr &, unsigned int)

  2883 nsStr::Realloc(nsStr &, unsigned int)

  2884 nsStr::EnsureCapacity(nsStr &, unsigned int)

  2885 nsStr::GrowCapacity(nsStr &, unsigned int)

  2886 nsString::SetCapacity(unsigned int)

  2887 nsString::SetLength(unsigned int)

  2888 nsAString::do_AssignFromReadable(nsAString const &)

  2889 nsAString::AssignFromReadable(nsAString const &)

  2890 nsTextBoxFrame::UpdateAttributes(nsIPresContext *, nsIAtom *, int &, int &)

  2892 <nsTextBoxFrame>

  2893 PR_Malloc

  2894 nsMemoryImpl::Alloc(unsigned int)

  2895 nsMemory::Alloc(unsigned int)

  2896 nsStr::Alloc(nsStr &, unsigned int)

  2897 nsStr::Realloc(nsStr &, unsigned int)

  2898 nsStr::EnsureCapacity(nsStr &, unsigned int)

  2899 nsStr::GrowCapacity(nsStr &, unsigned int)

  2900 nsString::SetCapacity(unsigned int)

  2901 nsString::SetLength(unsigned int)

  2902 nsAString::do_AssignFromReadable(nsAString const &)

  2903 nsAString::AssignFromReadable(nsAString const &)

  2904 nsTextBoxFrame::CalculateTitleForWidth(nsIPresContext *, nsRenderingContext &, int)

  2906 # ----------------------------------------------------------------------

  2907 #

  2908 # nsPopupSetFrame

  2909 #

  2911 <nsPopupSetFrame>

  2912 __builtin_new

  2913 nsPopupSetFrame::AddPopupFrame(nsIFrame *)

  2915 #----------------------------------------------------------------------

  2917 <nsStdURL>

  2918 PR_Malloc

  2919 nsMemoryImpl::Alloc(unsigned int)

  2920 nsMemory::Alloc(unsigned int)

  2921 ToNewCString(nsACString const &)

  2922 nsStdURL::GetSpec(char **)

  2924 <nsSimpleURI>

  2925 PR_Malloc

  2926 nsMemoryImpl::Alloc(unsigned int)

  2927 nsMemory::Alloc(unsigned int)

  2928 nsString::ToNewCString(void) const

  2929 nsSimpleURI::SetSpec(char const *)

  2931 <nsSimpleURI>

  2932 PR_Malloc

  2933 nsMemoryImpl::Alloc(unsigned int)

  2934 nsMemory::Alloc(unsigned int)

  2935 ToNewCString(nsAString const &)

  2936 nsSimpleURI::SetSpec(char const *)

  2938 <nsNodeInfoManager>

  2939 PR_Malloc

  2940 PL_ArenaFinish

  2941 PL_HashTableRawAdd

  2942 PL_HashTableAdd

  2943 nsNodeInfoManager::GetNodeInfo(nsIAtom *, nsIAtom *, int, nsINodeInfo *&)

  2945 <nsNodeInfoManager>

  2946 PR_Malloc

  2947 PL_ArenaFinish

  2948 PL_NewHashTable

  2949 nsNodeInfoManager::nsNodeInfoManager(void)

  2951 <nsNodeInfoManager>

  2952 PR_Malloc

  2953 PL_ArenaFinish

  2954 PL_HashTableRawRemove

  2955 PL_HashTableRemove

  2956 nsNodeInfoManager::RemoveNodeInfo(nsNodeInfo *)

  2958 <xptiInterfaceInfo>

  2959 XPT_ArenaMalloc

  2960 xptiInterfaceInfo::CopyName(char const *, xptiWorkingSet *)

  2962 <xptiInterfaceInfo>

  2963 __builtin_new

  2964 xptiInterfaceInfo::PartiallyResolveLocked(XPTInterfaceDescriptor *, xptiWorkingSet *)

  2966 <xpti-unclassified>

  2967 XPT_ArenaMalloc

  2969 <pthread-unclassified>

  2970 siglongjmp

  2971 pthread_create

  2973 <X-unclassified>

  2974 XkbAllocClientMap

  2976 <X-unclassified>

  2977 _XiCheckExtInit

  2979 <X-unclassified>

  2980 _XAllocScratch

  2982 <X-unclassified>

  2983 XUnlockDisplay

  2985 <X-unclassified>

  2986 _XlcCreateLC

  2988 <X-unclassified>

  2989 XkbUseExtension

  2991 <X-unclassified>

  2992 _XimServerDestroy

  2994 <X-unclassified>

  2995 _XlcAddCharSet

  2997 <X-unclassified>

  2998 XInitExtension

  3000 <X-unclassified>

  3001 _XlcGenericLoader

  3003 <X-unclassified>

  3004 _XwcDefaultDrawImageString

  3006 <X-unclassified>

  3007 _XlcAddCT

  3009 <X-unclassified>

  3010 XShmCreateImage

  3012 <X-unclassified>

  3013 _XFreeAtomTable

  3015 <X-unclassified>

  3016 XCreateRegion

  3018 <X-unclassified>

  3019 XIntersectRegion

  3021 <X-unclassified>

  3022 _XlcCreateLocaleDataBase

  3024 <X-unclassified>

  3025 _XUpdateAtomCache

  3027 <X-unclassified>

  3028 XrmMergeDatabases

  3030 <X-unclassified>

  3031 XrmParseCommand

  3033 <X-unclassified>

  3034 XOpenDisplay

  3036 <X-unclassified>

  3037 XCreateGC

  3039 <X-unclassified>

  3040 _XlcResetConverter

  3042 <X-unclassified>

  3043 _XEnq

  3045 <X-unclassified>

  3046 _XimLcctstowcs

  3048 <X-unclassified>

  3049 XtMalloc

  3051 <X-unclassified>

  3052 XtCalloc

  3054 <X-unclassified>

  3055 Xpermalloc

  3057 <X-unclassified>

  3058 _XlcCreateDefaultCharSet

  3060 <X-unclassified>

  3061 _XimLocalSetICValues

  3063 <X-unclassified>

  3064 _XimLocalCreateIC

  3066 <X-unclassified>

  3067 _XlcSetConverter

  3069 <X-unclassified>

  3070 _XkbGetCharset

  3072 <gtk-unclassified>

  3073 g_malloc

  3075 <gtk-unclassified>

  3076 g_realloc

  3078 <gtk-unclassified>

  3079 g_malloc0

  3081 <gtk-unclassified>

  3082 _XimLcctstoutf8

  3084 <gdk_imlib_load_image>

  3085 loader_png

  3086 gdk_imlib_load_image

  3088 <gdk_imlib_save_image>

  3089 loader_png

  3090 gdk_imlib_save_image

  3092 <dl-unclassified>

  3093 _dl_lookup_versioned_symbol_skip

  3095 <dl-unclassified>

  3096 _dl_dst_substitute

  3098 <dl-unclassified>

  3099 _dl_map_object_deps

  3101 <dl-unclassified>

  3102 _dl_map_object

  3104 <dl-unclassified>

  3105 _dl_debug_message

  3107 <nsRegistry>

  3108 PR_Malloc

  3109 bufio_SetBufferSize

  3110 nsXPTCStubBase::Sentinel9(void)

  3111 NR_RegSetBufferSize

  3112 nsRegistry::SetBufferSize(int)

  3114 <nsXBLService>

  3115 PR_Malloc

  3116 PL_ArenaAllocate

  3117 nsFixedSizeAllocator::AddBucket(unsigned int)

  3118 nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)

  3119 nsXBLService::nsXBLService(void)

  3121 <nsXBLService>

  3122 PR_Malloc

  3123 PL_HashTableFinalize(PLHashTable *)

  3124 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3125 nsHashtable::nsHashtable(unsigned int, int)

  3126 nsXBLService::nsXBLService(void)

  3128 <InMemoryDataSource>

  3129 PR_Malloc

  3130 PL_ArenaAllocate

  3131 nsFixedSizeAllocator::Alloc(unsigned int)

  3132 InMemoryAssertionEnumeratorImpl::operator new(unsigned int, nsFixedSizeAllocator &)

  3134 <nsGenericModule>

  3135 PR_Malloc

  3136 PL_HashTableFinalize(PLHashTable *)

  3137 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3138 nsHashtable::nsHashtable(unsigned int, int)

  3139 nsGenericModule::nsGenericModule(char const *, unsigned int, nsModuleComponentInfo *, unsigned int (*)(nsIModule *), void (*)(nsIModule *))

  3141 <nsGenericModule>

  3142 PR_Malloc

  3143 PL_HashTableFinalize(PLHashTable *)

  3144 PL_HashTableRawAdd

  3145 nsHashtable::Put(nsHashKey *, void *)

  3146 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3147 nsGenericModule::GetClassObject(nsIComponentManager *, nsID const &, nsID const &, void **)

  3149 <nsGenericModule>

  3150 __builtin_new

  3151 nsHashtable::Put(nsHashKey *, void *)

  3152 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3153 nsGenericModule::GetClassObject(nsIComponentManager *, nsID const &, nsID const &, void **)

  3155 <nsGenericModule>

  3156 PR_Malloc

  3157 PL_HashTableFinalize(PLHashTable *)

  3158 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3159 nsHashtable::nsHashtable(unsigned int, int)

  3160 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  3161 nsGenericModule::nsGenericModule(char const *, unsigned int, nsModuleComponentInfo *, void (*)(nsIModule *))

  3163 <nsGenericModule>

  3164 PR_Malloc

  3165 PL_HashTableFinalize(PLHashTable *)

  3166 PL_HashTableRawAdd

  3167 nsHashtable::nsHashtable(unsigned int, int)

  3168 nsGenericModule::nsGenericModule(char const *, unsigned int, nsModuleComponentInfo *, unsigned int (*)(nsIModule *), void (*)(nsIModule *))

  3170 <nsUNIXCharset>

  3171 gettext

  3172 gettext

  3173 setlocale

  3174 setlocale

  3175 nsUNIXCharset::nsUNIXCharset(void)

  3177 # ----------------------------------------------------------------------

  3178 #

  3179 # nsLocaleService

  3180 #

  3182 <nsLocaleService>

  3183 textdomain

  3184 textdomain

  3185 setlocale

  3186 setlocale

  3187 nsLocaleService::nsLocaleService(void)

  3189 <nsLocaleService>

  3190 setlocale

  3191 setlocale

  3192 setlocale

  3193 nsLocaleService::nsLocaleService(void)

  3195 <nsLocaleService>

  3196 PR_Malloc

  3197 PL_ArenaFinish

  3198 PL_NewHashTable

  3199 nsLocale::nsLocale(void)

  3201 <nsLocaleServie>

  3202 PR_Malloc

  3203 PL_ArenaFinish

  3204 PL_HashTableRawAdd

  3205 PL_HashTableAdd

  3206 nsLocale::AddCategory(unsigned short const *, unsigned short const *)

  3208 <nsLocaleService>

  3209 PR_Malloc

  3210 nsMemoryImpl::Alloc(unsigned int)

  3211 nsMemory::Alloc(unsigned int)

  3212 nsStr::Alloc(nsStr &, unsigned int)

  3213 nsStr::Realloc(nsStr &, unsigned int)

  3214 nsStr::EnsureCapacity(nsStr &, unsigned int)

  3215 nsStr::GrowCapacity(nsStr &, unsigned int)

  3216 nsString::SetCapacity(unsigned int)

  3217 nsString::SetLength(unsigned int)

  3218 nsAString::do_AssignFromReadable(nsAString const &)

  3219 nsAString::do_AssignFromElementPtr(unsigned short const *)

  3220 nsString::nsString(unsigned short const *)

  3221 nsLocale::AddCategory(unsigned short const *, unsigned short const *)

  3223 # ----------------------------------------------------------------------

  3224 #

  3225 # nsServiceManagerImpl (obsolete?)

  3226 #

  3228 <nsServiceManagerImpl>

  3229 __builtin_new

  3230 nsServiceManagerImpl::nsServiceManagerImpl(void)

  3231 NS_NewServiceManager(nsIServiceManager **)

  3233 <nsServiceManagerImpl>

  3234 PR_Malloc

  3235 PL_HashTableFinalize(PLHashTable *)

  3236 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3237 nsHashtable::nsHashtable(unsigned int, int)

  3238 nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)

  3239 nsServiceManagerImpl::nsServiceManagerImpl(void)

  3241 <nsServiceManagerImpl>

  3242 __builtin_new

  3243 nsHashtable::Put(nsHashKey *, void *)

  3244 nsServiceManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)

  3246 <nsServiceManagerImpl>

  3247 __builtin_new

  3248 nsServiceManagerImpl::nsServiceManagerImpl(void)

  3249 NS_NewServiceManager(nsIServiceManager **)

  3251 <nsServiceManagerImpl>

  3252 __builtin_new

  3253 nsServiceManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)

  3255 <nsServiceManagerImpl>

  3256 PR_Malloc

  3257 PL_HashTableFinalize(PLHashTable *)

  3258 PL_HashTableRawAdd

  3259 nsHashtable::Put(nsHashKey *, void *)

  3260 nsServiceManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *)

  3262 #----------------------------------------------------------------------

  3263 #

  3264 # nsXMLElement

  3265 #

  3267 <nsXMLElement>

  3268 __builtin_new

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

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

  3272 <nsXMLElement>

  3273 __builtin_new

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

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

  3277 <nsXMLElement>

  3278 __builtin_new

  3279 nsGenericContainerElement::SetAttr(nsINodeInfo *, nsAString const &, int)

  3280 nsXMLElement::SetAttr(nsINodeInfo *, nsAString const &, int)

  3282 <nsXMLElement>

  3283 PR_Malloc

  3284 nsMemoryImpl::Alloc(unsigned int)

  3285 nsMemory::Alloc(unsigned int)

  3286 nsStr::Alloc(nsStr &, unsigned int)

  3287 nsStr::Realloc(nsStr &, unsigned int)

  3288 nsStr::EnsureCapacity(nsStr &, unsigned int)

  3289 nsStr::GrowCapacity(nsStr &, unsigned int)

  3290 nsString::SetCapacity(unsigned int)

  3291 nsString::SetLength(unsigned int)

  3292 nsAString::do_AssignFromReadable(nsAString const &)

  3293 nsAString::AssignFromReadable(nsAString const &)

  3294 nsString::nsString(nsAString const &)

  3295 nsGenericContainerElement::SetAttr(nsINodeInfo *, nsAString const &, int)

  3296 nsXMLElement::SetAttr(nsINodeInfo *, nsAString const &, int)

  3298 <nsXMLElement>

  3299 PR_Malloc

  3300 nsVoidArray::SizeTo(int)

  3301 nsAutoVoidArray::SizeTo(int)

  3302 nsVoidArray::GrowArrayBy(int)

  3303 nsVoidArray::InsertElementAt(void *, int)

  3304 nsCheapVoidArray::AppendElement(void *)

  3305 nsGenericContainerElement::AppendChildTo(nsIContent *, int, int)

  3306 nsXMLContentSink::AddContentAsLeaf(nsIContent *)

  3308 #----------------------------------------------------------------------

  3309 #

  3310 # nsXMLDocument

  3311 #

  3313 <nsXMLDocument>

  3314 PR_Malloc

  3315 nsMemoryImpl::Alloc(unsigned int)

  3316 nsMemory::Alloc(unsigned int)

  3317 nsStr::Alloc(nsStr &, unsigned int)

  3318 nsStr::Realloc(nsStr &, unsigned int)

  3319 nsStr::EnsureCapacity(nsStr &, unsigned int)

  3320 nsStr::GrowCapacity(nsStr &, unsigned int)

  3321 nsString::SetCapacity(unsigned int)

  3322 nsString::SetLength(unsigned int)

  3323 nsAString::do_AssignFromReadable(nsAString const &)

  3324 nsAString::AssignFromReadable(nsAString const &)

  3325 nsDocument::nsDocument(void)

  3326 nsMarkupDocument::nsMarkupDocument(void)

  3327 nsXMLDocument::nsXMLDocument(void)

  3329 <nsXMLDocument>

  3330 PR_Malloc

  3331 nsMemoryImpl::Alloc(unsigned int)

  3332 nsMemory::Alloc(unsigned int)

  3333 nsStr::Alloc(nsStr &, unsigned int)

  3334 nsStr::Realloc(nsStr &, unsigned int)

  3335 nsStr::EnsureCapacity(nsStr &, unsigned int)

  3336 nsStr::GrowCapacity(nsStr &, unsigned int)

  3337 nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)

  3338 nsString::AppendWithConversion(char const *, int)

  3339 nsString::AssignWithConversion(char const *)

  3340 nsDocument::StartDocumentLoad(char const *, nsIChannel *, nsILoadGroup *, nsISupports *, nsIStreamListener **, int)

  3341 nsXMLDocument::StartDocumentLoad(char const *, nsIChannel *, nsILoadGroup *, nsISupports *, nsIStreamListener **, int)

  3343 #----------------------------------------------------------------------

  3345 <nsGCCache>

  3346 __builtin_new

  3347 nsGCCache::nsGCCache(void)

  3349 #----------------------------------------------------------------------

  3350 #

  3351 # prefs

  3352 #

  3354 <nsPref>

  3355 _init

  3356 PL_HashTableRawAdd

  3357 PL_HashTableAdd

  3358 pref_HashPref

  3360 <nsPref>

  3361 _init

  3362 PL_NewHashTable

  3363 PREF_Init

  3365 <nsPref>

  3366 pref_HashPref

  3368 <nsPref>

  3369 PR_Malloc

  3370 PL_HashTableFinalize(PLHashTable *)

  3371 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3372 nsHashtable::nsHashtable(unsigned int, int)

  3373 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  3374 nsPref::nsPref(void)

  3376 <nsPref>

  3377 PREF_RegisterCallback

  3379 <nsPref>

  3380 PR_Malloc

  3381 nsMemoryImpl::Alloc(unsigned int)

  3382 nsMemory::Alloc(unsigned int)

  3383 nsStr::Alloc(nsStr &, unsigned int)

  3384 nsStr::Realloc(nsStr &, unsigned int)

  3385 nsStr::EnsureCapacity(nsStr &, unsigned int)

  3386 nsStr::GrowCapacity(nsStr &, unsigned int)

  3387 nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)

  3388 nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)

  3389 nsCString::nsCString(nsCString const &)

  3390 nsTArray<nsCString>::InsertElementAt(int, nsCString const &)

  3391 nsPrefBranch::AddObserver(char const *, nsIObserver *)

  3393 #----------------------------------------------------------------------

  3395 <nsThread>

  3396 PR_Calloc

  3397 PR_SetThreadPrivate

  3398 nsThread::RegisterThreadSelf(void)

  3400 <nsFontGTK>

  3401 XFreeFont

  3403 <nsFontGTK>

  3404 __builtin_new

  3405 nsFontGTK::operator new(unsigned int)

  3407 <nsGenericContainerElement>

  3408 __builtin_new

  3409 nsCheapVoidArray::SwitchToVector(void)

  3410 nsCheapVoidArray::AppendElement(void *)

  3411 nsGenericContainerElement::AppendChildTo(nsIContent *, int)

  3413 <nsGenericContainerElement>

  3414 PR_Realloc

  3415 nsVoidArray::SizeTo(int)

  3416 nsAutoVoidArray::SizeTo(int)

  3417 nsVoidArray::GrowArrayBy(int)

  3418 nsVoidArray::InsertElementAt(void *, int)

  3419 nsCheapVoidArray::AppendElement(void *)

  3420 nsGenericContainerElement::AppendChildTo(nsIContent *, int, int)

  3422 #----------------------------------------------------------------------

  3423 #

  3424 # nsObserverService

  3425 #

  3427 <nsObserverService>

  3428 PR_Malloc

  3429 PL_HashTableFinalize(PLHashTable *)

  3430 PL_HashTableRawAdd

  3431 nsHashtable::Put(nsHashKey *, void *)

  3432 nsObserverService::GetObserverList(unsigned short const *, nsIObserverList **)

  3434 <nsObserverService>

  3435 PR_Malloc

  3436 PL_HashTableFinalize(PLHashTable *)

  3437 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3438 nsHashtable::nsHashtable(unsigned int, int)

  3439 nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)

  3440 nsObserverService::GetObserverList(unsigned short const *, nsIObserverList **)

  3442 <nsObserverService>

  3443 __builtin_new

  3444 nsStringKey::Clone(void) const

  3445 nsHashtable::Put(nsHashKey *, void *)

  3446 nsObserverService::GetObserverList(nsString const &, nsIObserverList **)

  3448 <nsObserverService>

  3449 PR_Malloc

  3450 PL_HashTableFinalize(PLHashTable *)

  3451 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3452 nsHashtable::nsHashtable(unsigned int, int)

  3453 nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)

  3454 nsObserverService::GetObserverList(nsString const &, nsIObserverList **)

  3456 <nsObserverService>

  3457 __builtin_new

  3458 NS_NewObserverList(nsIObserverList **)

  3459 nsObserverService::GetObserverList(nsString const &, nsIObserverList **)

  3461 <nsObserverService>

  3462 __builtin_new

  3463 nsObserverService::GetObserverList(nsString const &, nsIObserverList **)

  3465 <nsObserverService>

  3466 PR_Malloc

  3467 PL_HashTableFinalize(PLHashTable *)

  3468 PL_HashTableRawAdd

  3469 nsHashtable::Put(nsHashKey *, void *)

  3470 nsObserverService::GetObserverList(nsString const &, nsIObserverList **)

  3472 <nsObserverService>

  3473 PR_Malloc

  3474 PL_HashTableFinalize(PLHashTable *)

  3475 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3476 nsHashtable::nsHashtable(unsigned int, int)

  3477 nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)

  3478 nsObserverService::GetObserverList(char const *, nsObserverList **)

  3480 <nsObserverService>

  3481 __builtin_new

  3482 __builtin_vec_new

  3483 nsSupportsArray::GrowArrayBy(int)

  3484 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  3485 nsSupportsArray::AppendElement(nsISupports *)

  3486 nsObserverList::AddObserver(nsIObserver *, int)

  3488 #----------------------------------------------------------------------

  3490 <nsViewManager>

  3491 PR_Malloc

  3492 PL_HashTableFinalize(PLHashTable *)

  3493 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3494 nsHashtable::nsHashtable(unsigned int, int)

  3495 nsViewManager::nsViewManager(void)

  3497 <nsViewManager2>

  3498 __builtin_new

  3499 nsViewManager2::AddToDisplayList(int *, nsView *, nsRect &, nsRect &, unsigned int, int, int)

  3501 # ----------------------------------------------------------------------

  3502 #

  3503 # nsBindingManager

  3504 #

  3506 <nsBindingManager>

  3507 PR_Malloc

  3508 PL_HashTableFinalize(PLHashTable *)

  3509 PL_HashTableRawAdd

  3510 nsHashtable::Put(nsHashKey *, void *)

  3511 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3512 nsBindingManager::SetContentListFor(nsIContent *, nsISupportsArray *)

  3514 <nsBindingManager>

  3515 PR_Malloc

  3516 PL_HashTableFinalize(PLHashTable *)

  3517 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3518 nsHashtable::nsHashtable(unsigned int, int)

  3519 nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)

  3521 <nsBindingManager>

  3522 PR_Malloc

  3523 PL_HashTableFinalize(PLHashTable *)

  3524 PL_HashTableRawAdd

  3525 nsHashtable::Put(nsHashKey *, void *)

  3526 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3527 nsBindingManager::SetAnonymousNodesFor(nsIContent *, nsISupportsArray *)

  3529 <nsBindingManager>

  3530 __builtin_new

  3531 nsISupportsKey::Clone(void) const

  3532 nsHashtable::Put(nsHashKey *, void *)

  3533 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3534 nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)

  3536 <nsBindingManager>

  3537 __builtin_new

  3538 nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)

  3540 <nsBindingManager>

  3541 __builtin_new

  3542 nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)

  3544 <nsBindingManager>

  3545 PR_Malloc

  3546 PL_HashTableFinalize(PLHashTable *)

  3547 PL_HashTableRawAdd

  3548 nsHashtable::Put(nsHashKey *, void *)

  3549 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3550 nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)

  3552 <nsBindingManager>

  3553 PR_Malloc

  3554 PL_HashTableFinalize(PLHashTable *)

  3555 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3556 nsHashtable::nsHashtable(unsigned int, int)

  3557 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  3558 nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *)

  3560 <nsBindingManager>

  3561 PR_Malloc

  3562 PL_HashTableFinalize(PLHashTable *)

  3563 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3564 nsHashtable::nsHashtable(unsigned int, int)

  3565 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  3566 nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)

  3568 <nsBindingManager>

  3569 PR_Malloc

  3570 PL_HashTableFinalize(PLHashTable *)

  3571 PL_HashTableRawAdd

  3572 nsHashtable::Put(nsHashKey *, void *)

  3573 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3574 nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *)

  3576 <nsBindingManager>

  3577 PR_Malloc

  3578 PL_HashTableFinalize(PLHashTable *)

  3579 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3580 nsHashtable::nsHashtable(unsigned int, int)

  3581 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  3582 nsBindingManager::SetWrappedJS(nsIContent *, nsIXPConnectWrappedJS *)

  3584 <nsBindingManager>

  3585 __builtin_new

  3586 __builtin_vec_new

  3587 nsSupportsArray::GrowArrayBy(int)

  3588 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  3589 nsSupportsArray::AppendElement(nsISupports *)

  3590 nsBindingManager::AddToAttachedQueue(nsIXBLBinding *)

  3592 # ----------------------------------------------------------------------

  3594 <NameSpaceManagerImpl>

  3595 PR_Malloc

  3596 nsMemoryImpl::Alloc(unsigned int)

  3597 nsMemory::Alloc(unsigned int)

  3598 nsStr::Alloc(nsStr &, unsigned int)

  3599 nsStr::Realloc(nsStr &, unsigned int)

  3600 nsStr::EnsureCapacity(nsStr &, unsigned int)

  3601 nsStr::GrowCapacity(nsStr &, unsigned int)

  3602 nsString::SetCapacity(unsigned int)

  3603 nsString::SetLength(unsigned int)

  3604 nsAString::do_AssignFromReadable(nsAString const &)

  3605 nsAString::AssignFromReadable(nsAString const &)

  3606 nsString::nsString(nsAString const &)

  3607 NameSpaceManagerImpl::RegisterNameSpace(nsAString const &, int &)

  3609 <NameSpaceManagerImpl>

  3610 __builtin_new

  3611 nsStringKey::Clone(void) const

  3612 nsHashtable::Put(nsHashKey *, void *)

  3613 nsLayoutUtils::GetDynamicScriptContext(JSContext *, nsIScriptContext **)

  3614 NameSpaceManagerImpl::NameSpaceManagerImpl(void)

  3616 <NameSpaceManagerImpl>

  3617 __builtin_new

  3618 nsStringKey::Clone(void) const

  3619 nsHashtable::Put(nsHashKey *, void *)

  3620 NameSpaceManagerImpl::RegisterNameSpace(basic_nsAReadableString<unsigned short> const &, int &)

  3622 <NameSpaceManagerImpl>

  3623 PR_Malloc

  3624 nsMemoryImpl::Alloc(unsigned int)

  3625 nsMemory::Alloc(unsigned int)

  3626 nsStr::Alloc(nsStr &, unsigned int)

  3627 nsStr::Realloc(nsStr &, unsigned int)

  3628 nsStr::EnsureCapacity(nsStr &, unsigned int)

  3629 nsStr::GrowCapacity(nsStr &, unsigned int)

  3630 nsStr::StrAppend(nsStr &, nsStr const &, unsigned int, int)

  3631 nsStr::StrAssign(nsStr &, nsStr const &, unsigned int, int)

  3632 nsString::nsString(nsString const &)

  3633 nsLayoutUtils::CopyNewlineNormalizedUnicodeTo(nsReadingIterator<unsigned short> &, nsReadingIterator<unsigned short> const &, basic_nsAWritableString<unsigned short> &)

  3634 NameSpaceManagerImpl::NameSpaceManagerImpl(void)

  3636 <nsErrorService>

  3637 __builtin_new

  3638 nsErrorService::Create(nsISupports *, nsID const &, void **)

  3640 <nsErrorService>

  3641 __builtin_new

  3642 nsVoidKey::Clone(void) const

  3643 nsHashtable::Put(nsHashKey *, void *)

  3644 nsInt2StrHashtable::Put(unsigned int, char const *)

  3645 nsErrorService::RegisterErrorStringBundleKey(unsigned int, char const *)

  3647 <nsErrorService>

  3648 PR_Malloc

  3649 PL_HashTableFinalize(PLHashTable *)

  3650 PL_HashTableRawAdd

  3651 nsHashtable::Put(nsHashKey *, void *)

  3652 nsInt2StrHashtable::Put(unsigned int, char const *)

  3653 nsErrorService::RegisterErrorStringBundleKey(unsigned int, char const *)

  3655 <nsDocument>

  3656 __builtin_new

  3657 ArenaImpl::Create(nsISupports *, nsID const &, void **)

  3658 NS_NewHeapArena(nsIArena **, unsigned int)

  3659 nsDocument::Init(void)

  3661 <nsDocument>

  3662 PR_Malloc

  3663 PL_HashTableFinalize(PLHashTable *)

  3664 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3665 nsHashtable::nsHashtable(unsigned int, int)

  3666 nsDocument::nsDocument(void)

  3668 <nsDocument>

  3669 __builtin_new

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

  3672 <nsDocument::mContentWrapperHash>

  3673 PR_Malloc

  3674 PL_HashTableFinalize(PLHashTable *)

  3675 PL_HashTableRawAdd

  3676 nsHashtable::Put(nsHashKey *, void *)

  3677 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3678 nsDocument::AddReference(void *, nsISupports *)

  3680 <nsDocHeaderData>

  3681 PR_Malloc

  3682 nsMemoryImpl::Alloc(unsigned int)

  3683 nsMemory::Alloc(unsigned int)

  3684 nsStr::Alloc(nsStr &, unsigned int)

  3685 nsStr::Realloc(nsStr &, unsigned int)

  3686 nsStr::EnsureCapacity(nsStr &, unsigned int)

  3687 nsStr::GrowCapacity(nsStr &, unsigned int)

  3688 nsString::SetCapacity(unsigned int)

  3689 nsString::SetLength(unsigned int)

  3690 ~.*

  3691 ~.*

  3692 basic_nsAWritableString<unsigned short>::Assign(basic_nsAReadableString<unsigned short> const &)

  3693 nsDocHeaderData::nsDocHeaderData(nsIAtom *, basic_nsAReadableString<unsigned short> const &)

  3695 <XPCContext>

  3696 __builtin_new

  3697 XPCContext::newXPCContext(XPCJSRuntime *, JSContext *)

  3699 <nsEventQueueService>

  3700 __builtin_new

  3701 nsEventQueueServiceImpl::Create(nsISupports *, nsID const &, void **)

  3703 <nsEventQueueService>

  3704 PR_Malloc

  3705 PL_HashTableFinalize(PLHashTable *)

  3706 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3707 nsHashtable::nsHashtable(unsigned int, int)

  3708 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  3709 nsEventQueueServiceImpl::nsEventQueueServiceImpl(void)

  3711 <nsEventListenerManager>

  3712 PR_Realloc

  3713 nsVoidArray::SizeTo(int)

  3714 nsAutoVoidArray::SizeTo(int)

  3715 nsVoidArray::GrowArrayBy(int)

  3716 nsVoidArray::InsertElementAt(void *, int)

  3717 nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)

  3719 <nsEventListenerManager>

  3720 PR_Malloc

  3721 nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)

  3722 nsEventListenerManager::SetJSEventListener(nsIScriptContext *, nsISupports *, nsIAtom *, int)

  3723 nsEventListenerManager::AddScriptEventListener(nsIScriptContext *, nsISupports *, nsIAtom *, nsAString const &, int)

  3725 <nsEventListenerManager>

  3726 PR_Malloc

  3727 nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)

  3728 nsEventListenerManager::AddEventListenerByType(nsIDOMEventListener *, nsAString const &, int)

  3730 <nsEventListenerManager>

  3731 PR_Malloc

  3732 nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int)

  3733 nsEventListenerManager::AddEventListenerByIID(nsIDOMEventListener *, nsID const &, int)

  3735 <nsEventListenerManager>

  3736 PR_Malloc

  3737 nsVoidArray::SizeTo(int)

  3738 nsAutoVoidArray::SizeTo(int)

  3739 nsVoidArray::GrowArrayBy(int)

  3740 nsVoidArray::ReplaceElementAt(void *, int)

  3741 nsEventListenerManager::GetListenersByType(EventArrayType, nsHashKey *, int)

  3743 <nsEventListenerManager>

  3744 PR_Malloc

  3745 nsVoidArray::SizeTo(int)

  3746 nsAutoVoidArray::SizeTo(int)

  3747 nsVoidArray::GrowArrayBy(int)

  3748 nsVoidArray::ReplaceElementAt(void *, int)

  3749 nsEventListenerManager::GetListenersByType(EventArrayType, nsHashKey *, int)

  3751 <nsEventListenerManager>

  3752 __builtin_new

  3753 nsEventListenerManager::AddEventListener(nsIDOMEventListener *, nsID const &, int, int)

  3755 <nsEventListenerManager>

  3756 PR_Malloc

  3757 nsEventListenerManager::AddEventListener(nsIDOMEventListener *, nsID const &, int, int)

  3759 <nsCParserNode>

  3760 __builtin_new

  3761 nsCParserNode::AddAttribute(CToken *)

  3763 <nsCParserNode>

  3764 __builtin_new

  3765 __builtin_vec_new

  3766 nsDeque::GrowCapacity(void)

  3767 nsDeque::Push(void *)

  3768 nsCParserNode::AddAttribute(CToken *)

  3770 <nsSocketTransportService>

  3771 PR_Malloc

  3772 nsSocketTransportService::Init(void)

  3774 <nsSocketTransport>

  3775 PR_Malloc

  3776 nsSocketTransport::AsyncWrite(nsIInputStream *, nsIStreamObserver *, nsISupports *)

  3778 <nsSocketTransport>

  3779 PR_Malloc

  3780 _PR_Getfd

  3781 PR_GetConnectStatus

  3782 PR_Socket

  3783 PR_OpenTCPSocket

  3784 nsSocketTransport::doConnection(short)

  3786 <CompositeDataSourceImpl>

  3787 PR_Malloc

  3788 PL_ArenaAllocate

  3789 nsFixedSizeAllocator::AddBucket(unsigned int)

  3790 nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)

  3791 CompositeDataSourceImpl::CompositeDataSourceImpl(void)

  3793 <CompositeDataSourceImpl>

  3794 PR_Malloc

  3795 PL_ArenaAllocate

  3796 nsFixedSizeAllocator::Alloc(unsigned int)

  3797 CompositeDataSourceImpl::GetTargets(nsIRDFResource *, nsIRDFResource *, int, nsISimpleEnumerator **)

  3799 <CompositeDataSourceImpl>

  3800 PR_Malloc

  3801 PL_ArenaAllocate

  3802 nsFixedSizeAllocator::Alloc(unsigned int)

  3803 CompositeDataSourceImpl::ArcLabelsIn(nsIRDFNode *, nsISimpleEnumerator **)

  3805 <CompositeDataSourceImpl>

  3806 PR_Malloc

  3807 PL_ArenaAllocate

  3808 nsFixedSizeAllocator::Alloc(unsigned int)

  3809 CompositeDataSourceImpl::ArcLabelsOut(nsIRDFResource *, nsISimpleEnumerator **)

  3811 # ----------------------------------------------------------------------

  3812 #

  3813 # nsHTMLValue

  3814 #

  3816 <nsHTMLValue>

  3817 PR_Malloc

  3818 nsMemoryImpl::Alloc(unsigned int)

  3819 nsMemory::Alloc(unsigned int)

  3820 unsigned short * AllocateStringCopy<unsigned short, unsigned short>(basic_nsAReadableString<unsigned short> const &, unsigned short *)

  3821 ToNewUnicode(basic_nsAReadableString<unsigned short> const &)

  3822 nsHTMLValue::nsHTMLValue(basic_nsAReadableString<unsigned short> const &, nsHTMLUnit)

  3824 <nsHTMLValue>

  3825 PR_Malloc

  3826 nsMemoryImpl::Alloc(unsigned int)

  3827 nsMemory::Alloc(unsigned int)

  3828 ToNewUnicode(nsAString const &)

  3829 nsHTMLValue::SetStringValue(nsAString const &, nsHTMLUnit)

  3831 <nsHTMLValue>

  3832 PR_Malloc

  3833 nsMemoryImpl::Alloc(unsigned int)

  3834 nsMemory::Alloc(unsigned int)

  3835 unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)

  3836 ToNewUnicode(nsAString const &)

  3837 nsHTMLValue::nsHTMLValue(nsAString const &, nsHTMLUnit)

  3839 <nsHTMLValue>

  3840 PR_Malloc

  3841 nsMemoryImpl::Alloc(unsigned int)

  3842 nsMemory::Alloc(unsigned int)

  3843 unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)

  3844 ToNewUnicode(nsAString const &)

  3845 nsHTMLValue::SetStringValue(nsAString const &, nsHTMLUnit)

  3847 # ----------------------------------------------------------------------

  3849 <nsMemCache>

  3850 PR_Malloc

  3851 PL_HashTableFinalize(PLHashTable *)

  3852 PL_HashTableRawAdd

  3853 nsHashtable::Put(nsHashKey *, void *)

  3854 nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)

  3856 <nsMemCache>

  3857 PR_Malloc

  3858 PL_HashTableFinalize(PLHashTable *)

  3859 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3860 nsHashtable::nsHashtable(unsigned int, int)

  3861 nsMemCache::Init(void)

  3863 <nsMemCache>

  3864 __builtin_new

  3865 nsOpaqueKey::Clone(void) const

  3866 nsHashtable::Put(nsHashKey *, void *)

  3867 nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)

  3869 <nsMemCache>

  3870 PR_Malloc

  3871 nsMemoryImpl::Alloc(unsigned int)

  3872 nsMemory::Alloc(unsigned int)

  3873 nsOpaqueKey::Clone(void) const

  3874 nsHashtable::Put(nsHashKey *, void *)

  3875 nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)

  3877 <nsMemCache>

  3878 __builtin_new

  3879 nsOpaqueKey::Clone(void) const

  3880 nsHashtable::Put(nsHashKey *, void *)

  3881 nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)

  3883 <nsMemCache>

  3884 PR_Malloc

  3885 nsMemoryImpl::Alloc(unsigned int)

  3886 nsMemory::Alloc(unsigned int)

  3887 nsOpaqueKey::Clone(void) const

  3888 nsHashtable::Put(nsHashKey *, void *)

  3889 nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **)

  3891 <nsMemCacheRecord>

  3892 __builtin_new

  3893 __builtin_vec_new

  3894 nsMemCacheRecord::SetMetaData(unsigned int, char const *)

  3896 <nsMemCacheRecord>

  3897 __builtin_new

  3898 __builtin_vec_new

  3899 nsMemCacheRecord::Init(char const *, unsigned int, unsigned int, nsMemCache *)

  3901 <nsTextFormatter>

  3902 PR_Realloc

  3903 nsXPIDLString type_info function

  3904 nsXPIDLString type_info function

  3905 nsTextFormatter::vsmprintf(unsigned short const *, void *)

  3906 nsTextFormatter::smprintf(unsigned short const *,...)

  3908 <nsTextFormatter>

  3909 PR_Malloc

  3910 nsXPIDLString type_info function

  3911 nsXPIDLString type_info function

  3912 nsTextFormatter::vsmprintf(unsigned short const *, void *)

  3914 <nsTextFormatter>

  3915 PR_Realloc

  3916 nsXPIDLString type_info function

  3917 nsXPIDLString type_info function

  3918 nsTextFormatter::vsmprintf(unsigned short const *, void *)

  3920 #----------------------------------------------------------------------

  3921 #

  3922 # nsPresContext

  3923 #

  3925 <nsPresContext>

  3926 PR_Malloc

  3927 PL_HashTableFinalize(PLHashTable *)

  3928 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3929 nsHashtable::nsHashtable(unsigned int, int)

  3930 nsPresContext::nsPresContext(void)

  3932 <nsPresContext>

  3933 PR_Malloc

  3934 PL_HashTableFinalize(PLHashTable *)

  3935 PL_HashTableRawAdd

  3936 nsHashtable::Put(nsHashKey *, void *)

  3937 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3938 nsPresContext::LoadImage(nsString const &, nsIFrame *, imgIRequest **)

  3940 #----------------------------------------------------------------------

  3941 #

  3942 # nsPresState

  3943 #

  3945 <nsPresState>

  3946 __builtin_new

  3947 nsPresState::SetStateProperty(nsAString const &, nsAString const &)

  3949 <nsPresState>

  3950 __builtin_new

  3951 nsPresState::SetStatePropertyAsSupports(nsAString const &, nsISupports *)

  3953 <nsPresState>

  3954 PR_Malloc

  3955 PL_HashTableFinalize(PLHashTable *)

  3956 PL_HashTableRawAdd

  3957 nsHashtable::Put(nsHashKey *, void *)

  3958 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3959 nsPresState::SetStatePropertyAsSupports(basic_nsAReadableString<unsigned short> const &, nsISupports *)

  3961 <nsPresState>

  3962 PR_Malloc

  3963 PL_HashTableFinalize(PLHashTable *)

  3964 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3965 nsHashtable::nsHashtable(unsigned int, int)

  3966 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  3967 nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)

  3969 <nsPresState>

  3970 PR_Malloc

  3971 PL_HashTableFinalize(PLHashTable *)

  3972 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  3973 nsHashtable::nsHashtable(unsigned int, int)

  3974 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  3975 nsPresState::SetStatePropertyAsSupports(basic_nsAReadableString<unsigned short> const &, nsISupports *)

  3977 <nsPresState>

  3978 PR_Malloc

  3979 PL_HashTableFinalize(PLHashTable *)

  3980 PL_HashTableRawAdd

  3981 nsHashtable::Put(nsHashKey *, void *)

  3982 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3983 nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)

  3985 <nsPresState>

  3986 PR_Malloc

  3987 nsMemoryImpl::Alloc(unsigned int)

  3988 nsMemory::Alloc(unsigned int)

  3989 nsSupportsWStringImpl::SetDataWithLength(unsigned int, unsigned short const *)

  3990 nsSupportsWStringImpl::SetData(unsigned short const *)

  3991 nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)

  3993 <nsPresState>

  3994 __builtin_new

  3995 nsStringKey::Clone(void) const

  3996 nsHashtable::Put(nsHashKey *, void *)

  3997 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  3998 nsPresState::SetStatePropertyAsSupports(basic_nsAReadableString<unsigned short> const &, nsISupports *)

  4000 <nsPresState>

  4001 __builtin_new

  4002 nsStringKey::Clone(void) const

  4003 nsHashtable::Put(nsHashKey *, void *)

  4004 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4005 nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)

  4007 <nsPresState>

  4008 PR_Malloc

  4009 nsMemoryImpl::Alloc(unsigned int)

  4010 nsMemory::Alloc(unsigned int)

  4011 nsSupportsWStringImpl::SetDataWithLength(unsigned int, unsigned short const *)

  4012 nsSupportsWStringImpl::SetData(unsigned short const *)

  4013 nsPresState::SetStateProperty(basic_nsAReadableString<unsigned short> const &, basic_nsAReadableString<unsigned short> const &)

  4015 <nsPresState>

  4016 PR_Malloc

  4017 PL_HashTableFinalize(PLHashTable *)

  4018 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4019 nsHashtable::nsHashtable(unsigned int, int)

  4020 nsPresState::SetStateProperty(nsAString const &, nsAString const &)

  4022 <nsPresState>

  4023 PR_Malloc

  4024 PL_HashTableFinalize(PLHashTable *)

  4025 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4026 nsHashtable::nsHashtable(unsigned int, int)

  4027 nsPresState::SetStatePropertyAsSupports(nsAString const &, nsISupports *)

  4029 <nsPresState>

  4030 PR_Malloc

  4031 PL_HashTableFinalize(PLHashTable *)

  4032 PL_HashTableRawAdd

  4033 nsHashtable::Put(nsHashKey *, void *)

  4034 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4035 nsPresState::SetStateProperty(nsAString const &, nsAString const &)

  4037 <nsPresState>

  4038 PR_Malloc

  4039 PL_HashTableFinalize(PLHashTable *)

  4040 PL_HashTableRawAdd

  4041 nsHashtable::Put(nsHashKey *, void *)

  4042 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4043 nsPresState::SetStatePropertyAsSupports(nsAString const &, nsISupports *)

  4045 <nsPresState>

  4046 PR_Malloc

  4047 nsMemoryImpl::Alloc(unsigned int)

  4048 nsMemory::Alloc(unsigned int)

  4049 nsSupportsStringImpl::SetDataWithLength(unsigned int, char const *)

  4050 nsSupportsStringImpl::SetData(char const *)

  4051 nsPresState::SetStateProperty(nsAString const &, nsAString const &)

  4053 # ----------------------------------------------------------------------

  4054 #

  4055 # Prefs stuff

  4056 #

  4058 <prefs-unclassified>

  4059 PL_strdup

  4060 pref_HashPref

  4062 <prefs-unclassified>

  4063 PL_strdup

  4064 PREF_LockPref

  4066 <prefs-unclassified>

  4067 PL_strdup

  4068 PREF_RegisterCallback

  4070 #----------------------------------------------------------------------

  4071 #

  4072 # Imagelib Stuff

  4073 #

  4075 <imgRequest>

  4076 PR_Malloc

  4077 nsVoidArray::SizeTo(int)

  4078 nsVoidArray::GrowArrayBy(int)

  4079 nsVoidArray::InsertElementAt(void *, int)

  4080 imgRequest::AddProxy(imgRequestProxy *)

  4082 <ImageRequestImpl>

  4083 __builtin_new

  4084 ImageRequestImpl::AddObserver(nsIImageRequestObserver *)

  4086 <ImageRequestImpl>

  4087 PR_Malloc

  4088 XP_AddObserver

  4089 ImageRequestImpl::Init(void *, char const *, nsIImageRequestObserver *, unsigned int const *, unsigned int, unsigned int, unsigned int, ilINetContext *)

  4091 <imglib-unclassified>

  4092 __builtin_new

  4093 ImageNetContextImpl::GetURL(ilIURL *, ImgCachePolicy, ilINetReader *, int)

  4095 # il_group_notify() is really a call to a static rounting il_init_scaling()

  4096 <imglib-scaling>

  4097 PR_Malloc

  4098 il_group_notify(_IL_GroupContext *, long)

  4099 il_size(il_container_struct *)

  4100 ImgDCallbk::ImgDCBImageSize(void)

  4102 <imglib-gifdecode>

  4103 PR_Calloc

  4104 il_gif_write(il_container_struct *, unsigned char const *, int)

  4106 <imglib-gifdecode>

  4107 PR_Malloc

  4108 il_gif_write(il_container_struct *, unsigned char const *, int)

  4110 <gif_struct>

  4111 PR_Calloc

  4112 il_gif_init(il_container_struct *)

  4114 <IL_ImageReq>

  4115 PR_Calloc

  4116 IL_GetImage

  4118 <imglib-container-stuff>

  4119 PR_Calloc

  4120 il_get_container(_IL_GroupContext *, ImgCachePolicy, char const *, _NI_IRGB *, IL_DitherMode, int, int, int)

  4122 <IL_ColorSpace>

  4123 PR_Calloc

  4124 IL_CreateTrueColorSpace

  4126 <IL_Pixmap>

  4127 PR_Calloc

  4128 il_size(il_container_struct *)

  4129 ImgDCallbk::ImgDCBImageSize(void)

  4131 <IL_ColorSpace>

  4132 PR_Calloc

  4133 IL_CreateGreyScaleColorSpace

  4135 <imglib-gifcompat>

  4136 PR_Malloc

  4137 il_BACat(char **, unsigned int, char const *, unsigned int)

  4139 <imglib-gifcompat>

  4140 PR_Realloc

  4141 il_BACat(char **, unsigned int, char const *, unsigned int)

  4143 <ImageConsumer>

  4144 PR_Malloc

  4145 ImageConsumer::OnStartRequest(nsIChannel *, nsISupports *)

  4147 # These are really called from `static' routines in ilclient.cpp,

  4148 # *not* ImgDCallbk::CreateInstance()

  4149 <imglib-list>

  4150 PR_Calloc

  4151 ImgDCallbk::CreateInstance(nsID const &, il_container_struct *, nsID const &, void **)

  4153 #----------------------------------------------------------------------

  4155 <nsImageGTK>

  4156 __builtin_new

  4157 __builtin_vec_new

  4158 nsImageGTK::Init(int, int, int, nsMaskRequirements)

  4160 #----------------------------------------------------------------------

  4161 #

  4162 # nsLayoutHistoryState

  4163 #

  4165 <nsLayoutHistoryState>

  4166 PR_Malloc

  4167 PL_HashTableFinalize(PLHashTable *)

  4168 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4169 nsHashtable::nsHashtable(unsigned int, int)

  4170 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  4171 nsLayoutHistoryState::nsLayoutHistoryState(void)

  4173 <nsLayoutHistoryState>

  4174 PR_Malloc

  4175 PL_HashTableFinalize(PLHashTable *)

  4176 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4177 nsHashtable::nsHashtable(unsigned int, int)

  4178 nsLayoutHistoryState::nsLayoutHistoryState(void)

  4180 <nsLayoutHistoryState>

  4181 PR_Malloc

  4182 PL_HashTableFinalize(PLHashTable *)

  4183 PL_HashTableRawAdd

  4184 nsHashtable::Put(nsHashKey *, void *)

  4185 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4186 nsLayoutHistoryState::AddState(unsigned int, nsIPresState *, nsIStatefulFrame::StateType)

  4188 <nsLayoutHistoryState>

  4189 __builtin_new

  4190 nsVoidKey::Clone(void) const

  4191 nsHashtable::Put(nsHashKey *, void *)

  4192 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4193 nsLayoutHistoryState::AddState(unsigned int, nsIPresState *, nsIStatefulFrame::StateType)

  4195 <nsLayoutHistoryState>

  4196 PR_Malloc

  4197 nsMemoryImpl::Alloc(unsigned int)

  4198 nsMemory::Alloc(unsigned int)

  4199 nsCStringKey::Clone(void) const

  4200 nsHashtable::Put(nsHashKey *, void *)

  4201 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4202 nsLayoutHistoryState::AddState(nsCString const &, nsIPresState *)

  4204 <nsLayoutHistoryState>

  4205 PR_Malloc

  4206 PL_HashTableFinalize(PLHashTable *)

  4207 PL_HashTableRawAdd

  4208 nsHashtable::Put(nsHashKey *, void *)

  4209 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4210 nsLayoutHistoryState::AddState(nsCString const &, nsIPresState *)

  4212 # ----------------------------------------------------------------------

  4213 #

  4214 # nsCookieService

  4215 #

  4217 <nsCookieService>

  4218 PR_Realloc

  4219 Local_SACat(char **, char const *)

  4220 COOKIE_GetCookie(char *)

  4222 <nsCookieService>

  4223 PR_Malloc

  4224 cookie_IsFromHost(_cookie_CookieStruct *, char *)

  4226 <nsCookieService>

  4227 PR_Malloc

  4228 nsMemoryImpl::Alloc(unsigned int)

  4229 nsMemory::Alloc(unsigned int)

  4230 ToNewCString(nsAString const &)

  4231 COOKIE_Read(void)

  4232 nsCookieService::Init(void)

  4234 # ----------------------------------------------------------------------

  4236 <nsReplacementPolicy>

  4237 PR_Realloc

  4238 nsMemoryImpl::Realloc(void *, unsigned int)

  4239 nsMemory::Realloc(void *, unsigned int)

  4240 nsReplacementPolicy::AssociateCacheEntryWithRecord(nsINetDataCacheRecord *, nsINetDataCache *, nsCachedNetData **)

  4242 <nsReplacementPolicy>

  4243 PR_Malloc

  4244 nsMemoryImpl::Alloc(unsigned int)

  4245 nsMemory::Alloc(unsigned int)

  4246 nsReplacementPolicy::Init(unsigned int)

  4248 <nsHTTPHeaderArray>

  4249 PR_Malloc

  4250 nsMemoryImpl::Alloc(unsigned int)

  4251 nsMemory::Alloc(unsigned int)

  4252 nsStr::Alloc(nsStr &, unsigned int)

  4253 nsStr::Realloc(nsStr &, unsigned int)

  4254 nsStr::EnsureCapacity(nsStr &, unsigned int)

  4255 nsStr::GrowCapacity(nsStr &, unsigned int)

  4256 nsCString::SetCapacity(unsigned int)

  4257 nsCString::SetLength(unsigned int)

  4258 nsACString::do_AssignFromReadable(nsACString const &)

  4259 nsACString::do_AssignFromElementPtr(char const *)

  4260 nsHttpHeaderArray::SetHeader(nsHttpAtom, char const *)

  4262 <nsHTTPHandler>

  4263 PR_Malloc

  4264 PL_HashTableFinalize(PLHashTable *)

  4265 PL_HashTableRawAdd

  4266 nsHashtable::Put(nsHashKey *, void *)

  4267 nsHTTPHandler::SetServerCapabilities(char const *, int, unsigned int)

  4269 <nsHTTPHandler>

  4270 PR_Malloc

  4271 PL_HashTableFinalize(PLHashTable *)

  4272 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4273 nsHashtable::nsHashtable(unsigned int, int)

  4274 nsHTTPHandler::nsHTTPHandler(void)

  4276 <nsHTTPHandler>

  4277 __builtin_new

  4278 nsCStringKey::Clone(void) const

  4279 nsHashtable::Put(nsHashKey *, void *)

  4280 nsHTTPHandler::SetServerCapabilities(char const *, int, unsigned int)

  4282 <nsCachedNetData>

  4283 PR_Malloc

  4284 PL_ArenaAllocate

  4285 ArenaImpl::Alloc(unsigned int)

  4286 nsCachedNetData::operator new(unsigned int, nsIArena *)

  4288 <ns4xPluginStreamListener>

  4289 PR_Malloc

  4290 ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo *, nsIInputStream *, unsigned int)

  4292 <nsSegmentedBuffer>

  4293 PR_Malloc

  4294 nsMemoryImpl::Alloc(unsigned int)

  4295 nsSegmentedBuffer::AppendNewSegment(void)

  4297 <nsAuthURLParser>

  4298 PL_strndup

  4299 ExtractString

  4301 <nsJAR>

  4302 PR_Malloc

  4303 PL_HashTableFinalize(PLHashTable *)

  4304 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4305 nsHashtable::nsHashtable(unsigned int, int)

  4306 __17nsObjectHashtablePFP9nsHashKeyPvPv_PvPvPFP9nsHashKeyPvPv_iT2Uii

  4307 nsJAR::nsJAR(void)

  4309 <nsJAR>

  4310 PR_Malloc

  4311 PL_HashTableFinalize(PLHashTable *)

  4312 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4313 nsHashtable::nsHashtable(unsigned int, int)

  4314 nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)

  4315 nsJAR::nsJAR(void)

  4317 <nsJARURI>

  4318 PR_Malloc

  4319 nsMemoryImpl::Alloc(unsigned int)

  4320 nsMemory::Alloc(unsigned int)

  4321 ToNewCString(nsACString const &)

  4322 nsIOService::ResolveRelativePath(char const *, char const *, char **)

  4323 nsJARURI::SetSpec(char const *)

  4325 <nsStreamConverterService>

  4326 PR_Malloc

  4327 PL_HashTableFinalize(PLHashTable *)

  4328 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4329 nsHashtable::nsHashtable(unsigned int, int)

  4330 nsStreamConverterService::Init(void)

  4332 <nsLayoutUtils>

  4333 PR_Malloc

  4334 PL_HashTableFinalize(PLHashTable *)

  4335 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4336 nsHashtable::nsHashtable(unsigned int, int)

  4337 nsLayoutUtils::GetDynamicScriptContext(JSContext *, nsIScriptContext **)

  4339 <nsDNSService>

  4340 PR_Malloc

  4341 PL_HashTableFinalize(PLHashTable *)

  4342 PL_HashTableRawAdd

  4343 nsHashtable::Put(nsHashKey *, void *)

  4344 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4345 nsDNSService::GetLookupEntry(char const *, nsDNSLookup **)

  4347 <nsDNSService>

  4348 PL_DHashAllocTable

  4349 PL_DHashTableInit

  4350 nsDNSService::Init(void)

  4352 <nsDNSService>

  4353 __builtin_new

  4354 nsDNSService::GetLookupEntry(char const *, nsDNSLookup **)

  4356 <nsDNSService>

  4357 __builtin_new

  4358 nsDNSService::Lookup(char const *, nsIDNSListener *, nsISupports *, nsIRequest **)

  4360 <nsDNSService>

  4361 __builtin_new

  4362 nsCStringKey::Clone(void) const

  4363 nsHashtable::Put(nsHashKey *, void *)

  4364 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4365 nsDNSService::GetLookupEntry(char const *, nsDNSLookup **)

  4367 <nsDNSLookup>

  4368 gethostbyname2

  4369 PR_GetIPNodeByName

  4370 nsDNSLookup::InitiateLookup(void)

  4372 <nsDNSLookup>

  4373 __builtin_new

  4374 nsSupportsArray::Create(nsISupports *, nsID const &, void **)

  4375 NS_NewISupportsArray(nsISupportsArray **)

  4376 nsDNSLookup::Init(char const *)

  4378 <nsDNSLookup>

  4379 __builtin_new

  4380 nsDNSLookup::Create(char const *)

  4382 # ----------------------------------------------------------------------

  4383 #

  4384 # nsFormControlList

  4385 #

  4387 <nsFormControlList>

  4388 PR_Malloc

  4389 PL_HashTableFinalize(PLHashTable *)

  4390 PL_HashTableRawAdd

  4391 nsHashtable::Put(nsHashKey *, void *)

  4392 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

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

  4395 <nsFormControlList>

  4396 PR_Malloc

  4397 PL_HashTableFinalize(PLHashTable *)

  4398 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4399 nsHashtable::nsHashtable(unsigned int, int)

  4400 nsFormControlList::nsFormControlList(nsIDOMHTMLFormElement *)

  4402 <nsFormControlList>

  4403 __builtin_new

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

  4406 <nsFormControlList>

  4407 __builtin_new

  4408 nsStringKey::Clone(void) const

  4409 nsHashtable::Put(nsHashKey *, void *)

  4410 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

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

  4413 <nsFormControlList>

  4414 PR_Malloc

  4415 PL_HashTableFinalize(PLHashTable *)

  4416 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4417 nsHashtable::nsHashtable(unsigned int, int)

  4418 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

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

  4421 <nsFormControlList>

  4422 PR_Malloc

  4423 PL_HashTableFinalize(PLHashTable *)

  4424 PL_HashTableRawAdd

  4425 nsHashtable::Put(nsHashKey *, void *)

  4426 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4427 nsFormControlList::AddElementToTable(nsIFormControl *, nsAString const &)

  4429 # ----------------------------------------------------------------------

  4430 #

  4431 # nsControllerCommandManager

  4432 #

  4434 <nsControllerCommandManager>

  4435 __builtin_new

  4436 __builtin_vec_new

  4437 NS_NewControllerCommandManager(nsIControllerCommandManager **)

  4439 <nsControllerCommandManager>

  4440 PR_Malloc

  4441 PL_HashTableFinalize(PLHashTable *)

  4442 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4443 nsHashtable::nsHashtable(unsigned int, int)

  4444 nsControllerCommandManager::nsControllerCommandManager(void)

  4446 <nsControllerCommandManager>

  4447 PR_Malloc

  4448 PL_HashTableFinalize(PLHashTable *)

  4449 PL_HashTableRawAdd

  4450 nsHashtable::Put(nsHashKey *, void *)

  4451 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4452 nsControllerCommandManager::RegisterCommand(nsAString const &, nsIControllerCommand *)

  4454 <nsControllerCommandManager>

  4455 PR_Malloc

  4456 PL_HashTableFinalize(PLHashTable *)

  4457 PL_HashTableRawAdd

  4458 nsHashtable::Put(nsHashKey *, void *)

  4459 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4460 nsControllerCommandManager::RegisterCommand(unsigned short const *, nsIControllerCommand *)

  4462 <nsControllerCommandManager>

  4463 __builtin_new

  4464 nsStringKey::Clone(void) const

  4465 nsHashtable::Put(nsHashKey *, void *)

  4466 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  4467 nsControllerCommandManager::RegisterCommand(unsigned short const *, nsIControllerCommand *)

  4469 <nsControllerCommandManager>

  4470 PR_Malloc

  4471 PL_HashTableFinalize(PLHashTable *)

  4472 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  4473 nsHashtable::nsHashtable(unsigned int, int)

  4474 nsSupportsHashtable::nsSupportsHashtable(unsigned int, int)

  4475 nsControllerCommandManager::nsControllerCommandManager(void)

  4477 <nsConsoleService>

  4478 PR_Malloc

  4479 nsMemoryImpl::Alloc(unsigned int)

  4480 nsMemory::Alloc(unsigned int)

  4481 nsConsoleService::nsConsoleService(void)

  4483 <mozilla::dom::Element>

  4484 __builtin_new

  4485 mozilla::dom::Element::GetDOMSlots(void)

  4487 <HTMLAttribute>

  4488 __builtin_new

  4489 HTMLAttribute::CopyHTMLAttributes(HTMLAttribute *, HTMLAttribute **)

  4491 # ----------------------------------------------------------------------

  4492 #

  4493 # HTMLAttributesImpl

  4494 #

  4496 <HTMLAttributesImpl>

  4497 __builtin_new

  4498 HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsAString const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *)

  4500 <HTMLAttributesImpl>

  4501 __builtin_new

  4502 HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsHTMLValue const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *, int &)

  4504 <HTMLAttributesImpl>

  4505 __builtin_new

  4506 __builtin_vec_new

  4507 HTMLAttributesImpl::SetAttributeName(nsIAtom *, int &)

  4509 <HTMLAttributesImpl>

  4510 __builtin_new

  4511 nsHTMLMappedAttributes::SetAttribute(nsIAtom *, nsHTMLValue const &)

  4512 HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsHTMLValue const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *, int &)

  4514 <HTMLAttributesImpl>

  4515 PR_Malloc

  4516 nsMemoryImpl::Alloc(unsigned int)

  4517 nsMemory::Alloc(unsigned int)

  4518 nsCRT::strndup(unsigned short const *, unsigned int)

  4519 nsCRT::strdup(unsigned short const *)

  4520 nsHTMLValue::nsHTMLValue(nsHTMLValue const &)

  4521 HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsHTMLValue const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *, int &)

  4523 <HTMLAttributesImpl>

  4524 __builtin_new

  4525 nsHTMLMappedAttributes::nsHTMLMappedAttributes(nsHTMLMappedAttributes const &)

  4526 nsHTMLMappedAttributes::Clone(nsHTMLMappedAttributes **) const

  4527 HTMLAttributesImpl::EnsureSingleMappedFor(nsIHTMLContent *, nsIHTMLStyleSheet *, int)

  4529 # ----------------------------------------------------------------------

  4531 <nsEntityConverter>

  4532 __builtin_new

  4533 __builtin_vec_new

  4534 nsEntityConverter::LoadVersionPropertyFile(void)

  4536 <nsTableFrame>

  4537 __builtin_new

  4538 __builtin_vec_new

  4539 nsTableFrame::nsTableFrame(void)

  4541 <nsTableFrame>

  4542 __builtin_new

  4543 __builtin_vec_new

  4544 nsTableFrame::BalanceColumnWidths(nsIPresContext *, nsHTMLReflowState const &, nsSize const &, nsSize *)

  4546 <nsTableFrame>

  4547 __builtin_new

  4548 nsTableFrame::Init(nsIPresContext *, nsIContent *, nsIFrame *, nsIStyleContext *, nsIFrame *)

  4550 <nsTableCellFrame>

  4551 __builtin_new

  4552 nsTableCellFrame::GetFrameName(nsString &) const

  4554 <nsCellMap>

  4555 __builtin_new

  4556 nsCellMap::AppendCell(nsTableCellMap &, nsTableCellFrame &, int, int)

  4558 <nsCellMap>

  4559 __builtin_new

  4560 nsCellMap::Grow(nsTableCellMap &, int, int)

  4562 <nsCellMap>

  4563 PR_Malloc

  4564 nsVoidArray::SizeTo(int)

  4565 nsVoidArray::nsVoidArray(int)

  4566 nsCellMap::Grow(nsTableCellMap &, int, int)

  4568 <nsTableCellMap>

  4569 __builtin_new

  4570 nsTableCellMap::InsertGroupCellMap(nsTableRowGroupFrame &, nsTableRowGroupFrame *&)

  4572 <nsTableCellMap>

  4573 __builtin_new

  4574 nsTableCellMap::AddColsAtEnd(unsigned int)

  4576 <nsEncoderSupport>

  4577 __builtin_new

  4578 __builtin_vec_new

  4579 nsEncoderSupport::nsEncoderSupport(void)

  4581 <nsFrameImageLoader>

  4582 __builtin_new

  4583 Init__18nsFrameImageLoaderP14nsIPresContextP13nsIImageGroupRC8nsStringPCUiPC6nsSizeP8nsIFrame16nsImageAnimationPFP14nsIPresContextP19nsIFrameImageLoaderP8nsIFramePvUi_UiPvT9

  4585 <nsFrameImageLoader>

  4586 __builtin_new

  4587 AddFrame__18nsFrameImageLoaderP8nsIFramePFP14nsIPresContextP19nsIFrameImageLoaderP8nsIFramePvUi_UiPvT3

  4590 <nsFloaterCacheFreeList>

  4591 __builtin_new

  4592 nsFloaterCacheFreeList::Alloc(void)

  4594 <nsDocLoaderImpl>

  4595 __builtin_new

  4596 nsDocLoaderImpl::AddChannelInfo(nsIChannel *)

  4598 <nsDocLoaderImpl>

  4599 __builtin_new

  4600 nsDocLoaderImpl::AddRequestInfo(nsIRequest *)

  4602 <nsTokenAllocator>

  4603 PR_Malloc

  4604 PL_ArenaAllocate

  4605 nsFixedSizeAllocator::AddBucket(unsigned int)

  4606 nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)

  4607 nsTokenAllocator::nsTokenAllocator(void)

  4609 <SinkContext>

  4610 __builtin_new

  4611 __builtin_vec_new

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

  4614 <SinkContext>

  4615 __builtin_new

  4616 __builtin_vec_new

  4617 SinkContext::GrowStack(void)

  4619 <nsScanner>

  4620 PR_Malloc

  4621 nsMemoryImpl::Alloc(unsigned int)

  4622 nsMemory::Alloc(unsigned int)

  4623 nsScanner::Append(char const *, unsigned int)

  4625 <nsParser>

  4626 __builtin_new

  4627 nsParser::Parse(nsIURI *, nsIStreamObserver *, int, void *, nsDTDMode)

  4629 <nsParser>

  4630 __builtin_new

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

  4633 <nsParser>

  4634 __builtin_new

  4635 __builtin_vec_new

  4636 nsParser::OnDataAvailable(nsIChannel *, nsISupports *, nsIInputStream *, unsigned int, unsigned int)

  4638 <nsParserModule>

  4639 __builtin_new

  4640 __builtin_vec_new

  4641 InitializeElementTable(void)

  4643 <nsStorageStream>

  4644 __builtin_new

  4645 nsStorageStream::Init(unsigned int, unsigned int, nsIMemory *)

  4647 <nsEntryStack>

  4648 __builtin_new

  4649 __builtin_vec_new

  4650 nsEntryStack::EnsureCapacityFor(int, int)

  4652 <nsCacheManager>

  4653 __builtin_new

  4654 nsCacheManager::Init(void)

  4656 <nsScriptError>

  4657 PR_Malloc

  4658 nsMemoryImpl::Alloc(unsigned int)

  4659 nsMemory::Alloc(unsigned int)

  4660 nsStr::Alloc(nsStr &, unsigned int)

  4661 nsStr::Realloc(nsStr &, unsigned int)

  4662 nsStr::EnsureCapacity(nsStr &, unsigned int)

  4663 nsStr::GrowCapacity(nsStr &, unsigned int)

  4664 nsString::SetCapacity(unsigned int)

  4665 nsString::SetLength(unsigned int)

  4666 ~.*

  4667 ~.*

  4668 basic_nsAWritableString<unsigned short>::Assign(unsigned short const *)

  4669 nsScriptError::Init(unsigned short const *, unsigned short const *, unsigned short const *, unsigned int, unsigned int, unsigned int, char const *)

  4671 <nsScriptError>

  4672 PR_Malloc

  4673 nsMemoryImpl::Alloc(unsigned int)

  4674 nsMemory::Alloc(unsigned int)

  4675 nsStr::Alloc(nsStr &, unsigned int)

  4676 nsStr::Realloc(nsStr &, unsigned int)

  4677 nsStr::EnsureCapacity(nsStr &, unsigned int)

  4678 nsStr::GrowCapacity(nsStr &, unsigned int)

  4679 nsCString::SetCapacity(unsigned int)

  4680 nsCString::SetLength(unsigned int)

  4681 ~.*

  4682 ~.*

  4683 basic_nsAWritableString<char>::Assign(char const *)

  4684 nsScriptError::Init(unsigned short const *, unsigned short const *, unsigned short const *, unsigned int, unsigned int, unsigned int, char const *)

  4686 <registry-Buffer>

  4687 PR_Malloc

  4688 bufio_SetBufferSize

  4690 <nsString::PRUnichar*>

  4691 PR_Malloc

  4692 nsMemoryImpl::Alloc

  4693 nsMemory::Alloc

  4694 ToNewUnicode

  4696 <nsString::char*>

  4697 PR_Malloc

  4698 nsMemoryImpl::Alloc

  4699 nsMemory::Alloc

  4700 nsStr::Alloc

  4702 <nsDiskCacheMap>

  4703 __builtin_new

  4704 nsDiskCacheDevice::Init(void)

  4706 <nsXULPrototypeAttribute>

  4707 __builtin_new

  4708 __builtin_vec_new

  4709 XULContentSinkImpl::AddAttributes(nsIParserNode const &, nsXULPrototypeElement *)

  4711 #

  4712 # XPCNativeInterface::NewInstance allocates an array of XPCNativeMember

  4713 # objects, and it also allocates an array of bytes to use for

  4714 # XPCNativeInterface objects.  Trace would be the same for each.

  4715 #

  4716 <XPCNativeInterface>

  4717 __builtin_new

  4718 __builtin_vec_new

  4719 XPCNativeInterface::NewInstance(XPCCallContext &, nsIInterfaceInfo *)

  4721 <XPCNativeInterface>

  4722 JS_DHashAllocTable

  4723 JS_DHashTableFinish

  4724 JS_DHashTableOperate

  4725 XPCNativeInterface::GetNewOrUsed(XPCCallContext &, nsID const *)

  4727 <nsDiskCacheBlockFile::mBitmap>

  4728 __builtin_new

  4729 __builtin_vec_new

  4730 nsDiskCacheBlockFile::Open(nsILocalFile *, unsigned int)

  4732 #----------------------------------------------------------------------

  4733 #

  4734 # nsConflictSet

  4735 #

  4737 <nsConflictSet::mBindingDependencies>

  4738 __builtin_new

  4739 __builtin_vec_new

  4740 nsConflictSet::AllocBindingTable(void *, unsigned int)

  4742 <nsConflictSet::mBindingDependencies>

  4743 PR_Malloc

  4744 PL_ArenaAllocate

  4745 nsFixedSizeAllocator::Alloc(unsigned int)

  4746 nsConflictSet::AllocBindingEntry(void *, void const *)

  4748 <nsConflictSet::mClusters>

  4749 __builtin_new

  4750 __builtin_vec_new

  4751 nsConflictSet::AllocClusterTable(void *, unsigned int)

  4753 <nsConflictSet::mClusters>

  4754 PR_Malloc

  4755 PL_ArenaAllocate

  4756 nsFixedSizeAllocator::Alloc(unsigned int)

  4757 nsConflictSet::AllocClusterEntry(void *, void const *)

  4759 <nsConflictSet::mSupport>

  4760 __builtin_new

  4761 __builtin_vec_new

  4762 nsConflictSet::AllocSupportTable(void *, unsigned int)

  4764 <nsConflictSet::mSupport>

  4765 PR_Malloc

  4766 PL_ArenaAllocate

  4767 nsFixedSizeAllocator::Alloc(unsigned int)

  4768 nsConflictSet::AllocSupportEntry(void *, void const *)

  4770 <nsConflictSet::mSupport>

  4771 PR_Malloc

  4772 PL_ArenaAllocate

  4773 nsFixedSizeAllocator::Alloc(unsigned int)

  4774 nsRDFConMemberTestNode::Element::Clone(void *) const

  4776 <nsConflictSet::mSupport>

  4777 PR_Malloc

  4778 PL_ArenaAllocate

  4779 nsFixedSizeAllocator::Alloc(unsigned int)

  4780 nsRDFConInstanceTestNode::Element::Clone(void *) const

  4782 <nsConflictSet::mSupport>

  4783 PR_Malloc

  4784 PL_ArenaAllocate

  4785 nsFixedSizeAllocator::Alloc(unsigned int)

  4786 nsRDFConInstanceTestNode::FilterInstantiations(InstantiationSet &, void *) const

  4788 <nsConflictSet::mSupport>

  4789 __builtin_new

  4790 MemoryElementSet::Add(MemoryElement *)

  4792 <nsConflictSet>

  4793 PL_DHashAllocTable

  4794 PL_DHashTableFinish

  4795 PL_DHashTableOperate

  4796 nsTemplateMatchRefSet::AddToTable(nsTemplateMatch *)

  4797 nsTemplateMatchRefSet::Add(nsTemplateMatch const *)

  4798 nsConflictSet::Add(nsTemplateMatch *)

  4800 <nsConflictSet>

  4801 PR_Malloc

  4802 PL_ArenaAllocate

  4803 nsFixedSizeAllocator::AddBucket(unsigned int)

  4804 nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)

  4805 nsConflictSet::Init(void)

  4807 <nsConflictSet>

  4808 PR_Malloc

  4809 PL_ArenaAllocate

  4810 nsFixedSizeAllocator::Alloc(unsigned int)

  4811 nsConflictSet::SupportEntry::Create(nsFixedSizeAllocator &)

  4813 <nsConflictSet>

  4814 PR_Malloc

  4815 PL_ArenaAllocate

  4816 nsFixedSizeAllocator::Alloc(unsigned int)

  4817 nsConflictSet::ClusterEntry::Create(nsFixedSizeAllocator &)

  4819 #----------------------------------------------------------------------

  4821 <nsAssignmentSet>

  4822 __builtin_new

  4823 nsAssignmentSet::Add(nsAssignment const &)

  4825 #----------------------------------------------------------------------

  4826 #

  4827 # nsXULTemplateBuilder

  4828 #

  4830 <nsXULTemplateBuilder>

  4831 __builtin_new

  4832 nsXULTemplateBuilder::CompileSimpleRule(nsIContent *, int, InnerNode *)

  4834 <nsXULTemplateBuilder>

  4835 PL_DHashAllocTable

  4836 PL_DHashTableInit

  4837 nsXULContentBuilder::nsXULContentBuilder(void)

  4839 <nsXULTemplateBuilder>

  4840 PL_DHashAllocTable

  4841 PL_DHashTableInit

  4842 nsContentSupportMap::Init(void)

  4844 <nsXULTemplateBuilder>

  4845 PL_DHashAllocTable

  4846 PL_DHashTableFinish

  4847 PL_DHashTableOperate

  4848 nsXULContentBuilder::BuildContentFromTemplate(nsIContent *, nsIContent *, nsIContent *, int, nsIRDFResource *, int, nsTemplateMatch *, nsIContent **, int *)

  4850 <nsXULTemplateBuilder>

  4851 PR_Malloc

  4852 nsMemoryImpl::Alloc(unsigned int)

  4853 nsMemory::Alloc(unsigned int)

  4854 nsCRT::strndup(unsigned short const *, unsigned int)

  4855 nsCRT::strdup(unsigned short const *)

  4856 nsXULTemplateBuilder::AddBindingsFor(nsXULTemplateBuilder *, nsAString const &, void *)

  4858 #----------------------------------------------------------------------

  4859 #

  4860 # nsRuleNetwork

  4861 #

  4863 <nsRuleNetwork>

  4864 PL_DHashAllocTable

  4865 PL_DHashTableInit

  4866 nsRuleNetwork::Init(void)

  4868 #----------------------------------------------------------------------

  4869 #

  4870 # nsTemplateRule

  4871 #

  4873 <nsTemplateRule>

  4874 __builtin_new

  4875 nsTemplateRule::AddBinding(int, nsIRDFResource *, int)

  4877 #----------------------------------------------------------------------

  4878 #

  4879 # nsTemplateMatch

  4880 #

  4882 <nsTemplateMatch>

  4883 __builtin_new

  4884 nsAssignmentSet::Add(nsAssignment const &)

  4885 nsTemplateRule::ComputeAssignmentFor(nsConflictSet &, nsTemplateMatch *, int, Value *) const

  4886 nsTemplateMatch::GetAssignmentFor(nsConflictSet &, int, Value *)

  4888 <nsTemplateMatch>

  4889 PR_Malloc

  4890 PL_ArenaAllocate

  4891 nsFixedSizeAllocator::Alloc(unsigned int)

  4892 nsInstantiationNode::Propagate(InstantiationSet const &, void *)

  4894 <nsTemplateMatch>

  4895 PR_Malloc

  4896 PL_ArenaAllocate

  4897 nsFixedSizeAllocator::Alloc(unsigned int)

  4898 nsRDFConMemberTestNode::FilterInstantiations(InstantiationSet &, void *) const

  4900 <nsTemplateMatch>

  4901 PR_Malloc

  4902 PL_ArenaAllocate

  4903 nsFixedSizeAllocator::Alloc(unsigned int)

  4904 nsTemplateMatch::Create(nsFixedSizeAllocator &, nsTemplateRule const *, Instantiation const &, nsAssignmentSet const &)

  4906 #----------------------------------------------------------------------

  4908 <ReteNodeSet::mNodes>

  4909 __builtin_new

  4910 __builtin_vec_new

  4911 ReteNodeSet::Add(ReteNode *)

  4913 #----------------------------------------------------------------------

  4915 <StaticModuleInfo>

  4916 __builtin_new

  4917 __builtin_vec_new

  4918 nsStaticComponentLoader::GetModuleInfo(void)

  4920 <RuleValue*>

  4921 __builtin_new

  4922 __builtin_vec_new

  4923 RuleHash::EnumerateAllRules(int, nsIAtom *, nsIAtom *, nsVoidArray const &, void (*)(nsICSSStyleRule *, void *), void *)

  4925 <XPCNativeSet>

  4926 __builtin_new

  4927 __builtin_vec_new

  4928 XPCNativeSet::NewInstance(XPCCallContext &, nsIInterfaceInfo *)

  4930 <XPCNativeSet>

  4931 JS_DHashAllocTable

  4932 JS_DHashTableFinish

  4933 JS_DHashTableOperate

  4934 XPCNativeSet::ClearCacheEntryForClassInfo(nsIClassInfo *)

  4936 <XPCNativeSet>

  4937 __builtin_new

  4938 __builtin_vec_new

  4939 XPCNativeSet::NewInstanceMutate(XPCNativeSet *, XPCNativeInterface *, unsigned short)

  4941 <nsIRDFResource*>

  4942 __builtin_new

  4943 __builtin_vec_new

  4944 nsResourceSet::Add(nsIRDFResource *)

  4946 <nsXPCWrappedJSClass::mDescriptors>

  4947 __builtin_new

  4948 __builtin_vec_new

  4949 nsXPCWrappedJSClass::nsXPCWrappedJSClass(XPCCallContext &, nsID const &, nsIInterfaceInfo *)

  4951 <orkin-unclassified>

  4952 __builtin_new

  4953 orkinHeap::Alloc(nsIMdbEnv *, unsigned int, void **)

  4955 <nsGenericAttribute>

  4956 __builtin_new

  4957 nsGenericContainerElement::SetAttribute(nsINodeInfo *, nsAString const &, int)

  4959 #

  4960 # Space for LiteralImpl is allocated using global operator new so

  4961 # that extra space can be allocated for its string value.

  4962 #

  4963 <LiteralImpl>

  4964 __builtin_new

  4965 LiteralImpl::Create

  4967 <nsXULContentSinkImpl::mText>

  4968 PR_Malloc

  4969 nsMemoryImpl::Alloc(unsigned int)

  4970 nsMemory::Alloc(unsigned int)

  4971 nsStr::Alloc(nsStr &, unsigned int)

  4972 nsStr::Realloc(nsStr &, unsigned int)

  4973 nsStr::EnsureCapacity(nsStr &, unsigned int)

  4974 nsStr::GrowCapacity(nsStr &, unsigned int)

  4975 nsString::SetCapacity(unsigned int)

  4976 XULContentSinkImpl::FlushText(int)

  4978 <nsPersistentProperties>

  4979 PR_Malloc

  4980 nsMemoryImpl::Alloc(unsigned int)

  4981 nsMemory::Alloc(unsigned int)

  4982 nsCRT::strndup(unsigned short const *, unsigned int)

  4983 nsCRT::strdup(unsigned short const *)

  4984 nsString::ToNewUnicode(void) const

  4985 nsPersistentProperties::SetStringProperty(nsString const &, nsString &, nsString &)

  4987 <nsCSSValue>

  4988 PR_Malloc

  4989 nsMemoryImpl::Alloc(unsigned int)

  4990 nsMemory::Alloc(unsigned int)

  4991 nsCRT::strndup(unsigned short const *, unsigned int)

  4992 nsCRT::strdup(unsigned short const *)

  4993 nsCSSValue::operator=(nsCSSValue const &)

  4995 #----------------------------------------------------------------------

  4996 #

  4997 # nsXULDocument

  4998 #

  5000 <nsXULDocument>

  5001 PR_Realloc

  5002 nsVoidArray::SizeTo(int)

  5003 nsAutoVoidArray::SizeTo(int)

  5004 nsVoidArray::GrowArrayBy(int)

  5005 nsVoidArray::InsertElementAt(void *, int)

  5006 nsXULDocument::AddObserver(nsIDocumentObserver *)

  5008 <nsXULDocument::mBoxObjectTable>

  5009 PR_Malloc

  5010 PL_HashTableFinalize(PLHashTable *)

  5011 PL_HashTableRawAdd

  5012 nsHashtable::Put(nsHashKey *, void *)

  5013 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  5014 nsXULDocument::SetBoxObjectFor(nsIDOMElement *, nsIBoxObject *)

  5016 <nsXULDocument::mTemplateBuilderTable>

  5017 PR_Malloc

  5018 PL_HashTableFinalize(PLHashTable *)

  5019 PL_HashTableRawAdd

  5020 nsHashtable::Put(nsHashKey *, void *)

  5021 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  5022 nsXULDocument::SetTemplateBuilderFor(nsIContent *, nsIXULTemplateBuilder *)

  5024 # ----------------------------------------------------------------------

  5026 <nsXULDocument::mElementMap>

  5027 PR_Malloc

  5028 nsMemoryImpl::Alloc(unsigned int)

  5029 nsMemory::Alloc(unsigned int)

  5030 ToNewUnicode(nsAString const &)

  5031 nsElementMap::Add(nsAString const &, nsIContent *)

  5032 nsXULDocument::AddElementToMap(nsIContent *)

  5034 <nsXULDocument::mElementMap>

  5035 PR_Malloc

  5036 nsMemoryImpl::Alloc(unsigned int)

  5037 nsMemory::Alloc(unsigned int)

  5038 ToNewUnicode(nsAString const &)

  5039 nsElementMap::Add(nsAString const &, nsIContent *)

  5040 nsXULDocument::AddElementForID(nsAString const &, nsIContent *)

  5042 <nsXULDocument::mElementMap>

  5043 PR_Malloc

  5044 PL_ArenaAllocate

  5045 nsFixedSizeAllocator::Alloc(unsigned int)

  5046 nsXULTreeElement::SelectCallback(nsITimer *, void *)

  5047 PL_HashTableRawAdd

  5048 PL_HashTableAdd

  5049 nsElementMap::Add(nsAString const &, nsIContent *)

  5051 <nsXULDocument::mElementMap>

  5052 PR_Malloc

  5053 PL_ArenaAllocate

  5054 nsFixedSizeAllocator::Alloc(unsigned int)

  5055 NS_NewControllerCommandManager(nsIControllerCommandManager **)

  5056 PL_HashTableRawAdd

  5057 PL_HashTableAdd

  5058 nsElementMap::Add(nsAString const &, nsIContent *)

  5060 <nsXULDocument::mElementMap>

  5061 PR_Malloc

  5062 PL_ArenaAllocate

  5063 nsFixedSizeAllocator::Alloc(unsigned int)

  5064 nsElementMap::Add(nsAString const &, nsIContent *)

  5066 <nsXULDocument::mElementMap>

  5067 PR_Malloc

  5068 PL_ArenaAllocate

  5069 nsFixedSizeAllocator::AddBucket(unsigned int)

  5070 nsFixedSizeAllocator::Init(char const *, unsigned int const *, int, int, int)

  5071 nsElementMap::nsElementMap(void)

  5073 <nsXULDocument::mElementMap>

  5074 PR_Malloc

  5075 nsMemoryImpl::Alloc(unsigned int)

  5076 nsMemory::Alloc(unsigned int)

  5077 unsigned short * AllocateStringCopy<nsAString, unsigned short>(nsAString const &, unsigned short *)

  5078 ToNewUnicode(nsAString const &)

  5079 nsElementMap::Add(nsAString const &, nsIContent *)

  5081 <nsXULDocument::mContentWrapperHash>

  5082 PR_Malloc

  5083 PL_HashTableFinalize(PLHashTable *)

  5084 PL_HashTableRawAdd

  5085 nsHashtable::Put(nsHashKey *, void *)

  5086 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  5087 nsXULDocument::AddReference(void *, nsISupports *)

  5089 <nsXULDocument>

  5090 __builtin_new

  5091 __builtin_vec_new

  5092 nsSupportsArray::GrowArrayBy(int)

  5093 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  5094 nsSupportsArray::AppendElement(nsISupports *)

  5095 nsXULDocument::PrepareToWalk(void)

  5097 <nsXULDocument>

  5098 PL_DHashAllocTable

  5099 PL_DHashTableInit

  5100 PL_NewDHashTable

  5101 nsXULDocument::AddBroadcastListenerFor(nsIDOMElement *, nsIDOMElement *, nsAString const &)

  5103 #----------------------------------------------------------------------

  5105 <nsHTMLValue::mValue.mString>

  5106 PR_Malloc

  5107 nsMemoryImpl::Alloc(unsigned int)

  5108 nsMemory::Alloc(unsigned int)

  5109 ToNewUnicode(nsAString const &)

  5110 nsHTMLValue::nsHTMLValue(nsAString const &, nsHTMLUnit)

  5112 <nsCSSValue>

  5113 PR_Malloc

  5114 nsMemoryImpl::Alloc(unsigned int)

  5115 nsMemory::Alloc(unsigned int)

  5116 ExtractURLScheme

  5117 nsStdURL::Resolve(char const *, char **)

  5118 CSSParserImpl::ParseURL(int &, nsCSSValue &)

  5120 <url-unclassified>

  5121 PR_Malloc

  5122 nsMemoryImpl::Alloc(unsigned int)

  5123 nsMemory::Alloc(unsigned int)

  5124 ExtractURLScheme

  5125 nsStdURL::Resolve(char const *, char **)

  5127 <css-unclassified>

  5128 PR_Malloc

  5129 PL_HashTableFinalize(PLHashTable *)

  5130 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  5131 nsHashtable::nsHashtable(unsigned int, int)

  5132 nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)

  5133 nsRuleWalker::Forward(nsIStyleRule *)

  5135 #

  5136 # Doesn't inherit nsISupports

  5137 #

  5138 <nsSupportsHashtable>

  5139 __builtin_new

  5140 nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)

  5142 #

  5143 # No vtable.

  5144 #

  5145 <nsClassList>

  5146 __builtin_new

  5147 nsClassList::ParseClasses(nsClassList **, nsAString const &)

  5149 #

  5150 # Doesn't inherit nsISupports

  5151 #

  5152 <nsVoidArray>

  5153 __builtin_new

  5154 nsCheapVoidArray::SwitchToVector(void)

  5156 <nsEventListenerManager>

  5157 __builtin_new

  5158 nsEventListenerManager::GetListenersByType(EventArrayType, nsHashKey *, int)

  5160 #----------------------------------------------------------------------

  5162 <nsServiceModule::mServices>

  5163 PR_Malloc

  5164 PL_HashTableFinalize(PLHashTable *)

  5165 PL_HashTableInit(PLHashTable *, unsigned int, unsigned int (*)(void const *), int (*)(void const *, void const *), int (*)(void const *, void const *), PLHashAllocOps const *, void *)

  5166 nsHashtable::nsHashtable(unsigned int, int)

  5167 nsObjectHashtable::nsObjectHashtable(void *(*)(nsHashKey *, void *, void *), void *, int (*)(nsHashKey *, void *, void *), void *, unsigned int, int)

  5168 nsServiceManagerImpl::nsServiceManagerImpl(void)

  5170 <nsImportedStringHandle>

  5171 __builtin_new

  5172 nsXPIDLCString::PrepareForUseAsOutParam(void)

  5174 <nsXBLJSClass>

  5175 __builtin_new

  5176 nsXBLBinding::InitClass

  5178 <Assertion>

  5179 PR_Malloc

  5180 PL_ArenaAllocate

  5181 nsFixedSizeAllocator::Alloc(unsigned int)

  5182 InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)

  5184 <nsXBLAttributeEntry>

  5185 PR_Malloc

  5186 PL_ArenaAllocate

  5187 nsFixedSizeAllocator::Alloc(unsigned int)

  5188 nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *)

  5190 #----------------------------------------------------------------------

  5191 #

  5192 # nsRuleNode

  5193 #

  5195 <nsRuleNode>

  5196 PR_Malloc

  5197 PL_HashTableFinalize(PLHashTable *)

  5198 PL_HashTableRawAdd

  5199 nsHashtable::Put(nsHashKey *, void *)

  5200 nsSupportsHashtable::Put(nsHashKey *, nsISupports *, nsISupports **)

  5201 nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **)

  5203 <nsRuleNode>

  5204 PR_Malloc

  5205 nsMemoryImpl::Alloc(unsigned int)

  5206 nsMemory::Alloc(unsigned int)

  5207 nsStr::Alloc(nsStr &, unsigned int)

  5208 nsStr::Realloc(nsStr &, unsigned int)

  5209 nsStr::EnsureCapacity(nsStr &, unsigned int)

  5210 nsStr::GrowCapacity(nsStr &, unsigned int)

  5211 nsString::SetCapacity(unsigned int)

  5212 nsString::SetLength(unsigned int)

  5213 nsAString::do_AppendFromReadable(nsAString const &)

  5214 nsAString::do_AppendFromElementPtr(unsigned short const *)

  5215 nsRuleNode::ComputeDisplayData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5217 <nsRuleNode>

  5218 PR_Malloc

  5219 nsMemoryImpl::Alloc(unsigned int)

  5220 nsMemory::Alloc(unsigned int)

  5221 nsStr::Alloc(nsStr &, unsigned int)

  5222 nsStr::Realloc(nsStr &, unsigned int)

  5223 nsStr::EnsureCapacity(nsStr &, unsigned int)

  5224 nsStr::GrowCapacity(nsStr &, unsigned int)

  5225 nsString::SetCapacity(unsigned int)

  5226 nsString::SetLength(unsigned int)

  5227 nsAString::do_AppendFromReadable(nsAString const &)

  5228 nsAString::do_AppendFromElementPtr(unsigned short const *)

  5229 nsRuleNode::ComputeBackgroundData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5231 <nsRuleNode>

  5232 PR_Malloc

  5233 nsMemoryImpl::Alloc(unsigned int)

  5234 nsMemory::Alloc(unsigned int)

  5235 nsStr::Alloc(nsStr &, unsigned int)

  5236 nsStr::Realloc(nsStr &, unsigned int)

  5237 nsStr::EnsureCapacity(nsStr &, unsigned int)

  5238 nsStr::GrowCapacity(nsStr &, unsigned int)

  5239 nsString::SetCapacity(unsigned int)

  5240 nsString::SetLength(unsigned int)

  5241 nsAString::do_AppendFromReadable(nsAString const &)

  5242 nsAString::do_AppendFromElementPtr(unsigned short const *)

  5243 nsRuleNode::ComputeListData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5245 # ----------------------------------------------------------------------

  5247 # This stuff will only show off if you've turned off the FrameArena

  5248 # in nsPresShell.cpp

  5249 <nsRuleNode>

  5250 PR_Malloc

  5251 FrameArena::AllocateFrame(unsigned int, void **)

  5252 PresShell::AllocateFrame(unsigned int, void **)

  5253 nsPresContext::AllocateFromShell(unsigned int, void **)

  5254 nsRuleNode::ComputeOutlineData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5256 <nsRuleNode>

  5257 PR_Malloc

  5258 FrameArena::AllocateFrame(unsigned int, void **)

  5259 PresShell::AllocateFrame(unsigned int, void **)

  5260 nsPresContext::AllocateFromShell(unsigned int, void **)

  5261 nsRuleNode::ComputeContentData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5263 <nsRuleNode>

  5264 PR_Malloc

  5265 FrameArena::AllocateFrame(unsigned int, void **)

  5266 PresShell::AllocateFrame(unsigned int, void **)

  5267 nsPresContext::AllocateFromShell(unsigned int, void **)

  5268 nsRuleNode::ComputeTableData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5270 <nsRuleNode>

  5271 PR_Malloc

  5272 FrameArena::AllocateFrame(unsigned int, void **)

  5273 PresShell::AllocateFrame(unsigned int, void **)

  5274 nsPresContext::AllocateFromShell(unsigned int, void **)

  5275 nsRuleNode::ComputeUIResetData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5277 <nsRuleNode>

  5278 PR_Malloc

  5279 FrameArena::AllocateFrame(unsigned int, void **)

  5280 PresShell::AllocateFrame(unsigned int, void **)

  5281 nsPresContext::AllocateFromShell(unsigned int, void **)

  5282 nsRuleNode::ComputeXULData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5284 <nsRuleNode>

  5285 PR_Malloc

  5286 FrameArena::AllocateFrame(unsigned int, void **)

  5287 PresShell::AllocateFrame(unsigned int, void **)

  5288 nsPresContext::AllocateFromShell(unsigned int, void **)

  5289 nsRuleNode::SetDefaultOnRoot(nsStyleStructID, nsIStyleContext *)

  5291 <nsRuleNode>

  5292 PR_Malloc

  5293 FrameArena::AllocateFrame(unsigned int, void **)

  5294 PresShell::AllocateFrame(unsigned int, void **)

  5295 nsPresContext::AllocateFromShell(unsigned int, void **)

  5296 nsRuleNode::ComputeListData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5298 <nsRuleNode>

  5299 PR_Malloc

  5300 FrameArena::AllocateFrame(unsigned int, void **)

  5301 PresShell::AllocateFrame(unsigned int, void **)

  5302 nsPresContext::AllocateFromShell(unsigned int, void **)

  5303 nsRuleNode::ComputeTextData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5305 <nsRuleNode>

  5306 PR_Malloc

  5307 FrameArena::AllocateFrame(unsigned int, void **)

  5308 PresShell::AllocateFrame(unsigned int, void **)

  5309 nsPresContext::AllocateFromShell(unsigned int, void **)

  5310 nsRuleNode::ComputeTextResetData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5312 <nsRuleNode>

  5313 PR_Malloc

  5314 FrameArena::AllocateFrame(unsigned int, void **)

  5315 PresShell::AllocateFrame(unsigned int, void **)

  5316 nsPresContext::AllocateFromShell(unsigned int, void **)

  5317 nsRuleNode::ComputePaddingData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5319 <nsRuleNode>

  5320 PR_Malloc

  5321 FrameArena::AllocateFrame(unsigned int, void **)

  5322 PresShell::AllocateFrame(unsigned int, void **)

  5323 nsPresContext::AllocateFromShell(unsigned int, void **)

  5324 nsRuleNode::ComputeFontData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5326 <nsRuleNode>

  5327 PR_Malloc

  5328 FrameArena::AllocateFrame(unsigned int, void **)

  5329 PresShell::AllocateFrame(unsigned int, void **)

  5330 nsPresContext::AllocateFromShell(unsigned int, void **)

  5331 nsRuleNode::ComputeVisibilityData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5333 <nsRuleNode>

  5334 PR_Malloc

  5335 FrameArena::AllocateFrame(unsigned int, void **)

  5336 PresShell::AllocateFrame(unsigned int, void **)

  5337 nsPresContext::AllocateFromShell(unsigned int, void **)

  5338 nsRuleNode::ComputeColorData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5340 # ----------------------------------------------------------------------

  5341 #

  5342 # nsBookmarksService

  5343 #

  5345 <nsBookmarksService>

  5346 PL_DHashAllocTable

  5347 PL_DHashTableFinish

  5348 PL_DHashTableOperate

  5349 InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)

  5350 InMemoryDataSource::Assert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)

  5351 BookmarkParser::updateAtom(nsIRDFDataSource *, nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int *)

  5353 <nsBookmarksService>

  5354 PR_Malloc

  5355 PL_ArenaAllocate

  5356 nsFixedSizeAllocator::Alloc(unsigned int)

  5357 Assertion::Create(nsFixedSizeAllocator &, nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)

  5358 InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)

  5359 InMemoryDataSource::Assert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int)

  5360 BookmarkParser::updateAtom(nsIRDFDataSource *, nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int *)

  5362 # ----------------------------------------------------------------------

  5363 #

  5364 # The following types will only be visible if nsPresShell.cpp is compiled

  5365 # with the DEBUG_TRACEMALLOC_FRAMEARENA defined.

  5366 #

  5368 <nsStyleContext>

  5369 PR_Malloc

  5370 FrameArena::AllocateFrame(unsigned int, void **)

  5371 PresShell::AllocateFrame(unsigned int, void **)

  5372 nsPresContext::AllocateFromShell(unsigned int, void **)

  5373 nsStyleContext::SetStyle(nsStyleStructID, nsStyleStruct const &)

  5375 <nsStyleBorder>

  5376 PR_Malloc

  5377 FrameArena::AllocateFrame(unsigned int, void **)

  5378 PresShell::AllocateFrame(unsigned int, void **)

  5379 nsPresContext::AllocateFromShell(unsigned int, void **)

  5380 nsStyleBorder::operator new(unsigned int, nsIPresContext *)

  5382 # XXX This one is a bit sloppy, and may include some of the other

  5383 # style data structs.

  5384 <nsResetStyleData>

  5385 PR_Malloc

  5386 FrameArena::AllocateFrame(unsigned int, void **)

  5387 PresShell::AllocateFrame(unsigned int, void **)

  5388 nsPresContext::AllocateFromShell(unsigned int, void **)

  5389 nsRuleNode::ComputeDisplayData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5391 <nsResetStyleData>

  5392 PR_Malloc

  5393 FrameArena::AllocateFrame(unsigned int, void **)

  5394 PresShell::AllocateFrame(unsigned int, void **)

  5395 nsPresContext::AllocateFromShell(unsigned int, void **)

  5396 nsStyleContext::SetStyle(nsStyleStructID, nsStyleStruct const &)

  5398 <nsResetStyleData>

  5399 PR_Malloc

  5400 FrameArena::AllocateFrame(unsigned int, void **)

  5401 PresShell::AllocateFrame(unsigned int, void **)

  5402 nsPresContext::AllocateFromShell(unsigned int, void **)

  5403 nsRuleNode::ComputeBorderData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5405 <nsStyleUserInterface>

  5406 PR_Malloc

  5407 FrameArena::AllocateFrame(unsigned int, void **)

  5408 PresShell::AllocateFrame(unsigned int, void **)

  5409 nsPresContext::AllocateFromShell(unsigned int, void **)

  5410 nsRuleNode::ComputeUIData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5412 <nsStylePosition>

  5413 PR_Malloc

  5414 FrameArena::AllocateFrame(unsigned int, void **)

  5415 PresShell::AllocateFrame(unsigned int, void **)

  5416 nsPresContext::AllocateFromShell(unsigned int, void **)

  5417 nsRuleNode::ComputePositionData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5419 <nsStylePadding>

  5420 PR_Malloc

  5421 FrameArena::AllocateFrame(unsigned int, void **)

  5422 PresShell::AllocateFrame(unsigned int, void **)

  5423 nsPresContext::AllocateFromShell(unsigned int, void **)

  5424 nsStylePadding::operator new(unsigned int, nsIPresContext *)

  5426 <nsStyleMargin>

  5427 PR_Malloc

  5428 FrameArena::AllocateFrame(unsigned int, void **)

  5429 PresShell::AllocateFrame(unsigned int, void **)

  5430 nsPresContext::AllocateFromShell(unsigned int, void **)

  5431 nsStyleMargin::operator new(unsigned int, nsIPresContext *)

  5433 <nsStyleBackground>

  5434 PR_Malloc

  5435 FrameArena::AllocateFrame(unsigned int, void **)

  5436 PresShell::AllocateFrame(unsigned int, void **)

  5437 nsPresContext::AllocateFromShell(unsigned int, void **)

  5438 nsRuleNode::ComputeBackgroundData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5440 <nsStyleBackground>

  5441 PR_Malloc

  5442 nsMemoryImpl::Alloc(unsigned int)

  5443 nsMemory::Alloc(unsigned int)

  5444 nsStr::Alloc(nsStr &, unsigned int)

  5445 nsStr::Realloc(nsStr &, unsigned int)

  5446 nsStr::EnsureCapacity(nsStr &, unsigned int)

  5447 nsStr::GrowCapacity(nsStr &, unsigned int)

  5448 nsString::SetCapacity(unsigned int)

  5449 nsString::SetLength(unsigned int)

  5450 nsAString::do_AssignFromReadable(nsAString const &)

  5451 nsAString::AssignFromReadable(nsAString const &)

  5452 nsStyleBackground::nsStyleBackground(nsStyleBackground const &)

  5454 # XXX this'll may be subsumed as nsResetStyleData

  5455 <nsStyleDisplay>

  5456 PR_Malloc

  5457 FrameArena::AllocateFrame(unsigned int, void **)

  5458 PresShell::AllocateFrame(unsigned int, void **)

  5459 nsPresContext::AllocateFromShell(unsigned int, void **)

  5460 nsRuleNode::ComputeDisplayData(nsStyleStruct *, nsCSSStruct const &, nsIStyleContext *, nsRuleNode *, nsRuleNode::RuleDetail const &, int)

  5462 <nsStyleDisplay>

  5463 PR_Malloc

  5464 nsMemoryImpl::Alloc(unsigned int)

  5465 nsMemory::Alloc(unsigned int)

  5466 nsStr::Alloc(nsStr &, unsigned int)

  5467 nsStr::Realloc(nsStr &, unsigned int)

  5468 nsStr::EnsureCapacity(nsStr &, unsigned int)

  5469 nsStr::GrowCapacity(nsStr &, unsigned int)

  5470 nsString::SetCapacity(unsigned int)

  5471 nsString::SetLength(unsigned int)

  5472 nsAString::do_AssignFromReadable(nsAString const &)

  5473 nsAString::AssignFromReadable(nsAString const &)

  5474 nsStyleDisplay::nsStyleDisplay(nsStyleDisplay const &)

  5476 # ----------------------------------------------------------------------

  5477 # The following will only show up if you turn off the FrameArena

  5478 # in nsPresShell.cpp

  5479 <nsStyleContext>

  5480 PR_Malloc

  5481 FrameArena::AllocateFrame(unsigned int, void **)

  5482 PresShell::AllocateFrame(unsigned int, void **)

  5483 nsPresContext::AllocateFromShell(unsigned int, void **)

  5484 nsStyleContext::GetUniqueStyleData(nsIPresContext *, nsStyleStructID const &)

  5486 <nsStyleFont>

  5487 PR_Malloc

  5488 FrameArena::AllocateFrame(unsigned int, void **)

  5489 PresShell::AllocateFrame(unsigned int, void **)

  5490 nsPresContext::AllocateFromShell(unsigned int, void **)

  5491 nsStyleFont::operator new(unsigned int, nsIPresContext *)

  5493 # ----------------------------------------------------------------------

  5494 #

  5495 # Frames

  5496 #

  5498 <nsLineBox>

  5499 __builtin_new

  5500 nsLineBox::SetCombinedArea(nsRect const &)

  5502 # This will only appear when the FrameArena is off.

  5503 <nsLineBox>

  5504 PR_Malloc

  5505 FrameArena::AllocateFrame(unsigned int, void **)

  5506 PresShell::AllocateFrame(unsigned int, void **)

  5507 nsLineBox::operator new(unsigned int, nsIPresShell *)

  5509 # ----------------------------------------------------------------------

  5510 #

  5511 # nsCacheService

  5512 #

  5514 <nsCacheService>

  5515 __builtin_new

  5516 nsCacheService::ActivateEntry(nsCacheRequest *, nsCacheEntry **)

  5518 <nsCacheService>

  5519 __builtin_new

  5520 nsCacheEntry::CreateDescriptor(nsCacheRequest *, int, nsICacheEntryDescriptor **)

  5521 nsCacheService::ProcessRequest(nsCacheRequest *, int, nsICacheEntryDescriptor **)

  5523 <nsCacheService>

  5524 PR_Malloc

  5525 nsMemoryImpl::Alloc(unsigned int)

  5526 nsMemory::Alloc(unsigned int)

  5527 nsStr::Alloc(nsStr &, unsigned int)

  5528 nsStr::Realloc(nsStr &, unsigned int)

  5529 nsStr::EnsureCapacity(nsStr &, unsigned int)

  5530 nsStr::GrowCapacity(nsStr &, unsigned int)

  5531 nsCString::SetCapacity(unsigned int)

  5532 nsCString::SetLength(unsigned int)

  5533 nsACString::do_AppendFromReadable(nsACString const &)

  5534 nsACString::do_AppendFromElementPtr(char const *)

  5535 nsCacheService::CreateRequest(nsCacheSession *, char const *, int, int, nsICacheListener *, nsCacheRequest **)

  5537 <nsCacheService>

  5538 PL_DHashAllocTable

  5539 PL_DHashTableFinish

  5540 PL_DHashTableOperate

  5541 nsCacheEntryHashTable::AddEntry(nsCacheEntry *)

  5542 nsCacheService::ActivateEntry(nsCacheRequest *, nsCacheEntry **)

  5544 <nsCacheService>

  5545 PL_DHashAllocTable

  5546 PL_DHashTableFinish

  5547 PL_DHashTableOperate

  5548 nsCacheEntryHashTable::RemoveEntry(nsCacheEntry *)

  5550 # ----------------------------------------------------------------------

  5552 <nsCacheMetaData>

  5553 PL_DHashAllocTable

  5554 PL_DHashTableInit

  5555 nsCacheMetaData::Init(void)

  5557 # ----------------------------------------------------------------------

  5558 #

  5559 # nsXMLMIMEDataSource

  5560 #

  5562 <nsXMLMIMEDataSource>

  5563 PR_Malloc

  5564 PL_ArenaFinish

  5565 PL_HashTableRawAdd

  5566 PL_HashTableAdd

  5567 nsXMLMIMEDataSource::InitFromFile(nsIFile *)

  5569 <nsXMLMIMEDataSource>

  5570 PR_Malloc

  5571 PL_HashTableFinalize(PLHashTable *)

  5572 PL_HashTableRawAdd

  5573 nsHashtable::Put(nsHashKey *, void *)

  5574 nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)

  5576 <nsXMLMIMEDataSource>

  5577 PR_Malloc

  5578 nsVoidArray::SizeTo(int)

  5579 nsVoidArray::GrowArrayBy(int)

  5580 nsVoidArray::InsertElementAt(void *, int)

  5581 nsTArray<nsCString>::InsertElementAt(int, nsCString const &)

  5582 nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)

  5584 <nsXMLMIMEDataSource>

  5585 __builtin_new

  5586 __builtin_vec_new

  5587 nsSupportsArray::GrowArrayBy(int)

  5588 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  5589 nsSupportsArray::AppendElement(nsISupports *)

  5590 nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)

  5592 <nsXMLMIMEDataSource>

  5593 PR_Malloc

  5594 nsMemoryImpl::Alloc(unsigned int)

  5595 nsMemory::Alloc(unsigned int)

  5596 nsCStringKey::Clone(void) const

  5597 nsHashtable::Put(nsHashKey *, void *)

  5598 nsXMLMIMEDataSource::AddMapping(char const *, char const *, char const *, nsIURI *, unsigned int, unsigned int)

  5600 #----------------------------------------------------------------------

  5601 #

  5602 # nsRegion

  5603 #

  5605 <nsRegion>

  5606 __builtin_new

  5607 __builtin_vec_new

  5608 RgnRectMemoryAllocator::RgnRectMemoryAllocator(unsigned int)

  5609 nsRegion::Offset(int, int)

  5611 <nsRegion>

  5612 __builtin_new

  5613 __builtin_vec_new

  5614 RgnRectMemoryAllocator::Alloc(void)

  5615 nsRegion::Or(nsRegion const &, nsRectFast const &)

  5617 <nsRegion>

  5618 __builtin_new

  5619 __builtin_vec_new

  5620 RgnRectMemoryAllocator::Alloc(void)

  5621 nsRegion::SetToElements(unsigned int)

  5623 #----------------------------------------------------------------------

  5624 #

  5625 # nsCharsetMenu

  5626 #

  5628 <nsCharsetMenu>

  5629 __builtin_new

  5630 __builtin_vec_new

  5631 nsSupportsArray::GrowArrayBy(int)

  5632 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  5633 nsSupportsArray::AppendElement(nsISupports *)

  5634 nsCharsetConverterManager::GetRegistryEnumeration2(char *, int, nsISupportsArray **)

  5635 nsCharsetConverterManager::GetEncoderList(nsISupportsArray **)

  5636 nsCharsetMenu::InitResources(void)

  5638 <nsCharsetMenu>

  5639 __builtin_new

  5640 nsCharsetMenu::AddCharsetToItemArray(nsVoidArray *, nsIAtom *, nsMenuEntry **, int)

  5642 <nsCharsetMenu>

  5643 __builtin_new

  5644 __builtin_vec_new

  5645 nsSupportsArray::GrowArrayBy(int)

  5646 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  5647 nsSupportsArray::AppendElement(nsISupports *)

  5648 nsCharsetConverterManager::GetRegistryEnumeration2(char *, int, nsISupportsArray **)

  5649 nsCharsetConverterManager::GetDecoderList(nsISupportsArray **)

  5650 nsCharsetMenu::InitResources(void)

  5652 <nsCharsetMenu>

  5653 __builtin_new

  5654 __builtin_vec_new

  5655 nsSupportsArray::GrowArrayBy(int)

  5656 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  5657 nsSupportsArray::AppendElement(nsISupports *)

  5658 InMemoryDataSource::AddObserver(nsIRDFObserver *)

  5659 nsCharsetMenu::AddObserver(nsIRDFObserver *)

  5661 #----------------------------------------------------------------------

  5662 #

  5663 # nsLoadGroup

  5664 #

  5666 <nsLoadGroup>

  5667 __builtin_new

  5668 __builtin_vec_new

  5669 nsSupportsArray::GrowArrayBy(int)

  5670 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  5671 nsSupportsArray::AppendElement(nsISupports *)

  5672 nsLoadGroup::AddRequest(nsIRequest *, nsISupports *)

  5674 #----------------------------------------------------------------------

  5675 #

  5676 # Wallet

  5677 #

  5679 <Wallet>

  5680 PR_Malloc

  5681 nsMemoryImpl::Alloc(unsigned int)

  5682 nsMemory::Alloc(unsigned int)

  5683 nsStr::Alloc(nsStr &, unsigned int)

  5684 nsStr::Realloc(nsStr &, unsigned int)

  5685 nsStr::EnsureCapacity(nsStr &, unsigned int)

  5686 nsStr::GrowCapacity(nsStr &, unsigned int)

  5687 nsString::SetCapacity(unsigned int)

  5688 nsString::SetLength(unsigned int)

  5689 nsAString::do_AssignFromReadable(nsAString const &)

  5690 nsAString::AssignFromReadable(nsAString const &)

  5691 Wallet_Decrypt2

  5693 <Wallet>

  5694 PR_Malloc

  5695 nsMemoryImpl::Alloc(unsigned int)

  5696 nsMemory::Alloc(unsigned int)

  5697 nsStr::Alloc(nsStr &, unsigned int)

  5698 nsStr::Realloc(nsStr &, unsigned int)

  5699 nsStr::EnsureCapacity(nsStr &, unsigned int)

  5700 nsStr::GrowCapacity(nsStr &, unsigned int)

  5701 nsString::SetCapacity(unsigned int)

  5702 nsString::SetLength(unsigned int)

  5703 nsAString::do_AssignFromReadable(nsAString const &)

  5704 nsAString::AssignFromReadable(nsAString const &)

  5705 Wallet_RandomName

  5707 <Wallet>

  5708 PR_Malloc

  5709 nsVoidArray::SizeTo(int)

  5710 nsVoidArray::GrowArrayBy(int)

  5711 nsVoidArray::InsertElementAt(void *, int)

  5712 Wallet_RandomName

  5714 <Wallet>

  5715 __builtin_new

  5716 __builtin_vec_new

  5717 Wallet_Decrypt2

  5719 <Wallet>

  5720 __builtin_new

  5721 Wallet_RandomName

  5723 <Wallet>

  5724 PR_Realloc

  5725 nsVoidArray::SizeTo(int)

  5726 nsVoidArray::GrowArrayBy(int)

  5727 nsVoidArray::InsertElementAt(void *, int)

  5728 Wallet_Decrypt2

  5730 <Wallet>

  5731 PR_Realloc

  5732 nsVoidArray::SizeTo(int)

  5733 nsVoidArray::GrowArrayBy(int)

  5734 nsVoidArray::InsertElementAt(void *, int)

  5735 Wallet_RandomName

  5737 #----------------------------------------------------------------------

  5738 #

  5739 # nsMemoryCacheDevice

  5740 #

  5742 <nsMemCacheRecord>

  5743 PL_DHashAllocTable

  5744 PL_DHashTableFinish

  5745 PL_DHashTableOperate

  5746 nsCacheEntryHashTable::RemoveEntry(nsCacheEntry *)

  5747 nsMemoryCacheDevice::EvictEntry(nsCacheEntry *)

  5749 #----------------------------------------------------------------------

  5750 #

  5751 # nsSHEntry

  5752 #

  5754 <nsSHEntry>

  5755 PR_Malloc

  5756 nsMemoryImpl::Alloc(unsigned int)

  5757 nsMemory::Alloc(unsigned int)

  5758 nsStr::Alloc(nsStr &, unsigned int)

  5759 nsStr::Realloc(nsStr &, unsigned int)

  5760 nsStr::EnsureCapacity(nsStr &, unsigned int)

  5761 nsStr::GrowCapacity(nsStr &, unsigned int)

  5762 nsString::SetCapacity(unsigned int)

  5763 nsString::SetLength(unsigned int)

  5764 nsAString::do_AssignFromReadable(nsAString const &)

  5765 nsAString::do_AssignFromElementPtr(unsigned short const *)

  5766 nsSHEntry::SetTitle(unsigned short const *)

  5768 # ----------------------------------------------------------------------

  5770 <nsOutlinerStyleCache>

  5771 PR_Malloc

  5772 PL_HashTableFinalize(PLHashTable *)

  5773 PL_HashTableRawAdd

  5774 nsHashtable::Put(nsHashKey *, void *)

  5775 nsOutlinerStyleCache::GetStyleContext(nsICSSPseudoComparator *, nsIPresContext *, nsIContent *, nsIStyleContext *, nsIAtom *, nsISupportsArray *, nsIStyleContext **)

  5777 # ----------------------------------------------------------------------

  5778 #

  5779 # nsMsgDatabase

  5780 #

  5782 <nsMsgDatabase>

  5783 PL_DHashAllocTable

  5784 PL_DHashTableFinish

  5785 PL_DHashTableOperate

  5786 nsMsgDatabase::AddHdrToCache(nsIMsgDBHdr *, unsigned int)

  5788 <nsMsgDatabase>

  5789 PL_DHashAllocTable

  5790 PL_DHashTableFinish

  5791 PL_DHashTableOperate

  5792 nsMsgDatabase::AddHdrToUseCache(nsIMsgDBHdr *, unsigned int)

  5794 # ----------------------------------------------------------------------

  5795 #

  5796 # nsMsgFolderDataSource

  5797 #

  5799 <nsMsgFolderDataSource>

  5800 __builtin_new

  5801 __builtin_vec_new

  5802 nsSupportsArray::GrowArrayBy(int)

  5803 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  5804 nsSupportsArray::AppendElement(nsISupports *)

  5805 nsMsgFolderDataSource::getFolderArcLabelsOut(nsISupportsArray **)

  5807 # ----------------------------------------------------------------------

  5808 #

  5809 # singsign

  5810 #

  5812 <SINGSIGN>

  5813 __builtin_new

  5814 SI_DeletePersistentUserData

  5816 # ----------------------------------------------------------------------

  5817 #

  5818 # LocalStoreImpl

  5819 #

  5821 <LocalStoreImpl>

  5822 __builtin_new

  5823 __builtin_vec_new

  5824 nsSupportsArray::GrowArrayBy(int)

  5825 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int)

  5826 nsSupportsArray::AppendElement(nsISupports *)

  5827 LocalStoreImpl::AddObserver(nsIRDFObserver *)

  5829 # ----------------------------------------------------------------------

  5830 #

  5831 # NSS

  5832 #

  5834 <NSS>

  5835 PR_Malloc

  5836 PL_ArenaAllocate

  5837 PORT_ArenaAlloc

  5839 <NSS>

  5840 PR_Malloc

  5841 PL_ArenaAllocate

  5842 nss_ZAlloc

The Tor Browser / file revision

tools/trace-malloc/types.dat@97036ab72558

tools/trace-malloc/types.dat