Lines Matching defs:Chunk

69     // Chunk recycling function, returns a quarantined chunk to the backend,
72       Chunk::UnpackedHeader Header;
73       Chunk::loadHeader(Allocator.Cookie, Ptr, &Header);
74       if (UNLIKELY(Header.State != Chunk::State::Quarantined))
77       Header.State = Chunk::State::Available;
78       Chunk::storeHeader(Allocator.Cookie, Ptr, &Header);
91           sizeof(QuarantineBatch) + Chunk::getHeaderSize());
98                                      Chunk::getHeaderSize());
99       Chunk::UnpackedHeader Header = {};
100       Header.ClassId = QuarantineClassId & Chunk::ClassIdMask;
102       Header.State = Chunk::State::Allocated;
103       Chunk::storeHeader(Allocator.Cookie, Ptr, &Header);
117           sizeof(QuarantineBatch) + Chunk::getHeaderSize());
118       Chunk::UnpackedHeader Header;
119       Chunk::loadHeader(Allocator.Cookie, Ptr, &Header);
121       if (UNLIKELY(Header.State != Chunk::State::Allocated))
127       Header.State = Chunk::State::Available;
128       Chunk::storeHeader(Allocator.Cookie, Ptr, &Header);
131                                                 Chunk::getHeaderSize()));
334   NOINLINE void *allocate(uptr Size, Chunk::Origin Origin,
372         ((Alignment > MinAlignment) ? Alignment : Chunk::getHeaderSize());
414         reinterpret_cast<uptr>(Block) + Chunk::getHeaderSize(), Alignment);
427   NOINLINE void deallocate(void *Ptr, Chunk::Origin Origin, uptr DeleteSize = 0,
457     Chunk::UnpackedHeader Header;
458     Chunk::loadHeader(Cookie, Ptr, &Header);
460     if (UNLIKELY(Header.State != Chunk::State::Allocated))
467         if (Header.OriginOrWasZeroed != Chunk::Origin::Memalign ||
468             Origin != Chunk::Origin::Malloc)
500       void *NewPtr = allocate(NewSize, Chunk::Origin::Malloc, Alignment);
518     Chunk::UnpackedHeader Header;
519     Chunk::loadHeader(Cookie, OldPtr, &Header);
521     if (UNLIKELY(Header.State != Chunk::State::Allocated))
528       if (UNLIKELY(Header.OriginOrWasZeroed != Chunk::Origin::Malloc))
531                                   Chunk::Origin::Malloc);
569             Chunk::SizeOrUnusedBytesMask;
570         Chunk::storeHeader(Cookie, OldPtr, &Header);
589     void *NewPtr = allocate(NewSize, Chunk::Origin::Malloc, Alignment);
681       uptr Chunk;
682       Chunk::UnpackedHeader Header;
688         if (!getChunkFromBlock(Block, &Chunk, &Header) &&
689             !getChunkFromBlock(addHeaderTag(Block), &Chunk, &Header))
692         if (!getChunkFromBlock(addHeaderTag(Block), &Chunk, &Header))
695       if (Header.State == Chunk::State::Allocated) {
696         uptr TaggedChunk = Chunk;
700           TaggedChunk = loadTag(Chunk);
701         Callback(TaggedChunk, getSize(reinterpret_cast<void *>(Chunk), &Header),
765     Chunk::UnpackedHeader Header;
766     Chunk::loadHeader(Cookie, Ptr, &Header);
769     if (UNLIKELY(Header.State != Chunk::State::Allocated))
792     Chunk::UnpackedHeader Header;
793     return Chunk::isValid(Cookie, Ptr, &Header) &&
794            Header.State == Chunk::State::Allocated;
943   static_assert(MinAlignment >= sizeof(Chunk::PackedHeader),
1021     Chunk::UnpackedHeader Header = {};
1025         (MaxPrimaryAlignment - Chunk::getHeaderSize()) >> MinAlignmentLog;
1026     Header.Offset = MaxOffset & Chunk::OffsetMask;
1047                                     Chunk::UnpackedHeader *Header) {
1049         reinterpret_cast<uptr>(Ptr) - Chunk::getHeaderSize() -
1054   inline uptr getSize(const void *Ptr, Chunk::UnpackedHeader *Header) {
1064   ALWAYS_INLINE void *initChunk(const uptr ClassId, const Chunk::Origin Origin,
1070         reinterpret_cast<uptr>(Block) + Chunk::getHeaderSize();
1082     Chunk::UnpackedHeader Header = {};
1093       Header.Offset = (Offset >> MinAlignmentLog) & Chunk::OffsetMask;
1096     Header.ClassId = ClassId & Chunk::ClassIdMask;
1097     Header.State = Chunk::State::Allocated;
1098     Header.OriginOrWasZeroed = Origin & Chunk::OriginMask;
1099     Header.SizeOrUnusedBytes = SizeOrUnusedBytes & Chunk::SizeOrUnusedBytesMask;
1100     Chunk::storeHeader(Cookie, reinterpret_cast<void *>(addHeaderTag(UserPtr)),
1107   initChunkWithMemoryTagging(const uptr ClassId, const Chunk::Origin Origin,
1116         reinterpret_cast<uptr>(Block) + Chunk::getHeaderSize();
1136       Chunk::UnpackedHeader Header;
1214     Chunk::UnpackedHeader Header = {};
1225       Header.Offset = (Offset >> MinAlignmentLog) & Chunk::OffsetMask;
1228     Header.ClassId = ClassId & Chunk::ClassIdMask;
1229     Header.State = Chunk::State::Allocated;
1230     Header.OriginOrWasZeroed = Origin & Chunk::OriginMask;
1231     Header.SizeOrUnusedBytes = SizeOrUnusedBytes & Chunk::SizeOrUnusedBytesMask;
1232     Chunk::storeHeader(Cookie, Ptr, &Header);
1238                                    Chunk::UnpackedHeader *Header,
1248       Header->State = Chunk::State::Available;
1250       Header->State = Chunk::State::Quarantined;
1265     Chunk::storeHeader(Cookie, Ptr, Header);
1292                             Chunk::UnpackedHeader *Header, const uptr Size,
1319   bool getChunkFromBlock(uptr Block, uptr *Chunk,
1320                          Chunk::UnpackedHeader *Header) {
1321     *Chunk =
1323     return Chunk::isValid(Cookie, reinterpret_cast<void *>(*Chunk), Header);
1330     return Offset + Chunk::getHeaderSize();
1487                          Chunk::UnpackedHeader *Header, const u32 **Data,
1499       *Header = *reinterpret_cast<const Chunk::UnpackedHeader *>(
1500           ChunkBegin - Chunk::getHeaderSize());
1519       Chunk::UnpackedHeader Header;
1523           Header.State != Chunk::State::Allocated || Tag != FaultAddrTag)