[HLSL] Support cbuffer/tbuffer for hlsl.

[python3kgae]

Summary

This is first part for support cbuffer/tbuffer.

The format for cbuffer/tbuffer is
BufferType [Name] [: register(b#)] { VariableDeclaration [: packoffset(c#.xyzw)]; ... };

More details at https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-constants

New keyword 'cbuffer' and 'tbuffer' are added.
New AST node HLSLBufferDecl is added.
Build AST for simple cbuffer/tbuffer without attribute support.

The special thing is variables declared inside cbuffer is exposed into global scope.
So isTransparentContext should return true for HLSLBuffer.

[beanz]

clang/include/clang/Parse/Parser.h

2824

nit: maybe ParseHLSLBuffer, I don't think ParseCTBuffer makes it apparent what this is doing, also everything else is HLSLBuffer

clang/test/SemaHLSL/cbuffer_tbuffer.hlsl

1 ↗

(On Diff #445057)

This looks like it should be an AST test, not SEMA.

We should also have parser tests for malformed parse cases:

cbuffer { ... };
cbuffer missing_definition;
int cbuffer; // using a keyword as a variable name
cbuffer; // lots wrong here...
cbuffer missing_semicolon { int woo; }

It looks like this patch doesn't handle making the buffer variables constant. Having not looked at that I don't know how big of a change that is, so it might be okay as a subsequent patch, but we'll need that support to handle cases like:

cbuffer cb{
int x;
};

[numthreads(1,1,1)]
void main(int GI : SV_GROUPINDEX) {
  x = GI; // error: buffer content is const
}

[python3kgae]

Code cleanup and add test for error case.

[python3kgae]

clang/test/SemaHLSL/cbuffer_tbuffer.hlsl

1 ↗

(On Diff #445057)

Marking constant variables const better be done when supporting global constant buffer. Will add it in another patch.

[beanz]

Since this is adding a new AST node (hopefully the only one we need in HLSL) it would be nice to get @aaron.ballman to take a look here too to make sure this isn't too insane.

clang/lib/AST/DeclBase.cpp

1197

This could be merged into the return line below, which would make the function easier to understand.

clang/test/SemaHLSL/cb_error.hlsl

13

We should duplicate these cases for tbuffer

[python3kgae]

Add more comment about no name conflict for cbuffer.

[aaron.ballman]

There's a whole ton of test coverage missing from this (no actual sema tests, no AST dumping tests for text or JSON) not to mention a ton of situational tests that are missing. For example, can you put one of these declarations inside of a struct (so it's a member declaration)? How about declaring one as a local variable? Tests that it properly diagnoses use of a template, as in template <typename Ty> cbuffer a { Ty f; };? Are there restrictions on what can be declared within one of these buffers (can I declare an inline function in one?)? All those sorts of situations and more should be tested explicitly.

clang/include/clang/AST/Decl.h

4675

Are these redeclarable declarations? I assume not based on previous discussions, so mostly just double checking.

4690–4693

Speculative question: would it make more sense to add CreateCBuffer and CreateTBuffer static methods rather than use a bool parameter?

4696

Nope. :-D

4699–4700

Unused and unimplemented.

clang/lib/AST/Decl.cpp

5228–5230

So semantically these are all in the global namespace no matter where they're spelled? e.g., if you put one inside of a namespace... it's still globally accessible?

clang/lib/AST/DeclBase.cpp

1197–1198

clang/lib/AST/DeclPrinter.cpp

465–469

Let's make this better while we're touching it.

1660–1664

clang/lib/AST/TextNodeDumper.cpp

2392

You're missing similar changes for the JSONNodeDumper.

clang/lib/Parse/ParseDecl.cpp

1793

So these can form a declaration group? e.g.,

cbuffer a { int b; }, b { float f; };

I don't see any test coverage for this situation if that is supported. If it's not supported, I think this should be a return statement instead.

clang/lib/Parse/ParseHLSL.cpp

48–52

This looks like it's going to have some pretty bad error recovery behavior if something is amiss:

cbuffer a {
  oh no!
  this isn't even valid HLSL code
  despite seeming totally reasonable
  once you understand that HLSL
  is so flaming weird.
};

clang/lib/Sema/SemaHLSL.cpp

28

I don't see any tests for this.

34

(The interface was deprecated recently and this is the replacement API.)

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

880

Is this actually unreachable?

clang/test/AST/HLSL/cbuffer_tbuffer.hlsl

8

Something's amiss -- this declaration doesn't have a semicolon, is that expected? Because the SemaHLSL tests do have terminating semicolons and no diagnostics about it being superfluous.

clang/test/SemaHLSL/cb_error.hlsl

4–22

None of these are Sema tests, they're all parsing tests. I think the content should be moved to the parsing test directory and sema tests should be added. For example, we should clearly test using the same identifiers for these buffers and comment about why that's valid and not an error. We should also have tests that demonstrate name lookup behavior, e.g., what happens with this:

cbuffer a {
  int x;
};

int main() {
  return sizeof(a);
}

[python3kgae]

Add more comment about no name conflict for cbuffer.
Add Serialize and JSON dump for HLSLBufferDecl.

[python3kgae]

clang/lib/AST/Decl.cpp

5228–5230

It should not.
I was doing this to hoist nested buffer.
I'll drop the nested buffer support and make namespace work first.
Nested buffer support will be done in another review.

clang/lib/Parse/ParseDecl.cpp

1793

No, it cannot form a declaration group.
If early return, still need to convert to Decl group to match the return type of ParseDeclaration.

clang/lib/Parse/ParseHLSL.cpp

48–52

Add more checks for the Tok here.

clang/lib/Sema/SemaHLSL.cpp

28

Removed. Not see any difference without it when -Wdocumentation is on.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

880

Yeah. template on cbuffer/tbuffer is not allowed.

clang/test/AST/HLSL/cbuffer_tbuffer.hlsl

8

It is expected that cbuffer doesn't need a semicolon.

[aaron.ballman]

Thanks for the update, this is heading in a good direction! I think there's still a lot of test coverage missing. Consider:

namespace Name {
cbuffer a {
  int x;
}
}

struct S {
  cbuffer what {
    int y;
  }
};

void func() {
  tbuffer derp {
    int z;
  }

  decltype(derp) another {
    int a;
  }
}

clang/include/clang/AST/Decl.h

4690–4693

I'm still on the fence about this. On the one hand, being explicit is far better than hoping the reader understand the bool argument at the call site. On the other hand, using the bool parameter means less branching at the call sites. So I'm leaning towards leaving this as-is, but if @beanz has other opinions, I don't yet have a strong feeling.

clang/include/clang/Basic/DiagnosticParseKinds.td

1621

You know what kind of buffer it's within so we can be more precise.

clang/lib/AST/JSONNodeDumper.cpp

906

Matches the naming style for most everything else in the file.

clang/lib/Parse/ParseHLSL.cpp

20–21

Parameter is unused, I presume that's intentional rather than accidental?

25

33

50–54

59

The approach of using a switch and handling individual keywords specially strikes me as being quite fragile. I think a better approach is to split this loop out into its own function and model it (at least somewhat) after ParseStructUnionBody().

The current approach worries me because I have no idea why there's a giant block of invalid things or what should be added to that as we add new declarations to the compiler (and certainly nobody is going to think to come update this function when adding support for new kinds of declarations.

64–65

71–74

There's no way to reach this, so we shouldn't need the [[fallthrough]] here, right?

103–104

Why are type aliases prohibited?

106–107

Why are static assertions prohibited?

122–123

1. GCC supports HLSL?

2. This seems wrong because it will result in:

static template <typename Ty> Ty Val{}; // Prohibited
static void func(); // Allowed
inline void other(); // Prohibited
static inline void haha(); // Allowed

As mentioned above, I think we should use general parsing mechanisms here and then look at the AST node generated to see whether it's an allowed one or not.

134

The declarator context looks wrong to me -- I don't see anything prohibiting the user from doing:

namespace N {
cbuffer {
  ...
}
}

134–135

You're parsing things and then dropping them on the floor?

clang/test/ParserHLSL/invalid_inside_cb.hlsl

21–25

These aren't declarations or even really close (maybe if you squint and think about Objective-C?) so the diagnostic here is really weird. I'd expect to be some sort of syntax error because we have no idea what to parse.

[python3kgae]

Parse first and report error on the generated AST.

[python3kgae]

clang/lib/Parse/ParseHLSL.cpp

59

Changed to ParseExternalDeclaration then validate that only Function/Record/Var Declarations are in the result.

103–104

cbuffer is a legacy feature for HLSL while type alias is a new feature for HLSL2021.
The plan is to keep the legacy features as is.

134

namespace N {

cbuffer A {
}

}
is supported in HLSL.

cbuffer A {

namespace N {
}

} is tricky to support because the namespace N decl inside cbuffer needs to be accessed by things outside the cbuffer. This is not supported now and I hope we don't need to support it in the future.

I'll add test for the supported case.

134–135

The goal is to add these things to HLSLBuffer DeclarationContext.
ActOnStartHLSLBuffer should already make sure that.

[aaron.ballman]

(I didn't have the chance to do a complete review, but I did a partial one and spotted some things)

clang/lib/Parse/ParseHLSL.cpp

79–80

Just double-checking, but this allows [[]] style attributes as well as [] style attributes, but not __attribute__ or __declspec style attributes, is that intended?

clang/lib/Sema/SemaHLSL.cpp

32–33

cast will assert if given nullptr or the cast is invalid, so this should be equivalent.

[python3kgae]

Use cast to simplify code.

clang/lib/Parse/ParseHLSL.cpp

79–80

That is what dxc currently support.
It may change in the future. But for now, only [[]] and [] are supported.

[beanz]

clang/lib/Parse/ParseHLSL.cpp

79–80

Well... worth noting, HLSL doesn't actually support C++11 attributes, but that is almost certainly going to change in the near future, so we might as well support them from the start in Clang.

[aaron.ballman]

clang/lib/Parse/ParseHLSL.cpp

79–80

Ah, that is good to know @beanz -- we should think carefully about this situation because there are some tradeoffs to consider.

1. It's pretty weird to support half of the Microsoft attribute syntax (and the half we barely have any attribute support for, at that). Is there a reason to not support __declspec as well? (For example, are there concerns about things like using those attributes to do dllexport or specify a COMDAT section, etc?) In fact, if we're going to support vendor attributes like [[clang::overloadable]], it's a bit weird that we then prohibit the same attribute from being spelled __attribute__((overloadable)), is there a particular reason to not extend to all attributes?
2. Supporting [] style attributes means that attribute order is important. We cannot use MaybeParseAttributes() to parse attribute specifiers in any order because [] causes ambiguities under some circumstances. So you're stuck with the order you have -- [[]] attributes first, [] attributes second. Is that ordering reasonable?

And for the patch itself -- there are no test cases demonstrating what happens when using attributes on things within one of these buffers. I expect many things to be quite reasonable, like using [[deprecated]], but are the attributes which impact codegen reasonable as well? (Like naked functions, returns twice, disable tail calls, etc)

[beanz]

clang/lib/Parse/ParseHLSL.cpp

79–80

@aaron.ballman I think those are all good questions. Generally HLSL has used Microsoft attribute syntax, and I've started extending the Clang support to be more robust, but still have more work to do.

More on this patch, I want to take a step back.

I think @python3kgae copied this code from DXC, but I don't think it is ever used. I don't think we have any attributes in the language that are valid with cbuffer or tbuffer subjects. We certainly don't have any attributes implemented in clang that would be valid on these targets.

That makes me think we should remove since it should be dead and unreachable and untestable code.

Since these HLSL buffer decls are an older (although frequently used) HLSL feature, I think our general preference is to not extend new feature support to them, and instead to encourage users to use the newer buffer types.

Does that sound reasonable?

[aaron.ballman]

clang/lib/Parse/ParseHLSL.cpp

79–80

We certainly don't have any attributes implemented in clang that would be valid on these targets.

Despite knowing nothing about HLSL, I feel like pushing back a little bit here: deprecated, nodiscard, maybe_unused, and many others seem like they'd not only be valid on the target but perhaps useful to users.

Does that sound reasonable?

I'm totally fine with that approach; we can debate attributes later. :-)

[beanz]

clang/lib/Parse/ParseHLSL.cpp

79–80

Despite knowing nothing about HLSL, I feel like pushing back a little bit here: deprecated, nodiscard, maybe_unused, and many others seem like they'd not only be valid on the target but perhaps useful to users.

Okay... you got me here. I hadn't considered deprecated but can see a use for it. I don't think the other two apply, but I'll concede there may be more general clang attributes that do have uses.

If we can postpone this discussion though I think we can do some background and get a better feeling for what attributes we should and shouldn't support, and maybe consider the syntax a bit carefully too.

If I'm reading this correctly the DXC-supported syntax is:

cbuffer A { ... } [some_attribute]

(note: DXC doesn't really support CXX11 attributes, just the MS syntax)

If this syntax is really unreachable in DXC (which I believe it is), it might be better to shift the syntax to be more like C++ class and struct attributes:

[[some_attribute]]
cbuffer A {...}

I think that would be more familiar and understandable to users, especially as buffer declarations are sometimes hundreds of lines long.

[python3kgae]

Remove attribute for first cbuffer commit.

[python3kgae]

clang/lib/Parse/ParseHLSL.cpp

79–80

Removed attribute parsing.
Will add it back when real HLSL attributes like packoffset are supported.

[aaron.ballman]

LGTM!

[python3kgae]

Rebase for the PCH fix.

[kazu]

This patch seems to cause several warnings:

clang/include/clang/AST/Decl.h:4696:15: error: 'getSourceRange' overrides a member function but is not marked 'override' [-Werror,-Wsuggest-override]
clang/lib/Parse/ParseHLSL.cpp:76:20: error: unused variable 'Loc' [-Werror,-Wunused-variable]
clang/lib/CodeGen/CGDecl.cpp:48:11: error: enumeration value 'HLSLBuffer' not handled in switch [-Werror,-Wswitch]

I could fix the first two, but I don't know what should be done for the last one. Would you mind taking a look?

FWIW, I'm using clang-14.0.0.6 as the hot compiler with a cmake flag -DLLVM_ENABLE_WERROR=On.

[python3kgae]

In D129883#3806393, @kazu wrote:

This patch seems to cause several warnings:

clang/include/clang/AST/Decl.h:4696:15: error: 'getSourceRange' overrides a member function but is not marked 'override' [-Werror,-Wsuggest-override]
clang/lib/Parse/ParseHLSL.cpp:76:20: error: unused variable 'Loc' [-Werror,-Wunused-variable]
clang/lib/CodeGen/CGDecl.cpp:48:11: error: enumeration value 'HLSLBuffer' not handled in switch [-Werror,-Wswitch]

I could fix the first two, but I don't know what should be done for the last one. Would you mind taking a look?

FWIW, I'm using clang-14.0.0.6 as the hot compiler with a cmake flag -DLLVM_ENABLE_WERROR=On.

Working on it.
Building with clang now.

[python3kgae]

In D129883#3806393, @kazu wrote:

This patch seems to cause several warnings:

clang/include/clang/AST/Decl.h:4696:15: error: 'getSourceRange' overrides a member function but is not marked 'override' [-Werror,-Wsuggest-override]
clang/lib/Parse/ParseHLSL.cpp:76:20: error: unused variable 'Loc' [-Werror,-Wunused-variable]
clang/lib/CodeGen/CGDecl.cpp:48:11: error: enumeration value 'HLSLBuffer' not handled in switch [-Werror,-Wswitch]

I could fix the first two, but I don't know what should be done for the last one. Would you mind taking a look?

FWIW, I'm using clang-14.0.0.6 as the hot compiler with a cmake flag -DLLVM_ENABLE_WERROR=On.

Fixed with https://github.com/llvm/llvm-project/commit/a7e3de2450f5b62e7dfe8999443f15be5dfec0b0
Thanks for the help.
I will switch to clang in the future.

[kazu]

In D129883#3806507, @python3kgae wrote:

In D129883#3806393, @kazu wrote:

This patch seems to cause several warnings:

clang/include/clang/AST/Decl.h:4696:15: error: 'getSourceRange' overrides a member function but is not marked 'override' [-Werror,-Wsuggest-override]
clang/lib/Parse/ParseHLSL.cpp:76:20: error: unused variable 'Loc' [-Werror,-Wunused-variable]
clang/lib/CodeGen/CGDecl.cpp:48:11: error: enumeration value 'HLSLBuffer' not handled in switch [-Werror,-Wswitch]

I could fix the first two, but I don't know what should be done for the last one. Would you mind taking a look?

FWIW, I'm using clang-14.0.0.6 as the hot compiler with a cmake flag -DLLVM_ENABLE_WERROR=On.

Fixed with https://github.com/llvm/llvm-project/commit/a7e3de2450f5b62e7dfe8999443f15be5dfec0b0
Thanks for the help.
I will switch to clang in the future.

Thank you so much for fixing this quickly!

By the way, after your fix, I am getting:

clang/tools/libclang/CIndex.cpp:6648:11: error: enumeration value 'HLSLBuffer' not handled in switch [-Werror,-Wswitch]

Sorry for not listing all the warnings in my first message. (I thought I listed them all...) Should we add something like this?

case Decl::HLSLBuffer:
  return clang_getNullCursor();

[python3kgae]

In D129883#3806552, @kazu wrote:

In D129883#3806507, @python3kgae wrote:

In D129883#3806393, @kazu wrote:

This patch seems to cause several warnings:

clang/include/clang/AST/Decl.h:4696:15: error: 'getSourceRange' overrides a member function but is not marked 'override' [-Werror,-Wsuggest-override]
clang/lib/Parse/ParseHLSL.cpp:76:20: error: unused variable 'Loc' [-Werror,-Wunused-variable]
clang/lib/CodeGen/CGDecl.cpp:48:11: error: enumeration value 'HLSLBuffer' not handled in switch [-Werror,-Wswitch]

I could fix the first two, but I don't know what should be done for the last one. Would you mind taking a look?

FWIW, I'm using clang-14.0.0.6 as the hot compiler with a cmake flag -DLLVM_ENABLE_WERROR=On.

Fixed with https://github.com/llvm/llvm-project/commit/a7e3de2450f5b62e7dfe8999443f15be5dfec0b0
Thanks for the help.
I will switch to clang in the future.

Thank you so much for fixing this quickly!

By the way, after your fix, I am getting:

clang/tools/libclang/CIndex.cpp:6648:11: error: enumeration value 'HLSLBuffer' not handled in switch [-Werror,-Wswitch]

Sorry for not listing all the warnings in my first message. (I thought I listed them all...) Should we add something like this?

case Decl::HLSLBuffer:
  return clang_getNullCursor();

Yeah. return clang_getNullCursor(); looks fine.
I'm running a full build now. Hope it can catch all the issue.

clang/include/clang/AST/Decl.h

public:
   static EmptyDecl *Create(ASTContext &C, DeclContext *DC,
                            SourceLocation L);
   static EmptyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == Empty; }
 };
 
+/// HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.
+class HLSLBufferDecl final : public NamedDecl, public DeclContext {
+  /// LBraceLoc - The ending location of the source range.
+  SourceLocation LBraceLoc;
+  /// RBraceLoc - The ending location of the source range.
+  SourceLocation RBraceLoc;
+  /// KwLoc - The location of the cbuffer or tbuffer keyword.
+  SourceLocation KwLoc;
+  /// IsCBuffer - Whether the buffer is a cbuffer (and not a tbuffer).
+  bool IsCBuffer;
+
+  HLSLBufferDecl(DeclContext *DC, bool CBuffer, SourceLocation KwLoc,
+                 IdentifierInfo *ID, SourceLocation IDLoc,
+                 SourceLocation LBrace);
+
+public:
+  static HLSLBufferDecl *Create(ASTContext &C, DeclContext *LexicalParent,
+                                bool CBuffer, SourceLocation KwLoc,
+                                IdentifierInfo *ID, SourceLocation IDLoc,
+                                SourceLocation LBrace);
+  static HLSLBufferDecl *CreateDeserialized(ASTContext &C, unsigned ID);
+
+  SourceRange getSourceRange() const LLVM_READONLY {
+    return SourceRange(getLocStart(), RBraceLoc);
+  }
+  SourceLocation getLocStart() const LLVM_READONLY { return KwLoc; }
+  SourceLocation getLBraceLoc() const { return LBraceLoc; }
+  SourceLocation getRBraceLoc() const { return RBraceLoc; }
+  void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
+  bool isCBuffer() const { return IsCBuffer; }
+
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) { return K == HLSLBuffer; }
+  static DeclContext *castToDeclContext(const HLSLBufferDecl *D) {
+    return static_cast<DeclContext *>(const_cast<HLSLBufferDecl *>(D));
+  }
+  static HLSLBufferDecl *castFromDeclContext(const DeclContext *DC) {
+    return static_cast<HLSLBufferDecl *>(const_cast<DeclContext *>(DC));
+  }
+
+  friend class ASTDeclReader;
+  friend class ASTDeclWriter;
+};
+
 /// Insertion operator for diagnostics.  This allows sending NamedDecl's
 /// into a diagnostic with <<.
 inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                              const NamedDecl *ND) {
   PD.AddTaggedVal(reinterpret_cast<uint64_t>(ND),
                   DiagnosticsEngine::ak_nameddecl);
   return PD;
 }

clang/include/clang/AST/JSONNodeDumper.h

public:
   void VisitUsingShadowDecl(const UsingShadowDecl *USD);
   void VisitVarDecl(const VarDecl *VD);
   void VisitFieldDecl(const FieldDecl *FD);
   void VisitFunctionDecl(const FunctionDecl *FD);
   void VisitEnumDecl(const EnumDecl *ED);
   void VisitEnumConstantDecl(const EnumConstantDecl *ECD);
   void VisitRecordDecl(const RecordDecl *RD);
   void VisitCXXRecordDecl(const CXXRecordDecl *RD);
+  void VisitHLSLBufferDecl(const HLSLBufferDecl *D);
   void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D);
   void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D);
   void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D);
   void VisitLinkageSpecDecl(const LinkageSpecDecl *LSD);
   void VisitAccessSpecDecl(const AccessSpecDecl *ASD);
   void VisitFriendDecl(const FriendDecl *FD);
 
   void VisitObjCIvarDecl(const ObjCIvarDecl *D);

