// RUN: tf-opt %s -tf-region-control-flow-to-functional -split-input-file | FileCheck %s

// Simple IfRegion
// CHECK: func private @test_else_name(%arg0: tensor<*xf32>) -> tensor<*xf32>
// CHECK-NEXT:   "tf.Neg"
// CHECK: func private @test_then_name(%arg0: tensor<*xf32>) -> tensor<*xf32>
// CHECK-NEXT:   "tf.Abs"
func.func @testSimple(%arg0: tensor<i1>, %arg1: tensor<*xf32>) -> tensor<*xf32> {
  // CHECK: "tf.If"
  // CHECK-NOT: attr1

                        <div class="card-body">
                            <ul class="nav nav-tabs" role="tablist">
                                <li role="presentation" class="nav-item"><a href="#remote" aria-controls="remote" class="nav-link active"
                                                                          role="tab"
                                                                          data-toggle="tab"

# RUN: tf-mlir-translate -graphdef-to-mlir -tf-enable-shape-inference-on-import=false %s -tf-prune-unused-nodes -tf-control-output-arrays=AssignAdd -o - | FileCheck --check-prefix=PRUNE %s

run on TPU instead of CPU while still being compiled on host.
### `-tf-functional-control-flow-to-cfg`

_Transform functional control flow Ops to MLIR Control Form Graph (CFG) form_

### `-tf-functional-control-flow-to-regions`

_Transforms functional control flow operations to their region-based counterparts_

This pass transforms functional control flow operations in the TensorFlow

}

def ExecutorConvertControlToDataOutputsPass : Pass<"tf-executor-convert-control-to-data-outputs", "ModuleOp"> {
  let summary = "Chain control outputs of while loop body";

  let description = [{
    This pass converts the control outputs of a while loop body function to data
    outputs. Thus, inter iteration control dependencies are transformed to
    data dependencies. Since data dependencies can express which particular

func.func @invalid_yield(%arg0: tensor<*xf32>, %ctl: !tf_executor.control) {
  tf_executor.graph {
    "tf_executor.island"() ({
      "tf_executor.yield"(%arg0, %ctl) : (tensor<*xf32>, !tf_executor.control) -> ()
// expected-error@-1 {{'tf_executor.yield' op unexpected control type for operand #1}}
    }) : () -> (tensor<*xf32>, !tf_executor.control, !tf_executor.control)
  }
  func.return

			    Create a two-machine cluster with one control-plane node
			    (which controls the cluster), and one worker node
			    (where your workloads, like Pods and Deployments run).

			    ┌──────────────────────────────────────────────────────────┐
			    │ On the first machine:                                    │
			    ├──────────────────────────────────────────────────────────┤
			    │ control-plane# kubeadm init                              │

				for _, v := range child.Values {
					if v.Op != OpPhi {
						continue
					}
					v.AddArg(v.Args[ai])
				}
				if b.Func.pass.debug > 0 {
					b.Func.Warnl(b.Controls[0].Pos, "Redirect %s based on %s", b.Controls[0].Op, p.Controls[0].Op)
				}
				changed = true
				k--
				break
			}
			ft.restore()
		}
		if len(b.Preds) == 0 && b != f.Entry {
			// Block is now dead.
			b.Kind = BlockInvalid

module attributes {tf.versions = {bad_consumers = [], min_consumer = 12 : i32, producer = 458 : i32}} {
  func.func @main() {
    tf_executor.graph {
      %control = tf_executor.island wraps "tf.NoOp"() {_f = #tf_type.func<@callee, {attr2 = true, attr3 = 8.0 : f32}>} : () -> ()
      %control_1 = tf_executor.island(%control) wraps "tf.LegacyCall"() {f = @callee} : () -> ()
      tf_executor.fetch
    }
    func.return
  }

    tf_executor.graph {
      %outputs, %control = tf_executor.island wraps "tf.Const"() {device = "", value = dense<0> : tensor<i32>} : () -> tensor<i32>
      %outputs_0, %control_1 = tf_executor.island wraps "tf.Const"() {device = "", value = dense<1> : tensor<i32>} : () -> tensor<i32>