[MLIR] Allow Loop dialect IfOp and ForOp to define values

[nmostafa]

Summary

This patch implements the RFCs proposed here and here.
It introduces the following changes:

• All Loop Ops region, except for ReduceOp, terminate with a YieldOp.
• YieldOp can have variadice operands that is used to return values out of IfOp and ForOp regions.
• Change IfOp and ForOp syntax and representation to define values.
• Add unit-tests and update .td documentation.
• YieldOp is a terminator to loop.for/if/parallel
• YieldOp custom parser and printer

Lowering is not supported at the moment, and will be in a follow-up PR.

Thanks.

[stephenneuendorffer]

This looks like a really great start! Thanks for sketching this out.

mlir/lib/Dialect/LoopOps/LoopOps.cpp

159–169

For the for() loop syntax, I think that iter_args and the result type list should go together. They are either both present or both absent. As a result, there should be no need to replicate the type information 2x in the op syntax.

I think this could work two ways:

for()....iter_args(%x=%y) -> (i32) {...}
if %c -> (i32) {...} else {...}

However, with the else branch of the if being optional, it might make sense to have:

for()....args(%x=%y : i32) {...}
if %c args(%x=%y: i32) {...} else {...}

This would also more conveniently represent the case where %x is assigned in one branch of the if, but not the other.

mlir/test/Dialect/Loops/invalid.mlir

356

Need negative tests for type conflicts.

[rriddle]

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

118

Is this wrapped at 80 characters?

142

Can you just do:

getOperands().drop_front(getNumCtrlOperands())

?

147

Capitalize sentences and change these to ///

154

This doesn't look like it's wrapped at 80 characters/

197

A Also?

198

Same here.

208

nit: arguments before results

360

then -> the

mlir/lib/Dialect/LoopOps/LoopOps.cpp

89

You need to return when you emit an error.

159

Don't use !, use succeeded/failed(...) instead when parsing optional constructs.

503

Why is this necessary?

512

terminates

520

Return on error.

530

Start sentences with capital letters. Also typo opreands.

[nmostafa]

Review fixes

[nmostafa]

mlir/lib/Dialect/LoopOps/LoopOps.cpp

159–169

I personally prefer seeing the types right next to the operands for better readability (especially if you have too many operands, you have to look at the end of the op to figure out the types).

The result types are still convenient look at to quickly figure out the return types, but I am happy to remove it if there is consensus.

503

EnsureTerminator expects such a builder interface. Even though YieldOp has variadic arguments, ODS doesn't auto-gen that builder. Looks like ODS limitation.

[bondhugula]

Mostly typos and comment fixes.

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

54–56

such a region

67

Nit: will have -> has

72

Nit: result variables -> results

198

Better if this is rephrased to:

"Also, if "loop.if" defines one or more values, the 'else' block cannot be omitted."

258–259

such a region

360

Consider rephrasing to:
"If ..., the operands must match the parent op's results."

mlir/include/mlir/IR/OpImplementation.h

645

Terminate comments with a period.

645

(%x1 = %y1 : type1, %x2 = %y2 : type2, ...)

to be clearer here.

mlir/lib/Dialect/LoopOps/LoopOps.cpp

84

Nit: defines
comma after values. "that number" -> "that the number"
of of defined -> of the defined

154

Terminate comments with periods please.

[nicolasvasilache]

Thanks @nmostafa for pushing on this important feature, it will make everyone's life better.
Looking forward to seeing this lower to LLVM all the way to execution!

[nmostafa]

Fix comments and documentation per review feedback.

[rriddle]

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

368–371

Why are you not specifying a printer? Also, can you just use the declarative form? That would remove the need for defining the parser/printer in c++.

https://mlir.llvm.org/docs/OpDefinitions#declarative-assembly-format

Should be something like:

let assemblyFormat = "operands attr-dict `:` type(operands)";

369

Can you just provide the body of the builder here instead of the .cpp?

mlir/lib/Dialect/LoopOps/LoopOps.cpp

88

Can you switch this to early exit instead?

160

This needs to be checked for failure, missing tests?

[nmostafa]

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

368–371

The original TerminatorOp didn't have a custom printer, so I just stuck with that.

If you feel strongly about it, I can change it. However, using assemblyFormat will yield an awkward printing when there are no operands: loop.yield : and parsing will fail if the colon is missing. Is there a way to specify optional tokens in the declarative form ?

mlir/lib/Dialect/LoopOps/LoopOps.cpp

160

What needs to be checked ? iter_args in the syntax ?

[rriddle]

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

368–371

Oops forgot about the variadic operands bit, sorry about that. You will need to use c++ for that for now.

The original TerminatorOp didn't have a custom printer, so I just stuck with that.

That's because it was never printed. Now it can be, so it actually needs a printer. If you are defining a parser, you need a printer.

[bondhugula]

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

368–371

The original TerminatorOp didn't have a custom printer, so I just stuc

Sounds good to me. The custom printer can be done in a separate patch. You can add a TODO - it would be good to have a custom print for this now that it's elided less (having quotes around it would look weird!).

mlir/test/Dialect/Loops/ops.mlir

112

extra space added here

[rriddle]

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

368–371

The custom printer should be added in the same patch as the parser, whether it be this one or the next. I'm not comfortable with this going in with only one defined.

[bondhugula]

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

368–371

Okay. In that case, the commit message should be updated to reflect that (addition of custom parser/printer for yield).

[herhut]

