GraphExportConfig export_confs_;
};

// Decomposes the NodeDef to a set of primitive ops according to the decompose
// library loaded. Wrap the decomposed result in a FunctionDef.
absl::StatusOr<FunctionDef> ExpandNode(const NodeDef& node_def,
                                       StringPiece func_name);

// Decomposes the ops in the ModuleOp to a set of primitive ops according to
// decompose library in the context.

std::unique_ptr<OperationPass<ModuleOp>> CreateConvertLaunchFuncToTFCallPass();

// A pass that decomposes composite resource operations into primitive ones like
// ReadVariableOp, AssignVariableOp and other computations to facilitate
// transformations like resource op lifting.
std::unique_ptr<OperationPass<func::FuncOp>> CreateDecomposeResourceOpsPass();

// A pass that decomposes composite resource operations in device cluster

}

def DecomposeResourceOpsPass : Pass<"tf-device-decompose-resource-ops", "mlir::func::FuncOp"> {
  let summary = "Decompose composite resource variable operations into primitive Read/AssignVariableOp and raw computation.";

  let description = [{
    A pass that decomposes composite resource operations into primitive ones like

See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

// This transformation pass decomposes dense operations that assume
// support for hybrid quantization. These cases cover when a dense operation
// (e.g. matmul) has both quantized and unquantized inputs by dequantizing

                                         decomposed_partitioned_call_callees)))
      return failure();
  }
  return success();
}

// Decomposes stack ops on a region and recursively decomposes called functions.
// data_var_to_size_var: a mapping from stacks' buffer local variables to size
// local variables.
// decomposed_partitioned_call_callees: cache for partitioned call ops' callee

// Creates an instance of the TensorFlow Lite dialect QuantizeVariables pass.
std::unique_ptr<OperationPass<ModuleOp>> CreatePrepareQuantizeVariablesPass();

// Creates an instance of the TensorFlow Lite pass that decomposes hybrid
// quantization patterns to the same dense operation with tfl dequantization
// and quantization patterns.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateDecomposeHybridQuantizationPass();

               "Is the corresponding integer signed">,
  ];
}
def DecomposeHybridQuantizationPass : Pass<"tfl-decompose-hybrid-quantization", "mlir::func::FuncOp"> {
  let summary = "Decomposes hybridge quantization to explicit quantize / dequantize";
  let description = [{
      Decomposes (with explicit quantize/dequantize ops) selected math
      operations which exist in the model with hybrid quantization

	return &asyncCall{region: call, async: call, scope: fun, fun: fun}
}

var forbidden = []string{
	"FailNow",
	"Fatal",
	"Fatalf",
	"Skip",
	"Skipf",
	"SkipNow",
}

// forbiddenMethod decomposes a call x.m() into (x, x.m, m) where
// x is a variable, x.m is a selection, and m is the static callee m.
// Returns (nil, nil, nil) if call is not of this form.

// canonicalization.
//
// Operations in tf dialect are lowered to XLA HLO through the following steps:
//   . Legalizes control flow operations.
//   . Decomposes compound resource operations so that the only remaining
//     operations on resource variables are resource reads/writes..
//   . Replaces resource reads/writes with function inputs/outputs and

  for (int i = state_size + 1; i < body_args.size(); ++i) {
    body_returns.push_back(body_args[i]);
  }
  builder.create<TF::YieldOp>(loc,
                              /*operands=*/body_returns);
}

// Decomposes any ReduceDatasetOps in `function` into a dataset iteration and a
// call to the reduce function in the ReduceDatasetOp.
LogicalResult DecomposeReduceDatasetInFunction(FuncOp function) {
  if (!llvm::hasSingleElement(function))