AMDGPU: Rename MaxFlatWorkgroupSize to MaxFlatWorkGroupSize for consistency

[kzhuravl]

Summary

It seems like all other places use WorkGroup (attributes, function names, etc.)

[kzhuravl]

Rebase.

[t-tye]

LGTM

docs/AMDGPUUsage.rst

"NumSGPRs"                   integer                  Number of scalar
                                                            enabled. It is not
                                                            rounded up to the
                                                            allocation
                                                            granularity.
      "NumVGPRs"                   integer                  Number of vector
                                                            registers used by
                                                            each work-item for
                                                            GFX6-GFX9
-     "MaxFlatWorkgroupSize"       integer                  Maximum flat
+     "MaxFlatWorkGroupSize"       integer                  Maximum flat
                                                            work-group size
                                                            supported by the
                                                            kernel in work-items.
      "IsDynamicCallStack"         boolean                  Indicates if the
                                                            generated machine
                                                            code is using a
                                                            dynamically sized
                                                            call stack.
.. table:: Kernel Descriptor for GFX6-GFX9
      63:32   4 bytes PrivateSegmentFixedSize         The amount of fixed
                                                      private address space
                                                      memory required for a
                                                      work-item in bytes. If
                                                      is_dynamic_callstack is 1
                                                      then additional space must
                                                      be added to this value for
                                                      the call stack.
-     95:64   4 bytes MaxFlatWorkgroupSize            Maximum flat work-group
+     95:64   4 bytes MaxFlatWorkGroupSize            Maximum flat work-group
                                                      size supported by the
                                                      kernel in work-items.
      96      1 bit   IsDynamicCallStack              Indicates if the generated
                                                      machine code is using a
                                                      dynamically sized call
                                                      stack.
      97      1 bit   IsXNACKEnabled                  Indicates if the generated
                                                      machine code is capable of

include/llvm/Support/AMDGPUKernelDescriptor.h

