[HLSL] clang codeGen for HLSLShaderAttr.

[python3kgae]

Summary

Translate HLSLShaderAttr to IR level.

1. Skip mangle for hlsl entry functions.
2. Add function attribute for hlsl entry functions.

[Anastasia]

clang/lib/AST/Mangle.cpp

136

Does HLSL shader entry inherits the same behavior as C-linkage functions (extern C) e.g. they can't be overloaded, templated, etc? If that's the case it might be easier to add C-linkage to it during parsing and then you can inherit the rest of logic including excluding it from mangling... This is how we implement kernel function handling in clang for OpenCL.

[python3kgae]

clang/lib/AST/Mangle.cpp

136

Yes. It is like kernel for OpenCL.
I'll change to extern C.

[python3kgae]

Treat entry functions as in extern C scope.

[Anastasia]

clang/lib/CodeGen/CGHLSLRuntime.cpp

55

I don't think you need clang::CodeGen::?

clang/lib/CodeGen/CGHLSLRuntime.h

50

typo: setHLSLFnuctionAttributes -> setHLSLFunctionAttributes

clang/lib/CodeGen/CodeGenModule.cpp

1682

I think all attributes are expected to be added in ConstructAttributeList.

[Anastasia]

clang/test/CodeGenHLSL/entry.hlsl

2

Is this test here accidental?

clang/test/CodeGenHLSL/shader_type_attr.hlsl

4

I struggle understand the difference in this test? Can it be merged with the above?

[python3kgae]

clang/test/CodeGenHLSL/entry.hlsl

2

This test is to make sure generate "dx.shader" attribute on entry function which set by -E option.

clang/test/CodeGenHLSL/shader_type_attr.hlsl

4

The difference between these 2 tests is entry.hlsl test for entry which does not have shader attribute on foo while shader_type_attr.hlsl test for entry in a library which has shader attribute (the [shader("compute")]).

[python3kgae]

Move addHLSLFunctionAttributes to ConstructAttributeList.

[Anastasia]

clang/lib/CodeGen/CGCall.cpp

2606 ↗

