[DirectX backend] Support global ctor for DXILBitcodeWriter.

[python3kgae]

Summary

1. Save typed pointer type for GlobalVariable/Function instead of the ObjectType. This will allow use GlobalVariable/Function as value.
2. Save target type for global ctors for Constant.
3. In DXILBitcodeWriter::getTypeID, check PointerMap first for Constant case.

[python3kgae]

Use CallBase to cover both CallInst and Invoke

[python3kgae]

Recover patch overwrite by mistake.

[beanz]

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

2121

nit: you added extra braces here.

see: https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

llvm/lib/Target/DirectX/PointerTypeAnalysis.cpp

40

nit: please add braces here.

This is an example of the contrary point in the standard where readability is impacted by the braces. Since the first if has braces to improve readability we should keep braces on all the else blocks too.

96

This confuses me. RetTy starts as nullptr, if NewRetTy is also nullptr we set RetTy to nullptr? Unless I'm missing something this does nothing.

This changes the logic in the loop body, but not in a way that is clear to follow.

If I'm reading this logic correctly, I don't see how this function ever returns anything other than i8*. You enter the loop RetTy is nullptr. If NewRetTy is anything, you have a mismatch, and get i8*.

120

Is there a more generic way to do this? I feel like this more or less hard codes the type.

[python3kgae]

Add notes classifyGlobalCtorPointerType.

[python3kgae]

llvm/lib/Target/DirectX/PointerTypeAnalysis.cpp

96

Reverted.

120

Not sure how to support Constant with typed pointer type { i32, void ()*, i8* } and {
i32, float (float)*, i8* } map to same Constant with opaque pointer type
{i32, ptr, ptr} yet.
Mark as FIXME for now.

[python3kgae]

Add new line.

[python3kgae]

Remove hard coded type for global ctor.

[python3kgae]

Rebase

[beanz]

As an FYI (not something I expect you to tackle here), I just filed an issue to track writing an analysis printer for the pointer analysis pass (https://github.com/llvm/llvm-project/issues/57934). That would really help us debug and test this pass as it grows in complexity.

I have some other comments below mostly nitpicks about comment wording, but a few questions too. Overall looking good.

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

353

I assume this is true for all llvm::GlobalObjects right?

Maybe:

/// getGlobalObjectValueTypeID - returns the element type for a GlobalObject
///
/// GlobalObject types are saved by PointerTypeAnalysis as pointers to the 
/// GlobalObject, but in the bitcode writer we need the pointer element type.

566

The point of this being higher up in the function was to early out and avoid the cost of the map lookup. With your new code, is there a way we can rewrite this check instead of moving it?

1229

You’re not actually looking up the abbreviation, but rather the enumerated type identifier.

Maybe something more like:

// Use getGlobalObjectValueTypeID to look up the enumerated type ID for Global Variable types.

llvm/lib/Target/DirectX/PointerTypeAnalysis.cpp

123

Issue please.

128

Can we move this up above the map lookup?

159

207–208

I understand needing functions classified first, but this will break if we ever have any other global variable that contains function pointers right?

[python3kgae]

Code cleanup to match comments.

[beanz]

One small nit, otherwise looks good.

llvm/lib/Target/DirectX/PointerTypeAnalysis.cpp

108–109

nit: Why not just assign this to ArgTy? Temporary seems unnecessary now.

[python3kgae]

Rebase and fix issue for nullptr.

[beanz]

@python3kgae This breaks the unit tests for the PointerTypeAnalysis pass, so I've reverted it in rG5d4dd5357076de54d70f8621a39626b393a6e110.

Please ensure that all the in-tree tests pass before pushing.

[python3kgae]

Reopen for unit test fail.

[python3kgae]

Fix unit test.

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

private:
   void writeFunction(const Function &F);
   void writeBlockInfo();
 
   unsigned getEncodedSyncScopeID(SyncScope::ID SSID) { return unsigned(SSID); }
 
   unsigned getEncodedAlign(MaybeAlign Alignment) { return encode(Alignment); }
 
   unsigned getTypeID(Type *T, const Value *V = nullptr);
-  unsigned getTypeID(Type *T, const Function *F);
+  /// getGlobalObjectValueTypeID - returns the element type for a GlobalObject
+  ///
+  /// GlobalObject types are saved by PointerTypeAnalysis as pointers to the
+  /// GlobalObject, but in the bitcode writer we need the pointer element type.
+  unsigned getGlobalObjectValueTypeID(Type *T, const GlobalObject *G);
 };
 
 } // namespace dxil
 } // namespace llvm
 
 using namespace llvm;
 using namespace llvm::dxil;
 
