[MLIR] Remove document references to gpu.kernel_module and gpu.kernel.

[tpopp]

Summary

These have been replaced from attributes to operations gpu.module and
gpu.func respectively.

[frgossen]

Thank you.

mlir/include/mlir/Dialect/GPU/GPUOps.td

266

The kernel is now identified with a single nested symbol attribute kernel (https://github.com/llvm/llvm-project/commit/0372db05bb1552c2b39fc735f949977e0a863a25). I should have updated this, sorry.

[tpopp]

Update comment on the kernel attribute of gpu.launch_func.

mlir/docs/Dialects/SPIR-V.md

 returns an SSA value generated from an `spv._address_of` operation.
 
 ### Current conversions to SPIR-V
 
 Using the above infrastructure, conversions are implemented from
 
 *   [Standard Dialect][MlirStandardDialect] : Only arithmetic and logical
     operations conversions are implemented.
-*   [GPU Dialect][MlirGpuDialect] : A module with the attribute
-    `gpu.kernel_module` is converted to a `spv.module`. A function within this
-    module with the attribute `gpu.kernel` is lowered as an entry function.
+*   [GPU Dialect][MlirGpuDialect] : A gpu.module is converted to a `spv.module`.
+    A gpu.function within this module is lowered as an entry function.
 
 ## Code organization
 
 We aim to provide multiple libraries with clear dependencies for SPIR-V related
 functionalities in MLIR so developers can just choose the needed components
 without pulling in the whole world.
 
 ### The dialect

mlir/include/mlir/Dialect/GPU/GPUOps.td

def GPU_LaunchFuncOp : GPU_Op<"launch_func">,
   let summary = "Launches a function as a GPU kerneel";
 
   let description = [{
     Launch a kernel function on the specified grid of thread blocks.
     `gpu.launch` operations are lowered to `gpu.launch_func` operations by
     outlining the kernel body into a function in a dedicated module, which
     reflects the separate compilation process. The kernel function is required
     to have the `gpu.kernel` attribute. The module containing the kernel
-    function is required to have the `gpu.kernel_module` attribute and must be
-    named. And finally, the module containing the kernel module (which thus
-    cannot be the top-level module) is required to have the
-    `gpu.container_module` attribute. The `gpu.launch_func` operation has a
-    string attribute named `kernel` to specify the name of the kernel function
-    to launch and an attribute named `kernel_module` to specify the name of the
-    module containing that kernel function.
+    function is required to be a gpu.module. And finally, the module containing
+    the kernel module (which thus cannot be the top-level module) is required
+    to have the `gpu.container_module` attribute. The `gpu.launch_func`
+    operation has a symbol attribute named `kernel` to identify the fully specified
+    kernel function to launch (both the gpu.module and func).
 
     The operation takes at least six operands, with the first three operands
     being grid sizes along x,y,z dimensions and the following three being block
     sizes along x,y,z dimensions. When a lower-dimensional kernel is required,
     unused sizes must be explicitly set to `1`. The remaining operands are
     passed as arguments to the kernel function.
 
     A custom syntax for this operation is currently not available.
 
     Example:
 
     ```mlir
     module attributes {gpu.container_module} {
 
       // This module creates a separate compilation unit for the GPU compiler.
-      module @kernels attributes {gpu.kernel_module} {
+      gpu.module @kernels {
         func @kernel_1(%arg0 : f32, %arg1 : !llvm<"float*">)
             attributes { nvvm.kernel = true } {
 
           // Operations that produce block/thread IDs and dimensions are
           // injected when outlining the `gpu.launch` body to a function called
           // by `gpu.launch_func`.
           %tIdX = "gpu.thread_id"() {dimension = "x"} : () -> (index)
           %tIdY = "gpu.thread_id"() {dimension = "y"} : () -> (index)