}
}

// This is just a wrapper around abi.NoEscape. The inlining heuristics are
// finnicky and for whatever reason treat the local call to noescape as much
// lower cost with respect to the inliner budget. (That is, replacing calls to
// noescape with abi.NoEscape will cause inlining tests to fail.)
//
//go:nosplit
func noescape(p unsafe.Pointer) unsafe.Pointer {

      return
    }
    ```
  }];

  let constructor = "TF::CreateDecomposeReduceDatasetPass()";
}

def ExecutorTPUV1IslandInliningPass : Pass<"tf-executor-tpu-v1-island-inlining", "ModuleOp"> {
  let summary = "Inline calls to the nested TPU module.";

  let description = [{
    This pass inlines the islands calling into the nested module that was
    outlined, thus reversing the effect of the

  Region& region = cond ? op.getThenBranch() : op.getElseBranch();

  // If the IfRegion is stateless but the region being inlined itself is not
  // stateless, then inlining the region could cause a loss of information.
  // However, its probably better to fold the IfRegion instead of having the
  // dead branch stay.

  // Inline the region in place of the IfRegion op, and forward the yield

  return true;
}

// Returns true if the module holds all the invariants expected by the
// Translator class.
// TODO(hinsu): Now that translation is done by making a single pass over the
// MLIR module, consider inlining these validation checks at the place where
// these invariants are assumed instead of checking upfront.
static bool IsValidTFLiteMlirModule(ModuleOp module) {
  MLIRContext* context = module.getContext();

    return true;
  }
  bool isLegalToInline(Operation* op, Region* dest, bool wouldBeCloned,
                       IRMapping&) const final {
    // No TFLite op restricts inlining today, revise as needed in the future.
    return true;
  }
  bool isLegalToInline(Region* dest, Region* src, bool wouldBeCloned,
                       IRMapping& valueMapping) const final {

// Prefetch instructions (aux is option: 0 - PLDL1KEEP; 1 - PLDL1STRM)
(PrefetchCache addr mem)         => (PRFM [0] addr mem)
(PrefetchCacheStreamed addr mem) => (PRFM [1] addr mem)

// Arch-specific inlining for small or disjoint runtime.memmove
(SelectN [0] call:(CALLstatic {sym} s1:(MOVDstore _ (MOVDconst [sz]) s2:(MOVDstore  _ src s3:(MOVDstore {t} _ dst mem)))))
	&& sz >= 0
	&& isSameCall(sym, "runtime.memmove")

		if setval, val := valueToString(e), valueToString(iter.Value()); setval != val {
			t.Errorf("MapIter.Value() = %q, MapIter.SetValue() = %q", val, setval)
		}
	}

	if testenv.OptimizationOff() {
		return // no inlining with the noopt builder
	}

	got := int(testing.AllocsPerRun(10, func() {
		iter := v.MapRange()
		for iter.Next() {
			k.SetIterKey(iter)
			e.SetIterValue(iter)
		}
	}))

violet in the former Circuit, and the green was much more conspicuous, being as brisk and copious as any of the other Colours, except the yellow, but the red began to be a little faded, inclining very much to purple. After this succeeded the fourth Circuit of green and red. The green was very copious and lively, inclining on the one side to blue, and on the other side to yellow. But in this fourth Circuit there was neither violet, blue, nor yellow, and the red was very imperfect and dirty. Also the succeeding...