[HLSL] Add Semantic syntax, and SV_GroupIndex

[beanz]

Summary

HLSL has a language feature called Semantics which get attached to
declarations like attributes and are used in a variety of ways.

One example of semantic use is here with the SV_GroupIndex semantic
which, when applied to an input for a compute shader is pre-populated
by the driver with a flattened thread index.

[MaskRay]

clang/include/clang/Basic/AttrDocs.td

6386

[aaron.ballman]

You should also add parsing test coverage as this is parsing new syntax.

clang/include/clang/Basic/AttrDocs.td

6386

clang/include/clang/Parse/Parser.h

2789–2796

clang/lib/Parse/ParseDecl.cpp

6967–6969

This means the order is very specific -- should this be using MaybeParseAttributes() so that the syntaxes can be intermingled?

This reminds me, I don't see a change to ParseAttrKindMask, but perhaps we want that for both the microsoft and HLSL semantic attributes?

clang/lib/Parse/ParseHLSL.cpp

31–34

I think we should issue a diagnostic about ignoring an unused attribute here.

[beanz]

Will try to update today. Thank you!

clang/lib/Parse/ParseDecl.cpp

6967–6969

This is kinda 6 one way half dozen the other. GNU attribute syntax isn't supported in HLSL, I just haven't gotten around to disabling it yet.

If you have a preferred implementation I'm happy to go whatever way you suggest.

The HLSL language doesn't support Semantics or Microsoft-style attributes in all that many places in code. MS attributes are only used on functions, and semantics are restricted to input/output data (which is a little more complicated than it sounds, but basically is function parameters, returns, global variables and struct members).

clang/lib/Parse/ParseHLSL.cpp

31–34

+1

[aaron.ballman]

clang/lib/Parse/ParseDecl.cpp

6967–6969

Okay, then let's leave this as-is -- we can address it if someone hits an actual pain point.

[beanz]

Updates based on feedback from @aaron.ballman & @MaskRay.

Thank you!

[python3kgae]

clang/lib/Sema/SemaDeclAttr.cpp

6931

It is OK to have SV_GroupIndex on a compute shader entry for library profile.

[aaron.ballman]

General question about the new syntax -- how does this work on field declarations of a record? e.g.,

struct S {
  int i : SV_GroupIndex;
};

