[HLSL] Add resource binding attribute for HLSL.

[python3kgae]

Summary

The resource binding attribute is to set the virtual registers and logical register spaces resources in HLSL are bound to.
Format is ''register(ID, space)'' like register(t3, space1).
ID must be start with
t – for shader resource views (SRV),
s – for samplers,
u – for unordered access views (UAV),
b – for constant buffer views (CBV).

Register space is default to space0.

The full documentation is available here: https://docs.microsoft.com/en-us/windows/win32/direct3d12/resource-binding-in-hlsl

[beanz]

I have some nitpick comments about the wording of the errors and docs, but the bigger meta issue is that you've implemented this parsing entirely from scratch, and I suspect this should be sharing parsing logic with the generic semantic parser.

I know the parameters themselves have special parsing behavior, but it seems to me that we could parse this as a normal attribute and verify the arguments post attribute parsing.

clang/include/clang/Basic/Attr.td

4054

ID seems like the wrong name here as it doesn't really convey the meaning of the value. Maybe register or slot?

clang/include/clang/Basic/AttrDocs.td

6596

6597

6598

6604

clang/include/clang/Basic/DiagnosticParseKinds.td

1622

1623

1624

clang/include/clang/Parse/Parser.h

2821 ↗

(On Diff #445588)

I don't think this should be fully separate from parsing other HLSL semantics.

clang/lib/Parse/ParseHLSL.cpp

205

register isn't a kw.

[python3kgae]

Move resource binding attribute validation to Sema.

[python3kgae]

Treat resource binding as "HLSLSemantic".

[aaron.ballman]

clang/include/clang/Basic/Attr.td

150

This string literal looks suspiciously wrong to me. This is the text that shows up in a diagnostic message, so it's important to get it correct; so it seems like there's missing test coverage for the attribute.

4051

Do you really intend Slot to be optional?

clang/include/clang/Basic/AttrDocs.td

6597

This documentation says slot is mandatory, hence the question above about the argument.

6608

I think it would help to have a working example here that shows both slot without space and slot with space.

clang/include/clang/Basic/DiagnosticParseKinds.td

1622

Unintended whitespace change.

clang/include/clang/Basic/DiagnosticSemaKinds.td

11669

This diagnostic is not necessary; the common attribute handler already covers this. You're missing test coverage to verify that though.

11670

Will a user be able to determine how to fix the issue from this? Mostly, will it be clear what the "resource class specifier" is that they have incorrect? Perhaps it would help to say invalid resource class specifier '%0' used; expected 'b', 's', 't', or 'u'?

11672–11673

I don't know what the difference is between these two diagnostics; they seem to be the same situation. Also 'spaceX' looks like syntax the user wrote, but it's hardcoded in the diagnostic. Can these be replaced with invalid space specifier '%0' used; expected 'space' followed by an integer or something along those lines?

(Do we want to be kind and give users a fix-it for something like space 10 that removes the whitespace and recovers by pretending the user wrote space10 instead? Similar question about whitespace for register type.)

clang/include/clang/Parse/Parser.h

2821 ↗

(On Diff #451282)

Spurious whitespace change that can be backed out.

clang/lib/Parse/ParseHLSL.cpp

223–224

This seems like a situation we should be asserting, right?

clang/lib/Sema/SemaDeclAttr.cpp

6952–6955

This code should not be necessary as the common handler should take care of it for you.

6962

This diagnostic is wrong, it should be firing: S.Diag(AL.getLoc(), diag::err_attribute_argument_type) << AL << AANT_ArgumentIdentifier;

Note, you are using ArgLoc but it's not initialized to a valid source location.

6974

Again, this is the wrong diagnostic here and it also uses an uninitialized source location.

6982

How do we get into this situation if the slot is mandatory?

7002

???

7022

Any reason not to do that now?

[python3kgae]

Remove optional flag for Slot.
Update error messages and doc.
Add test for empty resource attribute and space only resource attribute.

clang/include/clang/Basic/Attr.td

4051

Good catch.

clang/include/clang/Basic/DiagnosticSemaKinds.td

11672–11673

Removed err_hlsl_unsupported_space_number.
The priority to add fix-it is very low compared to other things we need to add.

clang/lib/Sema/SemaDeclAttr.cpp

6982

It should not.
Fixed.

7022

Resource types like sampler/texture are ready yet.

[python3kgae]

Add fixit for case like space 1.

[aaron.ballman]

clang/include/clang/Basic/AttrDocs.td

6609–6610

These aren't really fully examples of how to use this properly. Can you add an actual example (it doesn't have to do anything particularly useful, the goal is largely to show off how a user would use this attribute)?

clang/lib/Parse/ParseHLSL.cpp

150–151

Any reason not to use ExpectAndConsume(tok::identifier, diag::err_expected) here instead?

176

Do we really mean insensitive here? (See comment below.)

clang/lib/Sema/SemaDeclAttr.cpp

6955–6965

7005

I'm surprised we want to be case insensitive here; we don't document that we are, but also, we're not case insensitive with the slot letters so it seems inconsistent. Is this part of the HLSL requirements?

(Note, I have no problems with doing a case insensitive check if the case sensitive check fails so we can give a better warning + fixit, if you thought that was useful.)

[python3kgae]

Limit to lower case.

[python3kgae]

clang/lib/Parse/ParseHLSL.cpp

150–151

Need to save the identifier string and loc for later use.
And the consume is done in ParseIdentifierLoc.

clang/lib/Sema/SemaDeclAttr.cpp

7005

Discussed with the team, we'll limit to lower case now.
If need for case insensitive for back-compat in the future, it is easy to enable it.

[aaron.ballman]

clang/include/clang/Basic/AttrDocs.td

6609–6610

Two things:

• The example doesn't use valid RST, it should look more like what's done on AttrDocs:649 (using .. code-block:: c++)
• I think the example is missing semicolons at the end of the declarations?

clang/lib/Parse/ParseHLSL.cpp

150–151

Ah, that's a good reason, thanks!

clang/lib/Sema/SemaDecl.cpp

2893–2894 ↗

(On Diff #452232)

I don't see any tests covering this code path. How do you get such a redeclaration in HLSL?

clang/test/SemaHLSL/resource_binding_attr_error.hlsl

16

Isn't this a re-definition of a which would cause an error?

[python3kgae]

Remove mergeHLSLResourceBindingAttr since should not be able to set ResourceBinding more than once.

[python3kgae]

clang/lib/Sema/SemaDecl.cpp

2893–2894 ↗

(On Diff #452232)

It should not.
I'll remove this code.

clang/test/SemaHLSL/resource_binding_attr_error.hlsl

16

The name for cbuffer is not used.
And no error should be reported for re-definition.

Discussed with the team, have to keep it like this for back-compat reason.

[aaron.ballman]

LGTM, only nits left that can be fixed when landing (no need for additional review).

clang/include/clang/Basic/AttrDocs.td

6609–6612

RST is very picky about that whitespace.

clang/test/SemaHLSL/resource_binding_attr_error.hlsl

16

Wow.

Please either add a comment explaining why this bizarre situation gets no diagnostic, or change the identifiers used so nobody else gets confused by this when reading the test file.

[beanz]

clang/test/SemaHLSL/resource_binding_attr_error.hlsl

16

cbuffer is really weird (and hopefully someday will disappear entirely). From a language perspective it behaves almost more like a named anonymous namespace than a datatype (yea, I know that sentence makes no sense).

The functionality that it provides is the ability to group a set of global constant variables so that the CPU-code can pack and provide those constants in known clumps.

One might ask why have them named at all? Which is a fair question... The names do get exposed via the CPU-side reflection API which supports querying bindings and the like. We _probably_ shouldn't have ever allowed duplicate names, but as long as they have unique "slot" bindings the names don't really matter.

cbuffers are important because we try to strip unused resources from shaders (because resource binding costs time). A cbuffer can either be striped entirely or not at all, which prevents individual binding elements from being stripped and simplifies shader calling code so the caller doesn't need to condition binding every individual resource element.

We have newer structures in the language which can handle all of the use cases for cbuffer, however there are still some cases (particularly targeting older versions of windows), where cbuffer is still the dominant technique.

[python3kgae]

Fix format in AttrDocs.td and avoid name conflict in test.

[python3kgae]

clang/test/SemaHLSL/resource_binding_attr_error.hlsl

16

Changed the names to avoid confusion.
More comment is added to https://reviews.llvm.org/D129883

[aaron.ballman]

LGTM!

[python3kgae]

Rebase

[python3kgae]

Add Issue link for FIXME.

clang/include/clang/Basic/Attr.td

def FunctionTmpl
     : SubsetSubject<Function, [{S->getTemplatedKind() ==
                                  FunctionDecl::TK_FunctionTemplate}],
                     "function templates">;
 
 def HLSLEntry
     : SubsetSubject<Function,
                     [{S->isExternallyVisible() && !isa<CXXMethodDecl>(S)}],
                     "global functions">;
+def HLSLBufferObj : SubsetSubject<HLSLBuffer,
+                    [{isa<HLSLBufferDecl>(S)}],
+                    "cbuffer/tbuffer">;
 
 def ClassTmpl : SubsetSubject<CXXRecord, [{S->getDescribedClassTemplate()}],
                               "class templates">;
 
 // FIXME: this hack is needed because DeclNodes.td defines the base Decl node
 // type to be a class, not a definition. This makes it impossible to create an
 // attribute subject which accepts a Decl. Normally, this is not a problem,
 // because the attribute can have no Subjects clause to accomplish this. But in

 
 def HLSLSV_GroupIndex: HLSLAnnotationAttr {
   let Spellings = [HLSLSemantic<"SV_GroupIndex">];
   let Subjects = SubjectList<[ParmVar, GlobalVar]>;
   let LangOpts = [HLSL];
   let Documentation = [HLSLSV_GroupIndexDocs];
 }
 
+def HLSLResourceBinding: InheritableAttr {
+  let Spellings = [HLSLSemantic<"register">];
+  let Subjects = SubjectList<[HLSLBufferObj, GlobalVar]>;
+  let LangOpts = [HLSL];
+  let Args = [StringArgument<"Slot">, StringArgument<"Space", 1>];
+  let Documentation = [HLSLResourceBindingDocs];
+}
+
 def HLSLShader : InheritableAttr {
   let Spellings = [Microsoft<"shader">];
   let Subjects = SubjectList<[HLSLEntry]>;
   let LangOpts = [HLSL];
   // NOTE:
   // order for the enum should match order in llvm::Triple::EnvironmentType.
   // ShaderType will be converted to llvm::Triple::EnvironmentType like
   //   (llvm::Triple::EnvironmentType)((uint32_t)ShaderType +

clang/include/clang/Basic/AttrDocs.td

 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
   }];
 }
 
+def HLSLResourceBindingDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+The resource binding attribute sets the virtual register and logical register space for a resource.
+Attribute spelling in HLSL is: ``register(slot [, space])``.
+``slot`` takes the format ``[type][number]``,
+where ``type`` is a single character specifying the resource type and ``number`` is the virtual register number.
+
+Register types are:
+t for shader resource views (SRV),
+s for samplers,
+u for unordered access views (UAV),
+b for constant buffer views (CBV).
+
+Register space is specified in the format ``space[number]`` and defaults to ``space0`` if omitted.
+Here're resource binding examples with and without space:
+.. code-block:: c++
+
+  RWBuffer<float> Uav : register(u3, space1);
+  Buffer<float> Buf : register(t1);
+
+The full documentation is available here: https://docs.microsoft.com/en-us/windows/win32/direct3d12/resource-binding-in-hlsl
+  }];
+}
+
 def AnnotateTypeDocs : Documentation {
   let Category = DocCatType;
   let Heading = "annotate_type";
   let Content = [{
 This attribute is used to add annotations to types, typically for use by static
 analysis tools that are not integrated into the core Clang compiler (e.g.,
 Clang-Tidy checks or out-of-tree Clang-based tools). It is a counterpart to the
 `annotate` attribute, which serves the same purpose, but for declarations.

clang/include/clang/Basic/DiagnosticParseKinds.td

 
 // HLSL Parser Diagnostics
 
 def err_expected_semantic_identifier : Error<
   "expected HLSL Semantic identifier">;
 def err_invalid_declaration_in_hlsl_buffer : Error<
   "invalid declaration inside %select{tbuffer|cbuffer}0">;
 def err_unknown_hlsl_semantic : Error<"unknown HLSL semantic %0">;
+def err_hlsl_separate_attr_arg_and_number : Error<"wrong argument format for hlsl attribute, use %0 instead">;
 def ext_hlsl_access_specifiers : ExtWarn<
   "access specifiers are a clang HLSL extension">,
   InGroup<HLSLExtension>;
 
 } // end of Parser diagnostics

clang/include/clang/Basic/DiagnosticSemaKinds.td

 
 // HLSL Diagnostics
 def err_hlsl_attr_unsupported_in_stage : Error<"attribute %0 is unsupported in %select{Pixel|Vertex|Geometry|Hull|Domain|Compute|Library|RayGeneration|Intersection|AnyHit|ClosestHit|Miss|Callable|Mesh|Amplification|Invalid}1 shaders, requires %2">;
 
 def err_hlsl_numthreads_argument_oor : Error<"argument '%select{X|Y|Z}0' to numthreads attribute cannot exceed %1">;
 def err_hlsl_numthreads_invalid : Error<"total number of threads cannot exceed %0">;
 def err_hlsl_missing_numthreads : Error<"missing numthreads attribute for %0 shader entry">;
 def err_hlsl_attribute_param_mismatch : Error<"%0 attribute parameters do not match the previous declaration">;
 def err_hlsl_missing_semantic_annotation : Error<
   "semantic annotations must be present for all parameters of an entry "
   "function or patch constant function">;
 def err_hlsl_init_priority_unsupported : Error<
   "initializer priorities are not supported in HLSL">;
 
+def err_hlsl_unsupported_register_type : Error<"invalid resource class specifier '%0' used; expected 'b', 's', 't', or 'u'">;
+def err_hlsl_unsupported_register_number : Error<"register number should be an integer">;
+def err_hlsl_expected_space : Error<"invalid space specifier '%0' used; expected 'space' followed by an integer, like space1">;
 def err_hlsl_pointers_unsupported : Error<
   "%select{pointers|references}0 are unsupported in HLSL">;
 
 def err_hlsl_operator_unsupported : Error<
   "the '%select{&|*|->}0' operator is unsupported in HLSL">;
 
 // Layout randomization diagnostics.
 def err_non_designated_init_used : Error<
   "a randomized struct can only be initialized with a designated initializer">;
 def err_cast_from_randomized_struct : Error<
   "casting from randomized structure pointer type %0 to %1">;
 } // end of sema component.

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/AST/Attr.h"
 #include "clang/Basic/AttributeCommonInfo.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 
 using namespace clang;
 
 static bool validateDeclsInsideHLSLBuffer(Parser::DeclGroupPtrTy DG,
Decl *Parser::ParseHLSLBuffer(SourceLocation &DeclEnd) {
   if (!Tok.is(tok::identifier)) {
     Diag(Tok, diag::err_expected) << tok::identifier;
     return nullptr;
   }
 
   IdentifierInfo *Identifier = Tok.getIdentifierInfo();
   SourceLocation IdentifierLoc = ConsumeToken();
 
+  ParsedAttributes Attrs(AttrFactory);
+  MaybeParseHLSLSemantics(Attrs, nullptr);
+
   ParseScope BufferScope(this, Scope::DeclScope);
   BalancedDelimiterTracker T(*this, tok::l_brace);
   if (T.consumeOpen()) {
     Diag(Tok, diag::err_expected) << tok::l_brace;
     return nullptr;
   }
 
   Decl *D = Actions.ActOnStartHLSLBuffer(getCurScope(), IsCBuffer, BufferLoc,
                                          Identifier, IdentifierLoc,
                                          T.getOpenLocation());
 
-  // FIXME: support attribute on cbuffer/tbuffer.
   while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
     // FIXME: support attribute on constants inside cbuffer/tbuffer.
     ParsedAttributes Attrs(AttrFactory);
 
     DeclGroupPtrTy Result = ParseExternalDeclaration(Attrs);
     if (!validateDeclsInsideHLSLBuffer(Result, IdentifierLoc, IsCBuffer,
                                        *this)) {
       T.skipToEnd();
       DeclEnd = T.getCloseLocation();
       BufferScope.Exit();
       Actions.ActOnFinishHLSLBuffer(D, DeclEnd);
       return nullptr;
     }
   }
 
   T.consumeClose();
   DeclEnd = T.getCloseLocation();
   BufferScope.Exit();
   Actions.ActOnFinishHLSLBuffer(D, DeclEnd);
 
+  Actions.ProcessDeclAttributeList(Actions.CurScope, D, Attrs);
   return D;
 }
 
+static void fixSeparateAttrArgAndNumber(StringRef ArgStr, SourceLocation ArgLoc,
+                                        Token Tok, ArgsVector &ArgExprs,
+                                        Parser &P, ASTContext &Ctx,
+                                        Preprocessor &PP) {
+  StringRef Num = StringRef(Tok.getLiteralData(), Tok.getLength());
+  SourceLocation EndNumLoc = Tok.getEndLoc();
+
+  P.ConsumeToken(); // consume constant.
+  std::string FixedArg = ArgStr.str() + Num.str();
+  P.Diag(ArgLoc, diag::err_hlsl_separate_attr_arg_and_number)
+      << FixedArg
+      << FixItHint::CreateReplacement(SourceRange(ArgLoc, EndNumLoc), FixedArg);
+  ArgsUnion &Slot = ArgExprs.back();
+  Slot = IdentifierLoc::create(Ctx, ArgLoc, PP.getIdentifierInfo(FixedArg));
+}
+
 void Parser::ParseHLSLSemantics(ParsedAttributes &Attrs,
                                 SourceLocation *EndLoc) {
+  // FIXME: HLSLSemantic is shared for Semantic and resource binding which is
+  // confusing. Need a better name to avoid misunderstanding. Issue
+  // https://github.com/llvm/llvm-project/issues/57882
   assert(Tok.is(tok::colon) && "Not a HLSL Semantic");
   ConsumeToken();
 
-  if (!Tok.is(tok::identifier)) {
+  IdentifierInfo *II = nullptr;
+  if (Tok.is(tok::kw_register))
+    II = PP.getIdentifierInfo("register");
+  else if (Tok.is(tok::identifier))
+    II = Tok.getIdentifierInfo();
+
+  if (!II) {
     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) {
+  ArgsVector ArgExprs;
+  switch (AttrKind) {
+  case ParsedAttr::AT_HLSLResourceBinding: {
+    if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after)) {
+      SkipUntil(tok::r_paren, StopAtSemi); // skip through )
+      return;
+    }
+    if (!Tok.is(tok::identifier)) {
+      Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
+      SkipUntil(tok::r_paren, StopAtSemi); // skip through )
+      return;
+    }
+    StringRef SlotStr = Tok.getIdentifierInfo()->getName();
+    SourceLocation SlotLoc = Tok.getLocation();
+    ArgExprs.push_back(ParseIdentifierLoc());
+
+    // Add numeric_constant for fix-it.
+    if (SlotStr.size() == 1 && Tok.is(tok::numeric_constant))
+      fixSeparateAttrArgAndNumber(SlotStr, SlotLoc, Tok, ArgExprs, *this,
+                                  Actions.Context, PP);
+
+    if (Tok.is(tok::comma)) {
+      ConsumeToken(); // consume comma
+      if (!Tok.is(tok::identifier)) {
+        Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
+        SkipUntil(tok::r_paren, StopAtSemi); // skip through )
+        return;
+      }
+      StringRef SpaceStr = Tok.getIdentifierInfo()->getName();
+      SourceLocation SpaceLoc = Tok.getLocation();
+      ArgExprs.push_back(ParseIdentifierLoc());
+
+      // Add numeric_constant for fix-it.
+      if (SpaceStr.equals("space") && Tok.is(tok::numeric_constant))
+        fixSeparateAttrArgAndNumber(SpaceStr, SpaceLoc, Tok, ArgExprs, *this,
+                                    Actions.Context, PP);
+    }
+    if (ExpectAndConsume(tok::r_paren, diag::err_expected)) {
+      SkipUntil(tok::r_paren, StopAtSemi); // skip through )
+      return;
+    }
+  } break;
+  case ParsedAttr::UnknownAttribute:
     Diag(Loc, diag::err_unknown_hlsl_semantic) << II;
     return;
+  case ParsedAttr::AT_HLSLSV_GroupIndex:
+    break;
+  default:
+    llvm_unreachable("invalid HLSL Semantic");
+    break;
   }
-  Attrs.addNew(II, Loc, nullptr, SourceLocation(), nullptr, 0,
-               ParsedAttr::AS_HLSLSemantic);
+
+  Attrs.addNew(II, Loc, nullptr, SourceLocation(), ArgExprs.data(),
+               ArgExprs.size(), ParsedAttr::AS_HLSLSemantic);
 }

clang/lib/Sema/SemaDeclAttr.cpp

if (NT->getType() != ShaderType) {
       Diag(NT->getLocation(), diag::err_hlsl_attribute_param_mismatch) << AL;
       Diag(AL.getLoc(), diag::note_conflicting_attribute);
     }
     return nullptr;
   }
   return HLSLShaderAttr::Create(Context, ShaderType, AL);
 }
 