clang/include/clang/AST/RecursiveASTVisitor.h

 
 DEF_TRAVERSE_DECL(CapturedDecl, {
   TRY_TO(TraverseStmt(D->getBody()));
   ShouldVisitChildren = false;
 })
 
 DEF_TRAVERSE_DECL(EmptyDecl, {})
 
+DEF_TRAVERSE_DECL(HLSLBufferDecl, {})
+
 DEF_TRAVERSE_DECL(LifetimeExtendedTemporaryDecl, {
   TRY_TO(TraverseStmt(D->getTemporaryExpr()));
 })
 
 DEF_TRAVERSE_DECL(FileScopeAsmDecl,
                   { TRY_TO(TraverseStmt(D->getAsmString())); })
 
 DEF_TRAVERSE_DECL(ImportDecl, {})

clang/include/clang/AST/TextNodeDumper.h

#include "clang/AST/AttrTextNodeDump.inc"
   void VisitObjCImplementationDecl(const ObjCImplementationDecl *D);
   void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D);
   void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
   void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
   void VisitBlockDecl(const BlockDecl *D);
   void VisitConceptDecl(const ConceptDecl *D);
   void
   VisitLifetimeExtendedTemporaryDecl(const LifetimeExtendedTemporaryDecl *D);
+  void VisitHLSLBufferDecl(const HLSLBufferDecl *D);
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_TEXTNODEDUMPER_H

