The Tor Browser / file comparison
comparison: tools/trace-malloc/types.dat
tools/trace-malloc/types.dat
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:dc39316586a9 |
|---|---|
| 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/. | |
| 4 | |
| 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. | |
| 17 | |
| 18 # Here's a handy regexp for cleaning up strings copied from the | |
| 19 # uncategorized file: | |
| 20 # | |
| 21 # \(^ *([0-9]+) \|\[.*\]$\) | |
| 22 # | |
| 23 | |
| 24 #---------------------------------------------------------------------- | |
| 25 | |
| 26 <nsStringRecycler> | |
| 27 __builtin_new | |
| 28 __builtin_vec_new | |
| 29 nsDeque::GrowCapacity(void) | |
| 30 nsDeque::Push(void *) | |
| 31 nsStringRecycler::Recycle(nsString *) | |
| 32 | |
| 33 #---------------------------------------------------------------------- | |
| 34 # | |
| 35 # AtomImpl | |
| 36 # | |
| 37 | |
| 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 &) | |
| 42 | |
| 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 &) | |
| 50 | |
| 51 <AtomImpl> | |
| 52 PR_Malloc | |
| 53 PL_ArenaFinish | |
| 54 PL_HashTableRawAdd | |
| 55 NS_NewAtom(nsAString const &) | |
| 56 NS_NewAtom(char const *) | |
| 57 | |
| 58 <AtomImpl> | |
| 59 PR_Malloc | |
| 60 PL_ArenaFinish | |
| 61 PL_HashTableRawAdd | |
| 62 NS_NewAtom(nsAString const &) | |
| 63 NS_NewAtom(unsigned short const *) | |
| 64 | |
| 65 #---------------------------------------------------------------------- | |
| 66 | |
| 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 &) | |
| 80 | |
| 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 &) | |
| 95 | |
| 96 <nsCSSRule> | |
| 97 __builtin_new | |
| 98 nsCSSRule::operator new(unsigned int) | |
| 99 | |
| 100 #---------------------------------------------------------------------- | |
| 101 # | |
| 102 # CSSLoaderImpl | |
| 103 # | |
| 104 | |
| 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) | |
| 111 | |
| 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 &) | |
| 124 | |
| 125 <CSSLoaderImpl> | |
| 126 PL_strdup | |
| 127 URLKey::Clone(void) const | |
| 128 nsHashtable::Put(nsHashKey *, void *) | |
| 129 CSSLoaderImpl::SheetComplete(nsICSSStyleSheet *, SheetLoadData *) | |
| 130 | |
| 131 #---------------------------------------------------------------------- | |
| 132 | |
| 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 &) | |
| 146 | |
| 147 #---------------------------------------------------------------------- | |
| 148 # | |
| 149 # nsFont | |
| 150 # | |
| 151 | |
| 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 &) | |
| 164 | |
| 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) | |
| 177 | |
| 178 #---------------------------------------------------------------------- | |
| 179 | |
| 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 &) | |
| 193 | |
| 194 <nsClassList> | |
| 195 __builtin_new | |
| 196 nsClassList::ParseClasses(nsClassList **, basic_nsAReadableString<unsigned short> const &) | |
| 197 | |
| 198 # ---------------------------------------------------------------------- | |
| 199 # | |
| 200 # nsLocalFile | |
| 201 # | |
| 202 | |
| 203 <nsLocalFile> | |
| 204 __builtin_new | |
| 205 nsLocalFile::Clone(nsIFile **) | |
| 206 | |
| 207 <nsLocalFile> | |
| 208 PR_Malloc | |
| 209 _PR_Getfd | |
| 210 PR_GetConnectStatus | |
| 211 PR_OpenFile | |
| 212 PR_Open | |
| 213 nsLocalFile::OpenNSPRFileDesc(int, int, PRFileDesc **) | |
| 214 | |
| 215 <nsLocalFile> | |
| 216 PR_Calloc | |
| 217 PR_LoadLibrary | |
| 218 PR_LoadLibraryWithFlags | |
| 219 PR_LoadLibrary | |
| 220 nsLocalFile::Load(PRLibrary **) | |
| 221 | |
| 222 <nsLocalFile> | |
| 223 __strdup | |
| 224 PR_LoadLibrary | |
| 225 PR_LoadLibraryWithFlags | |
| 226 PR_LoadLibrary | |
| 227 nsLocalFile::Load(PRLibrary **) | |
| 228 | |
| 229 <nsLocalFile> | |
| 230 PR_Malloc | |
| 231 nsMemoryImpl::Alloc(unsigned int) | |
| 232 nsMemory::Alloc(unsigned int) | |
| 233 ToNewCString(nsACString const &) | |
| 234 nsLocalFile::AppendRelativePath(char const *) | |
| 235 | |
| 236 <nsLocalFile> | |
| 237 PR_Malloc | |
| 238 nsMemoryImpl::Alloc(unsigned int) | |
| 239 nsMemory::Clone(void const *, unsigned int) | |
| 240 nsLocalFile::InitWithPath(char const *) | |
| 241 | |
| 242 <nsLocalFile> | |
| 243 PL_strdup | |
| 244 nsLocalFile::ParseURL(char const *, char **, char **, char **, char **) | |
| 245 | |
| 246 # ---------------------------------------------------------------------- | |
| 247 | |
| 248 <nsXULAttribute> | |
| 249 __builtin_new | |
| 250 nsXULAttribute::operator new(unsigned int) | |
| 251 | |
| 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) | |
| 259 | |
| 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) | |
| 266 | |
| 267 <nsXULAttributes> | |
| 268 __builtin_new | |
| 269 nsXULAttributes::Create(nsIContent *, nsXULAttributes **) | |
| 270 | |
| 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 &) | |
| 279 | |
| 280 <nsXULElement> | |
| 281 __builtin_new | |
| 282 nsXULElement::Create(nsINodeInfo *, nsIContent **) | |
| 283 | |
| 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) | |
| 291 | |
| 292 <nsXULElement> | |
| 293 PR_Realloc | |
| 294 nsVoidArray::SizeTo(int) | |
| 295 nsVoidArray::GrowArrayBy(int) | |
| 296 nsVoidArray::InsertElementAt(void *, int) | |
| 297 nsXULElement::AppendChildTo(nsIContent *, int, int) | |
| 298 | |
| 299 <nsXULElement> | |
| 300 __builtin_new | |
| 301 nsXULElement::EnsureSlots(void) | |
| 302 | |
| 303 <nsXULElement> | |
| 304 PR_Malloc | |
| 305 nsVoidArray::SizeTo(int) | |
| 306 nsVoidArray::GrowArrayBy(int) | |
| 307 nsVoidArray::InsertElementAt(void *, int) | |
| 308 nsXULElement::AppendChildTo(nsIContent *, int, int) | |
| 309 | |
| 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) | |
| 317 | |
| 318 <nsXULElement> | |
| 319 PR_Malloc | |
| 320 nsVoidArray::SizeTo(int) | |
| 321 nsVoidArray::GrowArrayBy(int) | |
| 322 nsVoidArray::InsertElementAt(void *, int) | |
| 323 nsXULElement::AddBroadcastListener(nsAString const &, nsIDOMElement *) | |
| 324 | |
| 325 <sscanf> | |
| 326 iconv_close | |
| 327 | |
| 328 <sscanf> | |
| 329 tsearch | |
| 330 | |
| 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 &) | |
| 338 | |
| 339 <CSSDeclarationImpl> | |
| 340 __builtin_new | |
| 341 CSSDeclarationImpl::AppendValue(nsCSSProperty, nsCSSValue const &) | |
| 342 | |
| 343 <CSSDeclarationImpl> | |
| 344 __builtin_new | |
| 345 CSSDeclarationImpl::SetValueImportant(nsCSSProperty) | |
| 346 | |
| 347 <CSSDeclarationImpl> | |
| 348 __builtin_new | |
| 349 CSSDeclarationImpl::operator new(unsigned int) | |
| 350 | |
| 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 &) | |
| 358 | |
| 359 <nsVoidArray> | |
| 360 __builtin_new | |
| 361 __builtin_vec_new | |
| 362 nsVoidArray::InsertElementAt(void *, int) | |
| 363 | |
| 364 <nsVoidArray> | |
| 365 __builtin_new | |
| 366 __builtin_vec_new | |
| 367 nsVoidArray::nsVoidArray(int) | |
| 368 | |
| 369 <nsVoidArray> | |
| 370 __builtin_new | |
| 371 __builtin_vec_new | |
| 372 nsVoidArray::Compact(void) | |
| 373 | |
| 374 <nsVoidArray> | |
| 375 __builtin_new | |
| 376 __builtin_vec_new | |
| 377 nsVoidArray::ReplaceElementAt(void *, int) | |
| 378 | |
| 379 <nsGenericHTMLContainerElement> | |
| 380 __builtin_new | |
| 381 nsCheapVoidArray::SwitchToVector(void) | |
| 382 nsCheapVoidArray::AppendElement(void *) | |
| 383 nsGenericHTMLContainerElement::AppendChildTo(nsIContent *, int) | |
| 384 | |
| 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) | |
| 393 | |
| 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) | |
| 402 | |
| 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) | |
| 411 | |
| 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 &) | |
| 427 | |
| 428 <nsSupportsArray> | |
| 429 __builtin_new | |
| 430 __builtin_vec_new | |
| 431 nsSupportsArray::InsertElementAt(nsISupports *, unsigned int) | |
| 432 | |
| 433 <nsSupportsArray> | |
| 434 __builtin_new | |
| 435 nsSupportsArray::Create(nsISupports *, nsID const &, void **) | |
| 436 | |
| 437 <nsZipArchive> | |
| 438 __builtin_new | |
| 439 __builtin_vec_new | |
| 440 nsZipArchive::BuildFileList(void) | |
| 441 | |
| 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 **) | |
| 450 | |
| 451 <InMemoryDataSource> | |
| 452 __builtin_new | |
| 453 __builtin_vec_new | |
| 454 InMemoryDataSource::AllocTable(void *, unsigned int) | |
| 455 | |
| 456 <InMemoryDataSource> | |
| 457 PL_DHashAllocTable | |
| 458 PL_DHashTableFinish | |
| 459 PL_DHashTableOperate | |
| 460 InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int) | |
| 461 | |
| 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 *) | |
| 468 | |
| 469 <InMemoryDataSource> | |
| 470 PR_Malloc | |
| 471 PL_ArenaAllocate | |
| 472 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 473 InMemoryDataSource::AllocEntry(void *, void const *) | |
| 474 | |
| 475 <InMemoryDataSource> | |
| 476 PR_Malloc | |
| 477 PL_ArenaAllocate | |
| 478 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 479 Assertion::operator new(unsigned int, nsFixedSizeAllocator &) | |
| 480 | |
| 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 *) | |
| 489 | |
| 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 *) | |
| 498 | |
| 499 <InMemoryDataSource> | |
| 500 PL_DHashAllocTable | |
| 501 PL_DHashTableInit | |
| 502 InMemoryDataSource::Init(void) | |
| 503 | |
| 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 &) | |
| 519 | |
| 520 <xptiTypelibGuts> | |
| 521 __builtin_new | |
| 522 __builtin_vec_new | |
| 523 xptiTypelibGuts::xptiTypelibGuts(XPTHeader *) | |
| 524 | |
| 525 # ---------------------------------------------------------------------- | |
| 526 # | |
| 527 # nsPluginTag | |
| 528 # | |
| 529 | |
| 530 <nsPluginTag> | |
| 531 __builtin_new | |
| 532 __builtin_vec_new | |
| 533 nsPluginTag::nsPluginTag(nsPluginInfo *) | |
| 534 | |
| 535 <nsPluginTag> | |
| 536 __builtin_new | |
| 537 __builtin_vec_new | |
| 538 new_str(char const *) | |
| 539 nsPluginTag::nsPluginTag(nsPluginInfo *) | |
| 540 | |
| 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) | |
| 545 | |
| 546 <nsPluginTag> | |
| 547 __builtin_new | |
| 548 __builtin_vec_new | |
| 549 nsPluginTag::nsPluginTag(nsPluginTag *) | |
| 550 | |
| 551 #---------------------------------------------------------------------- | |
| 552 # | |
| 553 # nsXBLInsertionPoint | |
| 554 # | |
| 555 | |
| 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 *) | |
| 563 | |
| 564 #---------------------------------------------------------------------- | |
| 565 # | |
| 566 # nsXBLBinding | |
| 567 # | |
| 568 | |
| 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 **) | |
| 576 | |
| 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 **) | |
| 583 | |
| 584 <nsXBLBinding> | |
| 585 __builtin_new | |
| 586 nsXBLBinding::GetInsertionPointsFor(nsIContent *, nsISupportsArray **) | |
| 587 | |
| 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 *) | |
| 595 | |
| 596 # ---------------------------------------------------------------------- | |
| 597 # | |
| 598 # nsXBLPrototypeBinding | |
| 599 # | |
| 600 | |
| 601 <nsXBLPrototypeBinding> | |
| 602 __builtin_new | |
| 603 nsXBLPrototypeBinding::InitClass(nsCString const &, nsIScriptContext *, void *, void **) | |
| 604 | |
| 605 <nsXBLPrototypeBinding> | |
| 606 __builtin_new | |
| 607 nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent *) | |
| 608 | |
| 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 *) | |
| 615 | |
| 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 **) | |
| 624 | |
| 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 *) | |
| 632 | |
| 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 *) | |
| 639 | |
| 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 *) | |
| 646 | |
| 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 *) | |
| 654 | |
| 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 *) | |
| 661 | |
| 662 <nsXBLPrototypeBinding> | |
| 663 __builtin_new | |
| 664 nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *) | |
| 665 | |
| 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 *) | |
| 673 | |
| 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 *) | |
| 680 | |
| 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 **) | |
| 688 | |
| 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 *) | |
| 703 | |
| 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 **) | |
| 711 | |
| 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 *) | |
| 719 | |
| 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 **) | |
| 726 | |
| 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 *) | |
| 733 | |
| 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 *) | |
| 740 | |
| 741 <nsXBLPrototypeBinding> | |
| 742 PR_Malloc | |
| 743 PL_ArenaAllocate | |
| 744 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 745 nsXBLAttributeEntry::Create(nsIAtom *, nsIAtom *, nsIContent *) | |
| 746 nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *) | |
| 747 | |
| 748 #---------------------------------------------------------------------- | |
| 749 # | |
| 750 # <nsXBLPrototypeProperty> | |
| 751 # | |
| 752 | |
| 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 *) | |
| 768 | |
| 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 *) | |
| 784 | |
| 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 *) | |
| 800 | |
| 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 *) | |
| 814 | |
| 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 *) | |
| 829 | |
| 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 *) | |
| 838 | |
| 839 # ---------------------------------------------------------------------- | |
| 840 # | |
| 841 # The frame arena | |
| 842 # | |
| 843 | |
| 844 <FrameArena> | |
| 845 PR_Malloc | |
| 846 PL_ArenaAllocate | |
| 847 FrameArena::AllocateFrame(unsigned int, void **) | |
| 848 | |
| 849 <PresShell> | |
| 850 PR_Malloc | |
| 851 PL_ArenaAllocate | |
| 852 nsDST::NodeArena::AllocLeafNode(void) | |
| 853 nsDST::Insert(void *, void *, void **) | |
| 854 PresShell::SetSubShellFor(nsIContent *, nsISupports *) | |
| 855 | |
| 856 <PresShell> | |
| 857 PR_Malloc | |
| 858 nsVoidArray::SizeTo(int) | |
| 859 nsVoidArray::GrowArrayBy(int) | |
| 860 nsVoidArray::InsertElementAt(void *, int) | |
| 861 PresShell::AppendReflowCommandInternal(nsIReflowCommand *, nsVoidArray &) | |
| 862 | |
| 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 *) | |
| 871 | |
| 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 *) | |
| 878 | |
| 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 *) | |
| 886 | |
| 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 *) | |
| 893 | |
| 894 # ---------------------------------------------------------------------- | |
| 895 # | |
| 896 # StackArena | |
| 897 # | |
| 898 | |
| 899 <StackArena> | |
| 900 PR_Malloc | |
| 901 StackArena::StackArena(void) | |
| 902 | |
| 903 <StackArena> | |
| 904 PR_Malloc | |
| 905 StackArena::Allocate(unsigned int, void **) | |
| 906 | |
| 907 <StackArena> | |
| 908 PR_Malloc | |
| 909 StackBlock::StackBlock(void) | |
| 910 StackArena::StackArena(void) | |
| 911 | |
| 912 <StackArena> | |
| 913 __builtin_new | |
| 914 __builtin_vec_new | |
| 915 StackArena::StackArena(void) | |
| 916 | |
| 917 <StackArena> | |
| 918 PR_Malloc | |
| 919 StackArena::Allocate(unsigned int, void **) | |
| 920 | |
| 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 *) | |
| 927 | |
| 928 | |
| 929 # ---------------------------------------------------------------------- | |
| 930 # | |
| 931 # nsFrameManager | |
| 932 # | |
| 933 | |
| 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 **) | |
| 940 | |
| 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 *)) | |
| 948 | |
| 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 *) | |
| 957 | |
| 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 *)) | |
| 966 | |
| 967 <FrameManager> | |
| 968 PR_Malloc | |
| 969 PL_ArenaFinish | |
| 970 PL_HashTableRawAdd | |
| 971 FrameHashTable::Put(void *, void *) | |
| 972 FrameManager::SetPlaceholderFrameFor(nsIFrame *, nsIFrame *) | |
| 973 | |
| 974 <FrameManager> | |
| 975 __builtin_new | |
| 976 nsDST::NewMemoryArena(unsigned int) | |
| 977 FrameManager::Init(nsIPresShell *, nsIStyleSet *) | |
| 978 | |
| 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 *) | |
| 986 | |
| 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 *)) | |
| 993 | |
| 994 <FrameManager> | |
| 995 PR_Malloc | |
| 996 PL_ArenaAllocate | |
| 997 nsDST::NodeArena::AllocLeafNode(void) | |
| 998 nsDST::Insert(void *, void *, void **) | |
| 999 FrameManager::SetPrimaryFrameFor(nsIContent *, nsIFrame *) | |
| 1000 | |
| 1001 <UndisplayedMap> | |
| 1002 PR_Malloc | |
| 1003 PL_ArenaFinish | |
| 1004 PL_HashTableRawAdd | |
| 1005 UndisplayedMap::AppendNodeFor(UndisplayedNode *, nsIContent *) | |
| 1006 | |
| 1007 <UndisplayedMap> | |
| 1008 __builtin_new | |
| 1009 UndisplayedMap::AddNodeFor(nsIContent *, nsIContent *, nsIStyleContext *) | |
| 1010 | |
| 1011 <UndisplayedMap> | |
| 1012 PR_Malloc | |
| 1013 PL_ArenaFinish | |
| 1014 PL_NewHashTable | |
| 1015 UndisplayedMap::UndisplayedMap(unsigned int) | |
| 1016 | |
| 1017 <PRLock> | |
| 1018 PR_Calloc | |
| 1019 PR_NewLock | |
| 1020 | |
| 1021 <PRMonitor> | |
| 1022 PR_Calloc | |
| 1023 PR_NewMonitor | |
| 1024 | |
| 1025 # ---------------------------------------------------------------------- | |
| 1026 # | |
| 1027 # RDFServiceImpl | |
| 1028 # | |
| 1029 | |
| 1030 <RDFServiceImpl> | |
| 1031 PR_Malloc | |
| 1032 PL_ArenaFinish | |
| 1033 PL_NewHashTable | |
| 1034 RDFServiceImpl::Init(void) | |
| 1035 | |
| 1036 <RDFServiceImpl> | |
| 1037 PR_Malloc | |
| 1038 nsRDFParserUtils::GetQuotedAttributeValue(nsString const &, nsString const &, nsString &) | |
| 1039 PL_HashTableRawAdd | |
| 1040 PL_HashTableAdd | |
| 1041 RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int) | |
| 1042 | |
| 1043 <RDFServiceImpl> | |
| 1044 PR_Malloc | |
| 1045 PL_ArenaFinish | |
| 1046 PL_HashTableRawAdd | |
| 1047 RDFServiceImpl::RegisterResource(nsIRDFResource *, int) | |
| 1048 | |
| 1049 <RDFServiceImpl> | |
| 1050 PR_Malloc | |
| 1051 PL_ArenaFinish | |
| 1052 PL_HashTableRawAdd | |
| 1053 PL_HashTableAdd | |
| 1054 RDFServiceImpl::RegisterLiteral(nsIRDFLiteral *, int) | |
| 1055 | |
| 1056 <RDFServiceImpl> | |
| 1057 PR_Malloc | |
| 1058 nsRDFParserUtils::IsJavaScriptLanguage(nsString const &, char const **) | |
| 1059 PL_NewHashTable | |
| 1060 RDFServiceImpl::Init(void) | |
| 1061 | |
| 1062 <RDFServiceImpl> | |
| 1063 PR_Malloc | |
| 1064 nsRDFParserUtils::IsJavaScriptLanguage(nsString const &, char const **) | |
| 1065 PL_HashTableRawAdd | |
| 1066 PL_HashTableAdd | |
| 1067 RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int) | |
| 1068 | |
| 1069 <RDFServiceImpl> | |
| 1070 PR_Malloc | |
| 1071 PL_ArenaFinish | |
| 1072 PL_HashTableRawRemove | |
| 1073 RDFServiceImpl::UnregisterResource(nsIRDFResource *) | |
| 1074 | |
| 1075 <RDFServiceImpl> | |
| 1076 PL_strdup | |
| 1077 RDFServiceImpl::RegisterDataSource(nsIRDFDataSource *, int) | |
| 1078 | |
| 1079 # ---------------------------------------------------------------------- | |
| 1080 | |
| 1081 <nsRDFResource> | |
| 1082 PR_Malloc | |
| 1083 nsMemoryImpl::Alloc(unsigned int) | |
| 1084 nsMemory::Alloc(unsigned int) | |
| 1085 nsRDFResource::Init(char const *) | |
| 1086 | |
| 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 &) | |
| 1102 | |
| 1103 <nsHTMLEntities> | |
| 1104 __builtin_new | |
| 1105 __builtin_vec_new | |
| 1106 nsHTMLEntities::AddRefTable(void) | |
| 1107 | |
| 1108 <nsHTMLEntities> | |
| 1109 __builtin_new | |
| 1110 nsAVLTree::AddItem(void *) | |
| 1111 nsHTMLEntities::AddRefTable(void) | |
| 1112 | |
| 1113 <nsStaticCaseInsensitiveNameTable> | |
| 1114 __builtin_new | |
| 1115 __builtin_vec_new | |
| 1116 nsStaticCaseInsensitiveNameTable::Init(char const **, int) | |
| 1117 | |
| 1118 <CNavDTD> | |
| 1119 __builtin_new | |
| 1120 CNavDTD::CNavDTD(void) | |
| 1121 | |
| 1122 <CNavDTD> | |
| 1123 __builtin_new | |
| 1124 __builtin_vec_new | |
| 1125 InitializeElementTable(void) | |
| 1126 CNavDTD::CNavDTD(void) | |
| 1127 | |
| 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) | |
| 1135 | |
| 1136 <COtherDTD> | |
| 1137 __builtin_new | |
| 1138 COtherDTD::COtherDTD(void) | |
| 1139 | |
| 1140 <nsScanner> | |
| 1141 PR_Malloc | |
| 1142 nsMemoryImpl::Alloc(unsigned int) | |
| 1143 nsMemory::Alloc(unsigned int) | |
| 1144 nsScanner::Append(char const *, unsigned int) | |
| 1145 | |
| 1146 <nsScanner> | |
| 1147 __builtin_new | |
| 1148 nsSlidingString::AppendBuffer(unsigned short *, unsigned short *, unsigned short *) | |
| 1149 nsScanner::AppendToBuffer(unsigned short *, unsigned short *, unsigned short *) | |
| 1150 | |
| 1151 <nsScanner> | |
| 1152 __builtin_new | |
| 1153 nsScanner::AppendToBuffer(unsigned short *, unsigned short *, unsigned short *) | |
| 1154 | |
| 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 &) | |
| 1162 | |
| 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 &) | |
| 1175 | |
| 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) | |
| 1188 | |
| 1189 <nsHTMLTokenizer> | |
| 1190 __builtin_new | |
| 1191 __builtin_vec_new | |
| 1192 nsDeque::GrowCapacity(void) | |
| 1193 nsDeque::Push(void *) | |
| 1194 nsHTMLTokenizer::ScanDocStructure(int) | |
| 1195 | |
| 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 *) | |
| 1202 | |
| 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) | |
| 1209 | |
| 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) | |
| 1216 | |
| 1217 # ---------------------------------------------------------------------- | |
| 1218 # | |
| 1219 # xptiWorkingSet | |
| 1220 # | |
| 1221 | |
| 1222 <xptiWorkingSet> | |
| 1223 __builtin_new | |
| 1224 __builtin_vec_new | |
| 1225 xptiWorkingSet::NewFileArray(unsigned int) | |
| 1226 | |
| 1227 <xptiWorkingSet> | |
| 1228 __builtin_new | |
| 1229 __builtin_vec_new | |
| 1230 xptiWorkingSet::ExtendFileArray(unsigned int) | |
| 1231 | |
| 1232 # ---------------------------------------------------------------------- | |
| 1233 | |
| 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 *) | |
| 1244 | |
| 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 &) | |
| 1257 | |
| 1258 <DeviceContextImpl> | |
| 1259 __builtin_new | |
| 1260 __builtin_vec_new | |
| 1261 DeviceContextImpl::DeviceContextImpl(void) | |
| 1262 | |
| 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) | |
| 1269 | |
| 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) | |
| 1275 | |
| 1276 <nsCompressedMap> | |
| 1277 __builtin_new | |
| 1278 __builtin_vec_new | |
| 1279 nsCompressedMap::nsCompressedMap(unsigned short *, unsigned int) | |
| 1280 | |
| 1281 <nsHTMLDocument> | |
| 1282 __builtin_new | |
| 1283 __builtin_vec_new | |
| 1284 nsHTMLDocument::nsHTMLDocument(void) | |
| 1285 | |
| 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) | |
| 1292 | |
| 1293 <nsHTMLDocument> | |
| 1294 PR_Malloc | |
| 1295 PL_HashTableFinalize(PLHashTable *) | |
| 1296 PL_HashTableRawAdd | |
| 1297 nsHashtable::Put(nsHashKey *, void *) | |
| 1298 nsHTMLDocument::InvalidateHashTables(void) | |
| 1299 | |
| 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 &) | |
| 1315 | |
| 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 &) | |
| 1331 | |
| 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 &) | |
| 1347 | |
| 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 &) | |
| 1362 | |
| 1363 #---------------------------------------------------------------------- | |
| 1364 # | |
| 1365 # XPC stuff | |
| 1366 # | |
| 1367 | |
| 1368 <Native2WrappedNativeMap> | |
| 1369 JS_DHashAllocTable | |
| 1370 JS_DHashTableInit | |
| 1371 JS_NewDHashTable | |
| 1372 Native2WrappedNativeMap::Native2WrappedNativeMap(int) | |
| 1373 | |
| 1374 <ClassInfo2WrappedNativeProtoMap> | |
| 1375 JS_DHashAllocTable | |
| 1376 JS_DHashTableInit | |
| 1377 JS_NewDHashTable | |
| 1378 ClassInfo2WrappedNativeProtoMap::ClassInfo2WrappedNativeProtoMap(int) | |
| 1379 | |
| 1380 <IID2NativeInterfaceMap> | |
| 1381 JS_DHashAllocTable | |
| 1382 JS_DHashTableInit | |
| 1383 JS_NewDHashTable | |
| 1384 IID2NativeInterfaceMap::IID2NativeInterfaceMap(int) | |
| 1385 | |
| 1386 <IID2WrappedJSClassMap> | |
| 1387 JS_DHashAllocTable | |
| 1388 JS_DHashTableInit | |
| 1389 JS_NewDHashTable | |
| 1390 IID2WrappedJSClassMap::IID2WrappedJSClassMap(int) | |
| 1391 | |
| 1392 <IID2ThisTranslatorMap> | |
| 1393 JS_DHashAllocTable | |
| 1394 JS_DHashTableInit | |
| 1395 JS_NewDHashTable | |
| 1396 IID2ThisTranslatorMap::IID2ThisTranslatorMap(int) | |
| 1397 | |
| 1398 <XPCNativeScriptableSharedMap> | |
| 1399 JS_DHashAllocTable | |
| 1400 JS_DHashTableInit | |
| 1401 JS_NewDHashTable | |
| 1402 XPCNativeScriptableSharedMap::XPCNativeScriptableSharedMap(int) | |
| 1403 | |
| 1404 <XPCNativeScriptableSharedMap> | |
| 1405 __builtin_new | |
| 1406 XPCNativeScriptableSharedMap::GetNewOrUsed(unsigned int, char *, XPCNativeScriptableInfo *) | |
| 1407 | |
| 1408 <JSContext2XPCContextMap> | |
| 1409 JS_DHashAllocTable | |
| 1410 JS_DHashTableInit | |
| 1411 JS_NewDHashTable | |
| 1412 JSContext2XPCContextMap::JSContext2XPCContextMap(int) | |
| 1413 | |
| 1414 <NativeSetMap> | |
| 1415 JS_DHashAllocTable | |
| 1416 JS_DHashTableInit | |
| 1417 JS_NewDHashTable | |
| 1418 NativeSetMap::NativeSetMap(int) | |
| 1419 | |
| 1420 <JSObject2WrappedJSMap> | |
| 1421 JS_DHashAllocTable | |
| 1422 JS_DHashTableInit | |
| 1423 JS_NewDHashTable | |
| 1424 JSObject2WrappedJSMap::JSObject2WrappedJSMap(int) | |
| 1425 | |
| 1426 <nsXPCWrappedJS> | |
| 1427 JS_DHashAllocTable | |
| 1428 JS_DHashTableFinish | |
| 1429 JS_DHashTableOperate | |
| 1430 nsXPCWrappedJS::GetNewOrUsed(XPCCallContext &, JSObject *, nsID const &, nsISupports *, nsXPCWrappedJS **) | |
| 1431 | |
| 1432 <XPCWrappedNativeProtoMap> | |
| 1433 JS_DHashAllocTable | |
| 1434 JS_DHashTableInit | |
| 1435 JS_NewDHashTable | |
| 1436 XPCWrappedNativeProtoMap::XPCWrappedNativeProtoMap(int) | |
| 1437 | |
| 1438 <XPCWrappedNativeProto> | |
| 1439 JS_DHashAllocTable | |
| 1440 JS_DHashTableFinish | |
| 1441 JS_DHashTableOperate | |
| 1442 XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int) | |
| 1443 | |
| 1444 <XPCWrappedNativeProto> | |
| 1445 __builtin_new | |
| 1446 XPCWrappedNativeProto::GetNewOrUsed(XPCCallContext &, XPCWrappedNativeScope *, nsIClassInfo *, XPCNativeScriptableCreateInfo const *, int) | |
| 1447 | |
| 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) | |
| 1454 | |
| 1455 <XPCWrappedNativeProto> | |
| 1456 __builtin_new | |
| 1457 XPCNativeScriptableInfo::Construct(XPCCallContext &, XPCNativeScriptableCreateInfo const *) | |
| 1458 XPCWrappedNativeProto::Init(XPCCallContext &, XPCNativeScriptableCreateInfo const *) | |
| 1459 | |
| 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) | |
| 1466 | |
| 1467 <XPCWrappedNative> | |
| 1468 JS_DHashAllocTable | |
| 1469 JS_DHashTableFinish | |
| 1470 JS_DHashTableOperate | |
| 1471 XPCWrappedNative::~XPCWrappedNative(void) | |
| 1472 | |
| 1473 <XPCWrappedNative> | |
| 1474 __builtin_new | |
| 1475 XPCWrappedNative::FindTearOff(XPCCallContext &, XPCNativeInterface *, int, unsigned int *) | |
| 1476 | |
| 1477 <XPCWrappedNative> | |
| 1478 JS_DHashAllocTable | |
| 1479 JS_DHashTableFinish | |
| 1480 JS_DHashTableOperate | |
| 1481 XPCWrappedNative::GetNewOrUsed(XPCCallContext &, nsISupports *, XPCWrappedNativeScope *, XPCNativeInterface *, XPCWrappedNative **) | |
| 1482 | |
| 1483 <XPCWrappedNativeScope> | |
| 1484 JS_DHashAllocTable | |
| 1485 JS_DHashTableInit | |
| 1486 JS_NewDHashTable | |
| 1487 js_LookupProperty | |
| 1488 js_GetProperty | |
| 1489 XPCWrappedNativeScope::SetGlobal(XPCCallContext &, JSObject *) | |
| 1490 | |
| 1491 <nsXPCWrappedNativeClass> | |
| 1492 __builtin_new | |
| 1493 __builtin_vec_new | |
| 1494 nsXPCWrappedNativeClass::BuildMemberDescriptors(XPCContext *) | |
| 1495 | |
| 1496 #---------------------------------------------------------------------- | |
| 1497 | |
| 1498 <nsNetModuleMgr> | |
| 1499 __builtin_new | |
| 1500 __builtin_vec_new | |
| 1501 nsNetModRegEntry::nsNetModRegEntry(char const *, nsINetNotify *, unsigned int *) | |
| 1502 nsNetModuleMgr::RegisterModule(char const *, nsINetNotify *) | |
| 1503 | |
| 1504 <nsProxyObjectManager> | |
| 1505 __builtin_new | |
| 1506 nsProxyObjectManager::nsProxyObjectManager(void) | |
| 1507 | |
| 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) | |
| 1514 | |
| 1515 <nsProxyEventClass> | |
| 1516 __builtin_new | |
| 1517 __builtin_vec_new | |
| 1518 nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *) | |
| 1519 | |
| 1520 <nsProxyEventClass> | |
| 1521 __builtin_new | |
| 1522 nsHashtable::Put(nsHashKey *, void *) | |
| 1523 nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *) | |
| 1524 | |
| 1525 <nsProxyEventClass> | |
| 1526 PR_Malloc | |
| 1527 PL_HashTableFinalize(PLHashTable *) | |
| 1528 PL_HashTableRawAdd | |
| 1529 nsHashtable::Put(nsHashKey *, void *) | |
| 1530 nsProxyEventClass::nsProxyEventClass(nsID const &, nsIInterfaceInfo *) | |
| 1531 | |
| 1532 <nsProxyEventObject> | |
| 1533 __builtin_new | |
| 1534 nsProxyEventKey::Clone(void) const | |
| 1535 nsHashtable::Put(nsHashKey *, void *) | |
| 1536 nsProxyEventObject::GetNewOrUsedProxy(nsIEventQueue *, int, nsISupports *, nsID const &) | |
| 1537 | |
| 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 &) | |
| 1544 | |
| 1545 # ---------------------------------------------------------------------- | |
| 1546 # | |
| 1547 # nsComponentManagerImpl | |
| 1548 # | |
| 1549 | |
| 1550 <nsComponentManagerImpl> | |
| 1551 __builtin_new | |
| 1552 nsComponentManagerImpl::Init(void) | |
| 1553 | |
| 1554 <nsComponentManagerImpl> | |
| 1555 __builtin_new | |
| 1556 nsComponentManagerImpl::GetServiceByContractID(char const *, nsID const &, void **) | |
| 1557 | |
| 1558 <nsComponentManagerImpl> | |
| 1559 __builtin_new | |
| 1560 nsComponentManagerImpl::GetService(nsID const &, nsID const &, void **) | |
| 1561 | |
| 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) | |
| 1569 | |
| 1570 <nsComponentManagerImpl> | |
| 1571 __builtin_vec_new | |
| 1572 nsComponentManagerImpl::Init(void) | |
| 1573 | |
| 1574 <nsComponentManagerImpl> | |
| 1575 __builtin_new | |
| 1576 nsComponentManagerImpl::PlatformPrePopulateRegistry(void) | |
| 1577 | |
| 1578 <nsComponentManagerImpl> | |
| 1579 __builtin_new | |
| 1580 nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int) | |
| 1581 | |
| 1582 <nsComponentManagerImpl> | |
| 1583 __builtin_new | |
| 1584 nsCStringKey::Clone(void) const | |
| 1585 nsHashtable::Put(nsHashKey *, void *) | |
| 1586 nsComponentManagerImpl::PlatformPrePopulateRegistry(void) | |
| 1587 | |
| 1588 <nsComponentManagerImpl> | |
| 1589 __builtin_new | |
| 1590 nsCStringKey::Clone(void) const | |
| 1591 nsHashtable::Put(nsHashKey *, void *) | |
| 1592 nsComponentManagerImpl::HashContractID(char const *, nsID const &) | |
| 1593 | |
| 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) | |
| 1600 | |
| 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 **) | |
| 1607 | |
| 1608 <nsComponentManagerImpl> | |
| 1609 __builtin_new | |
| 1610 nsCStringKey::Clone(void) const | |
| 1611 nsHashtable::Put(nsHashKey *, void *) | |
| 1612 nsComponentManagerImpl::ContractIDToClassID(char const *, nsID *) | |
| 1613 | |
| 1614 <nsComponentManagerImpl> | |
| 1615 PR_Malloc | |
| 1616 PL_HashTableFinalize(PLHashTable *) | |
| 1617 PL_HashTableRawAdd | |
| 1618 nsHashtable::Put(nsHashKey *, void *) | |
| 1619 nsComponentManagerImpl::PlatformPrePopulateRegistry(void) | |
| 1620 | |
| 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) | |
| 1628 | |
| 1629 <nsComponentManagerImpl> | |
| 1630 __builtin_new | |
| 1631 nsHashtable::Put(nsHashKey *, void *) | |
| 1632 nsComponentManagerImpl::PlatformPrePopulateRegistry(void) | |
| 1633 | |
| 1634 <nsComponentManagerImpl> | |
| 1635 __builtin_new | |
| 1636 nsHashtable::Put(nsHashKey *, void *) | |
| 1637 nsComponentManagerImpl::RegisterFactory(nsID const &, char const *, char const *, nsIFactory *, int) | |
| 1638 | |
| 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) | |
| 1645 | |
| 1646 <nsComponentManagerImpl> | |
| 1647 PR_Malloc | |
| 1648 bufio_SetBufferSize | |
| 1649 nsXPTCStubBase::Sentinel9(void) | |
| 1650 NR_RegSetBufferSize | |
| 1651 nsRegistry::SetBufferSize(int) | |
| 1652 nsComponentManagerImpl::AutoRegister(int, nsIFile *) | |
| 1653 | |
| 1654 <nsComponentManagerImpl> | |
| 1655 __builtin_new | |
| 1656 nsComponentManagerImpl::HashContractID(char const *, nsID const &) | |
| 1657 | |
| 1658 <nsComponentManagerImpl> | |
| 1659 __builtin_new | |
| 1660 nsComponentManagerImpl::RegisterComponentCommon(nsID const &, char const *, char const *, char const *, int, int, char const *) | |
| 1661 | |
| 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 *) | |
| 1666 | |
| 1667 <nsComponentManagerImpl> | |
| 1668 PR_Malloc | |
| 1669 PL_HashTableFinalize(PLHashTable *) | |
| 1670 PL_HashTableRawAdd | |
| 1671 nsHashtable::Put(nsHashKey *, void *) | |
| 1672 nsComponentManagerImpl::HashContractID(char const *, nsID const &) | |
| 1673 | |
| 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) | |
| 1680 | |
| 1681 <nsComponentManagerImpl> | |
| 1682 PR_Malloc | |
| 1683 PL_HashTableFinalize(PLHashTable *) | |
| 1684 PL_HashTableRawAdd | |
| 1685 nsHashtable::Put(nsHashKey *, void *) | |
| 1686 nsComponentManagerImpl::ContractIDToClassID(char const *, nsID *) | |
| 1687 | |
| 1688 <nsComponentManagerImpl> | |
| 1689 PR_Malloc | |
| 1690 PL_HashTableFinalize(PLHashTable *) | |
| 1691 PL_HashTableRawAdd | |
| 1692 nsHashtable::Put(nsHashKey *, void *) | |
| 1693 nsComponentManagerImpl::HashContractID(char const *, nsFactoryEntry *) | |
| 1694 | |
| 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 *) | |
| 1702 | |
| 1703 <nsComponentManagerImpl> | |
| 1704 __builtin_new | |
| 1705 nsComponentManagerImpl::GetService(char const *, nsID const &, nsISupports **, nsIShutdownListener *) | |
| 1706 | |
| 1707 <nsComponentManagerImpl> | |
| 1708 __builtin_new | |
| 1709 nsComponentManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *) | |
| 1710 | |
| 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) | |
| 1726 | |
| 1727 <nsComponentManagerImpl> | |
| 1728 PL_strdup | |
| 1729 nsComponentManagerImpl::HashContractID(char const *, nsFactoryEntry *) | |
| 1730 | |
| 1731 <nsComponentManagerImpl> | |
| 1732 PL_strdup | |
| 1733 nsFactoryEntry::nsFactoryEntry(nsID const &, char const *, int) | |
| 1734 nsComponentManagerImpl::PlatformPrePopulateRegistry(void) | |
| 1735 | |
| 1736 <nsComponentManagerImpl> | |
| 1737 PL_DHashAllocTable | |
| 1738 PL_DHashTableInit | |
| 1739 nsComponentManagerImpl::Init(void) | |
| 1740 | |
| 1741 # ---------------------------------------------------------------------- | |
| 1742 | |
| 1743 <nsZipArchive> | |
| 1744 __builtin_new | |
| 1745 nsZipArchive::BuildFileList(void) | |
| 1746 | |
| 1747 <nsStaticCaseInsensitiveNameTable> | |
| 1748 __builtin_new | |
| 1749 nsStaticCaseInsensitiveNameTable::Init(char const **, int) | |
| 1750 | |
| 1751 <nsStaticCaseInsensitiveNameTable> | |
| 1752 __builtin_new | |
| 1753 nsCStringKey::Clone(void) const | |
| 1754 nsHashtable::Put(nsHashKey *, void *) | |
| 1755 nsStaticCaseInsensitiveNameTable::Init(char const **, int) | |
| 1756 | |
| 1757 <nsStaticCaseInsensitiveNameTable> | |
| 1758 PR_Malloc | |
| 1759 PL_HashTableFinalize(PLHashTable *) | |
| 1760 PL_HashTableRawAdd | |
| 1761 nsHashtable::Put(nsHashKey *, void *) | |
| 1762 nsStaticCaseInsensitiveNameTable::Init(char const **, int) | |
| 1763 | |
| 1764 # ---------------------------------------------------------------------- | |
| 1765 # | |
| 1766 # nsDrawingSurfaceGTK | |
| 1767 # | |
| 1768 | |
| 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) | |
| 1775 | |
| 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) | |
| 1782 | |
| 1783 <nsDrawingSurfaceGTK> | |
| 1784 __builtin_new | |
| 1785 nsCStringKey::Clone(void) const | |
| 1786 nsHashtable::Put(nsHashKey *, void *) | |
| 1787 nsDrawingSurfaceGTK type_info function | |
| 1788 | |
| 1789 <nsDrawingSurfaceGTK> | |
| 1790 PR_Malloc | |
| 1791 nsDrawingSurfaceGTK::Init(_GdkGC *, unsigned int, unsigned int, unsigned int) | |
| 1792 | |
| 1793 # ---------------------------------------------------------------------- | |
| 1794 # | |
| 1795 # nsNativeComponentLoader | |
| 1796 # | |
| 1797 | |
| 1798 <nsNativeComponentLoader> | |
| 1799 __builtin_new | |
| 1800 nsNativeComponentLoader::Init(nsIComponentManager *, nsISupports *) | |
| 1801 | |
| 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 *) | |
| 1809 | |
| 1810 <nsNativeComponentLoader> | |
| 1811 __builtin_new | |
| 1812 nsCStringKey::Clone(void) const | |
| 1813 nsHashtable::Put(nsHashKey *, void *) | |
| 1814 nsNativeComponentLoader::CreateDll | |
| 1815 | |
| 1816 <nsNativeComponentLoader> | |
| 1817 __builtin_new | |
| 1818 nsNativeComponentLoader::CreateDll(nsIFile *, char const *, long long *, long long *, nsDll **) | |
| 1819 | |
| 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 **) | |
| 1825 | |
| 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 **) | |
| 1832 | |
| 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 **) | |
| 1840 | |
| 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 **) | |
| 1845 | |
| 1846 # ---------------------------------------------------------------------- | |
| 1847 | |
| 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 *) | |
| 1854 | |
| 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) | |
| 1861 | |
| 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 *) | |
| 1869 | |
| 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 *) | |
| 1877 | |
| 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) | |
| 1885 | |
| 1886 #---------------------------------------------------------------------- | |
| 1887 # | |
| 1888 # nsResProtocolHandler | |
| 1889 # | |
| 1890 | |
| 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 *) | |
| 1897 | |
| 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) | |
| 1905 | |
| 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 *) | |
| 1913 | |
| 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 *) | |
| 1921 | |
| 1922 # ---------------------------------------------------------------------- | |
| 1923 # | |
| 1924 # nsChromeRegistry | |
| 1925 # | |
| 1926 | |
| 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 *) | |
| 1933 | |
| 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 *) | |
| 1941 | |
| 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 *) | |
| 1949 | |
| 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 *) | |
| 1958 | |
| 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 *) | |
| 1967 | |
| 1968 # ---------------------------------------------------------------------- | |
| 1969 | |
| 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 **) | |
| 1976 | |
| 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 **) | |
| 1984 | |
| 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) | |
| 1992 | |
| 1993 <nsZipReaderCache> | |
| 1994 __builtin_new | |
| 1995 nsZipReaderCache::GetZip(nsIFile *, nsIZipReader **) | |
| 1996 | |
| 1997 # ---------------------------------------------------------------------- | |
| 1998 # | |
| 1999 # nsXBLDocumentInfo | |
| 2000 # | |
| 2001 | |
| 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 *) | |
| 2009 | |
| 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 *) | |
| 2016 | |
| 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 *) | |
| 2023 | |
| 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 *) | |
| 2031 | |
| 2032 <nsXBLDocumentInfo> | |
| 2033 __builtin_new | |
| 2034 nsXBLDocumentInfo::SetPrototypeBinding(nsCString const &, nsIXBLPrototypeBinding *) | |
| 2035 | |
| 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 *) | |
| 2043 | |
| 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 *) | |
| 2051 | |
| 2052 <nsXBLDocumentInfo> | |
| 2053 __builtin_new | |
| 2054 nsXBLDocumentInfo::SetPrototypeBinding(basic_nsAReadableString<char> const &, nsIXBLPrototypeBinding *) | |
| 2055 | |
| 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 *) | |
| 2071 | |
| 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 *) | |
| 2080 | |
| 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 *) | |
| 2094 | |
| 2095 <nsXBLDocumentInfo> | |
| 2096 __builtin_new | |
| 2097 nsXBLDocumentInfo::SetPrototypeBinding(nsACString const &, nsIXBLPrototypeBinding *) | |
| 2098 | |
| 2099 # ---------------------------------------------------------------------- | |
| 2100 # | |
| 2101 # nsXULPrototypeCache | |
| 2102 # | |
| 2103 | |
| 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 *) | |
| 2110 | |
| 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 *) | |
| 2118 | |
| 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) | |
| 2125 | |
| 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 *) | |
| 2133 | |
| 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 *) | |
| 2141 | |
| 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) | |
| 2149 | |
| 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 *) | |
| 2158 | |
| 2159 <nsXULPrototypeCache> | |
| 2160 PR_Malloc | |
| 2161 PL_HashTableFinalize(PLHashTable *) | |
| 2162 PL_HashTableRawAdd | |
| 2163 nsHashtable::Put(nsHashKey *, void *) | |
| 2164 nsXULPrototypeCache::PutScript(nsIURI *, void *) | |
| 2165 | |
| 2166 # nsXULPrototypeElement | |
| 2167 <nsXULPrototypeCache> | |
| 2168 __builtin_new | |
| 2169 XULContentSinkImpl::CreateElement(nsINodeInfo *, nsXULPrototypeElement **) | |
| 2170 | |
| 2171 # nsXULPrototypeNode | |
| 2172 <nsXULPrototypeCache> | |
| 2173 __builtin_new | |
| 2174 __builtin_vec_new | |
| 2175 XULContentSinkImpl::CloseContainer(nsIParserNode const &) | |
| 2176 | |
| 2177 # nsXULPrototypeScript | |
| 2178 <nsXULPrototypeCache> | |
| 2179 __builtin_new | |
| 2180 XULContentSinkImpl::OpenScript(nsIParserNode const &) | |
| 2181 | |
| 2182 # ---------------------------------------------------------------------- | |
| 2183 # | |
| 2184 # nsExternalHelperAppService | |
| 2185 # | |
| 2186 | |
| 2187 <nsExternalHelperAppService> | |
| 2188 __builtin_new | |
| 2189 nsExternalHelperAppService::nsExternalHelperAppService(void) | |
| 2190 | |
| 2191 <nsExternalHelperAppService> | |
| 2192 __builtin_new | |
| 2193 nsCStringKey::Clone(void) const | |
| 2194 nsHashtable::Put(nsHashKey *, void *) | |
| 2195 nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *) | |
| 2196 | |
| 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 *) | |
| 2204 | |
| 2205 <nsExternalHelperAppService> | |
| 2206 PR_Malloc | |
| 2207 PL_HashTableFinalize(PLHashTable *) | |
| 2208 PL_HashTableRawAdd | |
| 2209 nsHashtable::Put(nsHashKey *, void *) | |
| 2210 nsExternalHelperAppService::AddMimeInfoToCache(nsIMIMEInfo *) | |
| 2211 | |
| 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 *) | |
| 2219 | |
| 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) | |
| 2228 | |
| 2229 # ---------------------------------------------------------------------- | |
| 2230 # | |
| 2231 # nsCategoryManager | |
| 2232 # | |
| 2233 | |
| 2234 <nsCategoryManager> | |
| 2235 __builtin_new | |
| 2236 nsCategoryManager::AddCategoryEntry(char const *, char const *, char const *, int, int, char **) | |
| 2237 | |
| 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 **) | |
| 2245 | |
| 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 **) | |
| 2251 | |
| 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 **) | |
| 2259 | |
| 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 **) | |
| 2268 | |
| 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) | |
| 2276 | |
| 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 **) | |
| 2285 | |
| 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) | |
| 2293 | |
| 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 **) | |
| 2300 | |
| 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 **) | |
| 2308 | |
| 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 **) | |
| 2316 | |
| 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 **) | |
| 2331 | |
| 2332 # ---------------------------------------------------------------------- | |
| 2333 # | |
| 2334 # nsScriptNameSpaceManager | |
| 2335 # | |
| 2336 | |
| 2337 <nsScriptNameSpaceManager> | |
| 2338 PR_Malloc | |
| 2339 PL_HashTableFinalize(PLHashTable *) | |
| 2340 PL_HashTableRawAdd | |
| 2341 nsHashtable::Put(nsHashKey *, void *) | |
| 2342 nsScriptNameSpaceManager::RegisterClassName(char const *, int) | |
| 2343 | |
| 2344 <nsScriptNameSpaceManager> | |
| 2345 PR_Malloc | |
| 2346 PL_HashTableFinalize(PLHashTable *) | |
| 2347 PL_HashTableRawAdd | |
| 2348 nsHashtable::Put(nsHashKey *, void *) | |
| 2349 nsScriptNameSpaceManager::FillHashWithDOMInterfaces(void) | |
| 2350 | |
| 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) | |
| 2357 | |
| 2358 <nsScriptNameSpaceManager> | |
| 2359 __builtin_new | |
| 2360 nsScriptNameSpaceManager::RegisterClassName(char const *, int) | |
| 2361 | |
| 2362 # ---------------------------------------------------------------------- | |
| 2363 # | |
| 2364 # nsScriptSecurityManager | |
| 2365 # | |
| 2366 | |
| 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 *) | |
| 2373 | |
| 2374 <nsScriptSecurityManager> | |
| 2375 __builtin_new | |
| 2376 nsScriptSecurityManager::EnumeratePolicyCallback(char const *, void *) | |
| 2377 | |
| 2378 <nsScriptSecurityManager> | |
| 2379 __builtin_new | |
| 2380 nsCStringKey::Clone(void) const | |
| 2381 nsHashtable::Put(nsHashKey *, void *) | |
| 2382 nsScriptSecurityManager::EnumeratePolicyCallback(char const *, void *) | |
| 2383 | |
| 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) | |
| 2391 | |
| 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 *) | |
| 2399 | |
| 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 *) | |
| 2407 | |
| 2408 # ---------------------------------------------------------------------- | |
| 2409 # | |
| 2410 # nsStringBundleService | |
| 2411 # | |
| 2412 | |
| 2413 <nsStringBundleService> | |
| 2414 __builtin_new | |
| 2415 nsCStringKey::Clone(void) const | |
| 2416 nsHashtable::Put(nsHashKey *, void *) | |
| 2417 nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *) | |
| 2418 | |
| 2419 <nsStringBundleService> | |
| 2420 PR_Malloc | |
| 2421 PL_HashTableFinalize(PLHashTable *) | |
| 2422 PL_HashTableRawAdd | |
| 2423 nsHashtable::Put(nsHashKey *, void *) | |
| 2424 nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *) | |
| 2425 | |
| 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) | |
| 2432 | |
| 2433 <nsStringBundleService> | |
| 2434 PR_Malloc | |
| 2435 PL_ArenaAllocate | |
| 2436 nsStringBundleService::insertIntoCache(nsIStringBundle *, nsCStringKey *) | |
| 2437 | |
| 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 *) | |
| 2445 | |
| 2446 # ---------------------------------------------------------------------- | |
| 2447 | |
| 2448 <CSSStyleSheetImpl> | |
| 2449 __builtin_new | |
| 2450 CSSStyleSheetImpl::CSSStyleSheetImpl(void) | |
| 2451 | |
| 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 *) | |
| 2459 | |
| 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 *) | |
| 2467 | |
| 2468 <CSSStyleSheetImpl> | |
| 2469 __builtin_new | |
| 2470 AtomKey::Clone(void) const | |
| 2471 nsHashtable::Put(nsHashKey *, void *) | |
| 2472 CSSStyleSheetImpl::CheckRuleForAttributes(nsICSSRule *) | |
| 2473 | |
| 2474 <CSSStyleSheetImpl> | |
| 2475 PR_Malloc | |
| 2476 PL_HashTableFinalize(PLHashTable *) | |
| 2477 PL_HashTableRawAdd | |
| 2478 nsHashtable::Put(nsHashKey *, void *) | |
| 2479 CSSStyleSheetImpl::CheckRuleForAttributes(nsICSSRule *) | |
| 2480 | |
| 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 *) | |
| 2487 | |
| 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) | |
| 2494 | |
| 2495 <HTMLStyleSheetImpl> | |
| 2496 PR_Malloc | |
| 2497 PL_HashTableFinalize(PLHashTable *) | |
| 2498 PL_HashTableRawRemove | |
| 2499 nsHashtable::Remove(nsHashKey *) | |
| 2500 HTMLStyleSheetImpl::DropMappedAttributes(nsIHTMLMappedAttributes *) | |
| 2501 | |
| 2502 <HTMLStyleSheetImpl> | |
| 2503 __builtin_new | |
| 2504 AttributeKey::Clone(void) const | |
| 2505 nsHashtable::Put(nsHashKey *, void *) | |
| 2506 HTMLStyleSheetImpl::UniqueMappedAttributes(nsIHTMLMappedAttributes *, nsIHTMLMappedAttributes *&) | |
| 2507 | |
| 2508 <HTMLStyleSheetImpl> | |
| 2509 PR_Malloc | |
| 2510 PL_HashTableFinalize(PLHashTable *) | |
| 2511 PL_HashTableRawAdd | |
| 2512 nsHashtable::Put(nsHashKey *, void *) | |
| 2513 HTMLStyleSheetImpl::UniqueMappedAttributes(nsIHTMLMappedAttributes *, nsIHTMLMappedAttributes *&) | |
| 2514 | |
| 2515 <nsStyleContextData> | |
| 2516 __builtin_new | |
| 2517 nsStyleContextData::Create(nsIPresContext *) | |
| 2518 | |
| 2519 <nsStyleContent> | |
| 2520 __builtin_new | |
| 2521 __builtin_vec_new | |
| 2522 nsStyleContent::AllocateCounterResets(unsigned int) | |
| 2523 | |
| 2524 <nsStyleContent> | |
| 2525 __builtin_new | |
| 2526 __builtin_vec_new | |
| 2527 nsStyleContent::AllocateContents(unsigned int) | |
| 2528 | |
| 2529 <xptiManifest> | |
| 2530 __builtin_new | |
| 2531 xptiManifest::Read(xptiInterfaceInfoManager *, xptiWorkingSet *) | |
| 2532 | |
| 2533 <xptiManifest> | |
| 2534 PR_Malloc | |
| 2535 PL_ArenaFinish | |
| 2536 PL_HashTableRawAdd | |
| 2537 PL_HashTableAdd | |
| 2538 xptiManifest::Read(xptiInterfaceInfoManager *, xptiWorkingSet *) | |
| 2539 | |
| 2540 <CSSParserImpl> | |
| 2541 __builtin_new | |
| 2542 SelectorList::AddSelector(nsCSSSelector const &) | |
| 2543 CSSParserImpl::ParseSelectorGroup(int &, SelectorList *&) | |
| 2544 | |
| 2545 <CSSParserImpl> | |
| 2546 __builtin_new | |
| 2547 CSSParserImpl::ParseContent(int &, nsICSSDeclaration *, int &) | |
| 2548 | |
| 2549 # ---------------------------------------------------------------------- | |
| 2550 # | |
| 2551 # RuleHash | |
| 2552 # | |
| 2553 | |
| 2554 <RuleHash> | |
| 2555 __builtin_new | |
| 2556 RuleHash::AppendRuleToTable(nsHashtable &, int, nsICSSStyleRule *) | |
| 2557 | |
| 2558 <RuleHash> | |
| 2559 __builtin_new | |
| 2560 RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *) | |
| 2561 | |
| 2562 <RuleHash> | |
| 2563 __builtin_new | |
| 2564 RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *, int) | |
| 2565 | |
| 2566 <RuleHash> | |
| 2567 PR_Malloc | |
| 2568 PL_HashTableFinalize(PLHashTable *) | |
| 2569 PL_HashTableRawAdd | |
| 2570 nsHashtable::Put(nsHashKey *, void *) | |
| 2571 RuleHash::AppendRuleToTable(nsHashtable &, int, nsICSSStyleRule *) | |
| 2572 | |
| 2573 <RuleHash> | |
| 2574 __builtin_new | |
| 2575 AtomKey::Clone(void) const | |
| 2576 nsHashtable::Put(nsHashKey *, void *) | |
| 2577 RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *) | |
| 2578 | |
| 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) | |
| 2585 | |
| 2586 <RuleHash> | |
| 2587 PR_Malloc | |
| 2588 PL_HashTableFinalize(PLHashTable *) | |
| 2589 PL_HashTableRawAdd | |
| 2590 nsHashtable::Put(nsHashKey *, void *) | |
| 2591 RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *) | |
| 2592 | |
| 2593 <RuleHash> | |
| 2594 __builtin_new | |
| 2595 __builtin_vec_new | |
| 2596 RuleHash::EnumerateAllRules(nsIAtom *, nsIAtom *, nsVoidArray const &, void (*)(nsICSSStyleRule *, void *), void *) | |
| 2597 | |
| 2598 <RuleHash> | |
| 2599 PR_Malloc | |
| 2600 PL_HashTableFinalize(PLHashTable *) | |
| 2601 PL_HashTableRawAdd | |
| 2602 nsHashtable::Put(nsHashKey *, void *) | |
| 2603 RuleHash::AppendRuleToTable(nsHashtable &, nsIAtom *, nsICSSStyleRule *, int) | |
| 2604 | |
| 2605 # ---------------------------------------------------------------------- | |
| 2606 # | |
| 2607 # nsCSSSelector | |
| 2608 # | |
| 2609 | |
| 2610 <nsCSSSelector> | |
| 2611 __builtin_new | |
| 2612 nsCSSSelector::nsCSSSelector(nsCSSSelector const &) | |
| 2613 | |
| 2614 <nsCSSSelector> | |
| 2615 __builtin_new | |
| 2616 nsAtomList::nsAtomList(nsAtomList const &) | |
| 2617 nsCSSSelector::nsCSSSelector(nsCSSSelector const &) | |
| 2618 | |
| 2619 <nsCSSSelector> | |
| 2620 __builtin_new | |
| 2621 nsAttrSelector::nsAttrSelector(nsAttrSelector const &) | |
| 2622 nsCSSSelector::nsCSSSelector(nsCSSSelector const &) | |
| 2623 | |
| 2624 <nsCSSSelector> | |
| 2625 __builtin_new | |
| 2626 nsAttrSelector::nsAttrSelector(nsAttrSelector const &) | |
| 2627 nsAttrSelector::nsAttrSelector(nsAttrSelector const &) | |
| 2628 nsCSSSelector::nsCSSSelector(nsCSSSelector const &) | |
| 2629 | |
| 2630 # ---------------------------------------------------------------------- | |
| 2631 # | |
| 2632 # StyleSetImpl | |
| 2633 # | |
| 2634 | |
| 2635 <StyleSetImpl> | |
| 2636 __builtin_new | |
| 2637 CSSStyleSheetImpl::GetStyleRuleProcessor(nsIStyleRuleProcessor *&, nsIStyleRuleProcessor *) | |
| 2638 StyleSetImpl::ClearOverrideRuleProcessors(void) | |
| 2639 | |
| 2640 <StyleSetImpl> | |
| 2641 __builtin_new | |
| 2642 CSSRuleProcessor::GetRuleCascade(nsIPresContext *, nsIAtom *) | |
| 2643 CSSRuleProcessor::RulesMatching(nsIPresContext *, nsIAtom *, nsIContent *, nsIStyleContext *, nsIRuleWalker *) | |
| 2644 StyleSetImpl::ReplaceBackstopStyleSheets(nsISupportsArray *) | |
| 2645 | |
| 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) | |
| 2651 | |
| 2652 <StyleSetImpl> | |
| 2653 __builtin_new | |
| 2654 nsSupportsArray::Create(nsISupports *, nsID const &, void **) | |
| 2655 NS_NewISupportsArray(nsISupportsArray **) | |
| 2656 StyleSetImpl::EnsureArray(nsISupportsArray **) | |
| 2657 | |
| 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 *) | |
| 2666 | |
| 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 *) | |
| 2677 | |
| 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 *) | |
| 2690 | |
| 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) | |
| 2700 | |
| 2701 //---------------------------------------------------------------------- | |
| 2702 | |
| 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 *) | |
| 2718 | |
| 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) | |
| 2731 | |
| 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) | |
| 2742 | |
| 2743 # ---------------------------------------------------------------------- | |
| 2744 | |
| 2745 <StyleContextCache> | |
| 2746 PR_Malloc | |
| 2747 PL_HashTableFinalize(PLHashTable *) | |
| 2748 PL_HashTableRawAdd | |
| 2749 nsHashtable::Put(nsHashKey *, void *) | |
| 2750 StyleContextCache::VerifyList(unsigned int) | |
| 2751 | |
| 2752 <StyleContextCache> | |
| 2753 __builtin_new | |
| 2754 StyleContextCache::AllocateList(void) | |
| 2755 | |
| 2756 # ---------------------------------------------------------------------- | |
| 2757 # | |
| 2758 # nsPersistentProperties | |
| 2759 # | |
| 2760 | |
| 2761 <nsPersistentProperties> | |
| 2762 __builtin_new | |
| 2763 nsPersistentProperties::Create(nsISupports *, nsID const &, void **) | |
| 2764 | |
| 2765 <nsPersistentProperties> | |
| 2766 PR_Malloc | |
| 2767 PL_ArenaFinish | |
| 2768 PL_HashTableRawAdd | |
| 2769 nsPersistentProperties::SetStringProperty(nsAString const &, nsAString &, nsAString &) | |
| 2770 nsPersistentProperties::Load(nsIInputStream *) | |
| 2771 | |
| 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 &) | |
| 2781 | |
| 2782 <nsPersistentProperties> | |
| 2783 PR_Malloc | |
| 2784 PL_ArenaFinish | |
| 2785 PL_HashTableRawAdd | |
| 2786 nsPersistentProperties::SetStringProperty(nsString const &, nsString &, nsString &) | |
| 2787 | |
| 2788 <nsPersistentProperties> | |
| 2789 PR_Malloc | |
| 2790 PL_ArenaFinish | |
| 2791 PL_NewHashTable | |
| 2792 nsPersistentProperties::nsPersistentProperties(void) | |
| 2793 | |
| 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 &) | |
| 2800 | |
| 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 &) | |
| 2808 | |
| 2809 # ---------------------------------------------------------------------- | |
| 2810 # | |
| 2811 # nsCSSValue | |
| 2812 # | |
| 2813 | |
| 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 &) | |
| 2823 | |
| 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) | |
| 2830 | |
| 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) | |
| 2838 | |
| 2839 # ---------------------------------------------------------------------- | |
| 2840 | |
| 2841 <nsStringKey> | |
| 2842 PR_Malloc | |
| 2843 nsMemoryImpl::Alloc(unsigned int) | |
| 2844 nsMemory::Alloc(unsigned int) | |
| 2845 nsStringKey::Clone(void) const | |
| 2846 | |
| 2847 #---------------------------------------------------------------------- | |
| 2848 # | |
| 2849 # nsTextFragment | |
| 2850 # | |
| 2851 | |
| 2852 <nsTextFragment> | |
| 2853 PR_Malloc | |
| 2854 nsMemoryImpl::Alloc(unsigned int) | |
| 2855 nsMemory::Alloc(unsigned int) | |
| 2856 nsTextFragment::SetTo(unsigned short const *, int) | |
| 2857 | |
| 2858 <nsTextFragment> | |
| 2859 PR_Malloc | |
| 2860 nsMemoryImpl::Alloc(unsigned int) | |
| 2861 nsMemory::Alloc(unsigned int) | |
| 2862 ToNewCString(nsAString const &) | |
| 2863 nsTextFragment::operator=(nsAString const &) | |
| 2864 | |
| 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 &) | |
| 2872 | |
| 2873 #---------------------------------------------------------------------- | |
| 2874 # | |
| 2875 # nsTextBoxFrame | |
| 2876 # | |
| 2877 | |
| 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 &) | |
| 2891 | |
| 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) | |
| 2905 | |
| 2906 # ---------------------------------------------------------------------- | |
| 2907 # | |
| 2908 # nsPopupSetFrame | |
| 2909 # | |
| 2910 | |
| 2911 <nsPopupSetFrame> | |
| 2912 __builtin_new | |
| 2913 nsPopupSetFrame::AddPopupFrame(nsIFrame *) | |
| 2914 | |
| 2915 #---------------------------------------------------------------------- | |
| 2916 | |
| 2917 <nsStdURL> | |
| 2918 PR_Malloc | |
| 2919 nsMemoryImpl::Alloc(unsigned int) | |
| 2920 nsMemory::Alloc(unsigned int) | |
| 2921 ToNewCString(nsACString const &) | |
| 2922 nsStdURL::GetSpec(char **) | |
| 2923 | |
| 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 *) | |
| 2930 | |
| 2931 <nsSimpleURI> | |
| 2932 PR_Malloc | |
| 2933 nsMemoryImpl::Alloc(unsigned int) | |
| 2934 nsMemory::Alloc(unsigned int) | |
| 2935 ToNewCString(nsAString const &) | |
| 2936 nsSimpleURI::SetSpec(char const *) | |
| 2937 | |
| 2938 <nsNodeInfoManager> | |
| 2939 PR_Malloc | |
| 2940 PL_ArenaFinish | |
| 2941 PL_HashTableRawAdd | |
| 2942 PL_HashTableAdd | |
| 2943 nsNodeInfoManager::GetNodeInfo(nsIAtom *, nsIAtom *, int, nsINodeInfo *&) | |
| 2944 | |
| 2945 <nsNodeInfoManager> | |
| 2946 PR_Malloc | |
| 2947 PL_ArenaFinish | |
| 2948 PL_NewHashTable | |
| 2949 nsNodeInfoManager::nsNodeInfoManager(void) | |
| 2950 | |
| 2951 <nsNodeInfoManager> | |
| 2952 PR_Malloc | |
| 2953 PL_ArenaFinish | |
| 2954 PL_HashTableRawRemove | |
| 2955 PL_HashTableRemove | |
| 2956 nsNodeInfoManager::RemoveNodeInfo(nsNodeInfo *) | |
| 2957 | |
| 2958 <xptiInterfaceInfo> | |
| 2959 XPT_ArenaMalloc | |
| 2960 xptiInterfaceInfo::CopyName(char const *, xptiWorkingSet *) | |
| 2961 | |
| 2962 <xptiInterfaceInfo> | |
| 2963 __builtin_new | |
| 2964 xptiInterfaceInfo::PartiallyResolveLocked(XPTInterfaceDescriptor *, xptiWorkingSet *) | |
| 2965 | |
| 2966 <xpti-unclassified> | |
| 2967 XPT_ArenaMalloc | |
| 2968 | |
| 2969 <pthread-unclassified> | |
| 2970 siglongjmp | |
| 2971 pthread_create | |
| 2972 | |
| 2973 <X-unclassified> | |
| 2974 XkbAllocClientMap | |
| 2975 | |
| 2976 <X-unclassified> | |
| 2977 _XiCheckExtInit | |
| 2978 | |
| 2979 <X-unclassified> | |
| 2980 _XAllocScratch | |
| 2981 | |
| 2982 <X-unclassified> | |
| 2983 XUnlockDisplay | |
| 2984 | |
| 2985 <X-unclassified> | |
| 2986 _XlcCreateLC | |
| 2987 | |
| 2988 <X-unclassified> | |
| 2989 XkbUseExtension | |
| 2990 | |
| 2991 <X-unclassified> | |
| 2992 _XimServerDestroy | |
| 2993 | |
| 2994 <X-unclassified> | |
| 2995 _XlcAddCharSet | |
| 2996 | |
| 2997 <X-unclassified> | |
| 2998 XInitExtension | |
| 2999 | |
| 3000 <X-unclassified> | |
| 3001 _XlcGenericLoader | |
| 3002 | |
| 3003 <X-unclassified> | |
| 3004 _XwcDefaultDrawImageString | |
| 3005 | |
| 3006 <X-unclassified> | |
| 3007 _XlcAddCT | |
| 3008 | |
| 3009 <X-unclassified> | |
| 3010 XShmCreateImage | |
| 3011 | |
| 3012 <X-unclassified> | |
| 3013 _XFreeAtomTable | |
| 3014 | |
| 3015 <X-unclassified> | |
| 3016 XCreateRegion | |
| 3017 | |
| 3018 <X-unclassified> | |
| 3019 XIntersectRegion | |
| 3020 | |
| 3021 <X-unclassified> | |
| 3022 _XlcCreateLocaleDataBase | |
| 3023 | |
| 3024 <X-unclassified> | |
| 3025 _XUpdateAtomCache | |
| 3026 | |
| 3027 <X-unclassified> | |
| 3028 XrmMergeDatabases | |
| 3029 | |
| 3030 <X-unclassified> | |
| 3031 XrmParseCommand | |
| 3032 | |
| 3033 <X-unclassified> | |
| 3034 XOpenDisplay | |
| 3035 | |
| 3036 <X-unclassified> | |
| 3037 XCreateGC | |
| 3038 | |
| 3039 <X-unclassified> | |
| 3040 _XlcResetConverter | |
| 3041 | |
| 3042 <X-unclassified> | |
| 3043 _XEnq | |
| 3044 | |
| 3045 <X-unclassified> | |
| 3046 _XimLcctstowcs | |
| 3047 | |
| 3048 <X-unclassified> | |
| 3049 XtMalloc | |
| 3050 | |
| 3051 <X-unclassified> | |
| 3052 XtCalloc | |
| 3053 | |
| 3054 <X-unclassified> | |
| 3055 Xpermalloc | |
| 3056 | |
| 3057 <X-unclassified> | |
| 3058 _XlcCreateDefaultCharSet | |
| 3059 | |
| 3060 <X-unclassified> | |
| 3061 _XimLocalSetICValues | |
| 3062 | |
| 3063 <X-unclassified> | |
| 3064 _XimLocalCreateIC | |
| 3065 | |
| 3066 <X-unclassified> | |
| 3067 _XlcSetConverter | |
| 3068 | |
| 3069 <X-unclassified> | |
| 3070 _XkbGetCharset | |
| 3071 | |
| 3072 <gtk-unclassified> | |
| 3073 g_malloc | |
| 3074 | |
| 3075 <gtk-unclassified> | |
| 3076 g_realloc | |
| 3077 | |
| 3078 <gtk-unclassified> | |
| 3079 g_malloc0 | |
| 3080 | |
| 3081 <gtk-unclassified> | |
| 3082 _XimLcctstoutf8 | |
| 3083 | |
| 3084 <gdk_imlib_load_image> | |
| 3085 loader_png | |
| 3086 gdk_imlib_load_image | |
| 3087 | |
| 3088 <gdk_imlib_save_image> | |
| 3089 loader_png | |
| 3090 gdk_imlib_save_image | |
| 3091 | |
| 3092 <dl-unclassified> | |
| 3093 _dl_lookup_versioned_symbol_skip | |
| 3094 | |
| 3095 <dl-unclassified> | |
| 3096 _dl_dst_substitute | |
| 3097 | |
| 3098 <dl-unclassified> | |
| 3099 _dl_map_object_deps | |
| 3100 | |
| 3101 <dl-unclassified> | |
| 3102 _dl_map_object | |
| 3103 | |
| 3104 <dl-unclassified> | |
| 3105 _dl_debug_message | |
| 3106 | |
| 3107 <nsRegistry> | |
| 3108 PR_Malloc | |
| 3109 bufio_SetBufferSize | |
| 3110 nsXPTCStubBase::Sentinel9(void) | |
| 3111 NR_RegSetBufferSize | |
| 3112 nsRegistry::SetBufferSize(int) | |
| 3113 | |
| 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) | |
| 3120 | |
| 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) | |
| 3127 | |
| 3128 <InMemoryDataSource> | |
| 3129 PR_Malloc | |
| 3130 PL_ArenaAllocate | |
| 3131 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 3132 InMemoryAssertionEnumeratorImpl::operator new(unsigned int, nsFixedSizeAllocator &) | |
| 3133 | |
| 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 *)) | |
| 3140 | |
| 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 **) | |
| 3148 | |
| 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 **) | |
| 3154 | |
| 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 *)) | |
| 3162 | |
| 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 *)) | |
| 3169 | |
| 3170 <nsUNIXCharset> | |
| 3171 gettext | |
| 3172 gettext | |
| 3173 setlocale | |
| 3174 setlocale | |
| 3175 nsUNIXCharset::nsUNIXCharset(void) | |
| 3176 | |
| 3177 # ---------------------------------------------------------------------- | |
| 3178 # | |
| 3179 # nsLocaleService | |
| 3180 # | |
| 3181 | |
| 3182 <nsLocaleService> | |
| 3183 textdomain | |
| 3184 textdomain | |
| 3185 setlocale | |
| 3186 setlocale | |
| 3187 nsLocaleService::nsLocaleService(void) | |
| 3188 | |
| 3189 <nsLocaleService> | |
| 3190 setlocale | |
| 3191 setlocale | |
| 3192 setlocale | |
| 3193 nsLocaleService::nsLocaleService(void) | |
| 3194 | |
| 3195 <nsLocaleService> | |
| 3196 PR_Malloc | |
| 3197 PL_ArenaFinish | |
| 3198 PL_NewHashTable | |
| 3199 nsLocale::nsLocale(void) | |
| 3200 | |
| 3201 <nsLocaleServie> | |
| 3202 PR_Malloc | |
| 3203 PL_ArenaFinish | |
| 3204 PL_HashTableRawAdd | |
| 3205 PL_HashTableAdd | |
| 3206 nsLocale::AddCategory(unsigned short const *, unsigned short const *) | |
| 3207 | |
| 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 *) | |
| 3222 | |
| 3223 # ---------------------------------------------------------------------- | |
| 3224 # | |
| 3225 # nsServiceManagerImpl (obsolete?) | |
| 3226 # | |
| 3227 | |
| 3228 <nsServiceManagerImpl> | |
| 3229 __builtin_new | |
| 3230 nsServiceManagerImpl::nsServiceManagerImpl(void) | |
| 3231 NS_NewServiceManager(nsIServiceManager **) | |
| 3232 | |
| 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) | |
| 3240 | |
| 3241 <nsServiceManagerImpl> | |
| 3242 __builtin_new | |
| 3243 nsHashtable::Put(nsHashKey *, void *) | |
| 3244 nsServiceManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *) | |
| 3245 | |
| 3246 <nsServiceManagerImpl> | |
| 3247 __builtin_new | |
| 3248 nsServiceManagerImpl::nsServiceManagerImpl(void) | |
| 3249 NS_NewServiceManager(nsIServiceManager **) | |
| 3250 | |
| 3251 <nsServiceManagerImpl> | |
| 3252 __builtin_new | |
| 3253 nsServiceManagerImpl::GetService(nsID const &, nsID const &, nsISupports **, nsIShutdownListener *) | |
| 3254 | |
| 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 *) | |
| 3261 | |
| 3262 #---------------------------------------------------------------------- | |
| 3263 # | |
| 3264 # nsXMLElement | |
| 3265 # | |
| 3266 | |
| 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) | |
| 3271 | |
| 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) | |
| 3276 | |
| 3277 <nsXMLElement> | |
| 3278 __builtin_new | |
| 3279 nsGenericContainerElement::SetAttr(nsINodeInfo *, nsAString const &, int) | |
| 3280 nsXMLElement::SetAttr(nsINodeInfo *, nsAString const &, int) | |
| 3281 | |
| 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) | |
| 3297 | |
| 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 *) | |
| 3307 | |
| 3308 #---------------------------------------------------------------------- | |
| 3309 # | |
| 3310 # nsXMLDocument | |
| 3311 # | |
| 3312 | |
| 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) | |
| 3328 | |
| 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) | |
| 3342 | |
| 3343 #---------------------------------------------------------------------- | |
| 3344 | |
| 3345 <nsGCCache> | |
| 3346 __builtin_new | |
| 3347 nsGCCache::nsGCCache(void) | |
| 3348 | |
| 3349 #---------------------------------------------------------------------- | |
| 3350 # | |
| 3351 # prefs | |
| 3352 # | |
| 3353 | |
| 3354 <nsPref> | |
| 3355 _init | |
| 3356 PL_HashTableRawAdd | |
| 3357 PL_HashTableAdd | |
| 3358 pref_HashPref | |
| 3359 | |
| 3360 <nsPref> | |
| 3361 _init | |
| 3362 PL_NewHashTable | |
| 3363 PREF_Init | |
| 3364 | |
| 3365 <nsPref> | |
| 3366 pref_HashPref | |
| 3367 | |
| 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) | |
| 3375 | |
| 3376 <nsPref> | |
| 3377 PREF_RegisterCallback | |
| 3378 | |
| 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 *) | |
| 3392 | |
| 3393 #---------------------------------------------------------------------- | |
| 3394 | |
| 3395 <nsThread> | |
| 3396 PR_Calloc | |
| 3397 PR_SetThreadPrivate | |
| 3398 nsThread::RegisterThreadSelf(void) | |
| 3399 | |
| 3400 <nsFontGTK> | |
| 3401 XFreeFont | |
| 3402 | |
| 3403 <nsFontGTK> | |
| 3404 __builtin_new | |
| 3405 nsFontGTK::operator new(unsigned int) | |
| 3406 | |
| 3407 <nsGenericContainerElement> | |
| 3408 __builtin_new | |
| 3409 nsCheapVoidArray::SwitchToVector(void) | |
| 3410 nsCheapVoidArray::AppendElement(void *) | |
| 3411 nsGenericContainerElement::AppendChildTo(nsIContent *, int) | |
| 3412 | |
| 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) | |
| 3421 | |
| 3422 #---------------------------------------------------------------------- | |
| 3423 # | |
| 3424 # nsObserverService | |
| 3425 # | |
| 3426 | |
| 3427 <nsObserverService> | |
| 3428 PR_Malloc | |
| 3429 PL_HashTableFinalize(PLHashTable *) | |
| 3430 PL_HashTableRawAdd | |
| 3431 nsHashtable::Put(nsHashKey *, void *) | |
| 3432 nsObserverService::GetObserverList(unsigned short const *, nsIObserverList **) | |
| 3433 | |
| 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 **) | |
| 3441 | |
| 3442 <nsObserverService> | |
| 3443 __builtin_new | |
| 3444 nsStringKey::Clone(void) const | |
| 3445 nsHashtable::Put(nsHashKey *, void *) | |
| 3446 nsObserverService::GetObserverList(nsString const &, nsIObserverList **) | |
| 3447 | |
| 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 **) | |
| 3455 | |
| 3456 <nsObserverService> | |
| 3457 __builtin_new | |
| 3458 NS_NewObserverList(nsIObserverList **) | |
| 3459 nsObserverService::GetObserverList(nsString const &, nsIObserverList **) | |
| 3460 | |
| 3461 <nsObserverService> | |
| 3462 __builtin_new | |
| 3463 nsObserverService::GetObserverList(nsString const &, nsIObserverList **) | |
| 3464 | |
| 3465 <nsObserverService> | |
| 3466 PR_Malloc | |
| 3467 PL_HashTableFinalize(PLHashTable *) | |
| 3468 PL_HashTableRawAdd | |
| 3469 nsHashtable::Put(nsHashKey *, void *) | |
| 3470 nsObserverService::GetObserverList(nsString const &, nsIObserverList **) | |
| 3471 | |
| 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 **) | |
| 3479 | |
| 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) | |
| 3487 | |
| 3488 #---------------------------------------------------------------------- | |
| 3489 | |
| 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) | |
| 3496 | |
| 3497 <nsViewManager2> | |
| 3498 __builtin_new | |
| 3499 nsViewManager2::AddToDisplayList(int *, nsView *, nsRect &, nsRect &, unsigned int, int, int) | |
| 3500 | |
| 3501 # ---------------------------------------------------------------------- | |
| 3502 # | |
| 3503 # nsBindingManager | |
| 3504 # | |
| 3505 | |
| 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 *) | |
| 3513 | |
| 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 *) | |
| 3520 | |
| 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 *) | |
| 3528 | |
| 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 *) | |
| 3535 | |
| 3536 <nsBindingManager> | |
| 3537 __builtin_new | |
| 3538 nsBindingManager::SetBinding(nsIContent *, nsIXBLBinding *) | |
| 3539 | |
| 3540 <nsBindingManager> | |
| 3541 __builtin_new | |
| 3542 nsBindingManager::SetInsertionParent(nsIContent *, nsIContent *) | |
| 3543 | |
| 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 *) | |
| 3551 | |
| 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 *) | |
| 3559 | |
| 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 *) | |
| 3567 | |
| 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 *) | |
| 3575 | |
| 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 *) | |
| 3583 | |
| 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 *) | |
| 3591 | |
| 3592 # ---------------------------------------------------------------------- | |
| 3593 | |
| 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 &) | |
| 3608 | |
| 3609 <NameSpaceManagerImpl> | |
| 3610 __builtin_new | |
| 3611 nsStringKey::Clone(void) const | |
| 3612 nsHashtable::Put(nsHashKey *, void *) | |
| 3613 nsLayoutUtils::GetDynamicScriptContext(JSContext *, nsIScriptContext **) | |
| 3614 NameSpaceManagerImpl::NameSpaceManagerImpl(void) | |
| 3615 | |
| 3616 <NameSpaceManagerImpl> | |
| 3617 __builtin_new | |
| 3618 nsStringKey::Clone(void) const | |
| 3619 nsHashtable::Put(nsHashKey *, void *) | |
| 3620 NameSpaceManagerImpl::RegisterNameSpace(basic_nsAReadableString<unsigned short> const &, int &) | |
| 3621 | |
| 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) | |
| 3635 | |
| 3636 <nsErrorService> | |
| 3637 __builtin_new | |
| 3638 nsErrorService::Create(nsISupports *, nsID const &, void **) | |
| 3639 | |
| 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 *) | |
| 3646 | |
| 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 *) | |
| 3654 | |
| 3655 <nsDocument> | |
| 3656 __builtin_new | |
| 3657 ArenaImpl::Create(nsISupports *, nsID const &, void **) | |
| 3658 NS_NewHeapArena(nsIArena **, unsigned int) | |
| 3659 nsDocument::Init(void) | |
| 3660 | |
| 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) | |
| 3667 | |
| 3668 <nsDocument> | |
| 3669 __builtin_new | |
| 3670 nsDocument::SetHeaderData(nsIAtom *, basic_nsAReadableString<unsigned short> const &) | |
| 3671 | |
| 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 *) | |
| 3679 | |
| 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 &) | |
| 3694 | |
| 3695 <XPCContext> | |
| 3696 __builtin_new | |
| 3697 XPCContext::newXPCContext(XPCJSRuntime *, JSContext *) | |
| 3698 | |
| 3699 <nsEventQueueService> | |
| 3700 __builtin_new | |
| 3701 nsEventQueueServiceImpl::Create(nsISupports *, nsID const &, void **) | |
| 3702 | |
| 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) | |
| 3710 | |
| 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) | |
| 3718 | |
| 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) | |
| 3724 | |
| 3725 <nsEventListenerManager> | |
| 3726 PR_Malloc | |
| 3727 nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int) | |
| 3728 nsEventListenerManager::AddEventListenerByType(nsIDOMEventListener *, nsAString const &, int) | |
| 3729 | |
| 3730 <nsEventListenerManager> | |
| 3731 PR_Malloc | |
| 3732 nsEventListenerManager::AddEventListener(nsIDOMEventListener *, EventArrayType, int, nsHashKey *, int) | |
| 3733 nsEventListenerManager::AddEventListenerByIID(nsIDOMEventListener *, nsID const &, int) | |
| 3734 | |
| 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) | |
| 3742 | |
| 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) | |
| 3750 | |
| 3751 <nsEventListenerManager> | |
| 3752 __builtin_new | |
| 3753 nsEventListenerManager::AddEventListener(nsIDOMEventListener *, nsID const &, int, int) | |
| 3754 | |
| 3755 <nsEventListenerManager> | |
| 3756 PR_Malloc | |
| 3757 nsEventListenerManager::AddEventListener(nsIDOMEventListener *, nsID const &, int, int) | |
| 3758 | |
| 3759 <nsCParserNode> | |
| 3760 __builtin_new | |
| 3761 nsCParserNode::AddAttribute(CToken *) | |
| 3762 | |
| 3763 <nsCParserNode> | |
| 3764 __builtin_new | |
| 3765 __builtin_vec_new | |
| 3766 nsDeque::GrowCapacity(void) | |
| 3767 nsDeque::Push(void *) | |
| 3768 nsCParserNode::AddAttribute(CToken *) | |
| 3769 | |
| 3770 <nsSocketTransportService> | |
| 3771 PR_Malloc | |
| 3772 nsSocketTransportService::Init(void) | |
| 3773 | |
| 3774 <nsSocketTransport> | |
| 3775 PR_Malloc | |
| 3776 nsSocketTransport::AsyncWrite(nsIInputStream *, nsIStreamObserver *, nsISupports *) | |
| 3777 | |
| 3778 <nsSocketTransport> | |
| 3779 PR_Malloc | |
| 3780 _PR_Getfd | |
| 3781 PR_GetConnectStatus | |
| 3782 PR_Socket | |
| 3783 PR_OpenTCPSocket | |
| 3784 nsSocketTransport::doConnection(short) | |
| 3785 | |
| 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) | |
| 3792 | |
| 3793 <CompositeDataSourceImpl> | |
| 3794 PR_Malloc | |
| 3795 PL_ArenaAllocate | |
| 3796 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 3797 CompositeDataSourceImpl::GetTargets(nsIRDFResource *, nsIRDFResource *, int, nsISimpleEnumerator **) | |
| 3798 | |
| 3799 <CompositeDataSourceImpl> | |
| 3800 PR_Malloc | |
| 3801 PL_ArenaAllocate | |
| 3802 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 3803 CompositeDataSourceImpl::ArcLabelsIn(nsIRDFNode *, nsISimpleEnumerator **) | |
| 3804 | |
| 3805 <CompositeDataSourceImpl> | |
| 3806 PR_Malloc | |
| 3807 PL_ArenaAllocate | |
| 3808 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 3809 CompositeDataSourceImpl::ArcLabelsOut(nsIRDFResource *, nsISimpleEnumerator **) | |
| 3810 | |
| 3811 # ---------------------------------------------------------------------- | |
| 3812 # | |
| 3813 # nsHTMLValue | |
| 3814 # | |
| 3815 | |
| 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) | |
| 3823 | |
| 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) | |
| 3830 | |
| 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) | |
| 3838 | |
| 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) | |
| 3846 | |
| 3847 # ---------------------------------------------------------------------- | |
| 3848 | |
| 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 **) | |
| 3855 | |
| 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) | |
| 3862 | |
| 3863 <nsMemCache> | |
| 3864 __builtin_new | |
| 3865 nsOpaqueKey::Clone(void) const | |
| 3866 nsHashtable::Put(nsHashKey *, void *) | |
| 3867 nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **) | |
| 3868 | |
| 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 **) | |
| 3876 | |
| 3877 <nsMemCache> | |
| 3878 __builtin_new | |
| 3879 nsOpaqueKey::Clone(void) const | |
| 3880 nsHashtable::Put(nsHashKey *, void *) | |
| 3881 nsMemCache::GetCachedNetData(char const *, unsigned int, nsINetDataCacheRecord **) | |
| 3882 | |
| 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 **) | |
| 3890 | |
| 3891 <nsMemCacheRecord> | |
| 3892 __builtin_new | |
| 3893 __builtin_vec_new | |
| 3894 nsMemCacheRecord::SetMetaData(unsigned int, char const *) | |
| 3895 | |
| 3896 <nsMemCacheRecord> | |
| 3897 __builtin_new | |
| 3898 __builtin_vec_new | |
| 3899 nsMemCacheRecord::Init(char const *, unsigned int, unsigned int, nsMemCache *) | |
| 3900 | |
| 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 *,...) | |
| 3907 | |
| 3908 <nsTextFormatter> | |
| 3909 PR_Malloc | |
| 3910 nsXPIDLString type_info function | |
| 3911 nsXPIDLString type_info function | |
| 3912 nsTextFormatter::vsmprintf(unsigned short const *, void *) | |
| 3913 | |
| 3914 <nsTextFormatter> | |
| 3915 PR_Realloc | |
| 3916 nsXPIDLString type_info function | |
| 3917 nsXPIDLString type_info function | |
| 3918 nsTextFormatter::vsmprintf(unsigned short const *, void *) | |
| 3919 | |
| 3920 #---------------------------------------------------------------------- | |
| 3921 # | |
| 3922 # nsPresContext | |
| 3923 # | |
| 3924 | |
| 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) | |
| 3931 | |
| 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 **) | |
| 3939 | |
| 3940 #---------------------------------------------------------------------- | |
| 3941 # | |
| 3942 # nsPresState | |
| 3943 # | |
| 3944 | |
| 3945 <nsPresState> | |
| 3946 __builtin_new | |
| 3947 nsPresState::SetStateProperty(nsAString const &, nsAString const &) | |
| 3948 | |
| 3949 <nsPresState> | |
| 3950 __builtin_new | |
| 3951 nsPresState::SetStatePropertyAsSupports(nsAString const &, nsISupports *) | |
| 3952 | |
| 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 *) | |
| 3960 | |
| 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 &) | |
| 3968 | |
| 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 *) | |
| 3976 | |
| 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 &) | |
| 3984 | |
| 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 &) | |
| 3992 | |
| 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 *) | |
| 3999 | |
| 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 &) | |
| 4006 | |
| 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 &) | |
| 4014 | |
| 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 &) | |
| 4021 | |
| 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 *) | |
| 4028 | |
| 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 &) | |
| 4036 | |
| 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 *) | |
| 4044 | |
| 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 &) | |
| 4052 | |
| 4053 # ---------------------------------------------------------------------- | |
| 4054 # | |
| 4055 # Prefs stuff | |
| 4056 # | |
| 4057 | |
| 4058 <prefs-unclassified> | |
| 4059 PL_strdup | |
| 4060 pref_HashPref | |
| 4061 | |
| 4062 <prefs-unclassified> | |
| 4063 PL_strdup | |
| 4064 PREF_LockPref | |
| 4065 | |
| 4066 <prefs-unclassified> | |
| 4067 PL_strdup | |
| 4068 PREF_RegisterCallback | |
| 4069 | |
| 4070 #---------------------------------------------------------------------- | |
| 4071 # | |
| 4072 # Imagelib Stuff | |
| 4073 # | |
| 4074 | |
| 4075 <imgRequest> | |
| 4076 PR_Malloc | |
| 4077 nsVoidArray::SizeTo(int) | |
| 4078 nsVoidArray::GrowArrayBy(int) | |
| 4079 nsVoidArray::InsertElementAt(void *, int) | |
| 4080 imgRequest::AddProxy(imgRequestProxy *) | |
| 4081 | |
| 4082 <ImageRequestImpl> | |
| 4083 __builtin_new | |
| 4084 ImageRequestImpl::AddObserver(nsIImageRequestObserver *) | |
| 4085 | |
| 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 *) | |
| 4090 | |
| 4091 <imglib-unclassified> | |
| 4092 __builtin_new | |
| 4093 ImageNetContextImpl::GetURL(ilIURL *, ImgCachePolicy, ilINetReader *, int) | |
| 4094 | |
| 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) | |
| 4101 | |
| 4102 <imglib-gifdecode> | |
| 4103 PR_Calloc | |
| 4104 il_gif_write(il_container_struct *, unsigned char const *, int) | |
| 4105 | |
| 4106 <imglib-gifdecode> | |
| 4107 PR_Malloc | |
| 4108 il_gif_write(il_container_struct *, unsigned char const *, int) | |
| 4109 | |
| 4110 <gif_struct> | |
| 4111 PR_Calloc | |
| 4112 il_gif_init(il_container_struct *) | |
| 4113 | |
| 4114 <IL_ImageReq> | |
| 4115 PR_Calloc | |
| 4116 IL_GetImage | |
| 4117 | |
| 4118 <imglib-container-stuff> | |
| 4119 PR_Calloc | |
| 4120 il_get_container(_IL_GroupContext *, ImgCachePolicy, char const *, _NI_IRGB *, IL_DitherMode, int, int, int) | |
| 4121 | |
| 4122 <IL_ColorSpace> | |
| 4123 PR_Calloc | |
| 4124 IL_CreateTrueColorSpace | |
| 4125 | |
| 4126 <IL_Pixmap> | |
| 4127 PR_Calloc | |
| 4128 il_size(il_container_struct *) | |
| 4129 ImgDCallbk::ImgDCBImageSize(void) | |
| 4130 | |
| 4131 <IL_ColorSpace> | |
| 4132 PR_Calloc | |
| 4133 IL_CreateGreyScaleColorSpace | |
| 4134 | |
| 4135 <imglib-gifcompat> | |
| 4136 PR_Malloc | |
| 4137 il_BACat(char **, unsigned int, char const *, unsigned int) | |
| 4138 | |
| 4139 <imglib-gifcompat> | |
| 4140 PR_Realloc | |
| 4141 il_BACat(char **, unsigned int, char const *, unsigned int) | |
| 4142 | |
| 4143 <ImageConsumer> | |
| 4144 PR_Malloc | |
| 4145 ImageConsumer::OnStartRequest(nsIChannel *, nsISupports *) | |
| 4146 | |
| 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 **) | |
| 4152 | |
| 4153 #---------------------------------------------------------------------- | |
| 4154 | |
| 4155 <nsImageGTK> | |
| 4156 __builtin_new | |
| 4157 __builtin_vec_new | |
| 4158 nsImageGTK::Init(int, int, int, nsMaskRequirements) | |
| 4159 | |
| 4160 #---------------------------------------------------------------------- | |
| 4161 # | |
| 4162 # nsLayoutHistoryState | |
| 4163 # | |
| 4164 | |
| 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) | |
| 4172 | |
| 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) | |
| 4179 | |
| 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) | |
| 4187 | |
| 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) | |
| 4194 | |
| 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 *) | |
| 4203 | |
| 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 *) | |
| 4211 | |
| 4212 # ---------------------------------------------------------------------- | |
| 4213 # | |
| 4214 # nsCookieService | |
| 4215 # | |
| 4216 | |
| 4217 <nsCookieService> | |
| 4218 PR_Realloc | |
| 4219 Local_SACat(char **, char const *) | |
| 4220 COOKIE_GetCookie(char *) | |
| 4221 | |
| 4222 <nsCookieService> | |
| 4223 PR_Malloc | |
| 4224 cookie_IsFromHost(_cookie_CookieStruct *, char *) | |
| 4225 | |
| 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) | |
| 4233 | |
| 4234 # ---------------------------------------------------------------------- | |
| 4235 | |
| 4236 <nsReplacementPolicy> | |
| 4237 PR_Realloc | |
| 4238 nsMemoryImpl::Realloc(void *, unsigned int) | |
| 4239 nsMemory::Realloc(void *, unsigned int) | |
| 4240 nsReplacementPolicy::AssociateCacheEntryWithRecord(nsINetDataCacheRecord *, nsINetDataCache *, nsCachedNetData **) | |
| 4241 | |
| 4242 <nsReplacementPolicy> | |
| 4243 PR_Malloc | |
| 4244 nsMemoryImpl::Alloc(unsigned int) | |
| 4245 nsMemory::Alloc(unsigned int) | |
| 4246 nsReplacementPolicy::Init(unsigned int) | |
| 4247 | |
| 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 *) | |
| 4261 | |
| 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) | |
| 4268 | |
| 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) | |
| 4275 | |
| 4276 <nsHTTPHandler> | |
| 4277 __builtin_new | |
| 4278 nsCStringKey::Clone(void) const | |
| 4279 nsHashtable::Put(nsHashKey *, void *) | |
| 4280 nsHTTPHandler::SetServerCapabilities(char const *, int, unsigned int) | |
| 4281 | |
| 4282 <nsCachedNetData> | |
| 4283 PR_Malloc | |
| 4284 PL_ArenaAllocate | |
| 4285 ArenaImpl::Alloc(unsigned int) | |
| 4286 nsCachedNetData::operator new(unsigned int, nsIArena *) | |
| 4287 | |
| 4288 <ns4xPluginStreamListener> | |
| 4289 PR_Malloc | |
| 4290 ns4xPluginStreamListener::OnDataAvailable(nsIPluginStreamInfo *, nsIInputStream *, unsigned int) | |
| 4291 | |
| 4292 <nsSegmentedBuffer> | |
| 4293 PR_Malloc | |
| 4294 nsMemoryImpl::Alloc(unsigned int) | |
| 4295 nsSegmentedBuffer::AppendNewSegment(void) | |
| 4296 | |
| 4297 <nsAuthURLParser> | |
| 4298 PL_strndup | |
| 4299 ExtractString | |
| 4300 | |
| 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) | |
| 4308 | |
| 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) | |
| 4316 | |
| 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 *) | |
| 4324 | |
| 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) | |
| 4331 | |
| 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 **) | |
| 4338 | |
| 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 **) | |
| 4346 | |
| 4347 <nsDNSService> | |
| 4348 PL_DHashAllocTable | |
| 4349 PL_DHashTableInit | |
| 4350 nsDNSService::Init(void) | |
| 4351 | |
| 4352 <nsDNSService> | |
| 4353 __builtin_new | |
| 4354 nsDNSService::GetLookupEntry(char const *, nsDNSLookup **) | |
| 4355 | |
| 4356 <nsDNSService> | |
| 4357 __builtin_new | |
| 4358 nsDNSService::Lookup(char const *, nsIDNSListener *, nsISupports *, nsIRequest **) | |
| 4359 | |
| 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 **) | |
| 4366 | |
| 4367 <nsDNSLookup> | |
| 4368 gethostbyname2 | |
| 4369 PR_GetIPNodeByName | |
| 4370 nsDNSLookup::InitiateLookup(void) | |
| 4371 | |
| 4372 <nsDNSLookup> | |
| 4373 __builtin_new | |
| 4374 nsSupportsArray::Create(nsISupports *, nsID const &, void **) | |
| 4375 NS_NewISupportsArray(nsISupportsArray **) | |
| 4376 nsDNSLookup::Init(char const *) | |
| 4377 | |
| 4378 <nsDNSLookup> | |
| 4379 __builtin_new | |
| 4380 nsDNSLookup::Create(char const *) | |
| 4381 | |
| 4382 # ---------------------------------------------------------------------- | |
| 4383 # | |
| 4384 # nsFormControlList | |
| 4385 # | |
| 4386 | |
| 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 &) | |
| 4394 | |
| 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 *) | |
| 4401 | |
| 4402 <nsFormControlList> | |
| 4403 __builtin_new | |
| 4404 nsFormControlList::AddElementToTable(nsIFormControl *, basic_nsAReadableString<unsigned short> const &) | |
| 4405 | |
| 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 &) | |
| 4412 | |
| 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 &) | |
| 4420 | |
| 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 &) | |
| 4428 | |
| 4429 # ---------------------------------------------------------------------- | |
| 4430 # | |
| 4431 # nsControllerCommandManager | |
| 4432 # | |
| 4433 | |
| 4434 <nsControllerCommandManager> | |
| 4435 __builtin_new | |
| 4436 __builtin_vec_new | |
| 4437 NS_NewControllerCommandManager(nsIControllerCommandManager **) | |
| 4438 | |
| 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) | |
| 4445 | |
| 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 *) | |
| 4453 | |
| 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 *) | |
| 4461 | |
| 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 *) | |
| 4468 | |
| 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) | |
| 4476 | |
| 4477 <nsConsoleService> | |
| 4478 PR_Malloc | |
| 4479 nsMemoryImpl::Alloc(unsigned int) | |
| 4480 nsMemory::Alloc(unsigned int) | |
| 4481 nsConsoleService::nsConsoleService(void) | |
| 4482 | |
| 4483 <mozilla::dom::Element> | |
| 4484 __builtin_new | |
| 4485 mozilla::dom::Element::GetDOMSlots(void) | |
| 4486 | |
| 4487 <HTMLAttribute> | |
| 4488 __builtin_new | |
| 4489 HTMLAttribute::CopyHTMLAttributes(HTMLAttribute *, HTMLAttribute **) | |
| 4490 | |
| 4491 # ---------------------------------------------------------------------- | |
| 4492 # | |
| 4493 # HTMLAttributesImpl | |
| 4494 # | |
| 4495 | |
| 4496 <HTMLAttributesImpl> | |
| 4497 __builtin_new | |
| 4498 HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsAString const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *) | |
| 4499 | |
| 4500 <HTMLAttributesImpl> | |
| 4501 __builtin_new | |
| 4502 HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsHTMLValue const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *, int &) | |
| 4503 | |
| 4504 <HTMLAttributesImpl> | |
| 4505 __builtin_new | |
| 4506 __builtin_vec_new | |
| 4507 HTMLAttributesImpl::SetAttributeName(nsIAtom *, int &) | |
| 4508 | |
| 4509 <HTMLAttributesImpl> | |
| 4510 __builtin_new | |
| 4511 nsHTMLMappedAttributes::SetAttribute(nsIAtom *, nsHTMLValue const &) | |
| 4512 HTMLAttributesImpl::SetAttributeFor(nsIAtom *, nsHTMLValue const &, int, nsIHTMLContent *, nsIHTMLStyleSheet *, int &) | |
| 4513 | |
| 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 &) | |
| 4522 | |
| 4523 <HTMLAttributesImpl> | |
| 4524 __builtin_new | |
| 4525 nsHTMLMappedAttributes::nsHTMLMappedAttributes(nsHTMLMappedAttributes const &) | |
| 4526 nsHTMLMappedAttributes::Clone(nsHTMLMappedAttributes **) const | |
| 4527 HTMLAttributesImpl::EnsureSingleMappedFor(nsIHTMLContent *, nsIHTMLStyleSheet *, int) | |
| 4528 | |
| 4529 # ---------------------------------------------------------------------- | |
| 4530 | |
| 4531 <nsEntityConverter> | |
| 4532 __builtin_new | |
| 4533 __builtin_vec_new | |
| 4534 nsEntityConverter::LoadVersionPropertyFile(void) | |
| 4535 | |
| 4536 <nsTableFrame> | |
| 4537 __builtin_new | |
| 4538 __builtin_vec_new | |
| 4539 nsTableFrame::nsTableFrame(void) | |
| 4540 | |
| 4541 <nsTableFrame> | |
| 4542 __builtin_new | |
| 4543 __builtin_vec_new | |
| 4544 nsTableFrame::BalanceColumnWidths(nsIPresContext *, nsHTMLReflowState const &, nsSize const &, nsSize *) | |
| 4545 | |
| 4546 <nsTableFrame> | |
| 4547 __builtin_new | |
| 4548 nsTableFrame::Init(nsIPresContext *, nsIContent *, nsIFrame *, nsIStyleContext *, nsIFrame *) | |
| 4549 | |
| 4550 <nsTableCellFrame> | |
| 4551 __builtin_new | |
| 4552 nsTableCellFrame::GetFrameName(nsString &) const | |
| 4553 | |
| 4554 <nsCellMap> | |
| 4555 __builtin_new | |
| 4556 nsCellMap::AppendCell(nsTableCellMap &, nsTableCellFrame &, int, int) | |
| 4557 | |
| 4558 <nsCellMap> | |
| 4559 __builtin_new | |
| 4560 nsCellMap::Grow(nsTableCellMap &, int, int) | |
| 4561 | |
| 4562 <nsCellMap> | |
| 4563 PR_Malloc | |
| 4564 nsVoidArray::SizeTo(int) | |
| 4565 nsVoidArray::nsVoidArray(int) | |
| 4566 nsCellMap::Grow(nsTableCellMap &, int, int) | |
| 4567 | |
| 4568 <nsTableCellMap> | |
| 4569 __builtin_new | |
| 4570 nsTableCellMap::InsertGroupCellMap(nsTableRowGroupFrame &, nsTableRowGroupFrame *&) | |
| 4571 | |
| 4572 <nsTableCellMap> | |
| 4573 __builtin_new | |
| 4574 nsTableCellMap::AddColsAtEnd(unsigned int) | |
| 4575 | |
| 4576 <nsEncoderSupport> | |
| 4577 __builtin_new | |
| 4578 __builtin_vec_new | |
| 4579 nsEncoderSupport::nsEncoderSupport(void) | |
| 4580 | |
| 4581 <nsFrameImageLoader> | |
| 4582 __builtin_new | |
| 4583 Init__18nsFrameImageLoaderP14nsIPresContextP13nsIImageGroupRC8nsStringPCUiPC6nsSizeP8nsIFrame16nsImageAnimationPFP14nsIPresContextP19nsIFrameImageLoaderP8nsIFramePvUi_UiPvT9 | |
| 4584 | |
| 4585 <nsFrameImageLoader> | |
| 4586 __builtin_new | |
| 4587 AddFrame__18nsFrameImageLoaderP8nsIFramePFP14nsIPresContextP19nsIFrameImageLoaderP8nsIFramePvUi_UiPvT3 | |
| 4588 | |
| 4589 | |
| 4590 <nsFloaterCacheFreeList> | |
| 4591 __builtin_new | |
| 4592 nsFloaterCacheFreeList::Alloc(void) | |
| 4593 | |
| 4594 <nsDocLoaderImpl> | |
| 4595 __builtin_new | |
| 4596 nsDocLoaderImpl::AddChannelInfo(nsIChannel *) | |
| 4597 | |
| 4598 <nsDocLoaderImpl> | |
| 4599 __builtin_new | |
| 4600 nsDocLoaderImpl::AddRequestInfo(nsIRequest *) | |
| 4601 | |
| 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) | |
| 4608 | |
| 4609 <SinkContext> | |
| 4610 __builtin_new | |
| 4611 __builtin_vec_new | |
| 4612 SinkContext::AddText(basic_nsAReadableString<unsigned short> const &) | |
| 4613 | |
| 4614 <SinkContext> | |
| 4615 __builtin_new | |
| 4616 __builtin_vec_new | |
| 4617 SinkContext::GrowStack(void) | |
| 4618 | |
| 4619 <nsScanner> | |
| 4620 PR_Malloc | |
| 4621 nsMemoryImpl::Alloc(unsigned int) | |
| 4622 nsMemory::Alloc(unsigned int) | |
| 4623 nsScanner::Append(char const *, unsigned int) | |
| 4624 | |
| 4625 <nsParser> | |
| 4626 __builtin_new | |
| 4627 nsParser::Parse(nsIURI *, nsIStreamObserver *, int, void *, nsDTDMode) | |
| 4628 | |
| 4629 <nsParser> | |
| 4630 __builtin_new | |
| 4631 nsParser::Parse(basic_nsAReadableString<unsigned short> const &, void *, nsString const &, int, int, nsDTDMode) | |
| 4632 | |
| 4633 <nsParser> | |
| 4634 __builtin_new | |
| 4635 __builtin_vec_new | |
| 4636 nsParser::OnDataAvailable(nsIChannel *, nsISupports *, nsIInputStream *, unsigned int, unsigned int) | |
| 4637 | |
| 4638 <nsParserModule> | |
| 4639 __builtin_new | |
| 4640 __builtin_vec_new | |
| 4641 InitializeElementTable(void) | |
| 4642 | |
| 4643 <nsStorageStream> | |
| 4644 __builtin_new | |
| 4645 nsStorageStream::Init(unsigned int, unsigned int, nsIMemory *) | |
| 4646 | |
| 4647 <nsEntryStack> | |
| 4648 __builtin_new | |
| 4649 __builtin_vec_new | |
| 4650 nsEntryStack::EnsureCapacityFor(int, int) | |
| 4651 | |
| 4652 <nsCacheManager> | |
| 4653 __builtin_new | |
| 4654 nsCacheManager::Init(void) | |
| 4655 | |
| 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 *) | |
| 4670 | |
| 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 *) | |
| 4685 | |
| 4686 <registry-Buffer> | |
| 4687 PR_Malloc | |
| 4688 bufio_SetBufferSize | |
| 4689 | |
| 4690 <nsString::PRUnichar*> | |
| 4691 PR_Malloc | |
| 4692 nsMemoryImpl::Alloc | |
| 4693 nsMemory::Alloc | |
| 4694 ToNewUnicode | |
| 4695 | |
| 4696 <nsString::char*> | |
| 4697 PR_Malloc | |
| 4698 nsMemoryImpl::Alloc | |
| 4699 nsMemory::Alloc | |
| 4700 nsStr::Alloc | |
| 4701 | |
| 4702 <nsDiskCacheMap> | |
| 4703 __builtin_new | |
| 4704 nsDiskCacheDevice::Init(void) | |
| 4705 | |
| 4706 <nsXULPrototypeAttribute> | |
| 4707 __builtin_new | |
| 4708 __builtin_vec_new | |
| 4709 XULContentSinkImpl::AddAttributes(nsIParserNode const &, nsXULPrototypeElement *) | |
| 4710 | |
| 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 *) | |
| 4720 | |
| 4721 <XPCNativeInterface> | |
| 4722 JS_DHashAllocTable | |
| 4723 JS_DHashTableFinish | |
| 4724 JS_DHashTableOperate | |
| 4725 XPCNativeInterface::GetNewOrUsed(XPCCallContext &, nsID const *) | |
| 4726 | |
| 4727 <nsDiskCacheBlockFile::mBitmap> | |
| 4728 __builtin_new | |
| 4729 __builtin_vec_new | |
| 4730 nsDiskCacheBlockFile::Open(nsILocalFile *, unsigned int) | |
| 4731 | |
| 4732 #---------------------------------------------------------------------- | |
| 4733 # | |
| 4734 # nsConflictSet | |
| 4735 # | |
| 4736 | |
| 4737 <nsConflictSet::mBindingDependencies> | |
| 4738 __builtin_new | |
| 4739 __builtin_vec_new | |
| 4740 nsConflictSet::AllocBindingTable(void *, unsigned int) | |
| 4741 | |
| 4742 <nsConflictSet::mBindingDependencies> | |
| 4743 PR_Malloc | |
| 4744 PL_ArenaAllocate | |
| 4745 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 4746 nsConflictSet::AllocBindingEntry(void *, void const *) | |
| 4747 | |
| 4748 <nsConflictSet::mClusters> | |
| 4749 __builtin_new | |
| 4750 __builtin_vec_new | |
| 4751 nsConflictSet::AllocClusterTable(void *, unsigned int) | |
| 4752 | |
| 4753 <nsConflictSet::mClusters> | |
| 4754 PR_Malloc | |
| 4755 PL_ArenaAllocate | |
| 4756 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 4757 nsConflictSet::AllocClusterEntry(void *, void const *) | |
| 4758 | |
| 4759 <nsConflictSet::mSupport> | |
| 4760 __builtin_new | |
| 4761 __builtin_vec_new | |
| 4762 nsConflictSet::AllocSupportTable(void *, unsigned int) | |
| 4763 | |
| 4764 <nsConflictSet::mSupport> | |
| 4765 PR_Malloc | |
| 4766 PL_ArenaAllocate | |
| 4767 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 4768 nsConflictSet::AllocSupportEntry(void *, void const *) | |
| 4769 | |
| 4770 <nsConflictSet::mSupport> | |
| 4771 PR_Malloc | |
| 4772 PL_ArenaAllocate | |
| 4773 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 4774 nsRDFConMemberTestNode::Element::Clone(void *) const | |
| 4775 | |
| 4776 <nsConflictSet::mSupport> | |
| 4777 PR_Malloc | |
| 4778 PL_ArenaAllocate | |
| 4779 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 4780 nsRDFConInstanceTestNode::Element::Clone(void *) const | |
| 4781 | |
| 4782 <nsConflictSet::mSupport> | |
| 4783 PR_Malloc | |
| 4784 PL_ArenaAllocate | |
| 4785 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 4786 nsRDFConInstanceTestNode::FilterInstantiations(InstantiationSet &, void *) const | |
| 4787 | |
| 4788 <nsConflictSet::mSupport> | |
| 4789 __builtin_new | |
| 4790 MemoryElementSet::Add(MemoryElement *) | |
| 4791 | |
| 4792 <nsConflictSet> | |
| 4793 PL_DHashAllocTable | |
| 4794 PL_DHashTableFinish | |
| 4795 PL_DHashTableOperate | |
| 4796 nsTemplateMatchRefSet::AddToTable(nsTemplateMatch *) | |
| 4797 nsTemplateMatchRefSet::Add(nsTemplateMatch const *) | |
| 4798 nsConflictSet::Add(nsTemplateMatch *) | |
| 4799 | |
| 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) | |
| 4806 | |
| 4807 <nsConflictSet> | |
| 4808 PR_Malloc | |
| 4809 PL_ArenaAllocate | |
| 4810 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 4811 nsConflictSet::SupportEntry::Create(nsFixedSizeAllocator &) | |
| 4812 | |
| 4813 <nsConflictSet> | |
| 4814 PR_Malloc | |
| 4815 PL_ArenaAllocate | |
| 4816 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 4817 nsConflictSet::ClusterEntry::Create(nsFixedSizeAllocator &) | |
| 4818 | |
| 4819 #---------------------------------------------------------------------- | |
| 4820 | |
| 4821 <nsAssignmentSet> | |
| 4822 __builtin_new | |
| 4823 nsAssignmentSet::Add(nsAssignment const &) | |
| 4824 | |
| 4825 #---------------------------------------------------------------------- | |
| 4826 # | |
| 4827 # nsXULTemplateBuilder | |
| 4828 # | |
| 4829 | |
| 4830 <nsXULTemplateBuilder> | |
| 4831 __builtin_new | |
| 4832 nsXULTemplateBuilder::CompileSimpleRule(nsIContent *, int, InnerNode *) | |
| 4833 | |
| 4834 <nsXULTemplateBuilder> | |
| 4835 PL_DHashAllocTable | |
| 4836 PL_DHashTableInit | |
| 4837 nsXULContentBuilder::nsXULContentBuilder(void) | |
| 4838 | |
| 4839 <nsXULTemplateBuilder> | |
| 4840 PL_DHashAllocTable | |
| 4841 PL_DHashTableInit | |
| 4842 nsContentSupportMap::Init(void) | |
| 4843 | |
| 4844 <nsXULTemplateBuilder> | |
| 4845 PL_DHashAllocTable | |
| 4846 PL_DHashTableFinish | |
| 4847 PL_DHashTableOperate | |
| 4848 nsXULContentBuilder::BuildContentFromTemplate(nsIContent *, nsIContent *, nsIContent *, int, nsIRDFResource *, int, nsTemplateMatch *, nsIContent **, int *) | |
| 4849 | |
| 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 *) | |
| 4857 | |
| 4858 #---------------------------------------------------------------------- | |
| 4859 # | |
| 4860 # nsRuleNetwork | |
| 4861 # | |
| 4862 | |
| 4863 <nsRuleNetwork> | |
| 4864 PL_DHashAllocTable | |
| 4865 PL_DHashTableInit | |
| 4866 nsRuleNetwork::Init(void) | |
| 4867 | |
| 4868 #---------------------------------------------------------------------- | |
| 4869 # | |
| 4870 # nsTemplateRule | |
| 4871 # | |
| 4872 | |
| 4873 <nsTemplateRule> | |
| 4874 __builtin_new | |
| 4875 nsTemplateRule::AddBinding(int, nsIRDFResource *, int) | |
| 4876 | |
| 4877 #---------------------------------------------------------------------- | |
| 4878 # | |
| 4879 # nsTemplateMatch | |
| 4880 # | |
| 4881 | |
| 4882 <nsTemplateMatch> | |
| 4883 __builtin_new | |
| 4884 nsAssignmentSet::Add(nsAssignment const &) | |
| 4885 nsTemplateRule::ComputeAssignmentFor(nsConflictSet &, nsTemplateMatch *, int, Value *) const | |
| 4886 nsTemplateMatch::GetAssignmentFor(nsConflictSet &, int, Value *) | |
| 4887 | |
| 4888 <nsTemplateMatch> | |
| 4889 PR_Malloc | |
| 4890 PL_ArenaAllocate | |
| 4891 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 4892 nsInstantiationNode::Propagate(InstantiationSet const &, void *) | |
| 4893 | |
| 4894 <nsTemplateMatch> | |
| 4895 PR_Malloc | |
| 4896 PL_ArenaAllocate | |
| 4897 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 4898 nsRDFConMemberTestNode::FilterInstantiations(InstantiationSet &, void *) const | |
| 4899 | |
| 4900 <nsTemplateMatch> | |
| 4901 PR_Malloc | |
| 4902 PL_ArenaAllocate | |
| 4903 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 4904 nsTemplateMatch::Create(nsFixedSizeAllocator &, nsTemplateRule const *, Instantiation const &, nsAssignmentSet const &) | |
| 4905 | |
| 4906 #---------------------------------------------------------------------- | |
| 4907 | |
| 4908 <ReteNodeSet::mNodes> | |
| 4909 __builtin_new | |
| 4910 __builtin_vec_new | |
| 4911 ReteNodeSet::Add(ReteNode *) | |
| 4912 | |
| 4913 #---------------------------------------------------------------------- | |
| 4914 | |
| 4915 <StaticModuleInfo> | |
| 4916 __builtin_new | |
| 4917 __builtin_vec_new | |
| 4918 nsStaticComponentLoader::GetModuleInfo(void) | |
| 4919 | |
| 4920 <RuleValue*> | |
| 4921 __builtin_new | |
| 4922 __builtin_vec_new | |
| 4923 RuleHash::EnumerateAllRules(int, nsIAtom *, nsIAtom *, nsVoidArray const &, void (*)(nsICSSStyleRule *, void *), void *) | |
| 4924 | |
| 4925 <XPCNativeSet> | |
| 4926 __builtin_new | |
| 4927 __builtin_vec_new | |
| 4928 XPCNativeSet::NewInstance(XPCCallContext &, nsIInterfaceInfo *) | |
| 4929 | |
| 4930 <XPCNativeSet> | |
| 4931 JS_DHashAllocTable | |
| 4932 JS_DHashTableFinish | |
| 4933 JS_DHashTableOperate | |
| 4934 XPCNativeSet::ClearCacheEntryForClassInfo(nsIClassInfo *) | |
| 4935 | |
| 4936 <XPCNativeSet> | |
| 4937 __builtin_new | |
| 4938 __builtin_vec_new | |
| 4939 XPCNativeSet::NewInstanceMutate(XPCNativeSet *, XPCNativeInterface *, unsigned short) | |
| 4940 | |
| 4941 <nsIRDFResource*> | |
| 4942 __builtin_new | |
| 4943 __builtin_vec_new | |
| 4944 nsResourceSet::Add(nsIRDFResource *) | |
| 4945 | |
| 4946 <nsXPCWrappedJSClass::mDescriptors> | |
| 4947 __builtin_new | |
| 4948 __builtin_vec_new | |
| 4949 nsXPCWrappedJSClass::nsXPCWrappedJSClass(XPCCallContext &, nsID const &, nsIInterfaceInfo *) | |
| 4950 | |
| 4951 <orkin-unclassified> | |
| 4952 __builtin_new | |
| 4953 orkinHeap::Alloc(nsIMdbEnv *, unsigned int, void **) | |
| 4954 | |
| 4955 <nsGenericAttribute> | |
| 4956 __builtin_new | |
| 4957 nsGenericContainerElement::SetAttribute(nsINodeInfo *, nsAString const &, int) | |
| 4958 | |
| 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 | |
| 4966 | |
| 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) | |
| 4977 | |
| 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 &) | |
| 4986 | |
| 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 &) | |
| 4994 | |
| 4995 #---------------------------------------------------------------------- | |
| 4996 # | |
| 4997 # nsXULDocument | |
| 4998 # | |
| 4999 | |
| 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 *) | |
| 5007 | |
| 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 *) | |
| 5015 | |
| 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 *) | |
| 5023 | |
| 5024 # ---------------------------------------------------------------------- | |
| 5025 | |
| 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 *) | |
| 5033 | |
| 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 *) | |
| 5041 | |
| 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 *) | |
| 5050 | |
| 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 *) | |
| 5059 | |
| 5060 <nsXULDocument::mElementMap> | |
| 5061 PR_Malloc | |
| 5062 PL_ArenaAllocate | |
| 5063 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 5064 nsElementMap::Add(nsAString const &, nsIContent *) | |
| 5065 | |
| 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) | |
| 5072 | |
| 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 *) | |
| 5080 | |
| 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 *) | |
| 5088 | |
| 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) | |
| 5096 | |
| 5097 <nsXULDocument> | |
| 5098 PL_DHashAllocTable | |
| 5099 PL_DHashTableInit | |
| 5100 PL_NewDHashTable | |
| 5101 nsXULDocument::AddBroadcastListenerFor(nsIDOMElement *, nsIDOMElement *, nsAString const &) | |
| 5102 | |
| 5103 #---------------------------------------------------------------------- | |
| 5104 | |
| 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) | |
| 5111 | |
| 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 &) | |
| 5119 | |
| 5120 <url-unclassified> | |
| 5121 PR_Malloc | |
| 5122 nsMemoryImpl::Alloc(unsigned int) | |
| 5123 nsMemory::Alloc(unsigned int) | |
| 5124 ExtractURLScheme | |
| 5125 nsStdURL::Resolve(char const *, char **) | |
| 5126 | |
| 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 *) | |
| 5134 | |
| 5135 # | |
| 5136 # Doesn't inherit nsISupports | |
| 5137 # | |
| 5138 <nsSupportsHashtable> | |
| 5139 __builtin_new | |
| 5140 nsRuleNode::Transition(nsIStyleRule *, nsIRuleNode **) | |
| 5141 | |
| 5142 # | |
| 5143 # No vtable. | |
| 5144 # | |
| 5145 <nsClassList> | |
| 5146 __builtin_new | |
| 5147 nsClassList::ParseClasses(nsClassList **, nsAString const &) | |
| 5148 | |
| 5149 # | |
| 5150 # Doesn't inherit nsISupports | |
| 5151 # | |
| 5152 <nsVoidArray> | |
| 5153 __builtin_new | |
| 5154 nsCheapVoidArray::SwitchToVector(void) | |
| 5155 | |
| 5156 <nsEventListenerManager> | |
| 5157 __builtin_new | |
| 5158 nsEventListenerManager::GetListenersByType(EventArrayType, nsHashKey *, int) | |
| 5159 | |
| 5160 #---------------------------------------------------------------------- | |
| 5161 | |
| 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) | |
| 5169 | |
| 5170 <nsImportedStringHandle> | |
| 5171 __builtin_new | |
| 5172 nsXPIDLCString::PrepareForUseAsOutParam(void) | |
| 5173 | |
| 5174 <nsXBLJSClass> | |
| 5175 __builtin_new | |
| 5176 nsXBLBinding::InitClass | |
| 5177 | |
| 5178 <Assertion> | |
| 5179 PR_Malloc | |
| 5180 PL_ArenaAllocate | |
| 5181 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 5182 InMemoryDataSource::LockedAssert(nsIRDFResource *, nsIRDFResource *, nsIRDFNode *, int) | |
| 5183 | |
| 5184 <nsXBLAttributeEntry> | |
| 5185 PR_Malloc | |
| 5186 PL_ArenaAllocate | |
| 5187 nsFixedSizeAllocator::Alloc(unsigned int) | |
| 5188 nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent *) | |
| 5189 | |
| 5190 #---------------------------------------------------------------------- | |
| 5191 # | |
| 5192 # nsRuleNode | |
| 5193 # | |
| 5194 | |
| 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 **) | |
| 5202 | |
| 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) | |
| 5216 | |
| 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) | |
| 5230 | |
| 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) | |
| 5244 | |
| 5245 # ---------------------------------------------------------------------- | |
| 5246 | |
| 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) | |
| 5255 | |
| 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) | |
| 5262 | |
| 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) | |
| 5269 | |
| 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) | |
| 5276 | |
| 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) | |
| 5283 | |
| 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 *) | |
| 5290 | |
| 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) | |
| 5297 | |
| 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) | |
| 5304 | |
| 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) | |
| 5311 | |
| 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) | |
| 5318 | |
| 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) | |
| 5325 | |
| 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) | |
| 5332 | |
| 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) | |
| 5339 | |
| 5340 # ---------------------------------------------------------------------- | |
| 5341 # | |
| 5342 # nsBookmarksService | |
| 5343 # | |
| 5344 | |
| 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 *) | |
| 5352 | |
| 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 *) | |
| 5361 | |
| 5362 # ---------------------------------------------------------------------- | |
| 5363 # | |
| 5364 # The following types will only be visible if nsPresShell.cpp is compiled | |
| 5365 # with the DEBUG_TRACEMALLOC_FRAMEARENA defined. | |
| 5366 # | |
| 5367 | |
| 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 &) | |
| 5374 | |
| 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 *) | |
| 5381 | |
| 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) | |
| 5390 | |
| 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 &) | |
| 5397 | |
| 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) | |
| 5404 | |
| 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) | |
| 5411 | |
| 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) | |
| 5418 | |
| 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 *) | |
| 5425 | |
| 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 *) | |
| 5432 | |
| 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) | |
| 5439 | |
| 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 &) | |
| 5453 | |
| 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) | |
| 5461 | |
| 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 &) | |
| 5475 | |
| 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 &) | |
| 5485 | |
| 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 *) | |
| 5492 | |
| 5493 # ---------------------------------------------------------------------- | |
| 5494 # | |
| 5495 # Frames | |
| 5496 # | |
| 5497 | |
| 5498 <nsLineBox> | |
| 5499 __builtin_new | |
| 5500 nsLineBox::SetCombinedArea(nsRect const &) | |
| 5501 | |
| 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 *) | |
| 5508 | |
| 5509 # ---------------------------------------------------------------------- | |
| 5510 # | |
| 5511 # nsCacheService | |
| 5512 # | |
| 5513 | |
| 5514 <nsCacheService> | |
| 5515 __builtin_new | |
| 5516 nsCacheService::ActivateEntry(nsCacheRequest *, nsCacheEntry **) | |
| 5517 | |
| 5518 <nsCacheService> | |
| 5519 __builtin_new | |
| 5520 nsCacheEntry::CreateDescriptor(nsCacheRequest *, int, nsICacheEntryDescriptor **) | |
| 5521 nsCacheService::ProcessRequest(nsCacheRequest *, int, nsICacheEntryDescriptor **) | |
| 5522 | |
| 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 **) | |
| 5536 | |
| 5537 <nsCacheService> | |
| 5538 PL_DHashAllocTable | |
| 5539 PL_DHashTableFinish | |
| 5540 PL_DHashTableOperate | |
| 5541 nsCacheEntryHashTable::AddEntry(nsCacheEntry *) | |
| 5542 nsCacheService::ActivateEntry(nsCacheRequest *, nsCacheEntry **) | |
| 5543 | |
| 5544 <nsCacheService> | |
| 5545 PL_DHashAllocTable | |
| 5546 PL_DHashTableFinish | |
| 5547 PL_DHashTableOperate | |
| 5548 nsCacheEntryHashTable::RemoveEntry(nsCacheEntry *) | |
| 5549 | |
| 5550 # ---------------------------------------------------------------------- | |
| 5551 | |
| 5552 <nsCacheMetaData> | |
| 5553 PL_DHashAllocTable | |
| 5554 PL_DHashTableInit | |
| 5555 nsCacheMetaData::Init(void) | |
| 5556 | |
| 5557 # ---------------------------------------------------------------------- | |
| 5558 # | |
| 5559 # nsXMLMIMEDataSource | |
| 5560 # | |
| 5561 | |
| 5562 <nsXMLMIMEDataSource> | |
| 5563 PR_Malloc | |
| 5564 PL_ArenaFinish | |
| 5565 PL_HashTableRawAdd | |
| 5566 PL_HashTableAdd | |
| 5567 nsXMLMIMEDataSource::InitFromFile(nsIFile *) | |
| 5568 | |
| 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) | |
| 5575 | |
| 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) | |
| 5583 | |
| 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) | |
| 5591 | |
| 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) | |
| 5599 | |
| 5600 #---------------------------------------------------------------------- | |
| 5601 # | |
| 5602 # nsRegion | |
| 5603 # | |
| 5604 | |
| 5605 <nsRegion> | |
| 5606 __builtin_new | |
| 5607 __builtin_vec_new | |
| 5608 RgnRectMemoryAllocator::RgnRectMemoryAllocator(unsigned int) | |
| 5609 nsRegion::Offset(int, int) | |
| 5610 | |
| 5611 <nsRegion> | |
| 5612 __builtin_new | |
| 5613 __builtin_vec_new | |
| 5614 RgnRectMemoryAllocator::Alloc(void) | |
| 5615 nsRegion::Or(nsRegion const &, nsRectFast const &) | |
| 5616 | |
| 5617 <nsRegion> | |
| 5618 __builtin_new | |
| 5619 __builtin_vec_new | |
| 5620 RgnRectMemoryAllocator::Alloc(void) | |
| 5621 nsRegion::SetToElements(unsigned int) | |
| 5622 | |
| 5623 #---------------------------------------------------------------------- | |
| 5624 # | |
| 5625 # nsCharsetMenu | |
| 5626 # | |
| 5627 | |
| 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) | |
| 5637 | |
| 5638 <nsCharsetMenu> | |
| 5639 __builtin_new | |
| 5640 nsCharsetMenu::AddCharsetToItemArray(nsVoidArray *, nsIAtom *, nsMenuEntry **, int) | |
| 5641 | |
| 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) | |
| 5651 | |
| 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 *) | |
| 5660 | |
| 5661 #---------------------------------------------------------------------- | |
| 5662 # | |
| 5663 # nsLoadGroup | |
| 5664 # | |
| 5665 | |
| 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 *) | |
| 5673 | |
| 5674 #---------------------------------------------------------------------- | |
| 5675 # | |
| 5676 # Wallet | |
| 5677 # | |
| 5678 | |
| 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 | |
| 5692 | |
| 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 | |
| 5706 | |
| 5707 <Wallet> | |
| 5708 PR_Malloc | |
| 5709 nsVoidArray::SizeTo(int) | |
| 5710 nsVoidArray::GrowArrayBy(int) | |
| 5711 nsVoidArray::InsertElementAt(void *, int) | |
| 5712 Wallet_RandomName | |
| 5713 | |
| 5714 <Wallet> | |
| 5715 __builtin_new | |
| 5716 __builtin_vec_new | |
| 5717 Wallet_Decrypt2 | |
| 5718 | |
| 5719 <Wallet> | |
| 5720 __builtin_new | |
| 5721 Wallet_RandomName | |
| 5722 | |
| 5723 <Wallet> | |
| 5724 PR_Realloc | |
| 5725 nsVoidArray::SizeTo(int) | |
| 5726 nsVoidArray::GrowArrayBy(int) | |
| 5727 nsVoidArray::InsertElementAt(void *, int) | |
| 5728 Wallet_Decrypt2 | |
| 5729 | |
| 5730 <Wallet> | |
| 5731 PR_Realloc | |
| 5732 nsVoidArray::SizeTo(int) | |
| 5733 nsVoidArray::GrowArrayBy(int) | |
| 5734 nsVoidArray::InsertElementAt(void *, int) | |
| 5735 Wallet_RandomName | |
| 5736 | |
| 5737 #---------------------------------------------------------------------- | |
| 5738 # | |
| 5739 # nsMemoryCacheDevice | |
| 5740 # | |
| 5741 | |
| 5742 <nsMemCacheRecord> | |
| 5743 PL_DHashAllocTable | |
| 5744 PL_DHashTableFinish | |
| 5745 PL_DHashTableOperate | |
| 5746 nsCacheEntryHashTable::RemoveEntry(nsCacheEntry *) | |
| 5747 nsMemoryCacheDevice::EvictEntry(nsCacheEntry *) | |
| 5748 | |
| 5749 #---------------------------------------------------------------------- | |
| 5750 # | |
| 5751 # nsSHEntry | |
| 5752 # | |
| 5753 | |
| 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 *) | |
| 5767 | |
| 5768 # ---------------------------------------------------------------------- | |
| 5769 | |
| 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 **) | |
| 5776 | |
| 5777 # ---------------------------------------------------------------------- | |
| 5778 # | |
| 5779 # nsMsgDatabase | |
| 5780 # | |
| 5781 | |
| 5782 <nsMsgDatabase> | |
| 5783 PL_DHashAllocTable | |
| 5784 PL_DHashTableFinish | |
| 5785 PL_DHashTableOperate | |
| 5786 nsMsgDatabase::AddHdrToCache(nsIMsgDBHdr *, unsigned int) | |
| 5787 | |
| 5788 <nsMsgDatabase> | |
| 5789 PL_DHashAllocTable | |
| 5790 PL_DHashTableFinish | |
| 5791 PL_DHashTableOperate | |
| 5792 nsMsgDatabase::AddHdrToUseCache(nsIMsgDBHdr *, unsigned int) | |
| 5793 | |
| 5794 # ---------------------------------------------------------------------- | |
| 5795 # | |
| 5796 # nsMsgFolderDataSource | |
| 5797 # | |
| 5798 | |
| 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 **) | |
| 5806 | |
| 5807 # ---------------------------------------------------------------------- | |
| 5808 # | |
| 5809 # singsign | |
| 5810 # | |
| 5811 | |
| 5812 <SINGSIGN> | |
| 5813 __builtin_new | |
| 5814 SI_DeletePersistentUserData | |
| 5815 | |
| 5816 # ---------------------------------------------------------------------- | |
| 5817 # | |
| 5818 # LocalStoreImpl | |
| 5819 # | |
| 5820 | |
| 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 *) | |
| 5828 | |
| 5829 # ---------------------------------------------------------------------- | |
| 5830 # | |
| 5831 # NSS | |
| 5832 # | |
| 5833 | |
| 5834 <NSS> | |
| 5835 PR_Malloc | |
| 5836 PL_ArenaAllocate | |
| 5837 PORT_ArenaAlloc | |
| 5838 | |
| 5839 <NSS> | |
| 5840 PR_Malloc | |
| 5841 PL_ArenaAllocate | |
| 5842 nss_ZAlloc |
