# -*- Python -*-

# Return the options to use for a C++ library or binary build.

# Uses the ":optmode" config_setting to pick the options.

load(

"//tensorflow/core:platform/default/build_config_root.bzl",

"if_dynamic_kernels",

"if_static",

"tf_additional_grpc_deps_py",

"tf_additional_xla_deps_py",

"tf_cuda_tests_tags",

"tf_sycl_tests_tags",

)

load(

"@local_config_tensorrt//:build_defs.bzl",

"if_tensorrt",

)

load(

"@local_config_cuda//cuda:build_defs.bzl",

"cuda_default_copts",

"if_cuda",

"if_cuda_is_configured",

)

load(

"@local_config_rocm//rocm:build_defs.bzl",

"if_rocm",

"if_rocm_is_configured",

"rocm_copts",

"rocm_default_copts",

)

load(

"//third_party/mkl:build_defs.bzl",

"if_enable_mkl",

"if_mkl",

"if_mkl_lnx_x64",

"if_mkl_ml",

"mkl_deps",

)

load(

"//third_party/mkl_dnn:build_defs.bzl",

"if_mkl_open_source_only",

)

load(

"//third_party/ngraph:build_defs.bzl",

"if_ngraph",

)

def register_extension_info(**kwargs):

pass

# if_cuda_is_configured def placeholder

# Given a source file, generate a test name.

# i.e. "common_runtime/direct_session_test.cc" becomes

# "common_runtime_direct_session_test"

def src_to_test_name(src):

return src.replace("/", "_").split(".")[0]

def full_path(relative_paths):

return [native.package_name() + "/" + relative for relative in relative_paths]

def _add_tfcore_prefix(src):

if src.startswith("//"):

return src

return "//tensorflow/core:" + src

# List of proto files for android builds

def tf_android_core_proto_sources(core_proto_sources_relative):

return [

_add_tfcore_prefix(p)

for p in core_proto_sources_relative

]

# Returns the list of pb.h and proto.h headers that are generated for

# tf_android_core_proto_sources().

def tf_android_core_proto_headers(core_proto_sources_relative):

return ([

_add_tfcore_prefix(p).replace(":", "/").replace(".proto", ".pb.h")

for p in core_proto_sources_relative

] + [

_add_tfcore_prefix(p).replace(":", "/").replace(".proto", ".proto.h")

for p in core_proto_sources_relative

])

# Sanitize a dependency so that it works correctly from code that includes

# TensorFlow as a submodule.

def clean_dep(dep):

return str(Label(dep))

def if_android_x86(a):

return select({

clean_dep("//tensorflow:android_x86"): a,

clean_dep("//tensorflow:android_x86_64"): a,

"//conditions:default": [],

})

def if_android_arm(a):

return select({

clean_dep("//tensorflow:android_arm"): a,

"//conditions:default": [],

})

def if_android_arm64(a):

return select({

clean_dep("//tensorflow:android_arm64"): a,

"//conditions:default": [],

})

def if_android_mips(a):

return select({

clean_dep("//tensorflow:android_mips"): a,

"//conditions:default": [],

})

def if_not_android(a):

return select({

clean_dep("//tensorflow:android"): [],

"//conditions:default": a,

})

def if_not_android_mips_and_mips64(a):

return select({

clean_dep("//tensorflow:android_mips"): [],

clean_dep("//tensorflow:android_mips64"): [],

"//conditions:default": a,

})

def if_android(a):

return select({

clean_dep("//tensorflow:android"): a,

"//conditions:default": [],

})

def if_ios(a):

return select({

clean_dep("//tensorflow:ios"): a,

"//conditions:default": [],

})

def if_ios_x86_64(a):

return select({

clean_dep("//tensorflow:ios_x86_64"): a,

"//conditions:default": [],

})

def if_mobile(a):

return select({

clean_dep("//tensorflow:android"): a,

clean_dep("//tensorflow:ios"): a,

"//conditions:default": [],

})

def if_not_mobile(a):

return select({

clean_dep("//tensorflow:android"): [],

clean_dep("//tensorflow:ios"): [],

"//conditions:default": a,

})

# Config setting selector used when building for products

# which requires restricted licenses to be avoided.

def if_not_lgpl_restricted(a):

_ = (a,)

return select({

"//conditions:default": [],

})

def if_not_windows(a):