clang/include/clang/Basic/DeclNodes.td

 def ClassScopeFunctionSpecialization : DeclNode<Decl>;
 def Import : DeclNode<Decl>;
 def OMPThreadPrivate : DeclNode<Decl>;
 def OMPAllocate : DeclNode<Decl>;
 def OMPRequires : DeclNode<Decl>;
 def Empty : DeclNode<Decl>;
 def RequiresExprBody : DeclNode<Decl>, DeclContext;
 def LifetimeExtendedTemporary : DeclNode<Decl>;
-
+def HLSLBuffer : DeclNode<Named, "HLSLBuffer">, DeclContext;

clang/include/clang/Basic/DiagnosticParseKinds.td

def warn_max_tokens_total : Warning<
   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_invalid_declaration_in_hlsl_buffer : Error<
+  "invalid declaration inside %select{tbuffer|cbuffer}0">;
 def err_unknown_hlsl_semantic : Error<"unknown HLSL semantic %0">;
 def ext_hlsl_access_specifiers : ExtWarn<
   "access specifiers are a clang HLSL extension">,
   InGroup<HLSLExtension>;
 
 } // end of Parser diagnostics

clang/include/clang/Basic/TokenKinds.def

 #include "clang/Basic/OpenCLImageTypes.def"
 KEYWORD(pipe                        , KEYOPENCLC | KEYOPENCLCXX)
 // C++ for OpenCL s2.3.1: addrspace_cast operator
 KEYWORD(addrspace_cast              , KEYOPENCLCXX)
 
 // CUDA/HIP function attributes
 KEYWORD(__noinline__                , KEYCUDA)
 
