[mlir][spirv] Change op doc description autogen separator

[antiagainst]

Summary

This commit changes the separator line for dividing auto-generated
docs from spec and manually added appendix from "### Custom assembly
form" to "<!-- End of AutoGen section -->". This is in preparation
to use the declarative assembly form in MLIR core. We will replace
more and more manually written assembly forms to be autogenerated.

[antiagainst]

Add missing leading symols for h4

mlir/include/mlir/Dialect/SPIRV/SPIRVArithmeticOps.td

def SPV_FAddOp : SPV_ArithmeticBinaryOp<"FAdd", SPV_Float, [Commutative]> {
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
      The types of Operand 1 and Operand 2 both must be the same as Result
     Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fadd-op ::= ssa-id `=` `spv.FAdd` ssa-use, ssa-use
                           `:` float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FAdd %0, %1 : f32
     %5 = spv.FAdd %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FDivOp : SPV_ArithmeticBinaryOp<"FDiv", SPV_Float, []> {
   let summary = "Floating-point division of Operand 1 divided by Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
      The types of Operand 1 and Operand 2 both must be the same as Result
     Type.
 
      Results are computed per component.  The resulting value is undefined
     if Operand 2 is 0.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fdiv-op ::= ssa-id `=` `spv.FDiv` ssa-use, ssa-use
                           `:` float-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FDiv %0, %1 : f32
     %5 = spv.FDiv %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FModOp : SPV_ArithmeticBinaryOp<"FMod", SPV_Float, []> {
   let summary = [{
     The floating-point remainder whose sign matches the sign of Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
      The types of Operand 1 and Operand 2 both must be the same as Result
     Type.
 
      Results are computed per component.  The resulting value is undefined
     if Operand 2 is 0.  Otherwise, the result is the remainder r of Operand
     1 divided by Operand 2 where if r ≠ 0, the sign of r is the same as the
     sign of Operand 2.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fmod-op ::= ssa-id `=` `spv.FMod` ssa-use, ssa-use
                           `:` float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FMod %0, %1 : f32
     %5 = spv.FMod %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FMulOp : SPV_ArithmeticBinaryOp<"FMul", SPV_Float, [Commutative]> {
   let summary = "Floating-point multiplication of Operand 1 and Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
      The types of Operand 1 and Operand 2 both must be the same as Result
     Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fmul-op ::= `spv.FMul` ssa-use, ssa-use
                           `:` float-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FMul %0, %1 : f32
     %5 = spv.FMul %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FNegateOp : SPV_ArithmeticUnaryOp<"FNegate", SPV_Float, []> {
-  let summary = "Floating-point subtract of Operand from zero.";
+  let summary = [{
+    Inverts the sign bit of Operand. (Note, however, that OpFNegate is still
+    considered a floating-point instruction, and so is subject to the
+    general floating-point rules regarding, for example, subnormals and NaN
+    propagation).
+  }];
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
      The type of Operand must be the same as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fmul-op ::= `spv.FNegate` ssa-use `:` float-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %1 = spv.FNegate %0 : f32
     %3 = spv.FNegate %2 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FRemOp : SPV_ArithmeticBinaryOp<"FRem", SPV_Float, []> {
   let summary = [{
     The floating-point remainder whose sign matches the sign of Operand 1.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
      The types of Operand 1 and Operand 2 both must be the same as Result
     Type.
 
      Results are computed per component.  The resulting value is undefined
     if Operand 2 is 0.  Otherwise, the result is the remainder r of Operand
     1 divided by Operand 2 where if r ≠ 0, the sign of r is the same as the
     sign of Operand 1.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     frem-op ::= ssa-id `=` `spv.FRemOp` ssa-use, ssa-use
                           `:` float-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FRemOp %0, %1 : f32
     %5 = spv.FRemOp %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FSubOp : SPV_ArithmeticBinaryOp<"FSub", SPV_Float, []> {
   let summary = "Floating-point subtraction of Operand 2 from Operand 1.";
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
      The types of Operand 1 and Operand 2 both must be the same as Result
     Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fsub-op ::= ssa-id `=` `spv.FRemOp` ssa-use, ssa-use
                           `:` float-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FRemOp %0, %1 : f32
     %5 = spv.FRemOp %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_IAddOp : SPV_ArithmeticBinaryOp<"IAdd", SPV_Integer, [Commutative]> {
   let summary = "Integer addition of Operand 1 and Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same number of components as Result
     Type. They must have the same component width as Result Type.
 
     The resulting value will equal the low-order N bits of the correct
     result R, where N is the component width and R is computed with enough
     precision to avoid overflow and underflow.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     iadd-op ::= ssa-id `=` `spv.IAdd` ssa-use, ssa-use
                           `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.IAdd %0, %1 : i32
     %5 = spv.IAdd %2, %3 : vector<4xi32>
 
     ```
   }];
 
   let hasFolder = 1;
 }
let description = [{
     Type. They must have the same component width as Result Type.
 
     The resulting value will equal the low-order N bits of the correct
     result R, where N is the component width and R is computed with enough
     precision to avoid overflow and underflow.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     imul-op ::= ssa-id `=` `spv.IMul` ssa-use, ssa-use
                           `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.IMul %0, %1 : i32
     %5 = spv.IMul %2, %3 : vector<4xi32>
 
     ```
   }];
 
   let hasFolder = 1;
 }
let description = [{
     Type. They must have the same component width as Result Type.
 
     The resulting value will equal the low-order N bits of the correct
     result R, where N is the component width and R is computed with enough
     precision to avoid overflow and underflow.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     isub-op ::= `spv.ISub` ssa-use, ssa-use
                           `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.ISub %0, %1 : i32
     %5 = spv.ISub %2, %3 : vector<4xi32>
 
     ```
   }];
 
   let hasFolder = 1;
 }
 
 // -----
 
 def SPV_SDivOp : SPV_ArithmeticBinaryOp<"SDiv", SPV_Integer, []> {
   let summary = "Signed-integer division of Operand 1 divided by Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same number of components as Result
     Type. They must have the same component width as Result Type.
 
      Results are computed per component.  The resulting value is undefined
     if Operand 2 is 0.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     sdiv-op ::= ssa-id `=` `spv.SDiv` ssa-use, ssa-use
                            `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.SDiv %0, %1 : i32
     %5 = spv.SDiv %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
let description = [{
     integer type.  They must have the same number of components as Result
     Type. They must have the same component width as Result Type.
 
      Results are computed per component.  The resulting value is undefined
     if Operand 2 is 0.  Otherwise, the result is the remainder r of Operand
     1 divided by Operand 2 where if r ≠ 0, the sign of r is the same as the
     sign of Operand 2.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     smod-op ::= ssa-id `=` `spv.SMod` ssa-use, ssa-use
                            `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.SMod %0, %1 : i32
     %5 = spv.SMod %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
let description = [{
     integer type.  They must have the same number of components as Result
     Type. They must have the same component width as Result Type.
 
      Results are computed per component.  The resulting value is undefined
     if Operand 2 is 0.  Otherwise, the result is the remainder r of Operand
     1 divided by Operand 2 where if r ≠ 0, the sign of r is the same as the
     sign of Operand 1.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     srem-op ::= ssa-id `=` `spv.SRem` ssa-use, ssa-use
                            `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.SRem %0, %1 : i32
     %5 = spv.SRem %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
 def SPV_UDivOp : SPV_ArithmeticBinaryOp<"UDiv", SPV_Integer, []> {
   let summary = "Unsigned-integer division of Operand 1 divided by Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of integer type, whose Signedness
     operand is 0.
 
      The types of Operand 1 and Operand 2 both must be the same as Result
     Type.
 
      Results are computed per component.  The resulting value is undefined
     if Operand 2 is 0.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     udiv-op ::= ssa-id `=` `spv.UDiv` ssa-use, ssa-use
                            `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.UDiv %0, %1 : i32
     %5 = spv.UDiv %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
 def SPV_UModOp : SPV_ArithmeticBinaryOp<"UMod", SPV_Integer> {
   let summary = "Unsigned modulo operation of Operand 1 modulo Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of integer type, whose Signedness
     operand is 0.
 
      The types of Operand 1 and Operand 2 both must be the same as Result
     Type.
 
      Results are computed per component.  The resulting value is undefined
     if Operand 2 is 0.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     umod-op ::= ssa-id `=` `spv.UMod` ssa-use, ssa-use
                            `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.UMod %0, %1 : i32
     %5 = spv.UMod %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 #endif // SPIRV_ARITHMETIC_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVAtomicOps.td

let description = [{
 
     Result Type must be an integer type scalar.
 
      The type of Value must be the same as Result Type.  The type of the
     value pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"CrossDevice"` | `"Device"` | `"Workgroup"` | ...
 
     memory-semantics ::= `"None"` | `"Acquire"` | "Release"` | ...
 
     atomic-and-op ::=
         `spv.AtomicAnd` scope memory-semantics
                         ssa-use `,` ssa-use `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicAnd "Device" "None" %pointer, %value :
                        !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
 def SPV_AtomicCompareExchangeWeakOp : SPV_Op<"AtomicCompareExchangeWeak", []> {
   let summary = "Deprecated (use OpAtomicCompareExchange).";
 
   let description = [{
     Has the same semantics as OpAtomicCompareExchange.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     atomic-compare-exchange-weak-op ::=
         `spv.AtomicCompareExchangeWeak` scope memory-semantics memory-semantics
                                         ssa-use `,` ssa-use `,` ssa-use
                                         `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicCompareExchangeWeak "Workgroup" "Acquire" "None"
                                        %pointer, %value, %comparator
                                        : !spv.ptr<i32, WorkGroup>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
let description = [{
 
     Result Type must be an integer type scalar.
 
      The type of Value must be the same as Result Type.  The type of the
     value pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     atomic-iadd-op ::=
         `spv.AtomicIAdd` scope memory-semantics
                          ssa-use `,` ssa-use `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicIAdd "Device" "None" %pointer, %value :
                         !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
let description = [{
 
     The instruction’s result is the Original Value.
 
     Result Type must be an integer type scalar.  The type of the value
     pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     atomic-idecrement-op ::=
         `spv.AtomicIDecrement` scope memory-semantics ssa-use
                                `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicIDecrement "Device" "None" %pointer :
                               !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
let description = [{
 
     The instruction’s result is the Original Value.
 
     Result Type must be an integer type scalar.  The type of the value
     pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     atomic-iincrement-op ::=
         `spv.AtomicIIncrement` scope memory-semantics ssa-use
                                `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicIncrement "Device" "None" %pointer :
                              !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
let description = [{
 
     Result Type must be an integer type scalar.
 
      The type of Value must be the same as Result Type.  The type of the
     value pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     atomic-isub-op ::=
         `spv.AtomicISub` scope memory-semantics
                          ssa-use `,` ssa-use `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicISub "Device" "None" %pointer, %value :
                         !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
let description = [{
 
     Result Type must be an integer type scalar.
 
      The type of Value must be the same as Result Type.  The type of the
     value pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     atomic-or-op ::=
         `spv.AtomicOr` scope memory-semantics
                        ssa-use `,` ssa-use `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicOr "Device" "None" %pointer, %value :
                       !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
let description = [{
 
     Result Type must be an integer type scalar.
 
      The type of Value must be the same as Result Type.  The type of the
     value pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     atomic-smax-op ::=
         `spv.AtomicSMax` scope memory-semantics
                          ssa-use `,` ssa-use `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicSMax "Device" "None" %pointer, %value :
                         !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
let description = [{
 
     Result Type must be an integer type scalar.
 
      The type of Value must be the same as Result Type.  The type of the
     value pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     atomic-smin-op ::=
         `spv.AtomicSMin` scope memory-semantics
                          ssa-use `,` ssa-use `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicSMin "Device" "None" %pointer, %value :
                         !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
let description = [{
 
     Result Type must be an integer type scalar.
 
      The type of Value must be the same as Result Type.  The type of the
     value pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     atomic-umax-op ::=
         `spv.AtomicUMax` scope memory-semantics
                          ssa-use `,` ssa-use `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicUMax "Device" "None" %pointer, %value :
                         !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
let description = [{
 
     Result Type must be an integer type scalar.
 
      The type of Value must be the same as Result Type.  The type of the
     value pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     atomic-umin-op ::=
         `spv.AtomicUMin` scope memory-semantics
                          ssa-use `,` ssa-use `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicUMin "Device" "None" %pointer, %value :
                         !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
let description = [{
 
     Result Type must be an integer type scalar.
 
      The type of Value must be the same as Result Type.  The type of the
     value pointed to by Pointer must be the same as Result Type.
 
     Memory must be a valid memory Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     atomic-xor-op ::=
         `spv.AtomicXor` scope memory-semantics
                         ssa-use `,` ssa-use `:` spv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.AtomicXor "Device" "None" %pointer, %value :
                        !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
 #endif // SPIRV_ATOMIC_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVBitOps.td

let description = [{
     wide enough result width.
 
     Base must be a scalar or vector of integer type.  It must have the same
     number of components as Result Type.
 
     The result is the unsigned value that is the number of bits in Base that
     are 1.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`
     bitcount-op ::= ssa-id `=` `spv.BitCount` ssa-use
                                `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.BitCount %0: i32
     %3 = spv.BitCount %1: vector<4xi32>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
let description = [{
     in which case the result will be Base.
 
     Offset  must be an integer type scalar. Offset is the lowest-order bit
     of the bit field.  It will be consumed as an unsigned value.
 
     The resulting value is undefined if Count or Offset or their sum is
     greater than the number of bits in the result.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`
     bitfield-insert-op ::= ssa-id `=` `spv.BitFieldInsert` ssa-use `,` ssa-use
                                       `,` ssa-use `,` ssa-use
                                       `:` integer-scalar-vector-type
                                       `,` integer-type `,` integer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.BitFieldInsert %base, %insert, %offset, %count : vector<3xi32>, i8, i8
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
let description = [{
 
     Offset  must be an integer type scalar. Offset is the lowest-order bit
     of the bit field to extract from Base.  It will be consumed as an
     unsigned value.
 
     The resulting value is undefined if Count or Offset or their sum is
     greater than the number of bits in the result.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`
     bitfield-extract-s-op ::= ssa-id `=` `spv.BitFieldSExtract` ssa-use
                                          `,` ssa-use `,` ssa-use
                                          `:` integer-scalar-vector-type
                                          `,` integer-type `,` integer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.BitFieldSExtract %base, %offset, %count : vector<3xi32>, i8, i8
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
     Capability<[SPV_C_Shader]>
   ];
 }
 
 // -----
 
 def SPV_BitFieldUExtractOp : SPV_BitFieldExtractOp<"BitFieldUExtract", []> {
   let summary = "Extract a bit field from an object, without sign extension.";
 
   let description = [{
     The semantics are the same as with OpBitFieldSExtract with the exception
     that there is no sign extension. The remaining bits of the result will
     all be 0.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`
     bitfield-extract-u-op ::= ssa-id `=` `spv.BitFieldUExtract` ssa-use
                                          `,` ssa-use `,` ssa-use
                                          `:` integer-scalar-vector-type
                                          `,` integer-type `,` integer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.BitFieldUExtract %base, %offset, %count : vector<3xi32>, i8, i8
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
let description = [{
 
     Result Type must be a scalar or vector of integer type.
 
      The type of Base must be the same as Result Type.
 
     The bit-number n of the result will be taken from bit-number Width - 1 -
     n of Base, where Width is the OpTypeInt operand of the Result Type.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
     bitreverse-op ::= ssa-id `=` `spv.BitReverse` ssa-use
                                  `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.BitReverse %0 : i32
     %3 = spv.BitReverse %1 : vector<4xi32>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
def SPV_BitwiseAndOp : SPV_BitBinaryOp<"BitwiseAnd", [Commutative]> {
   let description = [{
      Results are computed per component, and within each component, per bit.
 
     Result Type must be a scalar or vector of integer type.  The type of
     Operand 1 and Operand 2  must be a scalar or vector of integer type.
     They must have the same number of components as Result Type. They must
     have the same component width as Result Type.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`
     bitwise-and-op ::= ssa-id `=` `spv.BitwiseAnd` ssa-use, ssa-use
                                   `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.BitwiseAnd %0, %1 : i32
     %2 = spv.BitwiseAnd %0, %1 : vector<4xi32>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
def SPV_BitwiseOrOp : SPV_BitBinaryOp<"BitwiseOr", [Commutative]> {
   let description = [{
      Results are computed per component, and within each component, per bit.
 
     Result Type must be a scalar or vector of integer type.  The type of
     Operand 1 and Operand 2  must be a scalar or vector of integer type.
     They must have the same number of components as Result Type. They must
     have the same component width as Result Type.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`
     bitwise-or-op ::= ssa-id `=` `spv.BitwiseOr` ssa-use, ssa-use
                                   `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.BitwiseOr %0, %1 : i32
     %2 = spv.BitwiseOr %0, %1 : vector<4xi32>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
def SPV_BitwiseXorOp : SPV_BitBinaryOp<"BitwiseXor", [Commutative]> {
   let description = [{
      Results are computed per component, and within each component, per bit.
 
     Result Type must be a scalar or vector of integer type.  The type of
     Operand 1 and Operand 2  must be a scalar or vector of integer type.
     They must have the same number of components as Result Type. They must
     have the same component width as Result Type.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`
     bitwise-xor-op ::= ssa-id `=` `spv.BitwiseXor` ssa-use, ssa-use
                                   `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.BitwiseXor %0, %1 : i32
     %2 = spv.BitwiseXor %0, %1 : vector<4xi32>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
let description = [{
     Shift is treated as unsigned. The result is undefined if Shift is
     greater than or equal to the bit width of the components of Base.
 
     The number of components and bit width of Result Type must match those
     Base type. All types must be integer types.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`
     shift-left-logical-op ::= ssa-id `=` `spv.ShiftLeftLogical`
                                           ssa-use `,` ssa-use `:`
                                           integer-scalar-vector-type `,`
                                           integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.ShiftLeftLogical %0, %1 : i32, i16
     %5 = spv.ShiftLeftLogical %3, %4 : vector<3xi32>, vector<3xi16>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
let description = [{
     number of components and bit width of the type of Base must be the same
     as in Result Type.
 
     Shift is treated as unsigned. The result is undefined if Shift is
     greater than or equal to the bit width of the components of Base.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`
     shift-right-arithmetic-op ::= ssa-id `=` `spv.ShiftRightArithmetic`
                                               ssa-use `,` ssa-use `:`
                                               integer-scalar-vector-type `,`
                                               integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.ShiftRightArithmetic %0, %1 : i32, i16
     %5 = spv.ShiftRightArithmetic %3, %4 : vector<3xi32>, vector<3xi16>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
let description = [{
     as in Result Type.
 
     Shift is consumed as an unsigned integer. The result is undefined if
     Shift is greater than or equal to the bit width of the components of
     Base.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`
     shift-right-logical-op ::= ssa-id `=` `spv.ShiftRightLogical`
                                            ssa-use `,` ssa-use `:`
                                            integer-scalar-vector-type `,`
                                            integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.ShiftRightLogical %0, %1 : i32, i16
     %5 = spv.ShiftRightLogical %3, %4 : vector<3xi32>, vector<3xi16>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
let description = [{
      Results are computed per component, and within each component, per bit.
 
     Result Type must be a scalar or vector of integer type.
 
     Operand’s type  must be a scalar or vector of integer type.  It must
     have the same number of components as Result Type.  The component width
     must equal the component width in Result Type.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     integer-scalar-vector-type ::= integer-type |
                                   `vector<` integer-literal `x` integer-type `>`
     not-op ::= ssa-id `=` `spv.BitNot` ssa-use `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.Not %0 : i32
     %3 = spv.Not %1 : vector<4xi32>
     ```
   }];
 }
 
 #endif // SPIRV_BIT_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVCastOps.td

let description = [{
     the smaller number of components. The number of components in L must be
     an integer multiple of the number of components in S. The first
     component (that is, the only or lowest-numbered component) of S maps to
     the first components of L, and so on,  up to the last component of S
     mapping to the last components of L. Within this mapping, any single
     component of S (mapping to multiple components of L) maps its lower-
     ordered bits to the lower-numbered components of L.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     bitcast-op ::= ssa-id `=` `spv.Bitcast` ssa-use
                    `:` operand-type `to` result-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %1 = spv.Bitcast %0 : f32 to i32
     %1 = spv.Bitcast %0 : vector<2xf32> to i64
     %1 = spv.Bitcast %0 : !spv.ptr<f32, Function> to !spv.ptr<i32, Function>
     ```
   }];
 
   let arguments = (ins
     SPV_ScalarOrVectorOrPtr:$operand
def SPV_ConvertFToSOp : SPV_CastOp<"ConvertFToS", SPV_Integer, SPV_Float, []> {
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
     Float Value must be a scalar or vector of floating-point type.  It must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     convert-f-to-s-op ::= ssa-id `=` `spv.ConvertFToSOp` ssa-use
                           `:` operand-type `to` result-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %1 = spv.ConvertFToS %0 : f32 to i32
     %3 = spv.ConvertFToS %2 : vector<3xf32> to vector<3xi32>
     ```
   }];
 }
 
 // -----
 
 def SPV_ConvertFToUOp : SPV_CastOp<"ConvertFToU", SPV_Integer, SPV_Float, []> {
   let summary = [{
     Convert value numerically from floating point to unsigned integer, with
     round toward 0.0.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type, whose Signedness
     operand is 0.
 
     Float Value must be a scalar or vector of floating-point type.  It must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     convert-f-to-u-op ::= ssa-id `=` `spv.ConvertFToUOp` ssa-use
                           `:` operand-type `to` result-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %1 = spv.ConvertFToU %0 : f32 to i32
     %3 = spv.ConvertFToU %2 : vector<3xf32> to vector<3xi32>
     ```
   }];
 }
 
 // -----
 
 def SPV_ConvertSToFOp : SPV_CastOp<"ConvertSToF", SPV_Float, SPV_Integer, []> {
   let summary = [{
     Convert value numerically from signed integer to floating point.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
     Signed Value must be a scalar or vector of integer type.  It must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     convert-s-to-f-op ::= ssa-id `=` `spv.ConvertSToFOp` ssa-use
                           `:` operand-type `to` result-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %1 = spv.ConvertSToF %0 : i32 to f32
     %3 = spv.ConvertSToF %2 : vector<3xi32> to vector<3xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_ConvertUToFOp : SPV_CastOp<"ConvertUToF", SPV_Float, SPV_Integer, []> {
   let summary = [{
     Convert value numerically from unsigned integer to floating point.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
     Unsigned Value must be a scalar or vector of integer type.  It must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     convert-u-to-f-op ::= ssa-id `=` `spv.ConvertUToFOp` ssa-use
                           `:` operand-type `to` result-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %1 = spv.ConvertUToF %0 : i32 to f32
     %3 = spv.ConvertUToF %2 : vector<3xi32> to vector<3xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FConvertOp : SPV_CastOp<"FConvert", SPV_Float, SPV_Float, []> {
   let summary = [{
     Convert value numerically from one floating-point width to another
     width.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
 
     Float Value must be a scalar or vector of floating-point type.  It must
     have the same number of components as Result Type.  The component width
     cannot equal the component width in Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     f-convert-op ::= ssa-id `=` `spv.FConvertOp` ssa-use
                      `:` operand-type `to` result-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %1 = spv.FConvertOp %0 : f32 to f64
     %3 = spv.FConvertOp %2 : vector<3xf32> to vector<3xf64>
     ```
   }];
 
   let verifier = [{ return verifyCastOp(this->getOperation(), false); }];
 }
 
 // -----
 
 def SPV_SConvertOp : SPV_CastOp<"SConvert", SPV_Integer, SPV_Integer, []> {
   let summary = [{
     Convert signed width.  This is either a truncate or a sign extend.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of integer type.
 
     Signed Value must be a scalar or vector of integer type.  It must have
     the same number of components as Result Type.  The component width
     cannot equal the component width in Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     s-convert-op ::= ssa-id `=` `spv.SConvertOp` ssa-use
                      `:` operand-type `to` result-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %1 = spv.SConvertOp %0 : i32 to i64
     %3 = spv.SConvertOp %2 : vector<3xi32> to vector<3xi64>
     ```
   }];
 
   let verifier = [{ return verifyCastOp(this->getOperation(), false); }];
 }
 
let description = [{
     operand is 0.
 
     Unsigned Value must be a scalar or vector of integer type.  It must have
     the same number of components as Result Type.  The component width
     cannot equal the component width in Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     u-convert-op ::= ssa-id `=` `spv.UConvertOp` ssa-use
                  `:` operand-type `to` result-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %1 = spv.UConvertOp %0 : i32 to i64
     %3 = spv.UConvertOp %2 : vector<3xi32> to vector<3xi64>
     ```
   }];
 
   let verifier = [{ return verifyCastOp(this->getOperation(), false); }];
 }
 
 #endif // SPIRV_CAST_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVCompositeOps.td

let description = [{
     exactly one Constituent for each top-level
     member/element/component/column of the result, with one exception. The
     exception is that for constructing a vector, a contiguous subset of the
     scalars consumed can be represented by a vector operand instead. The
     Constituents must appear in the order needed by the definition of the
     type of the result. When constructing a vector, there must be at least
     two Constituent operands.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     composite-construct-op ::= ssa-id `=` `spv.CompositeConstruct`
                                (ssa-use (`,` ssa-use)* )? `:` composite-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.CompositeConstruct %1, %2, %3 : vector<3xf32>
     ```
   }];
 
   let arguments = (ins
     Variadic<SPV_Type>:$constituents
   );
 
let description = [{
 
     Composite is the composite to extract from.
 
     Indexes walk the type hierarchy, potentially down to component
     granularity, to select the part to extract. All indexes must be in
     bounds.  All composite constituents use zero-based numbering, as
     described by their OpType… instruction.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     composite-extract-op ::= ssa-id `=` `spv.CompositeExtract` ssa-use
                              `[` integer-literal (',' integer-literal)* `]`
                              `:` composite-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>
     %1 = spv.Load "Function" %0 ["Volatile"] : !spv.array<4x!spv.array<4xf32>>
     %2 = spv.CompositeExtract %1[1 : i32] : !spv.array<4x!spv.array<4xf32>>
     ```
 
   }];
 
   let arguments = (ins
let description = [{
     Composite is the composite to copy all but the modified part from.
 
     Indexes walk the type hierarchy of Composite to the desired depth,
     potentially down to component granularity, to select the part to modify.
     All indexes must be in bounds. All composite constituents use zero-based
     numbering, as described by their OpType… instruction. The type of the
     part selected to modify must match the type of Object.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     composite-insert-op ::= ssa-id `=` `spv.CompositeInsert` ssa-use, ssa-use
                             `[` integer-literal (',' integer-literal)* `]`
                             `:` object-type `into` composite-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.CompositeInsert %object, %composite[1 : i32] : f32 into !spv.array<4xf32>
     ```
   }];
 
   let arguments = (ins
     SPV_Type:$object,
     SPV_Composite:$composite,
     I32ArrayAttr:$indices
   );
 
   let results = (outs
     SPV_Composite:$result
   );
 }
 
 #endif // SPIRV_COMPOSITE_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVControlFlowOps.td

 def SPV_BranchOp : SPV_Op<"Branch", [
     DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope, NoSideEffect,
     Terminator]> {
   let summary = "Unconditional branch to target block.";
 
   let description = [{
     This instruction must be the last instruction in a block.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     branch-op ::= `spv.Branch` successor
     successor ::= bb-id branch-use-list?
     branch-use-list ::= `(` ssa-use-list `:` type-list-no-parens `)`
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.Branch ^target
     spv.Branch ^target(%0, %1: i32, f32)
     ```
   }];
 
   let arguments = (ins Variadic<SPV_Type>:$targetOperands);
 
   let results = (outs);
let description = [{
     branch is taken is its weight divided by the sum of the two Branch
     weights. At least one weight must be non-zero. A weight of zero does not
     imply a branch is dead or permit its removal; branch weights are only
     hints. The two weights must not overflow a 32-bit unsigned integer when
     added together.
 
     This instruction must be the last instruction in a block.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     branch-conditional-op ::= `spv.BranchConditional` ssa-use
                               (`[` integer-literal, integer-literal `]`)?
                               `,` successor `,` successor
     successor ::= bb-id branch-use-list?
     branch-use-list ::= `(` ssa-use-list `:` type-list-no-parens `)`
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.BranchConditional %condition, ^true_branch, ^false_branch
     spv.BranchConditional %condition, ^true_branch(%0: i32), ^false_branch(%1: i32)
     ```
   }];
 
   let arguments = (ins
     SPV_Bool:$condition,
     Variadic<SPV_Type>:$trueTargetOperands,
let description = [{
     reference.
 
     Argument N is the object to copy to parameter N of Function.
 
     Note: A forward call is possible because there is no missing type
     information: Result Type must match the Return Type of the function, and
     the calling argument types must match the formal parameter types.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     function-call-op ::= `spv.FunctionCall` function-id `(` ssa-use-list `)`
                      `:` function-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.FunctionCall @f_void(%arg0) : (i32) ->  ()
     %0 = spv.FunctionCall @f_iadd(%arg0, %arg1) : (i32, i32) -> i32
     ```
   }];
 
   let arguments = (ins
     FlatSymbolRefAttr:$callee,
     Variadic<SPV_Type>:$arguments

 
 def SPV_ReturnOp : SPV_Op<"Return", [InFunctionScope, NoSideEffect,
                                      Terminator]> {
   let summary = "Return with no value from a function with void return type.";
 
   let description = [{
     This instruction must be the last instruction in a block.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     return-op ::= `spv.Return`
     ```
   }];
 
   let arguments = (ins);
 
   let results = (outs);
 
   let assemblyFormat = "attr-dict";
 }
 
 // -----
 
 def SPV_UnreachableOp : SPV_Op<"Unreachable", [InFunctionScope, Terminator]> {
   let summary = "Declares that this block is not reachable in the CFG.";
 
   let description = [{
     This instruction must be the last instruction in a block.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     unreachable-op ::= `spv.Unreachable`
     ```
   }];
 
   let arguments = (ins);
 
def SPV_ReturnValueOp : SPV_Op<"ReturnValue", [InFunctionScope, NoSideEffect,
 
   let description = [{
     Value is the value returned, by copy, and must match the Return Type
     operand of the OpTypeFunction type of the OpFunction body this return
     instruction is in.
 
     This instruction must be the last instruction in a block.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     return-value-op ::= `spv.ReturnValue` ssa-use `:` spirv-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.ReturnValue %0 : f32
     ```
   }];
 
   let arguments = (ins
     SPV_Type:$value
   );
 

mlir/include/mlir/Dialect/SPIRV/SPIRVGLSLOps.td

let description = [{
     Result is x if x >= 0; otherwise result is -x.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     abs-op ::= ssa-id `=` `spv.GLSL.FAbs` ssa-use `:`
                float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.FAbs %0 : f32
     %3 = spv.GLSL.FAbs %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLSAbsOp : SPV_GLSLUnaryArithmeticOp<"SAbs", 5, SPV_Integer> {
   let summary = "Absolute value of operand";
 
   let description = [{
     Result is x if x ≥ 0; otherwise result is -x, where x is interpreted as a
     signed integer.
 
     Result Type and the type of x must both be integer scalar or integer vector
     types. Result Type and operand types must have the same number of components
     with the same component width. Results are computed per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
     abs-op ::= ssa-id `=` `spv.GLSL.SAbs` ssa-use `:`
                integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.SAbs %0 : i32
     %3 = spv.GLSL.SAbs %1 : vector<3xi16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLCeilOp : SPV_GLSLUnaryArithmeticOp<"Ceil", 9, SPV_Float> {
   let summary = "Rounds up to the next whole number";
 
   let description = [{
     Result is the value equal to the nearest whole number that is greater than
     or equal to x.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     ceil-op ::= ssa-id `=` `spv.GLSL.Ceil` ssa-use `:`
                 float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.Ceil %0 : f32
     %3 = spv.GLSL.Ceil %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLCosOp : SPV_GLSLUnaryArithmeticOp<"Cos", 14, SPV_Float16or32> {
   let summary = "Cosine of operand in radians";
 
   let description = [{
     The standard trigonometric cosine of x radians.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     restricted-float-scalar-type ::=  `f16` | `f32`
     restricted-float-scalar-vector-type ::=
       restricted-float-scalar-type |
       `vector<` integer-literal `x` restricted-float-scalar-type `>`
     cos-op ::= ssa-id `=` `spv.GLSL.Cos` ssa-use `:`
                restricted-float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.Cos %0 : f32
     %3 = spv.GLSL.Cos %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLSinOp : SPV_GLSLUnaryArithmeticOp<"Sin", 13, SPV_Float16or32> {
   let summary = "Sine of operand in radians";
 
   let description = [{
     The standard trigonometric sine of x radians.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     restricted-float-scalar-type ::=  `f16` | `f32`
     restricted-float-scalar-vector-type ::=
       restricted-float-scalar-type |
       `vector<` integer-literal `x` restricted-float-scalar-type `>`
     sin-op ::= ssa-id `=` `spv.GLSL.Sin` ssa-use `:`
                restricted-float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.Sin %0 : f32
     %3 = spv.GLSL.Sin %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLExpOp : SPV_GLSLUnaryArithmeticOp<"Exp", 27, SPV_Float16or32> {
   let summary = "Exponentiation of Operand 1";
 
   let description = [{
     Result is the natural exponentiation of x; e^x.
 
     The operand x must be a scalar or vector whose component type is
     16-bit or 32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are
     computed per component.";
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     restricted-float-scalar-type ::=  `f16` | `f32`
     restricted-float-scalar-vector-type ::=
       restricted-float-scalar-type |
       `vector<` integer-literal `x` restricted-float-scalar-type `>`
     exp-op ::= ssa-id `=` `spv.GLSL.Exp` ssa-use `:`
                restricted-float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.Exp %0 : f32
     %3 = spv.GLSL.Exp %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLFloorOp : SPV_GLSLUnaryArithmeticOp<"Floor", 8, SPV_Float> {
   let summary = "Rounds down to the next whole number";
 
   let description = [{
     Result is the value equal to the nearest whole number that is less than or
     equal to x.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     floor-op ::= ssa-id `=` `spv.GLSL.Floor` ssa-use `:`
                 float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.Floor %0 : f32
     %3 = spv.GLSL.Floor %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLInverseSqrtOp : SPV_GLSLUnaryArithmeticOp<"InverseSqrt", 32, SPV_Float> {
   let summary = "Reciprocal of sqrt(operand)";
 
   let description = [{
     Result is the reciprocal of sqrt x. Result is undefined if x <= 0.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     rsqrt-op ::= ssa-id `=` `spv.GLSL.InverseSqrt` ssa-use `:`
                  float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.InverseSqrt %0 : f32
     %3 = spv.GLSL.InverseSqrt %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLLogOp : SPV_GLSLUnaryArithmeticOp<"Log", 28, SPV_Float16or32> {
   let summary = "Natural logarithm of the operand";
 
   let description = [{
     Result is the natural logarithm of x, i.e., the value y which satisfies the
     equation x = ey. Result is undefined if x <= 0.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     restricted-float-scalar-type ::=  `f16` | `f32`
     restricted-float-scalar-vector-type ::=
       restricted-float-scalar-type |
       `vector<` integer-literal `x` restricted-float-scalar-type `>`
     log-op ::= ssa-id `=` `spv.GLSL.Log` ssa-use `:`
                restricted-float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.Log %0 : f32
     %3 = spv.GLSL.Log %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLFMaxOp : SPV_GLSLBinaryArithmeticOp<"FMax", 40, SPV_Float> {
   let summary = "Return maximum of two floating-point operands";
 
   let description = [{
     Result is y if x < y; otherwise result is x. Which operand is the
     result is undefined if one of the operands is a NaN.
 
     The operands must all be a scalar or vector whose component type
     is floating-point.
 
     Result Type and the type of all operands must be the same
     type. Results are computed per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fmax-op ::= ssa-id `=` `spv.GLSL.FMax` ssa-use `:`
                 float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.FMax %0, %1 : f32
     %3 = spv.GLSL.FMax %0, %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLSMaxOp : SPV_GLSLBinaryArithmeticOp<"SMax", 42, SPV_Integer> {
   let summary = "Return maximum of two signed integer operands";
 
   let description = [{
     Result is y if x < y; otherwise result is x, where x and y are interpreted
     as signed integers.
 
     Result Type and the type of x and y must both be integer scalar or integer
     vector types. Result Type and operand types must have the same number of
     components with the same component width. Results are computed per
     component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
     smax-op ::= ssa-id `=` `spv.GLSL.SMax` ssa-use `:`
                 integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.SMax %0, %1 : i32
     %3 = spv.GLSL.SMax %0, %1 : vector<3xi16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLFMinOp : SPV_GLSLBinaryArithmeticOp<"FMin", 37, SPV_Float> {
   let summary = "Return minimum of two floating-point operands";
 
   let description = [{
     Result is y if y < x; otherwise result is x. Which operand is the result is
     undefined if one of the operands is a NaN.
 
     The operands must all be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of all operands must be the same type. Results are
     computed per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fmin-op ::= ssa-id `=` `spv.GLSL.FMin` ssa-use `:`
                 float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.FMin %0, %1 : f32
     %3 = spv.GLSL.FMin %0, %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLSMinOp : SPV_GLSLBinaryArithmeticOp<"SMin", 39, SPV_Integer> {
   let summary = "Return minimum of two signed integer operands";
 
   let description = [{
     Result is y if y < x; otherwise result is x, where x and y are interpreted
     as signed integers.
 
     Result Type and the type of x and y must both be integer scalar or integer
     vector types. Result Type and operand types must have the same number of
     components with the same component width. Results are computed per
     component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
     smin-op ::= ssa-id `=` `spv.GLSL.SMin` ssa-use `:`
                 integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.SMin %0, %1 : i32
     %3 = spv.GLSL.SMin %0, %1 : vector<3xi16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLFSignOp : SPV_GLSLUnaryArithmeticOp<"FSign", 6, SPV_Float> {
   let summary = "Returns the sign of the operand";
 
   let description = [{
     Result is 1.0 if x > 0, 0.0 if x = 0, or -1.0 if x < 0.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     sign-op ::= ssa-id `=` `spv.GLSL.FSign` ssa-use `:`
                 float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.FSign %0 : f32
     %3 = spv.GLSL.FSign %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLSSignOp : SPV_GLSLUnaryArithmeticOp<"SSign", 7, SPV_Integer> {
   let summary = "Returns the sign of the operand";
 
   let description = [{
     Result is 1 if x > 0, 0 if x = 0, or -1 if x < 0, where x is interpreted as
     a signed integer.
 
     Result Type and the type of x must both be integer scalar or integer vector
     types. Result Type and operand types must have the same number of components
     with the same component width. Results are computed per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
     sign-op ::= ssa-id `=` `spv.GLSL.SSign` ssa-use `:`
                 integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.SSign %0 : i32
     %3 = spv.GLSL.SSign %1 : vector<3xi16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLSqrtOp : SPV_GLSLUnaryArithmeticOp<"Sqrt", 31, SPV_Float> {
   let summary = "Returns the square root of the operand";
 
   let description = [{
     Result is the square root of x. Result is undefined if x < 0.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     sqrt-op ::= ssa-id `=` `spv.GLSL.Sqrt` ssa-use `:`
                 float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.Sqrt %0 : f32
     %3 = spv.GLSL.Sqrt %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_GLSLTanhOp : SPV_GLSLUnaryArithmeticOp<"Tanh", 21, SPV_Float16or32> {
   let summary = "Hyperbolic tangent of operand in radians";
 
   let description = [{
     Hyperbolic tangent of x radians.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
-    ### Custom assembly format
+    <!-- End of AutoGen section -->
     ```
     restricted-float-scalar-type ::=  `f16` | `f32`
     restricted-float-scalar-vector-type ::=
       restricted-float-scalar-type |
       `vector<` integer-literal `x` restricted-float-scalar-type `>`
     tanh-op ::= ssa-id `=` `spv.GLSL.Tanh` ssa-use `:`
                 restricted-float-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.GLSL.Tanh %0 : f32
     %3 = spv.GLSL.Tanh %1 : vector<3xf16>
     ```
   }];
 }
 
 #endif // SPIRV_GLSL_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVGroupOps.td

let description = [{
 
     Result Type must be a 4 component vector of 32 bit integer types.
 
     Result is a set of bitfields where the first invocation is represented in bit
     0 of the first vector component and the last (up to SubgroupSize) is the
     higher bit number of the last bitmask needed to represent all bits of the
     subgroup invocations.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     subgroup-ballot-op ::= ssa-id `=` `spv.SubgroupBallotKHR`
                                 ssa-use `:` `vector` `<` 4 `x` `i32` `>`
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.SubgroupBallotKHR %predicate : vector<4xi32>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
     Extension<[SPV_KHR_shader_ballot]>,

mlir/include/mlir/Dialect/SPIRV/SPIRVLogicalOps.td

let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fordequal-op ::= ssa-id `=` `spv.FOrdEqual` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FOrdEqual %0, %1 : f32
     %5 = spv.FOrdEqual %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FOrdGreaterThanOp : SPV_LogicalBinaryOp<"FOrdGreaterThan", SPV_Float, []> {
   let summary = [{
     Floating-point comparison if operands are ordered and Operand 1 is
     greater than  Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fordgt-op ::= ssa-id `=` `spv.FOrdGreaterThan` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FOrdGreaterThan %0, %1 : f32
     %5 = spv.FOrdGreaterThan %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FOrdGreaterThanEqualOp : SPV_LogicalBinaryOp<"FOrdGreaterThanEqual", SPV_Float, []> {
   let summary = [{
     Floating-point comparison if operands are ordered and Operand 1 is
     greater than or equal to Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fordgte-op ::= ssa-id `=` `spv.FOrdGreaterThanEqual` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FOrdGreaterThanEqual %0, %1 : f32
     %5 = spv.FOrdGreaterThanEqual %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FOrdLessThanOp : SPV_LogicalBinaryOp<"FOrdLessThan", SPV_Float, []> {
   let summary = [{
     Floating-point comparison if operands are ordered and Operand 1 is less
     than Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fordlt-op ::= ssa-id `=` `spv.FOrdLessThan` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FOrdLessThan %0, %1 : f32
     %5 = spv.FOrdLessThan %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FOrdLessThanEqualOp : SPV_LogicalBinaryOp<"FOrdLessThanEqual", SPV_Float, []> {
   let summary = [{
     Floating-point comparison if operands are ordered and Operand 1 is less
     than or equal to Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fordlte-op ::= ssa-id `=` `spv.FOrdLessThanEqual` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FOrdLessThanEqual %0, %1 : f32
     %5 = spv.FOrdLessThanEqual %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FOrdNotEqualOp : SPV_LogicalBinaryOp<"FOrdNotEqual", SPV_Float, [Commutative]> {
   let summary = "Floating-point comparison for being ordered and not equal.";
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     fordneq-op ::= ssa-id `=` `spv.FOrdNotEqual` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FOrdNotEqual %0, %1 : f32
     %5 = spv.FOrdNotEqual %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FUnordEqualOp : SPV_LogicalBinaryOp<"FUnordEqual", SPV_Float, [Commutative]> {
   let summary = "Floating-point comparison for being unordered or equal.";
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     funordequal-op ::= ssa-id `=` `spv.FUnordEqual` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FUnordEqual %0, %1 : f32
     %5 = spv.FUnordEqual %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FUnordGreaterThanOp : SPV_LogicalBinaryOp<"FUnordGreaterThan", SPV_Float, []> {
   let summary = [{
     Floating-point comparison if operands are unordered or Operand 1 is
     greater than  Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     funordgt-op ::= ssa-id `=` `spv.FUnordGreaterThan` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FUnordGreaterThan %0, %1 : f32
     %5 = spv.FUnordGreaterThan %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FUnordGreaterThanEqualOp : SPV_LogicalBinaryOp<"FUnordGreaterThanEqual", SPV_Float, []> {
   let summary = [{
     Floating-point comparison if operands are unordered or Operand 1 is
     greater than or equal to Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     funordgte-op ::= ssa-id `=` `spv.FUnordGreaterThanEqual` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FUnordGreaterThanEqual %0, %1 : f32
     %5 = spv.FUnordGreaterThanEqual %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FUnordLessThanOp : SPV_LogicalBinaryOp<"FUnordLessThan", SPV_Float, []> {
   let summary = [{
     Floating-point comparison if operands are unordered or Operand 1 is less
     than Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     funordlt-op ::= ssa-id `=` `spv.FUnordLessThan` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FUnordLessThan %0, %1 : f32
     %5 = spv.FUnordLessThan %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FUnordLessThanEqualOp : SPV_LogicalBinaryOp<"FUnordLessThanEqual", SPV_Float, []> {
   let summary = [{
     Floating-point comparison if operands are unordered or Operand 1 is less
     than or equal to Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     funordlte-op ::= ssa-id `=` `spv.FUnordLessThanEqual` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FUnordLessThanEqual %0, %1 : f32
     %5 = spv.FUnordLessThanEqual %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_FUnordNotEqualOp : SPV_LogicalBinaryOp<"FUnordNotEqual", SPV_Float, [Commutative]> {
   let summary = "Floating-point comparison for being unordered or not equal.";
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     floating-point type.  They must have the same type, and they must have
     the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     funordneq-op ::= ssa-id `=` `spv.FUnordNotEqual` ssa-use, ssa-use
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.FUnordNotEqual %0, %1 : f32
     %5 = spv.FUnordNotEqual %2, %3 : vector<4xf32>
     ```
   }];
 }
 
 // -----
 
 def SPV_IEqualOp : SPV_LogicalBinaryOp<"IEqual", SPV_Integer, [Commutative]> {
   let summary = "Integer comparison for equality.";
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     iequal-op ::= ssa-id `=` `spv.IEqual` ssa-use, ssa-use
                              `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.IEqual %0, %1 : i32
     %5 = spv.IEqual %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
 def SPV_INotEqualOp : SPV_LogicalBinaryOp<"INotEqual", SPV_Integer, [Commutative]> {
   let summary = "Integer comparison for inequality.";
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     inot-equal-op ::= ssa-id `=` `spv.INotEqual` ssa-use, ssa-use
                                  `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.INotEqual %0, %1 : i32
     %5 = spv.INotEqual %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
 def SPV_LogicalAndOp : SPV_LogicalBinaryOp<"LogicalAnd", SPV_Bool, [Commutative]> {
   let summary = [{
     Result is true if both Operand 1 and Operand 2 are true. Result is false
     if either Operand 1 or Operand 2 are false.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 must be the same as Result Type.
 
      The type of Operand 2 must be the same as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     logical-and ::= `spv.LogicalAnd` ssa-use `,` ssa-use
                     `:` operand-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.LogicalAnd %0, %1 : i1
     %2 = spv.LogicalAnd %0, %1 : vector<4xi1>
     ```
   }];
 
   let hasFolder = 1;
 }
 
let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 must be the same as Result Type.
 
      The type of Operand 2 must be the same as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     logical-equal ::= `spv.LogicalEqual` ssa-use `,` ssa-use
                       `:` operand-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.LogicalEqual %0, %1 : i1
     %2 = spv.LogicalEqual %0, %1 : vector<4xi1>
     ```
   }];
 }
 
 // -----
 
 def SPV_LogicalNotOp : SPV_LogicalUnaryOp<"LogicalNot", SPV_Bool, []> {
   let summary = [{
     Result is true if Operand is false.  Result is false if Operand is true.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand must be the same as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     logical-not ::= `spv.LogicalNot` ssa-use `:` operand-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.LogicalNot %0 : i1
     %2 = spv.LogicalNot %0 : vector<4xi1>
     ```
   }];
 
   let hasCanonicalizer = 1;
 }
 
let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 must be the same as Result Type.
 
      The type of Operand 2 must be the same as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     logical-not-equal ::= `spv.LogicalNotEqual` ssa-use `,` ssa-use
                           `:` operand-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.LogicalNotEqual %0, %1 : i1
     %2 = spv.LogicalNotEqual %0, %1 : vector<4xi1>
     ```
   }];
 }
 
 // -----
 
 def SPV_LogicalOrOp : SPV_LogicalBinaryOp<"LogicalOr", SPV_Bool, [Commutative]> {
   let summary = [{
     Result is true if either Operand 1 or Operand 2 is true. Result is false
     if both Operand 1 and Operand 2 are false.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 must be the same as Result Type.
 
      The type of Operand 2 must be the same as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     logical-or ::= `spv.LogicalOr` ssa-use `,` ssa-use
                     `:` operand-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %2 = spv.LogicalOr %0, %1 : i1
     %2 = spv.LogicalOr %0, %1 : vector<4xi1>
     ```
   }];
 
   let hasFolder = 1;
 }
 
 // -----
 
 def SPV_SGreaterThanOp : SPV_LogicalBinaryOp<"SGreaterThan", SPV_Integer, []> {
   let summary = [{
     Signed-integer comparison if Operand 1 is greater than  Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     sgreater-than-op ::= ssa-id `=` `spv.SGreaterThan` ssa-use, ssa-use
                                     `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.SGreaterThan %0, %1 : i32
     %5 = spv.SGreaterThan %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
 def SPV_SGreaterThanEqualOp : SPV_LogicalBinaryOp<"SGreaterThanEqual", SPV_Integer, []> {
   let summary = [{
     Signed-integer comparison if Operand 1 is greater than or equal to
     Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     sgreater-than-equal-op ::= ssa-id `=` `spv.SGreaterThanEqual` ssa-use, ssa-use
                                           `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
     ```
     %4 = spv.SGreaterThanEqual %0, %1 : i32
     %5 = spv.SGreaterThanEqual %2, %3 : vector<4xi32>
 
     ```
   }];
 }
let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     sless-than-op ::= ssa-id `=` `spv.SLessThan` ssa-use, ssa-use
                                  `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.SLessThan %0, %1 : i32
     %5 = spv.SLessThan %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
 def SPV_SLessThanEqualOp : SPV_LogicalBinaryOp<"SLessThanEqual", SPV_Integer, []> {
   let summary = [{
     Signed-integer comparison if Operand 1 is less than or equal to Operand
     2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     sless-than-equal-op ::= ssa-id `=` `spv.SLessThanEqual` ssa-use, ssa-use
                                        `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.SLessThanEqual %0, %1 : i32
     %5 = spv.SLessThanEqual %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
let description = [{
     is a scalar and false, the result is Object 2.
 
     If Condition is a vector, Result Type must be a vector with the same
     number of components as Condition and the result is a mix of Object 1
     and Object 2: When a component of Condition is true, the corresponding
     component in the result is taken from Object 1, otherwise it is taken
     from Object 2.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scalar-type ::= integer-type | float-type | boolean-type
     select-object-type ::= scalar-type
                            | `vector<` integer-literal `x` scalar-type `>`
                            | pointer-type
     select-condition-type ::= boolean-type
                               | `vector<` integer-literal `x` boolean-type `>`
     select-op ::= ssa-id `=` `spv.Select` ssa-use, ssa-use, ssa-use
                   `:` select-condition-type `,` select-object-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %3 = spv.Select %0, %1, %2 : i1, f32
     %3 = spv.Select %0, %1, %2 : i1, vector<3xi32>
     %3 = spv.Select %0, %1, %2 : vector<3xi1>, vector<3xf32>
     ```
   }];
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<SPV_Bool>:$condition,
let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     ugreater-than-op ::= ssa-id `=` `spv.UGreaterThan` ssa-use, ssa-use
                                     `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.UGreaterThan %0, %1 : i32
     %5 = spv.UGreaterThan %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
 def SPV_UGreaterThanEqualOp : SPV_LogicalBinaryOp<"UGreaterThanEqual", SPV_Integer, []> {
   let summary = [{
     Unsigned-integer comparison if Operand 1 is greater than or equal to
     Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     ugreater-than-equal-op ::= ssa-id `=` `spv.UGreaterThanEqual` ssa-use, ssa-use
                                           `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.UGreaterThanEqual %0, %1 : i32
     %5 = spv.UGreaterThanEqual %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
 def SPV_ULessThanOp : SPV_LogicalBinaryOp<"ULessThan", SPV_Integer, []> {
   let summary = [{
     Unsigned-integer comparison if Operand 1 is less than Operand 2.
   }];
 
   let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     uless-than-op ::= ssa-id `=` `spv.ULessThan` ssa-use, ssa-use
                                  `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.ULessThan %0, %1 : i32
     %5 = spv.ULessThan %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
let description = [{
     Result Type must be a scalar or vector of Boolean type.
 
      The type of Operand 1 and Operand 2  must be a scalar or vector of
     integer type.  They must have the same component width, and they must
     have the same number of components as Result Type.
 
      Results are computed per component.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     uless-than-equal-op ::= ssa-id `=` `spv.ULessThanEqual` ssa-use, ssa-use
                                        `:` integer-scalar-vector-type
     ```
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %4 = spv.ULessThanEqual %0, %1 : i32
     %5 = spv.ULessThanEqual %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 #endif // SPIRV_LOGICAL_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVNonUniformOps.td

let description = [{
     in the lowest bit of the first vector component and the last (up to the
     size of the group) is the higher bit number of the last bitmask needed
     to represent all bits of the group invocations.
 
     Execution must be Workgroup or Subgroup Scope.
 
     Predicate must be a Boolean type.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     non-uniform-ballot-op ::= ssa-id `=` `spv.GroupNonUniformBallot` scope
                               ssa-use `:` `vector` `<` 4 `x` `integer-type` `>`
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.GroupNonUniformBallot "SubGroup" %predicate : vector<4xi32>
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_3>,
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
let summary = [{
     group, otherwise result is false.
   }];
 
   let description = [{
     Result Type must be a Boolean type.
 
     Execution must be Workgroup or Subgroup Scope.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     non-uniform-elect-op ::= ssa-id `=` `spv.GroupNonUniformElect` scope
                              `:` `i1`
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.GroupNonUniformElect : i1
     ```
   }];
 
   let availability = [
     MinVersion<SPV_V_1_3>,
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
let description = [{
     invocations is implementation defined.
 
     ClusterSize is the size of cluster to use. ClusterSize must be a scalar
     of integer type, whose Signedness operand is 0. ClusterSize must come
     from a constant instruction. ClusterSize must be at least 1, and must be
     a power of 2. If ClusterSize is greater than the declared SubGroupSize,
     executing this instruction results in undefined behavior.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     operation ::= `"Reduce"` | `"InclusiveScan"` | `"ExclusiveScan"` | ...
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     non-uniform-fadd-op ::= ssa-id `=` `spv.GroupNonUniformFAdd` scope operation
                             ssa-use ( `cluster_size` `(` ssa_use `)` )?
                             `:` float-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : f32
     %vector = ... : vector<4xf32>
     %0 = spv.GroupNonUniformFAdd "Workgroup" "Reduce" %scalar : f32
     %1 = spv.GroupNonUniformFAdd "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
     ```
   }];
 }
let description = [{
     current invocation are NaN, then the result is an undefined value.
 
     ClusterSize is the size of cluster to use. ClusterSize must be a scalar
     of integer type, whose Signedness operand is 0. ClusterSize must come
     from a constant instruction. ClusterSize must be at least 1, and must be
     a power of 2. If ClusterSize is greater than the declared SubGroupSize,
     executing this instruction results in undefined behavior.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     operation ::= `"Reduce"` | `"InclusiveScan"` | `"ExclusiveScan"` | ...
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     non-uniform-fmax-op ::= ssa-id `=` `spv.GroupNonUniformFMax` scope operation
                             ssa-use ( `cluster_size` `(` ssa_use `)` )?
                             `:` float-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : f32
     %vector = ... : vector<4xf32>
     %0 = spv.GroupNonUniformFMax "Workgroup" "Reduce" %scalar : f32
     %1 = spv.GroupNonUniformFMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
     ```
   }];
 }
let description = [{
     current invocation are NaN, then the result is an undefined value.
 
     ClusterSize is the size of cluster to use. ClusterSize must be a scalar
     of integer type, whose Signedness operand is 0. ClusterSize must come
     from a constant instruction. ClusterSize must be at least 1, and must be
     a power of 2. If ClusterSize is greater than the declared SubGroupSize,
     executing this instruction results in undefined behavior.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     operation ::= `"Reduce"` | `"InclusiveScan"` | `"ExclusiveScan"` | ...
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     non-uniform-fmin-op ::= ssa-id `=` `spv.GroupNonUniformFMin` scope operation
                             ssa-use ( `cluster_size` `(` ssa_use `)` )?
                             `:` float-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : f32
     %vector = ... : vector<4xf32>
     %0 = spv.GroupNonUniformFMin "Workgroup" "Reduce" %scalar : f32
     %1 = spv.GroupNonUniformFMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
     ```
   }];
 }
let description = [{
     invocations is implementation defined.
 
     ClusterSize is the size of cluster to use. ClusterSize must be a scalar
     of integer type, whose Signedness operand is 0. ClusterSize must come
     from a constant instruction. ClusterSize must be at least 1, and must be
     a power of 2. If ClusterSize is greater than the declared SubGroupSize,
     executing this instruction results in undefined behavior.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     operation ::= `"Reduce"` | `"InclusiveScan"` | `"ExclusiveScan"` | ...
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     non-uniform-fmul-op ::= ssa-id `=` `spv.GroupNonUniformFMul` scope operation
                             ssa-use ( `cluster_size` `(` ssa_use `)` )?
                             `:` float-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : f32
     %vector = ... : vector<4xf32>
     %0 = spv.GroupNonUniformFMul "Workgroup" "Reduce" %scalar : f32
     %1 = spv.GroupNonUniformFMul "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
     ```
   }];
 }
let description = [{
      The type of Value must be the same as Result Type.
 
     ClusterSize is the size of cluster to use. ClusterSize must be a scalar
     of integer type, whose Signedness operand is 0. ClusterSize must come
     from a constant instruction. ClusterSize must be at least 1, and must be
     a power of 2. If ClusterSize is greater than the declared SubGroupSize,
     executing this instruction results in undefined behavior.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     operation ::= `"Reduce"` | `"InclusiveScan"` | `"ExclusiveScan"` | ...
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     non-uniform-iadd-op ::= ssa-id `=` `spv.GroupNonUniformIAdd` scope operation
                             ssa-use ( `cluster_size` `(` ssa_use `)` )?
                             `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformIAdd "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
 }
let description = [{
      The type of Value must be the same as Result Type.
 
     ClusterSize is the size of cluster to use. ClusterSize must be a scalar
     of integer type, whose Signedness operand is 0. ClusterSize must come
     from a constant instruction. ClusterSize must be at least 1, and must be
     a power of 2. If ClusterSize is greater than the declared SubGroupSize,
     executing this instruction results in undefined behavior.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     operation ::= `"Reduce"` | `"InclusiveScan"` | `"ExclusiveScan"` | ...
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     non-uniform-imul-op ::= ssa-id `=` `spv.GroupNonUniformIMul` scope operation
                             ssa-use ( `cluster_size` `(` ssa_use `)` )?
                             `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformIMul "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformIMul "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
 }
let description = [{
      The type of Value must be the same as Result Type.
 
     ClusterSize is the size of cluster to use. ClusterSize must be a scalar
     of integer type, whose Signedness operand is 0. ClusterSize must come
     from a constant instruction. ClusterSize must be at least 1, and must be
     a power of 2. If ClusterSize is greater than the declared SubGroupSize,
     executing this instruction results in undefined behavior.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     operation ::= `"Reduce"` | `"InclusiveScan"` | `"ExclusiveScan"` | ...
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     non-uniform-smax-op ::= ssa-id `=` `spv.GroupNonUniformSMax` scope operation
                             ssa-use ( `cluster_size` `(` ssa_use `)` )?
                             `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformSMax "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformSMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
 }
let description = [{
      The type of Value must be the same as Result Type.
 
     ClusterSize is the size of cluster to use. ClusterSize must be a scalar
     of integer type, whose Signedness operand is 0. ClusterSize must come
     from a constant instruction. ClusterSize must be at least 1, and must be
     a power of 2. If ClusterSize is greater than the declared SubGroupSize,
     executing this instruction results in undefined behavior.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     operation ::= `"Reduce"` | `"InclusiveScan"` | `"ExclusiveScan"` | ...
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     non-uniform-smin-op ::= ssa-id `=` `spv.GroupNonUniformSMin` scope operation
                             ssa-use ( `cluster_size` `(` ssa_use `)` )?
                             `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformSMin "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformSMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
 }
let description = [{
      The type of Value must be the same as Result Type.
 
     ClusterSize is the size of cluster to use. ClusterSize must be a scalar
     of integer type, whose Signedness operand is 0. ClusterSize must come
     from a constant instruction. ClusterSize must be at least 1, and must be
     a power of 2. If ClusterSize is greater than the declared SubGroupSize,
     executing this instruction results in undefined behavior.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     operation ::= `"Reduce"` | `"InclusiveScan"` | `"ExclusiveScan"` | ...
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     non-uniform-umax-op ::= ssa-id `=` `spv.GroupNonUniformUMax` scope operation
                             ssa-use ( `cluster_size` `(` ssa_use `)` )?
                             `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformUMax "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformUMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
 }
let description = [{
      The type of Value must be the same as Result Type.
 
     ClusterSize is the size of cluster to use. ClusterSize must be a scalar
     of integer type, whose Signedness operand is 0. ClusterSize must come
     from a constant instruction. ClusterSize must be at least 1, and must be
     a power of 2. If ClusterSize is greater than the declared SubGroupSize,
     executing this instruction results in undefined behavior.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"Workgroup"` | `"Subgroup"`
     operation ::= `"Reduce"` | `"InclusiveScan"` | `"ExclusiveScan"` | ...
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
     non-uniform-umin-op ::= ssa-id `=` `spv.GroupNonUniformUMin` scope operation
                             ssa-use ( `cluster_size` `(` ssa_use `)` )?
                             `:` integer-scalar-vector-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %four = spv.constant 4 : i32
     %scalar = ... : i32
     %vector = ... : vector<4xi32>
     %0 = spv.GroupNonUniformUMin "Workgroup" "Reduce" %scalar : i32
     %1 = spv.GroupNonUniformUMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
     ```
   }];
 }
 
 // -----
 
 #endif // SPIRV_NON_UNIFORM_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.td

let description = [{
      Each index in Indexes
 
     - must be a scalar integer type,
 
     - is treated as a signed count, and
 
     - must be an OpConstant when indexing into a structure.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
     ```
     access-chain-op ::= ssa-id `=` `spv.AccessChain` ssa-use
                         `[` ssa-use (',' ssa-use)* `]`
                         `:` pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = "spv.constant"() { value = 1: i32} : () -> i32
     %1 = spv.Variable : !spv.ptr<!spv.struct<f32, !spv.array<4xf32>>, Function>
     %2 = spv.AccessChain %1[%0] : !spv.ptr<!spv.struct<f32, !spv.array<4xf32>>, Function>
     %3 = spv.Load "Function" %2 ["Volatile"] : !spv.array<4xf32>
     ```
   }];
 
   let arguments = (ins
let description = [{
     such restriction starting with version 1.3.
 
     When used with the TessellationControl execution model, it also
     implicitly synchronizes the Output Storage Class:  Writes to Output
     variables performed by any invocation executed prior to a
     OpControlBarrier will be visible to any other invocation after return
     from that OpControlBarrier.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"CrossDevice"` | `"Device"` | `"Workgroup"` | ...
 
     memory-semantics ::= `"None"` | `"Acquire"` | "Release"` | ...
 
     control-barrier-op ::= `spv.ControlBarrier` scope, scope, memory-semantics
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.ControlBarrier "Workgroup", "Device", "Acquire|UniformMemory"
 
     ```
   }];
 
   let arguments = (ins
     SPV_ScopeAttr:$execution_scope,
     SPV_ScopeAttr:$memory_scope,
let description = [{
     instruction.
 
     Mode is the execution mode. See Execution Mode.
 
     This instruction is only valid when the Mode operand is an execution
     mode that takes no Extra Operands, or takes Extra Operands that are not
     <id> operands.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     execution-mode ::= "Invocations" | "SpacingEqual" |
                        <and other SPIR-V execution modes...>
 
     execution-mode-op ::= `spv.ExecutionMode ` ssa-use execution-mode
                           (integer-literal (`, ` integer-literal)* )?
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.ExecutionMode @foo "ContractionOff"
     spv.ExecutionMode @bar "LocalSizeHint", 3, 4, 5
     ```
   }];
 
   let arguments = (ins
     FlatSymbolRefAttr:$fn,
     SPV_ExecutionModeAttr:$execution_mode,
let description = [{
 
     Pointer is the pointer to load through.  Its type must be an
     OpTypePointer whose Type operand is the same as Result Type.
 
     If present, any Memory Operands must begin with a memory operand
     literal. If not present, it is the same as specifying the memory operand
     None.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     memory-access ::= `"None"` | `"Volatile"` | `"Aligned", ` integer-literal
                     | `"NonTemporal"`
 
     load-op ::= ssa-id ` = spv.Load ` storage-class ssa-use
                 (`[` memory-access `]`)? ` : ` spirv-element-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.Variable : !spv.ptr<f32, Function>
     %1 = spv.Load "Function" %0 : f32
     %2 = spv.Load "Function" %0 ["Volatile"] : f32
     %3 = spv.Load "Function" %0 ["Aligned", 4] : f32
     ```
   }];
 
   let arguments = (ins
let description = [{
     NonPrivateTexel image operand.
 
     Semantics declares what kind of memory is being controlled and what kind
     of control to apply.
 
     To execute both a memory barrier and a control barrier, see
     OpControlBarrier.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     scope ::= `"CrossDevice"` | `"Device"` | `"Workgroup"` | ...
 
     memory-semantics ::= `"None"` | `"Acquire"` | `"Release"` | ...
 
     memory-barrier-op ::= `spv.MemoryBarrier` scope, memory-semantics
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.MemoryBarrier "Device", "Acquire|UniformMemory"
 
     ```
   }];
 
   let arguments = (ins
     SPV_ScopeAttr:$memory_scope,
     SPV_MemorySemanticsAttr:$memory_semantics
let description = [{
     OpTypePointer whose Type operand is the same as the type of Object.
 
     Object is the object to store.
 
     If present, any Memory Operands must begin with a memory operand
     literal. If not present, it is the same as specifying the memory operand
     None.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     store-op ::= `spv.Store ` storage-class ssa-use `, ` ssa-use `, `
                   (`[` memory-access `]`)? `:` spirv-element-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.Variable : !spv.ptr<f32, Function>
     %1 = spv.FMul ... : f32
     spv.Store "Function" %0, %1 : f32
     spv.Store "Function" %0, %1 ["Volatile"] : f32
     spv.Store "Function" %0, %1 ["Aligned", 4] : f32
+    ```
   }];
 
   let arguments = (ins
     SPV_AnyPtr:$ptr,
     SPV_Type:$value,
     OptionalAttr<SPV_MemoryAccessAttr>:$memory_access,
     OptionalAttr<I32Attr>:$alignment
   );
 
+  let results = (outs);
+
   let builders = [
     OpBuilder<"Builder *builder, OperationState &state, "
       "Value ptr, Value value, ArrayRef<NamedAttribute> namedAttrs = {}", [{
       state.addOperands(ptr);
       state.addOperands(value);
       state.addAttributes(namedAttrs);
     }]>
   ];
-
-  let results = (outs);
 }
 
 // -----
 
 def SPV_UndefOp : SPV_Op<"undef", []> {
   let summary = "Make an intermediate object whose value is undefined.";
 
   let description = [{
     Result Type is the type of object to make.
 
     Each consumption of Result <id> yields an arbitrary, possibly different
     bit pattern or abstract value resulting in possibly different concrete,
     abstract, or opaque values.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     undef-op ::= `spv.undef` `:` spirv-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.undef : f32
     %1 = spv.undef : !spv.struct<!spv.array<4 x vector<4xi32>>>
     ```
   }];
 
   let arguments = (ins);
 
   let results = (outs
let description = [{
     the Result Type.
 
     Initializer is optional.  If Initializer is present, it will be the
     initial value of the variable’s memory content. Initializer must be an
     <id> from a constant instruction or a global (module scope) OpVariable
     instruction. Initializer must have the same type as the type pointed to
     by Result Type.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     variable-op ::= ssa-id `=` `spv.Variable` (`init(` ssa-use `)`)?
                     (`bind(` integer-literal, integer-literal `)`)?
                     (`built_in(` string-literal `)`)?
                     attribute-dict? `:` spirv-pointer-type
     ```
 
     where `init` specifies initializer and `bind` specifies the
     descriptor set and binding number. `built_in` specifies SPIR-V
     BuiltIn decoration associated with the op.
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.constant ...
 
     %1 = spv.Variable : !spv.ptr<f32, Function>
     %2 = spv.Variable init(%0): !spv.ptr<f32, Private>
     %3 = spv.Variable init(%0) bind(1, 2): !spv.ptr<f32, Uniform>
     %3 = spv.Variable built_in("GlobalInvocationID") : !spv.ptr<vector<3xi32>, Uniform>
     ```
   }];

mlir/include/mlir/Dialect/SPIRV/SPIRVStructureOps.td

let description = [{
     Variables in module scope are defined using symbol names. This op generates
     an SSA value that can be used to refer to the symbol within function scope
     for use in ops that expect an SSA value. This operation has no corresponding
     SPIR-V instruction; it's merely used for modelling purpose in the SPIR-V
     dialect. Since variables in module scope in SPIR-V dialect are of pointer
     type, this op returns a pointer type as well, and the type is the same as
     the variable referenced.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     spv-address-of-op ::= ssa-id `=` `spv._address_of` symbol-ref-id
                                      `:` spirv-pointer-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv._address_of @global_var : !spv.ptr<f32, Input>
     ```
   }];
 
   let arguments = (ins
     FlatSymbolRefAttr:$variable
   );
 
let description = [{
     * ...
 
     Having such a plethora of constant instructions renders IR transformations
     more tedious. Therefore, we use a single `spv.constant` op to represent
     them all. Note that conversion between those SPIR-V constant instructions
     and this op is purely mechanical; so it can be scoped to the binary
     (de)serialization process.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     spv-constant-op ::= ssa-id `=` `spv.constant` attribute-value
                         (`:` spirv-type)?
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv.constant true
     %1 = spv.constant dense<[2, 3]> : vector<2xf32>
     %2 = spv.constant [dense<3.0> : vector<2xf32>] : !spv.array<1xvector<2xf32>>
     ```
 
     TODO(antiagainst): support constant structs
   }];
 
let description = [{
     Interface symbols must be equal to or a superset of the
     `spv.globalVariable`s referenced by the entry point’s static call
     tree, within the interface’s storage classes.  Before version 1.4,
     the interface’s storage classes are limited to the Input and
     Output storage classes. Starting with version 1.4, the interface’s
     storage classes are all storage classes used in declaring all
     global variables referenced by the entry point’s call tree.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     execution-model ::= "Vertex" | "TesellationControl" |
                         <and other SPIR-V execution models...>
 
     entry-point-op ::= ssa-id `=` `spv.EntryPoint` execution-model
                        symbol-reference (`, ` symbol-reference)*
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.EntryPoint "GLCompute" @foo
     spv.EntryPoint "Kernel" @foo, @var1, @var2
 
     ```
   }];
 
   let arguments = (ins
     SPV_ExecutionModelAttr:$execution_model,
let description = [{
     Different from the SPIR-V binary format, this op is not allowed to
     implicitly capture global values, and all external references must use
     function arguments or symbol references. This op itself defines a symbol
     that is unique in the enclosing module op.
 
     This op itself takes no operands and generates no results. Its region
     can take zero or more arguments and return zero or one values.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     spv-function-control ::= "None" | "Inline" | "DontInline" | ...
     spv-function-op ::= `spv.func` function-signature
                          spv-function-control region
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.func @foo() -> () "None" { ... }
     spv.func @bar() -> () "Inline|Pure" { ... }
     ```
   }];
 
   let arguments = (ins
     TypeAttr:$type,
     StrAttr:$sym_name,
let description = [{
     scope (like Input, Output, StorageBuffer, etc.) are valid.
 
     Initializer is optional.  If Initializer is present, it will be
     the initial value of the variable’s memory content. Initializer
     must be an symbol defined from a constant instruction or other
     `spv.globalVariable` operation in module scope. Initializer must
     have the same type as the type of the defined symbol.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     variable-op ::= `spv.globalVariable` spirv-type symbol-ref-id
                     (`initializer(` symbol-ref-id `)`)?
                     (`bind(` integer-literal, integer-literal `)`)?
                     (`built_in(` string-literal `)`)?
                     attribute-dict?
     ```
 
     where `initializer` specifies initializer and `bind` specifies the
     descriptor set and binding number. `built_in` specifies SPIR-V
     BuiltIn decoration associated with the op.
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.globalVariable @var0 : !spv.ptr<f32, Input> @var0
     spv.globalVariable @var1 initializer(@var0) : !spv.ptr<f32, Output>
     spv.globalVariable @var2 bind(1, 2) : !spv.ptr<f32, Uniform>
     spv.globalVariable @var3 built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input>
     ```
   }];
 
   let arguments = (ins
let description = [{
     a clear-cut boundary.
 
     This op takes no operands and generates no results. This op should not
     implicitly capture values from the enclosing environment.
 
     This op has only one region, which only contains one block. The block
     must be terminated via the `spv._module_end` op.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     addressing-model ::= `Logical` | `Physical32` | `Physical64` | ...
     memory-model ::= `Simple` | `GLSL450` | `OpenCL` | `Vulkan` | ...
     spv-module-op ::= `spv.module` addressing-model memory-model
                       (requires  spirv-vce-attribute)?
                       (`attributes` attribute-dict)?
                       region
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.module Logical GLSL450  {}
 
     spv.module Logical Vulkan
         requires #spv.vce<v1.0, [Shader], [SPV_KHR_vulkan_memory_model]>
         attributes { some_additional_attr = ... } {
       spv.func @do_nothing() -> () {
         spv.Return
       }
def SPV_ReferenceOfOp : SPV_Op<"_reference_of", [NoSideEffect]> {
   let description = [{
     Specialization constant in module scope are defined using symbol names.
     This op generates an SSA value that can be used to refer to the symbol
     within function scope for use in ops that expect an SSA value.
     This operation has no corresponding SPIR-V instruction; it's merely used
     for modelling purpose in the SPIR-V dialect. This op's return type is
     the same as the specialization constant.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     spv-reference-of-op ::= ssa-id `=` `spv._reference_of` symbol-ref-id
                                        `:` spirv-scalar-type
     ```
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     %0 = spv._reference_of @spec_const : f32
     ```
   }];
 
   let arguments = (ins
     FlatSymbolRefAttr:$spec_const
   );
 
let description = [{
 
     * `OpSpecConstantTrue` and `OpSpecConstantFalse` for boolean constants
     * `OpSpecConstant` for scalar constants
 
     Similar as `spv.constant`, this op represents all of the above cases.
     `OpSpecConstantComposite` and `OpSpecConstantOp` are modelled with
     separate ops.
 
-    ### Custom assembly form
+    <!-- End of AutoGen section -->
 
     ```
     spv-spec-constant-op ::= `spv.specConstant` symbol-ref-id
                              `spec_id(` integer `)`
                              `=` attribute-value (`:` spirv-type)?
     ```
 
     where `spec_id` specifies the SPIR-V SpecId decoration associated with
     the op.
 
-    For example:
+    #### Example:
 
-    ```
+    ```mlir
     spv.specConstant @spec_const1 = true
     spv.specConstant @spec_const2 spec_id(5) = 42 : i32
     ```
 
     TODO(antiagainst): support composite spec constants with another op
   }];
 
   let arguments = (ins

mlir/utils/spirv/gen_spirv_dialect.py

- for_cap: bool value indicating whether this is the availability spec for
       capabilities themselves.
 
   Returns:
     - A `let availability = [...];` string if with availability spec or
       empty string if without availability spec
   """
   assert not (for_op and for_cap), 'cannot set both for_op and for_cap'
 
+  DEFAULT_MIN_VERSION = 'MinVersion<SPV_V_1_0>'
+  DEFAULT_MAX_VERSION = 'MaxVersion<SPV_V_1_5>'
+  DEFAULT_CAP = 'Capability<[]>'
+  DEFAULT_EXT = 'Extension<[]>'
+
   min_version = enum_case.get('version', '')
   if min_version == 'None':
     min_version = ''
   elif min_version:
     min_version = 'MinVersion<SPV_V_{}>'.format(min_version.replace('.', '_'))
   # TODO(antiagainst): delete this once ODS can support dialect-specific content
   # and we can use omission to mean no requirements.
   if for_op and not min_version:
-    min_version = 'MinVersion<SPV_V_1_0>'
+    min_version = DEFAULT_MIN_VERSION
 
   max_version = enum_case.get('lastVersion', '')
   if max_version:
     max_version = 'MaxVersion<SPV_V_{}>'.format(max_version.replace('.', '_'))
   # TODO(antiagainst): delete this once ODS can support dialect-specific content
   # and we can use omission to mean no requirements.
   if for_op and not max_version:
-    max_version = 'MaxVersion<SPV_V_1_5>'
+    max_version = DEFAULT_MAX_VERSION
 
   exts = enum_case.get('extensions', [])
   if exts:
     exts = 'Extension<[{}]>'.format(', '.join(sorted(set(exts))))
     # We need to strip the minimal version requirement if this symbol is
     # available via an extension, which means *any* SPIR-V version can support
     # it as long as the extension is provided. The grammar's 'version' field
     # under such case should be interpreted as this symbol is introduced as
     # a core symbol since the given version, rather than a minimal version
     # requirement.
-    min_version = 'MinVersion<SPV_V_1_0>' if for_op else ''
+    min_version = DEFAULT_MIN_VERSION if for_op else ''
   # TODO(antiagainst): delete this once ODS can support dialect-specific content
   # and we can use omission to mean no requirements.
   if for_op and not exts:
-    exts = 'Extension<[]>'
+    exts = DEFAULT_EXT
 
   caps = enum_case.get('capabilities', [])
   implies = ''
   if caps:
     canonicalized_caps = []
     for c in caps:
       if c in capability_mapping:
         canonicalized_caps.append(capability_mapping[c])
if for_cap:
       implies = 'list<I32EnumAttrCase> implies = [{}];'.format(
           ', '.join(prefixed_caps))
     else:
       caps = 'Capability<[{}]>'.format(', '.join(prefixed_caps))
       implies = ''
   # TODO(antiagainst): delete this once ODS can support dialect-specific content
   # and we can use omission to mean no requirements.
   if for_op and not caps:
-    caps = 'Capability<[]>'
+    caps = DEFAULT_CAP
 
   avail = ''
-  if min_version or max_version or caps or exts:
+  # Compose availability spec if any of the requirements is not empty.
+  # For ops, because we have a default in SPV_Op class, omit if the spec
+  # is the same.
+  if (min_version or max_version or caps or exts) and not (
+      for_op and min_version == DEFAULT_MIN_VERSION and
+      max_version == DEFAULT_MAX_VERSION and caps == DEFAULT_CAP and
+      exts == DEFAULT_EXT):
     joined_spec = ',\n    '.join(
         [e for e in [min_version, max_version, exts, caps] if e])
     avail = '{} availability = [\n    {}\n  ];'.format(
         'let' if for_op else 'list<Availability>', joined_spec)
 
   return '{}{}{}'.format(implies, '\n  ' if implies and avail else '', avail)
 
 
if quantifier == '?':
       arg_type = 'OptionalAttr<{}>'.format(arg_type)
 
   name = operand.get('name', '')
   name = snake_casify(name) if name else kind.lower()
 
   return '{}:${}'.format(arg_type, name)
 
 
-def get_description(text, assembly):
+def get_description(text, appendix):
   """Generates the description for the given SPIR-V instruction.
 
   Arguments:
     - text: Textual description of the operation as string.
-    - assembly: Custom Assembly format with example as string.
+    - appendix: Additional contents to attach in description as string,
+                includking IR examples, and others.
 
   Returns:
     - A string that corresponds to the description of the Tablegen op.
   """
-  fmt_str = ('{text}\n\n    ### Custom assembly ' 'form\n{assembly}\n  ')
-  return fmt_str.format(
-      text=text, assembly=assembly)
+  fmt_str = '{text}\n\n    <!-- End of AutoGen section -->\n{appendix}\n  '
+  return fmt_str.format(text=text, appendix=appendix)
 
 
 def get_op_definition(instruction, doc, existing_info, capability_mapping):
   """Generates the TableGen op definition for the given SPIR-V instruction.
 
   Arguments:
     - instruction: the instruction's SPIR-V JSON grammar
     - doc: the instruction's SPIR-V HTML doc
if inst_category == 'Op':
     fmt_str +='\n  let arguments = (ins{args});\n\n'\
               '  let results = (outs{results});\n'
 
   fmt_str +='{extras}'\
             '}}\n'
 
   opname = instruction['opname'][2:]
   category_args = existing_info.get('category_args', '')
-  # Make sure we have ', ' to separate the category arguments from traits
-  category_args = category_args.rstrip(', ') + ', '
 
   if '\n' in doc:
     summary, text = doc.split('\n', 1)
   else:
     summary = doc
     text = ''
   wrapper = textwrap.TextWrapper(
       width=76, initial_indent='    ', subsequent_indent='    ')
def get_op_definition(instruction, doc, existing_info, capability_mapping):
   # Wrap text
   text = text.split('\n')
   text = [wrapper.fill(line) for line in text if line]
   text = '\n\n'.join(text)
 
   operands = instruction.get('operands', [])
 
   # Op availability
+  avail = ''
+  # We assume other instruction categories has a base availability spec, so
+  # only add this if this is directly using SPV_Op as the base.
+  if inst_category == 'Op':
     avail = get_availability_spec(instruction, capability_mapping, True, False)
     if avail:
       avail = '\n\n  {0}'.format(avail)
 
   # Set op's result
   results = ''
   if len(operands) > 0 and operands[0]['kind'] == 'IdResultType':
     results = '\n    SPV_Type:$result\n  '
     operands = operands[1:]
   if 'results' in existing_info:
     results = existing_info['results']
if arguments is None:
     if arguments:
       # Prepend and append whitespace for formatting
       arguments = '\n    {}\n  '.format(arguments)
 
   description = existing_info.get('description', None)
   if description is None:
     assembly = '\n    ```\n'\
                '    [TODO]\n'\
-               '    ```\n\n'\
-               '    For example:\n\n'\
+               '    ```mlir\n\n'\
+               '    #### Example:\n\n'\
                '    ```\n'\
                '    [TODO]\n' \
                '    ```'
     description = get_description(text, assembly)
 
   return fmt_str.format(
       opname=opname,
       category_args=category_args,
def get_string_between_nested(base, start, end):
   Arguments:
     - base: string to extract from.
     - start: string to use as the start of the substring.
     - end: string to use as the end of the substring.
 
   Returns:
     - The substring if found
     - The part of the base after end of the substring. Is the base string itself
-      if the substring wasnt found.
+      if the substring wasn't found.
   """
   split = base.split(start, 1)
   if len(split) == 2:
     # Handle nesting delimiters
     rest = split[1]
     unmatched_start = 1
     index = 0
     while unmatched_start > 0 and index < len(rest):
       if rest[index:].startswith(end):
         unmatched_start -= 1
+        if unmatched_start == 0:
+          break
         index += len(end)
       elif rest[index:].startswith(start):
         unmatched_start += 1
         index += len(start)
       else:
         index += 1
 
     assert index < len(rest), \
            'cannot find end "{end}" while extracting substring '\
            'starting with "{start}"'.format(start=start, end=end)
-    return rest[:index - len(end)].rstrip(end), rest[index:]
+    return rest[:index], rest[index + len(end):]
   return '', split[0]
 
 
 def extract_td_op_info(op_def):
   """Extracts potentially manually specified sections in op's definition.
 
   Arguments: - A string containing the op's TableGen definition
     - doc: the instruction's SPIR-V HTML doc
def extract_td_op_info(op_def):
   inst_category = [
       o[4:] for o in re.findall('SPV_\w+Op',
                                 op_def.split(':', 1)[1])
   ]
   assert len(inst_category) <= 1, 'more than one ops in the same section!'
   inst_category = inst_category[0] if len(inst_category) == 1 else 'Op'
 
   # Get category_args
-  op_tmpl_params = get_string_between_nested(op_def, '<', '>')[0]
+  op_tmpl_params, _ = get_string_between_nested(op_def, '<', '>')
   opstringname, rest = get_string_between(op_tmpl_params, '"', '"')
   category_args = rest.split('[', 1)[0]
 
   # Get traits
-  traits, _ = get_string_between(rest, '[', ']')
+  traits, _ = get_string_between_nested(rest, '[', ']')
 
   # Get description
   description, rest = get_string_between(op_def, 'let description = [{\n',
                                          '}];\n')
 
   # Get arguments
   args, rest = get_string_between(rest, '  let arguments = (ins', ');\n')