[mlir][vector] Update transfer read/write doc (NFC).

[gysit]

Summary

Clarify the in_bounds attribute is specified for the vector dimensions.

[nicolasvasilache]

Thanks for improving the doc!

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

let description = [{
     [Tensor](../LangRef.md#tensor-type) supplied as its first operand
     into a [vector](../LangRef.md#vector-type) of the same base elemental type.
 
     A memref/tensor operand with vector element type, must have its vector
     element type match a suffix (shape and element type) of the vector (e.g.
     memref<3x2x6x4x3xf32>, vector<1x1x4x3xf32>).
 
     The slice is further defined by a full-rank index within the MemRef/Tensor,
-    supplied as the operands `[1 .. 1 + rank(memref/tensor))`.
+    supplied as the operands `[1 .. 1 + rank(memref/tensor))` that defines the
+    starting point of the transfer (e.g. `%A[%i0, %i1, %i2]`).
 
     The permutation_map [attribute](../LangRef.md#attributes) is an
     [affine-map](Affine.md#affine-maps) which specifies the transposition on the
     slice to match the vector shape. The permutation map may be implicit and
     omitted from parsing and printing if it is the canonical minor identity map
     (i.e. if it does not permute or broadcast any dimension).
 
     The size of the slice is specified by the size of the vector, given as the
     return type.
 
     An SSA value `padding` of the same elemental type as the MemRef/Tensor is
     provided to specify a fallback value in the case of out-of-bounds accesses
     and/or masking.
 
     An optional SSA value `mask` of the same shape as the vector type may be
     specified to mask out elements. Such elements will be replaces with
     `padding`. Elements whose corresponding mask element is `0` are masked out.
 
-    An optional boolean array attribute is provided to specify which dimensions
-    of the transfer are guaranteed to be within bounds. The length of the array
-    must equal the rank of the vector type. Broadcast dimensions must always be
-    in-bounds. The absence of this optional `in_bounds` attribute signifies that
-    any dimension of the transfer (except for broadcasts) may be out-of-bounds.
-    A `vector.transfer_read` can be lowered to a simple load if all dimensions
-    are specified to be within bounds and no `mask` was specified.
-
-    Note that `in_bounds` is specified for result dimensions and not input
-    dimensions. The starting point of the transfer, i.e.,
-    `%A[%expr1, %expr2, %expr3, %expr4]` in the example below, is expected to
-    be in-bounds and as indices are increasing, accesses may run out-of-bounds.
+    An optional boolean array attribute `in_bounds` specifies for every vector
+    dimension if the transfer is guaranteed to be within the source bounds.
+    While the starting point of the transfer has to be in-bounds, accesses may
+    run out-of-bounds as indices increase. Broadcast dimensions must always be
+    in-bounds. If specified, the `in_bounds` array length has to be equal to the
+    vector rank. In absence of the attribute, accesses along all dimensions
+    (except for broadcasts) may run out-of-bounds. A `vector.transfer_read` can
+    be lowered to a simple load if all dimensions are specified to be within
+    bounds and no `mask` was specified.
 
     This operation is called 'read' by opposition to 'load' because the
     super-vector granularity is generally not representable with a single
     hardware register. A `vector.transfer_read` is thus a mid-level abstraction
     that supports super-vectorization with non-effecting padding for full-tile
     only operations.
 
     More precisely, let's dive deeper into the permutation_map for the following
let description = [{
     supplied as its second operand.
 
     A vector memref/tensor operand must have its vector element type match a
     suffix (shape and element type) of the vector (e.g. memref<3x2x6x4x3xf32>,
     vector<1x1x4x3xf32>). If the operand is a tensor, the operation returns a
     new tensor of the same type.
 
     The slice is further defined by a full-rank index within the MemRef/Tensor,
-    supplied as the operands `[2 .. 2 + rank(memref/tensor))`.
+    supplied as the operands `[2 .. 2 + rank(memref/tensor))` that defines the
+    starting point of the transfer (e.g. `%A[%i0, %i1, %i2, %i3]`).
 
     The permutation_map [attribute](../LangRef.md#attributes) is an
     [affine-map](Affine.md#affine-maps) which specifies the transposition on the
     slice to match the vector shape. The permutation map may be implicit and
     omitted from parsing and printing if it is the canonical minor identity map
     (i.e. if it does not permute any dimension). In contrast to `transfer_read`,
     write ops cannot have broadcast dimensions.
 
     The size of the slice is specified by the size of the vector.
 
     An optional SSA value `mask` of the same shape as the vector type may be
     specified to mask out elements. Elements whose corresponding mask element
     is `0` are masked out.
 
-    An optional boolean array attribute is provided to specify which dimensions
-    of the transfer are guaranteed to be within bounds. The absence of this
-    `in_bounds` attribute signifies that any dimension of the transfer may be
-    out-of-bounds. A `vector.transfer_write` can be lowered to a simple store
-    if all dimensions are specified to be within bounds and no `mask` was
-    specified.
-
-    An optional boolean array attribute is provided to specify which dimensions
-    of the transfer are guaranteed to be within bounds. The length of the array
-    must equal the rank of the vector type. The absence of this optional
-    `in_bounds` attribute signifies that any dimension of the transfer
-    may be out-of-bounds. A `vector.transfer_write` can be lowered to a simple
-    store if all dimensions are specified to be within bounds and no `mask` was
-    specified.
-
-    Note that `in_bounds` is specified for result dimensions and not input
-    dimensions. The starting point of the transfer, i.e.,
-    `%A[%expr1, %expr2, %expr3, %expr4]` in the example below, is expected to
-    be in-bounds and as indices are increasing, accesses may run out-of-bounds.
+    An optional boolean array attribute `in_bounds` specifies for every vector
+    dimension if the transfer is guaranteed to be within the source bounds.
+    While the starting point of the transfer has to be in-bounds, accesses may
+    run out-of-bounds as indices increase. If specified, the `in_bounds` array
+    length has to be equal to the vector rank. In absence of the attribute,
+    accesses along all dimensions may run out-of-bounds. A
+    `vector.transfer_write` can be lowered to a simple store if all dimensions
+    are specified to be within bounds and no `mask` was specified.
 
     This operation is called 'write' by opposition to 'store' because the
     super-vector granularity is generally not representable with a single
     hardware register. A `vector.transfer_write` is thus a
     mid-level abstraction that supports super-vectorization with non-effecting
     padding for full-tile-only code. It is the responsibility of
     `vector.transfer_write`'s implementation to ensure the memory writes are
     valid. Different lowerings may be pertinent depending on the hardware