if (device_attr.getValue().empty()) {
          op->setAttr(kDeviceAttr, builder.getStringAttr(default_device_));
        }
      } else if (op->getDialect() == tf) {
        // Assign default device to all ops in Tensorflow dialect that do not
        // have device attribute.
        op->setAttr(kDeviceAttr, builder.getStringAttr(default_device_));
      }
    });
  }
};

        module.getLoc(), launch.getResultTypes(), launch.getOperands(),
        SymbolRefAttr::get(builder.getContext(), launch.getFunc()),
        /*config=*/builder.getStringAttr(""),
        /*config_proto=*/builder.getStringAttr(""),
        /*executor_type=*/builder.getStringAttr(""));
    call_op->setAttr("device", launch->getAttrOfType<StringAttr>("device"));
    launch.replaceAllUsesWith(call_op);
    launch.erase();
  });
}

    // Clean up functions from tf_saved_model attributes.
    OpBuilder builder(module);
    auto bound_input = builder.getStringAttr("tf_saved_model.bound_input");
    auto exported_names = builder.getStringAttr(kTfSavedModelExportedNamesAttr);
    auto index_path = builder.getStringAttr(kTfSavedModelIndexPathAttr);
    module.walk([&](func::FuncOp func) {
      func->removeAttr(exported_names);

                    builder.getStringAttr(tensorflow::kEmptyDevice));
        return mlir::WalkResult::advance();
      }
      tensorflow::DeviceNameUtils::ParsedName parsed_name;
      tensorflow::DeviceNameUtils::ParseFullOrLocalName(device_attr.getValue(),
                                                        &parsed_name);
      auto device_type = builder.getStringAttr(parsed_name.type);

TF::ConstOp CreateTensorNamesConst(const ArrayRef<std::string> tensor_names,
                                   OpBuilder& builder) {
  const auto loc = NameLoc::get(builder.getStringAttr("tensor_names"));
  return Create1DStringConst(tensor_names, loc, builder);
}

// Creates a 1D string array constant for "shape_and_slices" input of

                              rewriter.getStringAttr(folder_name)),
        rewriter.getNamedAttr("file_name", rewriter.getStringAttr(file_name)),
        // The op is disabled by default. Otherwise, values will be saved
        // during calibration.
        rewriter.getNamedAttr("enabled", rewriter.getBoolAttr(enabled)),
        rewriter.getNamedAttr("func_name", rewriter.getStringAttr(func_name)),

  for (const Edge* e : g->edges()) {
    if (!e->IsControlEdge()) {
      continue;
    }

    auto src_outside_compilation =
        GetStringAttr(*e->src(), outside_compilation_attr_name);
    auto dst_outside_compilation =
        GetStringAttr(*e->dst(), outside_compilation_attr_name);

    if (src_outside_compilation && dst_outside_compilation) {
      if (*src_outside_compilation != *dst_outside_compilation) {

      return fail(module, "No entrypoints found");
    }
    if (entrypoints.size() == 1) {
      auto entrypoint = entrypoints.begin()->second;
      Builder builder(entrypoint);
      entrypoint.setName(builder.getStringAttr("main"));
      return;
    }

    // In case we have more than 1 entry points, choose the one with
    // 'tf.entry_function' attribute set.
    llvm::SmallVector<func::FuncOp, 4> candidate_funcs;

  auto asset_op = builder.create<tf_saved_model::AssetOp>(
      module->getLoc(),
      /*sym_name=*/
      builder.getStringAttr("__tf_saved_model_variables"),  // Val unimportant.
      /*filename=*/
      builder.getStringAttr(checkpoint_path));
  // Marks the input to be inlined.
  main_func.setArgAttr(
      0, "tf_saved_model.bound_input",

// Creates a NamedAttribute given its name and value. Essentially creates
// a pair: {attribute_name, attribute_value}.
class NamedAttr<string attr_name> :
    NativeCodeCall<"NamedAttribute{$_builder.getStringAttr(\"" # attr_name # "\"), $0}">;

// Checks if the value is not defined inside a lifted function by checking the
// `tf_quant.composite_function` attribute.
def IsNotInLiftedFunc :