unsigned DXILBitcodeWriter::getEncodedBinaryOpcode(unsigned Opcode) {
   case Instruction::Or:
     return bitc::BINOP_OR;
   case Instruction::Xor:
     return bitc::BINOP_XOR;
   }
 }
 
 unsigned DXILBitcodeWriter::getTypeID(Type *T, const Value *V) {
-  if (!T->isOpaquePointerTy())
+  if (!T->isOpaquePointerTy() &&
+      // For Constant, always check PointerMap to make sure OpaquePointer in
+      // things like constant struct/array works.
+      (!V || !isa<Constant>(V)))
     return VE.getTypeID(T);
   auto It = PointerMap.find(V);
   if (It != PointerMap.end())
     return VE.getTypeID(It->second);
+  // For Constant, return T when cannot find in PointerMap.
+  // FIXME: support ConstantPointerNull which could map to more than one
+  // TypedPointerType.
+  // See https://github.com/llvm/llvm-project/issues/57942.
+  if (V && isa<Constant>(V) && !isa<ConstantPointerNull>(V))
+    return VE.getTypeID(T);
   return VE.getTypeID(I8PtrTy);
 }
 
-unsigned DXILBitcodeWriter::getTypeID(Type *T, const Function *F) {
-  auto It = PointerMap.find(F);
-  if (It != PointerMap.end())
-    return VE.getTypeID(It->second);
+unsigned DXILBitcodeWriter::getGlobalObjectValueTypeID(Type *T,
+                                                       const GlobalObject *G) {
+  auto It = PointerMap.find(G);
+  if (It != PointerMap.end()) {
+    TypedPointerType *PtrTy = cast<TypedPointerType>(It->second);
+    return VE.getTypeID(PtrTy->getElementType());
+  }
   return VE.getTypeID(T);
 }
 
 unsigned DXILBitcodeWriter::getEncodedRMWOperation(AtomicRMWInst::BinOp Op) {
   switch (Op) {
   default:
     llvm_unreachable("Unknown RMW operation!");
   case AtomicRMWInst::Xchg:
void DXILBitcodeWriter::writeModuleInfo() {
   MaybeAlign MaxAlignment;
   unsigned MaxGlobalType = 0;
   const auto UpdateMaxAlignment = [&MaxAlignment](const MaybeAlign A) {
     if (A)
       MaxAlignment = !MaxAlignment ? *A : std::max(*MaxAlignment, *A);
   };
   for (const GlobalVariable &GV : M.globals()) {
     UpdateMaxAlignment(GV.getAlign());
-    MaxGlobalType = std::max(MaxGlobalType, getTypeID(GV.getValueType(), &GV));
+    // Use getGlobalObjectValueTypeID to look up the enumerated type ID for
+    // Global Variable types.
+    MaxGlobalType = std::max(
+        MaxGlobalType, getGlobalObjectValueTypeID(GV.getValueType(), &GV));
     if (GV.hasSection()) {
       // Give section names unique ID's.
       unsigned &Entry = SectionMap[std::string(GV.getSection())];
       if (!Entry) {
         writeStringRecord(Stream, bitc::MODULE_CODE_SECTIONNAME,
                           GV.getSection(), 0 /*TODO*/);
         Entry = SectionMap.size();
       }
void DXILBitcodeWriter::writeModuleInfo() {
   SmallVector<unsigned, 64> Vals;
   for (const GlobalVariable &GV : M.globals()) {
     unsigned AbbrevToUse = 0;
 
     // GLOBALVAR: [type, isconst, initid,
     //             linkage, alignment, section, visibility, threadlocal,
     //             unnamed_addr, externally_initialized, dllstorageclass,
     //             comdat]
-    Vals.push_back(getTypeID(GV.getValueType(), &GV));
+    Vals.push_back(getGlobalObjectValueTypeID(GV.getValueType(), &GV));
     Vals.push_back(
         GV.getType()->getAddressSpace() << 2 | 2 |
         (GV.isConstant() ? 1 : 0)); // HLSL Change - bitwise | was used with
                                     // unsigned int and bool
     Vals.push_back(
         GV.isDeclaration() ? 0 : (VE.getValueID(GV.getInitializer()) + 1));
     Vals.push_back(getEncodedLinkage(GV));
     Vals.push_back(getEncodedAlign(GV.getAlign()));
for (const GlobalVariable &GV : M.globals()) {
     Vals.clear();
   }
 
   // Emit the function proto information.
   for (const Function &F : M) {
     // FUNCTION:  [type, callingconv, isproto, linkage, paramattrs, alignment,
     //             section, visibility, gc, unnamed_addr, prologuedata,
     //             dllstorageclass, comdat, prefixdata, personalityfn]
-    Vals.push_back(getTypeID(F.getFunctionType(), &F));
+    Vals.push_back(getGlobalObjectValueTypeID(F.getFunctionType(), &F));
     Vals.push_back(F.getCallingConv());
     Vals.push_back(F.isDeclaration());
     Vals.push_back(getEncodedLinkage(F));
     Vals.push_back(VE.getAttributeListID(F.getAttributes()));
     Vals.push_back(getEncodedAlign(F.getAlign()));
     Vals.push_back(F.hasSection() ? SectionMap[std::string(F.getSection())]
                                   : 0);
     Vals.push_back(getEncodedVisibility(F));
void DXILBitcodeWriter::writeConstants(unsigned FirstVal, unsigned LastVal,
 
   const ValueEnumerator::ValueList &Vals = VE.getValues();
   Type *LastTy = nullptr;
   for (unsigned i = FirstVal; i != LastVal; ++i) {
     const Value *V = Vals[i].first;
     // If we need to switch types, do so now.
     if (V->getType() != LastTy) {
       LastTy = V->getType();
-      Record.push_back(getTypeID(LastTy));
+      Record.push_back(getTypeID(LastTy, V));
       Stream.EmitRecord(bitc::CST_CODE_SETTYPE, Record,
                         CONSTANTS_SETTYPE_ABBREV);
       Record.clear();
     }
 
     if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
       Record.push_back(unsigned(IA->hasSideEffects()) |
                        unsigned(IA->isAlignStack()) << 1 |
if (C->isNullValue()) {
           Record.push_back(I);
         }
       }
     } else if (isa<ConstantArray>(C) || isa<ConstantStruct>(C) ||
                isa<ConstantVector>(C)) {
       Code = bitc::CST_CODE_AGGREGATE;
       for (const Value *Op : C->operands())
         Record.push_back(VE.getValueID(Op));
       AbbrevToUse = AggregateAbbrev;
     } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
       switch (CE->getOpcode()) {
       default:
         if (Instruction::isCast(CE->getOpcode())) {
           Code = bitc::CST_CODE_CE_CAST;
           Record.push_back(getEncodedCastOpcode(CE->getOpcode()));
-          Record.push_back(getTypeID(C->getOperand(0)->getType()));
+          Record.push_back(
+              getTypeID(C->getOperand(0)->getType(), C->getOperand(0)));
           Record.push_back(VE.getValueID(C->getOperand(0)));
           AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
         } else {
           assert(CE->getNumOperands() == 2 && "Unknown constant expr!");
           Code = bitc::CST_CODE_CE_BINOP;
           Record.push_back(getEncodedBinaryOpcode(CE->getOpcode()));
           Record.push_back(VE.getValueID(C->getOperand(0)));
           Record.push_back(VE.getValueID(C->getOperand(1)));
           uint64_t Flags = getOptimizationFlags(CE);
           if (Flags != 0)
             Record.push_back(Flags);
         }
         break;
       case Instruction::GetElementPtr: {
         Code = bitc::CST_CODE_CE_GEP;
         const auto *GO = cast<GEPOperator>(C);
         if (GO->isInBounds())
           Code = bitc::CST_CODE_CE_INBOUNDS_GEP;
         Record.push_back(getTypeID(GO->getSourceElementType()));
         for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) {
-          Record.push_back(getTypeID(C->getOperand(i)->getType()));
+          Record.push_back(
+              getTypeID(C->getOperand(i)->getType(), C->getOperand(i)));
           Record.push_back(VE.getValueID(C->getOperand(i)));
         }
         break;
       }
       case Instruction::Select:
         Code = bitc::CST_CODE_CE_SELECT;
         Record.push_back(VE.getValueID(C->getOperand(0)));
         Record.push_back(VE.getValueID(C->getOperand(1)));
case Instruction::Call: {
     const CallInst &CI = cast<CallInst>(I);
     FunctionType *FTy = CI.getFunctionType();
 
     Code = bitc::FUNC_CODE_INST_CALL;
 
     Vals.push_back(VE.getAttributeListID(CI.getAttributes()));
     Vals.push_back((CI.getCallingConv() << 1) | unsigned(CI.isTailCall()) |
                    unsigned(CI.isMustTailCall()) << 14 | 1 << 15);
-    Vals.push_back(getTypeID(FTy, CI.getCalledFunction()));
+    Vals.push_back(getGlobalObjectValueTypeID(FTy, CI.getCalledFunction()));
     pushValueAndType(CI.getCalledOperand(), InstID, Vals); // Callee
 
     // Emit value #'s for the fixed parameters.
     for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
       // Check for labels (can happen with asm labels).
       if (FTy->getParamType(i)->isLabelTy())
         Vals.push_back(VE.getValueID(CI.getArgOperand(i)));
       else

llvm/lib/Target/DirectX/PointerTypeAnalysis.cpp

 //===- Target/DirectX/PointerTypeAnalisis.cpp - 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.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PointerTypeAnalysis.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 
 using namespace llvm;
 using namespace llvm::dxil;
 
 namespace {
 
 // Classifies the type of the value passed in by walking the value's users to
 // find a typed instruction to materialize a type from.
-TypedPointerType *classifyPointerType(const Value *V) {
+Type *classifyPointerType(const Value *V, PointerTypeMap &Map) {
   assert(V->getType()->isOpaquePointerTy() &&
          "classifyPointerType called with non-opaque pointer");
+  auto It = Map.find(V);
+  if (It != Map.end())
+    return It->second;
+
   Type *PointeeTy = nullptr;
   if (auto *Inst = dyn_cast<GetElementPtrInst>(V)) {
     if (!Inst->getResultElementType()->isOpaquePointerTy())
       PointeeTy = Inst->getResultElementType();
   } else if (auto *Inst = dyn_cast<AllocaInst>(V)) {
     PointeeTy = Inst->getAllocatedType();
+  } else if (auto *GV = dyn_cast<GlobalVariable>(V)) {
+    PointeeTy = GV->getValueType();
   }
+
   for (const auto *User : V->users()) {
     Type *NewPointeeTy = nullptr;
     if (const auto *Inst = dyn_cast<LoadInst>(User)) {
       NewPointeeTy = Inst->getType();
     } else if (const auto *Inst = dyn_cast<StoreInst>(User)) {
       NewPointeeTy = Inst->getValueOperand()->getType();
+      // When store value is ptr type, cannot get more type info.
+      if (NewPointeeTy->isOpaquePointerTy())
+        continue;
     } else if (const auto *Inst = dyn_cast<GetElementPtrInst>(User)) {
       NewPointeeTy = Inst->getSourceElementType();
     }
     if (NewPointeeTy) {
       // HLSL doesn't support pointers, so it is unlikely to get more than one
       // or two levels of indirection in the IR. Because of this, recursion is
       // pretty safe.
-      if (NewPointeeTy->isOpaquePointerTy())
-        return TypedPointerType::get(classifyPointerType(User),
-                                     V->getType()->getPointerAddressSpace());
+      if (NewPointeeTy->isOpaquePointerTy()) {
+        PointeeTy = classifyPointerType(User, Map);
+        break;
+      }
       if (!PointeeTy)
         PointeeTy = NewPointeeTy;
       else if (PointeeTy != NewPointeeTy)
         PointeeTy = Type::getInt8Ty(V->getContext());
     }
   }
   // If we were unable to determine the pointee type, set to i8
   if (!PointeeTy)
     PointeeTy = Type::getInt8Ty(V->getContext());
-  return TypedPointerType::get(PointeeTy,
-                               V->getType()->getPointerAddressSpace());
+  auto *TypedPtrTy =
+      TypedPointerType::get(PointeeTy, V->getType()->getPointerAddressSpace());
+
+  Map[V] = TypedPtrTy;
+  return TypedPtrTy;
 }
 
 // This function constructs a function type accepting typed pointers. It only
 // handles function arguments and return types, and assigns the function type to
 // the function's value in the type map.
-void classifyFunctionType(const Function &F, PointerTypeMap &Map) {
+Type *classifyFunctionType(const Function &F, PointerTypeMap &Map) {
+  auto It = Map.find(&F);
+  if (It != Map.end())
+    return It->second;
+
   SmallVector<Type *, 8> NewArgs;
-  bool HasOpaqueTy = false;
   Type *RetTy = F.getReturnType();
+  LLVMContext &Ctx = F.getContext();
   if (RetTy->isOpaquePointerTy()) {
     RetTy = nullptr;
     for (const auto &B : F) {
-      for (const auto &I : B) {
-        if (const auto *RetInst = dyn_cast_or_null<ReturnInst>(&I)) {
-          Type *NewRetTy = classifyPointerType(RetInst->getReturnValue());
-          if (!RetTy)
-            RetTy = NewRetTy;
-          else if (RetTy != NewRetTy)
-            RetTy = TypedPointerType::get(
-                Type::getInt8Ty(I.getContext()),
-                F.getReturnType()->getPointerAddressSpace());
-        }
-      }
+      const auto *RetInst = dyn_cast_or_null<ReturnInst>(B.getTerminator());
+      if (!RetInst)
+        continue;
+
+      Type *NewRetTy = classifyPointerType(RetInst->getReturnValue(), Map);
+            Type::getInt8Ty(Ctx), F.getReturnType()->getPointerAddressSpace());
     }
+    // For function decl.
+    if (!RetTy)
+      RetTy = TypedPointerType::get(
+          Type::getInt8Ty(Ctx), F.getReturnType()->getPointerAddressSpace());
   }
   for (auto &A : F.args()) {
     Type *ArgTy = A.getType();
-    if (ArgTy->isOpaquePointerTy()) {
-      TypedPointerType *NewTy = classifyPointerType(&A);
-      Map[&A] = NewTy;
-      ArgTy = NewTy;
-      HasOpaqueTy = true;
-    }
+    if (ArgTy->isOpaquePointerTy())
+      ArgTy = classifyPointerType(&A, Map);
     NewArgs.push_back(ArgTy);
   }
-  if (!HasOpaqueTy)
-    return;
-  Map[&F] = FunctionType::get(RetTy, NewArgs, false);
+  auto *TypedPtrTy =
+      TypedPointerType::get(FunctionType::get(RetTy, NewArgs, false), 0);
+  Map[&F] = TypedPtrTy;
+  return TypedPtrTy;
 }
 } // anonymous namespace
 
+static Type *classifyConstantWithOpaquePtr(const Constant *C,
+                                           PointerTypeMap &Map) {
+  // FIXME: support ConstantPointerNull which could map to more than one
+  // TypedPointerType.
+  // See https://github.com/llvm/llvm-project/issues/57942.
+  if (isa<ConstantPointerNull>(C))
+    return TypedPointerType::get(Type::getInt8Ty(C->getContext()),
+                                 C->getType()->getPointerAddressSpace());
+
+  // Skip ConstantData which cannot have opaque ptr.
+  if (isa<ConstantData>(C))
+    return C->getType();
+
+  auto It = Map.find(C);
+  if (It != Map.end())
+    return It->second;
+
+  if (const auto *F = dyn_cast<Function>(C))
+    return classifyFunctionType(*F, Map);
+
+  Type *Ty = C->getType();
+  Type *TargetTy = nullptr;
+  if (auto *CS = dyn_cast<ConstantStruct>(C)) {
+    SmallVector<Type *> EltTys;
+    for (unsigned int I = 0; I < CS->getNumOperands(); ++I) {
+      const Constant *Elt = C->getAggregateElement(I);
+      Type *EltTy = classifyConstantWithOpaquePtr(Elt, Map);
+      EltTys.emplace_back(EltTy);
+    }
+    TargetTy = StructType::get(C->getContext(), EltTys);
+  } else if (auto *CA = dyn_cast<ConstantAggregate>(C)) {
+
+    Type *TargetEltTy = nullptr;
+    for (auto &Elt : CA->operands()) {
+      Type *EltTy = classifyConstantWithOpaquePtr(cast<Constant>(&Elt), Map);
+      assert(TargetEltTy == EltTy || TargetEltTy == nullptr);
+      TargetEltTy = EltTy;
+    }
+
+    if (auto *AT = dyn_cast<ArrayType>(Ty)) {
+      TargetTy = ArrayType::get(TargetEltTy, AT->getNumElements());
+    } else {
+      // Not struct, not array, must be vector here.
+      auto *VT = cast<VectorType>(Ty);
+      TargetTy = VectorType::get(TargetEltTy, VT);
+    }
+  }
+  // Must have a target ty when map.
+  assert(TargetTy && "PointerTypeAnalyisis failed to identify target type");
+
+  // Same type, no need to map.
+  if (TargetTy == Ty)
+    return Ty;
+
+  Map[C] = TargetTy;
+  return TargetTy;
+}
+
+static void classifyGlobalCtorPointerType(const GlobalVariable &GV,
+                                          PointerTypeMap &Map) {
+  const auto *CA = cast<ConstantArray>(GV.getInitializer());
+  // Type for global ctor should be array of { i32, void ()*, i8* }.
+  Type *CtorArrayTy = classifyConstantWithOpaquePtr(CA, Map);
+
+  // Map the global type.
+  Map[&GV] = TypedPointerType::get(CtorArrayTy,
+                                   GV.getType()->getPointerAddressSpace());
+}
+
 PointerTypeMap PointerTypeAnalysis::run(const Module &M) {
   PointerTypeMap Map;
   for (auto &G : M.globals()) {
     if (G.getType()->isOpaquePointerTy())
-      Map[&G] = classifyPointerType(&G);
+      classifyPointerType(&G, Map);
+    if (G.getName() == "llvm.global_ctors")
+      classifyGlobalCtorPointerType(G, Map);
   }
+
   for (auto &F : M) {
     classifyFunctionType(F, Map);
 
     for (const auto &B : F) {
       for (const auto &I : B) {
         if (I.getType()->isOpaquePointerTy())
-          Map[&I] = classifyPointerType(&I);
+          classifyPointerType(&I, Map);
       }
     }
   }
-
   return Map;
 }

llvm/test/tools/dxil-dis/global_ctor.ll

+; RUN: llc --filetype=obj %s -o - 2>&1 | dxil-dis -o - | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-unknown-shadermodel6.7-library"
+; Make sure global ctor type is changed to void ()*.
+; CHECK:@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_static_global.hlsl, i8* null }]
+
+@f = internal unnamed_addr global float 0.000000e+00, align 4
[e-mail]_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @_GLOBAL__sub_I_static_global.hlsl, ptr null }]
+
+declare float @"?init@@YAMXZ"() local_unnamed_addr #0
+
+; Function Attrs: nounwind
+define float @"?foo@@YAMXZ"() local_unnamed_addr #1 {
+entry:
+  %0 = load float, ptr @f, align 4, !tbaa !4
+  %inc = fadd float %0, 1.000000e+00
+  store float %inc, ptr @f, align 4, !tbaa !4
+  ret float %0
+}
+
+; Function Attrs: nounwind
+define float @"?bar@@YAMXZ"() local_unnamed_addr #1 {
+entry:
+  %0 = load float, ptr @f, align 4, !tbaa !4
+  %dec = fadd float %0, -1.000000e+00
+  store float %dec, ptr @f, align 4, !tbaa !4
+  ret float %0
+}
+
+; Function Attrs: nounwind
+define internal void @_GLOBAL__sub_I_static_global.hlsl() #1 {
+entry:
+  %call.i = tail call float @"?init@@YAMXZ"() #2
+  store float %call.i, ptr @f, align 4, !tbaa !4
+  ret void
+}
+
+attributes #0 = { "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #1 = { nounwind "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #2 = { nounwind }
+
+!llvm.module.flags = !{!0, !1}
+!llvm.ident = !{!2}
+!dx.valver = !{!3}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 7, !"frame-pointer", i32 2}
+!2 = !{!"clang version 16.0.0 (https://github.com/llvm/llvm-project.git c5dfff0e58cc66d74e666c31368f6d44328dd2f7)"}
+!3 = !{i32 1, i32 7}
+!4 = !{!5, !5, i64 0}
+!5 = !{!"float", !6, i64 0}
+!6 = !{!"omnipotent char", !7, i64 0}
+!7 = !{!"Simple C++ TBAA"}

llvm/unittests/Target/DirectX/PointerTypeAnalysisTests.cpp

TEST(PointerTypeAnalysis, DigressToi8) {
   auto M = parseAssemblyString(Assembly, Error, Context);
   ASSERT_TRUE(M) << "Bad assembly?";
 
   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
   ASSERT_EQ(Map.size(), 2u);
   Type *I8Ptr = TypedPointerType::get(Type::getInt8Ty(Context), 0);
   Type *FnTy = FunctionType::get(Type::getInt64Ty(Context), {I8Ptr}, false);
 
-  EXPECT_THAT(Map, Contains(Pair(IsA<Function>(), FnTy)));
-  EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I8Ptr)));  
+  EXPECT_THAT(Map,
+              Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
+  EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I8Ptr)));
 }
 
 TEST(PointerTypeAnalysis, DiscoverStore) {
   StringRef Assembly = R"(
     define i32 @test(ptr %p) {
       store i32 0, ptr %p
       ret i32 0
     }
   )";
 
   LLVMContext Context;
   SMDiagnostic Error;
   auto M = parseAssemblyString(Assembly, Error, Context);
   ASSERT_TRUE(M) << "Bad assembly?";
 
   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
   ASSERT_EQ(Map.size(), 2u);
   Type *I32Ptr = TypedPointerType::get(Type::getInt32Ty(Context), 0);
   Type *FnTy = FunctionType::get(Type::getInt32Ty(Context), {I32Ptr}, false);
 
