[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

138 ↗

(On Diff #426341)

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

138 ↗

(On Diff #426341)

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

54

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

clang/lib/CodeGen/CGHLSLRuntime.h

39

typo: setHLSLFnuctionAttributes -> setHLSLFunctionAttributes

clang/lib/CodeGen/CodeGenModule.cpp

1654 ↗

(On Diff #431812)

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

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

55

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/Decl.cpp

LanguageLinkage FunctionDecl::getLanguageLinkage() const {
   return getDeclLanguageLinkage(*this);
 }
 
 bool FunctionDecl::isExternC() const {
   return isDeclExternC(*this);
 }
 
 bool FunctionDecl::isInExternCContext() const {
-  if (hasAttr<OpenCLKernelAttr>())
+  if (hasAttr<OpenCLKernelAttr>() || hasAttr<HLSLShaderAttr>())
     return true;
   return getLexicalDeclContext()->isExternCContext();
 }
 
 bool FunctionDecl::isInExternCXXContext() const {
   return getLexicalDeclContext()->isExternCXXContext();
 }
 

clang/lib/CodeGen/CGCall.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "CGCall.h"
 #include "ABIInfo.h"
 #include "CGBlocks.h"
 #include "CGCXXABI.h"
 #include "CGCleanup.h"
+#include "CGHLSLRuntime.h"
 #include "CGRecordLayout.h"
 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
 #include "TargetInfo.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
if (Attrs.hasAttributes()) {
       std::tie(FirstIRArg, NumIRArgs) = IRFunctionArgs.getIRArgs(ArgNo);
       for (unsigned i = 0; i < NumIRArgs; i++)
         ArgAttrs[FirstIRArg + i] = ArgAttrs[FirstIRArg + i].addAttributes(
             getLLVMContext(), llvm::AttributeSet::get(getLLVMContext(), Attrs));
     }
   }
   assert(ArgNo == FI.arg_size());
 
+  if (getLangOpts().HLSL && TargetDecl) {
+    if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl))
+      getHLSLRuntime().addHLSLFunctionAttributes(FuncAttrs, RetAttrs, FD);
+  }
+
   AttrList = llvm::AttributeList::get(
       getLLVMContext(), llvm::AttributeSet::get(getLLVMContext(), FuncAttrs),
       llvm::AttributeSet::get(getLLVMContext(), RetAttrs), ArgAttrs);
 }
 
 /// An argument came in as a promoted argument; demote it back to its
 /// declared type.
 static llvm::Value *emitArgumentDemotion(CodeGenFunction &CGF,

clang/lib/CodeGen/CGHLSLRuntime.h

 // subclasses of this implement code generation for specific HLSL
 // runtime libraries.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_CODEGEN_CGHLSLRUNTIME_H
 #define LLVM_CLANG_LIB_CODEGEN_CGHLSLRUNTIME_H
 
+namespace llvm {
+class AttrBuilder;
+}
 namespace clang {
 
+class FunctionDecl;
+
 namespace CodeGen {
 
 class CodeGenModule;
 
 class CGHLSLRuntime {
 protected:
   CodeGenModule &CGM;
 
 public:
   CGHLSLRuntime(CodeGenModule &CGM) : CGM(CGM) {}
   virtual ~CGHLSLRuntime() {}
 
   void finishCodeGen();
+
+  void addHLSLFunctionAttributes(llvm::AttrBuilder &FuncAttrs,
+                                 llvm::AttrBuilder &RetAttrs,
+                                 const FunctionDecl *);
 };
 
 } // namespace CodeGen
 } // namespace clang
 
 #endif

clang/lib/CodeGen/CGHLSLRuntime.cpp

 } // namespace
 
 void CGHLSLRuntime::finishCodeGen() {
   auto &TargetOpts = CGM.getTarget().getTargetOpts();
 
   llvm::Module &M = CGM.getModule();
   addDxilValVersion(TargetOpts.DxilValidatorVersion, M);
 }
+
+void CGHLSLRuntime::addHLSLFunctionAttributes(llvm::AttrBuilder &FuncAttrs,
+                                              llvm::AttrBuilder &RetAttrs,
+                                              const FunctionDecl *FD) {
+  if (HLSLShaderAttr *ShaderAttr = FD->getAttr<HLSLShaderAttr>()) {
+    const StringRef ShaderAttrKindStr = "dx.shader";
+    FuncAttrs.addAttribute(
+        ShaderAttrKindStr,
+        ShaderAttr->ConvertShaderTypeToStr(ShaderAttr->getType()));
+  }
+}

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() {
+
+}