}

// Return true if the passed quantized type is unsigned.
bool QuantizedTypeIsUnsigned(Type type) {
  return TypeSwitch<Type, bool>(type)
      .Case<mlir::TF::Qint8Type>([](Type) { return false; })
      .Case<mlir::TF::Qint16Type>([](Type) { return false; })
      .Case<mlir::TF::Qint32Type>([](Type) { return false; })
      .Case<mlir::TF::Quint8Type>([](Type) { return true; })

    return false;
  }

  if (node.type_string() == "Const") {
    const AttrValue* attr = node.attrs().Find("dtype");
    if (!op_filter_.allow_string_consts && attr != nullptr &&
        attr->type() == DT_STRING) {
      *uncompilable_reason =
          "Const op with type DT_STRING is not supported by XLA.";
      return false;
    }
  }

    if (node->type_string() == "Const" && must_be_true) {
      const TensorProto* proto = nullptr;
      TF_RETURN_IF_ERROR(GetNodeAttr(node->def(), "value", &proto));

      Tensor tensor(proto->dtype());
      TF_RET_CHECK(tensor.FromProto(*proto));

      *predicate = tensor.scalar<bool>()() ? MakeTrue() : MakeFalse();
      return absl::OkStatus();
    }

    } else {
      return tensorflow::Status(absl::StatusCode::kInvalidArgument,
                                "Unsupported type");
    }
  } else if (auto itype = mlir::dyn_cast<mlir::IntegerType>(element_type)) {
    if (element_type.isSignedInteger()) {
      switch (itype.getWidth()) {
        case 8:
          return DenseElementsAttr::get<int8_t>(shaped_type,

    for (int i = 0; i < 2; ++i) {
      tensor_proto.add_int_val(1);
    }
    NodeDef const_def;
    TF_CHECK_OK(NodeDefBuilder("const", "Const")
                    .Attr("dtype", DT_INT32)
                    .Attr("value", tensor_proto)
                    .Finalize(&const_def));
    Status s;
    Node *const_node = g->AddNode(const_def, &s);
    TF_CHECK_OK(s);

    NodeDef fn_def;

    Location loc = graph_func.getLoc();
    FunctionType ftype = graph_func.getFunctionType();

    func::FuncOp func = rewriter.create<func::FuncOp>(
        graph_func.getLoc(),
        graph_func->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName())
            .getValue(),
        ftype);

    func->setAttrs(graph_func->getAttrs());

    llvm::SmallVector<Type> arg_types;
    llvm::SmallVector<Type> res_types;

string AttrView::DefaultValue() const {
  const AttrValue &attr_value = attr_.default_value();
  switch (attr_value.value_case()) {
    case AttrValue::VALUE_NOT_SET:
      return "";
    case AttrValue::kType:
      return DataType_Name(attr_value.type());
    case AttrValue::kS:
      return "\"" + attr_value.s() + "\"";
    case AttrValue::kI:
      return std::to_string(attr_value.i());
    case AttrValue::kF:

                    Attribute value) {
  // Handle the case where the type and value are already tensors.
  if (mlir::isa<TensorType>(type) && mlir::isa<ElementsAttr>(value)) {
    result.addTypes(type);
    result.addAttribute("value", value);
    return;
  }

  // Otherwise, default to the attribute builder.
  ConstOp::build(builder, result, value);

      assert(while_caller.body_function() == func);
      while_callers.push_back(while_caller);
    }
  }
  return while_callers;
}

bool IsResourceType(Type type) {
  return mlir::isa<TF::ResourceType>(getElementTypeOrSelf(type));
}

bool OnlyOperatesOnCompositeDevices(
    TF::TPUExecuteAndUpdateVariablesOp& op,
    const TF::SideEffectAnalysis::Info& side_effect_analysis,

    }
    if (ftype.isF64()) {
      return tflite::TensorType_COMPLEX128;
    }
    return Status(absl::StatusCode::kInvalidArgument, "Unsupported type");
  } else if (auto itype = mlir::dyn_cast<mlir::IntegerType>(type)) {
    switch (itype.getWidth()) {
      case 1:
        return tflite::TensorType_BOOL;
      case 4:
        if (itype.isUnsigned()) {
          return Status(absl::StatusCode::kInvalidArgument,