[mlir] NFC: fix broken links in doc of operation definitions

[ftynse]

Thanks!

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

let description = [{
 
     lower-bound ::= `max`? affine-map-attribute dim-and-symbol-use-list | shorthand-bound
     upper-bound ::= `min`? affine-map-attribute dim-and-symbol-use-list | shorthand-bound
     shorthand-bound ::= ssa-id | `-`? integer-literal
     ```
 
     The `affine.for` operation represents an affine loop nest. It has one region
     containing its body. This region must contain one block that terminates with
-    [`affine.terminator`](#affineterminator-operation). *Note:* when
+    [`affine.terminator`](#affineterminator-affineterminatorop). *Note:* when
     `affine.for` is printed in custom format, the terminator is omitted. The
     block has one argument of [`index`](../LangRef.md#index-type) type that
     represents the induction variable of the loop.
 
     The `affine.for` operation executes its body a number of times iterating
     from a lower bound to an upper bound by a stride. The stride, represented by
     `step`, is a positive constant integer which defaults to "1" if not present.
     The lower and upper bounds specify a half-open range: the range includes the
let description = [{
     The [same restrictions](#restrictions-on-dimensions-and-symbols) hold for
     these SSA values as for all bindings of SSA values to dimensions and
     symbols.
 
     The `affine.if` operation contains two regions for the "then" and "else"
     clauses. The latter may be empty (i.e. contain no blocks), meaning the
     absence of the else clause. When non-empty, both regions must contain
     exactly one block terminating with
-    [`affine.terminator`](#affineterminator-operation). *Note:* when `affine.if`
+    [`affine.terminator`](#affineterminator-affineterminatorop). *Note:* when `affine.if`
     is printed in custom format, the terminator is omitted. These blocks must
     not have any arguments.
 
     Example:
 
     ```mlir
     #set = affine_set<(d0, d1)[s0]: (d0 - 10 >= 0, s0 - d0 - 9 >= 0,
                                      d1 - 10 >= 0, s0 - d1 - 9 >= 0)>
def AffineTerminatorOp :
   let description = [{
     Syntax:
 
     ```
     operation ::= `"affine.terminator"() : () -> ()`
     ```
 
     Affine terminator is a special terminator operation for blocks inside affine
-    loops ([`affine.for`](#affinefor-operation)) and branches
-    ([`affine.if`](#affineif-operation)). It unconditionally transmits the
+    loops ([`affine.for`](#affinefor-affineforop)) and branches
+    ([`affine.if`](#affineif-affineifop)). It unconditionally transmits the
     control flow to the successor of the operation enclosing the region.
 
     *Rationale*: bodies of affine operations are [blocks](../LangRef.md#blocks)
     that must have terminators. Loops and branches represent structured control
     flow and should not accept arbitrary branches as terminators.
 
     This operation does _not_ have a custom syntax. However, affine control
     operations omit the terminator in their custom syntax for brevity.

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

def CallIndirectOp : Std_Op<"call_indirect", [
   let summary = "indirect call operation";
   let description = [{
     The `call_indirect` operation represents an indirect call to a value of
     function type. Functions are first class types in MLIR, and may be passed as
     arguments and merged together with block arguments. The operands and result
     types of the call must match the specified function type.
 
     Function values can be created with the
-    [`constant` operation](#constant-operation).
+    [`constant` operation](#stdconstant-constantop).
 
     Example:
 
     ```mlir
     %31 = call_indirect %15(%0, %1)
             : (tensor<16xf32>, tensor<16xf32>) -> tensor<16xf32>
     ```
   }];
let description = [{
     The `load` op reads an element from a memref specified by an index list. The
     output of load is a new value with the same type as the elements of the
     memref. The arity of indices is the rank of the memref (i.e., if the memref
     loaded from is of rank 3, then 3 indices are required for the load following
     the memref identifier).
 
     In an `affine.if` or `affine.for` body, the indices of a load are restricted
     to SSA values bound to surrounding loop induction variables,
-    [symbols](../LangRef.md#dimensions-and-symbols), results of a
-    [`constant` operation](#constant-operation), or the result of an
+    [symbols](../Affine.md#dimensions-and-symbols), results of a
+    [`constant` operation](#stdconstant-constantop), or the result of an
     `affine.apply` operation that can in turn take as arguments all of the
     aforementioned SSA values or the recursively result of such an
     `affine.apply` operation.
 
     Example:
 
     ```mlir
     %1 = affine.apply affine_map<(d0, d1) -> (3*d0)> (%i, %j)
     %2 = affine.apply affine_map<(d0, d1) -> (d1+1)> (%i, %j)
     %12 = load %A[%1, %2] : memref<8x?xi32, #layout, memspace0>
 
     // Example of an indirect load (treated as non-affine)
     %3 = affine.apply affine_map<(d0) -> (2*d0 + 1)>(%12)
     %13 = load %A[%3, %2] : memref<4x?xi32, #layout, memspace0>
     ```
 
     **Context:** The `load` and `store` operations are specifically crafted to
     fully resolve a reference to an element of a memref, and (in affine
     `affine.if` and `affine.for` operations) the compiler can follow use-def
-    chains (e.g. through [`affine.apply`](Affine.md#affineapply-operation)
+    chains (e.g. through [`affine.apply`](Affine.md#affineapply-affineapplyop)
     operations) to precisely analyze references at compile-time using polyhedral
     techniques. This is possible because of the
     [restrictions on dimensions and symbols](Affine.md#restrictions-on-dimensions-and-symbols)
     in these contexts.
   }];
 
   let arguments = (ins Arg<AnyMemRef, "the reference to load from",
                            [MemRead]>:$memref,
let description = [{
     the second operand is chosen, otherwise the third operand is chosen.
     The second and the third operand must have the same type.
 
     The operation applies to vectors and tensors elementwise given the _shape_
     of all operands is identical. The choice is made for each element
     individually based on the value at the same position as the element in the
     condition operand.
 
-    The `select` operation combined with [`cmpi`](#std-cmpi) can be used
+    The `select` operation combined with [`cmpi`](#stdcmpi-cmpiop) can be used
     to implement `min` and `max` with signed or unsigned comparison semantics.
 
     Example:
 
     ```mlir
     // Custom form of scalar selection.
     %x = select %cond, %true, %false : i32
 
def StoreOp : Std_Op<"store",
   let description = [{
     Store a value to a memref location given by indices. The value stored should
     have the same type as the elemental type of the memref. The number of
     arguments provided within brackets need to match the rank of the memref.
 
     In an affine context, the indices of a store are restricted to SSA values
     bound to surrounding loop induction variables,
     [symbols](Affine.md#restrictions-on-dimensions-and-symbols), results of a
-    [`constant` operation](#constant-operation), or the result of an
-    [`affine.apply`](Affine.md#affineapply-operation) operation that can in turn
+    [`constant` operation](#stdconstant-constantop), or the result of an
+    [`affine.apply`](Affine.md#affineapply-affineapplyop) operation that can in turn
     take as arguments all of the aforementioned SSA values or the recursively
     result of such an `affine.apply` operation.
 
     Example:
 
     ```mlir
     store %100, %A[%1, 1023] : memref<4x?xf32, #layout, memspace0>
     ```
 
     **Context:** The `load` and `store` operations are specifically crafted to
     fully resolve a reference to an element of a memref, and (in polyhedral
     `affine.if` and `affine.for` operations) the compiler can follow use-def
-    chains (e.g. through [`affine.apply`](Affine.md#affineapply-operation)
+    chains (e.g. through [`affine.apply`](Affine.md#affineapply-affineapplyop)
     operations) to precisely analyze references at compile-time using polyhedral
     techniques. This is possible because of the
     [restrictions on dimensions and symbols](Affine.md#restrictions-on-dimensions-and-symbols)
     in these contexts.
   }];
 
   let arguments = (ins AnyType:$value,
                        Arg<AnyMemRef, "the reference to store to",