[Mlir-commits] [mlir] 9488f0d - [mlir] NFC: fix broken links in doc of operation definitions

[Kazuaki Ishizaki]

Author: Kazuaki Ishizaki
Date: 2020-04-23T18:36:29+09:00
New Revision: 9488f0d518f4cca8ad7ac558f004c11b2d70ad6f

URL: https://github.com/llvm/llvm-project/commit/9488f0d518f4cca8ad7ac558f004c11b2d70ad6f
DIFF: https://github.com/llvm/llvm-project/commit/9488f0d518f4cca8ad7ac558f004c11b2d70ad6f.diff

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

Differential Revision: https://reviews.llvm.org/D78696

Added: 
    

Modified: 
    mlir/include/mlir/Dialect/Affine/IR/AffineOps.td
    mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

Removed: 
    


################################################################################
diff  --git a/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td b/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td
index cb827395840a..3dcea90465bd 100644
--- a/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td
+++ b/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td
@@ -114,7 +114,7 @@ def AffineForOp : Affine_Op<"for",
 
     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.
@@ -292,7 +292,7 @@ def AffineIfOp : Affine_Op<"if",
     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.
 
@@ -592,8 +592,8 @@ def AffineTerminatorOp :
     ```
 
     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)

diff  --git a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td
index 6c5f7c270f7a..bf0769dac652 100644
--- a/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td
+++ b/mlir/include/mlir/Dialect/StandardOps/IR/Ops.td
@@ -697,7 +697,7 @@ def CallIndirectOp : Std_Op<"call_indirect", [
     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:
 
@@ -1516,8 +1516,8 @@ def LoadOp : Std_Op<"load",
 
     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.
@@ -1537,7 +1537,7 @@ def LoadOp : Std_Op<"load",
     **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)
@@ -1932,7 +1932,7 @@ def SelectOp : Std_Op<"select", [NoSideEffect, SameOperandsAndResultShape,
     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:
@@ -2245,8 +2245,8 @@ def StoreOp : Std_Op<"store",
     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.
 
@@ -2259,7 +2259,7 @@ def StoreOp : Std_Op<"store",
     **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)