-  EXPECT_THAT(Map, Contains(Pair(IsA<Function>(), FnTy)));
+  EXPECT_THAT(Map,
+              Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
   EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I32Ptr)));
 }
 
 TEST(PointerTypeAnalysis, DiscoverLoad) {
   StringRef Assembly = R"(
     define i32 @test(ptr %p) {
       %v = load i32, ptr %p
       ret i32 %v
     }
   )";
 
   LLVMContext Context;
   SMDiagnostic Error;
   auto M = parseAssemblyString(Assembly, Error, Context);
   ASSERT_TRUE(M) << "Bad assembly?";
 
   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
   ASSERT_EQ(Map.size(), 2u);
   Type *I32Ptr = TypedPointerType::get(Type::getInt32Ty(Context), 0);
   Type *FnTy = FunctionType::get(Type::getInt32Ty(Context), {I32Ptr}, false);
 
-  EXPECT_THAT(Map, Contains(Pair(IsA<Function>(), FnTy)));
+  EXPECT_THAT(Map,
+              Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
   EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I32Ptr)));
 }
 
 TEST(PointerTypeAnalysis, DiscoverGEP) {
   StringRef Assembly = R"(
     define ptr @test(ptr %p) {
       %p2 = getelementptr i64, ptr %p, i64 1
       ret ptr %p2
     }
   )";
 
   LLVMContext Context;
   SMDiagnostic Error;
   auto M = parseAssemblyString(Assembly, Error, Context);
   ASSERT_TRUE(M) << "Bad assembly?";
 
   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
   ASSERT_EQ(Map.size(), 3u);
 
   Type *I64Ptr = TypedPointerType::get(Type::getInt64Ty(Context), 0);
   Type *FnTy = FunctionType::get(I64Ptr, {I64Ptr}, false);
 