+// HLSL keywords.
+KEYWORD(cbuffer                     , KEYHLSL)
+KEYWORD(tbuffer                     , KEYHLSL)
+
 // OpenMP Type Traits
 UNARY_EXPR_OR_TYPE_TRAIT(__builtin_omp_required_simd_align, OpenMPRequiredSimdAlign, KEYALL)
 
 // Borland Extensions.
 KEYWORD(__pascal                    , KEYALL)
 
 // Altivec Extension.
 KEYWORD(__vector                    , KEYALTIVEC|KEYZVECTOR)

clang/include/clang/Parse/Parser.h

private:
   void MaybeParseHLSLSemantics(ParsedAttributes &Attrs,
                                SourceLocation *EndLoc = nullptr) {
     if (getLangOpts().HLSL && Tok.is(tok::colon))
       ParseHLSLSemantics(Attrs, EndLoc);
   }
 
   void ParseHLSLSemantics(ParsedAttributes &Attrs,
                           SourceLocation *EndLoc = nullptr);
+  Decl *ParseHLSLBuffer(SourceLocation &DeclEnd);
 
   void MaybeParseMicrosoftAttributes(ParsedAttributes &Attrs) {
     if ((getLangOpts().MicrosoftExt || getLangOpts().HLSL) &&
         Tok.is(tok::l_square)) {
       ParsedAttributes AttrsWithRange(AttrFactory);
       ParseMicrosoftAttributes(AttrsWithRange);
       Attrs.takeAllFrom(AttrsWithRange);
     }

clang/include/clang/Sema/Sema.h

public:
   /// __builtin_astype(...)
   ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
                              SourceLocation BuiltinLoc,
                              SourceLocation RParenLoc);
   ExprResult BuildAsTypeExpr(Expr *E, QualType DestTy,
                              SourceLocation BuiltinLoc,
                              SourceLocation RParenLoc);
 
+  //===---------------------------- HLSL Features -------------------------===//
+  Decl *ActOnStartHLSLBuffer(Scope *BufferScope, bool CBuffer,
+                             SourceLocation KwLoc, IdentifierInfo *Ident,
+                             SourceLocation IdentLoc, SourceLocation LBrace);
+  void ActOnFinishHLSLBuffer(Decl *Dcl, SourceLocation RBrace);
+
   //===---------------------------- C++ Features --------------------------===//
 
   // Act on C++ namespaces
   Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,
                                SourceLocation NamespaceLoc,
                                SourceLocation IdentLoc, IdentifierInfo *Ident,
                                SourceLocation LBrace,
                                const ParsedAttributesView &AttrList,

clang/include/clang/Serialization/ASTBitCodes.h

enum DeclCode {
   DECL_OMP_DECLARE_MAPPER,
 
   /// An OMPDeclareReductionDecl record.
   DECL_OMP_DECLARE_REDUCTION,
 
   /// A UnnamedGlobalConstantDecl record.
   DECL_UNNAMED_GLOBAL_CONSTANT,
 
-  DECL_LAST = DECL_UNNAMED_GLOBAL_CONSTANT
+  /// A HLSLBufferDecl record.
+  DECL_HLSL_BUFFER,
+
+  DECL_LAST = DECL_HLSL_BUFFER
 };
 
 /// Record codes for each kind of statement or expression.
 ///
 /// These constants describe the records that describe statements
 /// or expressions. These records  occur within type and declarations
 /// block, so they begin with record values of 128.  Each constant
 /// describes a record for a specific statement or expression class in the

clang/lib/AST/Decl.cpp

 EmptyDecl *EmptyDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
   return new (C, DC) EmptyDecl(DC, L);
 }
 
 EmptyDecl *EmptyDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) EmptyDecl(nullptr, SourceLocation());
 }
 
