Replace usages of instruction with operation in the g3 documents.

PiperOrigin-RevId: 241037784

Author: River707

Diff for: g3doc/Canonicalization.md

@@ -40,7 +40,7 @@ Some important things to think about w.r.t. canonicalization patterns:
 
 These transformation are applied to all levels of IR:
 
-*   Elimination of instructions that have no side effects and have no uses.
+*   Elimination of operations that have no side effects and have no uses.
 
 *   Constant folding - e.g. "(addi 1, 2)" to "3". Constand folding hooks are
     specified by operations.
@@ -53,10 +53,10 @@ These transformation are applied to all levels of IR:
 These transformations are applied to builtin ops:
 
 *   `constant` ops are uniqued and hoisted into the entry block of a function.
-*   (TODO) Merge `affine.apply` instructions that directly feed each other.
+*   (TODO) Merge `affine.apply` operations that directly feed each other.
 
 ## Standard Ops Canonicalizations
 
-*   Shape folding of `alloc` instructions to turn dynamic dimensions into static
+*   Shape folding of `alloc` operations to turn dynamic dimensions into static
     ones.
-*   Folding `memref_cast` instructions into users where possible.
+*   Folding `memref_cast` operations into users where possible.

Diff for: g3doc/ConversionToLLVMDialect.md

@@ -178,7 +178,7 @@ func @qux(!llvm.type<"i32">, !llvm.type<"float">) -> !llvm.type<"{i64, double}">
 func @quux(() -> ()) -> (() -> ())
 // are converted into pointers to functions
 func @quux(!llvm.type<"void ()*">) -> !llvm.type<"void ()*">
-// the call flow is handled by the LLVM dialect `call` instruction supporting both
+// the call flow is handled by the LLVM dialect `call` operation supporting both
 // direct and indirect calls
 ```
 
@@ -291,8 +291,8 @@ Accesses to a memref element are transformed into an access to an element of the
 buffer pointed to by the descriptor. The position of the element in the buffer
 is calculated by linearizing memref indices in row-major order (lexically first
 index is the slowest varying, similar to C). The computation of the linear
-address is emitted as arithmetic instructions in the LLVM IR dialect. Static
-sizes are introduced as constants. Dynamic sizes are extracted from the memref
+address is emitted as arithmetic operation in the LLVM IR dialect. Static sizes
+are introduced as constants. Dynamic sizes are extracted from the memref
 descriptor.
 
 Accesses to zero-dimensional memref (that are interpreted as pointers to the

Diff for: g3doc/Dialects/Affine.md

@@ -10,7 +10,7 @@ The affine dialect imposes certain restrictions on dimension and symbolic
 identifiers to enable powerful analysis and transformation. A symbolic
 identifier can be bound to an SSA value that is either an argument to the
 function, a value defined at the top level of that function (outside of all
-loops and if instructions), the result of a
+loops and if operations), the result of a
 [`constant` operation](../LangRef.md#'constant'-operation), or the result of an
 [`affine.apply` operation](#'affine.apply'-operation) that recursively takes as
 arguments any symbolic identifiers. Dimensions may be bound not only to anything
@@ -29,11 +29,11 @@ Syntax:
 operation ::= ssa-id `=` `affine.apply` affine-map dim-and-symbol-use-list
 ```
 
