[HLSL] CodeGen hlsl cbuffer/tbuffer.

[python3kgae]

Summary

cbuffer A {

float a;
float b;

}

will be translated to a global variable.

Something like

struct CB_Ty {

float a;
float b;

};

CB_Ty A;

And all use of a and b will be replaced with A.a and A.b.

Only support none-legacy cbuffer layout now.
CodeGen for Resource binding will be in separate patch.
In the separate patch, resource binding will map the resource information to the global variable.

[Anastasia]

clang/lib/CodeGen/CGHLSLRuntime.cpp

65

I don't think I understand the intent of this function along with CGHLSLRuntime::addConstant that populates this collection.

66

It might be better to avoid using hard-coded constants. Are you adding new entires in clang's AddressSpace enum to represent different logical memory segment of the language?

163

Is this case covered by the test?

clang/lib/CodeGen/CGHLSLRuntime.h

53

what does this field represent?

[python3kgae]

clang/lib/CodeGen/CGHLSLRuntime.cpp

163

Nice catch.
I'll add a test for this.

clang/lib/CodeGen/CGHLSLRuntime.h

53

The field is for marking the CBuffer as a cbuffer or tbuffer.
The name is confusing.
How about adding an enum BufferKind { CBuffer, TBuffer };?

[python3kgae]

clang/lib/CodeGen/CGHLSLRuntime.cpp

65

It is translating

 cbuffer A {
   float a;
   float b;
}
float foo() {
  return a + b;
}

into

struct cb.A.Ty {
  float a;
  float b;
};

cbuffer A {
  cb.A.Ty CBA;
}
float foo() {
  return CBA.a + CBA.b;
}

Both a and b are in the global scope and will get a GlobalVariable in clang codeGen.
By doing the translation, we can ensure each buffer map to one GlobalVariable and save cbuffer layout in the value type of that GlobalVariable.

66

Thanks for pointing it out. I'll add the new address space to LangAS.

[python3kgae]

Take care alignment when layout CBuffer.
Add hlsl_cbuffer/tbuffer to clang::LangAS.
Change CGHLSLRuntime::CBuffer to CGHLSLRuntime::Buffer to match HLSLBufferDecl.

[python3kgae]

Add more comments.

[python3kgae]

clang/lib/CodeGen/CGHLSLRuntime.cpp

163