+HLSLBufferDecl::HLSLBufferDecl(DeclContext *DC, bool CBuffer,
+                               SourceLocation KwLoc, IdentifierInfo *ID,
+                               SourceLocation IDLoc, SourceLocation LBrace)
+    : NamedDecl(Decl::Kind::HLSLBuffer, DC, IDLoc, DeclarationName(ID)),
+      DeclContext(Decl::Kind::HLSLBuffer), LBraceLoc(LBrace), KwLoc(KwLoc),
+      IsCBuffer(CBuffer) {}
+
+HLSLBufferDecl *HLSLBufferDecl::Create(ASTContext &C,
+                                       DeclContext *LexicalParent, bool CBuffer,
+                                       SourceLocation KwLoc, IdentifierInfo *ID,
+                                       SourceLocation IDLoc,
+                                       SourceLocation LBrace) {
+  // For hlsl like this
+  // cbuffer A {
+  //     cbuffer B {
+  //     }
+  // }
+  // compiler should treat it as
+  // cbuffer A {
+  // }
+  // cbuffer B {
+  // }
+  // FIXME: support nested buffers if required for back-compat.
+  DeclContext *DC = LexicalParent;
+  HLSLBufferDecl *Result =
+      new (C, DC) HLSLBufferDecl(DC, CBuffer, KwLoc, ID, IDLoc, LBrace);
+  return Result;
+}
+
+HLSLBufferDecl *HLSLBufferDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
+  return new (C, ID) HLSLBufferDecl(nullptr, false, SourceLocation(), nullptr,
+                                    SourceLocation(), SourceLocation());
+}
+
 //===----------------------------------------------------------------------===//
 // ImportDecl Implementation
 //===----------------------------------------------------------------------===//
 
 /// Retrieve the number of module identifiers needed to name the given
 /// module.
 static unsigned getNumModuleIdentifiers(Module *Mod) {
   unsigned Result = 1;

clang/lib/AST/DeclBase.cpp

switch (DeclKind) {
     case CXXConversion:
     case EnumConstant:
     case Var:
     case ImplicitParam:
     case ParmVar:
     case ObjCMethod:
     case ObjCProperty:
     case MSProperty:
+    case HLSLBuffer:
       return IDNS_Ordinary;
     case Label:
       return IDNS_Label;
     case IndirectField:
       return IDNS_Ordinary | IDNS_Member;
 
     case Binding:
     case NonTypeTemplateParm:
bool DeclContext::isDependentContext() const {
 
   return getParent() && getParent()->isDependentContext();
 }
 
 bool DeclContext::isTransparentContext() const {
   if (getDeclKind() == Decl::Enum)
     return !cast<EnumDecl>(this)->isScoped();
 
-  return getDeclKind() == Decl::LinkageSpec || getDeclKind() == Decl::Export;
+  return isa<LinkageSpecDecl, ExportDecl, HLSLBufferDecl>(this);
 }
 
 static bool isLinkageSpecContext(const DeclContext *DC,
                                  LinkageSpecDecl::LanguageIDs ID) {
   while (DC->getDeclKind() != Decl::TranslationUnit) {
     if (DC->getDeclKind() == Decl::LinkageSpec)
       return cast<LinkageSpecDecl>(DC)->getLanguage() == ID;
     DC = DC->getLexicalParent();
   }
DeclContext *DeclContext::getPrimaryContext() {
   case Decl::Block:
   case Decl::Captured:
   case Decl::OMPDeclareReduction:
   case Decl::OMPDeclareMapper:
   case Decl::RequiresExprBody:
     // There is only one DeclContext for these entities.
     return this;
 
+  case Decl::HLSLBuffer:
+    // Each buffer, even with the same name, is a distinct construct.
+    // Multiple buffers with the same name are allowed for backward
+    // compatibility.
+    // As long as buffers have unique resource bindings the names don't matter.
+    // The names get exposed via the CPU-side reflection API which
+    // supports querying bindings, so we cannot remove them.
+    return this;
+
   case Decl::TranslationUnit:
     return static_cast<TranslationUnitDecl *>(this)->getFirstDecl();
   case Decl::Namespace:
     // The original namespace is our primary context.
     return static_cast<NamespaceDecl *>(this)->getOriginalNamespace();
 
   case Decl::ObjCMethod:
     return this;

clang/lib/AST/DeclPrinter.cpp

public:
     void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
     void VisitOMPAllocateDecl(OMPAllocateDecl *D);
     void VisitOMPRequiresDecl(OMPRequiresDecl *D);
     void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
     void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
     void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
     void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *TTP);
     void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *NTTP);
+    void VisitHLSLBufferDecl(HLSLBufferDecl *D);
 
     void printTemplateParameters(const TemplateParameterList *Params,
                                  bool OmitTemplateKW = false);
     void printTemplateArguments(llvm::ArrayRef<TemplateArgument> Args,
                                 const TemplateParameterList *Params);
     void printTemplateArguments(llvm::ArrayRef<TemplateArgumentLoc> Args,
                                 const TemplateParameterList *Params);
     void prettyPrintAttributes(Decl *D);
else if (auto FD = dyn_cast<FunctionDecl>(*D)) {
       if (FD->isThisDeclarationADefinition())
         Terminator = nullptr;
       else
         Terminator = ";";
     } else if (auto TD = dyn_cast<FunctionTemplateDecl>(*D)) {
       if (TD->getTemplatedDecl()->isThisDeclarationADefinition())
         Terminator = nullptr;
       else
         Terminator = ";";
-    } else if (isa<NamespaceDecl>(*D) || isa<LinkageSpecDecl>(*D) ||
-             isa<ObjCImplementationDecl>(*D) ||
-             isa<ObjCInterfaceDecl>(*D) ||
-             isa<ObjCProtocolDecl>(*D) ||
-             isa<ObjCCategoryImplDecl>(*D) ||
-             isa<ObjCCategoryDecl>(*D))
+    } else if (isa<NamespaceDecl, LinkageSpecDecl, ObjCImplementationDecl,
+                   ObjCInterfaceDecl, ObjCProtocolDecl, ObjCCategoryImplDecl,
+                   ObjCCategoryDecl, HLSLBufferDecl>(*D))
       Terminator = nullptr;
     else if (isa<EnumConstantDecl>(*D)) {
       DeclContext::decl_iterator Next = D;
       ++Next;
       if (Next != DEnd)
         Terminator = ",";
     } else
       Terminator = ";";
 
for (OMPThreadPrivateDecl::varlist_iterator I = D->varlist_begin(),
       Out << (I == D->varlist_begin() ? '(' : ',');
       NamedDecl *ND = cast<DeclRefExpr>(*I)->getDecl();
       ND->printQualifiedName(Out);
     }
     Out << ")";
   }
 }
 
+void DeclPrinter::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
+  if (D->isCBuffer())
+    Out << "cbuffer ";
+  else
+    Out << "tbuffer ";
+
+  Out << *D;
+
+  prettyPrintAttributes(D);
+
+  Out << " {\n";
+  VisitDeclContext(D);
+  Indent() << "}";
+}
+
 void DeclPrinter::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
   Out << "#pragma omp allocate";
   if (!D->varlist_empty()) {
     for (OMPAllocateDecl::varlist_iterator I = D->varlist_begin(),
                                            E = D->varlist_end();
          I != E; ++I) {
       Out << (I == D->varlist_begin() ? '(' : ',');
       NamedDecl *ND = cast<DeclRefExpr>(*I)->getDecl();

clang/lib/AST/JSONNodeDumper.cpp

void JSONNodeDumper::VisitCXXRecordDecl(const CXXRecordDecl *RD) {
   if (RD->getNumBases()) {
     JOS.attributeArray("bases", [this, RD] {
       for (const auto &Spec : RD->bases())
         JOS.value(createCXXBaseSpecifier(Spec));
     });
   }
 }
 
+void JSONNodeDumper::VisitHLSLBufferDecl(const HLSLBufferDecl *D) {
+  VisitNamedDecl(D);
+  JOS.attribute("bufferKind", D->isCBuffer() ? "cbuffer" : "tbuffer");
+}
+
 void JSONNodeDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
   VisitNamedDecl(D);
   JOS.attribute("tagUsed", D->wasDeclaredWithTypename() ? "typename" : "class");
   JOS.attribute("depth", D->getDepth());
   JOS.attribute("index", D->getIndex());
   attributeOnlyIfTrue("isParameterPack", D->isParameterPack());
 
   if (D->hasDefaultArgument())

clang/lib/AST/TextNodeDumper.cpp

void TextNodeDumper::VisitConceptDecl(const ConceptDecl *D) {
   dumpName(D);
 }
 
 void TextNodeDumper::VisitCompoundStmt(const CompoundStmt *S) {
   VisitStmt(S);
   if (S->hasStoredFPFeatures())
     printFPOptions(S->getStoredFPFeatures());
 }
+
+void TextNodeDumper::VisitHLSLBufferDecl(const HLSLBufferDecl *D) {
+  if (D->isCBuffer())
+    OS << " cbuffer";
+  else
+    OS << " tbuffer";
+  dumpName(D);
+}

clang/lib/Basic/IdentifierTable.cpp

enum TokenKey : unsigned {
     KEYZVECTOR    = 0x20000,
     KEYCOROUTINES = 0x40000,
     KEYMODULES    = 0x80000,
     KEYCXX20      = 0x100000,
     KEYOPENCLCXX  = 0x200000,
     KEYMSCOMPAT   = 0x400000,
     KEYSYCL       = 0x800000,
     KEYCUDA       = 0x1000000,
-    KEYMAX        = KEYCUDA, // The maximum key
+    KEYHLSL       = 0x2000000,
+    KEYMAX        = KEYHLSL, // The maximum key
     KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX20,
     KEYALL = (KEYMAX | (KEYMAX-1)) & ~KEYNOMS18 &
              ~KEYNOOPENCL // KEYNOMS18 and KEYNOOPENCL are used to exclude.
   };
 
   /// How a keyword is treated in the selected standard. This enum is ordered
   /// intentionally so that the value that 'wins' is the most 'permissive'.
   enum KeywordStatus {
static KeywordStatus getKeywordStatusHelper(const LangOptions &LangOpts,
   case KEYOPENCLCXX:
     return LangOpts.OpenCLCPlusPlus ? KS_Enabled : KS_Unknown;
   case KEYMSCOMPAT:
     return LangOpts.MSVCCompat ? KS_Enabled : KS_Unknown;
   case KEYSYCL:
     return LangOpts.isSYCL() ? KS_Enabled : KS_Unknown;
   case KEYCUDA:
     return LangOpts.CUDA ? KS_Enabled : KS_Unknown;
+  case KEYHLSL:
+    return LangOpts.HLSL ? KS_Enabled : KS_Unknown;
   case KEYNOCXX:
     // This is enabled in all non-C++ modes, but might be enabled for other
     // reasons as well.
     return LangOpts.CPlusPlus ? KS_Unknown : KS_Enabled;
   case KEYNOOPENCL:
     // The disable behavior for this is handled in getKeywordStatus.
     return KS_Unknown;
   case KEYNOMS18:

clang/lib/Parse/ParseDecl.cpp

case tok::kw_inline:
     if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_namespace)) {
       ProhibitAttributes(DeclAttrs);
       ProhibitAttributes(DeclSpecAttrs);
       SourceLocation InlineLoc = ConsumeToken();
       return ParseNamespace(Context, DeclEnd, InlineLoc);
     }
     return ParseSimpleDeclaration(Context, DeclEnd, DeclAttrs, DeclSpecAttrs,
                                   true, nullptr, DeclSpecStart);
+
+  case tok::kw_cbuffer:
+  case tok::kw_tbuffer:
+    SingleDecl = ParseHLSLBuffer(DeclEnd);
+    break;
   case tok::kw_namespace:
     ProhibitAttributes(DeclAttrs);
     ProhibitAttributes(DeclSpecAttrs);
     return ParseNamespace(Context, DeclEnd);
   case tok::kw_using: {
     ParsedAttributes Attrs(AttrFactory);
     takeAndConcatenateAttrs(DeclAttrs, DeclSpecAttrs, Attrs);
     return ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(),

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"
+#include "clang/Parse/RAIIObjectsForParser.h"
 
 using namespace clang;
 
+static bool validateDeclsInsideHLSLBuffer(Parser::DeclGroupPtrTy DG,
+                                          SourceLocation BufferLoc,
+                                          bool IsCBuffer, Parser &P) {
+  // The parse is failed, just return false.
+  if (!DG)
+    return false;
+  DeclGroupRef Decls = DG.get();
+  bool IsValid = true;
+  // Only allow function, variable, record decls inside HLSLBuffer.
+  for (DeclGroupRef::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
+    Decl *D = *I;
+    if (isa<CXXRecordDecl, RecordDecl, FunctionDecl, VarDecl>(D))
+      continue;
+
+    // FIXME: support nested HLSLBuffer and namespace inside HLSLBuffer.
+    if (isa<HLSLBufferDecl, NamespaceDecl>(D)) {
+      P.Diag(D->getLocation(), diag::err_invalid_declaration_in_hlsl_buffer)
+          << IsCBuffer;
+      IsValid = false;
+      continue;
+    }
+
+    IsValid = false;
+    P.Diag(D->getLocation(), diag::err_invalid_declaration_in_hlsl_buffer)
+        << IsCBuffer;
+  }
+  return IsValid;
+}
+
+Decl *Parser::ParseHLSLBuffer(SourceLocation &DeclEnd) {
+  assert((Tok.is(tok::kw_cbuffer) || Tok.is(tok::kw_tbuffer)) &&
+         "Not a cbuffer or tbuffer!");
+  bool IsCBuffer = Tok.is(tok::kw_cbuffer);
+  SourceLocation BufferLoc = ConsumeToken(); // Eat the 'cbuffer' or 'tbuffer'.
+
+  if (!Tok.is(tok::identifier)) {
+    Diag(Tok, diag::err_expected) << tok::identifier;
+    return nullptr;
+  }
+
+  IdentifierInfo *Identifier = Tok.getIdentifierInfo();
+  SourceLocation IdentifierLoc = ConsumeToken();
+
+  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)) {
+    SourceLocation Loc = Tok.getLocation();
+    // 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);
+
+  return D;
+}
+
 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/Parse/Parser.cpp

case tok::kw__Static_assert:
     // A function definition cannot start with any of these keywords.
     {
       SourceLocation DeclEnd;
       ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
       return ParseDeclaration(DeclaratorContext::File, DeclEnd, Attrs,
                               EmptyDeclSpecAttrs);
     }
 
+  case tok::kw_cbuffer:
+  case tok::kw_tbuffer:
+    if (getLangOpts().HLSL) {
+      SourceLocation DeclEnd;
+      ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
+      return ParseDeclaration(DeclaratorContext::File, DeclEnd, Attrs,
+                              EmptyDeclSpecAttrs);
+    }
+    goto dont_know;
+
   case tok::kw_static:
     // Parse (then ignore) 'static' prior to a template instantiation. This is
     // a GCC extension that we intentionally do not support.
     if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) {
       Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored)
         << 0;
       SourceLocation DeclEnd;
       ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);

