[IR] Move support for dxil::TypedPointerType to LLVM core IR.

[jcranmer-intel]

Summary

This allows the construct to be shared between different backends. However, it
still remains illegal to use TypedPointerType in LLVM IR--the type is intended
to remain an auxiliary type, not a real LLVM type. So no support is provided for
LLVM-C, nor bitcode, nor LLVM assembly (besides the bare minimum needed to make
Type->dump() work properly).

[jcranmer-intel]

Dropping LLVMContext target-specific data, originally added for this feature.

[nikic]

LG from my side, but I'd like @aeubanks to confirm that he's fine with this as well.

llvm/lib/IR/LLVMContextImpl.h

41

This can be a forward-declare.

llvm/lib/IR/TypedPointerType.cpp

17

Class no longer needed?

[nikic]

llvm/lib/IR/AsmWriter.cpp

615

If it's useful for debugging, you could also include TypedPointerType.h here and print *cast<TypedPointerType>(Ty->getElementType()), instead of printing the address of the type.

[jcranmer-intel]

Update for review coments.

[jcranmer-intel]

Typo fix.

[nikic]

llvm/lib/IR/AsmWriter.cpp

615

I believe this is missing an *, you're currently printing the address of the element type.

[jcranmer-intel]

llvm/lib/IR/AsmWriter.cpp

615

Just noticed it right before you wrote that comment, I'm embarrassed to have not caught it earlier. :-(

[beanz]

llvm/unittests/Target/DirectX/PointerTypeAnalysisTests.cpp

38

This test case can be moved out of the DirectX tests into IR tests, so that it gets run even if you don't compile in the DirectX backend.

[beanz]

llvm/lib/Target/DirectX/DXILWriter/DXILValueEnumerator.cpp

376

This needs to drop the dxil namespace.

397

Here too.

[jcranmer-intel]

Fix DirectX build.

Also took the opportunity to fix the printing of typed pointer slightly.

[aeubanks]

sorry, I haven't really been following https://discourse.llvm.org/t/rfc-better-support-for-typed-pointers-in-an-opaque-pointer-world, I'm reading through it

this change seems fine

but looking at PointerTypeAnalysis::run, if I'm understanding correctly, the pointee type can change based on optimizations. e.g. with a load i32, ptr %p the pointee type is i32, but if that load is eliminated and there are no users of the pointer, its pointee type is i8. and I believe this currently makes it into the generated DXIL. is this an issue? I'd assume so since the idea to use i8* everywhere doesn't seem to be the direction we're going

[beanz]

In D130592#3683662, @aeubanks wrote:

but looking at PointerTypeAnalysis::run, if I'm understanding correctly, the pointee type can change based on optimizations. e.g. with a load i32, ptr %p the pointee type is i32, but if that load is eliminated and there are no users of the pointer, its pointee type is i8. and I believe this currently makes it into the generated DXIL. is this an issue? I'd assume so since the idea to use i8* everywhere doesn't seem to be the direction we're going

DXIL is LLVM 3.7 bitcode, so opaque pointers don’t exist. i8* if we can’t figure out a pointer type is the closest we get to void*.

[beanz]

With the latest updates this LGTM.

[aeubanks]

In D130592#3683896, @beanz wrote:

In D130592#3683662, @aeubanks wrote:

but looking at PointerTypeAnalysis::run, if I'm understanding correctly, the pointee type can change based on optimizations. e.g. with a load i32, ptr %p the pointee type is i32, but if that load is eliminated and there are no users of the pointer, its pointee type is i8. and I believe this currently makes it into the generated DXIL. is this an issue? I'd assume so since the idea to use i8* everywhere doesn't seem to be the direction we're going

DXIL is LLVM 3.7 bitcode, so opaque pointers don’t exist. i8* if we can’t figure out a pointer type is the closest we get to void*.

I mean, is it okay if a pointer parameter can either be inferred and written as i8* or i32* depending on optimizations?

[jcranmer-intel]

In D130592#3685188, @aeubanks wrote:

I mean, is it okay if a pointer parameter can either be inferred and written as i8* or i32* depending on optimizations?

The question of pointer parameters is I think orthogonal to the change here. I can't speak for DXIL in particular, but for SPIR-V, there can sometimes be repercussions. We have some ideas for how to get the types of parameters inferred correctly, with the leading candidate at present being recovering information from Itanium mangled names.

[jcranmer-intel]