Cannot add a test before other HLSL resource type like Texture2D is supported :(

clang/lib/CodeGen/CGHLSLRuntime.h

53

Change struct CBuffer into struct Buffer to match HLSLBufferDecl.

[beanz]

clang/lib/CodeGen/CGHLSLRuntime.cpp

163

Texture2D will be a CXXRecordDecl, not a HLSLBufferDecl, we only need buffer decls for the legacy buffers. So this should be testable by nesting a cbuffer inside a cbuffer right?

[python3kgae]

clang/lib/CodeGen/CGHLSLRuntime.cpp

163

I see.
I was thinking about test the error path.
I'll add a test for nested cbuffer.

[beanz]

clang/lib/Basic/Targets/SPIR.h

46 ↗

(On Diff #448407)

I don’t think you need this comment. Most of those adds space values aren’t applicable to these targets, that’s why they are all 0.

clang/lib/CodeGen/CGHLSLRuntime.cpp

276

Why look both of these values up when you’re only going to use one?

280

nit: Don’t use auto in places where the type isn’t obvious from the expression.

295

nit: Rather than using int max as a sentinel here, why not use an llvm::Optional?

[python3kgae]

Add test for nested cbuffer.

[python3kgae]

Remove useless comment.
Use llvm::Optional.
Use real type instead of auto.

[Anastasia]

clang/lib/CodeGen/CGHLSLRuntime.cpp

65

Ok, I see, so if we are to translate it to C it would be something similar to:

struct A {
   float a;
   float b;
} cbuffer_A __attribute__((address_space(256)));

float foo() {
  return cbuffer_A.a + cbuffer_A.b;
}

Maybe you can add some comments to explain the intent of this code at a higher level... not sure if the generation can reuse or be made a bit close to the regular C structs + address spaces...

124

btw is this covered in the test?

157

Ok I think you don't have this in the tests too and the one below?

274

I think it's better to use getTargetAddressSpace from ASTContext.

clang/test/CodeGenHLSL/nest_cbuf.hlsl

8 ↗

(On Diff #448435)

is this generated as nested structs?

[python3kgae]

Add more test and comment.
Also use getTargetAddressSpace.

[python3kgae]

clang/lib/CodeGen/CGHLSLRuntime.cpp

65

Added comments.
Will check how union is supported in clang codeGen. The behavior feels similar, hope could share some code.

clang/test/CodeGenHLSL/nest_cbuf.hlsl

8 ↗

(On Diff #448435)

No. This will generate as two separate structs.

[beanz]

clang/lib/CodeGen/CGHLSLRuntime.cpp

99

Why are you manually inserting padding?

IR level accesses don't require explicit layout, and we don't do this in DXC either.

[beanz]

Now that I'm seeing the code in D131370, I don't know that this is the right way to do things.

I think using address spaces like this is odd. Address spaces aren't really intended for use differentiating high level access types, but rather memory regions and properties of that memory. I feel like the use of address spaces in this change and in D131370 just makes it more complicated and gets in the way.

In DXIL, since we don't really have raw memory load and stores, none of these address spaces mean anything. It is probably just cleaner to not use address spaces in the CodeGen here either.

[python3kgae]

In D130131#3720552, @beanz wrote:

Now that I'm seeing the code in D131370, I don't know that this is the right way to do things.

I think using address spaces like this is odd. Address spaces aren't really intended for use differentiating high level access types, but rather memory regions and properties of that memory. I feel like the use of address spaces in this change and in D131370 just makes it more complicated and gets in the way.

In DXIL, since we don't really have raw memory load and stores, none of these address spaces mean anything. It is probably just cleaner to not use address spaces in the CodeGen here either.

If not use address space, how do llvm passes know a cbuffer ptr is different from a tbuffer ptr or ptr to a static global variable? Or llvm passes don't need to know the difference?

clang/lib/CodeGen/CGHLSLRuntime.cpp

99

Does DL take care of the alignment

[python3kgae]

Remove address space and manual align.

[python3kgae]

In D130131#3720552, @beanz wrote:

Now that I'm seeing the code in D131370, I don't know that this is the right way to do things.

I think using address spaces like this is odd. Address spaces aren't really intended for use differentiating high level access types, but rather memory regions and properties of that memory. I feel like the use of address spaces in this change and in D131370 just makes it more complicated and gets in the way.

In DXIL, since we don't really have raw memory load and stores, none of these address spaces mean anything. It is probably just cleaner to not use address spaces in the CodeGen here either.

Removed address space.
Also removed nested HLSLBuffer and namespace inside HLSLBuffer.

[python3kgae]

Remove nested HLSLBuffer and namespace inside HLSLBuffer.

[aaron.ballman]

clang/lib/CodeGen/CGHLSLRuntime.cpp

82–84

Please spell out these types.

102–103

Please spell out these types.

109

Same here

148

150–153

177

Please spell out the type.

clang/lib/CodeGen/CGHLSLRuntime.h

51

76

[python3kgae]

Code cleanup to match comments

[beanz]

This is looking great. Thank you for all your work iterating on this.

Please update the description to reflect the changes in implementation.

clang/lib/CodeGen/CGHLSLRuntime.cpp

121

Please remove the empty function. We can add it when it does something. Also make sure we have an issue for the FIXME.

138

Please file an issue for this or link to the issue if it exists.

[python3kgae]

Create issue for FIXME.

[aaron.ballman]

No additional comments from me, but I don't feel comfortable signing off on the codegen bits; adding some codegen code owners.

[beanz]

+@asl for codegen owner perspective.

This LGTM too. The changes here are well isolated to HLSL, so they should have no adverse impact on other language support.

@efriedma, @asl & @rjmccall any feedback?

[python3kgae]

gentle ping.

[efriedma]

clang/lib/CodeGen/CGDecl.cpp

132

I'm a little confused by this. If it's possible to declare an HLSLBuffer inside a function, why don't you need to handle it? If it isn't possible to declare an HLSLBuffer this way, can you just move this to use the llvm_unreachable()?

clang/lib/CodeGen/CGHLSLRuntime.cpp

113

Messing with globals like this feels a little weird, but I guess it's fine if nothing actually tries to use the erased globals after this code runs. I'm a little concerned that someone might accidentally rearrange the relevant code in the future (CodeGenModule has a bunch of maps which aren't cleared before this code runs).

[python3kgae]

Go llvm_unreachable is hit HLSLBuffer inside function.

[python3kgae]

clang/lib/CodeGen/CGDecl.cpp

132

Nice catch.
Fixed.

clang/lib/CodeGen/CGHLSLRuntime.cpp

113

These globals should not be in any map except Buf.Constants which is used here.
If another map has these globals, we should remove them from the map.
Cannot see any other map has these globals now.

[efriedma]

clang/lib/CodeGen/CGHLSLRuntime.cpp

113

Oh, I see. Probably not an issue in that case.

clang/lib/CodeGen/CGDecl.cpp

void CodeGenFunction::EmitDecl(const Decl &D) {
   case Decl::Block:
   case Decl::Captured:
   case Decl::ClassScopeFunctionSpecialization:
   case Decl::UsingShadow:
   case Decl::ConstructorUsingShadow:
   case Decl::ObjCTypeParam:
   case Decl::Binding:
   case Decl::UnresolvedUsingIfExists:
+  case Decl::HLSLBuffer:
     llvm_unreachable("Declaration should not be in declstmts!");
   case Decl::Record:    // struct/union/class X;
   case Decl::CXXRecord: // struct/union/class X; [C++]
     if (CGDebugInfo *DI = getDebugInfo())
       if (cast<RecordDecl>(D).getDefinition())
         DI->EmitAndRetainType(getContext().getRecordType(cast<RecordDecl>(&D)));
     return;
   case Decl::Enum:      // enum X;
void CodeGenFunction::EmitDecl(const Decl &D) {
   case Decl::OMPThreadPrivate:
   case Decl::OMPAllocate:
   case Decl::OMPCapturedExpr:
   case Decl::OMPRequires:
   case Decl::Empty:
   case Decl::Concept:
   case Decl::LifetimeExtendedTemporary:
   case Decl::RequiresExprBody:
     // None of these decls require codegen support.
     return;
 
   case Decl::NamespaceAlias:
     if (CGDebugInfo *DI = getDebugInfo())
         DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(D));
     return;
   case Decl::Using:          // using X; [C++]
     if (CGDebugInfo *DI = getDebugInfo())
void CodeGenFunction::EmitDecl(const Decl &D) {
   case Decl::TypeAlias: {  // using X = int; [C++0x]
     QualType Ty = cast<TypedefNameDecl>(D).getUnderlyingType();
     if (CGDebugInfo *DI = getDebugInfo())
       DI->EmitAndRetainType(Ty);
     if (Ty->isVariablyModifiedType())
       EmitVariablyModifiedType(Ty);
     return;
   }
-  case Decl::HLSLBuffer:
-    // FIXME: add codegen for HLSLBuffer.
-    return;
   }
 }
 
 /// EmitVarDecl - This method handles emission of any variable declaration
 /// inside a function, including static vars etc.
 void CodeGenFunction::EmitVarDecl(const VarDecl &D) {
   if (D.hasExternalStorage())
     // Don't emit it now, allow it to be emitted lazily on its first use.

clang/lib/CodeGen/CGHLSLRuntime.h

 
 #ifndef LLVM_CLANG_LIB_CODEGEN_CGHLSLRUNTIME_H
 #define LLVM_CLANG_LIB_CODEGEN_CGHLSLRUNTIME_H
 
 #include "llvm/IR/IRBuilder.h"
 
 #include "clang/Basic/HLSLRuntime.h"
 
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+
+#include <vector>
+
 namespace llvm {
 class GlobalVariable;
 class Function;
+class StructType;
 } // namespace llvm
+
 namespace clang {
 class VarDecl;
 class ParmVarDecl;
+class HLSLBufferDecl;
+class CallExpr;
+class Type;
+class DeclContext;
 
 class FunctionDecl;
 
 namespace CodeGen {
 
 class CodeGenModule;
 
 class CGHLSLRuntime {
+public:
+  struct Buffer {
+    Buffer(const HLSLBufferDecl *D);
+    llvm::StringRef Name;
+    // IsCBuffer - Whether the buffer is a cbuffer (and not a tbuffer).
+    bool IsCBuffer;
+    llvm::Optional<unsigned> Reg;
+    unsigned Space;
+    // Global variable and offset for each constant.
+    std::vector<std::pair<llvm::GlobalVariable *, unsigned>> Constants;
+    llvm::StructType *LayoutStruct = nullptr;
+  };
+
 protected:
   CodeGenModule &CGM;
   uint32_t ResourceCounters[static_cast<uint32_t>(
       hlsl::ResourceClass::NumClasses)] = {0};
 
   llvm::Value *emitInputSemantic(llvm::IRBuilder<> &B, const ParmVarDecl &D);
 
 public:
   CGHLSLRuntime(CodeGenModule &CGM) : CGM(CGM) {}
   virtual ~CGHLSLRuntime() {}
 
   void annotateHLSLResource(const VarDecl *D, llvm::GlobalVariable *GV);
   void generateGlobalCtorDtorCalls();
 
+  void addBuffer(const HLSLBufferDecl *D);
   void finishCodeGen();
 
   void setHLSLEntryAttributes(const FunctionDecl *FD, llvm::Function *Fn);
 
   void emitEntryFunction(const FunctionDecl *FD, llvm::Function *Fn);
+  void setHLSLFunctionAttributes(llvm::Function *, const FunctionDecl *);
+
+private:
+  void addConstant(VarDecl *D, Buffer &CB);
+  void addBufferDecls(const DeclContext *DC, Buffer &CB);
+  llvm::SmallVector<Buffer> Buffers;
 };
 
 } // namespace CodeGen
 } // namespace clang
 
 #endif

clang/lib/CodeGen/CGHLSLRuntime.cpp

 //===----- CGHLSLRuntime.cpp - Interface to HLSL Runtimes -----------------===//
 //
 // 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 provides an abstract class for HLSL code generation.  Concrete
 // subclasses of this implement code generation for specific HLSL
 // runtime libraries.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CGHLSLRuntime.h"
+#include "CGDebugInfo.h"
 #include "CodeGenModule.h"
 #include "clang/AST/Decl.h"
 #include "clang/Basic/TargetOptions.h"
 #include "llvm/IR/IntrinsicsDirectX.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/FormatVariadic.h"
 
 using namespace clang;
 using namespace CodeGen;
 using namespace hlsl;
 using namespace llvm;
 
 namespace {
+
 void addDxilValVersion(StringRef ValVersionStr, llvm::Module &M) {
   // The validation of ValVersionStr is done at HLSLToolChain::TranslateArgs.
   // Assume ValVersionStr is legal here.
   VersionTuple Version;
   if (Version.tryParse(ValVersionStr) || Version.getBuild() ||
       Version.getSubminor() || !Version.getMinor()) {
     return;
   }
 
   uint64_t Major = Version.getMajor();
   uint64_t Minor = *Version.getMinor();
 
   auto &Ctx = M.getContext();
   IRBuilder<> B(M.getContext());
   MDNode *Val = MDNode::get(Ctx, {ConstantAsMetadata::get(B.getInt32(Major)),
                                   ConstantAsMetadata::get(B.getInt32(Minor))});
   StringRef DXILValKey = "dx.valver";
   auto *DXILValMD = M.getOrInsertNamedMetadata(DXILValKey);
   DXILValMD->addOperand(Val);
 }
 void addDisableOptimizations(llvm::Module &M) {
   StringRef Key = "dx.disable_optimizations";
   M.addModuleFlag(llvm::Module::ModFlagBehavior::Override, Key, 1);
 }
+// cbuffer will be translated into global variable in special address space.
+// If translate into C,
+// cbuffer A {
+//   float a;
+//   float b;
+// }
+// float foo() { return a + b; }
+//
+// will be translated into
+//
+// struct A {
+//   float a;
+//   float b;
+// } cbuffer_A __attribute__((address_space(4)));
+// float foo() { return cbuffer_A.a + cbuffer_A.b; }
+//
+// layoutBuffer will create the struct A type.
+// replaceBuffer will replace use of global variable a and b with cbuffer_A.a
+// and cbuffer_A.b.
+//
+void layoutBuffer(CGHLSLRuntime::Buffer &Buf, const DataLayout &DL) {
+  if (Buf.Constants.empty())
+    return;
+
+  std::vector<llvm::Type *> EltTys;
+  for (auto &Const : Buf.Constants) {
+    GlobalVariable *GV = Const.first;
+    Const.second = EltTys.size();
+    llvm::Type *Ty = GV->getValueType();
+    EltTys.emplace_back(Ty);
+  }
+  Buf.LayoutStruct = llvm::StructType::get(EltTys[0]->getContext(), EltTys);
+}
+
+GlobalVariable *replaceBuffer(CGHLSLRuntime::Buffer &Buf) {
+  // Create global variable for CB.
+  GlobalVariable *CBGV =
+      new GlobalVariable(Buf.LayoutStruct, /*isConstant*/ true,
+                         GlobalValue::LinkageTypes::ExternalLinkage, nullptr,
+                         Buf.Name + (Buf.IsCBuffer ? ".cb." : ".tb."),
+                         GlobalValue::NotThreadLocal);
+
+  IRBuilder<> B(CBGV->getContext());
+  Value *ZeroIdx = B.getInt32(0);
+  // Replace Const use with CB use.
+  for (auto &Const : Buf.Constants) {
+    llvm::Type *EltTy = Buf.LayoutStruct->getElementType(Const.second);
+    GlobalVariable *GV = Const.first;
+    unsigned Offset = Const.second;
+
+    Value *GEP =
+        B.CreateGEP(Buf.LayoutStruct, CBGV, {ZeroIdx, B.getInt32(Offset)});
+
+    llvm::Type *GVTy = GV->getValueType();
+    assert(EltTy == GVTy && "constant type mismatch");
+
+    // Replace.
+    GV->replaceAllUsesWith(GEP);
+    // Erase GV.
+    GV->removeDeadConstantUsers();
+    GV->eraseFromParent();
+  }
+  return CBGV;
+}
 
 } // namespace
 
+void CGHLSLRuntime::addConstant(VarDecl *D, Buffer &CB) {
+  if (D->getStorageClass() == SC_Static) {
+    // For static inside cbuffer, take as global static.
+    // Don't add to cbuffer.
+    CGM.EmitGlobal(D);
+    return;
+  }
+
+  auto *GV = cast<GlobalVariable>(CGM.GetAddrOfGlobalVar(D));
+  // Add debug info for constVal.
+  if (CGDebugInfo *DI = CGM.getModuleDebugInfo())
+    if (CGM.getCodeGenOpts().getDebugInfo() >=
+        codegenoptions::DebugInfoKind::LimitedDebugInfo)
+      DI->EmitGlobalVariable(cast<GlobalVariable>(GV), D);
+
+  // FIXME: support packoffset.
+  // See https://github.com/llvm/llvm-project/issues/57914.
+  uint32_t Offset = 0;
+  bool HasUserOffset = false;
+
+  unsigned LowerBound = HasUserOffset ? Offset : UINT_MAX;
+  CB.Constants.emplace_back(std::make_pair(GV, LowerBound));
+}
+
+void CGHLSLRuntime::addBufferDecls(const DeclContext *DC, Buffer &CB) {
+  for (Decl *it : DC->decls()) {
+    if (auto *ConstDecl = dyn_cast<VarDecl>(it)) {
+      addConstant(ConstDecl, CB);
+    } else if (isa<CXXRecordDecl, EmptyDecl>(it)) {
+      // Nothing to do for this declaration.
+    } else if (isa<FunctionDecl>(it)) {
+      // A function within an cbuffer is effectively a top-level function,
+      // as it only refers to globally scoped declarations.
+      CGM.EmitTopLevelDecl(it);
+    }
+  }
+}
+
+void CGHLSLRuntime::addBuffer(const HLSLBufferDecl *D) {
+  Buffers.emplace_back(Buffer(D));
+  addBufferDecls(D, Buffers.back());
+}
+
 void CGHLSLRuntime::finishCodeGen() {
   auto &TargetOpts = CGM.getTarget().getTargetOpts();
   llvm::Module &M = CGM.getModule();
   Triple T(M.getTargetTriple());
   if (T.getArch() == Triple::ArchType::dxil)
     addDxilValVersion(TargetOpts.DxilValidatorVersion, M);
 
   generateGlobalCtorDtorCalls();
   if (CGM.getCodeGenOpts().OptimizationLevel == 0)
     addDisableOptimizations(M);
+
+  const DataLayout &DL = M.getDataLayout();
+
+  for (auto &Buf : Buffers) {
+    layoutBuffer(Buf, DL);
+    GlobalVariable *GV = replaceBuffer(Buf);
+    M.getGlobalList().push_back(GV);
+    // FIXME: generate resource binding.
+    // See https://github.com/llvm/llvm-project/issues/57915.
+  }
+}
+
+CGHLSLRuntime::Buffer::Buffer(const HLSLBufferDecl *D) {
+  Name = D->getName();
+  IsCBuffer = D->isCBuffer();
+  if (auto *Binding = D->getAttr<HLSLResourceBindingAttr>()) {
+    llvm::APInt RegInt(64, 0);
+    Binding->getSlot().substr(1).getAsInteger(10, RegInt);
+    Reg = RegInt.getLimitedValue();
+
+    llvm::APInt SpaceInt(64, 0);
+    Binding->getSpace().substr(5).getAsInteger(10, RegInt);
+    Space = SpaceInt.getLimitedValue();
+  } else {
+    Space = 0;
+  }
 }
 
 void CGHLSLRuntime::annotateHLSLResource(const VarDecl *D, GlobalVariable *GV) {
   const Type *Ty = D->getType()->getPointeeOrArrayElementType();
   if (!Ty)
     return;
   const auto *RD = Ty->getAsCXXRecordDecl();
   if (!RD)

 
 void CGHLSLRuntime::emitEntryFunction(const FunctionDecl *FD,
                                       llvm::Function *Fn) {
   llvm::Module &M = CGM.getModule();
   llvm::LLVMContext &Ctx = M.getContext();
   auto *EntryTy = llvm::FunctionType::get(llvm::Type::getVoidTy(Ctx), false);
   Function *EntryFn =
       Function::Create(EntryTy, Function::ExternalLinkage, FD->getName(), &M);
 
   // Copy function attributes over, we have no argument or return attributes
   // that can be valid on the real entry.
   AttributeList NewAttrs = AttributeList::get(Ctx, AttributeList::FunctionIndex,
                                               Fn->getAttributes().getFnAttrs());
   EntryFn->setAttributes(NewAttrs);
   setHLSLEntryAttributes(FD, EntryFn);
 
   // Set the called function as internal linkage.
   Fn->setLinkage(GlobalValue::InternalLinkage);
 
   BasicBlock *BB = BasicBlock::Create(Ctx, "entry", EntryFn);
   IRBuilder<> B(BB);
   llvm::SmallVector<Value *> Args;
   // FIXME: support struct parameters where semantics are on members.
   // See: https://github.com/llvm/llvm-project/issues/57874
   for (const auto *Param : FD->parameters()) {
     Args.push_back(emitInputSemantic(B, *Param));
   }
 
   CallInst *CI = B.CreateCall(FunctionCallee(Fn), Args);
   (void)CI;
   // FIXME: Handle codegen for return type semantics.
   // See: https://github.com/llvm/llvm-project/issues/57875
   B.CreateRetVoid();
 }
 
 static void gatherFunctions(SmallVectorImpl<Function *> &Fns, llvm::Module &M,
                             bool CtorOrDtor) {
   const auto *GV =

clang/lib/CodeGen/CodeGenModule.cpp

case Decl::Record:
     break;
 
   case Decl::Enum:
     if (CGDebugInfo *DI = getModuleDebugInfo())
       if (cast<EnumDecl>(D)->getDefinition())
         DI->EmitAndRetainType(getContext().getEnumType(cast<EnumDecl>(D)));
     break;
 
+  case Decl::HLSLBuffer:
+    getHLSLRuntime().addBuffer(cast<HLSLBufferDecl>(D));
+    break;
+
   default:
     // Make sure we handled everything we should, every other kind is a
     // non-top-level decl.  FIXME: Would be nice to have an isTopLevelDeclKind
     // function. Need to recode Decl::Kind to do that easily.
     assert(isa<TypeDecl>(D) && "Unsupported decl kind");
     break;
   }
 }

clang/test/CodeGenHLSL/cbuf.hlsl

+// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \
+// RUN:   dxil-pc-shadermodel6.3-library %s \
+// RUN:   -emit-llvm -disable-llvm-passes -o - | FileCheck %s
+
+// CHECK: @[[CB:.+]] = external constant { float, double }
+cbuffer A : register(b0, space1) {
+  float a;
+  double b;
+}
+
+// CHECK: @[[TB:.+]] = external constant { float, double }
+tbuffer A : register(t2, space1) {
+  float c;
+  double d;
+}
+
+float foo() {
+// CHECK: load float, ptr @[[CB]], align 4
+// CHECK: load double, ptr getelementptr inbounds ({ float, double }, ptr @[[CB]], i32 0, i32 1), align 8
+// CHECK: load float, ptr @[[TB]], align 4
+// CHECK: load double, ptr getelementptr inbounds ({ float, double }, ptr @[[TB]], i32 0, i32 1), align 8
+  return a + b + c*d;
+}

clang/test/CodeGenHLSL/cbuf_in_namespace.hlsl

+// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \
+// RUN:   dxil-pc-shadermodel6.3-library %s \
+// RUN:   -emit-llvm -disable-llvm-passes -o - | FileCheck %s
+
+// Make sure cbuffer inside namespace works.
+// CHECK: @[[CB:.+]] = external constant { float }
+// CHECK: @[[TB:.+]] = external constant { float }
+namespace n0 {
+namespace n1 {
+  cbuffer A {
+    float a;
+  }
+}
+  tbuffer B {
+    float b;
+  }
+}
+
+float foo() {
+// CHECK: load float, ptr @[[CB]], align 4
+// CHECK: load float, ptr @[[TB]], align 4
+  return n0::n1::a + n0::b;
+}

clang/test/CodeGenHLSL/static_global_and_function_in_cb.hlsl

+// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \
+// RUN:   dxil-pc-shadermodel6.3-library %s \
+// RUN:   -emit-llvm -disable-llvm-passes -o - | FileCheck %s
+
+// CHECK-DAG: @[[CB:.+]] = external constant { float }
+
+cbuffer A {
+    float a;
+  // CHECK-DAG:@b = internal global float 3.000000e+00, align 4
+  static float b = 3;
+  // CHECK:load float, ptr @[[CB]], align 4
+  // CHECK:load float, ptr @b, align 4
+  float foo() { return a + b; }
+}
+
+float bar() {
+  return foo();
+}