Thanks! This looks great. I had written some comments but forgot to hit the submit button it seems :(

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

126

Should we add a builder with support for iter_args as well?

152

Should this just be a static constexpr unsigned kNumCtrlOperands?

258–259

Mention that the yield may not have operands.

354–355

I wonder whether we should keep the TerminatorOp for the loop.parallel. It is always implicit there anyway and has different semantics (the return values of loop.parallel are defined by loop.reduce operation. Having the extra op is not costing much and avoid the extra checks in verifiers.

mlir/lib/Dialect/LoopOps/LoopOps.cpp

515

Could you also verify that in the case of a Parallel operation the yield does not have any operands?

[nmostafa]

• Added custom printer for YieldOp
• Added tests to verify loop.parallel yield has no operands. Negative test for that as well.
• Updated td description for loop.parallel: yield without opreands
• Updates to commit message

[nmostafa]

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

126

To build an empty loop with no updates to the init args ? Otherwise, the loop will be invalid if the YieldOp has no operands.
Seems a bit awkward to me as opposed to generating an empty loop with no variables and have the user add variables to the ForOp, Region and YieldOp.

368–371

Actually, the TerminatorOp was printed before with the default printer.
ops.mlir: // CHECK: "loop.terminator"() : () -> ()

The only difference is that yield now can be explicit in the source and that's why a custom parser makes sense.
Let me add a custom printer and change the tests.

[nmostafa]

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

354–355

There are mixed opinions on this .. see https://llvm.discourse.group/t/rfc-adding-operands-and-results-to-loop-for/459/14
IMO, unifying under one terminator makes more sense, and yield semantics is really: Terminate and Yield values.

[stephenneuendorffer]

This looks like a really great start! Thanks for sketching this out.

mlir/lib/Dialect/LoopOps/LoopOps.cpp

159–169

@ftynse also suggested leaving off the return type for the for loop. Anyone else have an opinion on this? I'd really prefer for() and if() to be consistent in the respect, so I think in this incarnation, either the syntax for for() or if() needs to change.

[bondhugula]

I think the whole representation and syntax of loop.reduce / modeling reductions inside loop.for could be improved. Was this already discussed somewhere? If not, can we initiate one?

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

263

Is this missing a return value assignment for its result for clarity?

[bondhugula]

I think we could add a reduction_vars / reduction_args list just like iter_args on loop.for and completely get rid of loop.reduce / loop.reduce.return and just use yield from within for's region to send out both reduction vars and general cross loop/loop live out vars.

[schweitz]

How difficult is it to support both the old-style "does not return a value" and the new terminator that does return a value?

mlir/lib/Dialect/LoopOps/LoopOps.cpp

289

The comment here doesn't seem necessary.

297

Likewise here.

[nmostafa]

In D74174#1870307, @schweitz wrote:

How difficult is it to support both the old-style "does not return a value" and the new terminator that does return a value?

Not difficult, but since the new YieldOp terminator optionally return a value, it can serve both purposes.

mlir/lib/Dialect/LoopOps/LoopOps.cpp

159–169

We still need the return type for the IfOp, not sure how omitting it for ForOp would help consistency. Maybe I am not sure I follow the IfOp format you are suggesting:

if %c args(%x=%y: i32) {...} else {...}

Unlike ForOp, there is no binding needed upon entering the IfOp regions. Can you re-write the example below using the format you are suggesting ?

%d = if %c -> (f32) {  
   %r1 = ... : f32
    yield %r1 : f32
} else {  
   %r2 = ... : f32
    yield %r2 : f32
}

[ftynse]

I am mostly nitpicking. Let's finish the design discussion on discourse and land this!

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

81

Random observation: we mention the same type twice in iter_args and in the trailing arrow-type, which are also located close. Did you consider omitting the trailing type?

152

Nit: can we also spell out Control? It only needs 3 more characters.

355

Let's replace cf with loop here. cf dates back to a temporary state when the dialect used the prefix cf for "control flow".

360

"the operands must match..." should yield enforce this or should the parent operations enforce this?

362

Nit: it is _always_ present, we just omit it while pretty printing. Could you please rephrase this text to reflect that fact? Otherwise, it creates an incentive to check for the presence when working with loop.if/for in the code.

mlir/lib/Dialect/LoopOps/LoopOps.cpp

92

Nit: "op lop-carried" sounds weird

102

Mega-nit: I find it helpful to print the index of the mismatching type

130

Doesn't the presence of iter operands imply there should be results?

159–169

I don't have a strong opinion and I am receptive to the argument of consistency, i.e. for and if should have as close syntax as possible.

[nmostafa]

mlir/lib/Dialect/LoopOps/LoopOps.cpp

159–169

I will omit the types inside iter_args in ForOp. To become:
for()....iter_args(%x=%y) -> (i32) {...}

[nmostafa]

• Remove types from iter_args assignment list.
• Fix other nits per review.

[rriddle]

mlir/lib/Dialect/LoopOps/LoopOps.cpp

123

nit:

llvm::interleaveComma(llvm::zip(...), p, [&](auto it) {
  p << ...
}); 
p << ")";

127

Why assert here? This seems like something that would already be verified.

521

nit: Add {} for each if/else clause if any of them have one.

[nmostafa]

Rebased.
Use mlir::interleaveComma and remove assertion.

[nmostafa]

Add missing {} around else

[nmostafa]

If there are no further comments, going to commit this today.

[nmostafa]

Fix LIT tests after merge from master.

[rriddle]

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

152

This doesn't build with GCC 5, remove the constexpr.

[rriddle]

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

152

See: https://buildkite.com/mlir/mlir-core/builds/2902#6c915245-aa53-4a8f-87af-0258275b27af

Could you please take a look?

[nmostafa]

Fixed here: https://reviews.llvm.org/D74978

mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp

for (unsigned i = 0, e = memRefShape.size(); i != e; ++i) {
 
       // Terminate the loop body.
       rewriter.setInsertionPointToStart(loop.getBody());
 
       // Insert a newline after each of the inner dimensions of the shape.
       if (i != e - 1)
         rewriter.create<CallOp>(loc, printfRef, rewriter.getIntegerType(32),
                                 newLineCst);
-      rewriter.create<loop::TerminatorOp>(loc);
+      rewriter.create<loop::YieldOp>(loc);
       rewriter.setInsertionPointToStart(loop.getBody());
     }
 
     // Generate a call to printf for the current element of the loop.
     auto printOp = cast<toy::PrintOp>(op);
     auto elementLoad = rewriter.create<LoadOp>(loc, printOp.input(), loopIvs);
     rewriter.create<CallOp>(loc, printfRef, rewriter.getIntegerType(32),
                             ArrayRef<Value>({formatSpecifierCst, elementLoad}));

mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp

for (unsigned i = 0, e = memRefShape.size(); i != e; ++i) {
 
       // Terminate the loop body.
       rewriter.setInsertionPointToStart(loop.getBody());
 
       // Insert a newline after each of the inner dimensions of the shape.
       if (i != e - 1)
         rewriter.create<CallOp>(loc, printfRef, rewriter.getIntegerType(32),
                                 newLineCst);
-      rewriter.create<loop::TerminatorOp>(loc);
+      rewriter.create<loop::YieldOp>(loc);
       rewriter.setInsertionPointToStart(loop.getBody());
     }
 
     // Generate a call to printf for the current element of the loop.
     auto printOp = cast<toy::PrintOp>(op);
     auto elementLoad = rewriter.create<LoadOp>(loc, printOp.input(), loopIvs);
     rewriter.create<CallOp>(loc, printfRef, rewriter.getIntegerType(32),
                             ArrayRef<Value>({formatSpecifierCst, elementLoad}));

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

class Loop_Op<string mnemonic, list<OpTrait> traits = []> :
   // functions.
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 def ForOp : Loop_Op<"for",
       [DeclareOpInterfaceMethods<LoopLikeOpInterface>,
-       SingleBlockImplicitTerminator<"TerminatorOp">]> {
+       SingleBlockImplicitTerminator<"YieldOp">]> {
   let summary = "for operation";
   let description = [{
-    The "loop.for" operation represents a loop nest taking 3 SSA value as
+    The "loop.for" operation represents a loop taking 3 SSA value as
     operands that represent the lower bound, upper bound and step respectively.
     The operation defines an SSA value for its induction variable. It has one
     region capturing the loop body. The induction variable is represented as an
     argument of this region. This SSA value always has type index, which is the
     size of the machine word. The step is a value of type index, required to be
     positive.
-    The lower and upper bounds specify a half-open range: the range includes the
-    lower bound but does not include the upper bound.
+    The lower and upper bounds specify a half-open range: the range includes
+    the lower bound but does not include the upper bound.
 
     The body region must contain exactly one block that terminates with
-    "loop.terminator".  Calling ForOp::build will create such region and insert
-    the terminator, so will the parsing even in cases when it is absent from the
-    custom format. For example:
+    "loop.yield".  Calling ForOp::build will create such a region and insert
+    the terminator implicitly if none is defined, so will the parsing even 
+    in cases when it is absent from the custom format. For example:
 
     ```mlir
        loop.for %iv = %lb to %ub step %step {
          ... // body
        }
     ```
+
+    "loop.for" can also operate on loop-carried variables and returns the final values
+    after loop termination. The initial values of the variables are passed as additional SSA 
+    operands to the "loop.for" following the 3 loop control SSA values mentioned above
+    (lower bound, upper bound and step). The operation region has equivalent arguments 
+    for each variable representing the value of the variable at the current iteration.
+    
+    The region must terminate with a "loop.yield" that passes all the current iteration 
+    variables to the next iteration, or to the "loop.for" result, if at the last iteration.
+    "loop.for" results hold the final values after the last iteration. 
+    
+    For example, to sum-reduce a memref:
+    
+    ```mlir
+    func @reduce(%buffer: memref<1024xf32>, %lb: index, %ub: index, %step: index) -> (f32) {
+      // Initial sum set to 0.
+      %sum_0 = constant 0.0 : f32
+      // iter_args binds initial values to the loop's region arguments.
+      %sum = loop.for %iv = %lb to %ub step %step iter_args(%sum_iter = %sum_0) -> (f32) {
+        %t = load %buffer[%iv] : memref<1024xf32>
+        %sum_next = addf %sum_iter, %t : f32
+        // Yield current iteration sum to next iteration %sum_iter or to %sum if final iteration.
+        loop.yield %sum_next : f32
+      }
+      return %sum : f32
+    }   
+    ```
+
+    If the "loop.for" defines any values, a yield must be explicitly present. 
+    The number and types of the "loop.for" results must match the initial values 
+    in the "iter_args" binding and the yield operands.
+    
+    Another example with a nested "loop.if" (see "loop.if" for details) 
+    to perform conditional reduction:
+
+    ```mlir
+    func @conditional_reduce(%buffer: memref<1024xf32>, %lb: index, %ub: index, %step: index) -> (f32) {
+      %sum_0 = constant 0.0 : f32
+      %c0 = constant 0.0 : f32
+      %sum = loop.for %iv = %lb to %ub step %step iter_args(%sum_iter = %sum_0) -> (f32) {
+        %t = load %buffer[%iv] : memref<1024xf32>
+        %cond = cmpf "ugt", %t, %c0 : f32
+        %sum_next = loop.if %cond -> (f32) {
+          %new_sum = addf %sum_iter, %t : f32
+          loop.yield %new_sum : f32
+        } else {
+          loop.yield %sum_iter : f32
+        }
+        loop.yield %sum_next : f32
+      }
+      return %sum : f32
+    }
+  ```
   }];
-  let arguments = (ins Index:$lowerBound, Index:$upperBound, Index:$step);
+  let arguments = (ins Index:$lowerBound,
+                       Index:$upperBound,
+                       Index:$step,
+                       Variadic<AnyType>:$initArgs);
+  let results = (outs Variadic<AnyType>:$results);                       
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<"Builder *builder, OperationState &result, "
               "Value lowerBound, Value upperBound, Value step">
   ];
 
   let extraClassDeclaration = [{
     Block *getBody() { return &region().front(); }
     Value getInductionVar() { return getBody()->getArgument(0); }
     OpBuilder getBodyBuilder() {
       return OpBuilder(getBody(), std::prev(getBody()->end()));
     }
+    iterator_range<Block::args_iterator> getRegionIterArgs() {
+      return getBody()->getArguments().drop_front();
+    }
+    iterator_range<Operation::operand_iterator> getIterOperands() {
+      return getOperands().drop_front(getNumControlOperands());
+    }
+
     void setLowerBound(Value bound) { getOperation()->setOperand(0, bound); }
     void setUpperBound(Value bound) { getOperation()->setOperand(1, bound); }
     void setStep(Value step) { getOperation()->setOperand(2, step); }
+    
+    /// Number of region arguments for loop-carried values
+    unsigned getNumRegionIterArgs() {
+      return getBody()->getNumArguments() - 1; 
+    }
+    /// Number of operands controlling the loop: lb, ub, step
+    constexpr unsigned getNumControlOperands() { return 3; }
+    /// Does the operation hold operands for loop-carried values
+    bool hasIterOperands() { 
+      return getOperation()->getNumOperands() > getNumControlOperands();
+    }
+    /// Get Number of loop-carried values
+    unsigned getNumIterOperands() {
+      return getOperation()->getNumOperands() - getNumControlOperands();
+    }
   }];
 }
 
 def IfOp : Loop_Op<"if",
-      [SingleBlockImplicitTerminator<"TerminatorOp">]> {
+      [SingleBlockImplicitTerminator<"YieldOp">]> {
   let summary = "if-then-else operation";
   let description = [{
     The "loop.if" operation represents an if-then-else construct for
     conditionally executing two regions of code. The operand to an if operation
-    is a boolean value. The operation produces no results. For example:
+    is a boolean value. For example:
 
     ```mlir
        loop.if %b  {
          ...
        } else {
          ...
        }
     ```
 
-    The 'else' block is optional, and may be omitted. For
-    example:
+    "loop.if" may also return results that are defined in its regions. The values
+    defined are determined by which execution path is taken. 
+    For example:
+    ```mlir
+       %x, %y = loop.if %b -> (f32, f32) {
+         %x_true = ...
+         %y_true = ...
+         loop.yield %x_true, %y_true : f32, f32
+       } else {
+         %x_false = ... 
+         %y_false = ... 
+         loop.yield %x_false, %y_false : f32, f32
+       }
+    ```
+
+    "loop.if" regions are always terminated with "loop.yield". If "loop.if"
+    defines no values, the "loop.yield" can be left out, and will be
+    inserted implicitly. Otherwise, it must be explicit.
+    Also, if "loop.if" defines one or more values, the 'else' block cannot
+    be omitted. 
 
+    For example:
     ```mlir
        loop.if %b  {
          ...
        }
     ```
   }];
   let arguments = (ins I1:$condition);
+  let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$thenRegion, AnyRegion:$elseRegion);
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<"Builder *builder, OperationState &result, "
               "Value cond, bool withElseRegion">
   ];
 
   let extraClassDeclaration = [{
     OpBuilder getThenBodyBuilder() {
       assert(!thenRegion().empty() && "Unexpected empty 'then' region.");
       Block &body = thenRegion().front();
       return OpBuilder(&body, std::prev(body.end()));
     }
     OpBuilder getElseBodyBuilder() {
       assert(!elseRegion().empty() && "Unexpected empty 'else' region.");
       Block &body = elseRegion().front();
       return OpBuilder(&body, std::prev(body.end()));
     }
   }];
 }
 
 def ParallelOp : Loop_Op<"parallel",
