Author: Timm Baeder Date: 2025-08-20T09:23:19+02:00 New Revision: a9de444aa12c02c81f65e4e4e5262897b80c5a58
URL: https://github.com/llvm/llvm-project/commit/a9de444aa12c02c81f65e4e4e5262897b80c5a58 DIFF: https://github.com/llvm/llvm-project/commit/a9de444aa12c02c81f65e4e4e5262897b80c5a58.diff LOG: [clang][bytecode][NFC] Use an anonymous union in Pointer (#154405) So we can save ourselves writing PointeeStorage all the time. Added: Modified: clang/lib/AST/ByteCode/DynamicAllocator.cpp clang/lib/AST/ByteCode/InterpBlock.cpp clang/lib/AST/ByteCode/Pointer.cpp clang/lib/AST/ByteCode/Pointer.h clang/lib/AST/ByteCode/Program.cpp Removed: ################################################################################ diff --git a/clang/lib/AST/ByteCode/DynamicAllocator.cpp b/clang/lib/AST/ByteCode/DynamicAllocator.cpp index 3874e4db27007..4fedac667b389 100644 --- a/clang/lib/AST/ByteCode/DynamicAllocator.cpp +++ b/clang/lib/AST/ByteCode/DynamicAllocator.cpp @@ -31,7 +31,7 @@ void DynamicAllocator::cleanup() { if (B->hasPointers()) { while (B->Pointers) { Pointer *Next = B->Pointers->asBlockPointer().Next; - B->Pointers->PointeeStorage.BS.Pointee = nullptr; + B->Pointers->BS.Pointee = nullptr; B->Pointers = Next; } B->Pointers = nullptr; diff --git a/clang/lib/AST/ByteCode/InterpBlock.cpp b/clang/lib/AST/ByteCode/InterpBlock.cpp index fdaf112114f37..ac6f01f3cdca1 100644 --- a/clang/lib/AST/ByteCode/InterpBlock.cpp +++ b/clang/lib/AST/ByteCode/InterpBlock.cpp @@ -23,9 +23,9 @@ void Block::addPointer(Pointer *P) { assert(!hasPointer(P)); #endif if (Pointers) - Pointers->PointeeStorage.BS.Prev = P; - P->PointeeStorage.BS.Next = Pointers; - P->PointeeStorage.BS.Prev = nullptr; + Pointers->BS.Prev = P; + P->BS.Next = Pointers; + P->BS.Prev = nullptr; Pointers = P; #ifndef NDEBUG assert(hasPointer(P)); @@ -40,16 +40,16 @@ void Block::removePointer(Pointer *P) { assert(hasPointer(P)); #endif - BlockPointer &BP = P->PointeeStorage.BS; + BlockPointer &BP = P->BS; if (Pointers == P) Pointers = BP.Next; if (BP.Prev) - BP.Prev->PointeeStorage.BS.Next = BP.Next; + BP.Prev->BS.Next = BP.Next; if (BP.Next) - BP.Next->PointeeStorage.BS.Prev = BP.Prev; - P->PointeeStorage.BS.Pointee = nullptr; + BP.Next->BS.Prev = BP.Prev; + P->BS.Pointee = nullptr; #ifndef NDEBUG assert(!hasPointer(P)); #endif @@ -70,13 +70,13 @@ void Block::replacePointer(Pointer *Old, Pointer *New) { assert(hasPointer(Old)); #endif - BlockPointer &OldBP = Old->PointeeStorage.BS; - BlockPointer &NewBP = New->PointeeStorage.BS; + BlockPointer &OldBP = Old->BS; + BlockPointer &NewBP = New->BS; if (OldBP.Prev) - OldBP.Prev->PointeeStorage.BS.Next = New; + OldBP.Prev->BS.Next = New; if (OldBP.Next) - OldBP.Next->PointeeStorage.BS.Prev = New; + OldBP.Next->BS.Prev = New; NewBP.Prev = OldBP.Prev; NewBP.Next = OldBP.Next; if (Pointers == Old) @@ -116,7 +116,7 @@ DeadBlock::DeadBlock(DeadBlock *&Root, Block *Blk) // Transfer pointers. B.Pointers = Blk->Pointers; for (Pointer *P = Blk->Pointers; P; P = P->asBlockPointer().Next) - P->PointeeStorage.BS.Pointee = &B; + P->BS.Pointee = &B; Blk->Pointers = nullptr; } diff --git a/clang/lib/AST/ByteCode/Pointer.cpp b/clang/lib/AST/ByteCode/Pointer.cpp index 89d9829399302..821de3b98bd53 100644 --- a/clang/lib/AST/ByteCode/Pointer.cpp +++ b/clang/lib/AST/ByteCode/Pointer.cpp @@ -30,39 +30,62 @@ Pointer::Pointer(Block *Pointee) Pointer::Pointer(Block *Pointee, uint64_t BaseAndOffset) : Pointer(Pointee, BaseAndOffset, BaseAndOffset) {} -Pointer::Pointer(const Pointer &P) - : Offset(P.Offset), StorageKind(P.StorageKind), - PointeeStorage(P.PointeeStorage) { - - if (isBlockPointer() && PointeeStorage.BS.Pointee) - PointeeStorage.BS.Pointee->addPointer(this); -} - Pointer::Pointer(Block *Pointee, unsigned Base, uint64_t Offset) : Offset(Offset), StorageKind(Storage::Block) { assert((Base == RootPtrMark || Base % alignof(void *) == 0) && "wrong base"); - PointeeStorage.BS = {Pointee, Base, nullptr, nullptr}; + BS = {Pointee, Base, nullptr, nullptr}; if (Pointee) Pointee->addPointer(this); } -Pointer::Pointer(Pointer &&P) - : Offset(P.Offset), StorageKind(P.StorageKind), - PointeeStorage(P.PointeeStorage) { +Pointer::Pointer(const Pointer &P) + : Offset(P.Offset), StorageKind(P.StorageKind) { + switch (StorageKind) { + case Storage::Int: + Int = P.Int; + break; + case Storage::Block: + BS = P.BS; + if (BS.Pointee) + BS.Pointee->addPointer(this); + break; + case Storage::Fn: + Fn = P.Fn; + break; + case Storage::Typeid: + Typeid = P.Typeid; + break; + } +} - if (StorageKind == Storage::Block && PointeeStorage.BS.Pointee) - PointeeStorage.BS.Pointee->replacePointer(&P, this); +Pointer::Pointer(Pointer &&P) : Offset(P.Offset), StorageKind(P.StorageKind) { + switch (StorageKind) { + case Storage::Int: + Int = P.Int; + break; + case Storage::Block: + BS = P.BS; + if (BS.Pointee) + BS.Pointee->replacePointer(&P, this); + break; + case Storage::Fn: + Fn = P.Fn; + break; + case Storage::Typeid: + Typeid = P.Typeid; + break; + } } Pointer::~Pointer() { if (!isBlockPointer()) return; - if (Block *Pointee = PointeeStorage.BS.Pointee) { + if (Block *Pointee = BS.Pointee) { Pointee->removePointer(this); - PointeeStorage.BS.Pointee = nullptr; + BS.Pointee = nullptr; Pointee->cleanup(); } } @@ -73,13 +96,13 @@ Pointer &Pointer::operator=(const Pointer &P) { if (isBlockPointer()) { if (P.isBlockPointer() && this->block() == P.block()) { Offset = P.Offset; - PointeeStorage.BS.Base = P.PointeeStorage.BS.Base; + BS.Base = P.BS.Base; return *this; } - if (Block *Pointee = PointeeStorage.BS.Pointee) { + if (Block *Pointee = BS.Pointee) { Pointee->removePointer(this); - PointeeStorage.BS.Pointee = nullptr; + BS.Pointee = nullptr; Pointee->cleanup(); } } @@ -88,16 +111,16 @@ Pointer &Pointer::operator=(const Pointer &P) { Offset = P.Offset; if (P.isBlockPointer()) { - PointeeStorage.BS = P.PointeeStorage.BS; + BS = P.BS; - if (PointeeStorage.BS.Pointee) - PointeeStorage.BS.Pointee->addPointer(this); + if (BS.Pointee) + BS.Pointee->addPointer(this); } else if (P.isIntegralPointer()) { - PointeeStorage.Int = P.PointeeStorage.Int; + Int = P.Int; } else if (P.isFunctionPointer()) { - PointeeStorage.Fn = P.PointeeStorage.Fn; + Fn = P.Fn; } else if (P.isTypeidPointer()) { - PointeeStorage.Typeid = P.PointeeStorage.Typeid; + Typeid = P.Typeid; } else { assert(false && "Unhandled storage kind"); } @@ -110,13 +133,13 @@ Pointer &Pointer::operator=(Pointer &&P) { if (isBlockPointer()) { if (P.isBlockPointer() && this->block() == P.block()) { Offset = P.Offset; - PointeeStorage.BS.Base = P.PointeeStorage.BS.Base; + BS.Base = P.BS.Base; return *this; } - if (Block *Pointee = PointeeStorage.BS.Pointee) { + if (Block *Pointee = BS.Pointee) { Pointee->removePointer(this); - PointeeStorage.BS.Pointee = nullptr; + BS.Pointee = nullptr; Pointee->cleanup(); } } @@ -125,16 +148,16 @@ Pointer &Pointer::operator=(Pointer &&P) { Offset = P.Offset; if (P.isBlockPointer()) { - PointeeStorage.BS = P.PointeeStorage.BS; + BS = P.BS; - if (PointeeStorage.BS.Pointee) - PointeeStorage.BS.Pointee->addPointer(this); + if (BS.Pointee) + BS.Pointee->addPointer(this); } else if (P.isIntegralPointer()) { - PointeeStorage.Int = P.PointeeStorage.Int; + Int = P.Int; } else if (P.isFunctionPointer()) { - PointeeStorage.Fn = P.PointeeStorage.Fn; + Fn = P.Fn; } else if (P.isTypeidPointer()) { - PointeeStorage.Typeid = P.PointeeStorage.Typeid; + Typeid = P.Typeid; } else { assert(false && "Unhandled storage kind"); } @@ -163,12 +186,11 @@ APValue Pointer::toAPValue(const ASTContext &ASTCtx) const { } if (isTypeidPointer()) { - TypeInfoLValue TypeInfo(PointeeStorage.Typeid.TypePtr); - return APValue( - APValue::LValueBase::getTypeInfo( - TypeInfo, QualType(PointeeStorage.Typeid.TypeInfoType, 0)), - CharUnits::Zero(), {}, - /*OnePastTheEnd=*/false, /*IsNull=*/false); + TypeInfoLValue TypeInfo(Typeid.TypePtr); + return APValue(APValue::LValueBase::getTypeInfo( + TypeInfo, QualType(Typeid.TypeInfoType, 0)), + CharUnits::Zero(), {}, + /*OnePastTheEnd=*/false, /*IsNull=*/false); } // Build the lvalue base from the block. @@ -300,13 +322,13 @@ APValue Pointer::toAPValue(const ASTContext &ASTCtx) const { void Pointer::print(llvm::raw_ostream &OS) const { switch (StorageKind) { case Storage::Block: { - const Block *B = PointeeStorage.BS.Pointee; + const Block *B = BS.Pointee; OS << "(Block) " << B << " {"; if (isRoot()) - OS << "rootptr(" << PointeeStorage.BS.Base << "), "; + OS << "rootptr(" << BS.Base << "), "; else - OS << PointeeStorage.BS.Base << ", "; + OS << BS.Base << ", "; if (isElementPastEnd()) OS << "pastend, "; @@ -321,8 +343,7 @@ void Pointer::print(llvm::raw_ostream &OS) const { } break; case Storage::Int: OS << "(Int) {"; - OS << PointeeStorage.Int.Value << " + " << Offset << ", " - << PointeeStorage.Int.Desc; + OS << Int.Value << " + " << Offset << ", " << Int.Desc; OS << "}"; break; case Storage::Fn: @@ -412,18 +433,17 @@ bool Pointer::isInitialized() const { if (!isBlockPointer()) return true; - if (isRoot() && PointeeStorage.BS.Base == sizeof(GlobalInlineDescriptor)) { + if (isRoot() && BS.Base == sizeof(GlobalInlineDescriptor)) { const GlobalInlineDescriptor &GD = *reinterpret_cast<const GlobalInlineDescriptor *>(block()->rawData()); return GD.InitState == GlobalInitState::Initialized; } - assert(PointeeStorage.BS.Pointee && - "Cannot check if null pointer was initialized"); + assert(BS.Pointee && "Cannot check if null pointer was initialized"); const Descriptor *Desc = getFieldDesc(); assert(Desc); if (Desc->isPrimitiveArray()) { - if (isStatic() && PointeeStorage.BS.Base == 0) + if (isStatic() && BS.Base == 0) return true; InitMapPtr &IM = getInitMap(); @@ -448,9 +468,9 @@ void Pointer::initialize() const { if (!isBlockPointer()) return; - assert(PointeeStorage.BS.Pointee && "Cannot initialize null pointer"); + assert(BS.Pointee && "Cannot initialize null pointer"); - if (isRoot() && PointeeStorage.BS.Base == sizeof(GlobalInlineDescriptor)) { + if (isRoot() && BS.Base == sizeof(GlobalInlineDescriptor)) { GlobalInlineDescriptor &GD = *reinterpret_cast<GlobalInlineDescriptor *>( asBlockPointer().Pointee->rawData()); GD.InitState = GlobalInitState::Initialized; @@ -461,7 +481,7 @@ void Pointer::initialize() const { assert(Desc); if (Desc->isPrimitiveArray()) { // Primitive global arrays don't have an initmap. - if (isStatic() && PointeeStorage.BS.Base == 0) + if (isStatic() && BS.Base == 0) return; // Nothing to do for these. @@ -487,8 +507,7 @@ void Pointer::initialize() const { } // Field has its bit in an inline descriptor. - assert(PointeeStorage.BS.Base != 0 && - "Only composite fields can be initialised"); + assert(BS.Base != 0 && "Only composite fields can be initialised"); getInlineDesc()->IsInitialized = true; } @@ -507,10 +526,9 @@ void Pointer::initializeAllElements() const { void Pointer::activate() const { // Field has its bit in an inline descriptor. - assert(PointeeStorage.BS.Base != 0 && - "Only composite fields can be activated"); + assert(BS.Base != 0 && "Only composite fields can be activated"); - if (isRoot() && PointeeStorage.BS.Base == sizeof(GlobalInlineDescriptor)) + if (isRoot() && BS.Base == sizeof(GlobalInlineDescriptor)) return; if (!getInlineDesc()->InUnion) return; @@ -592,8 +610,7 @@ bool Pointer::pointToSameBlock(const Pointer &A, const Pointer &B) { } bool Pointer::hasSameArray(const Pointer &A, const Pointer &B) { - return hasSameBase(A, B) && - A.PointeeStorage.BS.Base == B.PointeeStorage.BS.Base && + return hasSameBase(A, B) && A.BS.Base == B.BS.Base && A.getFieldDesc()->IsArray; } diff --git a/clang/lib/AST/ByteCode/Pointer.h b/clang/lib/AST/ByteCode/Pointer.h index 27659d7eeaf09..96a11b68d1475 100644 --- a/clang/lib/AST/ByteCode/Pointer.h +++ b/clang/lib/AST/ByteCode/Pointer.h @@ -28,8 +28,6 @@ class Block; class DeadBlock; class Pointer; class Context; -template <unsigned A, bool B> class Integral; -enum PrimType : uint8_t; class Pointer; inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Pointer &P); @@ -95,31 +93,23 @@ class Pointer { static constexpr unsigned RootPtrMark = ~0u; public: - Pointer() { - StorageKind = Storage::Int; - PointeeStorage.Int.Value = 0; - PointeeStorage.Int.Desc = nullptr; - } - Pointer(IntPointer &&IntPtr) : StorageKind(Storage::Int) { - PointeeStorage.Int = std::move(IntPtr); - } + Pointer() : StorageKind(Storage::Int), Int{nullptr, 0} {} + Pointer(IntPointer &&IntPtr) + : StorageKind(Storage::Int), Int(std::move(IntPtr)) {} Pointer(Block *B); Pointer(Block *B, uint64_t BaseAndOffset); Pointer(const Pointer &P); Pointer(Pointer &&P); Pointer(uint64_t Address, const Descriptor *Desc, uint64_t Offset = 0) - : Offset(Offset), StorageKind(Storage::Int) { - PointeeStorage.Int.Value = Address; - PointeeStorage.Int.Desc = Desc; - } + : Offset(Offset), StorageKind(Storage::Int), Int{Desc, Address} {} Pointer(const Function *F, uint64_t Offset = 0) - : Offset(Offset), StorageKind(Storage::Fn) { - PointeeStorage.Fn = FunctionPointer(F); + : Offset(Offset), StorageKind(Storage::Fn), Fn(F) { + Fn = FunctionPointer(F); } Pointer(const Type *TypePtr, const Type *TypeInfoType, uint64_t Offset = 0) : Offset(Offset), StorageKind(Storage::Typeid) { - PointeeStorage.Typeid.TypePtr = TypePtr; - PointeeStorage.Typeid.TypeInfoType = TypeInfoType; + Typeid.TypePtr = TypePtr; + Typeid.TypeInfoType = TypeInfoType; } Pointer(Block *Pointee, unsigned Base, uint64_t Offset); ~Pointer(); @@ -350,7 +340,7 @@ class Pointer { /// Returns the type of the innermost field. QualType getType() const { if (isTypeidPointer()) - return QualType(PointeeStorage.Typeid.TypeInfoType, 0); + return QualType(Typeid.TypeInfoType, 0); if (inPrimitiveArray() && Offset != asBlockPointer().Base) { // Unfortunately, complex and vector types are not array types in clang, @@ -468,19 +458,19 @@ class Pointer { [[nodiscard]] const BlockPointer &asBlockPointer() const { assert(isBlockPointer()); - return PointeeStorage.BS; + return BS; } [[nodiscard]] const IntPointer &asIntPointer() const { assert(isIntegralPointer()); - return PointeeStorage.Int; + return Int; } [[nodiscard]] const FunctionPointer &asFunctionPointer() const { assert(isFunctionPointer()); - return PointeeStorage.Fn; + return Fn; } [[nodiscard]] const TypeidPointer &asTypeidPointer() const { assert(isTypeidPointer()); - return PointeeStorage.Typeid; + return Typeid; } bool isBlockPointer() const { return StorageKind == Storage::Block; } @@ -665,7 +655,7 @@ class Pointer { if (isIntegralPointer()) return false; - return !isZero() && Offset > PointeeStorage.BS.Pointee->getSize(); + return !isZero() && Offset > BS.Pointee->getSize(); } /// Checks if the pointer is an out-of-bounds element pointer. @@ -842,7 +832,7 @@ class Pointer { BlockPointer BS; FunctionPointer Fn; TypeidPointer Typeid; - } PointeeStorage; + }; }; inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Pointer &P) { diff --git a/clang/lib/AST/ByteCode/Program.cpp b/clang/lib/AST/ByteCode/Program.cpp index 755e5de4c02e2..5d72044af969e 100644 --- a/clang/lib/AST/ByteCode/Program.cpp +++ b/clang/lib/AST/ByteCode/Program.cpp @@ -227,10 +227,9 @@ std::optional<unsigned> Program::createGlobal(const ValueDecl *VD, Globals[PIdx] = NewGlobal; // All pointers pointing to the previous extern decl now point to the // new decl. - for (Pointer *Ptr = RedeclBlock->Pointers; Ptr; - Ptr = Ptr->PointeeStorage.BS.Next) { + for (Pointer *Ptr = RedeclBlock->Pointers; Ptr; Ptr = Ptr->BS.Next) { RedeclBlock->removePointer(Ptr); - Ptr->PointeeStorage.BS.Pointee = NewGlobal->block(); + Ptr->BS.Pointee = NewGlobal->block(); NewGlobal->block()->addPointer(Ptr); } } _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