Friendly review ping, @aeubanks ?

[beanz]

Just to add context. From the DXIL perspective, we don't really have dynamic linking. We will probably need to do something to preserve parameter types for static linking, but since static linking operates on IR, we can probably manage that without too much trouble.

The ins and outs of pointer type re-materialization is probably a bit out of scope for this review, but the DXIL pass is _way_ far from being production ready. It is really more of a proof-of-concept than anything else. I believe @jcranmer-intel, has a more comprehensive pass in development, and we'll hopefully converge to a single implementation. This change is part of making that possible by moving sharable logic into the IR library.

[aeubanks]

sorry, I'd said that this change looks fine but didn't explicitly accept

llvm/include/llvm/IR/LLVMContext.h

 #include "llvm/IR/DiagnosticHandler.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include <cstdint>
 #include <memory>
 #include <string>
 
 namespace llvm {
 
-class Any;
 class DiagnosticInfo;
 enum DiagnosticSeverity : char;
 class Function;
 class Instruction;
 class LLVMContextImpl;
 class Module;
 class OptPassGate;
 template <typename T> class SmallVectorImpl;
#undef LLVM_FIXED_MD_KIND
   /// 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.
   void setOpaquePointers(bool Enable) const;
 
   /// Whether typed pointers are supported. If false, all pointers are opaque.
   bool supportsTypedPointers() const;
 
-  /// Optionally target-spcific data can be attached to the context for lifetime
-  /// management and bypassing layering restrictions.
-  llvm::Any &getTargetData() 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.
   void addModule(Module*);
 

llvm/include/llvm/IR/Type.h

enum TypeID {
     // Derived types... see DerivedTypes.h file.
     IntegerTyID,        ///< Arbitrary bit width integers
     FunctionTyID,       ///< Functions
     PointerTyID,        ///< Pointers
     StructTyID,         ///< Structures
     ArrayTyID,          ///< Arrays
     FixedVectorTyID,    ///< Fixed width SIMD vector type
     ScalableVectorTyID, ///< Scalable SIMD vector type
-    DXILPointerTyID,    ///< DXIL typed pointer used by DirectX target
+    TypedPointerTyID,   ///< Typed pointer used by some GPU targets
   };
 
 private:
   /// This refers to the LLVMContext in which this type was uniqued.
   LLVMContext &Context;
 
   TypeID   ID : 8;            // The current base type of this type.
   unsigned SubclassData : 24; // Space for subclasses to store data.

llvm/include/llvm/IR/TypedPointerType.h

-//===- Target/DirectX/DXILPointerType.h - DXIL Typed Pointer Type ---------===//
+//===- llvm/IR/TypedPointerType.h - Typed Pointer Type --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
+// This file contains typed pointer type information. It is separated out into
+// a separate file to make it less likely to accidentally use this type.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_TARGET_DIRECTX_DXILPOINTERTYPE_H
-#define LLVM_TARGET_DIRECTX_DXILPOINTERTYPE_H
+#ifndef LLVM_IR_TYPEDPOINTERTYPE_H
+#define LLVM_IR_TYPEDPOINTERTYPE_H
 
 #include "llvm/IR/Type.h"
 
 namespace llvm {
-namespace dxil {
 
-// DXIL has typed pointers, this pointer type abstraction is used for tracking
-// in PointerTypeAnalysis and for the bitcode ValueEnumerator
+/// A few GPU targets, such as DXIL and SPIR-V, have typed pointers. This
+/// pointer type abstraction is used for tracking the types of these pointers.
+/// It is not legal to use this type, or derived types containing this type, in
+/// LLVM IR.
 class TypedPointerType : public Type {
   explicit TypedPointerType(Type *ElType, unsigned AddrSpace);
 
   Type *PointeeTy;
 
 public:
   TypedPointerType(const TypedPointerType &) = delete;
   TypedPointerType &operator=(const TypedPointerType &) = delete;
 
   /// This constructs a pointer to an object of the specified type in a numbered
   /// address space.
   static TypedPointerType *get(Type *ElementType, unsigned AddressSpace);
 
   /// Return true if the specified type is valid as a element type.
   static bool isValidElementType(Type *ElemTy);
 
   /// Return the address space of the Pointer type.
   unsigned getAddressSpace() const { return getSubclassData(); }
 
   Type *getElementType() const { return PointeeTy; }
 
   /// Implement support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {
-    return T->getTypeID() == DXILPointerTyID;
+    return T->getTypeID() == TypedPointerTyID;
   }
 };
 
-} // namespace dxil
 } // namespace llvm
 
