[llvm-branch-commits] [compiler-rt] [compiler-rt] Add Device AddressSanitizer runtime (PR #242445)
Joseph Huber via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Nov 20 13:55:48 PST 2026
================
@@ -0,0 +1,792 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Device address sanitizer allocator.
+///
+//===----------------------------------------------------------------------===//
+
+#include "dasan_allocator.h"
+
+#include "dasan_flags.h"
+#include "dasan_report.h"
+#include "sanitizer_common/sanitizer_common.h"
+
+using namespace __sanitizer;
+
+namespace __dasan {
+
+static const uptr kUserMapSize = 1 << 21;
+
+static_assert(kMaxRedzone <= kOffsetMax, "a redzone can outgrow its entry");
+
+uptr Allocator::UserMapChunks(uptr ClassId) const {
+ uptr Bytes = Granule > kUserMapSize ? Granule : kUserMapSize;
+ return Bytes / ClassIdToSize(ClassId);
+}
+
+uptr Allocator::AlignOf(uptr ClassId, uptr Alignment) const {
+ const uptr Chunk = ClassIdToSize(ClassId);
+ if (!Alignment || Alignment < Chunk)
+ Alignment = Chunk;
+ if (!IsPowerOfTwo(Alignment))
+ Alignment = RoundUpToPowerOfTwo(Alignment);
+ if (Alignment < Chunk)
+ Alignment = Chunk;
+ return Alignment;
+}
+
+void Allocator::SkipToFreshGranule(uptr ClassId, hsa_amd_memory_pool_t Pool) {
+ Region& R = Regions[ClassId];
+ const uptr Stride = MetaGranule / kMetadataSize;
+
+ if (R.NextChunk != 0 && R.MetadataPoolSet && R.MetadataPool != Pool) {
+ uptr Boundary = RoundUpTo(R.NextChunk, Stride);
+ // Boundary's granule is already homed on the other device.
+ if (R.MetadataBytes >= MetadataBytesFor(Boundary + 1))
+ Boundary += Stride;
+ R.NextChunk = Boundary;
+ }
+ R.MetadataPool = Pool;
+ R.MetadataPoolSet = true;
+ // The skipped index is a hole: nothing hands it out.
+ if (R.NextChunk <= R.Chunks.size())
+ return;
+
+ const uptr Mark = R.Chunks.size();
+ R.Chunks.resize(R.NextChunk);
+ for (uptr I = Mark; I < R.NextChunk; ++I) R.Chunks[I].Gap = true;
+}
+
+void Allocator::MarkGap(uptr ClassId, uptr Begin, uptr End) {
+ if (Begin >= End)
+ return;
+
+ Region& R = Regions[ClassId];
+ if (R.Chunks.size() < End)
+ R.Chunks.resize(End);
+ for (uptr I = Begin; I < End; ++I) R.Chunks[I].Gap = true;
+
+ if (R.NextChunk < End)
+ R.NextChunk = End;
+}
+
+uptr Allocator::FreeListFor(uptr ClassId, hsa_amd_memory_pool_t Pool) {
+ Region& R = Regions[ClassId];
+ for (uptr I = 0; I < R.FreeLists.size(); ++I)
+ if (R.FreeLists[I].Pool == Pool)
+ return I;
+ uptr I = R.FreeLists.size();
+ R.FreeLists.resize(I + 1);
+ R.FreeLists[I].Pool = Pool;
+ R.FreeLists[I].Head = 0;
+ R.FreeLists[I].QuarantinedBytes = 0;
+ return I;
+}
+
+void Allocator::PushFree(uptr ClassId, uptr List, Run R) {
+ if (!R.Count)
+ return;
+ auto& Free = Regions[ClassId].FreeLists[List].Free;
+ for (uptr I = 0; I < Free.size();) {
+ Run& F = Free[I];
+ const bool Abut =
+ F.Begin + F.Count == R.Begin || R.Begin + R.Count == F.Begin;
+ if (!Abut || F.UserMapped != R.UserMapped) {
+ ++I;
+ continue;
+ }
+ if (F.Begin < R.Begin)
+ R.Begin = F.Begin;
+ R.Count += F.Count;
+ F = Free.back();
+ Free.pop_back();
+ I = 0;
+ }
+ Free.push_back(R);
+}
+
+bool Allocator::TakeFree(uptr ClassId, uptr List, uptr Need, uptr Stride,
+ bool MapUser, uptr* Begin) {
+ auto& Free = Regions[ClassId].FreeLists[List].Free;
+ for (uptr N = Free.size(); N-- > 0;) {
+ const Run R = Free[N];
+ if (!MapUser && R.UserMapped)
+ continue;
+ const uptr Aligned = RoundUpTo(R.Begin, Stride);
+ if (Aligned < R.Begin || Aligned - R.Begin > R.Count)
+ continue;
+ if (Need > R.Count - (Aligned - R.Begin))
+ continue;
+ Free[N] = Free.back();
+ Free.pop_back();
+ if (Aligned > R.Begin)
+ PushFree(ClassId, List, {R.Begin, Aligned - R.Begin, R.UserMapped});
+ const uptr End = R.Begin + R.Count;
+ if (Aligned + Need < End)
+ PushFree(ClassId, List,
+ {Aligned + Need, End - (Aligned + Need), R.UserMapped});
+ *Begin = Aligned;
+ return true;
+ }
+ return false;
+}
+
+bool Allocator::CommitMap(uptr Addr, uptr Bytes, u64 Handle,
+ hsa_amd_memory_pool_t Home) {
+ if (!VaMap(Addr, Bytes, Handle, Home)) {
+ VaDestroy(Handle);
+ return false;
+ }
+ Maps.push_back({Addr, Bytes});
+ VmemHandles.push_back(Handle);
+ return true;
+}
+
+void Allocator::RollbackMap() {
+ const Mapping M = Maps.back();
+ Maps.pop_back();
+ VaUnmap(M.Addr, M.Size);
+ VaDestroy(VmemHandles.back());
+ VmemHandles.pop_back();
+}
+
+bool Allocator::CreateMetadata(hsa_amd_memory_pool_t Prefer, uptr Bytes,
+ u64* Handle, hsa_amd_memory_pool_t* Home) {
+ if (HasPool(Prefer) && VaCreate(Prefer, Bytes, 0, Handle)) {
+ *Home = Prefer;
+ return true;
+ }
+ InternalMmapVector<hsa_amd_memory_pool_t> Pools;
+ PlaceablePools(&Pools);
+ for (hsa_amd_memory_pool_t Other : Pools) {
+ if (!HasPool(Other) || Other == Prefer)
+ continue;
+ if (VaCreate(Other, Bytes, 0, Handle)) {
+ *Home = Other;
+ return true;
+ }
+ }
+
+ if (VaCreate({}, Bytes, 0, Handle)) {
+ *Home = {};
+ return true;
+ }
+ return false;
+}
+
+bool Allocator::EnsureMetadata(hsa_amd_memory_pool_t Pool, uptr ClassId,
+ uptr Chunks) {
+ Region& R = Regions[ClassId];
+ // Cover these chunks only. SkipToFreshGranule keeps another device's
+ // indices out of a granule this one already maps.
+ uptr Want = MetadataBytesFor(Chunks);
+ const uptr Max = MetadataBytesFor(ReachableChunks(ClassId));
+ if (Want > Max)
+ Want = Max;
+ if (R.MetadataBytes >= Want) {
+ return !HasPool(Pool) || VaAllow(MetadataBegin(ClassId, R.MetadataBytes),
+ R.MetadataBytes, Pool);
+ }
+
+ const uptr Beg = MetadataBegin(ClassId, Want);
+ const uptr Bytes = Want - R.MetadataBytes;
+ u64 H = 0;
+ hsa_amd_memory_pool_t Home = Pool;
+ if (!CreateMetadata(Pool, Bytes, &H, &Home))
+ return false;
+ if (!CommitMap(Beg, Bytes, H, Home))
+ return false;
+ if (HasPool(Pool) && Pool != Home && !VaAllow(Beg, Bytes, Pool)) {
+ RollbackMap();
+ return false;
+ }
+
+ if (!MetadataOk && !VaProbe(Beg)) {
+ Report("ERROR: %s: could not initialize metadata\n", SanitizerToolName);
+ Die();
+ }
+
+ VaPublish(Beg, nullptr, Bytes);
+ MetadataOk = true;
+ R.MetadataBytes = Want;
+ VReport(2, "%s: class %zu holds %zu KiB of entries%s\n", SanitizerToolName,
+ ClassId, Want >> 10,
+ Home != Pool ? " (spilled to another pool)" : "");
+ return true;
+}
+
+bool Allocator::MapUserChunk(hsa_amd_memory_pool_t Pool, uptr ClassId,
+ uptr ChunkIdx, uptr Need, u32 AllocFlags) {
+ ChunkState& S = Regions[ClassId].Chunks[ChunkIdx];
+ const uptr Chunk = ClassIdToSize(ClassId);
+ uptr Want = RoundUpTo(Need, Granule);
+ if (Want > Chunk)
+ Want = Chunk;
+ if (S.Mapped >= Want)
+ return true;
+
+ const uptr Beg = ChunkBegin(ClassId, ChunkIdx) + S.Mapped;
+ const uptr Bytes = Want - S.Mapped;
+ u64 H = 0;
+ if (!VaCreate(Pool, Bytes, AllocFlags, &H))
+ return false;
+ if (!CommitMap(Beg, Bytes, H, Pool))
+ return false;
+ S.Mapped = Want;
+ return true;
+}
+
+bool Allocator::MapPrefix(hsa_amd_memory_pool_t Pool, uptr ClassId, uptr Begin,
+ uptr Count, uptr Bytes, u32 AllocFlags) {
+ const uptr Chunk = ClassIdToSize(ClassId);
+
+ // A small class was mapped as a batch. A short prefix here would be a
+ // granule the device will not take.
+ if (MapOnPopulate(ClassId)) {
+ for (uptr I = 0; I < Count && Bytes; ++I) {
+ const uptr Need = Bytes > Chunk ? Chunk : Bytes;
+ if (Regions[ClassId].Chunks[Begin + I].Mapped < Need)
+ return false;
+ Bytes -= Need;
+ }
+ return true;
+ }
+ for (uptr I = 0; I < Count && Bytes; ++I) {
+ const uptr Need = Bytes > Chunk ? Chunk : Bytes;
+ if (!MapUserChunk(Pool, ClassId, Begin + I, Need, AllocFlags))
+ return false;
+ Bytes -= Need;
+ }
+ return true;
+}
+
+bool Allocator::Grow(hsa_amd_memory_pool_t Pool, uptr ClassId, uptr List,
+ uptr Need, uptr Stride, bool MapUser, u32 AllocFlags,
+ uptr* Begin) {
+ Region& R = Regions[ClassId];
+ SkipToFreshGranule(ClassId, Pool);
+
+ const uptr Max = MaxUsableChunks(ClassId);
+ const uptr Chunk = ClassIdToSize(ClassId);
+ const bool Batch = MapUser && MapOnPopulate(ClassId);
+ if (Batch) {
+ const uptr Per = Granule / Chunk;
+ const uptr MapAt = RoundUpTo(R.NextChunk, Per);
+ // The next granule would land in the metadata.
+ if (MapAt > Max)
+ return false;
+ if (MapAt > R.NextChunk)
+ MarkGap(ClassId, R.NextChunk, MapAt);
+ }
+
+ if (R.NextChunk > Max)
+ return false;
+ const uptr First = RoundUpTo(R.NextChunk, Stride);
+ if (First < R.NextChunk || First >= Max || Need > Max - First)
+ return false;
+
+ uptr BatchCount = Need;
+ uptr MapFrom = First;
+ if (Batch) {
+ const uptr Per = Granule / Chunk;
+ const uptr Span = First + Need - R.NextChunk;
+ BatchCount = UserMapChunks(ClassId);
+ if (BatchCount < Span)
+ BatchCount = RoundUpTo(Span, Per);
+ if (BatchCount > Max - R.NextChunk)
+ BatchCount = (Max - R.NextChunk) / Per * Per;
+ if (!BatchCount || BatchCount < Span)
+ return false;
+ MapFrom = R.NextChunk;
+ }
+
+ const uptr End = MapFrom + BatchCount;
+ if (!EnsureMetadata(Pool, ClassId, End))
+ return false;
+
+ // The caller maps this run. One reservation names it.
+ if (!MapUser) {
+ if (First > R.NextChunk)
+ PushFree(ClassId, List, {R.NextChunk, First - R.NextChunk, false});
+ R.NextChunk = End;
+ *Begin = First;
+ return true;
+ }
+
+ if (Batch) {
+ u64 H = 0;
+ if (!VaCreate(Pool, BatchCount * Chunk, AllocFlags, &H))
+ return false;
+ if (!CommitMap(ChunkBegin(ClassId, MapFrom), BatchCount * Chunk, H, Pool))
+ return false;
+ }
+
+ if (R.Chunks.size() < End)
+ R.Chunks.resize(End);
+ for (uptr I = R.NextChunk; I < End; ++I) {
+ ChunkState& S = R.Chunks[I];
+ S.List = static_cast<u32>(List);
+ // The batch map starts at NextChunk. A large class maps only the
+ // prefix the caller asked for, after Grow returns.
+ if (Batch && I >= MapFrom)
+ S.Mapped = Chunk;
+ }
+
+ // Alignment padding. Mapped when it sits inside the batch, otherwise a
+ // bare reservation a later run can claim.
+ if (First > R.NextChunk)
+ PushFree(ClassId, List, {R.NextChunk, First - R.NextChunk, Batch});
+ if (First + Need < End)
+ PushFree(ClassId, List, {First + Need, End - (First + Need), Batch});
+ R.NextChunk = End;
+ *Begin = First;
+ return true;
+}
+
+// Same function as globalRedzoneSize in the DeviceAddressSanitizer pass.
+static uptr GlobalRedzoneBytes(uptr Size) {
+ const uptr Chunk = ClassIdToSize(0);
+ const uptr Max = 1ull << 18;
+ if (Size <= Chunk / 2)
+ return Chunk - Size;
+ uptr RZ = (Size / Chunk / 4) * Chunk;
+ if (RZ < Chunk)
+ RZ = Chunk;
+ if (RZ > Max)
+ RZ = Max;
+ if (Size % Chunk)
+ RZ += Chunk - (Size % Chunk);
+ return RZ;
+}
+
+static uptr CoveredBytes(uptr Size) {
+ return RoundUpTo(Size + GlobalRedzoneBytes(Size), ClassIdToSize(0));
+}
+
+bool Allocator::Publish(uptr Addr, uptr Size, bool Pad) {
+ return WriteMetadata(Addr, Size, Pad, false);
+}
+
+bool Allocator::WriteMetadata(uptr Addr, uptr Size, bool Pad, bool Poison) {
+ if (!Size || !MetadataOk || Size > kSizeMask || !PointerIsMine(Addr))
+ return false;
+ const uptr ClassId = GetSizeClass(Addr);
+ const uptr Chunk = ClassIdToSize(ClassId);
+ uptr Base = 0;
+ uptr Off = 0;
+ uptr Count = 0;
+
+ // A heap chunk stores its redzone offset. Any other address is the base of
+ // a range the caller published.
+ const uptr Idx = GetChunkIdx(Addr, ClassId);
+ Region& R = Regions[ClassId];
+ if (Idx < R.Chunks.size() && !R.Chunks[Idx].Gap && R.Chunks[Idx].Heap &&
+ R.Chunks[Idx].RunLen) {
+ const ChunkState& S = R.Chunks[Idx];
+ Base = ChunkBegin(ClassId, S.RunStart);
+ Off = S.UserOffset;
+ if (Addr != Base + Off)
+ return false;
+ Count = S.RunLen;
+ } else {
+ if (Addr % Chunk)
+ return false;
+ Base = Addr;
+ const uptr Bytes = Pad ? CoveredBytes(Size) : RoundUpTo(Size, Chunk);
+ Count = Bytes / Chunk;
+ }
+ if (!Count || Base % Chunk || !PointerIsMine(Base) ||
+ GetSizeClass(Base) != ClassId)
+ return false;
+ const sptr Last =
+ static_cast<sptr>(Off) - static_cast<sptr>((Count - 1) * Chunk);
+ if (!OffsetFits(static_cast<sptr>(Off)) || !OffsetFits(Last))
+ return false;
+
+ auto Entry = [&](uptr I) {
+ const sptr Delta = static_cast<sptr>(Off) - static_cast<sptr>(I * Chunk);
+ u64 E = MakeEntry(Poison ? 0 : Size, Delta);
+ return Poison ? PoisonEntry(E) : E;
+ };
+ const uptr First = GetChunkIdx(Base, ClassId);
+ if (Count == 1) {
+ u64 E = Entry(0);
+ VaPublish(GetMetadata(RegionBeg(ClassId), First), &E, sizeof(E));
+ return true;
+ }
+ // The tail grows downward, so the last chunk is the lowest address.
+ InternalMmapVector<u64> Ordered(Count);
+ for (uptr I = 0; I < Count; ++I) Ordered[Count - 1 - I] = Entry(I);
+ VaPublish(GetMetadata(RegionBeg(ClassId), First + Count - 1), Ordered.data(),
+ Count * sizeof(u64));
+ return true;
+}
+
+void Allocator::MarkChunk(uptr ClassId, uptr Begin, uptr List,
+ const Placement& Place) {
+ ChunkState& S = Regions[ClassId].Chunks[Begin];
+ S.List = static_cast<u32>(List);
+ S.Live = true;
+ S.Gap = false;
+ S.Heap = true;
+ S.RunStart = Begin;
+ S.RunLen = 1;
+ S.UserOffset = Place.Offset;
+ S.UserSize = Place.UserSize;
+ S.AllocStack = Place.Stack;
+ S.FreeStack = 0;
+ S.AllocTid = Place.Tid;
+ S.FreeTid = 0;
+}
+
+void Allocator::ClearChunk(uptr ClassId, uptr Begin) {
+ ChunkState& S = Regions[ClassId].Chunks[Begin];
+ S.Live = false;
+ S.Heap = false;
+ S.UserSize = 0;
+ S.UserOffset = 0;
+ S.RunStart = 0;
+ S.RunLen = 0;
+ S.AllocStack = S.FreeStack = 0;
+ S.AllocTid = S.FreeTid = 0;
+}
+
+bool Allocator::Recycle(uptr ClassId, uptr List) {
+ FreeList& F = Regions[ClassId].FreeLists[List];
+ if (F.Head >= F.Quarantine.size())
+ return false;
+ const Run R = F.Quarantine[F.Head++];
+ const uptr Bytes = R.Count * ClassIdToSize(ClassId);
+ F.QuarantinedBytes -= Bytes;
+ QuarantinedBytes -= Bytes;
+ if (F.Head == F.Quarantine.size()) {
+ F.Quarantine.clear();
+ F.Head = 0;
+ }
+ // Leave the chunk's record in place until a new run overwrites it, so a
+ // use-after-free still names the allocation that owned these bytes.
+ PushFree(ClassId, List, R);
+ return true;
+}
+
+bool Allocator::RecycleOne(uptr PreferClass, uptr PreferList) {
+ if (Recycle(PreferClass, PreferList))
+ return true;
+ for (uptr C = 0; C < kNumSizeClasses; ++C) {
+ Region& R = Regions[C];
+ for (uptr L = 0; L < R.FreeLists.size(); ++L) {
+ if (C == PreferClass && L == PreferList)
+ continue;
+ if (Recycle(C, L))
+ return true;
+ }
+ }
+ return false;
+}
+
+void Allocator::Quarantine(uptr ClassId, uptr List, Run R, u32 Stack, u32 Tid) {
+ Region& Reg = Regions[ClassId];
+ const uptr Chunk = ClassIdToSize(ClassId);
+ ChunkState& S = Reg.Chunks[R.Begin];
+ const uptr UserOff = S.UserOffset;
+ const uptr UserSize = S.UserSize;
+ S.Live = false;
+ S.FreeStack = Stack;
+ S.FreeTid = Tid;
+ WriteMetadata(ChunkBegin(ClassId, R.Begin) + UserOff, UserSize, false, true);
+
+ FreeList& F = Reg.FreeLists[List];
+ const uptr Bytes = R.Count * Chunk;
+ F.Quarantine.push_back(R);
+ F.QuarantinedBytes += Bytes;
+ QuarantinedBytes += Bytes;
+ const uptr Budget = (uptr)flags()->quarantine_size_mb << 20;
+ while (QuarantinedBytes > Budget && RecycleOne(ClassId, List)) {
+ }
+}
+
+bool Allocator::Init() {
+ if (Initialized)
+ return Reserved;
+ Initialized = true;
+
+ Granule = VaGranule();
+ MetaGranule = VaMetaGranule();
+ // Both are non-zero powers of two. The device granule covers a host page,
+ // so every smaller class divides it. The metadata granule tiles an entry
+ // and the metadata region.
+ const uptr Page = GetPageSizeCached();
+ if (!Granule || !MetaGranule || !IsPowerOfTwo(Granule) ||
+ !IsPowerOfTwo(MetaGranule) || Granule < Page ||
+ MetaGranule % kMetadataSize || kMetadataBytes % MetaGranule) {
+ VReport(1, "%s: no usable metadata granule; HSA calls pass through\n",
+ SanitizerToolName);
+ return false;
+ }
+
+ if (!VaReserve(kSpaceBeg, kSpaceUsed)) {
+ VReport(1, "%s: could not reserve [0x%zx, 0x%zx); HSA calls pass through\n",
+ SanitizerToolName, (uptr)kSpaceBeg, (uptr)(kSpaceBeg + kSpaceUsed));
+ return false;
+ }
+ Reserved = true;
+ VReport(1, "%s: reserved [0x%zx, 0x%zx)\n", SanitizerToolName,
+ (uptr)kSpaceBeg, (uptr)(kSpaceBeg + kSpaceUsed));
+ return true;
+}
+
+void Allocator::Shutdown() {
+ if (Reserved) {
+ for (uptr I = 0; I < Maps.size(); ++I) VaUnmap(Maps[I].Addr, Maps[I].Size);
+ Maps.clear();
+ for (uptr I = 0; I < VmemHandles.size(); ++I) VaDestroy(VmemHandles[I]);
+ VmemHandles.clear();
+
+ for (uptr C = 0; C < kNumSizeClasses; ++C) {
+ Region& R = Regions[C];
+ for (uptr I = 0; I < R.FreeLists.size(); ++I) {
+ R.FreeLists[I].Free.clear();
+ R.FreeLists[I].Quarantine.clear();
+ }
+ R.FreeLists.clear();
+ R.Chunks.clear();
+ R.Reservations.clear();
+ R.NextChunk = R.MetadataBytes = 0;
+ R.MetadataPoolSet = false;
+ }
+
+ VaRelease(kSpaceBeg, kSpaceUsed);
+ Reserved = false;
+ MetadataOk = false;
+ Granule = MetaGranule = 0;
+ QuarantinedBytes = 0;
+ Count = {};
+ }
+ Initialized = false;
+}
+
+uptr Allocator::Allocate(hsa_amd_memory_pool_t Pool, uptr ClassId, uptr Size,
+ u32 AllocFlags, u32 Stack, u32 Tid, bool MapUser) {
+ if (!Size || ClassId >= kNumSizeClasses)
+ return 0;
+ if (Size > ~uptr{0} - kMinRedzone)
+ return 0;
+
+ // Search for a chunk we can use in the allocator.
+ const uptr Chunk = ClassIdToSize(ClassId);
+ uptr Off = 0;
+ uptr Bytes = Size;
+ uptr RunAlign = Granule;
+ if (MapUser) {
+ if (Size > kSizeMask)
+ return 0;
+ const uptr Align = HeapAlign(Size);
+ // This class holds the object in one chunk, redzone included.
+ if (Chunk < Align)
+ return 0;
+ Off = LeadingRedzone(Size, Chunk, Align);
+ if (Off + Size + kMinRedzone > Chunk)
+ return 0;
+ Bytes = Off + Size;
+ RunAlign = Chunk;
+ }
+
+ const uptr AlignTo = AlignOf(ClassId, RunAlign);
+ const uptr Stride = AlignTo / Chunk;
+ const uptr MaxChunks = MaxUsableChunks(ClassId);
+ if (!MaxChunks || Bytes > MaxChunks * Chunk)
+ return 0;
+
+ const uptr Need = RoundUpTo(Bytes, Chunk) / Chunk;
+ if (!Need)
+ return 0;
+
+ // Find a free chunk in the current free list.
+ const uptr List = FreeListFor(ClassId, Pool);
----------------
jhuber6 wrote:
I suppose this might happen in practice if we unload a shlib with executables? I can add some checks around that, thanks.
https://github.com/llvm/llvm-project/pull/242445
More information about the llvm-branch-commits
mailing list