-    [SameVariadicOperandSize, SingleBlockImplicitTerminator<"TerminatorOp">]> {
+    [SameVariadicOperandSize, SingleBlockImplicitTerminator<"YieldOp">]> {
   let summary = "parallel for operation";
   let description = [{
     The "loop.parallel" operation represents a loop nest taking 3 groups of SSA
     values as operands that represent the lower bounds, upper bounds and steps,
     respectively. The operation defines a variadic number of SSA values for its
     induction variables. It has one region capturing the loop body. The
     induction variables are represented as an argument of this region. These SSA
     values always have type index, which is the size of the machine word. The
     steps are values of type index, required to be positive.
     The lower and upper bounds specify a half-open range: the range includes the
     lower bound but does not include the upper bound.
 
     Semantically we require that the iteration space can be iterated in any
     order, and the loop body can be executed in parallel. If there are data
     races, the behavior is undefined.
 
     The parallel loop operation supports reduction of values produced by
     individual iterations into a single result. This is modeled using the
     loop.reduce operation (see loop.reduce for details). Each result of a
     loop.parallel operation is associated with a reduce operation that is an
     immediate child. Reduces are matched to result values in order of their
     appearance in the body. Consequently, we require that the body region has
     the same number of results as it has reduce operations.
 
     The body region must contain exactly one block that terminates with
-    "loop.terminator". Parsing ParallelOp will create such region and insert the
-    terminator when it is absent from the custom format. For example:
+    "loop.yield" without operands. Parsing ParallelOp will create such a region
+    and insert the terminator when it is absent from the custom format. For example:
 
     ```mlir
        loop.parallel (%iv) = (%lb) to (%ub) step (%step) {
          %zero = constant 0.0 : f32
          loop.reduce(%zero) {
            ^bb0(%lhs : f32, %rhs: f32):
              %res = addf %lhs, %rhs : f32
              loop.reduce.return %res : f32
          } : f32
        }
     ```
```mlir
       loop.reduce.return %res : f32
     ```
   }];
 
   let arguments = (ins AnyType:$result);
   let assemblyFormat = "$result attr-dict `:` type($result)";
 }
 
-def TerminatorOp : Loop_Op<"terminator", [Terminator]> {
-  let summary = "cf terminator operation";
+def YieldOp : Loop_Op<"yield", [Terminator]> {
+  let summary = "loop yield and termination operation";
   let description = [{
-    "loop.terminator" is a special terminator operation for blocks inside
-    loops. It terminates the region. This operation does _not_ have a custom
-    syntax. However, `std` control operations omit the terminator in their
-    custom syntax for brevity.
-
-    ```mlir
-       loop.terminator
-    ```
+    "loop.yield" yields an SSA value from a loop dialect op region and
+    terminates the regions. The semantics of how the values are yielded
+    is defined by the parent operation. 
+    If "loop.yield" has any operands, the operands must match the parent
+    operation's results. 
+    If the parent operation defines no values, then the "loop.yield" may be 
+    left out in the custom syntax and the builders will insert one implicitly.
+    Otherwise, it has to be present in the syntax to indicate which values
+    are yielded. 
   }];
 
-  // No custom parsing/printing form.
-  let parser = ?;
-  let printer = ?;
-
-  // Fully specified by traits.
-  let verifier = ?;
+  let arguments = (ins Variadic<AnyType>:$results);
+  let builders = [
+    OpBuilder<"Builder *builder, OperationState &result", [{ /* nothing to do */ }]>
+  ];
 }
-
 #endif // LOOP_OPS

mlir/include/mlir/IR/OpImplementation.h

do {
       Type type;
       if (parseType(type))
         return failure();
       result.push_back(type);
     } while (succeeded(parseOptionalComma()));
     return success();
   }
 
+  /// Parse an arrow followed by a type list.
+  virtual ParseResult parseArrowTypeList(SmallVectorImpl<Type> &result) = 0;
+
   /// Parse an optional arrow followed by a type list.
   virtual ParseResult
   parseOptionalArrowTypeList(SmallVectorImpl<Type> &result) = 0;
 
   /// Parse a colon followed by a type.
   virtual ParseResult parseColonType(Type &result) = 0;
 
   /// Parse a colon followed by a type of a specific kind, e.g. a FunctionType.
public:
   /// Parse a colon followed by a type list, which must have at least one type.
   virtual ParseResult parseColonTypeList(SmallVectorImpl<Type> &result) = 0;
 
   /// Parse an optional colon followed by a type list, which if present must
   /// have at least one type.
   virtual ParseResult
   parseOptionalColonTypeList(SmallVectorImpl<Type> &result) = 0;
 
+  /// Parse a list of assignments of the form
+  /// (%x1 = %y1 : type1, %x2 = %y2 : type2, ...).
+  /// The list must contain at least one entry
+  virtual ParseResult
+  parseAssignmentList(SmallVectorImpl<OperandType> &lhs,
+                      SmallVectorImpl<OperandType> &rhs) = 0;
+
   /// Parse a keyword followed by a type.
   ParseResult parseKeywordType(const char *keyword, Type &result) {
     return failure(parseKeyword(keyword) || parseType(result));
   }
 
   /// Add the specified type to the end of the specified type list and return
   /// success.  This is a helper designed to allow parse methods to be simple
   /// and chain through || operators.

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

 
 /// Affine terminators are removed.
 class AffineTerminatorLowering : public OpRewritePattern<AffineTerminatorOp> {
 public:
   using OpRewritePattern<AffineTerminatorOp>::OpRewritePattern;
 
   PatternMatchResult matchAndRewrite(AffineTerminatorOp op,
                                      PatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<loop::TerminatorOp>(op);
+    rewriter.replaceOpWithNewOp<loop::YieldOp>(op);
     return matchSuccess();
   }
 };
 
 class AffineForLowering : public OpRewritePattern<AffineForOp> {
 public:
   using OpRewritePattern<AffineForOp>::OpRewritePattern;
 

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.cpp

 public:
   using SPIRVOpLowering<loop::IfOp>::SPIRVOpLowering;
 
   PatternMatchResult
   matchAndRewrite(loop::IfOp IfOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
-/// Pattern to erase a loop::TerminatorOp.
-class TerminatorOpConversion final
-    : public SPIRVOpLowering<loop::TerminatorOp> {
+/// Pattern to erase a loop::YieldOp.
+class TerminatorOpConversion final : public SPIRVOpLowering<loop::YieldOp> {
 public:
-  using SPIRVOpLowering<loop::TerminatorOp>::SPIRVOpLowering;
+  using SPIRVOpLowering<loop::YieldOp>::SPIRVOpLowering;
 
   PatternMatchResult
-  matchAndRewrite(loop::TerminatorOp terminatorOp, ArrayRef<Value> operands,
+  matchAndRewrite(loop::YieldOp terminatorOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.eraseOp(terminatorOp);
     return matchSuccess();
   }
 };
 
 /// Pattern lowering GPU block/thread size/id to loading SPIR-V invocation
 /// builin variables.

mlir/lib/Dialect/LoopOps/LoopOps.cpp

 static LogicalResult verify(ForOp op) {
   if (auto cst = dyn_cast_or_null<ConstantIndexOp>(op.step().getDefiningOp()))
     if (cst.getValue() <= 0)
       return op.emitOpError("constant step operand must be positive");
 
   // Check that the body defines as single block argument for the induction
   // variable.
   auto *body = op.getBody();
-  if (body->getNumArguments() != 1 || !body->getArgument(0).getType().isIndex())
-    return op.emitOpError("expected body to have a single index argument for "
-                          "the induction variable");
+  if (!body->getArgument(0).getType().isIndex())
+    return op.emitOpError(
+        "expected body first argument to be an index argument for "
+
+  auto opNumResults = op.getNumResults();
+  if (opNumResults == 0)
+    return success();
+  // If ForOp defines values, check that the number and types of
+  // the defined values match ForOp initial iter operands and backedge
+  // basic block arguments.
+  if (op.getNumIterOperands() != opNumResults)
+    return op.emitOpError(
+        "mismatch in number of loop-carried values and defined values");
+  if (op.getNumRegionIterArgs() != opNumResults)
+    return op.emitOpError(
+        "mismatch in number of basic block args and defined values");
+  auto iterOperands = op.getIterOperands();
+  auto iterArgs = op.getRegionIterArgs();
+  auto opResults = op.getResults();
+  unsigned i = 0;
+  for (auto e : llvm::zip(iterOperands, iterArgs, opResults)) {
+    if (std::get<0>(e).getType() != std::get<2>(e).getType())
+      return op.emitOpError() << "types mismatch between " << i
+                              << "th iter operand and defined value";
+    if (std::get<1>(e).getType() != std::get<2>(e).getType())
+      return op.emitOpError() << "types mismatch between " << i
+                              << "th iter region arg and defined value";
+
+    i++;
+  }
   return success();
 }
 
 static void print(OpAsmPrinter &p, ForOp op) {
+  bool printBlockTerminators = false;
   p << op.getOperationName() << " " << op.getInductionVar() << " = "
     << op.lowerBound() << " to " << op.upperBound() << " step " << op.step();
+
+  if (op.hasIterOperands()) {
+    unsigned numIterOperands = op.getNumIterOperands(), i = 0;
+    p << " iter_args(";
+    auto regionArgs = op.getRegionIterArgs();
+    auto operands = op.getIterOperands();
+    for (auto e : llvm::zip(regionArgs, operands)) {
+      p << std::get<0>(e) << " = " << std::get<1>(e);
+      p << ((++i == numIterOperands) ? ")" : ", ");
+    }
+    assert(!op.results().empty());
+    p << " -> (" << op.getResultTypes() << ")";
+    printBlockTerminators = true;
+  }
   p.printRegion(op.region(),
                 /*printEntryBlockArgs=*/false,
-                /*printBlockTerminators=*/false);
+                /*printBlockTerminators=*/printBlockTerminators);
   p.printOptionalAttrDict(op.getAttrs());
 }
 
 static ParseResult parseForOp(OpAsmParser &parser, OperationState &result) {
   auto &builder = parser.getBuilder();
   OpAsmParser::OperandType inductionVariable, lb, ub, step;
   // Parse the induction variable followed by '='.
   if (parser.parseRegionArgument(inductionVariable) || parser.parseEqual())
     return failure();
 
   // Parse loop bounds.
   Type indexType = builder.getIndexType();
   if (parser.parseOperand(lb) ||
       parser.resolveOperand(lb, indexType, result.operands) ||
       parser.parseKeyword("to") || parser.parseOperand(ub) ||
       parser.resolveOperand(ub, indexType, result.operands) ||
       parser.parseKeyword("step") || parser.parseOperand(step) ||
       parser.resolveOperand(step, indexType, result.operands))
     return failure();
 
+  // Parse the optional initial iteration arguments.
+  SmallVector<OpAsmParser::OperandType, 4> regionArgs, operands;
+  SmallVector<Type, 4> argTypes;
+  regionArgs.push_back(inductionVariable);
+
+  if (succeeded(parser.parseOptionalKeyword("iter_args"))) {
+    // Parse assignment list and results type list.
+    if (parser.parseAssignmentList(regionArgs, operands) ||
+        parser.parseArrowTypeList(result.types))
+      return failure();
+    // Resolve input operands.
+    for (auto operand_type : llvm::zip(operands, result.types))
+      if (parser.resolveOperand(std::get<0>(operand_type),
+                                std::get<1>(operand_type), result.operands))
+        return failure();
+  }
+  // Induction variable.
+  argTypes.push_back(indexType);
+  // Loop carried variables
+  argTypes.append(result.types.begin(), result.types.end());
   // Parse the body region.
   Region *body = result.addRegion();
-  if (parser.parseRegion(*body, inductionVariable, indexType))
+  if (regionArgs.size() != argTypes.size())
+    return parser.emitError(
+        parser.getNameLoc(),
+        "mismatch in number of loop-carried values and defined values");
+
+  if (parser.parseRegion(*body, regionArgs, argTypes))
     return failure();
 
   ForOp::ensureTerminator(*body, builder, result.location);
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
for (auto &region : op.getOperation()->getRegions()) {
     if (region.empty())
       continue;
 
     for (auto &b : region)
       if (b.getNumArguments() != 0)
         return op.emitOpError(
             "requires that child entry blocks have no arguments");
   }
+  if (op.getNumResults() != 0 && op.elseRegion().empty())
+    return op.emitOpError("must have an else block if defining values");
+
   return success();
 }
 
 static ParseResult parseIfOp(OpAsmParser &parser, OperationState &result) {
   // Create the regions for 'then'.
   result.regions.reserve(2);
   Region *thenRegion = result.addRegion();
   Region *elseRegion = result.addRegion();
 
   auto &builder = parser.getBuilder();
   OpAsmParser::OperandType cond;
   Type i1Type = builder.getIntegerType(1);
   if (parser.parseOperand(cond) ||
       parser.resolveOperand(cond, i1Type, result.operands))
     return failure();
-
+  // Parse optional results type list.
+  if (parser.parseOptionalArrowTypeList(result.types))
+    return failure();
   // Parse the 'then' region.
   if (parser.parseRegion(*thenRegion, /*arguments=*/{}, /*argTypes=*/{}))
     return failure();
   IfOp::ensureTerminator(*thenRegion, parser.getBuilder(), result.location);
 
   // If we find an 'else' keyword then parse the 'else' region.
   if (!parser.parseOptionalKeyword("else")) {
     if (parser.parseRegion(*elseRegion, /*arguments=*/{}, /*argTypes=*/{}))
       return failure();
     IfOp::ensureTerminator(*elseRegion, parser.getBuilder(), result.location);
   }
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
-
   return success();
 }
 
 static void print(OpAsmPrinter &p, IfOp op) {
+  bool printBlockTerminators = false;
+
   p << IfOp::getOperationName() << " " << op.condition();
+  if (!op.results().empty()) {
+    p << " -> (" << op.getResultTypes() << ")";
+    // Print yield explicitly if the op defines values.
+    printBlockTerminators = true;
+  }
   p.printRegion(op.thenRegion(),
                 /*printEntryBlockArgs=*/false,
-                /*printBlockTerminators=*/false);
+                /*printBlockTerminators=*/printBlockTerminators);
 
   // Print the 'else' regions if it exists and has a block.
   auto &elseRegion = op.elseRegion();
   if (!elseRegion.empty()) {
     p << " else";
     p.printRegion(elseRegion,
                   /*printEntryBlockArgs=*/false,
-                  /*printBlockTerminators=*/false);
+                  /*printBlockTerminators=*/printBlockTerminators);
   }
 
   p.printOptionalAttrDict(op.getAttrs());
 }
 
 //===----------------------------------------------------------------------===//
 // ParallelOp
 //===----------------------------------------------------------------------===//
static LogicalResult verify(ReduceReturnOp op) {
   Type reduceType = reduceOp.operand().getType();
   if (reduceType != op.result().getType())
     return op.emitOpError() << "needs to have type " << reduceType
                             << " (the type of the enclosing ReduceOp)";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
+// YieldOp
+//===----------------------------------------------------------------------===//
+static LogicalResult verify(YieldOp op) {
+  auto parentOp = op.getParentOp();
+  auto results = parentOp->getResults();
+  auto operands = op.getOperands();
+
+  if (isa<IfOp>(parentOp) || isa<ForOp>(parentOp)) {
+    if (parentOp->getNumResults() != op.getNumOperands())
+      return op.emitOpError() << "parent of yield must have same number of "
+                                 "results as the yield operands";
+    for (auto e : llvm::zip(results, operands)) {
+      if (std::get<0>(e).getType() != std::get<1>(e).getType())
+        return op.emitOpError()
+               << "types mismatch between yield op and its parent";
+    }
+  } else if (isa<ParallelOp>(parentOp)) {
+    if (op.getNumOperands() != 0)
+      return op.emitOpError()
+             << "yield inside loop.parallel is not allowed to have operands";
+  } else
+    return op.emitOpError()
+           << "yield only terminates If, For or Parallel regions";
+
+  return success();
+}
+
+static ParseResult parseYieldOp(OpAsmParser &parser, OperationState &result) {
+  SmallVector<OpAsmParser::OperandType, 4> operands;
+  SmallVector<Type, 4> types;
+  llvm::SMLoc loc = parser.getCurrentLocation();
+  // Parse variadic operands list, their types, and resolve operands to SSA
+  // values.
+  if (parser.parseOperandList(operands) ||
+      parser.parseOptionalColonTypeList(types) ||
+      parser.resolveOperands(operands, types, loc, result.operands))
+    return failure();
+  return success();
+}
+
+static void print(OpAsmPrinter &p, YieldOp op) {
+  p << op.getOperationName();
+  if (op.getNumOperands() != 0)
+    p << ' ' << op.getOperands() << " : " << op.getOperandTypes();
+}
+
+//===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LoopOps/LoopOps.cpp.inc"

mlir/lib/Parser/Parser.cpp

public:
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a type.
   ParseResult parseType(Type &result) override {
     return failure(!(result = parser.parseType()));
   }
 
+  /// Parse an arrow followed by a type list.
+  ParseResult parseArrowTypeList(SmallVectorImpl<Type> &result) override {
+    if (parseArrow() || parser.parseFunctionResultTypes(result))
+      return failure();
+    return success();
+  }
+
   /// Parse an optional arrow followed by a type list.
   ParseResult
   parseOptionalArrowTypeList(SmallVectorImpl<Type> &result) override {
     if (!parser.consumeIf(Token::arrow))
       return success();
     return parser.parseFunctionResultTypes(result);
   }
 
public:
   /// have at least one type.
   ParseResult
   parseOptionalColonTypeList(SmallVectorImpl<Type> &result) override {
     if (!parser.consumeIf(Token::colon))
       return success();
     return parser.parseTypeListNoParens(result);
   }
 
+  /// Parse a list of assignments of the form
+  /// (%x1 = %y1 : type1, %x2 = %y2 : type2, ...).
+  /// The list must contain at least one entry
+  ParseResult parseAssignmentList(SmallVectorImpl<OperandType> &lhs,
+                                  SmallVectorImpl<OperandType> &rhs) {
+    auto parseElt = [&]() -> ParseResult {
+      OperandType regionArg, operand;
+      Type type;
+      if (parseRegionArgument(regionArg) || parseEqual() ||
+          parseOperand(operand))
+        return failure();
+      lhs.push_back(regionArg);
+      rhs.push_back(operand);
+      return success();
+    };
+    if (parseLParen())
+      return failure();
+    return parser.parseCommaSeparatedListUntil(Token::r_paren, parseElt);
+  }
+
 private:
   /// The source location of the operation name.
   SMLoc nameLoc;
 
   /// The abstract information of the operation.
   const AbstractOperation *opDefinition;
 
   /// The main operation parser.

mlir/test/Dialect/Linalg/parallel_loops.mlir

 // CHECK-DAG: %[[C0:.*]] = constant 0
 // CHECK-DAG: %[[C1:.*]] = constant 1
 // CHECK: loop.parallel (%[[I:.*]], %[[J:.*]]) = {{.*}}
 // CHECK:   %[[LHS_ELEM:.*]] = load %[[LHS]][%[[I]], %[[J]]]
 // CHECK:   %[[RHS_ELEM:.*]] = load %[[RHS]][%[[I]], %[[J]]]
 // CHECK:   %[[SUM_ELEM:.*]] = load %[[SUM]][%[[I]], %[[J]]]
 // CHECK:   %[[SUM:.*]] = addf %[[LHS_ELEM]], %[[RHS_ELEM]] : f32
 // CHECK:   store %[[SUM]], %{{.*}}[%[[I]], %[[J]]]
-// CHECK:   "loop.terminator"() : () -> ()
+// CHECK:   loop.yield
 
 // -----
 
 #accesses = [
   affine_map<(m, n) -> (m, n)>,
   affine_map<(m, n) -> (m)>
 ]
 #trait = {

mlir/test/Dialect/Loops/invalid.mlir

 
 // -----
 
 func @loop_for_step_positive(%arg0: index) {
   // expected-error@+2 {{constant step operand must be positive}}
   %c0 = constant 0 : index
   "loop.for"(%arg0, %arg0, %c0) ({
     ^bb0(%arg1: index):
-      "loop.terminator"() : () -> ()
+      loop.yield
   }) : (index, index, index) -> ()
   return
 }
 
 // -----
 
 func @loop_for_one_region(%arg0: index) {
   // expected-error@+1 {{incorrect number of regions: expected 1 but found 2}}
   "loop.for"(%arg0, %arg0, %arg0) (
-    {"loop.terminator"() : () -> ()},
-    {"loop.terminator"() : () -> ()}
+    {loop.yield},
+    {loop.yield}
   ) : (index, index, index) -> ()
   return
 }
 
 // -----
 
 func @loop_for_single_block(%arg0: index) {
   // expected-error@+1 {{expects region #0 to have 0 or 1 blocks}}
   "loop.for"(%arg0, %arg0, %arg0) (
     {
     ^bb1:
-      "loop.terminator"() : () -> ()
+      loop.yield
     ^bb2:
-      "loop.terminator"() : () -> ()
+      loop.yield
     }
   ) : (index, index, index) -> ()
   return
 }
 
 // -----
 
 func @loop_for_single_index_argument(%arg0: index) {
-  // expected-error@+1 {{expected body to have a single index argument for the induction variable}}
+  // expected-error@+1 {{op expected body first argument to be an index argument for the induction variable}}
   "loop.for"(%arg0, %arg0, %arg0) (
     {
     ^bb0(%i0 : f32):
-      "loop.terminator"() : () -> ()
+      loop.yield
     }
   ) : (index, index, index) -> ()
   return
 }
 
 // -----
 
 func @loop_if_not_i1(%arg0: index) {

 }
 
 // -----
 
 func @loop_if_not_one_block_per_region(%arg0: i1) {
   // expected-error@+1 {{expects region #0 to have 0 or 1 blocks}}
   "loop.if"(%arg0) ({
     ^bb0:
-      "loop.terminator"() : () -> ()
+      loop.yield
     ^bb1:
-      "loop.terminator"() : () -> ()
+      loop.yield
   }, {}): (i1) -> ()
   return
 }
 
 // -----
 
 func @loop_if_illegal_block_argument(%arg0: i1) {
   // expected-error@+1 {{requires that child entry blocks have no arguments}}
   "loop.if"(%arg0) ({
     ^bb0(%0 : index):
-      "loop.terminator"() : () -> ()
+      loop.yield
   }, {}): (i1) -> ()
   return
 }
 
 // -----
 
 func @parallel_arguments_different_tuple_size(
     %arg0: index, %arg1: index, %arg2: index) {
   // expected-error@+1 {{custom op 'loop.parallel' expected 1 operands}}
   loop.parallel (%i0) = (%arg0) to (%arg1, %arg2) step () {
   }
   return
 }
 
 // -----
 
 func @parallel_body_arguments_wrong_type(
     %arg0: index, %arg1: index, %arg2: index) {
   // expected-error@+1 {{'loop.parallel' op expects arguments for the induction variable to be of index type}}
   "loop.parallel"(%arg0, %arg1, %arg2) ({
     ^bb0(%i0: f32):
-      "loop.terminator"() : () -> ()
+      loop.yield
   }): (index, index, index) -> ()
   return
 }
 
 // -----
 
 func @parallel_body_wrong_number_of_arguments(
     %arg0: index, %arg1: index, %arg2: index) {
   // expected-error@+1 {{'loop.parallel' op expects the same number of induction variables as bound and step values}}
   "loop.parallel"(%arg0, %arg1, %arg2) ({
     ^bb0(%i0: index, %i1: index):
-      "loop.terminator"() : () -> ()
+      loop.yield
   }): (index, index, index) -> ()
   return
 }
 
 // -----
 
 func @parallel_no_tuple_elements() {
   // expected-error@+1 {{'loop.parallel' op needs at least one tuple element for lowerBound, upperBound and step}}

 
 // -----
 
 func @reduce_wrong_terminator(%arg0 : index, %arg1 : f32) {
   %res = loop.parallel (%i0) = (%arg0) to (%arg0) step (%arg0) {
     // expected-error@+1 {{the block inside reduce should be terminated with a 'loop.reduce.return' op}}
     loop.reduce(%arg1) {
       ^bb0(%lhs : f32, %rhs : f32):
-        "loop.terminator"(): () -> ()
+        loop.yield
     } : f32
   } : f32
   return
 }
 
 // -----
 
 func @reduceReturn_wrong_type(%arg0 : index, %arg1: f32) {

 
 func @reduceReturn_not_inside_reduce(%arg0 : f32) {
   "foo.region"() ({
     // expected-error@+1 {{expects parent op 'loop.reduce'}}
     loop.reduce.return %arg0 : f32
   }): () -> ()
   return
 }
+
+// -----
+
+func @std_if_incorrect_yield(%arg0: i1, %arg1: f32)
+{
+  %x, %y = loop.if %arg0 -> (f32, f32) {
+    %0 = addf %arg1, %arg1 : f32
+    // expected-error@+1 {{parent of yield must have same number of results as the yield operands}}
+    loop.yield %0 : f32
+  } else {
+    %0 = subf %arg1, %arg1 : f32
+    loop.yield %0 : f32
+  }
+  return
+}
+
+// -----
+
+func @std_if_missing_else(%arg0: i1, %arg1: f32)
+{
+  // expected-error@+1 {{must have an else block if defining values}}
+  %x = loop.if %arg0 -> (f32) {
+    %0 = addf %arg1, %arg1 : f32
+    loop.yield %0 : f32
+  }
+  return
+}
+
+// -----
+
+func @std_for_operands_mismatch(%arg0 : index, %arg1 : index, %arg2 : index) {
+  %s0 = constant 0.0 : f32
+  %t0 = constant 1 : i32
+  // expected-error@+1 {{mismatch in number of loop-carried values and defined values}}
+  %result1:3 = loop.for %i0 = %arg0 to %arg1 step %arg2 iter_args(%si = %s0, %ti = %t0) -> (f32, i32, f32) {
+    %sn = addf %si, %si : f32
+    %tn = addi %ti, %ti : i32
+    loop.yield %sn, %tn, %sn : f32, i32, f32
+  }
+  return
+}
+
+// -----
+
+func @std_for_operands_mismatch_2(%arg0 : index, %arg1 : index, %arg2 : index) {
+  %s0 = constant 0.0 : f32
+  %t0 = constant 1 : i32
+  %u0 = constant 1.0 : f32
+  // expected-error@+1 {{mismatch in number of loop-carried values and defined values}}
+  %result1:2 = loop.for %i0 = %arg0 to %arg1 step %arg2 iter_args(%si = %s0, %ti = %t0, %ui = %u0) -> (f32, i32) {
+    %sn = addf %si, %si : f32
+    %tn = addi %ti, %ti : i32
+    %un = subf %ui, %ui : f32
+    loop.yield %sn, %tn, %un : f32, i32, f32
+  }
+  return
+}
+
+// -----
+
+func @std_for_operands_mismatch_3(%arg0 : index, %arg1 : index, %arg2 : index) {
+  // expected-note@+1 {{prior use here}}
+  %s0 = constant 0.0 : f32
+  %t0 = constant 1.0 : f32
+  // expected-error@+1 {{expects different type than prior uses: 'i32' vs 'f32'}}
+  %result1:2 = loop.for %i0 = %arg0 to %arg1 step %arg2 iter_args(%si = %s0, %ti = %t0) -> (i32, i32) {
+    %sn = addf %si, %si : i32
+    %tn = addf %ti, %ti : i32
+    loop.yield %sn, %tn : i32, i32
+  }
+  return
+}
+
+// -----
+
+func @parallel_invalid_yield(
+    %arg0: index, %arg1: index, %arg2: index) {
+  loop.parallel (%i0) = (%arg0) to (%arg1) step (%arg2) {
+    %c0 = constant 1.0 : f32
+    // expected-error@+1 {{yield inside loop.parallel is not allowed to have operands}}
+    loop.yield %c0 : f32
+  }
+  return
+}
 No newline at end of file

mlir/test/Dialect/Loops/ops.mlir

 //  CHECK-NEXT:     %[[MAX:.*]] = select %[[MAX_CMP]], %[[I0]], %[[I1]] : index
 //  CHECK-NEXT:     loop.parallel (%{{.*}}) = (%[[MIN]]) to (%[[MAX]]) step (%[[I1]]) {
 //  CHECK-NEXT:       %[[ZERO:.*]] = constant 0.000000e+00 : f32
 //  CHECK-NEXT:       loop.reduce(%[[ZERO]]) {
 //  CHECK-NEXT:       ^bb0(%[[LHS:.*]]: f32, %[[RHS:.*]]: f32):
 //  CHECK-NEXT:         %[[RES:.*]] = addf %[[LHS]], %[[RHS]] : f32
 //  CHECK-NEXT:         loop.reduce.return %[[RES]] : f32
 //  CHECK-NEXT:       } : f32
-//  CHECK-NEXT:       "loop.terminator"() : () -> ()
+//  CHECK-NEXT:       loop.yield
 //  CHECK-NEXT:     } : f32
-//  CHECK-NEXT:     "loop.terminator"() : () -> ()
+//  CHECK-NEXT:     loop.yield
+
+func @parallel_explicit_yield(
+    %arg0: index, %arg1: index, %arg2: index) {
+  loop.parallel (%i0) = (%arg0) to (%arg1) step (%arg2) {
+    loop.yield
+  }
+  return
+}
+
+// CHECK-LABEL: func @parallel_explicit_yield(
+//  CHECK-SAME: %[[ARG0:[A-Za-z0-9]+]]:
+//  CHECK-SAME: %[[ARG1:[A-Za-z0-9]+]]:
+//  CHECK-SAME: %[[ARG2:[A-Za-z0-9]+]]:
+//  CHECK-NEXT: loop.parallel (%{{.*}}) = (%[[ARG0]]) to (%[[ARG1]]) step (%[[ARG2]])
+//  CHECK-NEXT: loop.yield
+//  CHECK-NEXT: }
+//  CHECK-NEXT: return
+//  CHECK-NEXT: }
+
+func @std_if_yield(%arg0: i1, %arg1: f32)
+{
+  %x, %y = loop.if %arg0 -> (f32, f32) {
+    %0 = addf %arg1, %arg1 : f32
+    %1 = subf %arg1, %arg1 : f32
+    loop.yield %0, %1 : f32, f32
+  } else {
+    %0 = subf %arg1, %arg1 : f32
+    %1 = addf %arg1, %arg1 : f32
+    loop.yield %0, %1 : f32, f32
+  }
+  return
+}
+// CHECK-LABEL: func @std_if_yield(
+//  CHECK-SAME: %[[ARG0:[A-Za-z0-9]+]]:
+//  CHECK-SAME: %[[ARG1:[A-Za-z0-9]+]]:
+//  CHECK-NEXT: %{{.*}}:2 = loop.if %[[ARG0]] -> (f32, f32) {
+//  CHECK-NEXT: %[[T1:.*]] = addf %[[ARG1]], %[[ARG1]]
+//  CHECK-NEXT: %[[T2:.*]] = subf %[[ARG1]], %[[ARG1]]
+//  CHECK-NEXT: loop.yield %[[T1]], %[[T2]] : f32, f32
+//  CHECK-NEXT: } else {
+//  CHECK-NEXT: %[[T3:.*]] = subf %[[ARG1]], %[[ARG1]]
+//  CHECK-NEXT: %[[T4:.*]] = addf %[[ARG1]], %[[ARG1]]
+//  CHECK-NEXT: loop.yield %[[T3]], %[[T4]] : f32, f32
+//  CHECK-NEXT: }
+
+func @std_for_yield(%arg0 : index, %arg1 : index, %arg2 : index) {
+  %s0 = constant 0.0 : f32
+  %result = loop.for %i0 = %arg0 to %arg1 step %arg2 iter_args(%si = %s0) -> (f32) {
+    %sn = addf %si, %si : f32
+    loop.yield %sn : f32
+  }
+  return
+}
+// CHECK-LABEL: func @std_for_yield(
+// CHECK-SAME: %[[ARG0:[A-Za-z0-9]+]]:
+// CHECK-SAME: %[[ARG1:[A-Za-z0-9]+]]:
+// CHECK-SAME: %[[ARG2:[A-Za-z0-9]+]]:
+// CHECK-NEXT: %[[INIT:.*]] = constant
+// CHECK-NEXT: %{{.*}} = loop.for %{{.*}} = %[[ARG0]] to %[[ARG1]] step %[[ARG2]]
+// CHECK-SAME: iter_args(%[[ITER:.*]] = %[[INIT]]) -> (f32) {
+// CHECK-NEXT: %[[NEXT:.*]] = addf %[[ITER]], %[[ITER]] : f32
+// CHECK-NEXT: loop.yield %[[NEXT]] : f32
+// CHECK-NEXT: }
+
+
+func @std_for_yield_multi(%arg0 : index, %arg1 : index, %arg2 : index) {
+  %s0 = constant 0.0 : f32
+  %t0 = constant 1 : i32
+  %u0 = constant 1.0 : f32
+  %result1:3 = loop.for %i0 = %arg0 to %arg1 step %arg2 iter_args(%si = %s0, %ti = %t0, %ui = %u0) -> (f32, i32, f32) {
+    %sn = addf %si, %si : f32
+    %tn = addi %ti, %ti : i32
+    %un = subf %ui, %ui : f32
+    loop.yield %sn, %tn, %un : f32, i32, f32
+  }
+  return
+}
+// CHECK-LABEL: func @std_for_yield_multi(
+// CHECK-SAME: %[[ARG0:[A-Za-z0-9]+]]:
+// CHECK-SAME: %[[ARG1:[A-Za-z0-9]+]]:
+// CHECK-SAME: %[[ARG2:[A-Za-z0-9]+]]:
+// CHECK-NEXT: %[[INIT1:.*]] = constant
+// CHECK-NEXT: %[[INIT2:.*]] = constant
+// CHECK-NEXT: %[[INIT3:.*]] = constant
+// CHECK-NEXT: %{{.*}}:3 = loop.for %{{.*}} = %[[ARG0]] to %[[ARG1]] step %[[ARG2]]
+// CHECK-SAME: iter_args(%[[ITER1:.*]] = %[[INIT1]], %[[ITER2:.*]] = %[[INIT2]], %[[ITER3:.*]] = %[[INIT3]]) -> (f32, i32, f32) {
+// CHECK-NEXT: %[[NEXT1:.*]] = addf %[[ITER1]], %[[ITER1]] : f32
+// CHECK-NEXT: %[[NEXT2:.*]] = addi %[[ITER2]], %[[ITER2]] : i32
+// CHECK-NEXT: %[[NEXT3:.*]] = subf %[[ITER3]], %[[ITER3]] : f32
+// CHECK-NEXT: loop.yield %[[NEXT1]], %[[NEXT2]], %[[NEXT3]] : f32, i32, f32
+
+
+func @conditional_reduce(%buffer: memref<1024xf32>, %lb: index, %ub: index, %step: index) -> (f32) {
+  %sum_0 = constant 0.0 : f32
+  %c0 = constant 0.0 : f32
+  %sum = loop.for %iv = %lb to %ub step %step iter_args(%sum_iter = %sum_0) -> (f32) {
+    %t = load %buffer[%iv] : memref<1024xf32>
+    %cond = cmpf "ugt", %t, %c0 : f32
+    %sum_next = loop.if %cond -> (f32) {
+      %new_sum = addf %sum_iter, %t : f32
+      loop.yield %new_sum : f32
+    } else {
+      loop.yield %sum_iter : f32
+    }
+    loop.yield %sum_next : f32
+  }
+  return %sum : f32
+}
+// CHECK-LABEL: func @conditional_reduce(
+//  CHECK-SAME: %[[ARG0:[A-Za-z0-9]+]]
+//  CHECK-SAME: %[[ARG1:[A-Za-z0-9]+]]
+//  CHECK-SAME: %[[ARG2:[A-Za-z0-9]+]]
+//  CHECK-SAME: %[[ARG3:[A-Za-z0-9]+]]
+//  CHECK-NEXT: %[[INIT:.*]] = constant
+//  CHECK-NEXT: %[[ZERO:.*]] = constant
+//  CHECK-NEXT: %[[RESULT:.*]] = loop.for %[[IV:.*]] = %[[ARG1]] to %[[ARG2]] step %[[ARG3]]
+//  CHECK-SAME: iter_args(%[[ITER:.*]] = %[[INIT]]) -> (f32) {
+//  CHECK-NEXT: %[[T:.*]] = load %[[ARG0]][%[[IV]]]
+//  CHECK-NEXT: %[[COND:.*]] = cmpf "ugt", %[[T]], %[[ZERO]]
+//  CHECK-NEXT: %[[IFRES:.*]] = loop.if %[[COND]] -> (f32) {
+//  CHECK-NEXT: %[[THENRES:.*]] = addf %[[ITER]], %[[T]]
+//  CHECK-NEXT: loop.yield %[[THENRES]] : f32
+//  CHECK-NEXT: } else {
+//  CHECK-NEXT: loop.yield %[[ITER]] : f32
+//  CHECK-NEXT: }
+//  CHECK-NEXT: loop.yield %[[IFRES]] : f32
+//  CHECK-NEXT: }
+//  CHECK-NEXT: return %[[RESULT]]