return select({

clean_dep("//tensorflow:windows"): [],

"//conditions:default": a,

})

def if_windows(a):

return select({

clean_dep("//tensorflow:windows"): a,

"//conditions:default": [],

})

def if_not_windows_cuda(a):

return select({

clean_dep("//tensorflow:with_cuda_support_windows_override"): [],

"//conditions:default": a,

})

def if_linux_x86_64(a):

return select({

clean_dep("//tensorflow:linux_x86_64"): a,

"//conditions:default": [],

})

def if_darwin(a):

return select({

clean_dep("//tensorflow:darwin"): a,

"//conditions:default": [],

})

def if_override_eigen_strong_inline(a):

return select({

clean_dep("//tensorflow:override_eigen_strong_inline"): a,

"//conditions:default": [],

})

def get_win_copts(is_external = False):

WINDOWS_COPTS = [

"/DPLATFORM_WINDOWS",

"/DEIGEN_HAS_C99_MATH",

"/DTENSORFLOW_USE_EIGEN_THREADPOOL",

"/DEIGEN_AVOID_STL_ARRAY",

"/Iexternal/gemmlowp",

"/wd4018", # -Wno-sign-compare

# Bazel's CROSSTOOL currently pass /EHsc to enable exception by

# default. We can't pass /EHs-c- to disable exception, otherwise

# we will get a waterfall of flag conflict warnings. Wait for

# Bazel to fix this.

# "/D_HAS_EXCEPTIONS=0",

# "/EHs-c-",

"/wd4577",

"/DNOGDI",

]

if is_external:

return WINDOWS_COPTS + ["/UTF_COMPILE_LIBRARY"]

else:

return WINDOWS_COPTS + ["/DTF_COMPILE_LIBRARY"]

# LINT.IfChange

def tf_copts(android_optimization_level_override = "-O2", is_external = False):

# For compatibility reasons, android_optimization_level_override

# is currently only being set for Android.

# To clear this value, and allow the CROSSTOOL default

# to be used, pass android_optimization_level_override=None

android_copts = [

"-std=c++11",

"-DTF_LEAN_BINARY",

"-Wno-narrowing",

"-fomit-frame-pointer",

]

if android_optimization_level_override:

android_copts.append(android_optimization_level_override)

return (

if_not_windows([

"-DEIGEN_AVOID_STL_ARRAY",

"-Iexternal/gemmlowp",

"-Wno-sign-compare",

"-fno-exceptions",

"-ftemplate-depth=900",

]) +

if_cuda(["-DGOOGLE_CUDA=1"]) +

if_tensorrt(["-DGOOGLE_TENSORRT=1"]) +

if_mkl(["-DINTEL_MKL=1", "-DEIGEN_USE_VML"]) +

if_mkl_open_source_only(["-DINTEL_MKL_DNN_ONLY"]) +

if_enable_mkl(["-DENABLE_MKL"]) +

if_ngraph(["-DINTEL_NGRAPH=1"]) +

if_mkl_lnx_x64(["-fopenmp"]) +

if_android_arm(["-mfpu=neon"]) +

if_linux_x86_64(["-msse3"]) +

if_ios_x86_64(["-msse4.1"]) +

select({

clean_dep("//tensorflow:framework_shared_object"): [],

"//conditions:default": ["-DTENSORFLOW_MONOLITHIC_BUILD"],

}) +

select({

clean_dep("//tensorflow:android"): android_copts,

clean_dep("//tensorflow:darwin"): [],

clean_dep("//tensorflow:windows"): get_win_copts(is_external),

clean_dep("//tensorflow:ios"): ["-std=c++11"],

clean_dep("//tensorflow:no_lgpl_deps"): ["-D__TENSORFLOW_NO_LGPL_DEPS__", "-pthread"],

"//conditions:default": ["-pthread"],

})

)

def tfe_xla_copts():

return select({

"//tensorflow:with_xla_support": ["-DTENSORFLOW_EAGER_USE_XLA"],

"//conditions:default": [],

})

def tf_opts_nortti_if_android():

return if_android([

"-fno-rtti",

"-DGOOGLE_PROTOBUF_NO_RTTI",

"-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",

])

# LINT.ThenChange(//tensorflow/contrib/android/cmake/CMakeLists.txt)

def tf_features_nomodules_if_android():

return if_android(["-use_header_modules"])

# Given a list of "op_lib_names" (a list of files in the ops directory