-#endif // LLVM_TARGET_DIRECTX_DXILPOINTERTYPE_H
+#endif // LLVM_IR_TYPEDPOINTERTYPE_H

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

case Type::ScalableVectorTyID: {
       //        [numelts, eltty, scalable]
       Code = bitc::TYPE_CODE_VECTOR;
       TypeVals.push_back(VT->getElementCount().getKnownMinValue());
       TypeVals.push_back(VE.getTypeID(VT->getElementType()));
       if (isa<ScalableVectorType>(VT))
         TypeVals.push_back(true);
       break;
     }
-    case Type::DXILPointerTyID:
-      llvm_unreachable("DXIL pointers cannot be added to IR modules");
+    case Type::TypedPointerTyID:
+      llvm_unreachable("Typed pointers cannot be added to IR modules");
     }
 
     // Emit the finished record.
     Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
     TypeVals.clear();
   }
 
   Stream.ExitBlock();

llvm/lib/IR/AsmWriter.cpp

 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ModuleSlotTracker.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/TypeFinder.h"
+#include "llvm/IR/TypedPointerType.h"
 #include "llvm/IR/Use.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
case Type::ScalableVectorTyID: {
     OS << "<";
     if (EC.isScalable())
       OS << "vscale x ";
     OS << EC.getKnownMinValue() << " x ";
     print(PTy->getElementType(), OS);
     OS << '>';
     return;
   }
-  case Type::DXILPointerTyID:
-    // DXIL pointer types are only handled by the DirectX backend. To avoid
-    // extra dependencies we just print the pointer's address here.
-    OS << "dxil-ptr (" << Ty << ")";
+  case Type::TypedPointerTyID:
+    OS << "typedptr (" << cast<TypedPointerType>(Ty)->getElementType() << ")";
     return;
   }
   llvm_unreachable("Invalid TypeID");
 }
 
 void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) {
   if (STy->isOpaque()) {
     OS << "opaque";

llvm/lib/IR/CMakeLists.txt

add_llvm_component_library(LLVMCore
   PrintPasses.cpp
   SafepointIRVerifier.cpp
   ProfileSummary.cpp
   PseudoProbe.cpp
   ReplaceConstant.cpp
   Statepoint.cpp
   StructuralHash.cpp
   Type.cpp
+  TypedPointerType.cpp
   TypeFinder.cpp
   Use.cpp
   User.cpp
   Value.cpp
   ValueSymbolTable.cpp
   VectorBuilder.cpp
   Verifier.cpp
 

llvm/lib/IR/Core.cpp

LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) {
   case Type::X86_MMXTyID:
     return LLVMX86_MMXTypeKind;
   case Type::X86_AMXTyID:
     return LLVMX86_AMXTypeKind;
   case Type::TokenTyID:
     return LLVMTokenTypeKind;
   case Type::ScalableVectorTyID:
     return LLVMScalableVectorTypeKind;
-  case Type::DXILPointerTyID:
-    llvm_unreachable("DXIL pointers are unsupported via the C API");
+  case Type::TypedPointerTyID:
+    llvm_unreachable("Typed pointers are unsupported via the C API");
   }
   llvm_unreachable("Unhandled TypeID.");
 }
 
 LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty)
 {
     return unwrap(Ty)->isSized();
 }

llvm/lib/IR/LLVMContext.cpp

 
 void LLVMContext::setOpaquePointers(bool Enable) const {
   pImpl->setOpaquePointers(Enable);
 }
 
 bool LLVMContext::supportsTypedPointers() const {
   return !pImpl->getOpaquePointers();
 }
-
-Any &LLVMContext::getTargetData() const {
-  return pImpl->TargetDataStorage;
-}

llvm/lib/IR/LLVMContextImpl.h

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/TrackingMDRef.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/StringSaver.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <memory>

 class InlineAsm;
 class LLVMRemarkStreamer;
 class OptPassGate;
 namespace remarks {
 class RemarkStreamer;
 }
 template <typename T> class StringMapEntry;
 class StringRef;
