return op_has_side_effects_(inner_op) ? WalkResult::interrupt()
                                                  : WalkResult::advance();
          }).wasInterrupted()) {
      ops_with_side_effects.push_back(&op);
    }
  }

  OpBuilder builder(fn.getContext());
  // The control tokens generated by the last ControlNodeOp wrapping.  Will be
  // empty until the first ControlNodeOp was generated, then have constant size

std::vector<std::string> GetVariableNames(
    llvm::ArrayRef<TF::VarHandleOp> var_handle_ops) {
  std::vector<std::string> names;
  names.reserve(var_handle_ops.size());
  for (auto var_handle_op : var_handle_ops)
    names.push_back(GetVariableName(var_handle_op));
  return names;
}

tensorflow::Var* GetVariableFromSession(mlir::TF::VarHandleOp var_handle_op,
                                        llvm::StringRef device_name,

  if (value.hasOneUse() &&
      llvm::isa<TFL::QuantizeOp>(*value.getUsers().begin()))
    return;

  // Add this result to the list to apply the default value.
  values->push_back(value);
}

void DefaultQuantParamsPass::QuantizeValue(OpBuilder builder, Value value,
                                           quant::QuantParams quant_params) {
  Type expressed_type = value.getType();

    // 'tf.entry_function' attribute set.
    llvm::SmallVector<func::FuncOp, 4> candidate_funcs;
    for (auto& entrypoint : entrypoints) {
      if (entrypoint.second->hasAttr("tf.entry_function")) {
        candidate_funcs.push_back(entrypoint.second);
      }
    }

    if (candidate_funcs.empty()) {
      return fail(module, "No entrypoints found");
    }
    if (candidate_funcs.size() > 1) {

  if (len > max_length_ || data_.size() >= max_length_ - len)
    return absl::ResourceExhaustedError("Buffer overflow");
  data_.resize(data_.size() + len);
  memcpy(data_.data() + offset_.back(), str, len);
  offset_.push_back(offset_.back() + len);
  return absl::OkStatus();
}

int MiniDynamicBuffer::WriteToBuffer(char** buffer) {
  // Allocate sufficient memory to tensor buffer.
  int32_t num_strings = offset_.size() - 1;

  for (mlir::Value res : op->getResults()) {
    for (Operation* user : res.getUsers()) {
      if (!dead_ops.insert(user).second) continue;
      RecursiveRemove(user, erase_list, dead_ops);
    }
  }

  erase_list.push_back(op);

  for (auto& use : op->getOpOperands()) {
    if (auto op_result = mlir::dyn_cast<mlir::OpResult>(use.get())) {
      Operation* def = op_result.getDefiningOp();
      if (!dead_ops.insert(def).second) continue;

      return failure();
    }
    const std::string& branch_id = id_pair[1];
    if (!std::all_of(branch_id.begin(), branch_id.end(), is_digit)) {
      return failure();
    }
    id_pairs.push_back(std::make_pair(id_pair[0], id_pair[1]));
  }
  return success();
}

}  // namespace TF

    CHECK(op_def != nullptr);  // Crash OK

    const ApiDef* api_def = api_def_map_->GetApiDef(op_name);
    CHECK(api_def != nullptr);  // Crash OK

    operators_.push_back(OpSpec::Create(*op_def, *api_def));
  }
}

}  // namespace generator

  if (dim_size != scales_.size()) {
    return {};
  }
  SmallVector<UniformQuantizedValueConverter, 4> converters;
  converters.reserve(dim_size);
  for (int i = 0, e = dim_size; i != e; ++i) {
    converters.push_back(getPerChunkConverter(i));
  }

  // Scan the elements of the dense elements attributes and quantize them by
  // using the right quantization parameters.
  int64_t flatten_index = 0;
  auto shape = type.getShape();

}

void TPUPartitionedOpConversionPass::runOnOperation() {
  llvm::SmallVector<TF::TPUReplicateMetadataOp, 4> metadata;
  getOperation()->walk(
      [&metadata](TF::TPUReplicateMetadataOp op) { metadata.push_back(op); });

  IntegerAttr num_cores_per_replica;
  if (metadata.size() == 1) {
    num_cores_per_replica = metadata.front().getNumCoresPerReplicaAttr();
  }