clang/lib/Sema/CMakeLists.txt

add_clang_library(clangSema
   SemaDeclCXX.cpp
   SemaDeclObjC.cpp
   SemaExceptionSpec.cpp
   SemaExpr.cpp
   SemaExprCXX.cpp
   SemaExprMember.cpp
   SemaExprObjC.cpp
   SemaFixItUtils.cpp
+  SemaHLSL.cpp
   SemaInit.cpp
   SemaLambda.cpp
   SemaLookup.cpp
   SemaModule.cpp
   SemaObjCProperty.cpp
   SemaOpenMP.cpp
   SemaOverload.cpp
   SemaPseudoObject.cpp

clang/lib/Sema/IdentifierResolver.cpp

 }
 
 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
 /// true if 'D' belongs to the given declaration context.
 bool IdentifierResolver::isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S,
                                        bool AllowInlineNamespace) const {
   Ctx = Ctx->getRedeclContext();
-
+  // The names for HLSL cbuffer/tbuffers only used by the CPU-side
+  // reflection API which supports querying bindings. It will not have name
+  // conflict with other Decls.
+  if (LangOpt.HLSL && isa<HLSLBufferDecl>(D))
+    return false;
   if (Ctx->isFunctionOrMethod() || (S && S->isFunctionPrototypeScope())) {
     // Ignore the scopes associated within transparent declaration contexts.
     while (S->getEntity() && S->getEntity()->isTransparentContext())
       S = S->getParent();
 
     if (S->isDeclScope(D))
       return true;
     if (LangOpt.CPlusPlus) {

clang/lib/Sema/SemaDecl.cpp

static bool shouldConsiderLinkage(const VarDecl *VD) {
   const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
   if (DC->isFunctionOrMethod() || isa<OMPDeclareReductionDecl>(DC) ||
       isa<OMPDeclareMapperDecl>(DC))
     return VD->hasExternalStorage();
   if (DC->isFileContext())
     return true;
   if (DC->isRecord())
     return false;
+  if (DC->getDeclKind() == Decl::HLSLBuffer)
+    return false;
+
   if (isa<RequiresExprBodyDecl>(DC))
     return false;
   llvm_unreachable("Unexpected context");
 }
 
 static bool shouldConsiderLinkage(const FunctionDecl *FD) {
   const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
   if (DC->isFileContext() || DC->isFunctionOrMethod() ||

clang/lib/Sema/SemaHLSL.cpp

+//===- SemaHLSL.cpp - Semantic Analysis for HLSL constructs ---------------===//
+//
+// 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 implements Semantic Analysis for HLSL constructs.
+//===----------------------------------------------------------------------===//
+
+#include "clang/Sema/Sema.h"
+
+using namespace clang;
+
+Decl *Sema::ActOnStartHLSLBuffer(Scope *BufferScope, bool CBuffer,
+                                 SourceLocation KwLoc, IdentifierInfo *Ident,
+                                 SourceLocation IdentLoc,
+                                 SourceLocation LBrace) {
+  // For anonymous namespace, take the location of the left brace.
+  DeclContext *LexicalParent = getCurLexicalContext();
+  HLSLBufferDecl *Result = HLSLBufferDecl::Create(
+      Context, LexicalParent, CBuffer, KwLoc, Ident, IdentLoc, LBrace);
+
+  PushOnScopeChains(Result, BufferScope);
+  PushDeclContext(BufferScope, Result);
+
+  return Result;
+}
+
+void Sema::ActOnFinishHLSLBuffer(Decl *Dcl, SourceLocation RBrace) {
+  auto *BufDecl = cast<HLSLBufferDecl>(Dcl);
+  BufDecl->setRBraceLoc(RBrace);
+  PopDeclContext();
+}

clang/lib/Sema/SemaLookup.cpp

void LookupResult::resolveKind() {
   unsigned UniqueTagIndex = 0;
 
   unsigned I = 0;
   while (I < N) {
     NamedDecl *D = Decls[I]->getUnderlyingDecl();
     D = cast<NamedDecl>(D->getCanonicalDecl());
 
     // Ignore an invalid declaration unless it's the only one left.
-    if (D->isInvalidDecl() && !(I == 0 && N == 1)) {
+    // Also ignore HLSLBufferDecl which not have name conflict with other Decls.
+    if ((D->isInvalidDecl() || isa<HLSLBufferDecl>(D)) && !(I == 0 && N == 1)) {
       Decls[I] = Decls[--N];
       continue;
     }
 
     llvm::Optional<unsigned> ExistingI;
 
     // Redeclarations of types via typedef can occur both within a scope
     // and, through using declarations and directives, across scopes. There is

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

static DeclT *getPreviousDeclForInstantiation(DeclT *D) {
   return Result;
 }
 
 Decl *
 TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
   llvm_unreachable("Translation units cannot be instantiated");
 }
 
+Decl *TemplateDeclInstantiator::VisitHLSLBufferDecl(HLSLBufferDecl *Decl) {
+  llvm_unreachable("HLSL buffer declarations cannot be instantiated");
+}
+
 Decl *
 TemplateDeclInstantiator::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
   llvm_unreachable("pragma comment cannot be instantiated");
 }
 
 Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl(
     PragmaDetectMismatchDecl *D) {
   llvm_unreachable("pragma comment cannot be instantiated");

clang/lib/Serialization/ASTCommon.cpp

bool serialization::isRedeclarableDeclKind(unsigned Kind) {
   case Decl::OMPDeclareMapper:
   case Decl::BuiltinTemplate:
   case Decl::Decomposition:
   case Decl::Binding:
   case Decl::Concept:
   case Decl::LifetimeExtendedTemporary:
   case Decl::RequiresExprBody:
   case Decl::UnresolvedUsingIfExists:
+  case Decl::HLSLBuffer:
     return false;
 
   // These indirectly derive from Redeclarable<T> but are not actually
   // redeclarable.
   case Decl::ImplicitParam:
   case Decl::ParmVar:
   case Decl::ObjCTypeParam:
     return false;

clang/lib/Serialization/ASTReaderDecl.cpp

public:
 
     void VisitDecl(Decl *D);
     void VisitPragmaCommentDecl(PragmaCommentDecl *D);
     void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
     void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
     void VisitNamedDecl(NamedDecl *ND);
     void VisitLabelDecl(LabelDecl *LD);
     void VisitNamespaceDecl(NamespaceDecl *D);
+    void VisitHLSLBufferDecl(HLSLBufferDecl *D);
     void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
     void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
     void VisitTypeDecl(TypeDecl *TD);
     RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD);
     void VisitTypedefDecl(TypedefDecl *TD);
     void VisitTypeAliasDecl(TypeAliasDecl *TD);
     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
     void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D);
if (AnonNamespace) {
     // any other module's anonymous namespaces, so don't attach the anonymous
     // namespace at all.
     auto *Anon = cast<NamespaceDecl>(Reader.GetDecl(AnonNamespace));
     if (!Record.isModule())
       D->setAnonymousNamespace(Anon);
   }
 }
 
+void ASTDeclReader::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
+  VisitNamedDecl(D);
+  VisitDeclContext(D);
+  D->IsCBuffer = Record.readBool();
+  D->KwLoc = readSourceLocation();
+  D->LBraceLoc = readSourceLocation();
+  D->RBraceLoc = readSourceLocation();
+}
+
 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
   RedeclarableResult Redecl = VisitRedeclarable(D);
   VisitNamedDecl(D);
   D->NamespaceLoc = readSourceLocation();
   D->IdentLoc = readSourceLocation();
   D->QualifierLoc = Record.readNestedNameSpecifierLoc();
   D->Namespace = readDeclAs<NamedDecl>();
   mergeRedeclarable(D, Redecl);
case DECL_EMPTY:
     D = EmptyDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_LIFETIME_EXTENDED_TEMPORARY:
     D = LifetimeExtendedTemporaryDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_OBJC_TYPE_PARAM:
     D = ObjCTypeParamDecl::CreateDeserialized(Context, ID);
     break;
+  case DECL_HLSL_BUFFER:
+    D = HLSLBufferDecl::CreateDeserialized(Context, ID);
+    break;
   }
 
   assert(D && "Unknown declaration reading AST file");
   LoadedDecl(Index, D);
   // Set the DeclContext before doing any deserialization, to make sure internal
   // calls to Decl::getASTContext() by Decl's methods will find the
   // TranslationUnitDecl without crashing.
   D->setDeclContext(Context.getTranslationUnitDecl());

clang/lib/Serialization/ASTWriter.cpp

#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
   RECORD(DECL_OMP_THREADPRIVATE);
   RECORD(DECL_EMPTY);
   RECORD(DECL_OBJC_TYPE_PARAM);
   RECORD(DECL_OMP_CAPTUREDEXPR);
   RECORD(DECL_PRAGMA_COMMENT);
   RECORD(DECL_PRAGMA_DETECT_MISMATCH);
   RECORD(DECL_OMP_DECLARE_REDUCTION);
   RECORD(DECL_OMP_ALLOCATE);
+  RECORD(DECL_HLSL_BUFFER);
 
   // Statements and Exprs can occur in the Decls and Types block.
   AddStmtsExprs(Stream, Record);
 
   BLOCK(PREPROCESSOR_DETAIL_BLOCK);
   RECORD(PPD_MACRO_EXPANSION);
   RECORD(PPD_MACRO_DEFINITION);
   RECORD(PPD_INCLUSION_DIRECTIVE);

clang/lib/Serialization/ASTWriterDecl.cpp

public:
     void VisitAccessSpecDecl(AccessSpecDecl *D);
     void VisitFriendDecl(FriendDecl *D);
     void VisitFriendTemplateDecl(FriendTemplateDecl *D);
     void VisitStaticAssertDecl(StaticAssertDecl *D);
     void VisitBlockDecl(BlockDecl *D);
     void VisitCapturedDecl(CapturedDecl *D);
     void VisitEmptyDecl(EmptyDecl *D);
     void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
-
     void VisitDeclContext(DeclContext *DC);
     template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
-
+    void VisitHLSLBufferDecl(HLSLBufferDecl *D);
 
     // FIXME: Put in the same order is DeclNodes.td?
     void VisitObjCMethodDecl(ObjCMethodDecl *D);
     void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
     void VisitObjCContainerDecl(ObjCContainerDecl *D);
     void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
     void VisitObjCIvarDecl(ObjCIvarDecl *D);
     void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
if (MostRecent != First) {
     (void)Writer.GetDeclRef(D->getPreviousDecl());
     (void)Writer.GetDeclRef(MostRecent);
   } else {
     // We use the sentinel value 0 to indicate an only declaration.
     Record.push_back(0);
   }
 }
 
+void ASTDeclWriter::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
+  VisitNamedDecl(D);
+  VisitDeclContext(D);
+  Record.push_back(D->isCBuffer());
+  Record.AddSourceLocation(D->getLocStart());
+  Record.AddSourceLocation(D->getLBraceLoc());
+  Record.AddSourceLocation(D->getRBraceLoc());
+
+  Code = serialization::DECL_HLSL_BUFFER;
+}
+
 void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
   Record.writeOMPChildren(D->Data);
   VisitDecl(D);
   Code = serialization::DECL_OMP_THREADPRIVATE;
 }
 
 void ASTDeclWriter::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
   Record.writeOMPChildren(D->Data);

