struct AndroidConfig {   using SizeClassMap = AndroidSizeClassMap; #if SCUDO_CAN_USE_PRIMARY64   // 256MB regions   typedef SizeClassAllocator64<SizeClassMap, 28U, 1000, 1000,                                /*MaySupportMemoryTagging=*/true>       Primary; #else   // 256KB regions   typedef SizeClassAllocator32<SizeClassMap, 18U, 1000, 1000> Primary; #endif   // Cache blocks up to 2MB   typedef MapAllocator<MapAllocatorCache<32U, 2UL << 20, 0, 1000>> Secondary;   template <class A>   using TSDRegistryT = TSDRegistrySharedT<A, 2U>; // Shared, max 2 TSDs. };

 struct UnpackedHeader {     uptr ClassId : 8;     u8 State : 2;     u8 Origin : 2;     uptr SizeOrUnusedBytes : 20;     uptr Offset : 16;     uptr Checksum : 16;   }; 

struct AndroidSizeClassConfig {   static const uptr NumBits = 7;   static const uptr MinSizeLog = 4;   static const uptr MidSizeLog = 6;   static const uptr MaxSizeLog = 16;   static const u32 MaxNumCachedHint = 14;   static const uptr MaxBytesCachedLog = 13;   static constexpr u32 Classes[] = {       0x00020, 0x00030, 0x00040, 0x00050, 0x00060, 0x00070, 0x00090, 0x000b0,       0x000c0, 0x000e0, 0x00120, 0x00160, 0x001c0, 0x00250, 0x00320, 0x00450,       0x00670, 0x00830, 0x00a10, 0x00c30, 0x01010, 0x01210, 0x01bd0, 0x02210,       0x02d90, 0x03790, 0x04010, 0x04810, 0x05a10, 0x07310, 0x08210, 0x10010,   };   static const uptr SizeDelta = 16; }; 

NOINLINE void *allocate(uptr Size, Chunk::Origin Origin,                           uptr Alignment = MinAlignment,                           bool ZeroContents = false) {     initThreadMaybe();  // 初始化TSD Array 和 Primary SizeClass地址空间     // skip trivials.......     // If the requested size happens to be 0 (more common than you might think),     // allocate MinAlignment bytes on top of the header. Then add the extra     // bytes required to fulfill the alignment requirements: we allocate enough     // to be sure that there will be an address in the block that will satisfy     // the alignment.     const uptr NeededSize =         roundUpTo(Size, MinAlignment) +         ((Alignment > MinAlignment) ? Alignment : Chunk::getHeaderSize());     // skip trivials.......          void *Block = nullptr;     uptr ClassId = 0;     uptr SecondaryBlockEnd;     if (LIKELY(PrimaryT::canAllocate(NeededSize))) {       // 从 Primary Allocator分配small object       ClassId = SizeClassMap::getClassIdBySize(NeededSize);       DCHECK_NE(ClassId, 0U);       bool UnlockRequired;       auto *TSD = TSDRegistry.getTSDAndLock(&UnlockRequired);       Block = TSD->Cache.allocate(ClassId);       // If the allocation failed, the most likely reason with a 32-bit primary       // is the region being full. In that event, retry in each successively       // larger class until it fits. If it fails to fit in the largest class,       // fallback to the Secondary.       if (UNLIKELY(!Block)) {         while (ClassId < SizeClassMap::LargestClassId) {           Block = TSD->Cache.allocate(++ClassId);           if (LIKELY(Block)) {             break;           }         }         if (UNLIKELY(!Block)) {           ClassId = 0;         }       }       if (UnlockRequired)         TSD->unlock();     }     // 如果分配的是大内存，或者Primary 无法分配小内存，     // 则直接在Secondary Allocator进行分配     if (UNLIKELY(ClassId == 0))       Block = Secondary.allocate(NeededSize, Alignment, &SecondaryBlockEnd,                                  ZeroContents);       // skip trivials.......     const uptr BlockUptr = reinterpret_cast<uptr>(Block);     const uptr UnalignedUserPtr = BlockUptr + Chunk::getHeaderSize();     const uptr UserPtr = roundUpTo(UnalignedUserPtr, Alignment);     void *Ptr = reinterpret_cast<void *>(UserPtr);     void *TaggedPtr = Ptr;          // skip trivials.......     // 根据返回内存地址，设置chunk-header对象数据     Chunk::UnpackedHeader Header = {};     if (UNLIKELY(UnalignedUserPtr != UserPtr)) {       const uptr Offset = UserPtr - UnalignedUserPtr;       DCHECK_GE(Offset, 2 * sizeof(u32));       // The BlockMarker has no security purpose, but is specifically meant for       // the chunk iteration function that can be used in debugging situations.       // It is the only situation where we have to locate the start of a chunk       // based on its block address.       reinterpret_cast<u32 *>(Block)[0] = BlockMarker;       reinterpret_cast<u32 *>(Block)[1] = static_cast<u32>(Offset);       Header.Offset = (Offset >> MinAlignmentLog) & Chunk::OffsetMask;     }     Header.ClassId = ClassId & Chunk::ClassIdMask;     Header.State = Chunk::State::Allocated;     Header.Origin = Origin & Chunk::OriginMask;     Header.SizeOrUnusedBytes =         (ClassId ? Size : SecondaryBlockEnd - (UserPtr + Size)) &         Chunk::SizeOrUnusedBytesMask;     // 设置chunk-header，CheckSum用于完整性校验     Chunk::storeHeader(Cookie, Ptr, &Header);     // skip trivials.......     return TaggedPtr;   }