+static void handleHLSLResourceBindingAttr(Sema &S, Decl *D,
+                                          const ParsedAttr &AL) {
+  StringRef Space = "space0";
+  StringRef Slot = "";
+
+  if (!AL.isArgIdent(0)) {
+    S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
+        << AL << AANT_ArgumentIdentifier;
+    return;
+  }
+
+  IdentifierLoc *Loc = AL.getArgAsIdent(0);
+  StringRef Str = Loc->Ident->getName();
+  SourceLocation ArgLoc = Loc->Loc;
+
+  SourceLocation SpaceArgLoc;
+  if (AL.getNumArgs() == 2) {
+    Slot = Str;
+    if (!AL.isArgIdent(1)) {
+      S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
+          << AL << AANT_ArgumentIdentifier;
+      return;
+    }
+
+    IdentifierLoc *Loc = AL.getArgAsIdent(1);
+    Space = Loc->Ident->getName();
+    SpaceArgLoc = Loc->Loc;
+  } else {
+    Slot = Str;
+  }
+
+  // Validate.
+  if (!Slot.empty()) {
+    switch (Slot[0]) {
+    case 'u':
+    case 'b':
+    case 's':
+    case 't':
+      break;
+    default:
+      S.Diag(ArgLoc, diag::err_hlsl_unsupported_register_type)
+          << Slot.substr(0, 1);
+      return;
+    }
+
+    StringRef SlotNum = Slot.substr(1);
+    unsigned Num = 0;
+    if (SlotNum.getAsInteger(10, Num)) {
+      S.Diag(ArgLoc, diag::err_hlsl_unsupported_register_number);
+      return;
+    }
+  }
+
+  if (!Space.startswith("space")) {
+    S.Diag(SpaceArgLoc, diag::err_hlsl_expected_space) << Space;
+    return;
+  }
+  StringRef SpaceNum = Space.substr(5);
+  unsigned Num = 0;
+  if (SpaceNum.getAsInteger(10, Num)) {
+    S.Diag(SpaceArgLoc, diag::err_hlsl_expected_space) << Space;
+    return;
+  }
+
+  // FIXME: check reg type match decl. Issue
+  // https://github.com/llvm/llvm-project/issues/57886.
+  HLSLResourceBindingAttr *NewAttr =
+      HLSLResourceBindingAttr::Create(S.getASTContext(), Slot, Space, AL);
+  if (NewAttr)
+    D->addAttr(NewAttr);
+}
+
 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());
   if (IA) {
case ParsedAttr::AT_HLSLNumThreads:
     handleHLSLNumThreadsAttr(S, D, AL);
     break;
   case ParsedAttr::AT_HLSLSV_GroupIndex:
     handleHLSLSVGroupIndexAttr(S, D, AL);
     break;
   case ParsedAttr::AT_HLSLShader:
     handleHLSLShaderAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_HLSLResourceBinding:
+    handleHLSLResourceBindingAttr(S, D, AL);
+    break;
 
   case ParsedAttr::AT_AbiTag:
     handleAbiTagAttr(S, D, AL);
     break;
   case ParsedAttr::AT_CFGuard:
     handleCFGuardAttr(S, D, AL);
     break;
 

clang/test/AST/HLSL/resource_binding_attr.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -ast-dump -o - %s | FileCheck %s
+
+// CHECK:HLSLBufferDecl 0x[[CB:[0-9a-f]+]] {{.*}} line:6:9 cbuffer CB
+// CHECK-NEXT:HLSLResourceBindingAttr 0x{{[0-9a-f]+}} <col:14> "b3" "space2"
+// CHECK-NEXT:VarDecl 0x[[A:[0-9a-f]+]] {{.*}} col:9 used a 'float'
+cbuffer CB : register(b3, space2) {
+  float a;
+}
+
+// CHECK:HLSLBufferDecl 0x[[TB:[0-9a-f]+]] {{.*}} line:13:9 tbuffer TB
+// CHECK-NEXT:HLSLResourceBindingAttr 0x{{[0-9a-f]+}} <col:14> "t2" "space1"
+// CHECK-NEXT:VarDecl 0x[[B:[0-9a-f]+]] {{.*}} col:9 used b 'float'
+tbuffer TB : register(t2, space1) {
+  float b;
+}
+
+float foo() {
+// CHECK: BinaryOperator 0x{{[0-9a-f]+}} <col:10, col:14> 'float' '+'
+// CHECK-NEXT: ImplicitCastExpr 0x{{[0-9a-f]+}} <col:10> 'float' <LValueToRValue>
+// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <col:10> 'float' lvalue Var 0x[[A]] 'a' 'float'
+// CHECK-NEXT: ImplicitCastExpr 0x{{[0-9a-f]+}} <col:14> 'float' <LValueToRValue>
+// CHECK-NEXT: DeclRefExpr 0x{{[0-9a-f]+}} <col:14> 'float' lvalue Var 0x[[B]] 'b' 'float'
+  return a + b;
+}

clang/test/SemaHLSL/resource_binding_attr_error.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -o - -fsyntax-only %s -verify
+
+// expected-error@+5 {{expected ';' after top level declarator}}
+// expected-error@+4 {{expected ')'}}
+// expected-note@+3 {{to match this '('}}
+// expected-error@+2 {{a type specifier is required for all declarations}}
+// expected-error@+1 {{illegal storage class on file-scoped variable}}
+float a : register(c0, space1);
+
+// expected-error@+1 {{invalid resource class specifier 'i' used; expected 'b', 's', 't', or 'u'}}
+cbuffer b : register(i0) {
+
+}
+// expected-error@+1 {{invalid space specifier 's2' used; expected 'space' followed by an integer, like space1}}
+cbuffer c : register(b0, s2) {
+
+}
+// expected-error@+1 {{register number should be an integer}}
+cbuffer d : register(bf, s2) {
+
+}
+// expected-error@+1 {{invalid space specifier 'spaces' used; expected 'space' followed by an integer, like space1}}
+cbuffer e : register(b2, spaces) {
+
+}
+
+// expected-error@+1 {{expected identifier}}
+cbuffer A : register() {}
+
+// expected-error@+1 {{register number should be an integer}}
+cbuffer B : register(space1) {}
+
+// expected-error@+1 {{wrong argument format for hlsl attribute, use b2 instead}}
+cbuffer C : register(b 2) {}
+
+// expected-error@+2 {{wrong argument format for hlsl attribute, use b2 instead}}
+// expected-error@+1 {{wrong argument format for hlsl attribute, use space3 instead}}
+cbuffer D : register(b 2, space 3) {}