enum ComputePgmRsrc2 {
   AMDGPU_BITS_ENUM_ENTRY(RESERVED1, 31, 1),
 };
 
 /// \brief Kernel descriptor layout. This layout should be kept backwards
 /// compatible as it is consumed by the command processor.
 struct KernelDescriptor final {
   uint32_t GroupSegmentFixedSize;
   uint32_t PrivateSegmentFixedSize;
-  uint32_t MaxFlatWorkgroupSize;
+  uint32_t MaxFlatWorkGroupSize;
   uint64_t IsDynamicCallStack : 1;
   uint64_t IsXNACKEnabled : 1;
   uint64_t Reserved0 : 30;
   int64_t KernelCodeEntryByteOffset;
   uint64_t Reserved1[3];
   uint32_t ComputePgmRsrc1;
   uint32_t ComputePgmRsrc2;
   uint64_t EnableSGPRPrivateSegmentBuffer : 1;

include/llvm/Support/AMDGPUMetadata.h

 /// \brief Key for Kernel::CodeProps::Metadata::mKernargSegmentAlign.
 constexpr char KernargSegmentAlign[] = "KernargSegmentAlign";
 /// \brief Key for Kernel::CodeProps::Metadata::mWavefrontSize.
 constexpr char WavefrontSize[] = "WavefrontSize";
 /// \brief Key for Kernel::CodeProps::Metadata::mNumSGPRs.
 constexpr char NumSGPRs[] = "NumSGPRs";
 /// \brief Key for Kernel::CodeProps::Metadata::mNumVGPRs.
 constexpr char NumVGPRs[] = "NumVGPRs";
-/// \brief Key for Kernel::CodeProps::Metadata::mMaxFlatWorkgroupSize.
-constexpr char MaxFlatWorkgroupSize[] = "MaxFlatWorkgroupSize";
+/// \brief Key for Kernel::CodeProps::Metadata::mMaxFlatWorkGroupSize.
+constexpr char MaxFlatWorkGroupSize[] = "MaxFlatWorkGroupSize";
 /// \brief Key for Kernel::CodeProps::Metadata::mIsDynamicCallStack.
 constexpr char IsDynamicCallStack[] = "IsDynamicCallStack";
 /// \brief Key for Kernel::CodeProps::Metadata::mIsXNACKEnabled.
 constexpr char IsXNACKEnabled[] = "IsXNACKEnabled";
 } // end namespace Key
 
 /// \brief In-memory representation of kernel code properties metadata.
 struct Metadata final {
struct Metadata final {
   uint32_t mKernargSegmentAlign = 0;
   /// \brief Wavefront size. Required.
   uint32_t mWavefrontSize = 0;
   /// \brief Total number of SGPRs used by a wavefront. Optional.
   uint16_t mNumSGPRs = 0;
   /// \brief Total number of VGPRs used by a workitem. Optional.
   uint16_t mNumVGPRs = 0;
   /// \brief Maximum flat work-group size supported by the kernel. Optional.
-  uint32_t mMaxFlatWorkgroupSize = 0;
+  uint32_t mMaxFlatWorkGroupSize = 0;
   /// \brief True if the generated machine code is using a dynamically sized
   /// call stack. Optional.
   bool mIsDynamicCallStack = false;
   /// \brief True if the generated machine code is capable of supporting XNACK.
   /// Optional.
   bool mIsXNACKEnabled = false;
 
   /// \brief Default constructor.

lib/Support/AMDGPUMetadata.cpp

static void mapping(IO &YIO, Kernel::CodeProps::Metadata &MD) {
     YIO.mapRequired(Kernel::CodeProps::Key::KernargSegmentAlign,
                     MD.mKernargSegmentAlign);
     YIO.mapRequired(Kernel::CodeProps::Key::WavefrontSize,
                     MD.mWavefrontSize);
     YIO.mapOptional(Kernel::CodeProps::Key::NumSGPRs,
                     MD.mNumSGPRs, uint16_t(0));
     YIO.mapOptional(Kernel::CodeProps::Key::NumVGPRs,
                     MD.mNumVGPRs, uint16_t(0));
-    YIO.mapOptional(Kernel::CodeProps::Key::MaxFlatWorkgroupSize,
-                    MD.mMaxFlatWorkgroupSize, uint32_t(0));
+    YIO.mapOptional(Kernel::CodeProps::Key::MaxFlatWorkGroupSize,
+                    MD.mMaxFlatWorkGroupSize, uint32_t(0));
     YIO.mapOptional(Kernel::CodeProps::Key::IsDynamicCallStack,
                     MD.mIsDynamicCallStack, false);
     YIO.mapOptional(Kernel::CodeProps::Key::IsXNACKEnabled,
                     MD.mIsXNACKEnabled, false);
   }
 };
 
 template <>

lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

HSACodeProps.mKernargSegmentSize =
       STM.getKernArgSegmentSize(MF, MFI.getABIArgOffset());
   HSACodeProps.mGroupSegmentFixedSize = ProgramInfo.LDSSize;
   HSACodeProps.mPrivateSegmentFixedSize = ProgramInfo.ScratchSize;
   HSACodeProps.mKernargSegmentAlign =
       std::max(uint32_t(4), MFI.getMaxKernArgAlign());
   HSACodeProps.mWavefrontSize = STM.getWavefrontSize();
   HSACodeProps.mNumSGPRs = CurrentProgramInfo.NumSGPR;
   HSACodeProps.mNumVGPRs = CurrentProgramInfo.NumVGPR;
-  HSACodeProps.mMaxFlatWorkgroupSize = MFI.getMaxFlatWorkGroupSize();
+  HSACodeProps.mMaxFlatWorkGroupSize = MFI.getMaxFlatWorkGroupSize();
   HSACodeProps.mIsDynamicCallStack = ProgramInfo.DynamicCallStack;
   HSACodeProps.mIsXNACKEnabled = STM.isXNACKEnabled();
 
   return HSACodeProps;
 }
 
 AMDGPU::HSAMD::Kernel::DebugProps::Metadata AMDGPUAsmPrinter::getHSADebugProps(
     const MachineFunction &MF,

test/CodeGen/AMDGPU/attr-amdgpu-flat-work-group-size.ll

define amdgpu_kernel void @min_1024_max_2048() #3 {
   ret void
 }
 attributes #3 = {"amdgpu-flat-work-group-size"="1024,2048"}
 
 ; HSAMD: NT_AMD_AMDGPU_HSA_METADATA (HSA Metadata)
 ; HSAMD: Version: [ 1, 0 ]
 ; HSAMD: Kernels:
 ; HSAMD: - Name:                 min_64_max_64