# without their .cc extensions), generate a library for that file.

def tf_gen_op_libs(op_lib_names, deps = None, is_external = True):

# Make library out of each op so it can also be used to generate wrappers

# for various languages.

if not deps:

deps = []

for n in op_lib_names:

native.cc_library(

name = n + "_op_lib",

copts = tf_copts(is_external = is_external),

srcs = ["ops/" + n + ".cc"],

deps = deps + [clean_dep("//tensorflow/core:framework")],

visibility = ["//visibility:public"],

alwayslink = 1,

linkstatic = 1,

)

def _make_search_paths(prefix, levels_to_root):

return ",".join(

[

"-rpath,%s/%s" % (prefix, "/".join([".."] * search_level))

for search_level in range(levels_to_root + 1)

],

)

def _rpath_linkopts(name):

# Search parent directories up to the TensorFlow root directory for shared

# object dependencies, even if this op shared object is deeply nested

# (e.g. tensorflow/contrib/package:python/ops/_op_lib.so). tensorflow/ is then

# the root and tensorflow/libtensorflow_framework.so should exist when

# deployed. Other shared object dependencies (e.g. shared between contrib/

# ops) are picked up as long as they are in either the same or a parent

# directory in the tensorflow/ tree.

levels_to_root = native.package_name().count("/") + name.count("/")

return select({

clean_dep("//tensorflow:darwin"): [

"-Wl,%s" % (_make_search_paths("@loader_path", levels_to_root),),

],

clean_dep("//tensorflow:windows"): [],

"//conditions:default": [

"-Wl,%s" % (_make_search_paths("$$ORIGIN", levels_to_root),),

],

})

# Bazel-generated shared objects which must be linked into TensorFlow binaries

# to define symbols from //tensorflow/core:framework and //tensorflow/core:lib.

def tf_binary_additional_srcs():

return if_static(

extra_deps = [],

otherwise = [

clean_dep("//tensorflow:libtensorflow_framework.so"),

],

)

def _linux_kernel_dso_name(kernel_build_target):

"""Given a build target, construct the dso name for linux."""

parts = kernel_build_target.split(":")

return "%s:libtfkernel_%s.so" % (parts[0], parts[1])

# Helper functions to add kernel dependencies to tf binaries when using dynamic

# kernel linking.

def tf_binary_dynamic_kernel_dsos(kernels):

return if_dynamic_kernels(

extra_deps = [_linux_kernel_dso_name(k) for k in kernels],

otherwise = [],

)

# Helper functions to add kernel dependencies to tf binaries when using static

# kernel linking.

def tf_binary_dynamic_kernel_deps(kernels):

return if_dynamic_kernels(

extra_deps = [],

otherwise = kernels,

)

def tf_cc_shared_object(

name,

srcs = [],

deps = [],

data = [],

linkopts = [],

framework_so = tf_binary_additional_srcs(),

kernels = [],

**kwargs):

native.cc_binary(

name = name,

srcs = srcs + framework_so,

deps = deps + tf_binary_dynamic_kernel_deps(kernels),

linkshared = 1,

data = data + tf_binary_dynamic_kernel_dsos(kernels),

linkopts = linkopts + _rpath_linkopts(name) + select({

clean_dep("//tensorflow:darwin"): [

"-Wl,-install_name,@rpath/" + name.split("/")[-1],

],

clean_dep("//tensorflow:windows"): [],

"//conditions:default": [

"-Wl,-soname," + name.split("/")[-1],

],

}),

**kwargs

)

register_extension_info(

extension_name = "tf_cc_shared_object",

label_regex_for_dep = "{extension_name}",

)

# Links in the framework shared object

# (//third_party/tensorflow:libtensorflow_framework.so) when not building

# statically. Also adds linker options (rpaths) so that the framework shared

# object can be found.

def tf_cc_binary(

name,

srcs = [],

deps = [],

data = [],

linkopts = [],

copts = tf_copts(),

kernels = [],

**kwargs):

native.cc_binary(

name = name,

copts = copts,

srcs = srcs + tf_binary_additional_srcs(),

deps = deps + tf_binary_dynamic_kernel_deps(kernels) + if_mkl_ml(

[

clean_dep("//third_party/mkl:intel_binary_blob"),

],

),

data = data + tf_binary_dynamic_kernel_dsos(kernels),

linkopts = linkopts + _rpath_linkopts(name),

**kwargs

)

