size 82 MMgc/FixedAlloc-inlines.h return GetFixedBlock(item)->size;
size 85 MMgc/FixedAlloc-inlines.h REALLY_INLINE void* FixedAllocSafe::Alloc(size_t size, FixedMallocOpts flags)
size 88 MMgc/FixedAlloc-inlines.h return FixedAlloc::Alloc(size, flags);
size 112 MMgc/FixedAlloc-inlines.h REALLY_INLINE void* FastAllocator::operator new(size_t size, FixedAlloc *alloc)
size 114 MMgc/FixedAlloc-inlines.h return alloc->Alloc(size);
size 126 MMgc/FixedAlloc.cpp VerifyFreeBlockIntegrity(m_firstBlock->firstFree, m_firstBlock->size);
size 137 MMgc/FixedAlloc.cpp (void)size;
size 139 MMgc/FixedAlloc.cpp GCAssertMsg(((size_t)m_itemSize >= size), "allocator itemsize too small");
size 167 MMgc/FixedAlloc.cpp (((uintptr_t)b->firstFree - (uintptr_t)b->items) % b->size) == 0 &&
size 171 MMgc/FixedAlloc.cpp VerifyFreeBlockIntegrity(item, b->size);
size 201 MMgc/FixedAlloc.cpp m_totalAskSize += size;
size 204 MMgc/FixedAlloc.cpp m_heap->AllocHook(item, size, b->size - DebugSize());
size 211 MMgc/FixedAlloc.cpp memset(item, 0xfa, b->size - DebugSize());
size 215 MMgc/FixedAlloc.cpp memset(item, 0, b->size - DebugSize());
size 235 MMgc/FixedAlloc.cpp heap->FinalizeHook(item, b->size - DebugSize());
size 236 MMgc/FixedAlloc.cpp heap->FreeHook(item, b->size - DebugSize(), 0xed);
size 275 MMgc/FixedAlloc.cpp totalAllocated += b->numAlloc * b->size;
size 306 MMgc/FixedAlloc.cpp b->size = (uint16_t)m_itemSize;
size 396 MMgc/FixedAlloc.cpp int n = (size >> 2) - 3;
size 398 MMgc/FixedAlloc.cpp int n = (size >> 2) - 1;
size 439 MMgc/FixedAlloc.cpp return FixedMalloc::GetFixedMalloc()->Alloc(size);
size 86 MMgc/FixedAlloc.h void* Alloc(size_t size, FixedMallocOpts flags=kNone);
size 156 MMgc/FixedAlloc.h uint16_t size;
size 198 MMgc/FixedAlloc.h static void VerifyFreeBlockIntegrity(const void* item, uint32_t size);
size 218 MMgc/FixedAlloc.h void* Alloc(size_t size, FixedMallocOpts flags=kNone);
size 242 MMgc/FixedAlloc.h static void *operator new(size_t size, FixedAlloc *alloc);
size 244 MMgc/FixedAlloc.h static void *operator new[](size_t size);
size 52 MMgc/FixedMalloc-inlines.h REALLY_INLINE void* FixedMalloc::Alloc(size_t size, FixedMallocOpts flags)
size 57 MMgc/FixedMalloc-inlines.h if (size <= (size_t)kLargestAlloc) {
size 58 MMgc/FixedMalloc-inlines.h return FindSizeClass(size)->Alloc(size, flags);
size 60 MMgc/FixedMalloc-inlines.h return LargeAlloc(size, flags);
size 64 MMgc/FixedMalloc-inlines.h REALLY_INLINE void *FixedMalloc::PleaseAlloc(size_t size)
size 66 MMgc/FixedMalloc-inlines.h return Alloc(size, kCanFail);
size 89 MMgc/FixedMalloc-inlines.h size_t size;
size 91 MMgc/FixedMalloc-inlines.h size = LargeSize(item);
size 93 MMgc/FixedMalloc-inlines.h size = FixedAlloc::Size(item);
size 96 MMgc/FixedMalloc-inlines.h size -= DebugSize();
size 98 MMgc/FixedMalloc-inlines.h return size;
size 116 MMgc/FixedMalloc-inlines.h REALLY_INLINE FixedAllocSafe* FixedMalloc::FindSizeClass(size_t size)
size 118 MMgc/FixedMalloc-inlines.h GCAssertMsg(size > 0, "cannot allocate a 0 sized block\n");
size 121 MMgc/FixedMalloc-inlines.h uint32_t const size8 = (uint32_t)((size+7)&~7); // round up to multiple of 8
size 129 MMgc/FixedMalloc-inlines.h unsigned const index = kSizeClassIndex[((size+7)>>3)];
size 133 MMgc/FixedMalloc-inlines.h unsigned const index = (size <= 4) ? 0 : kSizeClassIndex[((size+7)>>3)];
size 137 MMgc/FixedMalloc-inlines.h GCAssert(size <= m_allocs[index].GetItemSize());
size 140 MMgc/FixedMalloc-inlines.h GCAssert(index == 0 || size > m_allocs[index-1].GetItemSize());
size 173 MMgc/FixedMalloc.cpp return Alloc(size, flags);
size 208 MMgc/FixedMalloc.cpp GCHeap::CheckForAllocSizeOverflow(size, GCHeap::kBlockSize+DebugSize());
size 210 MMgc/FixedMalloc.cpp size += DebugSize();
size 212 MMgc/FixedMalloc.cpp int blocksNeeded = (int)GCHeap::SizeToBlocks(size);
size 230 MMgc/FixedMalloc.cpp totalAskSizeLargeAllocs += (size - DebugSize());
size 232 MMgc/FixedMalloc.cpp m_heap->AllocHook(item, size - DebugSize(), Size(item));
size 239 MMgc/FixedMalloc.cpp memset(item, 0xfa, size - DebugSize());
size 75 MMgc/FixedMalloc.h void* Alloc(size_t size, FixedMallocOpts flags=kNone);
size 78 MMgc/FixedMalloc.h void *PleaseAlloc(size_t size);
size 81 MMgc/FixedMalloc.h void* FASTCALL OutOfLineAlloc(size_t size, FixedMallocOpts flags=kNone);
size 98 MMgc/FixedMalloc.h void *Calloc(size_t count, size_t size, FixedMallocOpts flags=kNone);
size 192 MMgc/FixedMalloc.h FixedAllocSafe* FindSizeClass(size_t size);
size 200 MMgc/FixedMalloc.h void *LargeAlloc(size_t size, FixedMallocOpts flags=kNone);
size 51 MMgc/GC-inlines.h REALLY_INLINE void *GCRoot::operator new(size_t size)
size 53 MMgc/GC-inlines.h return FixedMalloc::GetFixedMalloc()->Alloc(size, MMgc::kZero);
size 63 MMgc/GC-inlines.h return GCWorkItem(object, (uint32_t)size, false);
size 137 MMgc/GC-inlines.h REALLY_INLINE void GC::SignalAllocWork(size_t size)
size 139 MMgc/GC-inlines.h if (policy.signalAllocWork(size))
size 143 MMgc/GC-inlines.h REALLY_INLINE void *GC::PleaseAlloc(size_t size, int flags)
size 145 MMgc/GC-inlines.h return Alloc(size, flags | kCanFail);
size 151 MMgc/GC-inlines.h REALLY_INLINE void *GC::AllocExtra(size_t size, size_t extra, int flags)
size 153 MMgc/GC-inlines.h return Alloc(GCHeap::CheckForAllocSizeOverflow(size, extra), flags);
size 162 MMgc/GC-inlines.h #define SIZEARG size ,
size 170 MMgc/GC-inlines.h REALLY_INLINE void *GC::AllocPtrZero(size_t size)
size 173 MMgc/GC-inlines.h if (size <= kLargestAlloc)
size 174 MMgc/GC-inlines.h return GetUserPointer(containsPointersAllocs[sizeClassIndex[(size-1)>>3]]->Alloc(SIZEARG GC::kContainsPointers|GC::kZero));
size 176 MMgc/GC-inlines.h return Alloc(size, GC::kContainsPointers|GC::kZero);
size 179 MMgc/GC-inlines.h REALLY_INLINE void *GC::AllocPtrZeroFinalized(size_t size)
size 182 MMgc/GC-inlines.h if (size <= kLargestAlloc)
size 183 MMgc/GC-inlines.h return GetUserPointer(containsPointersAllocs[sizeClassIndex[(size-1)>>3]]->Alloc(SIZEARG GC::kContainsPointers|GC::kZero|GC::kFinalize));
size 185 MMgc/GC-inlines.h return Alloc(size, GC::kContainsPointers|GC::kZero|GC::kFinalize);
size 188 MMgc/GC-inlines.h REALLY_INLINE void *GC::AllocRCObject(size_t size)
size 191 MMgc/GC-inlines.h if (size <= kLargestAlloc)
size 192 MMgc/GC-inlines.h return GetUserPointer(containsPointersRCAllocs[sizeClassIndex[(size-1)>>3]]->Alloc(SIZEARG GC::kContainsPointers|GC::kZero|GC::kRCObject|GC::kFinalize));
size 194 MMgc/GC-inlines.h return Alloc(size, GC::kContainsPointers|GC::kZero|GC::kRCObject|GC::kFinalize);
size 213 MMgc/GC-inlines.h REALLY_INLINE void *GC::AllocExtraPtrZero(size_t size, size_t extra)
size 216 MMgc/GC-inlines.h if ((size|extra) <= (kLargestAlloc/2 & ~7)) {
size 217 MMgc/GC-inlines.h size += extra;
size 218 MMgc/GC-inlines.h return GetUserPointer(containsPointersAllocs[sizeClassIndex[(size-1)>>3]]->Alloc(SIZEARG GC::kContainsPointers|GC::kZero));
size 221 MMgc/GC-inlines.h return OutOfLineAllocExtra(size, extra, GC::kContainsPointers|GC::kZero);
size 224 MMgc/GC-inlines.h REALLY_INLINE void *GC::AllocExtraPtrZeroFinalized(size_t size, size_t extra)
size 227 MMgc/GC-inlines.h if ((size|extra) <= (kLargestAlloc/2 & ~7)) {
size 228 MMgc/GC-inlines.h size += extra;
size 229 MMgc/GC-inlines.h return GetUserPointer(containsPointersAllocs[sizeClassIndex[(size-1)>>3]]->Alloc(SIZEARG GC::kContainsPointers|GC::kZero|GC::kFinalize));
size 232 MMgc/GC-inlines.h return OutOfLineAllocExtra(size, extra, GC::kContainsPointers|GC::kZero|GC::kFinalize);
size 235 MMgc/GC-inlines.h REALLY_INLINE void *GC::AllocExtraRCObject(size_t size, size_t extra)
size 238 MMgc/GC-inlines.h if ((size|extra) <= kLargestAlloc/2) {
size 239 MMgc/GC-inlines.h size += extra;
size 240 MMgc/GC-inlines.h return GetUserPointer(containsPointersRCAllocs[sizeClassIndex[(size-1)>>3]]->Alloc(SIZEARG GC::kContainsPointers|GC::kZero|GC::kRCObject|GC::kFinalize));
size 243 MMgc/GC-inlines.h return OutOfLineAllocExtra(size, extra, GC::kContainsPointers|GC::kZero|GC::kRCObject|GC::kFinalize);
size 277 MMgc/GC-inlines.h return GetBlockHeader(ptr)->size - DebugSize();
size 628 MMgc/GC-inlines.h VMPI_memset(v, 0, size);
size 630 MMgc/GC-inlines.h size = 0;
size 642 MMgc/GC-inlines.h this->size = _size;
size 1143 MMgc/GC.cpp , size(size)
size 1152 MMgc/GC.cpp GCHeap::CheckForAllocSizeOverflow(size, hdr_size);
size 1158 MMgc/GC.cpp block = mmfx_new_array_opt(char, size + hdr_size, MMgc::kZero);
size 1160 MMgc/GC.cpp RCRootSegment *segment = new RCRootSegment(this, mem, size);
size 1264 MMgc/GC.cpp GCAssertMsg(size > 0, "cannot allocate a 0 sized block\n");
size 1287 MMgc/GC.cpp const size_t askSize = size; // preserve this for statistics gathering and profiling
size 1290 MMgc/GC.cpp GCHeap::CheckForAllocSizeOverflow(size, 7+DebugSize());
size 1291 MMgc/GC.cpp size = (size+7)&~7; // round up to multiple of 8
size 1292 MMgc/GC.cpp size += DebugSize(); // add in some (possibly zero) multiple of 8 bytes for debug information
size 1300 MMgc/GC.cpp if (size <= kLargestAlloc)
size 1306 MMgc/GC.cpp const unsigned index = sizeClassIndex[(size>>3)-1];
size 1308 MMgc/GC.cpp const unsigned index = sizeClassIndex[(size-1)>>3];
size 1315 MMgc/GC.cpp GCAssert(size <= allocs[index]->GetItemSize());
size 1318 MMgc/GC.cpp GCAssert( (index==0) || (size > allocs[index-1]->GetItemSize()));
size 1329 MMgc/GC.cpp GCHeap::CheckForAllocSizeOverflow(size, 7+DebugSize());
size 1330 MMgc/GC.cpp size = (size+7)&~7; // round up to multiple of 8
size 1331 MMgc/GC.cpp size += DebugSize();
size 1334 MMgc/GC.cpp item = largeAlloc->Alloc(askSize, size, flags);
size 1336 MMgc/GC.cpp item = largeAlloc->Alloc(size, flags);
size 1371 MMgc/GC.cpp return AllocExtra(size, extra, flags);
size 1597 MMgc/GC.cpp heap->FreeHook(GetUserPointer(lb+1), lb->size - DebugSize(), 0xba);
size 1649 MMgc/GC.cpp GCAssert(size > 0);
size 1651 MMgc/GC.cpp void *item = heapAlloc(size, zero ? GCHeap::kZero : 0);
size 1654 MMgc/GC.cpp item = heapAlloc(size, GCHeap::kExpand| (zero ? GCHeap::kZero : 0) | (canFail ? GCHeap::kCanFail : 0));
size 1661 MMgc/GC.cpp MarkGCPages((char*)item+GCHeap::kBlockSize, size - 1, kGCLargeAllocPageRest);
size 1670 MMgc/GC.cpp heapFree(ptr, size, false);
size 1671 MMgc/GC.cpp UnmarkGCPages(ptr, size);
size 1806 MMgc/GC.cpp size_t size;
size 1808 MMgc/GC.cpp MMGC_GET_STACK_EXTENTS(this, stackP, size);
size 1839 MMgc/GC.cpp size = _size;
size 1840 MMgc/GC.cpp GCAssert(size % 2 == 0);
size 1864 MMgc/GC.cpp this->size = _size;
size 1944 MMgc/GC.cpp size_t size = Size(item)/sizeof(uint32_t);
size 1946 MMgc/GC.cpp uint32_t *limit = p+size;
size 1951 MMgc/GC.cpp size--;
size 2261 MMgc/GC.cpp uintptr_t *end = p + (size / sizeof(void*));
size 2343 MMgc/GC.cpp uintptr_t *end = p + (size / sizeof(void*));
size 2368 MMgc/GC.cpp if (block->size == 1)
size 2376 MMgc/GC.cpp int fixedsize = fixed->size;
size 2600 MMgc/GC.cpp uint32_t size;
size 2604 MMgc/GC.cpp while (iter1.GetNextMarkedObject(ptr, size)) {
size 2605 MMgc/GC.cpp GCWorkItem item(ptr, size, true);
size 2610 MMgc/GC.cpp while (iter2.GetNextMarkedObject(ptr, size)) {
size 2611 MMgc/GC.cpp GCWorkItem item(ptr, size, true);
size 2618 MMgc/GC.cpp while (iter3.GetNextMarkedObject(ptr, size)) {
size 2619 MMgc/GC.cpp GCWorkItem item(ptr, size, true);
size 2654 MMgc/GC.cpp bytesMarked += size;
size 2657 MMgc/GC.cpp uintptr *end = p + (size / sizeof(void*));
size 2764 MMgc/GC.cpp size_t size = wi.GetSize();
size 2789 MMgc/GC.cpp if (size > markstackCutoff)
size 2791 MMgc/GC.cpp PushWorkItem(GCWorkItem(p + markstackCutoff / sizeof(uintptr_t), uint32_t(size - markstackCutoff), false));
size 2792 MMgc/GC.cpp size = markstackCutoff;
size 2795 MMgc/GC.cpp policy.signalMarkWork(size);
size 2797 MMgc/GC.cpp uintptr_t *end = p + (size / sizeof(void*));
size 2855 MMgc/GC.cpp item = block->items + itemNum * block->size;
size 2859 MMgc/GC.cpp if (block->items + itemNum * block->size != item)
size 2864 MMgc/GC.cpp if ((block->items + itemNum * block->size + sizeof(void *)) == item)
size 2865 MMgc/GC.cpp item = block->items + itemNum * block->size;
size 2885 MMgc/GC.cpp uint32_t itemSize = block->size - (uint32_t)DebugSize();
size 2949 MMgc/GC.cpp uint32_t itemSize = b->size - (uint32_t)DebugSize();
size 2968 MMgc/GC.cpp policy.signalDemographics(size/sizeof(void*), could_be_pointer, actually_is_pointer);
size 3410 MMgc/GC.cpp uintptr_t *end = p + ((size) / sizeof(void*));
size 3451 MMgc/GC.cpp WhitePointerScan(item, lb->size - DebugSize());
size 3803 MMgc/GC.cpp if(b->size == 1) {
size 125 MMgc/GC.h void init(GC*gc, const void *object, size_t size);
size 130 MMgc/GC.h GCRoot(GC *gc, const void *object, size_t size);
size 134 MMgc/GC.h void *operator new(size_t size);
size 139 MMgc/GC.h const void *End() const { return (char*)object + size; }
size 140 MMgc/GC.h void Set(const void *object, size_t size);
size 152 MMgc/GC.h size_t size;
size 868 MMgc/GC.h void *Alloc(size_t size, int flags=0);
size 877 MMgc/GC.h void *AllocPtrZero(size_t size); // Flags: GC::kContainsPointers|GC::kZero
size 878 MMgc/GC.h void *AllocPtrZeroFinalized(size_t size); // Flags: GC::kContainsPointers|GC::kZero|GC::kFinalize
size 879 MMgc/GC.h void *AllocRCObject(size_t size); // Flags: GC::kContainsPointers|GC::kZero|GC::kRCObject|GC::kFinalize
size 891 MMgc/GC.h void *AllocExtra(size_t size, size_t extra, int flags=0);
size 896 MMgc/GC.h void *AllocExtraPtrZero(size_t size, size_t extra); // Flags: GC::kContainsPointers|GC::kZero
size 897 MMgc/GC.h void *AllocExtraPtrZeroFinalized(size_t size, size_t extra); // Flags: GC::kContainsPointers|GC::kZero|GC::kFinalize
size 898 MMgc/GC.h void *AllocExtraRCObject(size_t size, size_t extra); // Flags: GC::kContainsPointers|GC::kZero|GC::kRCObject|GC::kFinalize
size 903 MMgc/GC.h void *OutOfLineAllocExtra(size_t size, size_t extra, int flags);
size 908 MMgc/GC.h void *PleaseAlloc(size_t size, int flags=0);
size 914 MMgc/GC.h void SignalAllocWork(size_t size);
size 922 MMgc/GC.h RCRootSegment(GC* gc, void* mem, size_t size);
size 924 MMgc/GC.h size_t size;
size 940 MMgc/GC.h AutoRCRootSegment(GC* gc, void* mem, size_t size);
size 949 MMgc/GC.h void* AllocRCRoot(size_t size);
size 1012 MMgc/GC.h void* AllocBlock(int size, int pageType, bool zero=true, bool canFail=false);
size 1014 MMgc/GC.h void FreeBlock(void *ptr, uint32_t size);
size 1315 MMgc/GC.h void *heapAlloc(size_t size, int flags=GCHeap::kExpand|GCHeap::kZero|GCHeap::kProfile);
size 1610 MMgc/GC.h void UnmarkedScan(const void *mem, size_t size);
size 1618 MMgc/GC.h void WhitePointerScan(const void *mem, size_t size);
size 1637 MMgc/GC.h void ProbeForMatch(const void *mem, size_t size, uintptr_t value, int recurseDepth, int currentDepth);
size 1771 MMgc/GC.h size_t size;
size 93 MMgc/GCAlloc-inlines.h return block->items + block->size * GetIndex(block, item);
size 221 MMgc/GCAlloc-inlines.h GCAssert(((char*) item - block->items) / block->size == (uint32_t) index);
size 329 MMgc/GCAlloc-inlines.h , size(alloc->m_itemSize)
size 344 MMgc/GCAlloc-inlines.h out_ptr = GetUserPointer(block->items + i*size);
size 345 MMgc/GCAlloc-inlines.h out_size = size - (uint32_t)DebugSize();
size 102 MMgc/GCAlloc.cpp VerifyFreeBlockIntegrity(m_firstBlock->firstFree, m_firstBlock->size);
size 136 MMgc/GCAlloc.cpp b->size = m_itemSize;
size 232 MMgc/GCAlloc.cpp GCAssertMsg(((size_t)m_itemSize >= size), "allocator itemsize too small");
size 273 MMgc/GCAlloc.cpp VerifyFreeBlockIntegrity(item, b->size);
size 277 MMgc/GCAlloc.cpp if(((uintptr_t)((char*)item + b->size) & 0xfff) != 0) {
size 278 MMgc/GCAlloc.cpp b->nextItem = (char*)item + b->size;
size 335 MMgc/GCAlloc.cpp m_totalAskSize += size;
size 336 MMgc/GCAlloc.cpp heap->AllocHook(GetUserPointer(item), size, userSize);
size 553 MMgc/GCAlloc.cpp m_gc->heap->FreeHook(GetUserPointer(item), b->size - DebugSize(), 0xba);
size 676 MMgc/GCAlloc.cpp if(block->items + itemNum * block->size != item)
size 754 MMgc/GCAlloc.cpp VMPI_memset((char*)item, 0, size);
size 785 MMgc/GCAlloc.cpp int n = (size >> 2) - 3;
size 787 MMgc/GCAlloc.cpp int n = (size >> 2) - 1;
size 55 MMgc/GCAlloc.h uint32_t size; // Size of objects stored in this block
size 102 MMgc/GCAlloc.h void* Alloc(size_t size, int flags);
size 204 MMgc/GCAlloc.h static void VerifyFreeBlockIntegrity(const void* item, uint32_t size);
size 319 MMgc/GCAlloc.h uint32_t size;
size 45 MMgc/GCAllocObject.cpp return VMPI_alloc(size);
size 50 MMgc/GCAllocObject.cpp return VMPI_alloc(size);
size 58 MMgc/GCAllocObject.h void* operator new (size_t size);
size 59 MMgc/GCAllocObject.h void* operator new [] (size_t size);
size 51 MMgc/GCGlobalNew.cpp void *space = VMPI_alloc(size);
size 59 MMgc/GCGlobalNew.cpp GCHeap::GetGCHeap()->SystemOOMEvent(size, attempt++);
size 60 MMgc/GCGlobalNew.cpp space = VMPI_alloc(size);
size 66 MMgc/GCGlobalNew.cpp heap->TrackSystemAlloc(space, size);
size 69 MMgc/GCGlobalNew.cpp VMPI_memset(space, 0, size);
size 107 MMgc/GCGlobalNew.cpp return MMgc::NewTaggedScalar(size);
size 112 MMgc/GCGlobalNew.cpp return MMgc::NewTaggedScalar(size, opts);
size 125 MMgc/GCGlobalNew.cpp size = GCHeap::CheckForAllocSizeOverflow(size, MMGC_GUARDCOOKIE_SIZE);
size 128 MMgc/GCGlobalNew.cpp char* mem = (char*)AllocCallInline(size, opts);
size 145 MMgc/GCGlobalNew.cpp return TaggedAlloc(size, opts, MMGC_SCALAR_GUARD);
size 152 MMgc/GCGlobalNew.cpp size_t size = GCHeap::CheckForCallocSizeOverflow(count, elsize);
size 154 MMgc/GCGlobalNew.cpp size = GCHeap::CheckForAllocSizeOverflow(size, MMGC_ARRAYHEADER_SIZE);
size 156 MMgc/GCGlobalNew.cpp void *p = TaggedAlloc(size, opts, MMGC_NORM_ARRAY_GUARD + uint32_t(isPrimitive));
size 67 MMgc/GCGlobalNew.h void *SystemNew(size_t size, FixedMallocOpts opts);
size 79 MMgc/GCGlobalNew.h REALLY_INLINE void *AllocCallInline(size_t size, FixedMallocOpts opts=kNone)
size 82 MMgc/GCGlobalNew.h return SystemNew(size, opts);
size 84 MMgc/GCGlobalNew.h return FixedMalloc::GetFixedMalloc()->OutOfLineAlloc(size, opts);
size 127 MMgc/GCGlobalNew.h return MMgc::AllocCallInline(size);
size 132 MMgc/GCGlobalNew.h return MMgc::AllocCallInline(size, opts);
size 135 MMgc/GCGlobalNew.h REALLY_INLINE void *operator new[](size_t size) MMGC_NEW_THROWS_CLAUSE
size 137 MMgc/GCGlobalNew.h return MMgc::AllocCallInline(size);
size 140 MMgc/GCGlobalNew.h REALLY_INLINE void *operator new[](size_t size, MMgc::FixedMallocOpts opts) MMGC_NEW_THROWS_CLAUSE
size 142 MMgc/GCGlobalNew.h return MMgc::AllocCallInline(size, opts);
size 221 MMgc/GCGlobalNew.h void* NewTaggedScalar(size_t size, FixedMallocOpts opts=kNone);
size 425 MMgc/GCGlobalNew.h (void)size; GCAssert(false);
size 437 MMgc/GCGlobalNew.h REALLY_INLINE void *operator new[](size_t size) MMGC_NEW_THROWS_CLAUSE
size 439 MMgc/GCGlobalNew.h (void)size;GCAssert(false);
size 45 MMgc/GCHashtable.cpp void* p = VMPI_alloc(size);
size 61 MMgc/GCHashtable.cpp return mmfx_alloc_opt(size, canFail ? kCanFail : kNone);
size 337 MMgc/GCHashtable.h static void* alloc(size_t size, bool canFail);
size 344 MMgc/GCHashtable.h static void* alloc(size_t size, bool canFail);
size 232 MMgc/GCHeap.cpp size_t internalNum = AddrToBlock(blocks)->size + numRegionBlocks;
size 284 MMgc/GCHeap.cpp GCAssert(size > 0);
size 292 MMgc/GCHeap.cpp HeapBlock *block = AllocBlock(size, zero);
size 298 MMgc/GCHeap.cpp ExpandHeap(size, (flags & kCanFail) != 0);
size 299 MMgc/GCHeap.cpp block = AllocBlock(size, zero);
size 311 MMgc/GCHeap.cpp GCAssert(block->size == size);
size 313 MMgc/GCHeap.cpp numAlloc += size;
size 326 MMgc/GCHeap.cpp profiler->RecordAllocation(baseAddr, size * kBlockSize, size * kBlockSize);
size 330 MMgc/GCHeap.cpp CheckForSoftLimitExceeded(size);
size 335 MMgc/GCHeap.cpp VMPI_memset(baseAddr, 0, size * kBlockSize);
size 356 MMgc/GCHeap.cpp GCAssert(numAlloc >= (unsigned int)block->size);
size 357 MMgc/GCHeap.cpp numAlloc -= block->size;
size 366 MMgc/GCHeap.cpp profiler->RecordDeallocation(item, block->size * kBlockSize);
size 415 MMgc/GCHeap.cpp GCAssert(block->size != 0);
size 422 MMgc/GCHeap.cpp if((size_t)block->size > decommitSize)
size 448 MMgc/GCHeap.cpp decommitSize -= block->size;
size 452 MMgc/GCHeap.cpp else if(VMPI_decommitMemory(block->baseAddr, block->size * kBlockSize))
size 456 MMgc/GCHeap.cpp decommitSize -= block->size;
size 458 MMgc/GCHeap.cpp GCLog("decommitted %d page block from %p\n", block->size, block->baseAddr);
size 473 MMgc/GCHeap.cpp numDecommitted += block->size;
size 480 MMgc/GCHeap.cpp prev->size += block->size;
size 482 MMgc/GCHeap.cpp block->size = 0;
size 489 MMgc/GCHeap.cpp HeapBlock *next = block + block->size;
size 490 MMgc/GCHeap.cpp if(next->size != 0 && !next->committed && !next->inUse()) {
size 493 MMgc/GCHeap.cpp block->size += next->size;
size 495 MMgc/GCHeap.cpp next->size = 0;
size 500 MMgc/GCHeap.cpp next = block + block->size;
size 501 MMgc/GCHeap.cpp next->sizePrevious = block->size;
size 508 MMgc/GCHeap.cpp if (pointToInsert->size >= block->size && !pointToInsert->committed) {
size 523 MMgc/GCHeap.cpp region->commitTop == block->baseAddr + block->size*kBlockSize) {
size 605 MMgc/GCHeap.cpp GCLog("Removing block %p %d\n", block->baseAddr, block->size);
size 659 MMgc/GCHeap.cpp region->blockId += block->size;
size 699 MMgc/GCHeap.cpp size_t newBlocksLen = blocksLen - block->size;
size 701 MMgc/GCHeap.cpp HeapBlock *nextBlock = block + block->size;
size 706 MMgc/GCHeap.cpp if( block->sizePrevious && nextBlock->size ) {
size 711 MMgc/GCHeap.cpp else if ( !block->sizePrevious && !nextBlock->size ) {
size 730 MMgc/GCHeap.cpp size_t blockSize = block->size;
size 734 MMgc/GCHeap.cpp HeapBlock *src = block + block->size;
size 741 MMgc/GCHeap.cpp sentinel->size = 0;
size 810 MMgc/GCHeap.cpp if(block->size) {
size 811 MMgc/GCHeap.cpp next = block + block->size;
size 812 MMgc/GCHeap.cpp GCAssert(next->sizePrevious == block->size);
size 817 MMgc/GCHeap.cpp GCAssert(prev->size == block->sizePrevious);
size 822 MMgc/GCHeap.cpp GCAssert(sentinel->size == 0);
size 827 MMgc/GCHeap.cpp GCAssert(block->baseAddr == prev->baseAddr + (kBlockSize * prev->size));
size 833 MMgc/GCHeap.cpp GCAssert(block->size == 0);
size 836 MMgc/GCHeap.cpp Region *prevRegion = AddrToRegion(prev->baseAddr + (prev->size*kBlockSize) - 1);
size 837 MMgc/GCHeap.cpp GCAssert(prev->baseAddr + (prev->size*kBlockSize) == prevRegion->commitTop);
size 840 MMgc/GCHeap.cpp GCAssert(block - blocks == (intptr_t)blocksLen || block->size != 0);
size 868 MMgc/GCHeap.cpp GCAssert(item >= b->baseAddr && item < b->baseAddr + b->size * GCHeap::kBlockSize);
size 876 MMgc/GCHeap.cpp uint32_t startList = GetFreeListIndex(size);
size 888 MMgc/GCHeap.cpp if (block->size >= size && block->committed)
size 900 MMgc/GCHeap.cpp size_t totalSize = block->size;
size 906 MMgc/GCHeap.cpp while(totalSize < size && firstFree->sizePrevious != 0)
size 909 MMgc/GCHeap.cpp if(!prevBlock->inUse() && prevBlock->size > 0) {
size 910 MMgc/GCHeap.cpp totalSize += prevBlock->size;
size 917 MMgc/GCHeap.cpp if(totalSize > size) {
size 921 MMgc/GCHeap.cpp HeapBlock *nextBlock = block + block->size;
size 922 MMgc/GCHeap.cpp while(nextBlock->size > 0 && !nextBlock->inUse() && totalSize < size) {
size 923 MMgc/GCHeap.cpp totalSize += nextBlock->size;
size 924 MMgc/GCHeap.cpp nextBlock = nextBlock + nextBlock->size;
size 927 MMgc/GCHeap.cpp if(totalSize > size) {
size 943 MMgc/GCHeap.cpp if(blockToUse->size > size)
size 945 MMgc/GCHeap.cpp HeapBlock *newBlock = Split(blockToUse, size);
size 972 MMgc/GCHeap.cpp if(decommittedSuitableBlock->size > size)
size 974 MMgc/GCHeap.cpp size_t toCommit = size > kMinHeapIncrement ? size : kMinHeapIncrement;
size 976 MMgc/GCHeap.cpp if(toCommit > decommittedSuitableBlock->size)
size 977 MMgc/GCHeap.cpp toCommit = decommittedSuitableBlock->size;
size 982 MMgc/GCHeap.cpp if(decommittedSuitableBlock->size > toCommit) {
size 991 MMgc/GCHeap.cpp if(toCommit > size) {
size 992 MMgc/GCHeap.cpp HeapBlock *newBlock = Split(decommittedSuitableBlock, size);
size 1002 MMgc/GCHeap.cpp size_t amountRecommitted = block->committed ? 0 : block->size;
size 1004 MMgc/GCHeap.cpp while(block->size < size)
size 1006 MMgc/GCHeap.cpp HeapBlock *nextBlock = block + block->size;
size 1011 MMgc/GCHeap.cpp block->size += nextBlock->size;
size 1012 MMgc/GCHeap.cpp amountRecommitted += nextBlock->committed ? 0 : nextBlock->size;
size 1014 MMgc/GCHeap.cpp nextBlock->size = 0;
size 1023 MMgc/GCHeap.cpp if(!VMPI_commitMemory(block->baseAddr, block->size * kBlockSize))
size 1032 MMgc/GCHeap.cpp GCAssert(decommittedSuitableBlock->size >= size);
size 1035 MMgc/GCHeap.cpp if(block->size > size)
size 1037 MMgc/GCHeap.cpp HeapBlock *newBlock = Split(block, size);
size 1042 MMgc/GCHeap.cpp GCAssert(decommittedSuitableBlock->size == size);
size 1045 MMgc/GCHeap.cpp HeapBlock *nextBlock = decommittedSuitableBlock + size;
size 1046 MMgc/GCHeap.cpp nextBlock->sizePrevious = size;
size 1059 MMgc/GCHeap.cpp GCAssert(block->size > size);
size 1060 MMgc/GCHeap.cpp HeapBlock *newBlock = block + size;
size 1061 MMgc/GCHeap.cpp newBlock->baseAddr = block->baseAddr + kBlockSize * size;
size 1063 MMgc/GCHeap.cpp newBlock->size = block->size - size;
size 1064 MMgc/GCHeap.cpp newBlock->sizePrevious = size;
size 1067 MMgc/GCHeap.cpp block->size = size;
size 1070 MMgc/GCHeap.cpp HeapBlock *nextBlock = newBlock + newBlock->size;
size 1071 MMgc/GCHeap.cpp nextBlock->sizePrevious = newBlock->size;
size 1080 MMgc/GCHeap.cpp if(!VMPI_commitMemory(block->baseAddr, block->size * kBlockSize))
size 1085 MMgc/GCHeap.cpp GCLog("recommitted %d pages\n", block->size);
size 1088 MMgc/GCHeap.cpp numDecommitted -= block->size;
size 1109 MMgc/GCHeap.cpp GCAssert(block->sizePrevious == prev->size);
size 1126 MMgc/GCHeap.cpp if( !b->size )
size 1135 MMgc/GCHeap.cpp char* end = b->baseAddr + b->size*kBlockSize;
size 1137 MMgc/GCHeap.cpp GCLog("error, block %d %p %d did not find a matching region\n", block_idx, b->baseAddr, b->size);
size 1156 MMgc/GCHeap.cpp if(!blocks[r->blockId].size){
size 1158 MMgc/GCHeap.cpp if( blocks[i].size){
size 1160 MMgc/GCHeap.cpp if( ((blocks[i].baseAddr + blocks[i].size*kBlockSize) <= r->baseAddr) ) {
size 1178 MMgc/GCHeap.cpp if(!blocks[b].size)
size 1180 MMgc/GCHeap.cpp GCLog("%d %p %d\n", b, blocks[b].baseAddr, blocks[b].size);
size 1197 MMgc/GCHeap.cpp int index = GetFreeListIndex(block->size);
size 1205 MMgc/GCHeap.cpp if (block->size >= kUniqueThreshold) {
size 1207 MMgc/GCHeap.cpp if (pointToInsert->size >= block->size) {
size 1242 MMgc/GCHeap.cpp VMPI_memset(block->baseAddr, 0xfb, block->size * kBlockSize);
size 1255 MMgc/GCHeap.cpp prevBlock->size += block->size;
size 1257 MMgc/GCHeap.cpp block->size = 0;
size 1266 MMgc/GCHeap.cpp HeapBlock *nextBlock = block + block->size;
size 1268 MMgc/GCHeap.cpp GCAssert(block->size != 0);
size 1275 MMgc/GCHeap.cpp block->size += nextBlock->size;
size 1276 MMgc/GCHeap.cpp nextBlock->size = 0;
size 1282 MMgc/GCHeap.cpp nextBlock = block + block->size;
size 1283 MMgc/GCHeap.cpp nextBlock->sizePrevious = block->size;
size 1343 MMgc/GCHeap.cpp size_t size = askSize;
size 1349 MMgc/GCHeap.cpp size_t defaultReserve = test_bridging ? (size+kMinHeapIncrement) : kDefaultReserve;
size 1364 MMgc/GCHeap.cpp size = roundUp(size, kMinHeapIncrement);
size 1378 MMgc/GCHeap.cpp size_t curHeapBlocksSize = blocks ? AddrToBlock(blocks)->size : 0;
size 1379 MMgc/GCHeap.cpp size_t newHeapBlocksSize = numHeapBlocksToNumBlocks(blocksLen + size + extraBlocks);
size 1385 MMgc/GCHeap.cpp size = roundUp(askSize + newHeapBlocksSize + extraBlocks, kMinHeapIncrement);
size 1392 MMgc/GCHeap.cpp newHeapBlocksSize = numHeapBlocksToNumBlocks(blocksLen + size + extraBlocks);
size 1405 MMgc/GCHeap.cpp if (size <= commitAvail) {
size 1406 MMgc/GCHeap.cpp if (VMPI_commitMemory(region->commitTop, size * kBlockSize))
size 1414 MMgc/GCHeap.cpp contiguous = last->baseAddr + last->size * kBlockSize == baseAddr;
size 1417 MMgc/GCHeap.cpp region->commitTop += size*kBlockSize;
size 1434 MMgc/GCHeap.cpp if (defaultReserve > size) {
size 1445 MMgc/GCHeap.cpp (size - commitAvail)*kBlockSize);
size 1446 MMgc/GCHeap.cpp newRegionSize = size - commitAvail;
size 1464 MMgc/GCHeap.cpp if (!VMPI_commitMemory(newRegionAddr, (size - commitAvail) * kBlockSize))
size 1474 MMgc/GCHeap.cpp (size-commitAvail)*kBlockSize);
size 1486 MMgc/GCHeap.cpp contiguous = last->baseAddr + last->size * kBlockSize == baseAddr;
size 1501 MMgc/GCHeap.cpp if (size < defaultReserve) {
size 1511 MMgc/GCHeap.cpp size*kBlockSize);
size 1512 MMgc/GCHeap.cpp newRegionSize = size;
size 1522 MMgc/GCHeap.cpp size*kBlockSize) == 0)
size 1538 MMgc/GCHeap.cpp newRegionAddr = (char*)VMPI_allocateAlignedMemory(size * kBlockSize);
size 1540 MMgc/GCHeap.cpp newRegionSize = size;
size 1557 MMgc/GCHeap.cpp size_t newBlocksLen = blocksLen + size;
size 1591 MMgc/GCHeap.cpp block->size = size;
size 1599 MMgc/GCHeap.cpp while(b->size == 0)
size 1604 MMgc/GCHeap.cpp block->sizePrevious = b->size;
size 1605 MMgc/GCHeap.cpp GCAssert((block - block->sizePrevious)->size == b->size);
size 1640 MMgc/GCHeap.cpp size_t freeBlockSize = block->size;
size 1645 MMgc/GCHeap.cpp block->size = 0;
size 1660 MMgc/GCHeap.cpp block->size = 0;
size 1680 MMgc/GCHeap.cpp numAlloc -= oldBlocksHB->size;
size 1701 MMgc/GCHeap.cpp newRegionAddr+(size-commitAvail)*kBlockSize, // commit top
size 1702 MMgc/GCHeap.cpp newBlocksLen-(size-commitAvail)-1); // block id
size 1715 MMgc/GCHeap.cpp GCLog("heap expanded by %d pages\n", size);
size 1778 MMgc/GCHeap.cpp (void)item,(void)size;
size 1783 MMgc/GCHeap.cpp profiler->RecordDeallocation(item, size);
size 1788 MMgc/GCHeap.cpp avmplus::recordDeallocationSample(item, size);
size 1794 MMgc/GCHeap.cpp (void)poison,(void)item,(void)size;
size 1796 MMgc/GCHeap.cpp DebugFree(item, poison, size);
size 1824 MMgc/GCHeap.cpp (void)size;
size 2145 MMgc/GCHeap.cpp GCAssert(spanningBlock->baseAddr + (spanningBlock->size * kBlockSize) > r->baseAddr);
size 2147 MMgc/GCHeap.cpp char *end = spanningBlock->baseAddr + (spanningBlock->size * kBlockSize);
size 2154 MMgc/GCHeap.cpp if(addr == spanningBlock->baseAddr + (spanningBlock->size * kBlockSize))
size 2159 MMgc/GCHeap.cpp GCAssert(hb->size != 0);
size 2168 MMgc/GCHeap.cpp for(i=0, n=hb->size; i < n; i++, addr += GCHeap::kBlockSize) {
size 2232 MMgc/GCHeap.cpp bool success = VMPI_releaseMemoryRegion(address, size);
size 338 MMgc/GCHeap.h void *Alloc(size_t size, uint32_t flags=kExpand | kZero | kProfile);
size 344 MMgc/GCHeap.h void *AllocCodeMemory(size_t size)
size 346 MMgc/GCHeap.h codeMemory += size;
size 347 MMgc/GCHeap.h return Alloc(size);
size 365 MMgc/GCHeap.h codeMemory -= block->size;
size 434 MMgc/GCHeap.h void FinalizeHook(const void *item, size_t size);
size 436 MMgc/GCHeap.h void FreeHook(const void *item, size_t size, int poison);
size 461 MMgc/GCHeap.h void SystemOOMEvent(size_t size, int attempt);
size 492 MMgc/GCHeap.h REALLY_INLINE static size_t CheckForAllocSizeOverflow(size_t size, size_t extra)
size 495 MMgc/GCHeap.h uint64_t total = (uint64_t)size + (uint64_t)extra;
size 500 MMgc/GCHeap.h if ((total > (uint64_t)kMaxObjectSize) || (total < size) || (total < extra))
size 664 MMgc/GCHeap.h void ExpandHeap(size_t size, bool canFail=false);
size 665 MMgc/GCHeap.h bool ExpandHeapInternal(size_t size);
size 672 MMgc/GCHeap.h size_t size; // size of this block
size 683 MMgc/GCHeap.h char *endAddr() const { return baseAddr + size*kBlockSize; }
size 687 MMgc/GCHeap.h size = 0;
size 699 MMgc/GCHeap.h HeapBlock *AllocBlock(size_t size, bool& zero);
size 705 MMgc/GCHeap.h HeapBlock *Split(HeapBlock *block, size_t size);
size 756 MMgc/GCHeap.h inline uint32_t GetFreeListIndex(size_t size)
size 758 MMgc/GCHeap.h if (size <= kUniqueThreshold) {
size 759 MMgc/GCHeap.h return (uint32_t)size-1;
size 760 MMgc/GCHeap.h } else if (size >= kHugeThreshold) {
size 763 MMgc/GCHeap.h return (uint32_t) ((size-kUniqueThreshold)/kFreeListCompression+kUniqueThreshold-1);
size 776 MMgc/GCHeap.h void ReleaseMemory(char *address, size_t size);
size 859 MMgc/GCHeap.h return block->size;
size 183 MMgc/GCLargeAlloc-inlines.h return (size + sizeof(LargeBlock)) / GCHeap::kBlockSize;
size 199 MMgc/GCLargeAlloc-inlines.h out_size = b->size - (uint32_t)DebugSize();
size 83 MMgc/GCLargeAlloc.cpp block->size = computedSize;
size 106 MMgc/GCLargeAlloc.cpp size_t userSize = block->size - DebugSize();
size 209 MMgc/GCLargeAlloc.cpp m_gc->heap->FinalizeHook(GetUserPointer(item), b->size - DebugSize());
size 248 MMgc/GCLargeAlloc.cpp totalAllocated += block->size;
size 64 MMgc/GCMemoryProfiler.cpp size_t size;
size 195 MMgc/GCMemoryProfiler.cpp trace->size += delta;
size 197 MMgc/GCMemoryProfiler.cpp GCAssert(trace->count != 0 || trace->size == 0);
size 243 MMgc/GCMemoryProfiler.cpp ChangeSize(info->allocTrace, -1 * int(size));
size 251 MMgc/GCMemoryProfiler.cpp trace->sweepSize += size;
size 283 MMgc/GCMemoryProfiler.cpp PackageGroup(const char *name) : name(name), size(0), count(0), categories(16) {}
size 285 MMgc/GCMemoryProfiler.cpp size_t size;
size 295 MMgc/GCMemoryProfiler.cpp CategoryGroup(const char *name) : name(name), size(0), count(0)
size 300 MMgc/GCMemoryProfiler.cpp size_t size;
size 386 MMgc/GCMemoryProfiler.cpp size_t size;
size 389 MMgc/GCMemoryProfiler.cpp size = trace->sweepSize;
size 391 MMgc/GCMemoryProfiler.cpp size = trace->totalSize;
size 393 MMgc/GCMemoryProfiler.cpp size = trace->size;
size 396 MMgc/GCMemoryProfiler.cpp if(size == 0)
size 399 MMgc/GCMemoryProfiler.cpp residentSize += size;
size 411 MMgc/GCMemoryProfiler.cpp pg->size += size;
size 420 MMgc/GCMemoryProfiler.cpp tg->size += size;
size 427 MMgc/GCMemoryProfiler.cpp if(!tg->traces[j] || tg->traces[j]->size < size) {
size 449 MMgc/GCMemoryProfiler.cpp if(packages[j] == NULL || packages[j]->size < pg->size) {
size 485 MMgc/GCMemoryProfiler.cpp if(residentFatties[j]->size < tg->size) {
size 495 MMgc/GCMemoryProfiler.cpp GCLog("%s - %3.1f%% - %u kb %u items, avg %u b\n", pg->name, PERCENT(residentSize, pg->size), (unsigned int)(pg->size>>10), pg->count, (unsigned int)(pg->count ? pg->size/pg->count : 0));
size 506 MMgc/GCMemoryProfiler.cpp GCLog("\t%s - %3.1f%% - %u kb %u items, avg %u b\n", tg->name, PERCENT(residentSize, tg->size), (unsigned int)(tg->size>>10), tg->count, (unsigned int)(tg->count ? tg->size/tg->count : 0));
size 510 MMgc/GCMemoryProfiler.cpp size_t size = trace->size;
size 513 MMgc/GCMemoryProfiler.cpp size = trace->sweepSize;
size 516 MMgc/GCMemoryProfiler.cpp size = trace->totalSize;
size 519 MMgc/GCMemoryProfiler.cpp GCLog("\t\t %3.1f%% - %u kb - %u items - ", PERCENT(tg->size, size), size>>10, count);
size 562 MMgc/GCMemoryProfiler.cpp size_t size;
size 566 MMgc/GCMemoryProfiler.cpp size = trace->sweepSize;
size 569 MMgc/GCMemoryProfiler.cpp size = trace->totalSize;
size 572 MMgc/GCMemoryProfiler.cpp size = trace->size;
size 576 MMgc/GCMemoryProfiler.cpp if(size == 0)
size 579 MMgc/GCMemoryProfiler.cpp GCLog("%u b - %u items - ", size, count);
size 729 MMgc/GCMemoryProfiler.cpp *mem++ = (int32_t)size;
size 731 MMgc/GCMemoryProfiler.cpp mem += (size>>2);
size 743 MMgc/GCMemoryProfiler.cpp uint32_t size = *ip;
size 744 MMgc/GCMemoryProfiler.cpp uint32_t *endMarker = ip + 2 + (size>>2);
size 751 MMgc/GCMemoryProfiler.cpp if(size == 0)
size 772 MMgc/GCMemoryProfiler.cpp DebugFreeHelper(item, poison, size);
size 89 MMgc/GCMemoryProfiler.h void RecordDeallocation(const void *item, size_t size);
size 142 MMgc/GCMemoryProfiler.h void DebugDecorate(const void *item, size_t size);
size 147 MMgc/GCMemoryProfiler.h void *DebugFree(const void *item, int poison, size_t size);
size 56 MMgc/GCObject.h return gc->AllocPtrZero(size);
size 61 MMgc/GCObject.h return gc->Alloc(size, flags);
size 73 MMgc/GCObject.h static void *operator new(size_t size, GC *gc, size_t extra) GNUC_ONLY(throw());
size 75 MMgc/GCObject.h static void *operator new(size_t size, GC *gc) GNUC_ONLY(throw());
size 93 MMgc/GCObject.h static void* operator new(size_t size, GC *gc, size_t extra);
size 94 MMgc/GCObject.h static void* operator new(size_t size, GC *gc);
size 98 MMgc/GCObject.h REALLY_INLINE void *GCObject::operator new(size_t size, GC *gc, size_t extra) GNUC_ONLY(throw())
size 100 MMgc/GCObject.h return gc->AllocExtraPtrZero(size, extra);
size 103 MMgc/GCObject.h REALLY_INLINE void *GCObject::operator new(size_t size, GC *gc) GNUC_ONLY(throw())
size 105 MMgc/GCObject.h return gc->AllocPtrZero(size);
size 128 MMgc/GCObject.h REALLY_INLINE void* GCFinalizedObject::operator new(size_t size, GC *gc, size_t extra)
size 130 MMgc/GCObject.h return gc->AllocExtraPtrZeroFinalized(size, extra);
size 133 MMgc/GCObject.h REALLY_INLINE void* GCFinalizedObject::operator new(size_t size, GC *gc)
size 135 MMgc/GCObject.h return gc->AllocPtrZeroFinalized(size);
size 171 MMgc/GCObject.h REALLY_INLINE static void *operator new(size_t size, GC *gc, size_t extra)
size 173 MMgc/GCObject.h return gc->AllocExtraRCObject(size, extra);
size 176 MMgc/GCObject.h REALLY_INLINE static void *operator new(size_t size, GC *gc)
size 178 MMgc/GCObject.h return gc->AllocRCObject(size);
size 66 MMgc/GCWeakRef.h static void *operator new(size_t size, GC *gc)
size 68 MMgc/GCWeakRef.h return gc->Alloc(size, GC::kFinalize);
size 591 MMgc/ZCT.cpp PinStackObjects(segment->mem, segment->size);
size 123 VMPI/MMgcPortMac.cpp size,
size 133 VMPI/MMgcPortMac.cpp VMPI_releaseMemoryRegion(addr, size);
size 141 VMPI/MMgcPortMac.cpp int result = munmap(address, size);
size 148 VMPI/MMgcPortMac.cpp size,
size 157 VMPI/MMgcPortMac.cpp kern_return_t result = vm_deallocate(mach_task_self(), (vm_address_t)address, size);
size 160 VMPI/MMgcPortMac.cpp result = vm_map(mach_task_self(), (vm_address_t*)&address, size, 0, FALSE, MEMORY_OBJECT_NULL, 0, FALSE, VM_PROT_NONE, VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE, VM_INHERIT_NONE);
size 168 VMPI/MMgcPortMac.cpp return valloc(size);
size 182 VMPI/MMgcPortMac.cpp vm_size_t size = 0;
size 190 VMPI/MMgcPortMac.cpp addr += size;
size 193 VMPI/MMgcPortMac.cpp ret = vm_region_64(task, &addr, &size, VM_REGION_TOP_INFO, (vm_region_info_t)&info, &count, &object_name);
size 195 VMPI/MMgcPortMac.cpp ret = vm_region(task, &addr, &size, VM_REGION_TOP_INFO, (vm_region_info_t)&info, &count, &object_name);
size 62 VMPI/MMgcPortSymbian.cpp if(chunk.CreateLocalCode(0,size,EOwnerProcess) == KErrNone)
size 64 VMPI/MMgcPortSymbian.cpp if(chunk.CreateDisconnectedLocal(0,0,size,EOwnerProcess) == KErrNone)
size 69 VMPI/MMgcPortSymbian.cpp endAddr = startAddr + size;
size 86 VMPI/MMgcPortSymbian.cpp if(chunk.Commit(addr - startAddr, size) == KErrNone)
size 96 VMPI/MMgcPortSymbian.cpp if(chunk.Decommit(addr - startAddr, size) == KErrNone)
size 163 VMPI/MMgcPortSymbian.cpp SymbianHeap* newHeap = new SymbianHeap(size);
size 217 VMPI/MMgcPortSymbian.cpp result = heap->Commit((TInt)address, (TInt)size);
size 221 VMPI/MMgcPortSymbian.cpp memset(address, 0, size);
size 231 VMPI/MMgcPortSymbian.cpp while( temp_addr < (addr+size))
size 251 VMPI/MMgcPortSymbian.cpp result = heap->Decommit((TInt)address, (TInt)size);
size 264 VMPI/MMgcPortSymbian.cpp size_t alloc_size = size + align_size + sizeof(int);
size 104 VMPI/MMgcPortUnix.cpp size,
size 113 VMPI/MMgcPortUnix.cpp VMPI_releaseMemoryRegion(addr, size);
size 121 VMPI/MMgcPortUnix.cpp int result = munmap((maddr_ptr)address, size);
size 128 VMPI/MMgcPortUnix.cpp size,
size 135 VMPI/MMgcPortUnix.cpp while( temp_addr < (addr+size))
size 153 VMPI/MMgcPortUnix.cpp size,
size 162 VMPI/MMgcPortUnix.cpp return valloc(size);
size 244 VMPI/MMgcPortUnix.cpp uint32_t size = VMPI_atoi(size_buff)*1024;
size 245 VMPI/MMgcPortUnix.cpp uint32_t blocks = size/pageSize;
size 246 VMPI/MMgcPortUnix.cpp if( size % pageSize != 0 )
size 86 VMPI/MMgcPortWin.cpp size,
size 103 VMPI/MMgcPortWin.cpp size,
size 133 VMPI/MMgcPortWin.cpp size_t commitSize = size > mbi.RegionSize ? mbi.RegionSize : size;
size 136 VMPI/MMgcPortWin.cpp size -= commitSize;
size 137 VMPI/MMgcPortWin.cpp } while(size > 0 && success);
size 148 VMPI/MMgcPortWin.cpp size_t commitSize = size > mbi.RegionSize ? mbi.RegionSize : size;
size 151 VMPI/MMgcPortWin.cpp size -= commitSize;
size 152 VMPI/MMgcPortWin.cpp } while(size > 0 && success);
size 159 VMPI/MMgcPortWin.cpp return VirtualAlloc(NULL, size, MEM_COMMIT
size 134 VMPI/PosixPortUtils.cpp return malloc(size);
size 192 VMPI/PosixPortUtils.cpp void *endAddress = (void*) ((char*)address + size);
size 182 VMPI/SymbianPortUtils.cpp return malloc(size);
size 232 VMPI/SymbianPortUtils.cpp (void)size;
size 225 VMPI/WinPortUtils.cpp return HeapAlloc(GetProcessHeap(), 0, size);
size 293 VMPI/WinPortUtils.cpp size_t markSize = size > mbi.RegionSize ? mbi.RegionSize : size;
size 299 VMPI/WinPortUtils.cpp size -= markSize;
size 300 VMPI/WinPortUtils.cpp } while(size > 0 && retval);
size 232 axscript/axtam.cpp std::ifstream::pos_type size(file.tellg());
size 233 axscript/axtam.cpp ScriptBuffer code = newScriptBuffer(size);
size 235 axscript/axtam.cpp file.read((char *)code.getBuffer(), size);
size 84 core/AbcGen.h size_t size() { return bytes.size(); }
size 178 core/AbcParser.cpp debugger->pool2abcIndex.add(pool, (const void *)debugger->abcList.size());
size 295 core/AbcParser.cpp if (index >= pool->cpool_mn_offsets.size())
size 296 core/AbcParser.cpp toplevel->throwVerifyError(kCpoolIndexRangeError, core->toErrorString(index), core->toErrorString(pool->cpool_mn_offsets.size()));
size 305 core/AbcParser.cpp if (index == 0 || index >= pool->cpool_mn_offsets.size())
size 654 core/AbcParser.cpp int size = methodCount == 0 ? 1 : methodCount;
size 656 core/AbcParser.cpp if (size > (abcEnd - pos))
size 660 core/AbcParser.cpp pool->_methods.ensureCapacity(size);
size 664 core/AbcParser.cpp pool->_method_dmi.ensureCapacity(size);
size 665 core/AbcParser.cpp for (int i = 0; i < size; ++i)
size 672 core/AbcParser.cpp pool->_method_name_indices.ensureCapacity(size);
size 991 core/AbcParser.cpp if (name_index >= pool->cpool_mn_offsets.size())
size 1021 core/AbcParser.cpp if (name_index >= pool->cpool_mn_offsets.size())
size 766 core/ArrayClass.cpp uint32 size;
size 778 core/ArrayClass.cpp size = (hi - lo) + 1; // number of elements in the partition
size 780 core/ArrayClass.cpp if (size < 4) {
size 792 core/ArrayClass.cpp if (size == 3) {
size 809 core/ArrayClass.cpp } else if (size == 2) {
size 820 core/ArrayClass.cpp uint32 pivot = lo + (size / 2);
size 531 core/ArrayObject.cpp uint64 s = ScriptObject::size();
size 132 core/ArrayObject.h virtual uint64 size() const;
size 398 core/AvmCore.cpp for(int i=0, size=builtinPool->methodCount(); i<size; i++)
size 401 core/AvmCore.cpp for(int i=0, size=builtinPool->classCount(); i<size; i++)
size 404 core/AvmCore.cpp for(int i=0, size=builtinPool->scriptCount(); i<size; i++)
size 1570 core/AvmCore.cpp if (index > 0 && index <= pool->cpool_mn_offsets.size())
size 1606 core/AvmCore.cpp if (index < pool->cpool_int.size())
size 1614 core/AvmCore.cpp if (index < pool->cpool_uint.size())
size 1622 core/AvmCore.cpp if (index > 0 && index < pool->cpool_double.size())
size 1636 core/AvmCore.cpp if (index < pool->cpool_ns.size())
size 1816 core/AvmCore.cpp if (index < pool->cpool_double.size())
size 1826 core/AvmCore.cpp if (index < pool->cpool_ns.size())
size 3440 core/AvmCore.cpp return new (GetGC(), size) BasicScriptBufferImpl(size);
size 1384 core/AvmCore.h ScriptBufferImpl* newScriptBuffer(size_t size);
size 60 core/AvmPlusScriptableObject.h virtual uint64 size() const = 0;
size 229 core/BigInteger.h inline void copyBuffer(const uint32 *newBuff, int32 size)
size 231 core/BigInteger.h numWords = size;
size 605 core/CdeclThunk.cpp int32_t size = 0;
size 619 core/CdeclThunk.cpp return size;
size 626 core/CdeclThunk.cpp size += sizeof(int32_t);
size 628 core/CdeclThunk.cpp size += sizeof(double);
size 630 core/CdeclThunk.cpp size += sizeof(void*);
size 635 core/CdeclThunk.cpp size += sizeof(void*);
size 636 core/CdeclThunk.cpp return size;
size 141 core/ClassClosure.cpp uint64 size = ScriptObject::size();
size 142 core/ClassClosure.cpp size += vtable->size();
size 143 core/ClassClosure.cpp return size;
size 77 core/ClassClosure.h virtual uint64 size() const;
size 226 core/CodegenLIR.cpp uint32_t size;
size 869 core/CodegenLIR.cpp return out->insJtbl(index, size);
size 878 core/CodegenLIR.cpp AvmAssert(size >= 4 && isU16((size+3)>>2));
size 879 core/CodegenLIR.cpp return out->insAlloc(size);
size 996 core/CodegenLIR.cpp return out->insJtbl(index, size);
size 2208 core/CodegenLIR.cpp int captured_depth = scope->size;
size 3134 core/CodegenLIR.cpp if (scopeTypes->size == 0)
size 3273 core/CodegenLIR.cpp LIns* realAddr = mopAddrToRangeCheckedRealAddrAndDisp(mopAddr, mi.size, &disp);
size 3276 core/CodegenLIR.cpp LIns* realAddr = mopAddrToRangeCheckedRealAddrAndDisp(mopAddr, mi.size, NULL);
size 3295 core/CodegenLIR.cpp LIns* realAddr = mopAddrToRangeCheckedRealAddrAndDisp(mopAddr, mi.size, &disp);
size 3298 core/CodegenLIR.cpp LIns* realAddr = mopAddrToRangeCheckedRealAddrAndDisp(mopAddr, mi.size, NULL);
size 4972 core/CodegenLIR.cpp AvmAssert(size > 0); // it's signed to help make the int promotion correct
size 4978 core/CodegenLIR.cpp globalMemoryInfo->size = pool->domain->globalMemorySize();
size 4980 core/CodegenLIR.cpp pool->domain->addGlobalMemorySizeRef(&globalMemoryInfo->size);
size 5035 core/CodegenLIR.cpp LInsp mopsMemorySize = loadIns(LIR_ldc, 0, InsConstPtr(&globalMemoryInfo->size));
size 5043 core/CodegenLIR.cpp rhs = binaryIns(LIR_sub, mopsMemorySize, InsConst(size));
size 5055 core/CodegenLIR.cpp lhs = binaryIns(LIR_add, mopAddr, InsConst(*disp+size));
size 5251 core/CodegenLIR.cpp return lirout->insAlloc(size >= 4 ? size : 4);
size 5633 core/CodegenLIR.cpp AvmAssert(!jitPendingRecords.size()); // all should be resolved by now
size 5634 core/CodegenLIR.cpp int32_t count = jitInfoList.size();
size 5638 core/CodegenLIR.cpp if (jitInfo->lineNumTable.size()) {
size 5652 core/CodegenLIR.cpp if (jitInfoList.size()<1)
size 5654 core/CodegenLIR.cpp return jitInfoList[jitInfoList.size()-1];
size 5680 core/CodegenLIR.cpp int32_t size = jitPendingRecords.size();
size 5681 core/CodegenLIR.cpp for(int32_t i=size-1; i>=0; i--) {
size 5693 core/CodegenLIR.cpp int32_t size = jitPendingRecords.size();
size 5694 core/CodegenLIR.cpp for(int32_t i=size-1; i>=0; i--) {
size 5785 core/CodegenLIR.cpp return mmfx_alloc(size);
size 358 core/CodegenLIR.h uint32_t size;
size 428 core/CodegenLIR.h LIns* mopAddrToRangeCheckedRealAddrAndDisp(LIns* mopAddr, int32_t const size, int32_t* disp);
size 1703 core/MethodEnv.cpp if (outerTraits->fullsize > outerTraits->size)
size 1706 core/MethodEnv.cpp t = outerTraits->getScopeTraitsAt(outerTraits->size);
size 1133 core/MethodInfo.cpp uint32_t size = sizeof(MethodInfo);
size 1134 core/MethodInfo.cpp size += getMethodSignature()->param_count() * 2 * sizeof(Atom);
size 1135 core/MethodInfo.cpp size += codeSize();
size 1136 core/MethodInfo.cpp return size;
size 335 core/MethodInfo.h uint32_t size();
size 99 core/MultinameHashtable.cpp size(0),
size 129 core/MultinameHashtable.cpp return 5*(size+1) >= numQuads*4;
size 300 core/MultinameHashtable.cpp size++;
size 161 core/MultinameHashtable.h public: int size; // no. of properties
size 119 core/Namespace.h uint64 size() const { return sizeof(Namespace) - sizeof(AvmPlusScriptableObject); }
size 44 core/PoolObject-inlines.h REALLY_INLINE void* PrecomputedMultinames::operator new(size_t size, size_t extra)
size 47 core/PoolObject-inlines.h return MMgc::FixedMalloc::GetFixedMalloc()->Alloc(size+extra, MMgc::kZero);
size 99 core/PoolObject-inlines.h return _classes.size();
size 109 core/PoolObject-inlines.h return _scripts.size();
size 119 core/PoolObject-inlines.h return _methods.size();
size 130 core/PoolObject-inlines.h return (i < _method_dmi.size()) ? _method_dmi[i] : NULL;
size 143 core/PoolObject-inlines.h REALLY_INLINE void PoolObject::ConstantStrings::setup(uint32_t size)
size 146 core/PoolObject-inlines.h size *= sizeof(ConstantStringData);
size 147 core/PoolObject-inlines.h data = (ConstantStringData*) mmfx_alloc(size);
size 148 core/PoolObject-inlines.h Set(data, size);
size 299 core/PoolObject.cpp if (!cpool_int_atoms.size())
size 304 core/PoolObject.cpp AvmAssert(cpool_int_atoms.size() == constantIntCount);
size 335 core/PoolObject.cpp if (!cpool_uint_atoms.size())
size 340 core/PoolObject.cpp AvmAssert(cpool_uint_atoms.size() == constantUIntCount);
size 568 core/PoolObject.cpp if (index == 0 || index >= cpool_mn_offsets.size())
size 571 core/PoolObject.cpp toplevel->throwVerifyError(kCpoolIndexRangeError, core->toErrorString(index), core->toErrorString(cpool_mn_offsets.size()));
size 594 core/PoolObject.cpp if (index >= cpool_mn_offsets.size())
size 597 core/PoolObject.cpp toplevel->throwVerifyError(kCpoolIndexRangeError, core->toErrorString(index), core->toErrorString(cpool_mn_offsets.size()));
size 687 core/PoolObject.cpp size_t const s = sizeof(PrecomputedMultinames) - sizeof(Multiname) + this->cpool_mn_offsets.size() * sizeof(Multiname);
size 696 core/PoolObject.cpp nNames = pool->cpool_mn_offsets.size();
size 715 core/PoolObject.cpp if (core->config.methodNames && (uint32_t(i) < uint32_t(this->_method_name_indices.size())))
size 60 core/PoolObject.h void *operator new(size_t size, size_t extra=0);
size 207 core/PoolObject.h void setup(uint32_t size);
size 139 core/Sampler.cpp sampler->recordAllocationSample(item, size);
size 147 core/Sampler.cpp sampler->recordDeallocationSample(item, size);
size 343 core/Sampler.cpp read(p, s.size);
size 369 core/Sampler.cpp write(currentSample, size);
size 445 core/Sampler.cpp write(currentSample, size);
size 142 core/Sampler.h uint64 size;
size 176 core/Sampler.h uint64 recordAllocationSample(const void* item, uint64_t size, bool callback_ok = true, bool forceWrite = false);
size 177 core/Sampler.h void recordDeallocationSample(const void* item, uint64_t size);
size 45 core/ScopeChain-inlines.h : size(_size), fullsize(_fullsize), _traits(traits)
size 94 core/ScopeChain-inlines.h return _scopeTraits->size;
size 99 core/ScopeChain-inlines.h AvmAssert(i >= 0 && i < _scopeTraits->size);
size 48 core/ScopeChain.cpp const int32_t outerSize = (outer ? outer->size : 0);
size 104 core/ScopeChain.cpp ScopeTypeChain* nscope = new(gc, padSize) ScopeTypeChain(this->size, this->fullsize, p_traits);
size 136 core/ScopeChain.cpp const int32_t scopeTraitsSize = scopeTraits->size;
size 137 core/ScopeChain.cpp const int32_t outerSize = outer ? outer->_scopeTraits->size : 0;
size 154 core/ScopeChain.cpp const int32_t scopeTraitsSize = nstc->size;
size 157 core/ScopeChain.cpp for (int32_t i=0; i < nstc->size; i ++)
size 166 core/ScopeChain.cpp AvmAssert(i >= 0 && i < _scopeTraits->size);
size 180 core/ScopeChain.cpp for (int32_t i = 0; i < _scopeTraits->size; i++)
size 78 core/ScopeChain.h const int32_t size;
size 56 core/ScriptBuffer.h size_t getSize() const { return size; }
size 70 core/ScriptBuffer.h size_t size;
size 84 core/ScriptBuffer.h this->size = _size;
size 88 core/ScriptBuffer.h static void *operator new(size_t size, MMgc::GC *gc, size_t extra = 0)
size 90 core/ScriptBuffer.h return gc->Alloc(size + extra, 0);
size 105 core/ScriptBuffer.h this->size = _size;
size 121 core/ScriptBuffer.h this->size = _size;
size 835 core/ScriptObject.cpp uint64 size = traits()->getTotalSize();
size 838 core/ScriptObject.cpp size += getTable()->size();
size 840 core/ScriptObject.cpp size -= sizeof(AvmPlusScriptableObject);
size 841 core/ScriptObject.cpp return size;
size 231 core/ScriptObject.h virtual uint64 size() const;
size 85 core/SortedMap.h return keys.size() == 0;
size 87 core/SortedMap.h int size() const
size 89 core/SortedMap.h return keys.size();
size 103 core/SortedMap.h if (keys.size() == 0 || k > keys.last())
size 122 core/SortedMap.h AvmAssert(keys.size() != (uint32_t)i);
size 162 core/SortedMap.h T removeLast() { return isEmpty() ? (T)0 : removeAt(keys.size()-1); }
size 164 core/SortedMap.h T last() const { return isEmpty() ? (T)0 : values[keys.size()-1]; }
size 167 core/SortedMap.h K lastKey() const { return isEmpty() ? 0 : keys[keys.size()-1]; }
size 184 core/SortedMap.h int hi = keys.size()-1;
size 201 core/SortedMap.h void* operator new(size_t size);
size 217 core/SortedMap.h inline int size() const { return map.size(); }
size 2253 core/StringObject.cpp uint64 String::size() const
size 446 core/StringObject.h virtual uint64 size() const;
size 567 core/StringObject.h REALLY_INLINE void* operator new(size_t size, MMgc::GC *gc)
size 569 core/StringObject.h return AvmPlusScriptableObject::operator new(size, gc);
size 945 core/Traits.cpp size = tb->m_slotSize;
size 953 core/Traits.cpp size = 0;
size 963 core/Traits.cpp size = tb->m_slotSize - prevBindings->m_slotSize;
size 1152 core/Traits.cpp return seen.size();
size 1382 core/Traits.cpp for (uint32_t n = pending.size(); i < n; i++) {
size 1424 core/Traits.cpp for (uint32_t i = 0, n = pending.size(); i < n; i++) {
size 1707 core/Traits.cpp if (gen.size() == 0)
size 1711 core/Traits.cpp AbcGen newMethodBody(gc, uint32_t(16 + gen.size())); // @todo 16 is a magic value that was here before I touched the code -- I don't know the significance
size 1760 core/Traits.cpp newMethodBody.writeInt((uint32_t)gen.size()); // code length
size 1767 core/Traits.cpp uint8_t* newBytes = (uint8_t*) gc->Alloc(newMethodBody.size());
size 1768 core/Traits.cpp VMPI_memcpy(newBytes, newMethodBody.getBytes().getData(), newMethodBody.size());
size 2111 core/Traits.cpp return (Traits**) gc->Alloc((size+1) * sizeof(Traits*), MMgc::GC::kZero);
size 270 core/Traits.h void computeSlotAreaCountAndSize(TraitsBindings* tb, uint32_t& slotCount, uint32_t& size) const;
size 341 core/Traits.h static Traits** allocSupertypeList(MMgc:: GC*, uint32_t size);
size 324 core/VTable.cpp uint32 size = work_stack.size();
size 325 core/VTable.cpp for(uint32 i = 0; i < size; ++i)
size 327 core/VTable.cpp cur = work_stack[size-i-1];
size 451 core/VTable.cpp uint32 size = sizeof(VTable);
size 454 core/VTable.cpp size += ivtable->size();
size 459 core/VTable.cpp size += td->methodCount*sizeof(MethodInfo*);
size 471 core/VTable.cpp size += method->size();
size 474 core/VTable.cpp return size;
size 130 core/VTable.h uint32 size() const;
size 145 core/Verifier.cpp for(int i = 0, n=blockStates->size(); i < n; i++)
size 278 core/Verifier.cpp int size;
size 279 core/Verifier.cpp for (const byte* pc = code_pos, *code_end=code_pos+code_length; pc < code_end; pc += size)
size 445 core/Verifier.cpp size = int(nextpc-pc);
size 446 core/Verifier.cpp if (pc+size > code_end)
size 461 core/Verifier.cpp size += 3*(imm30b+1);
size 510 core/Verifier.cpp if (pc + size + 3*case_count > code_end)
size 514 core/Verifier.cpp int off = AvmCore::readS24(pc+size);
size 516 core/Verifier.cpp size += 3;
size 734 core/Verifier.cpp if (state->scopeDepth + scope->size == 0)
size 749 core/Verifier.cpp if (state->scopeDepth + scope->size == 0)
size 1378 core/Verifier.cpp if (scope->fullsize > (scope->size+state->scopeDepth))
size 1381 core/Verifier.cpp Traits* requiredType = scope->getScopeTraitsAt(scope->size+state->scopeDepth);
size 1466 core/Verifier.cpp int captured_depth = scope->size;
size 1507 core/Verifier.cpp if (!state->scopeDepth && !scope->size)
size 1509 core/Verifier.cpp Traits *globalTraits = scope->size > 0 ? scope->getScopeTraitsAt(0) : state->scopeValue(0).traits;
size 1858 core/Verifier.cpp size = 0;
size 2072 core/Verifier.cpp if (scope->size == 0)
size 2094 core/Verifier.cpp for (index = scope->size-1; index > 0; index--)
size 2117 core/Verifier.cpp if (scope->size > 0)
size 2218 core/Verifier.cpp int captured_depth = scope->size;
size 2700 core/Verifier.cpp if( !index || index >= pool->cpool_mn_offsets.size() )
size 2702 core/Verifier.cpp verifyFailed(kCpoolIndexRangeError, core->toErrorString(index), core->toErrorString(pool->cpool_mn_offsets.size()));
size 2868 core/Verifier.cpp if (declaringScope && declaringScope->size > 0)
size 2871 core/Verifier.cpp for (int i=0, n=declaringScope->size; i < n; i++)
size 2970 core/Verifier.cpp for (int i=0, n=blocks.size(); i < n; i++)
size 2972 core/Verifier.cpp for (int i=0, n=edges.size(); i < n; i++)
size 2988 core/Verifier.cpp for (int i = 0; i < blocks.size(); i++) {
size 2992 core/Verifier.cpp for (uint32_t j = 0; j < b->preds.size(); j++) {
size 2997 core/Verifier.cpp for (uint32_t j = 0; j < b->succs.size(); j++) {
size 3004 core/Verifier.cpp for (int i = 0; i < edges.size(); i++) {
size 478 core/XMLParser16.cpp if (index >= attributes.size()) {
size 394 core/avmplusDebugger.cpp uintptr index = abcList.size();
size 444 core/avmplusDebugger.cpp int size = 0;
size 447 core/avmplusDebugger.cpp for (const byte* pc=start; pc < end; pc += size)
size 453 core/avmplusDebugger.cpp size = AvmCore::calculateInstructionWidth(pc);
size 455 core/avmplusDebugger.cpp if (pc+size > end)
size 465 core/avmplusDebugger.cpp size += case_count*3;
size 575 core/avmplusDebugger.cpp return abcList.size();
size 601 core/avmplusDebugger.cpp return source.size();
size 671 core/avmplusDebugger.cpp return functions.size();
size 125 core/avmplusDebugger.h virtual int size() const = 0;
size 532 core/avmplusDebugger.h int size() const;
size 538 core/avmplusDebugger.h AbcFile(AvmCore* core, int size);
size 110 core/avmplusHashtable.h inline uint64 size() const
size 235 core/avmplusList.h uint32 size() const
size 287 core/avmplusList.h ensureCapacity(len+l.size());
size 290 core/avmplusList.h arraycopy(l.getData(), 0, data, len, l.size());
size 291 core/avmplusList.h len += l.size();
size 378 core/avmplusList.h for (int i=0, n=list.size(); i < n; i++)
size 83 core/avmplusStack.h int size()
size 54 eval/eval-abc.cpp uint32_t size = 0;
size 56 eval/eval-abc.cpp size += xs->hd->size();
size 57 eval/eval-abc.cpp return size;
size 77 eval/eval-abc.cpp uint32_t nbytes = src->size();
size 298 eval/eval-abc.cpp lenU30(intCount) + intBuf.size() +
size 299 eval/eval-abc.cpp lenU30(uintCount) + uintBuf.size() +
size 300 eval/eval-abc.cpp lenU30(doubleCount) + doubleBuf.size() +
size 301 eval/eval-abc.cpp lenU30(stringCount) + stringBuf.size() +
size 302 eval/eval-abc.cpp lenU30(namespaceCount) + namespaceBuf.size() +
size 303 eval/eval-abc.cpp lenU30(nssetCount) + nssetBuf.size() +
size 304 eval/eval-abc.cpp lenU30(multinameCount) + multinameBuf.size() +
size 433 eval/eval-abc.cpp reported_size = (lenU30(init_method->index) + traits->size());
size 464 eval/eval-abc.cpp exceptions.size() +
size 465 eval/eval-abc.cpp (traits ? traits->size() : lenU30(0)));
size 539 eval/eval-abc.cpp reported_size += exceptions->hd->size();
size 48 eval/eval-abc.h virtual uint32_t size() = 0;
size 91 eval/eval-abc.h uint32_t size();
size 145 eval/eval-abc.h virtual uint32_t size();
size 158 eval/eval-abc.h virtual uint32_t size();
size 174 eval/eval-abc.h virtual uint32_t size();
size 193 eval/eval-abc.h virtual uint32_t size();
size 207 eval/eval-abc.h virtual uint32_t size();
size 221 eval/eval-abc.h virtual uint32_t size();
size 238 eval/eval-abc.h virtual uint32_t size();
size 274 eval/eval-abc.h virtual uint32_t size();
size 280 eval/eval-abc.h virtual uint32_t size();
size 286 eval/eval-abc.h virtual uint32_t size();
size 57 eval/eval-cogen-inlines.h inline uint32_t Cogen::getCodeLength() const { return code.size(); }
size 107 eval/eval-cogen.cpp return b + code.size();
size 233 eval/eval-cogen.cpp label->backpatches = ALLOC(Seq<uint32_t>, (code.size() - 3, label->backpatches));
size 239 eval/eval-cogen.cpp label->address = code.size();
size 151 eval/eval-compile.cpp abc.serialize(context->obtainStorageForResult(abc.size()));
size 424 eval/eval-util.cpp size_rest = size();
size 176 eval/eval-util.h uint32_t size() const;
size 237 extensions/JavaGlue.cpp jarray jobj = clazz->createArray(this, size, arr);
size 448 extensions/JavaGlue.cpp arr = jni->NewBooleanArray(size);
size 452 extensions/JavaGlue.cpp arr = jni->NewByteArray(size);
size 456 extensions/JavaGlue.cpp arr = jni->NewCharArray(size);
size 460 extensions/JavaGlue.cpp arr = jni->NewShortArray(size);
size 464 extensions/JavaGlue.cpp arr = jni->NewIntArray(size);
size 468 extensions/JavaGlue.cpp arr = jni->NewLongArray(size);
size 472 extensions/JavaGlue.cpp arr = jni->NewFloatArray(size);
size 476 extensions/JavaGlue.cpp arr = jni->NewDoubleArray(size);
size 482 extensions/JavaGlue.cpp arr = jni->NewObjectArray(size, cref, 0);
size 82 extensions/JavaGlue.h JObject* createArray(JObject* arrayType, int size, ArrayObject* arr);
size 142 extensions/JavaGlue.h jarray createArray(JObjectClass* jobj, int size, ArrayObject* arr);
size 424 extensions/SamplerScript.cpp dsam->set_size(static_cast<double>(sample.size));
size 493 extensions/SamplerScript.cpp return (double)o->size();
size 750 extensions/SamplerScript.cpp : SampleObject(vtable, delegate), size(0)
size 769 extensions/SamplerScript.cpp double s = (double)size;
size 770 extensions/SamplerScript.cpp if( !size ) {
size 117 extensions/SamplerScript.h void setSize(uint64 s) { size = s; }
size 120 extensions/SamplerScript.h uint64 size;
size 99 nanojit/Allocator.h return a.alloc(size);
size 104 nanojit/Allocator.h return a->alloc(size);
size 108 nanojit/Allocator.h inline void* operator new[](size_t size, nanojit::Allocator& a) {
size 109 nanojit/Allocator.h return a.alloc(size);
size 113 nanojit/Allocator.h inline void* operator new[](size_t size, nanojit::Allocator* a) {
size 114 nanojit/Allocator.h return a->alloc(size);
size 254 nanojit/Assembler.cpp for (int n = i + (ins->size()>>2); j < n; j++) {
size 811 nanojit/Assembler.cpp PERFM_NVPROF("code", CodeAlloc::size(codeList));
size 1621 nanojit/Assembler.cpp int32_t count = ins->size()>>2;
size 1645 nanojit/Assembler.cpp for (int i=0; i < size; i++) {
size 1654 nanojit/Assembler.cpp int32_t size = l->isop(LIR_alloc) ? (l->size()>>2) : l->isQuad() ? 2 : 1;
size 1661 nanojit/Assembler.cpp if (size == 1) {
size 1671 nanojit/Assembler.cpp else if (size == 2) {
size 1686 nanojit/Assembler.cpp if (start < size) start = size;
size 1689 nanojit/Assembler.cpp if (canfit(size, i, ar)) {
size 1691 nanojit/Assembler.cpp for (int32_t j=0; j < size; j++) {
size 1702 nanojit/Assembler.cpp if (tos+size >= NJ_MAX_STACK_ENTRY) {
size 106 nanojit/CodeAlloc.cpp if (b->size() < minAllocSize)
size 144 nanojit/CodeAlloc.cpp avmplus::AvmLog("free %p-%p %d\n", start, end, (int)blk->size());
size 155 nanojit/CodeAlloc.cpp already_on_avail_list = lower->size() >= minAllocSize;
size 169 nanojit/CodeAlloc.cpp if ( coalescedBlock->size() >= minAllocSize ) {
size 177 nanojit/CodeAlloc.cpp NanoAssert(free_block->size() >= minAllocSize);
size 195 nanojit/CodeAlloc.cpp if ( !already_on_avail_list && blk->size() >= minAllocSize )
size 253 nanojit/CodeAlloc.cpp flushICache(b->start(), b->size());
size 438 nanojit/CodeAlloc.cpp size_t size = 0;
size 440 nanojit/CodeAlloc.cpp size += int((uintptr_t)b->end - (uintptr_t)b);
size 441 nanojit/CodeAlloc.cpp return size;
size 493 nanojit/CodeAlloc.cpp NanoAssert(avail->isFree && avail->size() >= minAllocSize);
size 499 nanojit/CodeAlloc.cpp if (hb->isFree && hb->size() >= minAllocSize) {
size 84 nanojit/CodeAlloc.h size_t size() const { return uintptr_t(end) - uintptr_t(&code[0]); }
size 184 nanojit/CodeAlloc.h static size_t size(const CodeList* code);
size 187 nanojit/CodeAlloc.h size_t size();
size 294 nanojit/LIR.cpp LIns** table = new (_buf->_allocator) LIns*[size];
size 296 nanojit/LIR.cpp VMPI_memset(table, 0, size * sizeof(LIns*));
size 297 nanojit/LIR.cpp ins->initLInsJtbl(index, size, table);
size 303 nanojit/LIR.cpp size = (size+3)>>2; // # of required 32bit words
size 306 nanojit/LIR.cpp ins->initLInsI(LIR_alloc, size);
size 1759 nanojit/LIR.cpp VMPI_sprintf(s, "%s = %s %d", formatRef(i), lirNames[op], i->size());
size 2307 nanojit/LIR.cpp Entry *e = new (allocator) Entry(copy, size << align, align);
size 2318 nanojit/LIR.cpp const void *end = (const char*)start + e->size;
size 300 nanojit/LIR.h inline void initLInsJtbl(LIns* index, uint32_t size, LIns** table);
size 371 nanojit/LIR.h inline int32_t size() const;
size 726 nanojit/LIR.h uint32_t size; // number of entries in table
size 830 nanojit/LIR.h void LIns::initLInsJtbl(LIns* index, uint32_t size, LIns** table) {
size 835 nanojit/LIR.h toLInsJtbl()->size = size;
size 865 nanojit/LIR.h NanoAssert(index < toLInsJtbl()->size);
size 872 nanojit/LIR.h NanoAssert(index < toLInsJtbl()->size);
size 915 nanojit/LIR.h int32_t LIns::size() const {
size 953 nanojit/LIR.h return toLInsJtbl()->size;
size 1015 nanojit/LIR.h virtual LInsp insAlloc(int32_t size) {
size 1016 nanojit/LIR.h NanoAssert(size != 0);
size 1017 nanojit/LIR.h return out->insAlloc(size);
size 1019 nanojit/LIR.h virtual LInsp insJtbl(LIns* index, uint32_t size) {
size 1020 nanojit/LIR.h return out->insJtbl(index, size);
size 1058 nanojit/LIR.h Entry(int) : name(0), size(0), align(0) {}
size 1059 nanojit/LIR.h Entry(char *n, size_t s, size_t a) : name(n),size(s),align(a) {}
size 1061 nanojit/LIR.h size_t size:29, align:3;
size 1069 nanojit/LIR.h void add(const void *p, size_t size, size_t align, const char *name);
size 1167 nanojit/LIR.h LIns* insJtbl(LIns* index, uint32_t size) {
size 1168 nanojit/LIR.h return add_flush(out->insJtbl(index, size));
size 1199 nanojit/LIR.h LIns* insAlloc(int32_t size) {
size 1200 nanojit/LIR.h return add(out->insAlloc(size));
size 1390 nanojit/LIR.h LInsp insAlloc(int32_t size);
size 1391 nanojit/LIR.h LInsp insJtbl(LIns* index, uint32_t size);
size 963 other-licenses/zlib/deflate.c if (len > size) len = size;
size 43 other-licenses/zlib/gzio.c #define ALLOC(size) malloc(size)
size 795 other-licenses/zlib/gzio.c uInt size = Z_BUFSIZE;
size 796 other-licenses/zlib/gzio.c if (offset < Z_BUFSIZE) size = (uInt)offset;
size 798 other-licenses/zlib/gzio.c size = gzwrite(file, s->inbuf, size);
size 799 other-licenses/zlib/gzio.c if (size == 0) return -1L;
size 801 other-licenses/zlib/gzio.c offset -= size;
size 844 other-licenses/zlib/gzio.c int size = Z_BUFSIZE;
size 845 other-licenses/zlib/gzio.c if (offset < Z_BUFSIZE) size = (int)offset;
size 847 other-licenses/zlib/gzio.c size = gzread(file, s->outbuf, (uInt)size);
size 848 other-licenses/zlib/gzio.c if (size <= 0) return -1L;
size 849 other-licenses/zlib/gzio.c offset -= size;
size 271 other-licenses/zlib/inflate.c unsigned low, size;
size 284 other-licenses/zlib/inflate.c size = 1U << 9;
size 285 other-licenses/zlib/inflate.c printf(" static const code lenfix[%u] = {", size);
size 291 other-licenses/zlib/inflate.c if (++low == size) break;
size 295 other-licenses/zlib/inflate.c size = 1U << 5;
size 296 other-licenses/zlib/inflate.c printf("\n static const code distfix[%u] = {", size);
size 302 other-licenses/zlib/inflate.c if (++low == size) break;
size 219 other-licenses/zlib/zutil.c ulg bsize = (ulg)items*size;
size 278 other-licenses/zlib/zutil.c return _halloc((long)items, size);
size 305 other-licenses/zlib/zutil.c if (opaque) items += size - size; /* make compiler happy */
size 306 other-licenses/zlib/zutil.c return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
size 307 other-licenses/zlib/zutil.c (voidpf)calloc(items, size);
size 265 other-licenses/zlib/zutil.h (*((strm)->zalloc))((strm)->opaque, (items), (size))
size 6122 pcre/pcre_compile.cpp size_t size;
size 6317 pcre/pcre_compile.cpp size = length + sizeof(real_pcre) + cd->names_found * (cd->name_entry_size + 3);
size 6318 pcre/pcre_compile.cpp re = (real_pcre *)(pcre_malloc)(size);
size 6332 pcre/pcre_compile.cpp re->size = (pcre_uint32)size;
size 96 pcre/pcre_fullinfo.cpp *((size_t *)where) = re->size;
size 100 pcre/pcre_fullinfo.cpp *((size_t *)where) = (study == NULL)? 0 : study->size;
size 243 pcre/pcre_get.cpp if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
size 285 pcre/pcre_get.cpp return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
size 316 pcre/pcre_get.cpp int size = sizeof(char *);
size 322 pcre/pcre_get.cpp size += sizeof(char *) + ovector[i+1] - ovector[i] + 1;
size 324 pcre/pcre_get.cpp stringlist = (char **)(pcre_malloc)(size);
size 59 pcre/pcre_globals.cpp return mmfx_new_array(char, size);
size 889 pcre/pcre_internal.h pcre_uint32 size; /* Total that was malloced */
size 910 pcre/pcre_internal.h pcre_uint32 size; /* Total that was malloced */
size 178 pcre/pcre_scanner.cc it->data() + it->size() <= data_.c_str() + end)) {
size 86 pcre/pcre_scanner_unittest.cc CHECK_EQ(comments.size(), 1);
size 94 pcre/pcre_scanner_unittest.cc CHECK_EQ(comments.size(), 1);
size 102 pcre/pcre_scanner_unittest.cc CHECK_EQ(comments.size(), 1);
size 107 pcre/pcre_scanner_unittest.cc CHECK_EQ(comments.size(), 3);
size 114 pcre/pcre_scanner_unittest.cc CHECK_EQ(comments.size(), 0);
size 119 pcre/pcre_scanner_unittest.cc CHECK_EQ(comments.size(), 3);
size 127 pcre/pcre_scanner_unittest.cc CHECK_EQ(comments.size(), 1);
size 46 pcre/pcre_stringpiece_unittest.cc CHECK(map.size() == 3);
size 64 pcre/pcre_stringpiece_unittest.cc CHECK(map.size() == 2);
size 575 pcre/pcre_study.cpp study->size = sizeof(pcre_study_data);
size 109 pcre/pcre_try_flipped.cpp internal_re->size = byteflip(re->size, sizeof(re->size));
size 129 pcre/pcre_try_flipped.cpp internal_study->size = byteflip(study->size, sizeof(study->size));
size 433 pcre/pcrecpp.cc for (int ii = 0; ii < unquoted.size(); ++ii) {
size 477 pcre/pcrecpp.cc text.size(),
size 558 pcre/pcrecpp.cc for (const char *s = rewrite.data(), *end = s + rewrite.size();
size 851 pcre/pcrecpp_unittest.cc CHECK_EQ(sp.size(), 4);
size 550 pcre/pcretest.cpp void *block = malloc(size);
size 551 pcre/pcretest.cpp gotten_store = size;
size 553 pcre/pcretest.cpp fprintf(outfile, "malloc %3d %p\n", (int)size, block);
size 569 pcre/pcretest.cpp void *block = malloc(size);
size 571 pcre/pcretest.cpp fprintf(outfile, "stack_malloc %3d %p\n", (int)size, block);
size 981 pcre/pcretest.cpp size_t size, regex_gotten_store;
size 1313 pcre/pcretest.cpp true_size = ((real_pcre *)re)->size;
size 1338 pcre/pcretest.cpp true_study_size = ((pcre_study_data *)(extra->study_data))->size;
size 1350 pcre/pcretest.cpp rre->size = byteflip(rre->size, sizeof(rre->size));
size 1365 pcre/pcretest.cpp rsd->size = byteflip(rsd->size, sizeof(rsd->size));
size 1392 pcre/pcretest.cpp new_info(re, NULL, PCRE_INFO_SIZE, &size);
size 1424 pcre/pcretest.cpp if (size != regex_gotten_store) fprintf(outfile,
size 1426 pcre/pcretest.cpp (int)size, (int)regex_gotten_store);
size 205 platform/win32/Vtune.cpp int size = tbl->size();
size 207 platform/win32/Vtune.cpp if (size)
size 209 platform/win32/Vtune.cpp int bsz = size*sizeof(LineNumberInfo);
size 216 platform/win32/Vtune.cpp for(int i=0; i<size; i++)
size 113 platform/win32/coff.cpp int size = VMPI_strlen(s); // the string size
size 114 platform/win32/coff.cpp int allocSize = sizeof(int) + size + 1; // string length + its content + null terminator
size 129 platform/win32/coff.cpp c = write(c, (char*)&size, sizeof(int));
size 130 platform/win32/coff.cpp write(c, s, size+1);
size 175 platform/win32/coff.cpp int* size = (int*)(symbols[i]+1); // the string is stored pascal style (i.e length leads content)
size 176 platform/win32/coff.cpp pos += *size;
size 208 platform/win32/coff.cpp int* size = (int*)(symbols[i]+1); // pascal style string after the entry
size 209 platform/win32/coff.cpp realPos += fwrite(size+1, 1, *size+1, f);
size 653 shell/ByteArrayGlue.cpp int64_t len = fp->size();
size 274 shell/DebugCLI.cpp int size = src->functionCount();
size 275 shell/DebugCLI.cpp for(int i=0; i<size; i++)
size 123 shell/File.h virtual int64_t size() const = 0;
size 90 shell/FileClass.cpp int64_t fileSize = fp->size();
size 49 shell/FileInputStream.cpp len = file->size();
size 57 shell/PosixFile.h virtual int64_t size() const;
size 57 shell/WinFile.h virtual int64_t size() const;
size 66 utils/abcasm/src/abcasm/AbcEmitter.java int pos = w.size();
size 67 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(core.intPool.size());
size 71 utils/abcasm/src/abcasm/AbcEmitter.java pos = w.size();
size 73 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(core.uintPool.size());
size 77 utils/abcasm/src/abcasm/AbcEmitter.java pos = w.size();
size 79 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(core.doublePool.size());
size 83 utils/abcasm/src/abcasm/AbcEmitter.java pos = w.size();
size 85 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(core.stringPool.size());
size 92 utils/abcasm/src/abcasm/AbcEmitter.java pos = w.size();
size 94 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(core.nsPool.size());
size 97 utils/abcasm/src/abcasm/AbcEmitter.java pos = w.size();
size 99 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(core.nssetPool.size());
size 106 utils/abcasm/src/abcasm/AbcEmitter.java pos = w.size();
size 108 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(core.namePool.size());
size 147 utils/abcasm/src/abcasm/AbcEmitter.java pos = w.size();
size 149 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(core.methodSignatures.size());
size 198 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(core.scripts.size());
size 204 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(core.methodBodies.size());
size 257 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(info.paramTypes.size());
size 260 utils/abcasm/src/abcasm/AbcEmitter.java for (int i=0, n=info.paramTypes.size(); i < n; i++)
size 315 utils/abcasm/src/abcasm/AbcEmitter.java code_len += blockWriter.size();
size 319 utils/abcasm/src/abcasm/AbcEmitter.java if ( b.insns.size() == 0)
size 354 utils/abcasm/src/abcasm/AbcEmitter.java int code_start = w.size();
size 384 utils/abcasm/src/abcasm/AbcEmitter.java int from = w.size()+3;
size 390 utils/abcasm/src/abcasm/AbcEmitter.java for ( int i = 0; i < b.insns.size() && b.insns.elementAt(i).target == null; i++)
size 530 utils/abcasm/src/abcasm/AbcEmitter.java w.writeU30(exceptions.size());
size 301 utils/abcasm/src/abcasm/AssemblerCore.java if ( scripts.size() == 1 )
size 336 utils/abcasm/src/abcasm/AssemblerCore.java if ( scripts.size() == 1 )
size 396 utils/abcasm/src/abcasm/AssemblerCore.java for ( int i = staticScopes.size() -1; i >= 0 && null == result; i-- )
size 434 utils/abcasm/src/abcasm/AssemblerCore.java staticScopes.remove(staticScopes.size()-1);
size 85 utils/abcasm/src/abcasm/Main.java if ( core.syntaxErrors.size() > 0 )
size 103 utils/abcasm/src/abcasm/Main.java if ( core.semanticErrors.size() > 0 )
size 564 utils/abcasm/src/abcasm/MethodBodyInfo.java else if ( max_slot < traits.size() )
size 565 utils/abcasm/src/abcasm/MethodBodyInfo.java return traits.size();
size 600 utils/abcasm/src/abcasm/MethodBodyInfo.java if ( opcodeNameToOpcode.size() == 0)
size 58 utils/abcasm/src/abcasm/MethodInfo.java return paramTypes.size() + 1;
size 113 utils/abcasm/src/abcasm/Name.java assert(this.qualifiers.namespaces.size() == 1);
size 59 utils/abcasm/src/abcasm/Nsset.java return namespaces.size();
size 65 utils/abcasm/src/abcasm/Nsset.java int result = this.namespaces.size() - other.namespaces.size();
size 67 utils/abcasm/src/abcasm/Nsset.java for ( int i = 0; i < this.namespaces.size() && 0 == result; i++ )
size 83 utils/abcasm/src/abcasm/Nsset.java for ( int i = 0; i < namespaces.size(); i++ )
size 69 utils/abcasm/src/abcasm/Pool.java refs.put(e, size());
size 94 utils/abcasm/src/abcasm/Pool.java return countFrom + refs.size();
size 56 utils/abcasm/src/abcasm/Traits.java return size();