(On Diff #432393)

I think TargetDecl can't be nullptr at this point due to the above check? So perhaps using dyn_cast is better here?

clang/lib/CodeGen/CGHLSLRuntime.cpp

56

This parameter seems to be unused?

clang/test/CodeGenHLSL/shader_type_attr.hlsl

4

Ok, I see although in this patch you only add support for generating the attribute in IR so the logic for handling -E or input attribute is I assume elsewhere and it is tested separately?

But the tests are small so no big concerns to keep both either.

[python3kgae]

Code cleanup to match comments.

[Anastasia]

LGTM! Thanks

[python3kgae]

Rebase to upstream.

[python3kgae]

Add -fcgl to make test work without DirectX backend.

clang/lib/AST/Mangle.cpp

bool MangleContext::shouldMangleDeclName(const NamedDecl *D) {
   // over all other naming in the .o file.
   if (D->hasAttr<AsmLabelAttr>())
     return true;
 
   // Declarations that don't have identifier names always need to be mangled.
   if (isa<MSGuidDecl>(D))
     return true;
 
+  // HLSL shader entry function never need to be mangled.
+  if (getASTContext().getLangOpts().HLSL && D->hasAttr<HLSLShaderAttr>())
+    return false;
+
   return shouldMangleCXXName(D);
 }
 
 void MangleContext::mangleName(GlobalDecl GD, raw_ostream &Out) {
   const ASTContext &ASTContext = getASTContext();
   const NamedDecl *D = cast<NamedDecl>(GD.getDecl());
 
   // Any decl can be declared with __asm("foo") on it, and this takes precedence

clang/lib/CodeGen/CGHLSLRuntime.h

 #ifndef LLVM_CLANG_LIB_CODEGEN_CGHLSLRUNTIME_H
 #define LLVM_CLANG_LIB_CODEGEN_CGHLSLRUNTIME_H
 
 #include "clang/Basic/HLSLRuntime.h"
 
 namespace llvm {
 class Value;
 class GlobalVariable;
+class Function;
 } // namespace llvm
 namespace clang {
 class CallExpr;
 class Type;
 class VarDecl;
 
+class FunctionDecl;
+
 namespace CodeGen {
 
 class CodeGenModule;
 
 class CGHLSLRuntime {
 protected:
   CodeGenModule &CGM;
   uint32_t ResourceCounters[static_cast<uint32_t>(
       hlsl::ResourceClass::NumClasses)] = {0};
 
 public:
   CGHLSLRuntime(CodeGenModule &CGM) : CGM(CGM) {}
   virtual ~CGHLSLRuntime() {}
 
   void annotateHLSLResource(const VarDecl *D, llvm::GlobalVariable *GV);
 
   void finishCodeGen();
+
+  void setHLSLFnuctionAttributes(llvm::Function *, const FunctionDecl *);
 };
 
 } // namespace CodeGen
 } // namespace clang
 
 #endif

clang/lib/CodeGen/CGHLSLRuntime.cpp

 
 void CGHLSLRuntime::finishCodeGen() {
   auto &TargetOpts = CGM.getTarget().getTargetOpts();
 
   llvm::Module &M = CGM.getModule();
   addDxilValVersion(TargetOpts.DxilValidatorVersion, M);
 }
 
 void CGHLSLRuntime::annotateHLSLResource(const VarDecl *D, GlobalVariable *GV) {
   const Type *Ty = D->getType()->getPointeeOrArrayElementType();
   if (!Ty)
     return;
   const auto *RD = Ty->getAsCXXRecordDecl();
   if (!RD)
     return;
   const auto *Attr = RD->getAttr<HLSLResourceAttr>();
   if (!Attr)
     return;
void CGHLSLRuntime::annotateHLSLResource(const VarDecl *D, GlobalVariable *GV) {
 
   auto &Ctx = CGM.getModule().getContext();
   IRBuilder<> B(Ctx);
   QualType QT(Ty, 0);
   ResourceMD->addOperand(MDNode::get(
       Ctx, {ValueAsMetadata::get(GV), MDString::get(Ctx, QT.getAsString()),
             ConstantAsMetadata::get(B.getInt32(Counter))}));
 }
+
+void clang::CodeGen::CGHLSLRuntime::setHLSLFnuctionAttributes(
+    llvm::Function *F, const FunctionDecl *FD) {
+  if (HLSLShaderAttr *ShaderAttr = FD->getAttr<HLSLShaderAttr>()) {
+    const StringRef ShaderAttrKindStr = "dx.shader";
+    F->addFnAttr(ShaderAttrKindStr,
+                 ShaderAttr->ConvertShaderTypeToStr(ShaderAttr->getType()));
+  }
+}

clang/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::SetLLVMFunctionAttributes(GlobalDecl GD,
                                               const CGFunctionInfo &Info,
                                               llvm::Function *F, bool IsThunk) {
   unsigned CallingConv;
   llvm::AttributeList PAL;
   ConstructAttributeList(F->getName(), Info, GD, PAL, CallingConv,
                          /*AttrOnCallSite=*/false, IsThunk);
   F->setAttributes(PAL);
   F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
+  if (getLangOpts().HLSL) {
+    if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(GD.getDecl()))
+      getHLSLRuntime().setHLSLFnuctionAttributes(F, FD);
+  }
 }
 
 static void removeImageAccessQualifier(std::string& TyName) {
   std::string ReadOnlyQual("__read_only");
   std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);
   if (ReadOnlyPos != std::string::npos)
     // "+ 1" for the space after access qualifier.
     TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);

clang/test/CodeGenHLSL/entry.hlsl

+// RUN: %clang --driver-mode=dxc -Tcs_6_1 -Efoo -fcgl  -Fo - %s | FileCheck %s
+
+// Make sure not mangle entry.
+// CHECK:define void @foo()
+// Make sure add function attribute.
+// CHECK:"dx.shader"="compute"
+[numthreads(1,1,1)]
+void foo() {
+
+}

clang/test/CodeGenHLSL/shader_type_attr.hlsl

+// RUN: %clang --driver-mode=dxc -Tlib_6_x -fcgl -Fo - %s | FileCheck %s
+
+// Make sure not mangle entry.
+// CHECK:define void @foo()
+// Make sure add function attribute.
+// CHECK:"dx.shader"="compute"
+[shader("compute")]
+[numthreads(1,1,1)]
+void foo() {
+
+}