[IR] Deprecate opaque pointer compatibility APIs

[nikic]

Summary

This deprecates various compatibility APIs that have been introduced as part of the opaque pointer migration.

These will be removed at some point after the LLVM 17 release.

[nikic]

Also deprecate getNonOpaquePointerElementType() and remove getPointerElementType(), which has already been deprecated for a long time.

[aeubanks]

I'd split up the API removals and deprecations into separate patches, but otherwise lgtm

llvm/include/llvm/IR/DerivedTypes.h

inline ElementCount VectorType::getElementCount() const {
   return ElementCount::get(ElementQuantity, isa<ScalableVectorType>(this));
 }
 
 /// Class to represent pointers.
 class PointerType : public Type {
   explicit PointerType(Type *ElType, unsigned AddrSpace);
   explicit PointerType(LLVMContext &C, unsigned AddrSpace);
 
-  Type *PointeeTy;
-
 public:
   PointerType(const PointerType &) = delete;
   PointerType &operator=(const PointerType &) = delete;
 
   /// This constructs a pointer to an object of the specified type in a numbered
   /// address space.
   static PointerType *get(Type *ElementType, unsigned AddressSpace);
   /// This constructs an opaque pointer to an object in a numbered address
static PointerType *getUnqual(LLVMContext &C) {
     return PointerType::get(C, 0);
   }
 
   /// This constructs a pointer type with the same pointee type as input
   /// PointerType (or opaque pointer if the input PointerType is opaque) and the
   /// 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);
   }
 
-  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);
 
   /// Return true if we can load or store from a pointer to this type.
   static bool isLoadableOrStorableType(Type *ElemTy);
 
   /// Return the address space of the Pointer type.
   inline unsigned getAddressSpace() const { return getSubclassData(); }
 
   /// Return true if either this is an opaque pointer type or if this pointee
   /// 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.
   static bool classof(const Type *T) {
     return T->getTypeID() == PointerTyID;
   }
 };
 

llvm/include/llvm/IR/LLVMContext.h

#undef LLVM_FIXED_MD_KIND
   /// The lifetime of the object must be guaranteed to extend as long as the
   /// LLVMContext is used by compilation.
   void setOptPassGate(OptPassGate&);
 
   /// Set whether opaque pointers are enabled. The method may be called multiple
   /// 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:
   // Module needs access to the add/removeModule methods.
   friend class Module;
 
   /// addModule - Register a module as being instantiated in this context.  If
   /// the context is deleted, the module will be deleted as well.

llvm/include/llvm/IR/Type.h

public:
 
   /// True if this is an instance of ArrayType.
   bool isArrayTy() const { return getTypeID() == ArrayTyID; }
 
   /// True if this is an instance of PointerType.
   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(); }
 
   /// True if this is an instance of VectorType.
   inline bool isVectorTy() const {
     return getTypeID() == ScalableVectorTyID || getTypeID() == FixedVectorTyID;
   }
Type *getArrayElementType() const {
     return ContainedTys[0];
   }
 
   inline StringRef getTargetExtName() const;
 
   /// 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,
   /// whilst keeping the old number of elements.
   /// For non-vectors simply returns \p EltTy.
   inline Type *getWithNewType(Type *EltTy) const;
 
   /// Given an integer or vector type, change the lane bitwidth to NewBitwidth,

llvm/lib/IR/Type.cpp

default:
     return nullptr;
   }
 }
 
 bool Type::isIntegerTy(unsigned Bitwidth) const {
   return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
 }
 
-bool Type::isOpaquePointerTy() const {
-  if (auto *PTy = dyn_cast<PointerType>(this))
-    return PTy->isOpaque();
-  return false;
-}
-
 bool Type::isScalableTy() const {
   if (const auto *STy = dyn_cast<StructType>(this)) {
     SmallPtrSet<Type *, 4> Visited;
     return STy->containsScalableVectorType(&Visited);
   }
   return getTypeID() == ScalableVectorTyID || isScalableTargetExtTy();
 }
 
PointerType *PointerType::get(LLVMContext &C, unsigned AddressSpace) {
   PointerType *&Entry = AddressSpace == 0 ? CImpl->AS0PointerType
                                           : CImpl->PointerTypes[AddressSpace];
 
   if (!Entry)
     Entry = new (CImpl->Alloc) PointerType(C, AddressSpace);
   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);
 }
 
 PointerType *Type::getPointerTo(unsigned AddrSpace) const {
   return PointerType::get(const_cast<Type*>(this), AddrSpace);
 }
 
 bool PointerType::isValidElementType(Type *ElemTy) {

llvm/unittests/AsmParser/AsmParserTest.cpp

TEST(AsmParserTest, TypeWithSlotMappingParsing) {
   ST = cast<StructType>(Ty);
   ASSERT_TRUE(ST->isOpaque());
 
   // Check we properly parse pointer types.
   Ty = parseType("ptr", Error, M, &Mapping);
   ASSERT_TRUE(Ty);
   ASSERT_TRUE(Ty->isPointerTy());
 
-  PointerType *PT = cast<PointerType>(Ty);
-  ASSERT_TRUE(PT->isOpaque());
-
   // Check that we reject types with garbage.
   Ty = parseType("i32 garbage", Error, M, &Mapping);
   ASSERT_TRUE(!Ty);
 }
 
 TEST(AsmParserTest, TypeAtBeginningWithSlotMappingParsing) {
   LLVMContext Ctx;
   SMDiagnostic Error;
TEST(AsmParserTest, TypeAtBeginningWithSlotMappingParsing) {
 
   // Check we properly parse pointer types.
   // One indirection.
   Ty = parseTypeAtBeginning("ptr", Read, Error, M, &Mapping);
   ASSERT_TRUE(Ty);
   ASSERT_TRUE(Ty->isPointerTy());
   ASSERT_TRUE(Read == 3);
 
-  PointerType *PT = cast<PointerType>(Ty);
-  ASSERT_TRUE(PT->isOpaque());
-
   // Check that we reject types with garbage.
   Ty = parseTypeAtBeginning("i32 garbage", Read, Error, M, &Mapping);
   ASSERT_TRUE(Ty);
   ASSERT_TRUE(Ty->isIntegerTy());
   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
   // We go to the next token, i.e., we read "i32" + ' '.
   ASSERT_TRUE(Read == 4);
 }