+class TypedPointerType;
 class ValueHandleBase;
 
 using DenseMapAPIntKeyInfo = DenseMapInfo<APInt>;
 
 struct DenseMapAPFloatKeyInfo {
   static inline APFloat getEmptyKey() { return APFloat(APFloat::Bogus(), 1); }
   static inline APFloat getTombstoneKey() {
     return APFloat(APFloat::Bogus(), 2);
#include "llvm/IR/Metadata.def"
   StructTypeSet AnonStructTypes;
   StringMap<StructType *> NamedStructTypes;
   unsigned NamedStructTypesUniqueID = 0;
 
   DenseMap<std::pair<Type *, uint64_t>, ArrayType *> ArrayTypes;
   DenseMap<std::pair<Type *, ElementCount>, VectorType *> VectorTypes;
   DenseMap<Type *, PointerType *> PointerTypes; // Pointers in AddrSpace = 0
   DenseMap<std::pair<Type *, unsigned>, PointerType *> ASPointerTypes;
+  DenseMap<std::pair<Type *, unsigned>, TypedPointerType *> ASTypedPointerTypes;
 
   /// ValueHandles - This map keeps track of all of the value handles that are
   /// watching a Value*.  The Value::HasValueHandle bit is used to know
   /// whether or not a value has an entry in this map.
   using ValueHandlesTy = DenseMap<Value *, ValueHandleBase *>;
   ValueHandlesTy ValueHandles;
 
   /// CustomMDKindNames - Map to hold the metadata string to ID mapping.
#include "llvm/IR/Metadata.def"
   void setOptPassGate(OptPassGate &);
 
   // TODO: clean up the following after we no longer support non-opaque pointer
   // types.
   bool getOpaquePointers();
   bool hasOpaquePointersValue();
   void setOpaquePointers(bool OP);
 
-  llvm::Any TargetDataStorage;
-
 private:
   Optional<bool> OpaquePointers;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_IR_LLVMCONTEXTIMPL_H

llvm/lib/IR/TypedPointerType.cpp

+//===- TypedPointerType.cpp - Typed Pointer Type --------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/TypedPointerType.h"
+#include "LLVMContextImpl.h"
+
+using namespace llvm;
+
+TypedPointerType *TypedPointerType::get(Type *EltTy, unsigned AddressSpace) {
+  assert(EltTy && "Can't get a pointer to <null> type!");
+  assert(isValidElementType(EltTy) && "Invalid type for pointer element!");
+
+  LLVMContextImpl *CImpl = EltTy->getContext().pImpl;
+
+  // Since AddressSpace #0 is the common case, we special case it.
+  TypedPointerType *&Entry =
+      CImpl->ASTypedPointerTypes[std::make_pair(EltTy, AddressSpace)];
+
+  if (!Entry)
+    Entry = new (CImpl->Alloc) TypedPointerType(EltTy, AddressSpace);
+  return Entry;
+}
+
+TypedPointerType::TypedPointerType(Type *E, unsigned AddrSpace)
+    : Type(E->getContext(), TypedPointerTyID), PointeeTy(E) {
+  ContainedTys = &PointeeTy;
+  NumContainedTys = 1;
+  setSubclassData(AddrSpace);
+}
+
+bool TypedPointerType::isValidElementType(Type *ElemTy) {
+  return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
+         !ElemTy->isMetadataTy() && !ElemTy->isTokenTy() &&
+         !ElemTy->isX86_AMXTy();
+}

llvm/lib/IR/Value.cpp

 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DerivedUser.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
+#include "llvm/IR/TypedPointerType.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
 using namespace llvm;
 
 static cl::opt<unsigned> UseDerefAtPointSemantics(
     "use-dereferenceable-at-point-semantics", cl::Hidden, cl::init(false),
     cl::desc("Deref attributes and metadata infer facts at definition only"));
 
 //===----------------------------------------------------------------------===//
 //                                Value Class
 //===----------------------------------------------------------------------===//
 static inline Type *checkType(Type *Ty) {
   assert(Ty && "Value defined with a null type: Error!");
+  assert(!isa<TypedPointerType>(Ty) &&
+         "Cannot have values with typed pointer types");
   return Ty;
 }
 
 Value::Value(Type *ty, unsigned scid)
     : VTy(checkType(ty)), UseList(nullptr), SubclassID(scid), HasValueHandle(0),
       SubclassOptionalData(0), SubclassData(0), NumUserOperands(0),
       IsUsedByMD(false), HasName(false), HasMetadata(false) {
   static_assert(ConstantFirstVal == 0, "!(SubclassID < ConstantFirstVal)");

llvm/lib/Target/DirectX/CMakeLists.txt

 add_llvm_target(DirectXCodeGen
   DirectXAsmPrinter.cpp
   DirectXInstrInfo.cpp
   DirectXRegisterInfo.cpp
   DirectXSubtarget.cpp
   DirectXTargetMachine.cpp
   DXILOpBuilder.cpp
   DXILOpLowering.cpp
-  DXILPointerType.cpp
   DXILPrepare.cpp
   DXILTranslateMetadata.cpp
   PointerTypeAnalysis.cpp
 
   LINK_COMPONENTS
   Core
   Support
   DirectXInfo

llvm/lib/Target/DirectX/DXILPointerType.cpp

-//===- Target/DirectX/DXILTypedPointerType.cpp - DXIL Typed Pointer Type
-//-------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-//
-//===----------------------------------------------------------------------===//
-
-#include "DXILPointerType.h"
-#include "llvm/ADT/Any.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/IR/LLVMContext.h"
-
-using namespace llvm;
-using namespace llvm::dxil;
-
-class TypedPointerTracking {
-public:
-  TypedPointerTracking() {}
-  DenseMap<Type *, std::unique_ptr<TypedPointerType>> PointerTypes;
-  DenseMap<std::pair<Type *, unsigned>, std::unique_ptr<TypedPointerType>>
-      ASPointerTypes;
-};
-
-TypedPointerType *TypedPointerType::get(Type *EltTy, unsigned AddressSpace) {
-  assert(EltTy && "Can't get a pointer to <null> type!");
-  assert(isValidElementType(EltTy) && "Invalid type for pointer element!");
-
-  llvm::Any &TargetData = EltTy->getContext().getTargetData();
-  if (!TargetData.hasValue())
-    TargetData = Any{std::make_shared<TypedPointerTracking>()};
-
-  assert(any_isa<std::shared_ptr<TypedPointerTracking>>(TargetData) &&
-         "Unexpected target data type");
-
-  std::shared_ptr<TypedPointerTracking> Tracking =
-      any_cast<std::shared_ptr<TypedPointerTracking>>(TargetData);
-
-  // Since AddressSpace #0 is the common case, we special case it.
-  std::unique_ptr<TypedPointerType> &Entry =
-      AddressSpace == 0
-          ? Tracking->PointerTypes[EltTy]
-          : Tracking->ASPointerTypes[std::make_pair(EltTy, AddressSpace)];
-
-  if (!Entry)
-    Entry = std::unique_ptr<TypedPointerType>(
-        new TypedPointerType(EltTy, AddressSpace));
-  return Entry.get();
-}
-
-TypedPointerType::TypedPointerType(Type *E, unsigned AddrSpace)
-    : Type(E->getContext(), DXILPointerTyID), PointeeTy(E) {
-  ContainedTys = &PointeeTy;
-  NumContainedTys = 1;
-  setSubclassData(AddrSpace);
-}
-
-bool TypedPointerType::isValidElementType(Type *ElemTy) {
-  return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
-         !ElemTy->isMetadataTy() && !ElemTy->isTokenTy() &&
-         !ElemTy->isX86_AMXTy();
-}

llvm/lib/Target/DirectX/DXILWriter/DXILBitcodeWriter.cpp

for (Type *T : TypeList) {
     case Type::X86_MMXTyID:
       Code = bitc::TYPE_CODE_X86_MMX;
       break;
     case Type::IntegerTyID:
       // INTEGER: [width]
       Code = bitc::TYPE_CODE_INTEGER;
       TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());
       break;
-    case Type::DXILPointerTyID: {
+    case Type::TypedPointerTyID: {
       TypedPointerType *PTy = cast<TypedPointerType>(T);
       // POINTER: [pointee type, address space]
       Code = bitc::TYPE_CODE_POINTER;
       TypeVals.push_back(getTypeID(PTy->getElementType()));
       unsigned AddressSpace = PTy->getAddressSpace();
       TypeVals.push_back(AddressSpace);
       if (AddressSpace == 0)
         AbbrevToUse = PtrAbbrev;

llvm/lib/Target/DirectX/DXILWriter/DXILValueEnumerator.cpp

 //===- ValueEnumerator.cpp - Number values and types for bitcode writer ---===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the ValueEnumerator class.
 // Forked from lib/Bitcode/Writer
 //
 //===----------------------------------------------------------------------===//
 
 #include "DXILValueEnumerator.h"
-#include "DXILPointerType.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalIFunc.h"
 #include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
+#include "llvm/IR/TypedPointerType.h"
 #include "llvm/IR/Use.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/MathExtras.h"
for (const GlobalVariable &GV : M.globals()) {
     EnumerateType(GV.getValueType());
   }
 
   // Enumerate the functions.
   for (const Function &F : M) {
     EnumerateValue(&F);
     EnumerateType(F.getValueType());
     EnumerateType(
         dxil::TypedPointerType::get(F.getFunctionType(), F.getAddressSpace()));
     EnumerateAttributes(F.getAttributes());
   }
 
   // Enumerate the aliases.
   for (const GlobalAlias &GA : M.aliases()) {
     EnumerateValue(&GA);
     EnumerateType(GA.getValueType());
   }
 
   // Enumerate the ifuncs.
   for (const GlobalIFunc &GIF : M.ifuncs()) {
     EnumerateValue(&GIF);
     EnumerateType(GIF.getValueType());
   }
 
   // Enumerate the global variable initializers and attributes.
   for (const GlobalVariable &GV : M.globals()) {
     if (GV.hasInitializer())
       EnumerateValue(GV.getInitializer());
     EnumerateType(
         dxil::TypedPointerType::get(GV.getValueType(), GV.getAddressSpace()));
     if (GV.hasAttributes())
       EnumerateAttributes(GV.getAttributesAsList(AttributeList::FunctionIndex));
   }
 
   // Enumerate the aliasees.
   for (const GlobalAlias &GA : M.aliases())
     EnumerateValue(GA.getAliasee());
 

llvm/lib/Target/DirectX/PointerTypeAnalysis.h

 //===- Target/DirectX/PointerTypeAnalysis.h - PointerType analysis --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Analysis pass to assign types to opaque pointers.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TARGET_DIRECTX_POINTERTYPEANALYSIS_H
 #define LLVM_TARGET_DIRECTX_POINTERTYPEANALYSIS_H
 
-#include "DXILPointerType.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/IR/TypedPointerType.h"
 
 namespace llvm {
 
 namespace dxil {
 
 // Store the underlying type and the number of pointer indirections
 using PointerTypeMap = DenseMap<const Value *, Type *>;
 

llvm/lib/Target/Hexagon/HexagonTargetObjectFile.cpp

unsigned HexagonTargetObjectFile::getSmallestAddressableSize(const Type *Ty,
   case Type::X86_FP80TyID:
   case Type::FP128TyID:
   case Type::PPC_FP128TyID:
   case Type::LabelTyID:
   case Type::MetadataTyID:
   case Type::X86_MMXTyID:
   case Type::X86_AMXTyID:
   case Type::TokenTyID:
-  case Type::DXILPointerTyID:
+  case Type::TypedPointerTyID:
     return 0;
   }
 
   return 0;
 }
 
 MCSection *HexagonTargetObjectFile::selectSmallSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {

llvm/unittests/Target/DirectX/PointerTypeAnalysisTests.cpp

 //===- llvm/unittests/Target/DirectX/PointerTypeAnalysisTests.cpp ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "DXILPointerType.h"
 #include "PointerTypeAnalysis.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Type.h"
+#include "llvm/IR/TypedPointerType.h"
 #include "llvm/Support/SourceMgr.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using ::testing::Contains;
 using ::testing::Pair;
 
 using namespace llvm;
 using namespace llvm::dxil;
 
 template <typename T> struct IsA {
   friend bool operator==(const Value *V, const IsA &) { return isa<T>(V); }
 };
 
 TEST(DXILPointerType, PrintTest) {
   std::string Buffer;
   LLVMContext Context;
   raw_string_ostream OS(Buffer);
 
   Type *I8Ptr = TypedPointerType::get(Type::getInt8Ty(Context), 0);
   I8Ptr->print(OS);
-  EXPECT_TRUE(StringRef(Buffer).startswith("dxil-ptr ("));
+  EXPECT_TRUE(StringRef(Buffer).startswith("typedptr ("));
 }
 
 TEST(PointerTypeAnalysis, DigressToi8) {
   StringRef Assembly = R"(
     define i64 @test(ptr %p) {
       store i32 0, ptr %p
       %v = load i64, ptr %p
       ret i64 %v
     }