Index: llvm/include/llvm/IR/DerivedTypes.h =================================================================== --- llvm/include/llvm/IR/DerivedTypes.h +++ llvm/include/llvm/IR/DerivedTypes.h @@ -644,8 +644,6 @@ explicit PointerType(Type *ElType, unsigned AddrSpace); explicit PointerType(LLVMContext &C, unsigned AddrSpace); - Type *PointeeTy; - public: PointerType(const PointerType &) = delete; PointerType &operator=(const PointerType &) = delete; @@ -674,14 +672,14 @@ /// given address space. This is only useful during the opaque pointer /// transition. /// TODO: remove after opaque pointer transition is complete. + [[deprecated("Use PointerType::get() with LLVMContext argument instead")]] static PointerType *getWithSamePointeeType(PointerType *PT, unsigned AddressSpace) { - if (PT->isOpaque()) - return get(PT->getContext(), AddressSpace); - return get(PT->PointeeTy, AddressSpace); + return get(PT->getContext(), AddressSpace); } - bool isOpaque() const { return !PointeeTy; } + [[deprecated("Always returns true")]] + bool isOpaque() const { return true; } /// Return true if the specified type is valid as a element type. static bool isValidElementType(Type *ElemTy); @@ -696,16 +694,18 @@ /// type matches Ty. Primarily used for checking if an instruction's pointer /// operands are valid types. Will be useless after non-opaque pointers are /// removed. - bool isOpaqueOrPointeeTypeMatches(Type *Ty) { - return isOpaque() || PointeeTy == Ty; + [[deprecated("Always returns true")]] + bool isOpaqueOrPointeeTypeMatches(Type *) { + return true; } /// Return true if both pointer types have the same element type. Two opaque /// pointers are considered to have the same element type, while an opaque /// and a non-opaque pointer have different element types. /// TODO: Remove after opaque pointer transition is complete. + [[deprecated("Always returns true")]] bool hasSameElementTypeAs(PointerType *Other) { - return PointeeTy == Other->PointeeTy; + return true; } /// Implement support type inquiry through isa, cast, and dyn_cast. Index: llvm/include/llvm/IR/LLVMContext.h =================================================================== --- llvm/include/llvm/IR/LLVMContext.h +++ llvm/include/llvm/IR/LLVMContext.h @@ -316,9 +316,11 @@ /// times, but only with the same value. Note that creating a pointer type or /// otherwise querying the opaque pointer mode performs an implicit set to /// the default value. + [[deprecated("Opaque pointers are always enabled")]] void setOpaquePointers(bool Enable) const; /// Whether typed pointers are supported. If false, all pointers are opaque. + [[deprecated("Always returns false")]] bool supportsTypedPointers() const; private: Index: llvm/include/llvm/IR/Type.h =================================================================== --- llvm/include/llvm/IR/Type.h +++ llvm/include/llvm/IR/Type.h @@ -256,7 +256,8 @@ bool isPointerTy() const { return getTypeID() == PointerTyID; } /// True if this is an instance of an opaque PointerType. - bool isOpaquePointerTy() const; + LLVM_DEPRECATED("Use isPointerTy() instead", "isPointerTy") + bool isOpaquePointerTy() const { return isPointerTy(); }; /// Return true if this is a pointer type or a vector of pointer types. bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); } @@ -408,23 +409,12 @@ inline StringRef getTargetExtName() const; - /// This method is deprecated without replacement. Pointer element types are - /// not available with opaque pointers. - [[deprecated("Deprecated without replacement, see " - "https://llvm.org/docs/OpaquePointers.html for context and " - "migration instructions")]] - Type *getPointerElementType() const { - return getNonOpaquePointerElementType(); - } - /// Only use this method in code that is not reachable with opaque pointers, /// or part of deprecated methods that will be removed as part of the opaque /// pointers transition. + [[deprecated("Pointers no longer have element types")]] Type *getNonOpaquePointerElementType() const { - assert(getTypeID() == PointerTyID); - assert(NumContainedTys && - "Attempting to get element type of opaque pointer"); - return ContainedTys[0]; + llvm_unreachable("Pointers no longer have element types"); } /// Given vector type, change the element type, Index: llvm/lib/IR/Type.cpp =================================================================== --- llvm/lib/IR/Type.cpp +++ llvm/lib/IR/Type.cpp @@ -57,12 +57,6 @@ return isIntegerTy() && cast(this)->getBitWidth() == Bitwidth; } -bool Type::isOpaquePointerTy() const { - if (auto *PTy = dyn_cast(this)) - return PTy->isOpaque(); - return false; -} - bool Type::isScalableTy() const { if (const auto *STy = dyn_cast(this)) { SmallPtrSet Visited; @@ -814,15 +808,8 @@ return Entry; } -PointerType::PointerType(Type *E, unsigned AddrSpace) - : Type(E->getContext(), PointerTyID), PointeeTy(E) { - ContainedTys = &PointeeTy; - NumContainedTys = 1; - setSubclassData(AddrSpace); -} - PointerType::PointerType(LLVMContext &C, unsigned AddrSpace) - : Type(C, PointerTyID), PointeeTy(nullptr) { + : Type(C, PointerTyID) { setSubclassData(AddrSpace); } Index: llvm/unittests/AsmParser/AsmParserTest.cpp =================================================================== --- llvm/unittests/AsmParser/AsmParserTest.cpp +++ llvm/unittests/AsmParser/AsmParserTest.cpp @@ -252,9 +252,6 @@ ASSERT_TRUE(Ty); ASSERT_TRUE(Ty->isPointerTy()); - PointerType *PT = cast(Ty); - ASSERT_TRUE(PT->isOpaque()); - // Check that we reject types with garbage. Ty = parseType("i32 garbage", Error, M, &Mapping); ASSERT_TRUE(!Ty); @@ -370,9 +367,6 @@ ASSERT_TRUE(Ty->isPointerTy()); ASSERT_TRUE(Read == 3); - PointerType *PT = cast(Ty); - ASSERT_TRUE(PT->isOpaque()); - // Check that we reject types with garbage. Ty = parseTypeAtBeginning("i32 garbage", Read, Error, M, &Mapping); ASSERT_TRUE(Ty);