register_extension_info(

extension_name = "tf_cc_binary",

label_regex_for_dep = "{extension_name}.*",

)

# A simple wrap around native.cc_binary rule.

# When using this rule, you should realize it doesn't link to any tensorflow

# dependencies by default.

def tf_native_cc_binary(

name,

copts = tf_copts(),

**kwargs):

native.cc_binary(

name = name,

copts = copts,

**kwargs

)

register_extension_info(

extension_name = "tf_native_cc_binary",

label_regex_for_dep = "{extension_name}.*",

)

def tf_gen_op_wrapper_cc(

name,

out_ops_file,

pkg = "",

op_gen = clean_dep("//tensorflow/cc:cc_op_gen_main"),

deps = None,

include_internal_ops = 0,

# ApiDefs will be loaded in the order specified in this list.

api_def_srcs = []):

# Construct an op generator binary for these ops.

tool = out_ops_file + "_gen_cc"

if deps == None:

deps = [pkg + ":" + name + "_op_lib"]

tf_cc_binary(

name = tool,

copts = tf_copts(),

linkopts = if_not_windows(["-lm", "-Wl,-ldl"]),

linkstatic = 1, # Faster to link this one-time-use binary dynamically

deps = [op_gen] + deps,

)

srcs = api_def_srcs[:]

if not api_def_srcs:

api_def_args_str = ","

else:

api_def_args = []

for api_def_src in api_def_srcs:

# Add directory of the first ApiDef source to args.

# We are assuming all ApiDefs in a single api_def_src are in the

# same directory.

api_def_args.append(

" $$(dirname $$(echo $(locations " + api_def_src +

") | cut -d\" \" -f1))",

)

api_def_args_str = ",".join(api_def_args)

native.genrule(

name = name + "_genrule",

outs = [

out_ops_file + ".h",

out_ops_file + ".cc",

out_ops_file + "_internal.h",

out_ops_file + "_internal.cc",

],

srcs = srcs,

tools = [":" + tool] + tf_binary_additional_srcs(),

cmd = ("$(location :" + tool + ") $(location :" + out_ops_file + ".h) " +

"$(location :" + out_ops_file + ".cc) " +

str(include_internal_ops) + " " + api_def_args_str),

)

# Given a list of "op_lib_names" (a list of files in the ops directory

# without their .cc extensions), generate individual C++ .cc and .h

# files for each of the ops files mentioned, and then generate a

# single cc_library called "name" that combines all the

# generated C++ code.

#

# For example, for:

# tf_gen_op_wrappers_cc("tf_ops_lib", [ "array_ops", "math_ops" ])

#

#

# This will ultimately generate ops/* files and a library like:

#

# cc_library(name = "tf_ops_lib",

# srcs = [ "ops/array_ops.cc",

# "ops/math_ops.cc" ],

# hdrs = [ "ops/array_ops.h",

# "ops/math_ops.h" ],

# deps = [ ... ])

#

# Plus a private library for the "hidden" ops.

# cc_library(name = "tf_ops_lib_internal",

# srcs = [ "ops/array_ops_internal.cc",

# "ops/math_ops_internal.cc" ],

# hdrs = [ "ops/array_ops_internal.h",

# "ops/math_ops_internal.h" ],

# deps = [ ... ])

# TODO(joshl): Cleaner approach for hidden ops.

def tf_gen_op_wrappers_cc(

name,

op_lib_names = [],

other_srcs = [],

other_hdrs = [],

other_srcs_internal = [],

other_hdrs_internal = [],

pkg = "",

deps = [

clean_dep("//tensorflow/cc:ops"),

clean_dep("//tensorflow/cc:scope"),

clean_dep("//tensorflow/cc:const_op"),

],

deps_internal = [],

op_gen = clean_dep("//tensorflow/cc:cc_op_gen_main"),

include_internal_ops = 0,

visibility = None,

# ApiDefs will be loaded in the order apecified in this list.

api_def_srcs = []):

subsrcs = other_srcs[:]

subhdrs = other_hdrs[:]

internalsrcs = other_srcs_internal[:]

internalhdrs = other_hdrs_internal[:]

for n in op_lib_names:

tf_gen_op_wrapper_cc(

n,

"ops/" + n,

pkg = pkg,

op_gen = op_gen,

include_internal_ops = include_internal_ops,

api_def_srcs = api_def_srcs,

)