(Please tell me the answer is: it doesn't, because bit-fields are a thing.) Similar question applies to other places where a colon can show up. like for (int i : SV_GroupIndex) or class C : SV_GroupIndex.

clang/include/clang/Basic/AttrDocs.td

6386

Minor grammar nit

clang/test/SemaHLSL/Semantics/semantic_parsing.hlsl

7 ↗

(On Diff #419570)

There doesn't appear to be a test for parsing on global variables, you should add one for that.

[beanz]

In D122699#3422298, @aaron.ballman wrote:

General question about the new syntax -- how does this work on field declarations of a record? e.g.,

struct S {
  int i : SV_GroupIndex;
};

(Please tell me the answer is: it doesn't, because bit-fields are a thing.)

Oh @aaron.ballman… you’re such an optimist… Thankfully HLSL does’t support bitfields… or didn’t, until HLSL 2021…

This patch doesn’t add support for the semantic syntax anywhere other than on parameter declarations, which is enough to get us rolling to start. I was hoping to flesh out the rest of the places it is used over time so that we can figure out good ways to handle the bitfield ambiguity…

Similar question applies to other places where a colon can show up. like for (int i : SV_GroupIndex) or class C : SV_GroupIndex.

Thankfully it can’t be used like that! HLSL doesn’t support range-based for, and it wouldn’t be valid in a for loop declaration anyways.

[beanz]

Updating based on feedback from @aaron.ballman

I think this covers all the cases for parsing as a function parameter. I haven't added the code to parse these in structure definitions or globals yet. If it is okay I'd like to do that in a separate patch.

[aaron.ballman]

In D122699#3422347, @beanz wrote:

In D122699#3422298, @aaron.ballman wrote:

General question about the new syntax -- how does this work on field declarations of a record? e.g.,

struct S {
  int i : SV_GroupIndex;
};

(Please tell me the answer is: it doesn't, because bit-fields are a thing.)

Oh @aaron.ballman… you’re such an optimist… Thankfully HLSL does’t support bitfields… or didn’t, until HLSL 2021…

I had a dream that I woke up on Monday and you said "btw, that was an April Fool's joke -- nobody is *that* bad at designing attribute syntax". :: sighs :: we'll cross that bridge when we get to it, I guess.

This patch doesn’t add support for the semantic syntax anywhere other than on parameter declarations, which is enough to get us rolling to start. I was hoping to flesh out the rest of the places it is used over time so that we can figure out good ways to handle the bitfield ambiguity…

Yeah, we can definitely punt on the bit-field ambiguity. Frankly, I expect us to find more such issues. (This extension is nonconforming, so I think when we go to implement this part, we're going to have to be loud about diagnostics because this extension breaks conforming code.)

Mostly just nits at this point, so this is getting pretty close to being ready.

clang/include/clang/Basic/AttrDocs.td

6386

Might have missed this nit.

clang/include/clang/Basic/AttributeCommonInfo.h

47–48

Should this comment now move down a bit?

clang/include/clang/Basic/DiagnosticParseKinds.td

1600

clang/lib/Sema/SemaDeclAttr.cpp

6931

Is there more to be done for this comment?

clang/test/SemaHLSL/Semantics/semantic_parsing.hlsl

4–7 ↗

(On Diff #420376)

This isn't really a Sema test because it's testing parsing behavior -- thoughts on adding ParserHLSL as a test directory (or do you expect so few parsing changes for this that it'd be a waste)?

[beanz]

Thank you! Will update shortly.

clang/include/clang/Basic/AttributeCommonInfo.h

47–48

I'm struggling a bit with what that comment is referring to, and I feel like I'm missing something obvious. If you change the order of any of the cases AS_ContextSensitiveKeyword or earlier in the list, things start breaking. Specifically putting AS_HLSLSemantic above AS_ContextSensitiveKeyword breaks parsing context sensitive keywords...

I'm clearly missing something...

That said, I can add a new case after AS_ContextSensitiveKeyword before AS_HLSLSemantic and it all still works fine.

With my current understanding, I'm not sure moving the comment makes sense, but I could expand the comment. Thoughts?

clang/test/SemaHLSL/Semantics/semantic_parsing.hlsl

4–7 ↗

(On Diff #420376)

Adding a ParserHLSL directory makes sense. I think we'll have enough cases to justify it :).

[aaron.ballman]

clang/include/clang/Basic/AttributeCommonInfo.h

47–48

This is where that comment ultimately came from: https://github.com/llvm/llvm-project/commit/be89f4c5655d01dd44d6c82a4d5e44820a81f404

Based on that, I don't think we need to move the comment after all.

[beanz]

Updates based on feedback from @aaron.ballman.

[aaron.ballman]

LGTM! There's an open question about the circumstances under which we emit the err_hlsl_attr_unsupported_in_stage diagnostic, but if there's code to be changed there, it can be done in a follow up.

clang/include/clang/Basic/Attr.td

 
 // The Clang spelling implies GNU<name>, CXX11<"clang", name>, and optionally,
 // C2x<"clang", name>. This spelling should be used for any Clang-specific
 // attributes.
 class Clang<string name, bit allowInC = 1> : Spelling<name, "Clang"> {
   bit AllowInC = allowInC;
 }
 
+// HLSL Semantic spellings
+class HLSLSemantic<string name> : Spelling<name, "HLSLSemantic">;
+
 class Accessor<string name, list<Spelling> spellings> {
   string Name = name;
   list<Spelling> Spellings = spellings;
 }
 
 class SubjectDiag<bit warn> {
   bit Warn = warn;
 }

 def HLSLNumThreads: InheritableAttr {
   let Spellings = [Microsoft<"numthreads">];
   let Args = [IntArgument<"X">, IntArgument<"Y">, IntArgument<"Z">];
   let Subjects = SubjectList<[HLSLEntry]>;
   let LangOpts = [HLSL];
   let Documentation = [NumThreadsDocs];
 }
 
+def HLSLSV_GroupIndex: InheritableAttr {
+  let Spellings = [HLSLSemantic<"SV_GroupIndex">];
+  let Subjects = SubjectList<[ParmVar, GlobalVar]>;
+  let LangOpts = [HLSL];
+  let Documentation = [HLSLSV_GroupIndexDocs];
+}
+
 def RandomizeLayout : InheritableAttr {
   let Spellings = [GCC<"randomize_layout">];
   let Subjects = SubjectList<[Record]>;
   let Documentation = [ClangRandomizeLayoutDocs];
   let LangOpts = [COnly];
 }
 
 def NoRandomizeLayout : InheritableAttr {
   let Spellings = [GCC<"no_randomize_layout">];
   let Subjects = SubjectList<[Record]>;
   let Documentation = [ClangRandomizeLayoutDocs];
   let LangOpts = [COnly];
 }
 def : MutualExclusions<[RandomizeLayout, NoRandomizeLayout]>;

clang/include/clang/Basic/AttrDocs.td

 
 The full documentation is available here: https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sm5-attributes-numthreads
   }];
 }
 
 def ClangRandomizeLayoutDocs : Documentation {
   let Category = DocCatDecl;
   let Heading = "randomize_layout, no_randomize_layout";
   let Content = [{
 The attribute ``randomize_layout``, when attached to a C structure, selects it
 for structure layout field randomization; a compile-time hardening technique. A
 "seed" value, is specified via the ``-frandomize-layout-seed=`` command line flag.
 For example:
 
 .. code-block:: bash
 
   SEED=`od -A n -t x8 -N 32 /dev/urandom | tr -d ' \n'`

 program should be compiled with the same seed, but keep the seed safe
 otherwise.
 
 The attribute ``no_randomize_layout``, when attached to a C structure,
 instructs the compiler that this structure should not have its field layout
 randomized.
   }];
 }
+
+def HLSLSV_GroupIndexDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+The ``SV_GroupIndex`` semantic, when applied to an input parameter, specifies a
+data binding to map the group index to the specified parameter. This attribute
+is only supported in compute shaders.
+
+The full documentation is available here: https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sv-groupindex
+  }];
+}

clang/include/clang/Basic/AttributeCommonInfo.h

enum Syntax {
     AS_Microsoft,
 
     /// __ptr16, alignas(...), etc.
     AS_Keyword,
 
     /// #pragma ...
     AS_Pragma,
 
     // Note TableGen depends on the order above.  Do not add or change the order
     // without adding related code to TableGen/ClangAttrEmitter.cpp.
     /// Context-sensitive version of a keyword attribute.
     AS_ContextSensitiveKeyword,
+
+    /// <vardecl> : <semantic>
+    AS_HLSLSemantic,
   };
   enum Kind {
 #define PARSED_ATTR(NAME) AT_##NAME,
 #include "clang/Sema/AttrParsedAttrList.inc"
 #undef PARSED_ATTR
     NoSemaHandlerAttribute,
     IgnoredAttribute,
     UnknownAttribute,

clang/include/clang/Basic/Attributes.h

enum class AttrSyntax {
   Declspec,
   /// Is the identifier known as a [] Microsoft-style attribute?
   Microsoft,
   // Is the identifier known as a C++-style attribute?
   CXX,
   // Is the identifier known as a C-style attribute?
   C,
   // Is the identifier known as a pragma attribute?
-  Pragma
+  Pragma,
+  // Is the identifier known as a HLSL semantic?
+  HLSLSemantic,
 };
 
 /// Return the version number associated with the attribute if we
 /// recognize and implement the attribute specified by the given information.
 int hasAttribute(AttrSyntax Syntax, const IdentifierInfo *Scope,
                  const IdentifierInfo *Attr, const TargetInfo &Target,
                  const LangOptions &LangOpts);
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_ATTRIBUTES_H

clang/include/clang/Basic/DiagnosticParseKinds.td

def warn_max_tokens : Warning<
   InGroup<MaxTokens>, DefaultIgnore;
 
 def warn_max_tokens_total : Warning<
   "the total number of preprocessor source tokens (%0) exceeds the token limit (%1)">,
   InGroup<MaxTokens>, DefaultIgnore;
 
 def note_max_tokens_total_override : Note<"total token limit set here">;
 
+// HLSL Parser Diagnostics
+
+def err_expected_semantic_identifier : Error<
+  "expected HLSL Semantic identifier">;
+def err_unknown_hlsl_semantic : Error<"unknown HLSL semantic %0">;
+
 } // end of Parser diagnostics

clang/include/clang/Parse/Parser.h

bool ParseCXX11AttributeArgs(IdentifierInfo *AttrName,
                                SourceLocation ScopeLoc,
                                CachedTokens &OpenMPTokens);
 
   IdentifierInfo *TryParseCXX11AttributeIdentifier(
       SourceLocation &Loc,
       Sema::AttributeCompletion Completion = Sema::AttributeCompletion::None,
       const IdentifierInfo *EnclosingScope = nullptr);
 
+  void MaybeParseHLSLSemantics(ParsedAttributes &Attrs,
+                               SourceLocation *EndLoc = nullptr) {
+    if (getLangOpts().HLSL && Tok.is(tok::colon))
+      ParseHLSLSemantics(Attrs, EndLoc);
+  }
+
+  void ParseHLSLSemantics(ParsedAttributes &Attrs,
+                          SourceLocation *EndLoc = nullptr);
+
   void MaybeParseMicrosoftAttributes(ParsedAttributes &Attrs) {
     if ((getLangOpts().MicrosoftExt || getLangOpts().HLSL) &&
         Tok.is(tok::l_square)) {
       ParsedAttributes AttrsWithRange(AttrFactory);
       ParseMicrosoftAttributes(AttrsWithRange);
       Attrs.takeAllFrom(AttrsWithRange);
     }
   }

clang/lib/Parse/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   MC
   MCParser
   Support
   )
 
 add_clang_library(clangParse
   ParseAST.cpp
   ParseCXXInlineMethods.cpp
   ParseDecl.cpp
   ParseDeclCXX.cpp
   ParseExpr.cpp
   ParseExprCXX.cpp
+  ParseHLSL.cpp
   ParseInit.cpp
   ParseObjc.cpp
   ParseOpenMP.cpp
   ParsePragma.cpp
   ParseStmt.cpp
   ParseStmtAsm.cpp
   ParseTemplate.cpp
   ParseTentative.cpp

clang/lib/Parse/ParseDecl.cpp

Declarator ParmDeclarator(
         DS, DeclaratorCtx == DeclaratorContext::RequiresExpr
                 ? DeclaratorContext::RequiresExpr
                 : DeclaratorCtx == DeclaratorContext::LambdaExpr
                       ? DeclaratorContext::LambdaExprParameter
                       : DeclaratorContext::Prototype);
     ParseDeclarator(ParmDeclarator);
 
     // Parse GNU attributes, if present.
     MaybeParseGNUAttributes(ParmDeclarator);
+    MaybeParseHLSLSemantics(DS.getAttributes());
 
     if (Tok.is(tok::kw_requires)) {
       // User tried to define a requires clause in a parameter declaration,
       // which is surely not a function declaration.
       // void f(int (*g)(int, int) requires true);
       Diag(Tok,
            diag::err_requires_clause_on_declarator_not_declaring_a_function);
       ConsumeToken();
       Actions.CorrectDelayedTyposInExpr(

clang/lib/Parse/ParseHLSL.cpp

+//===--- ParseHLSL.cpp - HLSL-specific parsing support --------------------===//
+//
+// 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 parsing logic for HLSL language features.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/AttributeCommonInfo.h"
+#include "clang/Parse/ParseDiagnostic.h"
+#include "clang/Parse/Parser.h"
+
+using namespace clang;
+
+void Parser::ParseHLSLSemantics(ParsedAttributes &Attrs,
+                                SourceLocation *EndLoc) {
+  assert(Tok.is(tok::colon) && "Not a HLSL Semantic");
+  ConsumeToken();
+
+  if (!Tok.is(tok::identifier)) {
+    Diag(Tok.getLocation(), diag::err_expected_semantic_identifier);
+    return;
+  }
+
+  IdentifierInfo *II = Tok.getIdentifierInfo();
+  SourceLocation Loc = ConsumeToken();
+  if (EndLoc)
+    *EndLoc = Tok.getLocation();
+  ParsedAttr::Kind AttrKind =
+      ParsedAttr::getParsedKind(II, nullptr, ParsedAttr::AS_HLSLSemantic);
+
+  if (AttrKind == ParsedAttr::UnknownAttribute) {
+    Diag(Loc, diag::err_unknown_hlsl_semantic) << II;
+    return;
+  }
+  Attrs.addNew(II, Loc, nullptr, SourceLocation(), nullptr, 0,
+               ParsedAttr::AS_HLSLSemantic);
+}

clang/lib/Sema/SemaDeclAttr.cpp

if (NT->getX() != X || NT->getY() != Y || NT->getZ() != Z) {
       Diag(NT->getLocation(), diag::err_hlsl_attribute_param_mismatch) << AL;
       Diag(AL.getLoc(), diag::note_conflicting_attribute);
     }
     return nullptr;
   }
   return ::new (Context) HLSLNumThreadsAttr(Context, AL, X, Y, Z);
 }
 
+static void handleHLSLSVGroupIndexAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  using llvm::Triple;
+  Triple Target = S.Context.getTargetInfo().getTriple();
+  if (Target.getEnvironment() != Triple::Compute) {
+    uint32_t Pipeline =
+        (uint32_t)S.Context.getTargetInfo().getTriple().getEnvironment() -
+        (uint32_t)llvm::Triple::Pixel;
+    S.Diag(AL.getLoc(), diag::err_hlsl_attr_unsupported_in_stage)
+        << AL << Pipeline << "Compute";
+    return;
+  }
+
+  D->addAttr(::new (S.Context) HLSLSV_GroupIndexAttr(S.Context, AL));
+}
+
 static void handleMSInheritanceAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (!S.LangOpts.CPlusPlus) {
     S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
         << AL << AttributeLangSupport::C;
     return;
   }
   MSInheritanceAttr *IA = S.mergeMSInheritanceAttr(
       D, AL, /*BestCase=*/true, (MSInheritanceModel)AL.getSemanticSpelling());
static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   case ParsedAttr::AT_Thread:
     handleDeclspecThreadAttr(S, D, AL);
     break;
   
   // HLSL attributes:
   case ParsedAttr::AT_HLSLNumThreads:
     handleHLSLNumThreadsAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_HLSLSV_GroupIndex:
+    handleHLSLSVGroupIndexAttr(S, D, AL);
+    break;
 
   case ParsedAttr::AT_AbiTag:
     handleAbiTagAttr(S, D, AL);
     break;
   case ParsedAttr::AT_CFGuard:
     handleCFGuardAttr(S, D, AL);
     break;
 

clang/test/ParserHLSL/lit.local.cfg

+config.suffixes = ['.hlsl']

clang/test/ParserHLSL/semantic_parsing.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-compute -x hlsl -ast-dump -o - %s -verify
+
+// expected-error@+1 {{expected HLSL Semantic identifier}}
+void Entry(int GI : ) { }
+
+// expected-error@+1 {{unknown HLSL semantic 'SV_IWantAPony'}}
+void Pony(int GI : SV_IWantAPony) { }

clang/test/SemaHLSL/Semantics/entry_parameter.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-compute -x hlsl -ast-dump -o - %s | FileCheck %s 
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-mesh -x hlsl -ast-dump -verify -o - %s 
+
+[numthreads(8,8, 1)]
+// expected-error@+1 {{attribute 'SV_GroupIndex' is unsupported in Mesh shaders, requires Compute}}
+void CSMain(int GI : SV_GroupIndex) {
+// CHECK: FunctionDecl 0x{{[0-9a-fA-F]+}} <{{.*}}> line:[[@LINE-1]]:6 CSMain 'void (int)'
+// CHECK-NEXT: ParmVarDecl 0x{{[0-9a-fA-F]+}} <{{.*}}> col:17 GI 'int'
+// CHECK-NEXT: HLSLSV_GroupIndexAttr
+}

clang/utils/TableGen/ClangAttrEmitter.cpp

for (unsigned I = 0; I < Spellings.size(); ++ I) {
     } else if (Variety == "Pragma") {
       Prefix = "#pragma ";
       Suffix = "\n";
       std::string Namespace = Spellings[I].nameSpace();
       if (!Namespace.empty()) {
         Spelling += Namespace;
         Spelling += " ";
       }
+    } else if (Variety == "HLSLSemantic") {
+      Prefix = ":";
+      Suffix = "";
     } else {
       llvm_unreachable("Unknown attribute syntax variety!");
     }
 
     Spelling += Name;
 
     OS << "  case " << I << " : {\n"
        << "    OS << \"" << Prefix << Spelling << "\";\n";

 
 // Emits the list of spellings for attributes.
 void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Code to implement the __has_attribute logic", OS);
 
   // Separate all of the attributes out into four group: generic, C++11, GNU,
   // and declspecs. Then generate a big switch statement for each of them.
   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
-  std::vector<Record *> Declspec, Microsoft, GNU, Pragma;
+  std::vector<Record *> Declspec, Microsoft, GNU, Pragma, HLSLSemantic;
   std::map<std::string, std::vector<Record *>> CXX, C2x;
 
   // Walk over the list of all attributes, and split them out based on the
   // spelling variety.
   for (auto *R : Attrs) {
     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
     for (const auto &SI : Spellings) {
       const std::string &Variety = SI.variety();
       if (Variety == "GNU")
         GNU.push_back(R);
       else if (Variety == "Declspec")
         Declspec.push_back(R);
       else if (Variety == "Microsoft")
         Microsoft.push_back(R);
       else if (Variety == "CXX11")
         CXX[SI.nameSpace()].push_back(R);
       else if (Variety == "C2x")
         C2x[SI.nameSpace()].push_back(R);
       else if (Variety == "Pragma")
         Pragma.push_back(R);
+      else if (Variety == "HLSLSemantic")
+        HLSLSemantic.push_back(R);
     }
   }
 
   OS << "const llvm::Triple &T = Target.getTriple();\n";
   OS << "switch (Syntax) {\n";
   OS << "case AttrSyntax::GNU:\n";
   OS << "  return llvm::StringSwitch<int>(Name)\n";
   GenerateHasAttrSpellingStringSwitch(GNU, OS, "GNU");
   OS << "case AttrSyntax::Declspec:\n";
   OS << "  return llvm::StringSwitch<int>(Name)\n";
   GenerateHasAttrSpellingStringSwitch(Declspec, OS, "Declspec");
   OS << "case AttrSyntax::Microsoft:\n";
   OS << "  return llvm::StringSwitch<int>(Name)\n";
   GenerateHasAttrSpellingStringSwitch(Microsoft, OS, "Microsoft");
   OS << "case AttrSyntax::Pragma:\n";
   OS << "  return llvm::StringSwitch<int>(Name)\n";
   GenerateHasAttrSpellingStringSwitch(Pragma, OS, "Pragma");
+  OS << "case AttrSyntax::HLSLSemantic:\n";
+  OS << "  return llvm::StringSwitch<int>(Name)\n";
+  GenerateHasAttrSpellingStringSwitch(HLSLSemantic, OS, "HLSLSemantic");
   auto fn = [&OS](const char *Spelling, const char *Variety,
                   const std::map<std::string, std::vector<Record *>> &List) {
     OS << "case AttrSyntax::" << Variety << ": {\n";
     // C++11-style attributes are further split out based on the Scope.
     for (auto I = List.cbegin(), E = List.cend(); I != E; ++I) {
       if (I != List.cbegin())
         OS << " else ";
       if (I->first.empty())

 }
 
 // Emits the kind list of parsed attributes
 void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Attribute name matcher", OS);
 
   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
   std::vector<StringMatcher::StringPair> GNU, Declspec, Microsoft, CXX11,
-      Keywords, Pragma, C2x;
+      Keywords, Pragma, C2x, HLSLSemantic;
   std::set<std::string> Seen;
   for (const auto *A : Attrs) {
     const Record &Attr = *A;
 
     bool SemaHandler = Attr.getValueAsBit("SemaHandler");
     bool Ignored = Attr.getValueAsBit("Ignored");
     if (SemaHandler || Ignored) {
       // Attribute spellings can be shared between target-specific attributes,
if (SemaHandler || Ignored) {
         else if (Variety == "Declspec")
           Matches = &Declspec;
         else if (Variety == "Microsoft")
           Matches = &Microsoft;
         else if (Variety == "Keyword")
           Matches = &Keywords;
         else if (Variety == "Pragma")
           Matches = &Pragma;
+        else if (Variety == "HLSLSemantic")
+          Matches = &HLSLSemantic;
 
         assert(Matches && "Unsupported spelling variety found");
 
         if (Variety == "GNU")
           Spelling += NormalizeGNUAttrSpelling(RawSpelling);
         else
           Spelling += RawSpelling;
 
void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
   StringMatcher("Name", CXX11, OS).Emit();
   OS << "  } else if (AttributeCommonInfo::AS_C2x == Syntax) {\n";
   StringMatcher("Name", C2x, OS).Emit();
   OS << "  } else if (AttributeCommonInfo::AS_Keyword == Syntax || ";
   OS << "AttributeCommonInfo::AS_ContextSensitiveKeyword == Syntax) {\n";
   StringMatcher("Name", Keywords, OS).Emit();
   OS << "  } else if (AttributeCommonInfo::AS_Pragma == Syntax) {\n";
   StringMatcher("Name", Pragma, OS).Emit();
+  OS << "  } else if (AttributeCommonInfo::AS_HLSLSemantic == Syntax) {\n";
+  StringMatcher("Name", HLSLSemantic, OS).Emit();
   OS << "  }\n";
   OS << "  return AttributeCommonInfo::UnknownAttribute;\n"
      << "}\n";
 }
 
 // Emits the code to dump an attribute.
 void EmitClangAttrTextNodeDump(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Attribute text node dumper", OS);
for (const auto *A : Attrs) {
     // (Currently there's only one such attr, revisit if this becomes common).
     StringRef Text =
         Docs.front()->getValueAsOptionalString("Content").getValueOr("");
     OS << "\nstatic const char AttrDoc_" << A->getName() << "[] = "
        << "R\"reST(" << Text.trim() << ")reST\";\n";
   }
 }
 
-enum class SpellingKind {
+enum class SpellingKind : size_t {
   GNU,
   CXX11,
   C2x,
   Declspec,
   Microsoft,
   Keyword,
   Pragma,
+  HLSLSemantic,
+  NumSpellingKinds
 };
-static const size_t NumSpellingKinds = (size_t)SpellingKind::Pragma + 1;
+static const size_t NumSpellingKinds = (size_t)SpellingKind::NumSpellingKinds;
 
 class SpellingList {
   std::vector<std::string> Spellings[NumSpellingKinds];
 
 public:
   ArrayRef<std::string> operator[](SpellingKind K) const {
     return Spellings[(size_t)K];
   }
 
   void add(const Record &Attr, FlattenedSpelling Spelling) {
     SpellingKind Kind = StringSwitch<SpellingKind>(Spelling.variety())
                             .Case("GNU", SpellingKind::GNU)
                             .Case("CXX11", SpellingKind::CXX11)
                             .Case("C2x", SpellingKind::C2x)
                             .Case("Declspec", SpellingKind::Declspec)
                             .Case("Microsoft", SpellingKind::Microsoft)
                             .Case("Keyword", SpellingKind::Keyword)
-                            .Case("Pragma", SpellingKind::Pragma);
+                            .Case("Pragma", SpellingKind::Pragma)
+                            .Case("HLSLSemantic", SpellingKind::HLSLSemantic);
     std::string Name;
     if (!Spelling.nameSpace().empty()) {
       switch (Kind) {
       case SpellingKind::CXX11:
       case SpellingKind::C2x:
         Name = Spelling.nameSpace() + "::";
         break;
       case SpellingKind::Pragma:

 
 static void WriteDocumentation(RecordKeeper &Records,
                                const DocumentationData &Doc, raw_ostream &OS) {
   OS << Doc.Heading << "\n" << std::string(Doc.Heading.length(), '-') << "\n";
 
   // List what spelling syntaxes the attribute supports.
   OS << ".. csv-table:: Supported Syntaxes\n";
   OS << "   :header: \"GNU\", \"C++11\", \"C2x\", \"``__declspec``\",";
-  OS << " \"Keyword\", \"``#pragma``\", \"``#pragma clang attribute``\"\n\n";
-  OS << "   \"";
+  OS << " \"Keyword\", \"``#pragma``\", \"``#pragma clang attribute``\",";
+  OS << " \"HLSL Semantic\"\n\n   \"";
   for (size_t Kind = 0; Kind != NumSpellingKinds; ++Kind) {
     SpellingKind K = (SpellingKind)Kind;
     // TODO: List Microsoft (IDL-style attribute) spellings once we fully
     // support them.
     if (K == SpellingKind::Microsoft)
       continue;
 
     bool PrintedAny = false;