-The `affine.apply` instruction applies an
+The `affine.apply` operation applies an
 [affine mapping](../LangRef.md#affine-expressions) to a list of SSA values,
 yielding a single SSA value. The number of dimension and symbol arguments to
 affine.apply must be equal to the respective number of dimensional and symbolic
-inputs to the affine mapping; the `affine.apply` instruction always returns one
+inputs to the affine mapping; the `affine.apply` operation always returns one
 value. The input operands and result must all have 'index' type.
 
 Example:
@@ -53,7 +53,7 @@ Syntax:
 
 ``` {.ebnf}
 operation   ::= `affine.for` ssa-id `=` lower-bound `to` upper-bound
-                      (`step` integer-literal)? `{` inst* `}`
+                      (`step` integer-literal)? `{` op* `}`
 
 lower-bound ::= `max`? affine-map dim-and-symbol-use-list | shorthand-bound
 upper-bound ::= `min`? affine-map dim-and-symbol-use-list | shorthand-bound
@@ -113,8 +113,8 @@ func @simple_example(%A: memref<?x?xf32>, %B: memref<?x?xf32>) {
 Syntax:
 
 ``` {.ebnf}
-operation    ::= `affine.if` if-inst-cond `{` inst* `}` (`else` `{` inst* `}`)?
-if-inst-cond ::= integer-set dim-and-symbol-use-list
+operation    ::= `affine.if` if-op-cond `{` op* `}` (`else` `{` op* `}`)?
+if-op-cond ::= integer-set dim-and-symbol-use-list
 ```
 
 The `affine.if` operation restricts execution to a subset of the loop iteration

Diff for: g3doc/Dialects/LLVM.md

@@ -1,7 +1,7 @@
 # LLVM IR Dialect
 
 This dialect wraps the LLVM IR types and instructions into MLIR types and
-operations. It provides several additional instructions that are necessary to
+operations. It provides several additional operations that are necessary to
 cover for the differences in the IR structure (e.g., MLIR does not have `phi`
 operations and LLVM IR does not have a `constant` operation).
 
@@ -101,7 +101,7 @@ Examples:
 %1 = "llvm.fdiv"(%a, %b) : (!llvm<"float">, !llvm<"float">) -> !llvm<"float">
 ```
 
-#### Memory-related instructions
+#### Memory-related operations
 
 -   `<r> = alloca <size>`
 -   `<r> = getelementptr <address>, <index> (, <index>)+`
@@ -213,7 +213,7 @@ this behavior by providing a variadic `call` operation for 0- and 1-result
 functions. Even though MLIR supports multi-result functions, LLVM IR dialect
 disallows them.
 
-The `call` instruction supports both direct and indirect calls. Direct calls
+The `call` operation supports both direct and indirect calls. Direct calls
 require the `callee` attribute of function type to be present. Otherwise, the
 call is considered indirect and expects the function as its first argument.
 

Diff for: g3doc/Dialects/Vector.md

@@ -94,7 +94,7 @@ On a GPU one could then map `i`, `j`, `k` to blocks and threads. Notice that the
 temporary storage footprint is `3 * 5` values but `3 * 4 * 5` values are
 actually transferred betwen `%A` and `%tmp`.
 
-Alternatively, if a notional vector broadcast instruction were available, the
+Alternatively, if a notional vector broadcast operation were available, the
 lowered code would resemble:
 
 ```mlir {.mlir}

Diff for: g3doc/GenericDAGRewriter.md

@@ -322,14 +322,14 @@ class Pattern {
   /// returns a None value.  On success it a (possibly null) pattern-specific
   /// state wrapped in a Some.  This state is passed back into its rewrite
   /// function if this match is selected.
-  virtual Optional<PatternState*> match(OperationInst *op) const = 0;
+  virtual Optional<PatternState*> match(Operation *op) const = 0;
 
   /// Rewrite the IR rooted at the specified operation with the result of
   /// this pattern, generating any new operations with the specified
   /// rewriter.  If an unexpected error is encountered (an internal
   /// compiler error), it is emitted through the normal MLIR diagnostic
   /// hooks and the IR is left in a valid state.
-  virtual void rewrite(OperationInst *op, PatternState *state,
+  virtual void rewrite(Operation *op, PatternState *state,
                        PatternRewriter &rewriter) const;
 };
 ```
@@ -372,8 +372,8 @@ class PatternMatcher {
    // Given a specific operation, see if there is some rewrite that is
    // interesting.  If so, return success and return the list of new
    // operations that were created.  If not, return failure.
-   bool matchAndRewrite(OperationInst *op,
-                        SmallVectorImpl<OperationInst*> &newlyCreatedOps);
+   bool matchAndRewrite(Operation *op,
+                        SmallVectorImpl<Operation*> &newlyCreatedOps);
 };
 ```