clang/test/AST/HLSL/ast-dump-comment-cbuffe-tbufferr.hlsl

+// RUN: %clang_cc1 -Wdocumentation -ast-dump=json -x hlsl -triple dxil-pc-shadermodel6.3-library %s | FileCheck %s --check-prefix=JSON
+// RUN: %clang_cc1 -Wdocumentation -ast-dump -x hlsl -triple dxil-pc-shadermodel6.3-library %s | FileCheck %s --check-prefix=AST
+
+// JSON:"kind": "HLSLBufferDecl",
+// JSON:"name": "A",
+// JSON-NEXT:"bufferKind": "cbuffer",
+// JSON:"kind": "TextComment",
+// JSON:"text": " CBuffer decl."
+
+/// CBuffer decl.
+cbuffer A {
+    // JSON: "kind": "VarDecl",
+    // JSON: "name": "a",
+    // JSON: "qualType": "float"
+    float a;
+    // JSON: "kind": "VarDecl",
+    // JSON: "name": "b",
+    // JSON: "qualType": "int"
+    int b;
+}
+
+// JSON:"kind": "HLSLBufferDecl",
+// JSON:"name": "B",
+// JSON-NEXT:"bufferKind": "tbuffer",
+// JSON:"kind": "TextComment",
+// JSON:"text": " TBuffer decl."
+
+/// TBuffer decl.
+tbuffer B {
+    // JSON: "kind": "VarDecl",
+    // JSON: "name": "c",
+    // JSON: "qualType": "float"
+    float c;
+    // JSON: "kind": "VarDecl",
+    // JSON: "name": "d",
+    // JSON: "qualType": "int"
+    int d;
+}
+
+// AST:HLSLBufferDecl {{.*}}:11:1, line:20:1> line:11:9 cbuffer A
+// AST-NEXT:FullComment {{.*}}<line:10:4, col:17>
+// AST-NEXT:`-ParagraphComment {{.*}}<col:4, col:17>
+// AST-NEXT:`-TextComment {{.*}}<col:4, col:17> Text=" CBuffer decl."
+// AST-NEXT:-VarDecl {{.*}}<line:15:5, col:11> col:11 a 'float'
+// AST-NEXT:`-VarDecl {{.*}}<line:19:5, col:9> col:9 b 'int'
+// AST-NEXT:HLSLBufferDecl {{.*}}<line:29:1, line:38:1> line:29:9 tbuffer B
+// AST-NEXT:-FullComment {{.*}}<line:28:4, col:17>
+// AST-NEXT: `-ParagraphComment {{.*}}<col:4, col:17>
+// AST-NEXT:  `-TextComment {{.*}}<col:4, col:17> Text=" TBuffer decl."
+// AST-NEXT:-VarDecl {{.*}}<line:33:5, col:11> col:11 c 'float'
+// AST-NEXT:`-VarDecl {{.*}} <line:37:5, col:9> col:9 d 'int'