subsrcs += ["ops/" + n + ".cc"]

subhdrs += ["ops/" + n + ".h"]

internalsrcs += ["ops/" + n + "_internal.cc"]

internalhdrs += ["ops/" + n + "_internal.h"]

native.cc_library(

name = name,

srcs = subsrcs,

hdrs = subhdrs,

deps = deps + if_not_android([

clean_dep("//tensorflow/core:core_cpu"),

clean_dep("//tensorflow/core:framework"),

clean_dep("//tensorflow/core:lib"),

clean_dep("//tensorflow/core:protos_all_cc"),

]) + if_android([

clean_dep("//tensorflow/core:android_tensorflow_lib"),

]),

copts = tf_copts(),

alwayslink = 1,

visibility = visibility,

)

native.cc_library(

name = name + "_internal",

srcs = internalsrcs,

hdrs = internalhdrs,

deps = deps + deps_internal + if_not_android([

clean_dep("//tensorflow/core:core_cpu"),

clean_dep("//tensorflow/core:framework"),

clean_dep("//tensorflow/core:lib"),

clean_dep("//tensorflow/core:protos_all_cc"),

]) + if_android([

clean_dep("//tensorflow/core:android_tensorflow_lib"),

]),

copts = tf_copts(),

alwayslink = 1,

visibility = [clean_dep("//tensorflow:internal")],

)

# Generates a Python library target wrapping the ops registered in "deps".

#

# Args:

# name: used as the name of the generated target and as a name component of

# the intermediate files.

# out: name of the python file created by this rule. If None, then

# "ops/gen_{name}.py" is used.

# hidden: Optional list of ops names to make private in the Python module.

# It is invalid to specify both "hidden" and "op_whitelist".

# visibility: passed to py_library.

# deps: list of dependencies for the intermediate tool used to generate the

# python target. NOTE these `deps` are not applied to the final python

# library target itself.

# require_shape_functions: leave this as False.

# hidden_file: optional file that contains a list of op names to make private

# in the generated Python module. Each op name should be on a line by

# itself. Lines that start with characters that are invalid op name

# starting characters are treated as comments and ignored.

# generated_target_name: name of the generated target (overrides the

# "name" arg)

# op_whitelist: if not empty, only op names in this list will be wrapped. It

# is invalid to specify both "hidden" and "op_whitelist".

# cc_linkopts: Optional linkopts to be added to tf_cc_binary that contains the

# specified ops.

def tf_gen_op_wrapper_py(

name,

out = None,

hidden = None,

visibility = None,

deps = [],

require_shape_functions = False,

hidden_file = None,

generated_target_name = None,

op_whitelist = [],

cc_linkopts = [],

api_def_srcs = []):

if (hidden or hidden_file) and op_whitelist:

fail("Cannot pass specify both hidden and op_whitelist.")

# Construct a cc_binary containing the specified ops.

tool_name = "gen_" + name + "_py_wrappers_cc"

if not deps:

deps = [str(Label("//tensorflow/core:" + name + "_op_lib"))]

tf_cc_binary(

name = tool_name,

linkopts = if_not_windows(["-lm", "-Wl,-ldl"]) + cc_linkopts,

copts = tf_copts(),

linkstatic = 1, # Faster to link this one-time-use binary dynamically

deps = ([

clean_dep("//tensorflow/core:framework"),

clean_dep("//tensorflow/python:python_op_gen_main"),

] + deps),

visibility = [clean_dep("//tensorflow:internal")],

)

# Invoke the previous cc_binary to generate a python file.

if not out:

out = "ops/gen_" + name + ".py"

if hidden:

op_list_arg = ",".join(hidden)

op_list_is_whitelist = False

elif op_whitelist:

op_list_arg = ",".join(op_whitelist)

op_list_is_whitelist = True

else:

op_list_arg = "''"

op_list_is_whitelist = False

# Prepare ApiDef directories to pass to the genrule.

if not api_def_srcs:

api_def_args_str = ","

else:

api_def_args = []

for api_def_src in api_def_srcs:

# Add directory of the first ApiDef source to args.

# We are assuming all ApiDefs in a single api_def_src are in the

# same directory.

api_def_args.append(

"$$(dirname $$(echo $(locations " + api_def_src +

") | cut -d\" \" -f1))",

)

api_def_args_str = ",".join(api_def_args)

if hidden_file:

