explicit PointerType(Type *ElType, unsigned AddrSpace);
explicit PointerType(LLVMContext &C, unsigned AddrSpace);
- Type *PointeeTy;
-
public:
PointerType(const PointerType &) = delete;
PointerType &operator=(const PointerType &) = delete;
/// 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);
/// 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.
/// 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:
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(); }
/// 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,
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 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);
}
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);
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);