[DirectX] Support opaque ptr for ValueAsMetadata in DXILBitcodeWriter

[python3kgae]

Summary

When writeValueAsMetadata for GlobalVariable and Function, write TypedPointerType for ValueType and FunctionType.

[arsenm]

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

1362

This should also query the address space

[python3kgae]

Save addresspace for Function.

[python3kgae]

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

1362

Fixed.
Never know Function can have address space before.

[bogner]

LGTM with a comment about the test

llvm/test/tools/dxil-dis/opaque-value_as_metadata.ll

29

Is it worth trying to anchor this to the dx metadata (ie, capture the "!8" from "!dx.entryPoints" rather than using the regex...)? I think that'd make what the test is doing a little clearer, but I guess this will be reliable enough as is based on looking for @CBV/@main, so it's probably not a big deal if that's more complicated than it's worth.

Aside, the regex should be {{[0-9]+}} just in cast this ends up being !10

[python3kgae]

Update regex to cover more cases.

[python3kgae]

llvm/test/tools/dxil-dis/opaque-value_as_metadata.ll

29

Thanks for review.
The !8 will change, that's why I use regex here.
Changed to {{[0-9]+}}

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

for (const GlobalAlias &A : M.aliases()) {
     Vals.clear();
   }
 }
 
 void DXILBitcodeWriter::writeValueAsMetadata(
     const ValueAsMetadata *MD, SmallVectorImpl<uint64_t> &Record) {
   // Mimic an MDNode with a value as one operand.
   Value *V = MD->getValue();
-  Record.push_back(getTypeID(V->getType()));
+  Type *Ty = V->getType();
+  if (Function *F = dyn_cast<Function>(V))
+    Ty = TypedPointerType::get(F->getFunctionType(), F->getAddressSpace());
+  else if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
+    Ty = TypedPointerType::get(GV->getValueType(), GV->getAddressSpace());
+  Record.push_back(getTypeID(Ty));
   Record.push_back(VE.getValueID(V));
   Stream.EmitRecord(bitc::METADATA_VALUE, Record, 0);
   Record.clear();
 }
 
 void DXILBitcodeWriter::writeMDTuple(const MDTuple *N,
                                      SmallVectorImpl<uint64_t> &Record,
                                      unsigned Abbrev) {

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"
for (const GlobalVariable &GV : M.globals()) {
     EnumerateValue(&GV);
     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/test/tools/dxil-dis/opaque-value_as_metadata.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:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%"$Globals" = type { float }
+
+@CBV = external constant %"$Globals"
+
+define void @main() {
+  ret void
+}
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.entryPoints = !{!8}
+
+!0 = !{!"clang version 15.0.0"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 7}
+!3 = !{!"ps", i32 6, i32 0}
+!4 = !{null, null, !5, null}
+!5 = !{!6}
+; CHECK-DAG:!{{[0-9]+}} = !{i32 0, %"$Globals"* @CBV
+!6 = !{i32 0, ptr @CBV, !"", i32 0, i32 0, i32 1, i32 4, null}
+!7 = !{[2 x i32] [i32 0, i32 1]}
+; CHECK-DAG:!{{[0-9]+}} = !{void ()* @main
+!8 = !{ptr @main, !"main", null, !4, null}