# `hidden_file` is file containing a list of op names to be hidden in the

# generated module.

native.genrule(

name = name + "_pygenrule",

outs = [out],

srcs = api_def_srcs + [hidden_file],

tools = [tool_name] + tf_binary_additional_srcs(),

cmd = ("$(location " + tool_name + ") " + api_def_args_str +

" @$(location " + hidden_file + ") " +

("1" if require_shape_functions else "0") + " > $@"),

)

else:

native.genrule(

name = name + "_pygenrule",

outs = [out],

srcs = api_def_srcs,

tools = [tool_name] + tf_binary_additional_srcs(),

cmd = ("$(location " + tool_name + ") " + api_def_args_str + " " +

op_list_arg + " " +

("1" if require_shape_functions else "0") + " " +

("1" if op_list_is_whitelist else "0") + " > $@"),

)

# Make a py_library out of the generated python file.

if not generated_target_name:

generated_target_name = name

native.py_library(

name = generated_target_name,

srcs = [out],

srcs_version = "PY2AND3",

visibility = visibility,

deps = [

clean_dep("//tensorflow/python:framework_for_generated_wrappers_v2"),

],

)

# Define a bazel macro that creates cc_test for tensorflow.

#

# Links in the framework shared object

# (//third_party/tensorflow:libtensorflow_framework.so) when not building

# statically. Also adds linker options (rpaths) so that the framework shared

# object can be found.

#

# TODO(opensource): we need to enable this to work around the hidden symbol

# __cudaRegisterFatBinary error. Need more investigations.

def tf_cc_test(

name,

srcs,

deps,

data = [],

linkstatic = 0,

extra_copts = [],

suffix = "",

linkopts = [],

nocopts = None,

kernels = [],

**kwargs):

native.cc_test(

name = "%s%s" % (name, suffix),

srcs = srcs + tf_binary_additional_srcs(),

copts = tf_copts() + extra_copts,

linkopts = select({

clean_dep("//tensorflow:android"): [

"-pie",

],

clean_dep("//tensorflow:windows"): [],

clean_dep("//tensorflow:darwin"): [

"-lm",

],

"//conditions:default": [

"-lpthread",

"-lm",

],

}) + linkopts + _rpath_linkopts(name),

deps = deps + tf_binary_dynamic_kernel_deps(kernels) + if_mkl_ml(

[

clean_dep("//third_party/mkl:intel_binary_blob"),

],

),

data = data + tf_binary_dynamic_kernel_dsos(kernels),

# Nested select() statements seem not to be supported when passed to

# linkstatic, and we already have a cuda select() passed in to this

# function.

linkstatic = linkstatic or select({

# cc_tests with ".so"s in srcs incorrectly link on Darwin unless

# linkstatic=1 (https://github.com/bazelbuild/bazel/issues/3450).

# TODO(allenl): Remove Mac static linking when Bazel 0.6 is out.

clean_dep("//tensorflow:darwin"): 1,

"//conditions:default": 0,

}),

nocopts = nocopts,

**kwargs

)

register_extension_info(

extension_name = "tf_cc_test",

label_regex_for_dep = "{extension_name}.*",

)

# Part of the testing workflow requires a distinguishable name for the build

# rules that involve a GPU, even if otherwise identical to the base rule.

def tf_cc_test_gpu(

name,

srcs,

deps,

linkstatic = 0,

tags = [],

data = [],

size = "medium",

suffix = "",

args = None):

tf_cc_test(

name,

srcs,

deps,

linkstatic = linkstatic,

tags = tags,

data = data,

size = size,

suffix = suffix,

args = args,

)

register_extension_info(

extension_name = "tf_cc_test_gpu",

label_regex_for_dep = "{extension_name}",

)

def tf_cuda_cc_test(

name,

srcs = [],

deps = [],

tags = [],

data = [],

size = "medium",

extra_copts = [],

linkstatic = 0,

args = [],

kernels = [],

linkopts = []):

tf_cc_test(

name = name,

srcs = srcs,

deps = deps,

tags = tags + ["manual"],

data = data,

size = size,

extra_copts = extra_copts,

linkstatic = linkstatic,

linkopts = linkopts,

args = args,

kernels = kernels,

)

