Respond to more feedback

Separate out the load store lowering functions from the pass class
 in vector scalarization pass

Calculate load size on scalar element rather than resret element type to
get correct alignment on scalars instead of on the whole vector.
Adjust various tests accordingly that depended on or used code generated
with the incorrect alignment, which always just hit the max of 8.

Change iteration through matching intrinsics in link scalarization pass

Capitalize varibles according to coding standards

Include and remove whitespace in tests.

Author: Greg Roth

lib/HLSL/DxilScalarizeVectorLoadStores.cpp

@@ -24,13 +24,12 @@
 using namespace llvm;
 using namespace hlsl;
 
-class DxilScalarizeVectorLoadStores : public ModulePass {
-private:
-  void scalarizeVectorLoad(hlsl::OP *HlslOP, const DataLayout &DL,
-                           CallInst *CI);
-  void scalarizeVectorStore(hlsl::OP *HlslOP, const DataLayout &DL,
-                            CallInst *CI);
+static void scalarizeVectorLoad(hlsl::OP *HlslOP, const DataLayout &DL,
+                                CallInst *CI);
+static void scalarizeVectorStore(hlsl::OP *HlslOP, const DataLayout &DL,
+                                 CallInst *CI);
 
+class DxilScalarizeVectorLoadStores : public ModulePass {
 public:
   static char ID; // Pass identification, replacement for typeid
   explicit DxilScalarizeVectorLoadStores() : ModulePass(ID) {}
@@ -48,25 +47,22 @@ class DxilScalarizeVectorLoadStores : public ModulePass {
     bool Changed = false;
 
     hlsl::OP *HlslOP = DM.GetOP();
-    for (auto F = M.functions().begin(), E = M.functions().end(); F != E;) {
-      Function *Func = &*(F++);
-      DXIL::OpCodeClass OpClass;
-      if (HlslOP->GetOpCodeClass(Func, OpClass)) {
-        if (OpClass == DXIL::OpCodeClass::RawBufferVectorLoad) {
-          for (auto U = Func->user_begin(), UE = Func->user_end(); U != UE;) {
-            CallInst *CI = cast<CallInst>(*(U++));
-            scalarizeVectorLoad(HlslOP, M.getDataLayout(), CI);
-            Changed = true;
-          }
-          Func->eraseFromParent();
-        } else if (OpClass == DXIL::OpCodeClass::RawBufferVectorStore) {
-          for (auto U = Func->user_begin(), UE = Func->user_end(); U != UE;) {
-            CallInst *CI = cast<CallInst>(*(U++));
-            scalarizeVectorStore(HlslOP, M.getDataLayout(), CI);
-            Changed = true;
-          }
-          Func->eraseFromParent();
-        }
+    for (auto FIt : HlslOP->GetOpFuncList(DXIL::OpCode::RawBufferVectorLoad)) {
+      Function *Func = FIt.second;
+      if (!Func) continue;
+      for (auto U = Func->user_begin(), UE = Func->user_end(); U != UE;) {
+        CallInst *CI = cast<CallInst>(*(U++));
+        scalarizeVectorLoad(HlslOP, M.getDataLayout(), CI);
+        Changed = true;
+      }
+    }
+    for (auto FIt : HlslOP->GetOpFuncList(DXIL::OpCode::RawBufferVectorStore)) {
+      Function *Func = FIt.second;
+      if (!Func) continue;
+      for (auto U = Func->user_begin(), UE = Func->user_end(); U != UE;) {
+        CallInst *CI = cast<CallInst>(*(U++));
+        scalarizeVectorStore(HlslOP, M.getDataLayout(), CI);
+        Changed = true;
       }
     }
     return Changed;
@@ -90,16 +86,15 @@ static unsigned GetRawBufferMask(unsigned NumComponents) {
   return DXIL::kCompMask_All;
 }
 
-void DxilScalarizeVectorLoadStores::scalarizeVectorLoad(hlsl::OP *HlslOP,
-                                                        const DataLayout &DL,
-                                                        CallInst *CI) {
+static void scalarizeVectorLoad(hlsl::OP *HlslOP, const DataLayout &DL,
+                                CallInst *CI) {
   IRBuilder<> Builder(CI);
   // Collect the information required to break this into scalar ops from args.
   DxilInst_RawBufferVectorLoad VecLd(CI);
   OP::OpCode OpCode = OP::OpCode::RawBufferLoad;
-  llvm::Constant *opArg = Builder.getInt32((unsigned)OpCode);
+  llvm::Constant *OpArg = Builder.getInt32((unsigned)OpCode);
   SmallVector<Value *, 10> Args;
-  Args.emplace_back(opArg);                     // opcode @0.
+  Args.emplace_back(OpArg);                     // opcode @0.
   Args.emplace_back(VecLd.get_buf());           // Resource handle @1.
   Args.emplace_back(VecLd.get_index());         // Index @2.
   Args.emplace_back(VecLd.get_elementOffset()); // Offset @3.
@@ -161,16 +156,15 @@ void DxilScalarizeVectorLoadStores::scalarizeVectorLoad(hlsl::OP *HlslOP,
   CI->eraseFromParent();
 }
 
-void DxilScalarizeVectorLoadStores::scalarizeVectorStore(hlsl::OP *HlslOP,
-                                                         const DataLayout &DL,
-                                                         CallInst *CI) {
+static void scalarizeVectorStore(hlsl::OP *HlslOP, const DataLayout &DL,
+                                 CallInst *CI) {
   IRBuilder<> Builder(CI);
   // Collect the information required to break this into scalar ops from args.
   DxilInst_RawBufferVectorStore VecSt(CI);
   OP::OpCode OpCode = OP::OpCode::RawBufferStore;
-  llvm::Constant *opArg = Builder.getInt32((unsigned)OpCode);
+  llvm::Constant *OpArg = Builder.getInt32((unsigned)OpCode);
   SmallVector<Value *, 10> Args;
-  Args.emplace_back(opArg);                     // opcode @0.
+  Args.emplace_back(OpArg);                     // opcode @0.
   Args.emplace_back(VecSt.get_uav());           // Resource handle @1.
   Args.emplace_back(VecSt.get_index());         // Index @2.
   Args.emplace_back(VecSt.get_elementOffset()); // Offset @3.

lib/HLSL/HLOperationLower.cpp

@@ -4179,6 +4179,9 @@ Value *TranslateBufLoad(ResLoadHelper &helper, HLResource::Kind RK,
   if (isBool || (is64 && isTyped))
     EltTy = Builder.getInt32Ty();
 
+  // Calculate load size with the scalar memory element type.
+  unsigned LdSize = DL.getTypeAllocSize(EltTy);
+
   // Adjust number of components as needed.
   if (is64 && isTyped) {
     // 64-bit types are stored as int32 pairs in typed buffers.
@@ -4190,7 +4193,6 @@ Value *TranslateBufLoad(ResLoadHelper &helper, HLResource::Kind RK,
     NumComponents = 1;
   }
 
-  unsigned LdSize = DL.getTypeAllocSize(EltTy);
   SmallVector<Value *, 10> Args = GetBufLoadArgs(helper, RK, Builder, LdSize);
 
   // Keep track of the first load for debug info migration.

tools/clang/test/CodeGenDXIL/hlsl/intrinsics/buffer-load-stores-sm69.hlsl

@@ -15,11 +15,11 @@
 
 // CHECK: %dx.types.ResRet.[[VTY:v[0-9]*[a-z][0-9][0-9]]] = type { <[[NUM:[0-9]*]] x [[TYPE:[a-z_0-9]*]]>, i32 }
 
-  ByteAddressBuffer RoByBuf : register(t1);
+ByteAddressBuffer RoByBuf : register(t1);
 RWByteAddressBuffer RwByBuf : register(u1);
 
-StructuredBuffer< vector<TYPE, NUM> > RoStBuf : register(t2);
-RWStructuredBuffer< vector<TYPE, NUM>  > RwStBuf : register(u2);
+StructuredBuffer<vector<TYPE, NUM> > RoStBuf : register(t2);
+RWStructuredBuffer<vector<TYPE, NUM> > RwStBuf : register(u2);
 
 ConsumeStructuredBuffer<vector<TYPE, NUM> > CnStBuf : register(u4);
 AppendStructuredBuffer<vector<TYPE, NUM> > ApStBuf  : register(u5);