-  EXPECT_THAT(Map, Contains(Pair(IsA<Function>(), FnTy)));
+  EXPECT_THAT(Map,
+              Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
   EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I64Ptr)));
   EXPECT_THAT(Map, Contains(Pair(IsA<GetElementPtrInst>(), I64Ptr)));
 }
 
 TEST(PointerTypeAnalysis, TraceIndirect) {
   StringRef Assembly = R"(
     define i64 @test(ptr %p) {
       %p2 = load ptr, ptr %p
TEST(PointerTypeAnalysis, TraceIndirect) {
 
   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
   ASSERT_EQ(Map.size(), 3u);
 
   Type *I64Ptr = TypedPointerType::get(Type::getInt64Ty(Context), 0);
   Type *I64PtrPtr = TypedPointerType::get(I64Ptr, 0);
   Type *FnTy = FunctionType::get(Type::getInt64Ty(Context), {I64PtrPtr}, false);
 
-  EXPECT_THAT(Map, Contains(Pair(IsA<Function>(), FnTy)));
+  EXPECT_THAT(Map,
+              Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
   EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I64PtrPtr)));
   EXPECT_THAT(Map, Contains(Pair(IsA<LoadInst>(), I64Ptr)));
 }
 
 TEST(PointerTypeAnalysis, WithNoOpCasts) {
   StringRef Assembly = R"(
     define i64 @test(ptr %p) {
       %1 = bitcast ptr %p to ptr
TEST(PointerTypeAnalysis, WithNoOpCasts) {
   PointerTypeMap Map = PointerTypeAnalysis::run(*M);
   ASSERT_EQ(Map.size(), 4u);
 
   Type *I8Ptr = TypedPointerType::get(Type::getInt8Ty(Context), 0);
   Type *I32Ptr = TypedPointerType::get(Type::getInt32Ty(Context), 0);
   Type *I64Ptr = TypedPointerType::get(Type::getInt64Ty(Context), 0);
   Type *FnTy = FunctionType::get(Type::getInt64Ty(Context), {I8Ptr}, false);
 
-  EXPECT_THAT(Map, Contains(Pair(IsA<Function>(), FnTy)));
+  EXPECT_THAT(Map,
+              Contains(Pair(IsA<Function>(), TypedPointerType::get(FnTy, 0))));
   EXPECT_THAT(Map, Contains(Pair(IsA<Argument>(), I8Ptr)));
   EXPECT_THAT(Map, Contains(Pair(IsA<BitCastInst>(), I64Ptr)));
   EXPECT_THAT(Map, Contains(Pair(IsA<BitCastInst>(), I32Ptr)));
 }