tf_cc_test(

name = name,

srcs = srcs,

suffix = "_gpu",

deps = deps + if_cuda([

clean_dep("//tensorflow/core:gpu_runtime"),

]),

linkstatic = select({

# TODO(allenl): Remove Mac static linking when Bazel 0.6 is out.

clean_dep("//tensorflow:darwin"): 1,

"@local_config_cuda//cuda:using_nvcc": 1,

"@local_config_cuda//cuda:using_clang": 1,

"//conditions:default": 0,

}),

tags = tags + tf_cuda_tests_tags(),

data = data,

size = size,

extra_copts = extra_copts,

linkopts = linkopts,

args = args,

kernels = kernels,

)

register_extension_info(

extension_name = "tf_cuda_cc_test",

label_regex_for_dep = "{extension_name}",

)

def tf_cuda_only_cc_test(

name,

srcs = [],

deps = [],

tags = [],

data = [],

size = "medium",

linkstatic = 0,

args = [],

kernels = [],

linkopts = []):

native.cc_test(

name = "%s%s" % (name, "_gpu"),

srcs = srcs + tf_binary_additional_srcs(),

size = size,

args = args,

copts = _cuda_copts() + rocm_copts() + tf_copts(),

data = data + tf_binary_dynamic_kernel_dsos(kernels),

deps = deps + tf_binary_dynamic_kernel_deps(kernels) +

if_cuda_is_configured([

clean_dep("//tensorflow/core:cuda"),

clean_dep("//tensorflow/core:gpu_lib"),

]) +

if_rocm_is_configured([

clean_dep("//tensorflow/core:gpu_lib"),

]),

linkopts = if_not_windows(["-lpthread", "-lm"]) + linkopts + _rpath_linkopts(name),

linkstatic = linkstatic or select({

# cc_tests with ".so"s in srcs incorrectly link on Darwin

# unless linkstatic=1.

# TODO(allenl): Remove Mac static linking when Bazel 0.6 is out.

clean_dep("//tensorflow:darwin"): 1,

"//conditions:default": 0,

}),

tags = tags + tf_cuda_tests_tags(),

)

register_extension_info(

extension_name = "tf_cuda_only_cc_test",

label_regex_for_dep = "{extension_name}_gpu",

)

# Create a cc_test for each of the tensorflow tests listed in "tests"

def tf_cc_tests(

srcs,

deps,

name = "",

linkstatic = 0,

tags = [],

size = "medium",

args = None,

linkopts = [],

kernels = [],

nocopts = None):

for src in srcs:

tf_cc_test(

name = src_to_test_name(src),

srcs = [src],

deps = deps,

linkstatic = linkstatic,

tags = tags,

size = size,

args = args,

linkopts = linkopts,

nocopts = nocopts,

kernels = kernels,

)

def tf_cc_test_mkl(

srcs,

deps,

name = "",

data = [],

linkstatic = 0,

tags = [],

size = "medium",

kernels = [],

args = None):

# -fno-exceptions in nocopts breaks compilation if header modules are enabled.

disable_header_modules = ["-use_header_modules"]

for src in srcs:

native.cc_test(

name = src_to_test_name(src),

srcs = if_mkl([src]) + tf_binary_additional_srcs(),

copts = tf_copts(),

linkopts = select({

clean_dep("//tensorflow:android"): [

"-pie",

],

clean_dep("//tensorflow:windows"): [],

"//conditions:default": [

"-lpthread",

"-lm",

],

}) + _rpath_linkopts(src_to_test_name(src)),

deps = deps + tf_binary_dynamic_kernel_deps(kernels) + mkl_deps(),

data = data + tf_binary_dynamic_kernel_dsos(kernels),

linkstatic = linkstatic,

tags = tags,

size = size,

args = args,

features = disable_header_modules,

nocopts = "-fno-exceptions",

)

def tf_cc_tests_gpu(

srcs,

deps,

name = "",

linkstatic = 0,

tags = [],

size = "medium",

kernels = [],

args = None):

tf_cc_tests(srcs, deps, linkstatic, tags = tags, size = size, kernels = kernels, args = args)

def tf_cuda_cc_tests(

srcs,

deps,

name = "",

tags = [],

size = "medium",

linkstatic = 0,

args = None,

kernels = [],

linkopts = []):

for src in srcs:

tf_cuda_cc_test(

name = src_to_test_name(src),

srcs = [src],

deps = deps,

tags = tags,

size = size,

linkstatic = linkstatic,

args = args,

kernels = kernels,

linkopts = linkopts,