clang/test/AST/HLSL/cbuffer_tbuffer.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:5:9 cbuffer CB
+// CHECK-NEXT:VarDecl 0x[[A:[0-9a-f]+]] {{.*}} col:9 used a 'float'
+cbuffer CB {
+  float a;
+}
+
+// CHECK:HLSLBufferDecl 0x[[TB:[0-9a-f]+]] {{.*}} line:11:9 tbuffer TB
+// CHECK-NEXT:VarDecl 0x[[B:[0-9a-f]+]] {{.*}} col:9 used b 'float'
+tbuffer TB {
+  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/AST/HLSL/pch_hlsl_buffer.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl \
+// RUN:   -emit-pch -o %t %s
+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl \
+// RUN:   -include-pch %t -fsyntax-only -ast-dump-all %S/Inputs/empty.hlsl \
+// RUN: | FileCheck  %s
+
+cbuffer A {
+  float a;
+}
+
+tbuffer B {
+  float b;
+}
+
+float foo() {
+  return a + b;
+}
+// Make sure cbuffer/tbuffer works for PCH.
+// CHECK:HLSLBufferDecl 0x{{[0-9a-f]+}} <{{.*}}:7:1, line:9:1> line:7:9 imported <undeserialized declarations> cbuffer A
+// CHECK-NEXT:`-VarDecl 0x[[A:[0-9a-f]+]] <line:8:3, col:9> col:9 imported used a 'float'
+// CHECK-NEXT:HLSLBufferDecl 0x{{[0-9a-f]+}} <line:11:1, line:13:1> line:11:9 imported <undeserialized declarations> tbuffer B
+// CHECK-NEXT:`-VarDecl 0x[[B:[0-9a-f]+]] <line:12:3, col:9> col:9 imported used b 'float'
+// CHECK-NEXT:FunctionDecl 0x{{[0-9a-f]+}} <line:15:1, line:17:1> line:15:7 imported foo 'float ()'
+// CHECK-NEXT:CompoundStmt 0x{{[0-9a-f]+}} <col:13, line:17:1>
+// CHECK-NEXT:ReturnStmt 0x{{[0-9a-f]+}} <line:16:3, col:14>
+// CHECK-NEXT: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'

clang/test/ParserHLSL/cb_error.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -o - -fsyntax-only %s -verify
+
+// expected-error@+2 {{expected identifier}}
+// expected-error@+1 {{expected unqualified-id}}
+cbuffer { ... };
+// expected-error@+1 {{expected '{'}}
+cbuffer missing_definition;
+// expected-error@+1 {{expected unqualified-id}}
+int cbuffer;
+// expected-error@+1 {{expected identifier}}
+cbuffer;
+
+// expected-error@+2 {{expected identifier}}
+// expected-error@+1 {{expected unqualified-id}}
+tbuffer { ... };
+// expected-error@+1 {{expected '{'}}
+tbuffer missing_definition;
+// expected-error@+1 {{expected unqualified-id}}
+int tbuffer;
+// expected-error@+1 {{expected identifier}}
+tbuffer;
+
+// expected-error@+1 {{expected unqualified-id}}
+cbuffer A {}, B{}
+
+// cbuffer inside namespace is supported.
+namespace N {
+  cbuffer A {
+    float g;
+  }
+}
+
+cbuffer A {
+  // expected-error@+1 {{invalid declaration inside cbuffer}}
+  namespace N {
+  }
+}
+
+cbuffer A {
+  // expected-error@+1 {{invalid declaration inside cbuffer}}
+  cbuffer Nested {
+  }
+}
+
+struct S {
+  // expected-error@+1 {{expected member name or ';' after declaration specifiers}}
+  cbuffer what {
+    int y;
+  }
+};
+
+void func() {
+  // expected-error@+1 {{expected expression}}
+  tbuffer derp {
+    int z;
+  }
+
+  decltype(derp) another {
+    int a;
+  }
+}
+
+// struct decl inside cb is supported.
+cbuffer A {
+  struct S2 {
+    float s;
+  };
+  S2 s;
+}
+
+// function decl inside cb is supported.
+cbuffer A {
+  float foo_inside_cb() { return 1.2;}
+}

clang/test/ParserHLSL/invalid_inside_cb.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -o - -fsyntax-only %s -verify
+
+// template not allowed inside cbuffer.
+cbuffer A {
+    // expected-error@+2 {{invalid declaration inside cbuffer}}
+    template<typename T>
+    T foo(T t) { return t;}
+}
+
+cbuffer A {
+    // expected-error@+2 {{invalid declaration inside cbuffer}}
+    template<typename T>
+    struct S { float s;};
+}
+
+// typealias not allowed inside cbuffer.
+cbuffer A {
+    // expected-error@+2 {{invalid declaration inside cbuffer}}
+    // expected-warning@+1 {{alias declarations are a C++11 extension}}
+    using F32 = float;
+}

clang/test/SemaHLSL/cb_error.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -o - -fsyntax-only %s -verify
+
+// expected-note@+1 {{declared here}}
+cbuffer a {
+  int x;
+};
+
+int foo() {
+  // expected-error@+1 {{'a' does not refer to a value}}
+  return sizeof(a);
+}
+
+// expected-error@+1 {{expected unqualified-id}}
+template <typename Ty> cbuffer a { Ty f; };
+
+// For back-compat reason, it is OK for multiple cbuffer/tbuffer use same name in hlsl.
+// And these cbuffer name only used for reflection, cannot be removed.
+cbuffer A {
+  float A;
+}
+
+cbuffer A {
+  float b;
+}
+
+tbuffer A {
+  float a;
+}
+
+float bar() {
+  // cbuffer/tbuffer name will not conflict with other variables.
+  return A;
+}
+
+cbuffer a {
+  // expected-error@+2 {{unknown type name 'oh'}}
+  // expected-error@+1 {{expected ';' after top level declarator}}
+  oh no!
+  // expected-warning@+1 {{missing terminating ' character}}
+  this isn't even valid HLSL code
+  despite seeming totally reasonable
+  once you understand that HLSL
+  is so flaming weird.
+}
+
+tbuffer B {
+  // expected-error@+1 {{unknown type name 'flaot'}}
+  flaot f;
+}