-; HSAMD:   MaxFlatWorkgroupSize: 64
+; HSAMD:   MaxFlatWorkGroupSize: 64
 ; HSAMD: - Name:                 min_64_max_128
-; HSAMD:   MaxFlatWorkgroupSize: 128
+; HSAMD:   MaxFlatWorkGroupSize: 128
 ; HSAMD: - Name:                 min_128_max_128
-; HSAMD:   MaxFlatWorkgroupSize: 128
+; HSAMD:   MaxFlatWorkGroupSize: 128
 ; HSAMD: - Name:                 min_1024_max_2048
-; HSAMD:   MaxFlatWorkgroupSize: 2048
+; HSAMD:   MaxFlatWorkGroupSize: 2048

test/CodeGen/AMDGPU/hsa-metadata-kernel-code-props.ll

 ; CHECK:        KernargSegmentAlign:     8
 ; CHECK:        WavefrontSize:           64
 ; GFX700:       NumSGPRs:                6
 ; GFX800:       NumSGPRs:                96
 ; GFX900:       NumSGPRs:                6
 ; GFX700:       NumVGPRs:                4
 ; GFX800:       NumVGPRs:                6
 ; GFX900:       NumVGPRs:                6
-; CHECK:        MaxFlatWorkgroupSize:    256
+; CHECK:        MaxFlatWorkGroupSize:    256
 define amdgpu_kernel void @test(
     half addrspace(1)* %r,
     half addrspace(1)* %a,
     half addrspace(1)* %b) {
 entry:
   %a.val = load half, half addrspace(1)* %a
   %b.val = load half, half addrspace(1)* %b
   %r.val = fadd half %a.val, %b.val
   store half %r.val, half addrspace(1)* %r
   ret void
 }

test/MC/AMDGPU/hsa-metadata-kernel-code-props.s

 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx700 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX700 %s
 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx800 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX800 %s
 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx900 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX900 %s
 
 // CHECK:  .amd_amdgpu_hsa_metadata
 // CHECK:    Version: [ 1, 0 ]
 // CHECK:    Kernels:
 // CHECK:      - Name:       test_kernel
 // CHECK:        SymbolName: 'test_kernel@kd'
 // CHECK:        CodeProps:
 // CHECK:          KernargSegmentSize:      24
 // CHECK:          GroupSegmentFixedSize:   24
 // CHECK:          PrivateSegmentFixedSize: 16
 // CHECK:          KernargSegmentAlign:     16
 // CHECK:          WavefrontSize:           64
-// CHECK:          MaxFlatWorkgroupSize:    256
+// CHECK:          MaxFlatWorkGroupSize:    256
 .amd_amdgpu_hsa_metadata
   Version: [ 1, 0 ]
   Printf: [ '1:1:4:%d\n', '2:1:8:%g\n' ]
   Kernels:
     - Name:            test_kernel
       SymbolName:      test_kernel@kd
       CodeProps:
         KernargSegmentSize:      24
         GroupSegmentFixedSize:   24
         PrivateSegmentFixedSize: 16
         KernargSegmentAlign:     16
         WavefrontSize:           64
-        MaxFlatWorkgroupSize:    256
+        MaxFlatWorkGroupSize:    256
 .end_amd_amdgpu_hsa_metadata