pytorch

1
# NOTE: This file is shared by internal and OSS BUCK build.
2
# These load paths point to different files in internal and OSS environment
3

4
load("@bazel_skylib//lib:paths.bzl", "paths")
5
load("//tools/build_defs:fb_native_wrapper.bzl", "fb_native")
6
load("//tools/build_defs:fb_xplat_cxx_library.bzl", "fb_xplat_cxx_library")
7
load("//tools/build_defs:fb_xplat_genrule.bzl", "fb_xplat_genrule")
8
load("//tools/build_defs:fbsource_utils.bzl", "is_arvr_mode")
9
load("//tools/build_defs:glob_defs.bzl", "subdir_glob")
10
load("//tools/build_defs:platform_defs.bzl", "APPLETVOS", "IOS", "MACOSX")
11
load("//tools/build_defs:type_defs.bzl", "is_list", "is_string")
12
load("//tools/build_defs/android:build_mode_defs.bzl", is_production_build_android = "is_production_build")
13
load("//tools/build_defs/apple:build_mode_defs.bzl", is_production_build_ios = "is_production_build")
14
load("//tools/build_defs/windows:windows_flag_map.bzl", "windows_convert_gcc_clang_flags")
15
load(
16
    ":build_variables.bzl",
17
    "aten_cpu_source_list",
18
    "aten_native_source_list",
19
    "core_sources_common",
20
    "core_sources_full_mobile_no_backend_interface_xplat",
21
    "core_trainer_sources",
22
    "jit_core_headers",
23
    "jit_core_sources",
24
    "libtorch_profiler_sources",
25
    "torch_cpp_srcs",
26
    "torch_mobile_tracer_sources",
27
)
28
load(
29
    ":pt_ops.bzl",
30
    "USED_PT_BACKENDS",
31
)
32
load(
33
    ":pt_template_srcs.bzl",
34
    "METAL_MASKRCNN_SOURCE_LIST",
35
    "METAL_SOURCE_LIST",
36
    "TEMPLATE_MASKRCNN_SOURCE_LIST",
37
    "TEMPLATE_SOURCE_LIST",
38
    "aten_ufunc_generated_all_cpu_sources",
39
    "get_gen_oplist_outs",
40
    "get_generate_code_bin_outs",
41
    "get_metal_registration_files_outs",
42
    "get_metal_registration_files_outs_windows",
43
    "get_metal_source_dict",
44
    "get_template_registration_file_rules",
45
    "get_template_registration_files_outs",
46
    "get_template_source_dict",
47
)
48
load(
49
    ":ufunc_defs.bzl",
50
    "aten_ufunc_generated_cpu_kernel_sources",
51
    "aten_ufunc_generated_cpu_sources",
52
    "aten_ufunc_generated_cuda_sources",
53
)
54

55
def read_bool(section, field, default, required = True):
56
    val = read_config(section, field)
57
    if val != None:
58
        if val in ["true", "True", "1"]:
59
            return True
60
        elif val in ["false", "False", "0"]:
61
            return False
62
        else:
63
            fail(
64
                "`{}:{}`: must be one of (0, 1, true, false, True, False), but was {}".format(section, field, val),
65
            )
66
    elif default != None:
67
        return default
68
    elif not required:
69
        return None
70
    else:
71
        fail("`{}:{}`: no value set".format(section, field))
72

73
def _is_build_mode_dev():
74
    if is_production_build_android():
75
        # Android Prod builds
76
        return False
77
    if is_production_build_ios():
78
        # iOS Prod builds
79
        return False
80

81
    return True
82

83
def _get_enable_lightweight_dispatch():
84
    return read_bool("pt", "enable_lightweight_dispatch", False)
85

86
def _get_enable_record_kernel_dtype():
87
    return read_bool("pt", "enable_record_kernel_dtype", False)
88

89
def get_enable_mobile_dispatch_keys_trimming():
90
    return read_bool("pt", "enable_mobile_dispatch_keys_trimming", False)
91

92
def get_disable_per_op_profiling():
93
    return read_bool("pt", "disable_per_op_profiling", True)
94

95
def get_strip_error_messages():
96
    if IS_OSS:
97
        return True  # always strip in OSS CI to expose potential issues
98
    return read_bool("pt", "strip_error_messages", not _is_build_mode_dev())
99

100
def get_disable_warn():
101
    return read_bool("pt", "disable_warn", False)
102

103
def get_enable_eager_symbolication():
104
    return read_bool("pt", "enable_eager_symbolication", default = False, required = False)
105

106
def get_static_dispatch_backend():
107
    static_dispatch_backend = native.read_config("pt", "static_dispatch_backend", None)
108
    if static_dispatch_backend == None:
109
        return []
110
    return static_dispatch_backend.split(";")
111

112
def get_glsl_image_format():
113
    if read_config("pt", "vulkan_full_precision", "0") == "0":
114
        return "rgba16f"
115
    return "rgba32f"
116

117
def get_glsl_paths():
118
    paths = [
119
        "//xplat/caffe2:aten_vulkan_glsl_src_path",
120
        "aten/src/ATen/native/vulkan/glsl",
121
    ] + [
122
        p
123
        for p in read_config("gen_vulkan_spv", "additional_glsl_paths", "").split(" ")
124
        if p
125
    ]
126

127
    if len(paths) % 2 != 0:
128
        fail(
129
            "gen_vulkan_spv.additional_glsl_paths must contain an even number of elements",
130
        )
131

132
    return " ".join(
133
        [
134
            "$(location {})/{}".format(
135
                paths[i],
136
                paths[i + 1],
137
            )
138
            for i in range(
139
                0,
140
                len(paths),
141
                2,
142
            )
143
        ],
144
    )
145

146
def spv_shader_library():
147
    pass
148

149
IS_OSS = read_config("pt", "is_oss", "0") == "1"  # True for OSS BUCK build, and False for internal BUCK build
150

151
NOT_OSS = not IS_OSS
152

153
# for targets in caffe2 root path
154
ROOT = "//" if IS_OSS else "//xplat/caffe2"
155

156
# for targets in subfolders
157
ROOT_PATH = "//" if IS_OSS else "//xplat/caffe2/"
158

159
C10 = "//c10:c10" if IS_OSS else "//xplat/caffe2/c10:c10"
160

161
# a dictionary maps third party library name to fbsource and oss target
162
THIRD_PARTY_LIBS = {
163
    "FP16": ["//xplat/third-party/FP16:FP16", "//third_party:FP16"],
164
    "FXdiv": ["//xplat/third-party/FXdiv:FXdiv", "//third_party:FXdiv"],
165
    "XNNPACK": ["//xplat/third-party/XNNPACK:XNNPACK", "//third_party:XNNPACK"],
166
    "clog": ["//xplat/third-party/clog:clog", "//third_party:clog"],
167
    "cpuinfo": ["//third-party/cpuinfo:cpuinfo", "//third_party:cpuinfo"],
168
    "flatbuffers-api": ["//third-party/flatbuffers/fbsource_namespace:flatbuffers-api", "//third_party:flatbuffers-api"],
169
    "flatc": ["//third-party/flatbuffers/fbsource_namespace:flatc", "//third_party:flatc"],
170
    "fmt": ["//third-party/fmt:fmt", "//third_party:fmt"],
171
    "glog": ["//third-party/glog:glog", "//third_party:glog"],
172
    "gmock": ["//third-party/googletest:gmock_main", "//third_party:gmock"],
173
    "gtest": ["//third-party/googletest:gtest_main", "//third_party:gtest"],
174
    "kineto": ["//xplat/kineto/libkineto:libkineto", "//third_party:libkineto"],
175
    "libkineto_headers": ["//xplat/kineto/libkineto:libkineto_headers", "//third_party:libkineto_headers"],
176
    "omp": ["//xplat/third-party/linker_lib:omp", "//third_party:no-op"],
177
    "pocketfft": ["//third-party/pocket_fft:pocketfft", "//third_party:pocketfft_header"],
178
    "psimd": ["//xplat/third-party/psimd:psimd", "//third_party:psimd"],
179
    "pthreadpool": ["//xplat/third-party/pthreadpool:pthreadpool", "//third_party:pthreadpool"],
180
    "pthreadpool_header": ["//xplat/third-party/pthreadpool:pthreadpool_header", "//third_party:pthreadpool_header"],
181
    "pyyaml": ["//third-party/pyyaml:pyyaml", "//third_party:pyyaml"],
182
    "rt": ["//xplat/third-party/linker_lib:rt", "//third_party:rt"],
183
    "ruy": ["//third-party/ruy:ruy_xplat_lib", "//third_party:ruy_lib"],
184
    "sleef_arm": ["//third-party/sleef:sleef_arm", "//third_party:sleef_arm"],
185
    "typing-extensions": ["//third-party/typing-extensions:typing-extensions", "//third_party:typing-extensions"],
186
}
187

188
def third_party(name):
189
    if name not in THIRD_PARTY_LIBS:
190
        fail("Cannot find third party library " + name + ", please register it in THIRD_PARTY_LIBS first!")
191
    return THIRD_PARTY_LIBS[name][1] if IS_OSS else THIRD_PARTY_LIBS[name][0]
192

193
def get_pt_compiler_flags():
194
    return select({
195
        "DEFAULT": _PT_COMPILER_FLAGS,
196
        "ovr_config//compiler:cl": windows_convert_gcc_clang_flags(_PT_COMPILER_FLAGS),
197
    })
198

199
_PT_COMPILER_FLAGS = [
200
    "-fexceptions",
201
    "-frtti",
202
    "-Os",
203
    "-Wno-unknown-pragmas",
204
    "-Wno-write-strings",
205
    "-Wno-unused-variable",
206
    "-Wno-unused-function",
207
    "-Wno-deprecated-declarations",
208
    "-Wno-shadow",
209
    "-Wno-global-constructors",
210
    "-Wno-missing-prototypes",
211
]
212

213
ATEN_COMPILER_FLAGS = [
214
    "-fexceptions",
215
    "-frtti",
216
    "-fPIC",
217
    "-Os",
218
    "-Wno-absolute-value",
219
    "-Wno-deprecated-declarations",
220
    "-Wno-macro-redefined",
221
    "-Wno-tautological-constant-out-of-range-compare",
222
    "-Wno-unknown-pragmas",
223
    "-Wno-unknown-warning-option",
224
    "-Wno-unused-function",
225
    "-Wno-unused-variable",
226
    "-Wno-pass-failed",
227
    "-Wno-shadow",
228
]
229

230
def get_aten_compiler_flags():
231
    return ATEN_COMPILER_FLAGS
232

233
_COMMON_PREPROCESSOR_FLAGS = [
234
    "-DC10_MOBILE",
235
    "-DNO_EXPORT",
236
] + (
237
    ["-DC10_MOBILE_TRIM_DISPATCH_KEYS"] if get_enable_mobile_dispatch_keys_trimming() else []
238
) + (
239
    ["-DSTRIP_ERROR_MESSAGES"] if get_strip_error_messages() else []
240
) + (
241
    ["-DDISABLE_WARN"] if get_disable_warn() else []
242
)
243

244
def get_aten_preprocessor_flags():
245
    # read_config is not allowed outside of function in Starlark
246
    ATEN_PREPROCESSOR_FLAGS = _COMMON_PREPROCESSOR_FLAGS + [
247
        "-DCPU_CAPABILITY_DEFAULT",
248
        "-DCPU_CAPABILITY=DEFAULT",
249
        "-DCAFFE2_USE_LITE_PROTO",
250
        "-DATEN_CUDNN_ENABLED_FBXPLAT=0",
251
        "-DATEN_MKLDNN_ENABLED_FBXPLAT=0",
252
        "-DATEN_MKLDNN_ACL_ENABLED_FBXPLAT=0",
253
        "-DATEN_NNPACK_ENABLED_FBXPLAT=0",
254
        "-DATEN_MKL_ENABLED_FBXPLAT=0",
255
        "-DATEN_MKL_SEQUENTIAL_FBXPLAT=0",
256
        "-DUSE_PYTORCH_METAL",
257
        "-DUSE_PYTORCH_QNNPACK",
258
        "-DUSE_XNNPACK",
259
        "-DPYTORCH_QNNPACK_RUNTIME_QUANTIZATION",
260
        "-DAT_PARALLEL_OPENMP_FBXPLAT=0",
261
        "-DAT_PARALLEL_NATIVE_FBXPLAT=1",
262
        "-DUSE_LAPACK_FBXPLAT=0",
263
        "-DAT_BLAS_F2C_FBXPLAT=0",
264
        "-DAT_BLAS_USE_CBLAS_DOT_FBXPLAT=0",
265
        "-DUSE_RUY_QMATMUL",
266
    ]
267
    if get_disable_per_op_profiling():
268
        ATEN_PREPROCESSOR_FLAGS.append("-DPYTORCH_DISABLE_PER_OP_PROFILING")
269
    if _get_enable_record_kernel_dtype():
270
        ATEN_PREPROCESSOR_FLAGS.append("-DENABLE_RECORD_KERNEL_FUNCTION_DTYPE")
271
    return ATEN_PREPROCESSOR_FLAGS
272

273
def get_pt_preprocessor_flags():
274
    # read_config is not allowed outside of function in Starlark
275
    PT_PREPROCESSOR_FLAGS = _COMMON_PREPROCESSOR_FLAGS + [
276
        "-D_THP_CORE",
277
        "-DUSE_SCALARS",
278
        "-DNO_CUDNN_DESTROY_HANDLE",
279
    ]
280

281
    if _is_build_mode_dev():
282
        PT_PREPROCESSOR_FLAGS.append("-DENABLE_PYTORCH_NON_PRODUCTION_BUILDS")
283
    return PT_PREPROCESSOR_FLAGS
284

285
# This needs to be kept in sync with https://github.com/pytorch/pytorch/blob/release/1.9/torchgen/gen.py#L892
286
PT_BACKEND_HEADERS = [
287
    "CPU",
288
    "CUDA",
289
    "CompositeExplicitAutograd",
290
    "CompositeExplicitAutogradNonFunctional",
291
    "CompositeImplicitAutograd",
292
    "CompositeImplicitAutogradNestedTensor",
293
    "Meta",
294
]
295

296
def get_aten_static_dispatch_backend_headers(existing_headers):
297
    static_backends = get_static_dispatch_backend()
298
    for backend in static_backends:
299
        if backend != "CPU":
300
            existing_headers["{}Functions.h".format(backend)] = ":gen_aten[{}Functions.h]".format(backend)
301
            existing_headers["{}Functions_inl.h".format(backend)] = ":gen_aten[{}Functions_inl.h]".format(backend)
302
    return existing_headers
303

304
def get_aten_codegen_extra_params(backends):
305
    extra_params = {
306
        "force_schema_registration": True,
307
    }
308
    static_backends = get_static_dispatch_backend()
309
    if static_backends:
310
        extra_params["static_dispatch_backend"] = static_backends
311
        extra_params["enabled_backends"] = static_backends
312
    else:
313
        extra_params["enabled_backends"] = backends
314
    return extra_params
315

316
def get_jit_codegen_params():
317
    return []
318

319
def get_unboxing_generated_files():
320
    srcs = []
321
    if _get_enable_lightweight_dispatch():
322
        srcs = [
323
            "UnboxingFunctions.h",
324
            "UnboxingFunctions_0.cpp",
325
            "UnboxingFunctions_1.cpp",
326
            "UnboxingFunctions_2.cpp",
327
            "UnboxingFunctions_3.cpp",
328
            "UnboxingFunctions_4.cpp",
329
            "RegisterCodegenUnboxedKernels_0.cpp",
330
            "RegisterCodegenUnboxedKernels_1.cpp",
331
            "RegisterCodegenUnboxedKernels_2.cpp",
332
            "RegisterCodegenUnboxedKernels_3.cpp",
333
            "RegisterCodegenUnboxedKernels_4.cpp",
334
            "RegisterCodegenUnboxedKernels_5.cpp",
335
            "RegisterCodegenUnboxedKernels_6.cpp",
336
            "RegisterCodegenUnboxedKernels_7.cpp",
337
            "RegisterCodegenUnboxedKernels_8.cpp",
338
            "RegisterCodegenUnboxedKernels_9.cpp",
339
        ]
340
    res = {}
341
    for file_name in srcs:
342
        res[file_name] = [file_name]
343
    return res
344

345
def get_aten_generated_files(enabled_backends):
346
    # NB: RegisterMeta counts as an optionally enabled backend,
347
    # and is intentionally omitted from here
348
    src_files = [
349
        "RegisterBackendSelect.cpp",
350
        "RegisterCompositeImplicitAutograd.cpp",
351
        "RegisterCompositeImplicitAutogradNestedTensor.cpp",
352
        "RegisterCompositeExplicitAutograd.cpp",
353
        "RegisterCompositeExplicitAutogradNonFunctional.cpp",
354
        "CompositeViewCopyKernels.cpp",
355
        "RegisterSchema.cpp",
356
        "Declarations.yaml",
357
        "Functions.cpp",
358
        "Functions.h",
359
        "RedispatchFunctions.h",
360
        "NativeFunctions.h",
361
        "NativeMetaFunctions.h",
362
        "MethodOperators.h",
363
        "FunctionalInverses.h",
364
        "Operators.h",
365
        "Operators_0.cpp",
366
        "Operators_1.cpp",
367
        "Operators_2.cpp",
368
        "Operators_3.cpp",
369
        "Operators_4.cpp",
370
        "CompositeImplicitAutogradFunctions.h",
371
        "CompositeImplicitAutogradFunctions_inl.h",
372
        "CompositeImplicitAutogradNestedTensorFunctions.h",
373
        "CompositeImplicitAutogradNestedTensorFunctions_inl.h",
374
        "CompositeExplicitAutogradFunctions.h",
375
        "CompositeExplicitAutogradFunctions_inl.h",
376
        "CompositeExplicitAutogradNonFunctionalFunctions.h",
377
        "CompositeExplicitAutogradNonFunctionalFunctions_inl.h",
378
        "VmapGeneratedPlumbing.h",
379
        "core/ATenOpList.cpp",
380
        "core/TensorBody.h",
381
        "core/TensorMethods.cpp",
382
        "core/aten_interned_strings.h",
383
        "core/enum_tag.h",
384
        "torch/csrc/inductor/aoti_torch/generated/c_shim_cpu.cpp",
385
    ] + get_aten_derived_type_srcs(enabled_backends)
386

387
    # This is tiresome.  A better strategy would be to unconditionally
388
    # generate these files, and then only actually COMPILE them depended
389
    # on the generated set.  C'est la vie...
390
    if "CPU" in enabled_backends:
391
        src_files.extend(aten_ufunc_generated_cpu_sources())
392
        src_files.extend(aten_ufunc_generated_cpu_kernel_sources())
393
    if "CUDA" in enabled_backends:
394
        # Cannot unconditionally include this, because in the Edge selective
395
        # build CUDA is not enabled and thus the ufunc codegen for CUDA gets
396
        # skipped
397
        src_files.extend(aten_ufunc_generated_cuda_sources())
398

399
    res = {}
400
    for file_name in src_files:
401
        res[file_name] = [file_name]
402
    return res
403

404
def get_aten_derived_type_src_rules(aten_rule_name, enabled_backends):
405
    return [
406
        ":{}[{}]".format(aten_rule_name, "Register" + backend + ".cpp")
407
        for backend in enabled_backends
408
    ]
409

410
def get_aten_selective_cpp_rules(aten_rule_name, enabled_backends):
411
    return [
412
        ":{}[{}]".format(aten_rule_name, f)
413
        for f in ["RegisterCompositeImplicitAutograd.cpp", "RegisterCompositeImplicitAutogradNestedTensor.cpp", "RegisterCompositeExplicitAutograd.cpp", "RegisterCompositeExplicitAutogradNonFunctional.cpp", "RegisterSchema.cpp", "RegisterBackendSelect.cpp", "CompositeViewCopyKernels.cpp"]
414
    ] + get_aten_derived_type_src_rules(aten_rule_name, enabled_backends)
415

416
def get_aten_derived_type_srcs(enabled_backends):
417
    return [
418
        "Register" + derived_type + ".cpp"
419
        for derived_type in enabled_backends
420
    ] + [
421
        derived_type + "Functions.h"
422
        for derived_type in enabled_backends
423
        if derived_type in PT_BACKEND_HEADERS or derived_type in get_static_dispatch_backend()
424
    ] + [
425
        derived_type + "Functions_inl.h"
426
        for derived_type in enabled_backends
427
        if derived_type in PT_BACKEND_HEADERS or derived_type in get_static_dispatch_backend()
428
    ]
429

430
def gen_aten_files(
431
        name,
432
        extra_flags = {},
433
        visibility = [],
434
        compatible_with = [],
435
        apple_sdks = None):
436
    extra_params = []
437
    force_schema_registration = extra_flags.get("force_schema_registration", False)
438
    op_registration_allowlist = extra_flags.get("op_registration_allowlist", None)
439
    op_selection_yaml_path = extra_flags.get("op_selection_yaml_path", None)
440
    enabled_backends = extra_flags.get("enabled_backends", None)
441
    static_dispatch_backend = extra_flags.get("static_dispatch_backend", None)
442

443
    if force_schema_registration:
444
        extra_params.append("--force_schema_registration")
445
    if op_registration_allowlist != None and is_string(op_registration_allowlist):
446
        extra_params.append("--op_registration_whitelist")
447
        extra_params.append(op_registration_allowlist)
448
    if op_selection_yaml_path != None and is_string(op_selection_yaml_path):
449
        extra_params.append("--op_selection_yaml_path")
450
        extra_params.append(op_selection_yaml_path)
451
    if enabled_backends != None and is_list(enabled_backends):
452
        extra_params.append("--backend_whitelist")
453
        extra_params.extend(enabled_backends)
454
    if _get_enable_lightweight_dispatch():
455
        extra_params.append("--skip_dispatcher_op_registration")
456
    if static_dispatch_backend:
457
        extra_params.append("--static_dispatch_backend")
458
        extra_params.extend(static_dispatch_backend)
459
        backends = static_dispatch_backend
460
    else:
461
        backends = enabled_backends
462
    fb_xplat_genrule(
463
        name = name,
464
        default_outs = ["."],
465
        outs = get_aten_generated_files(backends),
466
        cmd = "$(exe {}torchgen:gen) ".format(ROOT_PATH) + " ".join([
467
            "--source-path $(location {}:aten_src_path)/aten/src/ATen".format(ROOT),
468
            "--install_dir $OUT",
469
            "--aoti_install_dir $OUT/torch/csrc/inductor/aoti_torch/generated"
470
        ] + extra_params),
471
        visibility = visibility,
472
        compatible_with = compatible_with,
473
        apple_sdks = apple_sdks,
474
    )
475

476
def gen_aten_unboxing_files(
477
        genrule_name,
478
        extra_flags = {}):
479
    extra_params = []
480
    op_selection_yaml_path = extra_flags.get("op_selection_yaml_path", None)
481
    op_registration_allowlist = extra_flags.get("op_registration_allowlist", None)
482
    if op_selection_yaml_path != None and is_string(op_selection_yaml_path):
483
        extra_params.append("--op_selection_yaml_path")
484
        extra_params.append(op_selection_yaml_path)
485
    if op_registration_allowlist != None and is_string(op_registration_allowlist):
486
        extra_params.append("--op_registration_allowlist")
487
        extra_params.append(op_registration_allowlist)
488

489
    fb_xplat_genrule(
490
        name = genrule_name,
491
        default_outs = ["."],
492
        outs = get_unboxing_generated_files(),
493
        cmd = "$(exe {}tools:gen_unboxing_bin) ".format(ROOT_PATH) + " ".join([
494
            "--source-path $(location {}:aten_src_path)/aten/src/ATen".format(ROOT),
495
            "--install_dir $OUT",
496
        ] + extra_params),
497
        visibility = ["PUBLIC"],
498
    )
499

500
def copy_template_registration_files(name, apple_sdks = None):
501
    cmd = []
502
    cmd_exe = []
503

504
    template_source_dict = get_template_source_dict()
505

506
    # Ideally, we would run one copy command for a single source directory along
507
    # with all its child directories, but it's somewhat hard to know if a directory
508
    # is a child of another just bu looking at the metadata (directory relative
509
    # path) that we currently have since 1 directory could look like a parent of
510
    # another and yet come from a different filegroup() rule.
511
    #
512
    for (path_prefix, file_paths) in template_source_dict.items():
513
        cmd.append("mkdir -p $OUT/{}".format(path_prefix))
514
        cmd_exe.append("md $OUT/{}".format(path_prefix))
515

516
        # Adding *.cpp is a workaround to prevent cp from thrown an error when it
517
        # encounters a directory (since -r was not specified). If files with an
518
        # extension other than .cpp need to be copied, then the command below
519
        # will not work and will need to be updated.
520
        #
521
        cmd.append("cp -f $(location {0}:templated_selective_build_srcs)/{1}/*.cpp $OUT/{1}/".format(ROOT, path_prefix))
522
        cmd_exe.append("robocopy /E $(location {0}:templated_selective_build_srcs)/{1} $OUT/{1}".format(ROOT, path_prefix))
523

524
    if NOT_OSS:
525
        for file_path in TEMPLATE_MASKRCNN_SOURCE_LIST:
526
            maskrcnn_file = "$(location //xplat/caffe2/fb/custom_ops/maskrcnn:templated_selective_build_srcs)/" + file_path
527
            cmd.append("cp -f " + maskrcnn_file + " $OUT")
528
            cmd_exe.append("copy " + maskrcnn_file + " $OUT")
529

530
    cmd.append("mkdir -p $OUT/aten/src/ATen")
531
    cmd_exe.append("md $OUT/aten/src/ATen")
532

533
    # NB: CUDA is skipped here because this is selective build and CUDA is not
534
    # supported for selective build
535
    for ufunc_file in aten_ufunc_generated_all_cpu_sources("$(location " + ROOT + ":gen_aten[{}])"):
536
        cmd.append("cp -f " + ufunc_file + " $OUT/aten/src/ATen")
537
        cmd_exe.append("copy " + ufunc_file + " $OUT/aten/src/ATen")
538

539
    if NOT_OSS:
540
        pvd_batch_box_cox_file = "$(location //xplat/caffe2/fb/custom_ops/batch_box_cox:templated_selective_build_srcs)/register_batch_box_cox_ops.cpp"
541
        cmd.append("cp -f " + pvd_batch_box_cox_file + " $OUT")
542
        cmd_exe.append("copy " + pvd_batch_box_cox_file + " $OUT")
543

544
    fb_xplat_genrule(
545
        name = name,
546
        cmd = " && ".join(cmd),
547
        cmd_exe = "@powershell -Command " + ("; ".join(cmd_exe)),
548
        outs = get_template_registration_files_outs(IS_OSS),
549
        default_outs = ["."],
550
        apple_sdks = apple_sdks,
551
    )
552

553
def get_feature_tracer_source_list():
554
    """
555
    Return just the Feature specific handlers used in the model tracer.
556
    """
557
    sources = []
558
    for s in torch_mobile_tracer_sources:
559
        if s.endswith("Tracer.cpp"):
560
            sources.append(s)
561
    return sources
562

563
def pt_operator_query_codegen(
564
        name,
565
        deps = [],
566
        train = False,
567
        enforce_traced_op_list = False,
568
        pt_allow_forced_schema_registration = True,
569
        compatible_with = [],
570
        apple_sdks = None):
571
    oplist_dir_name = name + "_pt_oplist"
572

573
    # @lint-ignore BUCKLINT
574
    fb_native.genrule(
575
        name = oplist_dir_name,
576
        cmd = ("$(exe {}tools:gen_oplist) ".format(ROOT_PATH) +
577
               "--model_file_list_path $(@query_outputs 'attrfilter(labels, pt_operator_library, deps(set({deps})))') " +
578
               ("" if enforce_traced_op_list else "--allow_include_all_overloads ") +
579
               "--output_dir $OUT ").format(deps = " ".join(["\"{}\"".format(d) for d in deps])),
580
        outs = get_gen_oplist_outs(),
581
        default_outs = ["."],
582
        compatible_with = compatible_with,
583
    )
584

585
    # Aten files
586
    aten_genrule = name + "_aten"
587
    extra_flags = {
588
        "enabled_backends": USED_PT_BACKENDS,
589
        "op_selection_yaml_path": "$(location :{}[selected_operators.yaml])".format(oplist_dir_name),
590
    }
591

592
    if train and pt_allow_forced_schema_registration:
593
        extra_flags["force_schema_registration"] = True
594

595
    unboxing_genrule = name + "_unboxing"
596
    if _get_enable_lightweight_dispatch():
597
        gen_aten_unboxing_files(
598
            unboxing_genrule,
599
            extra_flags = extra_flags,
600
        )
601

602
    static_dispatch_backend = get_static_dispatch_backend()
603
    if static_dispatch_backend:
604
        extra_flags["static_dispatch_backend"] = static_dispatch_backend
605

606
    gen_aten_files(
607
        aten_genrule,
608
        extra_flags = extra_flags,
609
        compatible_with = compatible_with,
610
        apple_sdks = apple_sdks,
611
    )
612

613
    # unboxing_wrappers files
614
    extra_params = [
615
        "--operators_yaml_path",
616
        "$(location :" + oplist_dir_name + "[selected_operators.yaml])",
617
    ]
618
    unboxing_and_autograd_genrule = name + "_unboxing_and_autograd"
619
    gen_aten_libtorch_files(
620
        unboxing_and_autograd_genrule,
621
        extra_params,
622
        compatible_with,
623
        apple_sdks = apple_sdks,
624
    )
625

626
    # Template runtime files (prim ops, etc)
627
    template_registration_genrule = name + "_template_registration"
628
    copy_template_registration_files(template_registration_genrule, apple_sdks = apple_sdks)
629

630
    # Files needed for metal
631
    if NOT_OSS:
632
        metal_genrule = name + "_metal"
633
        copy_metal(metal_genrule, apple_sdks = apple_sdks)
634

635
    srcs = get_aten_selective_cpp_rules(
636
        aten_genrule,
637
        static_dispatch_backend if static_dispatch_backend else USED_PT_BACKENDS,
638
    ) + get_template_registration_file_rules(template_registration_genrule, IS_OSS) + ([
639
        ":{}[autograd/generated/VariableType_0.cpp]".format(unboxing_and_autograd_genrule),
640
        ":{}[autograd/generated/VariableType_1.cpp]".format(unboxing_and_autograd_genrule),
641
        ":{}[autograd/generated/VariableType_2.cpp]".format(unboxing_and_autograd_genrule),
642
        ":{}[autograd/generated/VariableType_3.cpp]".format(unboxing_and_autograd_genrule),
643
        ":{}[autograd/generated/VariableType_4.cpp]".format(unboxing_and_autograd_genrule),
644
        ":{}[autograd/generated/ADInplaceOrViewType_0.cpp]".format(unboxing_and_autograd_genrule),
645
        ":{}[autograd/generated/ADInplaceOrViewType_1.cpp]".format(unboxing_and_autograd_genrule),
646
    ] if train else []) + ([
647
        ":{}[SupportedMobileModelsRegistration.cpp]".format(oplist_dir_name),
648
    ] if NOT_OSS else [])
649

650
    headers = {
651
        "selected_mobile_ops.h": ":{}[selected_mobile_ops.h]".format(oplist_dir_name),
652
    }
653

654
    if _get_enable_lightweight_dispatch():
655
        srcs.extend([
656
            ":{}[UnboxingFunctions_0.cpp]".format(unboxing_genrule),
657
            ":{}[UnboxingFunctions_1.cpp]".format(unboxing_genrule),
658
            ":{}[UnboxingFunctions_2.cpp]".format(unboxing_genrule),
659
            ":{}[UnboxingFunctions_3.cpp]".format(unboxing_genrule),
660
            ":{}[UnboxingFunctions_4.cpp]".format(unboxing_genrule),
661
            ":{}[RegisterCodegenUnboxedKernels_0.cpp]".format(unboxing_genrule),
662
            ":{}[RegisterCodegenUnboxedKernels_1.cpp]".format(unboxing_genrule),
663
            ":{}[RegisterCodegenUnboxedKernels_2.cpp]".format(unboxing_genrule),
664
            ":{}[RegisterCodegenUnboxedKernels_3.cpp]".format(unboxing_genrule),
665
            ":{}[RegisterCodegenUnboxedKernels_4.cpp]".format(unboxing_genrule),
666
            ":{}[RegisterCodegenUnboxedKernels_5.cpp]".format(unboxing_genrule),
667
            ":{}[RegisterCodegenUnboxedKernels_6.cpp]".format(unboxing_genrule),
668
            ":{}[RegisterCodegenUnboxedKernels_7.cpp]".format(unboxing_genrule),
669
            ":{}[RegisterCodegenUnboxedKernels_8.cpp]".format(unboxing_genrule),
670
            ":{}[RegisterCodegenUnboxedKernels_9.cpp]".format(unboxing_genrule),
671
        ])
672
        headers["UnboxingFunctions.h"] = ":{}[UnboxingFunctions.h]".format(unboxing_genrule)
673
    return {"headers": headers, "srcs": srcs}
674

675
def gen_aten_libtorch_files(name, extra_params = [], compatible_with = [], apple_sdks = None):
676
    fb_xplat_genrule(
677
        name = name,
678
        outs = get_generate_code_bin_outs(),
679
        default_outs = ["."],
680
        bash = "mkdir -p tools && " +
681
               "$(exe {}tools:generate_code_bin) ".format(ROOT_PATH) + " ".join(
682
            # Mobile build only needs libtorch - skip python bindings for now, except
683
            # for ovrsource, which needs Python bindings.
684
            (["--subset libtorch"] if not is_arvr_mode() else []) + [
685
                "--native-functions-path $(location {}:aten_src_path)/aten/src/ATen/native/native_functions.yaml".format(ROOT),
686
                "--tags-path $(location {}:aten_src_path)/aten/src/ATen/native/tags.yaml".format(ROOT),
687
                "--install_dir $OUT",
688
            ] + extra_params,
689
        ),
690
        cmd_exe = "@powershell -Command New-Item -Path tools -ItemType Directory -Force; " +
691
                  "$(exe {}tools:generate_code_bin) ".format(ROOT_PATH) + " ".join(
692
            # Mobile build only needs libtorch - skip python bindings for now, except
693
            # for ovrsource, which needs Python bindings.
694
            (["--subset libtorch"] if not is_arvr_mode() else []) + [
695
                "--native-functions-path $(location {}:aten_src_path)/aten/src/ATen/native/native_functions.yaml".format(ROOT),
696
                "--tags-path $(location {}:aten_src_path)/aten/src/ATen/native/tags.yaml".format(ROOT),
697
                "--install_dir $OUT",
698
            ] + extra_params,
699
        ),
700
        compatible_with = compatible_with,
701
        apple_sdks = apple_sdks,
702
    )
703

704
def vulkan_spv_shader_library(name, spv_filegroup):
705
    genrule_cmd = [
706
        "$(exe //xplat/caffe2/tools:gen_aten_vulkan_spv_bin)",
707
        "--glsl-paths $(location {})".format(spv_filegroup),
708
        "--output-path $OUT --env FLOAT_IMAGE_FORMAT={}".format(get_glsl_image_format()),
709
        "--glslc-path=$(exe //xplat/caffe2/fb/vulkan/dotslash:glslc)",
710
        "--tmp-dir-path=$TMP",
711
    ]
712

713
    genrule_name = "gen_{}_cpp".format(name)
714
    fb_xplat_genrule(
715
        name = "gen_{}_cpp".format(name),
716
        outs = {
717
            "{}.cpp".format(name): ["spv.cpp"],
718
        },
719
        cmd = " ".join(genrule_cmd),
720
        default_outs = ["."],
721
        labels = ["uses_dotslash"],
722
    )
723

724
    fb_xplat_cxx_library(
725
        name = name,
726
        srcs = [
727
            ":{}[{}.cpp]".format(genrule_name, name),
728
        ],
729
        # Static initialization is used to register shaders to the global shader registry,
730
        # therefore link_whole must be True to make sure unused symbols are not discarded.
731
        # @lint-ignore BUCKLINT: Avoid `link_whole=True`
732
        link_whole = True,
733
        # Define a soname that can be used for dynamic loading in Java, Python, etc.
734
        soname = "lib{}.$(ext)".format(name),
735
        visibility = ["PUBLIC"],
736
        exported_deps = [
737
            "//xplat/caffe2:torch_vulkan_api",
738
        ],
739
    )
740

741
def copy_metal(name, apple_sdks = None):
742
    cmd = []
743
    cmd_exe = []
744
    metal_source_dict = get_metal_source_dict()
745

746
    # Copy all source files over to bring them into the per app build
747
    for path_prefix in sorted(metal_source_dict.keys()):
748
        cmd.append("mkdir -p $OUT/{}".format(path_prefix))
749
        cmd_exe.append("mkdir -Force $OUT/{0}".format(path_prefix))
750

751
        # Not every directory has a mm or cpp file so '2>/dev/null || :' are tricks to suppress the error messages and codes.
752
        cmd.append("cp -f {0}/{1}/*.mm $OUT/{1}/ 2>/dev/null || :".format("$(location //xplat/caffe2:metal_build_srcs)", path_prefix))
753
        cmd.append("cp -f {0}/{1}/*.cpp $OUT/{1}/ 2>/dev/null || :".format("$(location //xplat/caffe2:metal_build_srcs)", path_prefix))
754

755
        # Robocopy has a default success code of 1 which buck treats as failure so the echo masks that problem
756
        cmd_exe.append("(robocopy /E /NFL /NDL /NJH /NJS {0}/{1} $OUT/{1}) || ECHO robocopy failed".format("$(location //xplat/caffe2:metal_build_srcs)", path_prefix))
757

758
    # Metal custom ops currently have to be brought into selective build because they directly reference metal ops instead of
759
    # going through the dispatcher. There is some weird issues with the genrule and these files locations on windows though, so
760
    # for now we simply skip building them for windows where they very likely arent needed anyway.
761
    # Metal MaskRCNN custom op
762
    for full_path in METAL_MASKRCNN_SOURCE_LIST:
763
        path_prefix = paths.dirname(full_path)
764
        cmd.append("mkdir -p $OUT/{}".format(path_prefix))
765
        cmd.append("cp -f {0}/{1}/*.mm $OUT/{1}/ 2>/dev/null || :".format("$(location //xplat/caffe2/fb/metal:metal_maskrcnn_sources)", path_prefix))
766

767
    # Unet Metal Prepack Custom op
768
    unet_metal_prepack_file = "$(location //xplat/caffe2/fb/custom_ops/unet_metal_prepack:unet_metal_prepack_sources)"
769
    cmd.append("cp -f " + unet_metal_prepack_file + "/unet_metal_prepack.cpp" + " $OUT")
770
    cmd.append("cp -f " + unet_metal_prepack_file + "/unet_metal_prepack.mm" + " $OUT")
771

772
    fb_xplat_genrule(
773
        name = name,
774
        cmd = " && ".join(cmd),
775
        cmd_exe = "@powershell -Command " + ("; ".join(cmd_exe)),
776
        # due to an obscure bug certain custom ops werent being copied correctly on windows. ARVR also sometimes builds android targets on windows,
777
        # so we just exclude those targets from being copied for those platforms (They end up uncompiled anyway).
778
        outs = select({
779
            "DEFAULT": get_metal_registration_files_outs(),
780
            "ovr_config//os:android": get_metal_registration_files_outs_windows(),
781
            "ovr_config//os:windows": get_metal_registration_files_outs_windows(),
782
        }),
783
        default_outs = ["."],
784
        apple_sdks = apple_sdks,
785
    )
786

787
def get_pt_operator_registry_dict(
788
        name,
789
        deps = [],
790
        train = False,
791
        labels = [],
792
        env = [],
793
        template_select = True,
794
        enforce_traced_op_list = False,
795
        pt_allow_forced_schema_registration = True,
796
        enable_flatbuffer = False,
797
        **kwargs):
798
    code_gen_files = pt_operator_query_codegen(
799
        name,
800
        deps = deps,
801
        train = train,
802
        enforce_traced_op_list = enforce_traced_op_list,
803
        pt_allow_forced_schema_registration = pt_allow_forced_schema_registration,
804
        compatible_with = kwargs.get("compatible_with", []),
805
        apple_sdks = kwargs.get("apple_sdks"),
806
    )
807

808
    return dict(
809
        srcs = code_gen_files["srcs"],
810
        linker_flags = [
811
            "-Wl,--no-as-needed",
812
        ],
813
        # @lint-ignore BUCKLINT link_whole
814
        link_whole = True,
815
        soname = "libtorch-code-gen.$(ext)",
816
        header_namespace = "ATen",
817
        compiler_flags = get_aten_compiler_flags(),
818
        exported_headers = code_gen_files["headers"],
819
        exported_preprocessor_flags = get_aten_preprocessor_flags() + (["-DTEMPLATE_SELECTIVE_BUILD"] if template_select else []),
820
        headers = kwargs.pop("headers", []),
821
        labels = kwargs.pop("labels", []) + [
822
            # This library has multiple sources with the same file name
823
            # and does not work with Buck filegroup used in bad practices.
824
            # Opt out of the bad practices check with the below label.
825
            "bad_practices_ignore_override",
826
            "pt_operator_registry",
827
        ],
828
        deps = [
829
            # need absolute path here
830
            ROOT + ":torch_mobile_core",
831
            ROOT + ":aten_cpu",
832
            ROOT + ":aten_metal_prepack_header",
833
            third_party("glog"),
834
            C10,
835
        ] + ([ROOT + ":torch_mobile_train"] if train else []),
836
        **kwargs
837
    )
838

839
# these targets are shared by internal and OSS BUCK
840
def define_buck_targets(
841
        aten_default_args = dict(),
842
        pt_xplat_cxx_library = fb_xplat_cxx_library,
843
        c2_fbandroid_xplat_compiler_flags = [],
844
        labels = []):
845
    # @lint-ignore BUCKLINT
846
    fb_native.filegroup(
847
        name = "metal_build_srcs",
848
        srcs = glob(METAL_SOURCE_LIST),
849
        visibility = [
850
            "PUBLIC",
851
        ],
852
    )
853

854
    # @lint-ignore BUCKLINT
855
    fb_native.filegroup(
856
        name = "templated_selective_build_srcs",
857
        # NB: no glob here, there are generated targets in this list!
858
        srcs = glob(TEMPLATE_SOURCE_LIST) + aten_ufunc_generated_all_cpu_sources(":gen_aten[{}]"),
859
        visibility = [
860
            "PUBLIC",
861
        ],
862
    )
863

864
    fb_xplat_cxx_library(
865
        name = "aten_header",
866
        header_namespace = "",
867
        exported_headers = subdir_glob([
868
            # ATen Core
869
            ("aten/src", "ATen/core/**/*.h"),
870
            ("aten/src", "ATen/ops/*.h"),
871
            # ATen Base
872
            ("aten/src", "ATen/*.h"),
873
            ("aten/src", "ATen/cpu/**/*.h"),
874
            ("aten/src", "ATen/detail/*.h"),
875
            ("aten/src", "ATen/functorch/**/*.h"),
876
            ("aten/src", "ATen/quantized/*.h"),
877
            ("aten/src", "ATen/vulkan/*.h"),
878
            ("aten/src", "ATen/metal/*.h"),
879
            ("aten/src", "ATen/nnapi/*.h"),
880
            # ATen Native
881
            ("aten/src", "ATen/native/*.h"),
882
            ("aten/src", "ATen/native/ao_sparse/quantized/cpu/*.h"),
883
            ("aten/src", "ATen/native/cpu/**/*.h"),
884
            ("aten/src", "ATen/native/sparse/*.h"),
885
            ("aten/src", "ATen/native/nested/*.h"),
886
            ("aten/src", "ATen/native/quantized/*.h"),
887
            ("aten/src", "ATen/native/quantized/cpu/*.h"),
888
            ("aten/src", "ATen/native/transformers/*.h"),
889
            ("aten/src", "ATen/native/ufunc/*.h"),
890
            ("aten/src", "ATen/native/utils/*.h"),
891
            ("aten/src", "ATen/native/vulkan/ops/*.h"),
892
            ("aten/src", "ATen/native/xnnpack/*.h"),
893
            ("aten/src", "ATen/mps/*.h"),
894
            ("aten/src", "ATen/native/mps/*.h"),
895
            # Remove the following after modifying codegen for mobile.
896
            ("aten/src", "ATen/mkl/*.h"),
897
            ("aten/src", "ATen/native/mkl/*.h"),
898
            ("aten/src", "ATen/native/mkldnn/*.h"),
899
        ]),
900
        visibility = ["PUBLIC"],
901
        labels = labels,
902
    )
903

904
    fb_xplat_cxx_library(
905
        name = "aten_vulkan_header",
906
        header_namespace = "",
907
        exported_headers = subdir_glob([
908
            ("aten/src", "ATen/native/vulkan/*.h"),
909
            ("aten/src", "ATen/native/vulkan/ops/*.h"),
910
            ("aten/src", "ATen/vulkan/*.h"),
911
        ]),
912
        labels = labels,
913
        visibility = ["PUBLIC"],
914
    )
915

916
    fb_xplat_cxx_library(
917
        name = "jit_core_headers",
918
        header_namespace = "",
919
        exported_headers = subdir_glob([("", x) for x in jit_core_headers]),
920
        labels = labels,
921
    )
922

923
    fb_xplat_cxx_library(
924
        name = "torch_headers",
925
        header_namespace = "",
926
        exported_headers = subdir_glob(
927
            [
928
                ("torch/csrc/api/include", "torch/**/*.h"),
929
                ("", "torch/csrc/**/*.h"),
930
                ("", "torch/script.h"),
931
                ("", "torch/library.h"),
932
                ("", "torch/custom_class.h"),
933
                ("", "torch/custom_class_detail.h"),
934
                # Add again due to namespace difference from aten_header.
935
                ("", "aten/src/ATen/*.h"),
936
                ("", "aten/src/ATen/functorch/**/*.h"),
937
                ("", "aten/src/ATen/quantized/*.h"),
938
            ],
939
            exclude = [
940
                # Don't need on mobile.
941
                "torch/csrc/Exceptions.h",
942
                "torch/csrc/python_headers.h",
943
                "torch/csrc/jit/serialization/mobile_bytecode_generated.h",
944
            ],
945
        ),
946
        labels = labels,
947
        visibility = ["PUBLIC"],
948
        deps = [
949
            ":generated-version-header",
950
        ],
951
    )
952

953
    fb_xplat_cxx_library(
954
        name = "aten_test_header",
955
        header_namespace = "",
956
        exported_headers = subdir_glob([
957
            ("aten/src", "ATen/test/*.h"),
958
        ]),
959
    )
960

961
    fb_xplat_cxx_library(
962
        name = "aten_metal_prepack_header",
963
        header_namespace = "",
964
        exported_headers = subdir_glob([
965
            ("aten/src", "ATen/native/metal/MetalPrepackOpContext.h"),
966
        ]),
967
        labels = labels,
968
        visibility = ["PUBLIC"],
969
    )
970

971
    fb_xplat_cxx_library(
972
        name = "torch_mobile_headers",
973
        header_namespace = "",
974
        exported_headers = subdir_glob(
975
            [
976
                ("", "torch/csrc/jit/mobile/*.h"),
977
            ],
978
        ),
979
        labels = labels,
980
        visibility = ["PUBLIC"],
981
    )
982

983
    fb_xplat_cxx_library(
984
        name = "generated_aten_config_header",
985
        header_namespace = "ATen",
986
        exported_headers = {
987
            "Config.h": ":generate_aten_config[Config.h]",
988
        },
989
        labels = labels,
990
    )
991

992
    fb_xplat_cxx_library(
993
        name = "generated-autograd-headers",
994
        header_namespace = "torch/csrc/autograd/generated",
995
        exported_headers = {
996
            "Functions.h": ":gen_aten_libtorch[autograd/generated/Functions.h]",
997
            "VariableType.h": ":gen_aten_libtorch[autograd/generated/VariableType.h]",
998
            "variable_factories.h": ":gen_aten_libtorch[autograd/generated/variable_factories.h]",
999
            "ViewFuncs.h": ":gen_aten_libtorch[autograd/generated/ViewFuncs.h]",
1000
            # Don't build python bindings on mobile.
1001
            #"python_functions.h",
1002
        },
1003
        labels = labels,
1004
        visibility = ["PUBLIC"],
1005
    )
1006

1007
    fb_xplat_cxx_library(
1008
        name = "generated-version-header",
1009
        header_namespace = "torch",
1010
        exported_headers = {
1011
            "version.h": ":generate-version-header[version.h]",
1012
        },
1013
        labels = labels,
1014
    )
1015

1016
    # @lint-ignore BUCKLINT
1017
    fb_native.genrule(
1018
        name = "generate-version-header",
1019
        srcs = [
1020
            "torch/csrc/api/include/torch/version.h.in",
1021
            "version.txt",
1022
        ],
1023
        cmd = "$(exe {}tools:gen-version-header) ".format(ROOT_PATH) + " ".join([
1024
            "--template-path",
1025
            "torch/csrc/api/include/torch/version.h.in",
1026
            "--version-path",
1027
            "version.txt",
1028
            "--output-path",
1029
            "$OUT/version.h",
1030
        ]),
1031
        outs = {
1032
            "version.h": ["version.h"],
1033
        },
1034
        default_outs = ["."],
1035
    )
1036

1037
    # @lint-ignore BUCKLINT
1038
    fb_native.filegroup(
1039
        name = "aten_src_path",
1040
        srcs = [
1041
            "aten/src/ATen/native/native_functions.yaml",
1042
            "aten/src/ATen/native/tags.yaml",
1043
        ] + glob(["aten/src/ATen/templates/*"]),
1044
        visibility = [
1045
            "PUBLIC",
1046
        ],
1047
    )
1048

1049
    fb_xplat_cxx_library(
1050
        name = "common_core",
1051
        srcs = [
1052
            "caffe2/core/common.cc",
1053
        ],
1054
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1055
        compiler_flags = get_pt_compiler_flags(),
1056
        labels = labels,
1057
        # @lint-ignore BUCKLINT link_whole
1058
        link_whole = True,
1059
        visibility = ["PUBLIC"],
1060
        windows_preferred_linkage = "static" if is_arvr_mode() else None,
1061
        deps = [
1062
            ":caffe2_headers",
1063
            C10,
1064
        ],
1065
    )
1066

1067
    # @lint-ignore BUCKLINT
1068
    fb_native.genrule(
1069
        name = "generate_aten_config",
1070
        srcs = [
1071
            "aten/src/ATen/Config.h.in",
1072
        ],
1073
        cmd = "$(exe {}tools:substitute) ".format(ROOT_PATH) + " ".join([
1074
            "--install_dir",
1075
            "$OUT",
1076
            "--input-file",
1077
            "aten/src/ATen/Config.h.in",
1078
            "--output-file",
1079
            "Config.h",
1080
            "--replace",
1081
            "@AT_MKLDNN_ENABLED@",
1082
            "ATEN_MKLDNN_ENABLED_FBXPLAT",
1083
            "--replace",
1084
            "@AT_MKLDNN_ACL_ENABLED@",
1085
            "ATEN_MKLDNN_ACL_ENABLED_FBXPLAT",
1086
            "--replace",
1087
            "@AT_MKL_ENABLED@",
1088
            "ATEN_MKL_ENABLED_FBXPLAT",
1089
            "--replace",
1090
            "@AT_MKL_SEQUENTIAL@",
1091
            "ATEN_MKL_SEQUENTIAL_FBXPLAT",
1092
            "--replace",
1093
            "@AT_POCKETFFT_ENABLED@",
1094
            "1",
1095
            "--replace",
1096
            "@AT_NNPACK_ENABLED@",
1097
            "ATEN_NNPACK_ENABLED_FBXPLAT",
1098
            "--replace",
1099
            "@CAFFE2_STATIC_LINK_CUDA_INT@",
1100
            "CAFFE2_STATIC_LINK_CUDA_FBXPLAT",
1101
            "--replace",
1102
            "@AT_BUILD_WITH_BLAS@",
1103
            "USE_BLAS_FBXPLAT",
1104
            "--replace",
1105
            "@AT_PARALLEL_OPENMP@",
1106
            "AT_PARALLEL_OPENMP_FBXPLAT",
1107
            "--replace",
1108
            "@AT_PARALLEL_NATIVE@",
1109
            "AT_PARALLEL_NATIVE_FBXPLAT",
1110
            "--replace",
1111
            "@AT_BUILD_WITH_LAPACK@",
1112
            "USE_LAPACK_FBXPLAT",
1113
            "--replace",
1114
            "@AT_BLAS_F2C@",
1115
            "AT_BLAS_F2C_FBXPLAT",
1116
            "--replace",
1117
            "@AT_BLAS_USE_CBLAS_DOT@",
1118
            "AT_BLAS_USE_CBLAS_DOT_FBXPLAT",
1119
        ]),
1120
        outs = {
1121
            "Config.h": ["Config.h"],
1122
        },
1123
        default_outs = ["."],
1124
    )
1125

1126
    gen_aten_files(
1127
        name = "gen_aten",
1128
        extra_flags = get_aten_codegen_extra_params(USED_PT_BACKENDS),
1129
        visibility = ["PUBLIC"],
1130
    )
1131

1132
    gen_aten_libtorch_files(name = "gen_aten_libtorch")
1133

1134
    gen_aten_libtorch_files(
1135
        name = "gen_aten_libtorch_lite",
1136
        extra_params = get_jit_codegen_params(),
1137
    )
1138

1139
    fb_xplat_cxx_library(
1140
        name = "generated_aten_headers_cpu",
1141
        header_namespace = "ATen",
1142
        exported_headers = get_aten_static_dispatch_backend_headers({
1143
            "CPUFunctions.h": ":gen_aten[CPUFunctions.h]",
1144
            "CPUFunctions_inl.h": ":gen_aten[CPUFunctions_inl.h]",
1145
            "CompositeExplicitAutogradFunctions.h": ":gen_aten[CompositeExplicitAutogradFunctions.h]",
1146
            "CompositeExplicitAutogradFunctions_inl.h": ":gen_aten[CompositeExplicitAutogradFunctions_inl.h]",
1147
            "CompositeExplicitAutogradNonFunctionalFunctions.h": ":gen_aten[CompositeExplicitAutogradNonFunctionalFunctions.h]",
1148
            "CompositeExplicitAutogradNonFunctionalFunctions_inl.h": ":gen_aten[CompositeExplicitAutogradNonFunctionalFunctions_inl.h]",
1149
            "CompositeImplicitAutogradFunctions.h": ":gen_aten[CompositeImplicitAutogradFunctions.h]",
1150
            "CompositeImplicitAutogradFunctions_inl.h": ":gen_aten[CompositeImplicitAutogradFunctions_inl.h]",
1151
            "CompositeImplicitAutogradNestedTensorFunctions.h": ":gen_aten[CompositeImplicitAutogradNestedTensorFunctions.h]",
1152
            "CompositeImplicitAutogradNestedTensorFunctions_inl.h": ":gen_aten[CompositeImplicitAutogradNestedTensorFunctions_inl.h]",
1153
            "FunctionalInverses.h": ":gen_aten[FunctionalInverses.h]",
1154
            "Functions.h": ":gen_aten[Functions.h]",
1155
            "MethodOperators.h": ":gen_aten[MethodOperators.h]",
1156
            "NativeFunctions.h": ":gen_aten[NativeFunctions.h]",
1157
            "NativeMetaFunctions.h": ":gen_aten[NativeMetaFunctions.h]",
1158
            "Operators.h": ":gen_aten[Operators.h]",
1159
            "RedispatchFunctions.h": ":gen_aten[RedispatchFunctions.h]",
1160
            "core/TensorBody.h": ":gen_aten[core/TensorBody.h]",
1161
            "core/aten_interned_strings.h": ":gen_aten[core/aten_interned_strings.h]",
1162
            "core/enum_tag.h": ":gen_aten[core/enum_tag.h]",
1163
        }),
1164
        labels = labels,
1165
    )
1166

1167
    fb_xplat_cxx_library(
1168
        name = "torch_mobile_observer",
1169
        srcs = [
1170
            "torch/csrc/jit/mobile/observer.cpp",
1171
        ] + ([] if IS_OSS else ["torch/fb/observers/MobileObserverUtil.cpp"]),
1172
        compiler_flags = ["-fexceptions"],
1173
        header_namespace = "",
1174
        exported_headers = subdir_glob(
1175
            [
1176
                ("", "torch/csrc/jit/mobile/observer.h"),
1177
            ] + ([] if IS_OSS else [
1178
                ("", "torch/fb/observers/ObserverUtil.h"),
1179
                ("", "torch/fb/observers/MobileObserverUtil.h"),
1180
            ]),
1181
        ),
1182
        fbobjc_compiler_flags = [
1183
            "-Wno-missing-prototypes",
1184
        ],
1185
        labels = labels,
1186
        visibility = ["PUBLIC"],
1187
        deps = [
1188
            C10,
1189
        ],
1190
    )
1191

1192
    # Base library shared by lite-interpreter and full-jit.
1193
    pt_xplat_cxx_library(
1194
        name = "torch_common",
1195
        srcs = core_sources_common,
1196
        compiler_flags = get_pt_compiler_flags(),
1197
        exported_preprocessor_flags = get_pt_preprocessor_flags(),
1198
        # @lint-ignore BUCKLINT link_whole
1199
        link_whole = True,
1200
        visibility = ["PUBLIC"],
1201
        deps = [
1202
            ":aten_cpu",
1203
            ":generated-autograd-headers",
1204
            ":torch_headers",
1205
            C10,
1206
            third_party("libkineto_headers"),
1207
        ],
1208
    )
1209

1210
    pt_xplat_cxx_library(
1211
        name = "torch_mobile_deserialize_common",
1212
        srcs = [
1213
            "torch/csrc/jit/mobile/parse_bytecode.cpp",
1214
            "torch/csrc/jit/mobile/parse_operators.cpp",
1215
            "torch/csrc/jit/mobile/upgrader_mobile.cpp",
1216
            "torch/csrc/jit/serialization/import_read.cpp",
1217
            "torch/csrc/jit/serialization/unpickler.cpp",
1218
        ],
1219
        header_namespace = "",
1220
        exported_headers = [
1221
            "torch/csrc/jit/serialization/import_read.h",
1222
            "torch/csrc/jit/serialization/unpickler.h",
1223
        ],
1224
        compiler_flags = get_pt_compiler_flags(),
1225
        exported_preprocessor_flags = get_pt_preprocessor_flags(),
1226
        extra_flags = {
1227
            "fbandroid_compiler_flags": ["-frtti"],
1228
        },
1229
        # torch_mobile_deserialize brings in sources neccessary to read a module
1230
        # which depends on mobile module definition
1231
        # link_whole is enable so that all symbols neccessary for mobile module are compiled
1232
        # instead of only symbols used while loading; this prevents symbol
1233
        # found definied in runtime
1234
        # @lint-ignore BUCKLINT link_whole
1235
        link_whole = True,
1236
        linker_flags = ["-Wl,--no-as-needed"],
1237
        visibility = ["PUBLIC"],
1238
        exported_deps = [
1239
            ":aten_cpu",
1240
            ":caffe2_headers",
1241
            ":caffe2_serialize",
1242
            ":torch_common",
1243
            ":torch_headers",
1244
            ":torch_mobile_headers",
1245
            ":torch_mobile_module",
1246
            ":torch_mobile_observer",
1247
            C10,
1248
        ],
1249
    )
1250

1251
    pt_xplat_cxx_library(
1252
        name = "torch_mobile_module",
1253
        srcs = [
1254
            "torch/csrc/jit/mobile/function.cpp",
1255
            "torch/csrc/jit/mobile/interpreter.cpp",
1256
            "torch/csrc/jit/mobile/module.cpp",
1257
        ],
1258
        header_namespace = "",
1259
        exported_headers = [
1260
        ],
1261
        compiler_flags = get_pt_compiler_flags(),
1262
        exported_preprocessor_flags = get_pt_preprocessor_flags() + (["-DSYMBOLICATE_MOBILE_DEBUG_HANDLE"] if get_enable_eager_symbolication() else []),
1263
        extra_flags = {
1264
            "fbandroid_compiler_flags": ["-frtti"],
1265
        },
1266
        # @lint-ignore BUCKLINT link_whole
1267
        link_whole = True,
1268
        linker_flags = [
1269
            "-Wl,--no-as-needed",
1270
        ],
1271
        visibility = ["PUBLIC"],
1272
        exported_deps = [
1273
            ":aten_cpu",
1274
            ":caffe2_headers",
1275
            ":torch_common",
1276
            ":torch_headers",
1277
            ":torch_mobile_headers",
1278
            ":torch_mobile_observer",
1279
            C10,
1280
        ],
1281
    )
1282

1283
    pt_xplat_cxx_library(
1284
        name = "torch_mobile_debug_symbolication",
1285
        srcs = [
1286
            # included in aten_cpu "torch/csrc/jit/frontend/source_range.cpp",
1287
            "torch/csrc/jit/ir/scope.cpp",
1288
            "torch/csrc/jit/mobile/debug_info.cpp",
1289
            "torch/csrc/jit/serialization/callstack_debug_info_serialization.cpp",
1290
            "torch/csrc/jit/serialization/source_range_serialization.cpp",
1291
            "torch/csrc/jit/serialization/pickle.cpp",
1292
            # pickler.cpp doesn't seem to be needed.
1293
            # "torch/csrc/jit/serialization/pickler.cpp",
1294
            # included in core_sources_common "torch/csrc/jit/serialization/unpickler.cpp",
1295
        ],
1296
        compiler_flags = get_pt_compiler_flags(),
1297
        exported_preprocessor_flags = get_pt_preprocessor_flags(),
1298
        header_namespace = "",
1299
        # @lint-ignore BUCKLINT link_whole
1300
        link_whole = True,
1301
        linker_flags = [
1302
            "-Wl,--no-as-needed",
1303
        ],
1304
        visibility = ["PUBLIC"],
1305
        deps = [
1306
            ":torch_mobile_deserialize",
1307
        ],
1308
        exported_deps = [
1309
            ":torch_common",
1310
        ],
1311
    )
1312

1313
    pt_xplat_cxx_library(
1314
        name = "torch_model_tracer",
1315
        srcs = [
1316
            "torch/csrc/jit/mobile/model_tracer/TracerRunner.cpp",
1317
        ] + get_feature_tracer_source_list(),
1318
        header_namespace = "",
1319
        compiler_flags = get_pt_compiler_flags(),
1320
        exported_preprocessor_flags = get_pt_preprocessor_flags() + (["-DSYMBOLICATE_MOBILE_DEBUG_HANDLE"] if get_enable_eager_symbolication() else []),
1321
        # @lint-ignore BUCKLINT link_whole
1322
        link_whole = True,
1323
        linker_flags = [
1324
            "-Wl,--no-as-needed",
1325
        ],
1326
        visibility = ["PUBLIC"],
1327
        deps = [
1328
            ":generated-autograd-headers",
1329
            ":torch_mobile_deserialize",
1330
            ":torch_mobile_headers",
1331
            ":torch_mobile_observer",
1332
        ] + ([] if IS_OSS else ["//xplat/folly:molly"]),
1333
        exported_deps = [
1334
            ":aten_cpu",
1335
            ":torch_common",
1336
        ] + ([] if IS_OSS else [
1337
            "//xplat/caffe2/fb/custom_ops/batch_box_cox:batch_box_cox",
1338
            "//xplat/caffe2/fb/custom_ops/maskrcnn:maskrcnn",
1339
        ]),
1340
    )
1341

1342
    pt_xplat_cxx_library(
1343
        name = "torch_mobile_deserialize",
1344
        srcs = [
1345
            "torch/csrc/jit/mobile/import.cpp",
1346
            "torch/csrc/jit/mobile/flatbuffer_loader.cpp",
1347
        ],
1348
        compiler_flags = get_pt_compiler_flags(),
1349
        exported_preprocessor_flags = get_pt_preprocessor_flags() + (["-DFB_XPLAT_BUILD"] if not IS_OSS else []),
1350
        header_namespace = "",
1351
        exported_headers = [
1352
            "torch/csrc/jit/mobile/import.h",
1353
            "torch/csrc/jit/mobile/flatbuffer_loader.h",
1354
        ],
1355
        # torch_mobile_deserialize brings in sources neccessary to read a module
1356
        # which depends on mobile module definition
1357
        # link_whole is enable so that all symbols neccessary for mobile module are compiled
1358
        # instead of only symbols used while loading; this prevents symbol
1359
        # found definied in runtime
1360
        # @lint-ignore BUCKLINT link_whole
1361
        link_whole = True,
1362
        linker_flags = [
1363
            "-Wl,--no-as-needed",
1364
        ],
1365
        visibility = ["PUBLIC"],
1366
        exported_deps = [
1367
            ":aten_cpu",
1368
            ":caffe2_headers",
1369
            ":caffe2_serialize",
1370
            ":torch_common",
1371
            ":torch_headers",
1372
            ":torch_mobile_headers",
1373
            ":torch_mobile_module",
1374
            ":torch_mobile_observer",
1375
            ":torch_mobile_deserialize_common",
1376
            ":mobile_bytecode",
1377
            C10,
1378
        ],
1379
    )
1380

1381
    pt_xplat_cxx_library(
1382
        name = "torch_mobile_core",
1383
        srcs = [],
1384
        header_namespace = "",
1385
        exported_headers = [],
1386
        compiler_flags = get_pt_compiler_flags(),
1387
        exported_preprocessor_flags = get_pt_preprocessor_flags() + (["-DSYMBOLICATE_MOBILE_DEBUG_HANDLE"] if get_enable_eager_symbolication() else []),
1388
        # torch_mobile_core brings in sources neccessary to read and run a module
1389
        # link_whole is enabled so that all symbols linked
1390
        # operators, registerations and other few symbols are need in runtime
1391
        # @lint-ignore BUCKLINT link_whole
1392
        link_whole = True,
1393
        linker_flags = [
1394
            "-Wl,--no-as-needed",
1395
        ],
1396
        visibility = ["PUBLIC"],
1397
        deps = [
1398
            ":generated-autograd-headers",
1399
            ":torch_mobile_headers",
1400
            ":torch_mobile_observer",
1401
        ],
1402
        exported_deps = [
1403
            ":aten_cpu",
1404
            ":torch_common",
1405
            ":torch_mobile_deserialize",
1406
            ":torch_supported_mobile_models",
1407
        ],
1408
    )
1409

1410
    pt_xplat_cxx_library(
1411
        name = "torch_mobile_core_pickle_and_flatbuffer",
1412
        compiler_flags = get_pt_compiler_flags(),
1413
        exported_preprocessor_flags = get_pt_preprocessor_flags(),
1414
        visibility = ["PUBLIC"],
1415
        exported_deps = [
1416
            ":flatbuffers_mobile",
1417
            ":torch_mobile_core",
1418
        ],
1419
    )
1420

1421
    pt_xplat_cxx_library(
1422
        name = "torch_cpp_cpu",
1423
        srcs = torch_cpp_srcs,
1424
        headers = native.glob(["torch/csrc/api/include/**/*.h"]) + ["torch/script.h"],
1425
        compiler_flags = get_pt_compiler_flags(),
1426
        exported_preprocessor_flags = get_pt_preprocessor_flags(),
1427
        visibility = ["PUBLIC"],
1428
        exported_deps = [
1429
            ":torch",
1430
            ":torch_mobile_deserialize_common",  # for torch/csrc/api/src/serialize/input-archive.cpp
1431
        ],
1432
    )
1433

1434
    pt_xplat_cxx_library(
1435
        name = "torch_core",
1436
        srcs = core_sources_full_mobile_no_backend_interface_xplat,
1437
        compiler_flags = get_pt_compiler_flags(),
1438
        exported_preprocessor_flags = get_pt_preprocessor_flags(),
1439
        visibility = [
1440
            "//xplat/caffe2/android/...",
1441
            "//xplat/caffe2/fb/...",
1442
            "//xplat/caffe2/fb/model_tracer/...",
1443
        ],
1444
        deps = [
1445
            ":aten_cpu",
1446
            ":backend_interface_lib",
1447
            ":generated-autograd-headers",
1448
            ":torch_headers",
1449
            ":torch_mobile_deserialize",
1450
            third_party("glog"),
1451
            third_party("rt"),
1452
            C10,
1453
        ] + ([] if IS_OSS else [
1454
            "//xplat/caffe2/fb/custom_ops/batch_box_cox:batch_box_cox",
1455
            "//xplat/caffe2/fb/custom_ops/maskrcnn:maskrcnn",
1456
        ]),
1457
        exported_deps = [
1458
            ":torch_common",
1459
            ":torch_mobile_train",
1460
        ],
1461
    )
1462

1463
    pt_xplat_cxx_library(
1464
        name = "torch_train",
1465
        srcs = [
1466
            "torch/csrc/api/src/data/samplers/random.cpp",
1467
            "torch/csrc/api/src/data/samplers/sequential.cpp",
1468
            "torch/csrc/api/src/optim/optimizer.cpp",
1469
            "torch/csrc/api/src/optim/serialize.cpp",
1470
            "torch/csrc/api/src/optim/sgd.cpp",
1471
            "torch/csrc/api/src/serialize/input-archive.cpp",
1472
            "torch/csrc/api/src/serialize/output-archive.cpp",
1473
            "torch/csrc/jit/api/module_save.cpp",
1474
        ],
1475
        compiler_flags = get_pt_compiler_flags(),
1476
        exported_preprocessor_flags = get_pt_preprocessor_flags(),
1477
        visibility = ["PUBLIC"],
1478
        deps = [
1479
            ":aten_cpu",
1480
            ":torch_headers",
1481
            ":torch",
1482
            ":torch_core",
1483
            ":torch_mobile_deserialize",
1484
            ":torch_mobile_train",
1485
            ":jit_module_saving",
1486
            C10,
1487
        ],
1488
    )
1489

1490
    pt_xplat_cxx_library(
1491
        name = "torch_mobile_train",
1492
        srcs = core_trainer_sources + [
1493
            "torch/csrc/autograd/VariableTypeManual.cpp",
1494
            "torch/csrc/autograd/FunctionsManual.cpp",
1495
            "torch/csrc/api/src/data/datasets/mnist.cpp",
1496
            "torch/csrc/jit/mobile/quantization.cpp",
1497
            "torch/csrc/jit/mobile/train/export_data.cpp",
1498
            "torch/csrc/jit/mobile/train/optim/sgd.cpp",
1499
            "torch/csrc/jit/mobile/train/random.cpp",
1500
            "torch/csrc/jit/mobile/train/sequential.cpp",
1501
            ":gen_aten_libtorch[autograd/generated/Functions.cpp]",
1502
            ":gen_aten_libtorch[autograd/generated/ViewFuncs.cpp]",
1503
        ],
1504
        compiler_flags = get_pt_compiler_flags(),
1505
        exported_preprocessor_flags = get_pt_preprocessor_flags() + ["-DUSE_MOBILE_CLASSTYPE"],
1506
        # torch_mobile_train brings in sources neccessary to read and run a mobile
1507
        # and save and load mobile params along with autograd
1508
        # link_whole is enabled so that all symbols linked
1509
        # operators, registerations and autograd related symbols are need in runtime
1510
        # @lint-ignore BUCKLINT link_whole
1511
        link_whole = True,
1512
        visibility = ["PUBLIC"],
1513
        deps = [
1514
            ":aten_cpu",
1515
            ":generated-autograd-headers",
1516
            ":torch_headers",
1517
            ":torch_mobile_deserialize",
1518
            ":flatbuffers_serializer_mobile",
1519
            C10,
1520
        ],
1521
    )
1522

1523
    pt_xplat_cxx_library(
1524
        name = "torch",
1525
        srcs = [
1526
            "torch/csrc/jit/runtime/register_c10_ops.cpp",
1527
            "torch/csrc/jit/runtime/register_prim_ops_fulljit.cpp",
1528
        ],
1529
        compiler_flags = get_pt_compiler_flags(),
1530
        exported_preprocessor_flags = get_pt_preprocessor_flags(),
1531
        # torch brings in all sources neccessary to read and run a mobile module/jit module
1532
        # link_whole is enabled so that all symbols linked
1533
        # operators, registerations and other few symbols are need in runtime
1534
        # @lint-ignore BUCKLINT link_whole
1535
        link_whole = True,
1536
        visibility = ["PUBLIC"],
1537
        deps = [
1538
            # This is to have autograd profiler available
1539
            # in xplat/caffe2:torch which some builds are using
1540
            # notable xplate/facegen:testsAndroid
1541
            ":torch_headers",
1542
            ":torch_kineto_profiling",
1543
        ],
1544
        exported_deps = [
1545
            ":aten_cpu",
1546
            ":torch_core",
1547
            C10,
1548
        ],
1549
    )
1550

1551
    pt_xplat_cxx_library(
1552
        name = "torch_mobile_train_import_data",
1553
        srcs = [
1554
            "torch/csrc/jit/mobile/import_data.cpp",
1555
        ],
1556
        compiler_flags = get_pt_compiler_flags(),
1557
        exported_preprocessor_flags = get_pt_preprocessor_flags() + ["-DUSE_MOBILE_CLASSTYPE"],
1558
        # torch_mobile_train_import_data brings in sources neccessary to read a mobile module
1559
        # link_whole is enabled so that all symbols linked
1560
        # operators other few symbols are need in runtime
1561
        # @lint-ignore BUCKLINT link_whole
1562
        link_whole = True,
1563
        visibility = ["PUBLIC"],
1564
        deps = [
1565
            ":torch_headers",
1566
            ":torch_mobile_observer",
1567
            ":torch_mobile_core",
1568
            ":torch_mobile_train",
1569
        ],
1570
    )
1571

1572
    fb_xplat_cxx_library(
1573
        name = "torch_mobile_compatibility",
1574
        srcs = [
1575
            # These .cpp brought in through core_sources_common
1576
            # "torch/csrc/jit/mobile/compatibility/runtime_compatibility.cpp",
1577
            # "torch/csrc/jit/serialization/unpickler.cpp",
1578
            "torch/csrc/jit/mobile/compatibility/model_compatibility.cpp",
1579
        ],
1580
        header_namespace = "",
1581
        exported_headers = [
1582
            "torch/csrc/jit/mobile/compatibility/backport.h",
1583
            "torch/csrc/jit/mobile/compatibility/backport_manager.h",
1584
            "torch/csrc/jit/mobile/compatibility/model_compatibility.h",
1585
            "torch/csrc/jit/mobile/compatibility/runtime_compatibility.h",
1586
        ],
1587
        compiler_flags = [
1588
            "-fexceptions",
1589
            "-frtti",
1590
            "-Wno-deprecated-declarations",
1591
            "-Wno-global-constructors",
1592
        ],
1593
        labels = labels,
1594
        visibility = ["PUBLIC"],
1595
        deps = [
1596
            ":torch_mobile_deserialize",
1597
        ],
1598
    )
1599

1600
    pt_xplat_cxx_library(
1601
        name = "jit_module_saving",
1602
        srcs = [
1603
            "torch/csrc/jit/api/module_save.cpp",
1604
            "torch/csrc/jit/serialization/export_bytecode.cpp",
1605
            "torch/csrc/jit/serialization/export_module.cpp",
1606
        ],
1607
        compiler_flags = get_pt_compiler_flags(),
1608
        exported_preprocessor_flags = get_pt_preprocessor_flags() +
1609
                                      (["-DFB_XPLAT_BUILD"] if not IS_OSS else []),
1610
        exported_headers = [
1611
            "torch/csrc/jit/serialization/export.h",
1612
        ],
1613
        visibility = ["PUBLIC"],
1614
        deps = [
1615
            ":torch",
1616
            ":torch_mobile_core",
1617
            ":flatbuffers_serializer_mobile",
1618
        ],
1619
    )
1620

1621
    pt_xplat_cxx_library(
1622
        name = "torch_mobile_model_tracer",
1623
        srcs = [
1624
            "torch/csrc/jit/mobile/model_tracer/MobileModelRunner.cpp",
1625
            "torch/csrc/jit/mobile/model_tracer/TensorUtils.cpp",
1626
        ],
1627
        headers = [
1628
            "torch/csrc/jit/mobile/model_tracer/MobileModelRunner.h",
1629
            "torch/csrc/jit/mobile/model_tracer/TensorUtils.h",
1630
        ],
1631
        header_namespace = "",
1632
        exported_headers = [
1633
            "torch/csrc/jit/mobile/model_tracer/MobileModelRunner.h",
1634
        ],
1635
        compiler_flags = get_pt_compiler_flags(),
1636
        exported_preprocessor_flags = get_pt_preprocessor_flags() + (["-DSYMBOLICATE_MOBILE_DEBUG_HANDLE"] if get_enable_eager_symbolication() else []),
1637
        # torch_mobile_model_tracer brings in sources neccessary to read and run a jit module
1638
        # and trace the ops
1639
        # link_whole is enabled so that all symbols linked
1640
        # operators, registerations and other few symbols are need in runtime
1641
        # @lint-ignore BUCKLINT link_whole
1642
        link_whole = True,
1643
        linker_flags = [
1644
            "-Wl,--no-as-needed",
1645
        ],
1646
        visibility = ["PUBLIC"],
1647
        deps = [
1648
            ":caffe2_serialize",
1649
            ":generated-autograd-headers",
1650
            ":torch_mobile_headers",
1651
            ":torch_mobile_observer",
1652
            ":torch_mobile_core",
1653
        ] + ([] if IS_OSS else ["//xplat/folly:molly"]),
1654
        exported_deps = [
1655
            ":aten_cpu",
1656
            ":torch_common",
1657
        ] + ([] if IS_OSS else [
1658
            "//xplat/caffe2/fb/custom_ops/batch_box_cox:batch_box_cox",
1659
            "//xplat/caffe2/fb/custom_ops/maskrcnn:maskrcnn",
1660
            "//xplat/caffe2/fb/custom_ops/sparsenn:sparsenn-all",
1661
        ]),
1662
    )
1663

1664
    #TODO(qihan) delete
1665
    pt_xplat_cxx_library(
1666
        name = "torch_mobile_core_flatbuffer",
1667
        srcs = [],
1668
        header_namespace = "",
1669
        exported_headers = [],
1670
        compiler_flags = get_pt_compiler_flags(),
1671
        exported_preprocessor_flags = get_pt_preprocessor_flags() + (["-DSYMBOLICATE_MOBILE_DEBUG_HANDLE"] if get_enable_eager_symbolication() else []),
1672
        # @lint-ignore BUCKLINT link_whole
1673
        link_whole = True,
1674
        linker_flags = [
1675
            "-Wl,--no-as-needed",
1676
        ],
1677
        visibility = ["PUBLIC"],
1678
        deps = [
1679
            ":generated-autograd-headers",
1680
            ":torch_mobile_headers",
1681
            ":torch_mobile_observer",
1682
        ],
1683
        exported_deps = [
1684
            ":aten_cpu",
1685
            ":torch_common",
1686
        ],
1687
    )
1688

1689
    fb_xplat_cxx_library(
1690
        name = "backend_interface_lib",
1691
        srcs = [
1692
            "torch/csrc/jit/backends/backend_debug_info.cpp",
1693
            "torch/csrc/jit/backends/backend_interface.cpp",
1694
        ],
1695
        compiler_flags = get_pt_compiler_flags(),
1696
        fbandroid_compiler_flags = c2_fbandroid_xplat_compiler_flags,
1697
        # @lint-ignore BUCKLINT link_whole
1698
        link_whole = True,
1699
        linker_flags = [
1700
            "-Wl,--no-as-needed",
1701
        ],
1702
        visibility = ["PUBLIC"],
1703
        exported_deps = [
1704
            ":aten_cpu",
1705
            ":torch_common",
1706
        ],
1707
    )
1708

1709
    pt_xplat_cxx_library(
1710
        name = "torch_kineto_profiling",
1711
        srcs = libtorch_profiler_sources,
1712
        compiler_flags = get_pt_compiler_flags() + ["-Wno-error"],
1713
        exported_preprocessor_flags = get_pt_preprocessor_flags() + [
1714
            "-DUSE_KINETO",
1715
            # Need this otherwise USE_KINETO is undefed
1716
            # for mobile
1717
            "-DEDGE_PROFILER_USE_KINETO",
1718
        ],
1719
        # @lint-ignore BUCKLINT link_whole
1720
        link_whole = True,
1721
        linker_flags = [
1722
            "-Wl,--no-as-needed",
1723
        ],
1724
        visibility = ["PUBLIC"],
1725
        deps = [
1726
            third_party("glog"),
1727
            third_party("kineto"),
1728
        ],
1729
        exported_deps = [
1730
            ":aten_cpu",
1731
            ":torch_common",
1732
        ],
1733
    )
1734

1735
    pt_xplat_cxx_library(
1736
        name = "torch_edge_profiling",
1737
        srcs = ["torch/csrc/jit/mobile/profiler_edge.cpp"],
1738
        compiler_flags = get_pt_compiler_flags() + ["-Wno-error"],
1739
        exported_preprocessor_flags = get_pt_preprocessor_flags() + [
1740
            "-DUSE_KINETO",
1741
            "-DEDGE_PROFILER_USE_KINETO",
1742
        ],
1743
        # @lint-ignore BUCKLINT link_whole
1744
        link_whole = True,
1745
        linker_flags = [
1746
            "-Wl,--no-as-needed",
1747
        ],
1748
        visibility = ["PUBLIC"],
1749
        exported_deps = [
1750
            ":torch_common",
1751
            ":torch_kineto_profiling",
1752
            ":torch_mobile_core",
1753
        ],
1754
    )
1755

1756
    fb_xplat_genrule(
1757
        name = "mobile_bytecode_header",
1758
        srcs = [
1759
            "torch/csrc/jit/serialization/mobile_bytecode.fbs",
1760
        ],
1761
        outs = {
1762
            "mobile_bytecode_generated_fbsource.h": ["mobile_bytecode_generated.h"],
1763
        },
1764
        cmd = "$(exe {})".format(third_party("flatc")) +
1765
              " --cpp --gen-mutable --scoped-enums -o ${OUT} ${SRCS}",
1766
        default_outs = ["."],
1767
        visibility = [
1768
            "{}:mobile_bytecode".format(ROOT),
1769
        ],
1770
    )
1771

1772
    # Users of this target will need to add third_party("flatbuffers-api") as a
1773
    # dep.
1774
    fb_xplat_cxx_library(
1775
        name = "mobile_bytecode",
1776
        header_namespace = "",
1777
        exported_headers = {
1778
            ("torch/csrc/jit/serialization/mobile_bytecode_generated.h" if IS_OSS else "torch/csrc/jit/serialization/mobile_bytecode_generated_fbsource.h"): ":mobile_bytecode_header[mobile_bytecode_generated_fbsource.h]",
1779
        },
1780
        # Avoid leaking implementation details by only exposing this header to
1781
        # the internals of the loader/serializer layer.
1782
        visibility = [
1783
            "{}:flatbuffer_loader".format(ROOT),
1784
            "{}:flatbuffers_serializer_mobile".format(ROOT),
1785
        ],
1786
        exported_deps = [
1787
            third_party("flatbuffers-api"),
1788
        ],
1789
    )
1790

1791
    fb_xplat_cxx_library(
1792
        name = "flatbuffers_serializer_mobile",
1793
        srcs = ["torch/csrc/jit/serialization/flatbuffer_serializer.cpp"],
1794
        exported_headers = [
1795
            "torch/csrc/jit/serialization/flatbuffer_serializer.h",
1796
        ],
1797
        compiler_flags = [
1798
            "-g0",
1799
            "-O3",
1800
            "-fexceptions",
1801
            "-frtti",
1802
            "-Wno-deprecated-declarations",
1803
        ] + (["-DFB_XPLAT_BUILD"] if not IS_OSS else []),
1804
        visibility = ["PUBLIC"],
1805
        deps = [
1806
            ":mobile_bytecode",
1807
            ":torch_mobile_module",
1808
            C10,
1809
        ],
1810
        exported_deps = [
1811
            ":torch_mobile_deserialize",
1812
            ":mobile_bytecode",
1813
        ],
1814
    )
1815

1816
    # TODO (qihan) delete
1817
    pt_xplat_cxx_library(
1818
        name = "flatbuffer_loader",
1819
        srcs = [
1820
        ],
1821
        exported_headers = [
1822
            "torch/csrc/jit/mobile/flatbuffer_loader.h",
1823
        ],
1824
        compiler_flags = get_pt_compiler_flags() + ["-Wno-error"],
1825
        exported_preprocessor_flags = get_pt_preprocessor_flags() + [
1826
            "-DUSE_KINETO",
1827
            # Need this otherwise USE_KINETO is undefed
1828
            # for mobile
1829
            "-DEDGE_PROFILER_USE_KINETO",
1830
        ] + (["-DFB_XPLAT_BUILD"] if not IS_OSS else []),
1831
        extra_flags = {
1832
            "fbandroid_compiler_flags": ["-frtti"],
1833
        },
1834
        # torch_mobile_deserialize brings in sources neccessary to read a module
1835
        # which depends on mobile module definition
1836
        # link_whole is enable so that all symbols neccessary for mobile module are compiled
1837
        # instead of only symbols used while loading; this prevents symbol
1838
        # found definied in runtime
1839
        # @lint-ignore BUCKLINT link_whole
1840
        link_whole = True,
1841
        linker_flags = [
1842
            "-Wl,--no-as-needed",
1843
        ],
1844
        visibility = ["PUBLIC"],
1845
        deps = [
1846
            ":mobile_bytecode",
1847
        ],
1848
        exported_deps = [
1849
            C10,
1850
        ],
1851
    )
1852

1853
    # TODO(qihan) delete
1854
    fb_xplat_cxx_library(
1855
        name = "flatbuffers_serializer_jit",
1856
        compiler_flags = [
1857
            "-g0",
1858
            "-O3",
1859
            "-fexceptions",
1860
            "-frtti",
1861
            "-Wno-deprecated-declarations",
1862
        ],
1863
        headers = [
1864
            "torch/csrc/jit/serialization/flatbuffer_serializer_jit.h",
1865
        ],
1866
        srcs = [
1867
            "torch/csrc/jit/serialization/flatbuffer_serializer_jit.cpp",
1868
        ],
1869
        linker_flags = [
1870
            "-Wl,--no-as-needed",
1871
        ],
1872
        visibility = ["PUBLIC"],
1873
        deps = [
1874
            ":flatbuffer_loader",
1875
            ":flatbuffers_serializer_mobile",
1876
            ":torch_core",
1877
            ":torch_mobile_module",
1878
            C10,
1879
        ],
1880
    )
1881

1882
    fb_xplat_cxx_library(
1883
        name = "flatbuffers_jit",
1884
        visibility = ["PUBLIC"],
1885
        exported_deps = [
1886
            ":flatbuffer_loader",
1887
            ":flatbuffers_serializer_mobile",
1888
            ":flatbuffers_serializer_jit",
1889
        ],
1890
    )
1891

1892
    fb_xplat_cxx_library(
1893
        name = "flatbuffers_mobile",
1894
        visibility = ["PUBLIC"],
1895
        exported_deps = [
1896
            ":flatbuffer_loader",
1897
            ":flatbuffers_serializer_mobile",
1898
            ":torch_mobile_train",
1899
        ],
1900
    )
1901

1902
    pt_xplat_cxx_library(
1903
        name = "torch_supported_mobile_models",
1904
        srcs = [
1905
            "fb/supported_mobile_models/SupportedMobileModels.cpp",
1906
        ] if NOT_OSS else [],
1907
        header_namespace = "",
1908
        exported_headers = ["fb/supported_mobile_models/SupportedMobileModels.h"] if NOT_OSS else [],
1909
        compiler_flags = get_pt_compiler_flags() + ["-Wno-error"],
1910
        exported_preprocessor_flags = get_pt_preprocessor_flags() + (["-DSYMBOLICATE_MOBILE_DEBUG_HANDLE"] if get_enable_eager_symbolication() else []),
1911
        # @lint-ignore BUCKLINT link_whole
1912
        link_whole = True,
1913
        linker_flags = [
1914
            "-Wl,--no-as-needed",
1915
        ],
1916
        visibility = ["PUBLIC"],
1917
        deps = [],
1918
        exported_deps = [
1919
            "//xplat/caffe2/fb/custom_ops/batch_box_cox:batch_box_cox",
1920
            "//xplat/caffe2/fb/custom_ops/maskrcnn:maskrcnn",
1921
        ] if NOT_OSS else [],
1922
    )
1923

1924
    fb_xplat_cxx_library(
1925
        name = "static_runtime",
1926
        srcs = [
1927
            "torch/csrc/jit/runtime/static/fusion.cpp",
1928
            "torch/csrc/jit/runtime/static/generated_ops.cpp",
1929
            "torch/csrc/jit/runtime/static/impl.cpp",
1930
            "torch/csrc/jit/runtime/static/memory_planner.cpp",
1931
            "torch/csrc/jit/runtime/static/native_ops.cpp",
1932
            "torch/csrc/jit/runtime/static/ops.cpp",
1933
            "torch/csrc/jit/runtime/static/passes.cpp",
1934
            "torch/csrc/jit/runtime/static/te_wrapper.cpp",
1935
        ],
1936
        compiler_flags = ["-fexceptions"],
1937
        labels = labels,
1938
        # @lint-ignore BUCKLINT link_whole
1939
        link_whole = True,
1940
        visibility = ["PUBLIC"],
1941
        windows_preferred_linkage = "static" if is_arvr_mode() else None,
1942
        deps = [
1943
            ":aten_cpu",
1944
            ":caffe2_headers",
1945
            ":torch_core",
1946
            C10,
1947
        ],
1948
    )
1949

1950
    # aten_cpu and aten_native_cpu
1951
    for name, srcs in [
1952
        ("aten_cpu", jit_core_sources + aten_cpu_source_list + [
1953
            # Generated
1954
            ":gen_aten[Functions.cpp]",
1955
            ":gen_aten[Operators_0.cpp]",
1956
            ":gen_aten[Operators_1.cpp]",
1957
            ":gen_aten[Operators_2.cpp]",
1958
            ":gen_aten[Operators_3.cpp]",
1959
            ":gen_aten[Operators_4.cpp]",
1960
            ":gen_aten[core/ATenOpList.cpp]",
1961
            ":gen_aten[core/TensorMethods.cpp]",
1962
            # Needed by ATen/native/EmbeddingBag.cpp
1963
            "caffe2/perfkernels/embedding_lookup_idx.cc",
1964
        ]),
1965
        ("aten_native_cpu", aten_native_source_list),
1966
    ]:
1967
        fb_xplat_cxx_library(
1968
            name = name,
1969
            srcs = srcs,
1970
            header_namespace = "",
1971
            # @lint-ignore BUCKLINT
1972
            link_whole = True,
1973
            visibility = ["PUBLIC"],
1974
            deps = [
1975
                third_party("omp"),
1976
                third_party("cpuinfo"),
1977
                third_party("glog"),
1978
                third_party("XNNPACK"),
1979
                third_party("pocketfft"),
1980
            ] + select({
1981
                "DEFAULT": [],
1982
                "ovr_config//runtime:fbcode-arm64": [
1983
                    third_party("sleef_arm"),
1984
                ],
1985
            }),
1986
            compiler_flags = get_aten_compiler_flags(),
1987
            exported_preprocessor_flags = get_aten_preprocessor_flags(),
1988
            exported_deps = [
1989
                ":aten_header",
1990
                ":caffe2_headers",
1991
                ":common_core",
1992
                ":generated_aten_config_header",
1993
                ":generated_aten_headers_cpu",
1994
                ":jit_core_headers",
1995
                ":pthreadpool",
1996
                third_party("fmt"),
1997
                third_party("ruy"),
1998
                C10,
1999
                ROOT_PATH + "aten/src/ATen/native/quantized/cpu/qnnpack:pytorch_qnnpack",
2000
            ],
2001
            labels = labels,
2002
            **aten_default_args
2003
        )
2004

2005
    fb_xplat_cxx_library(
2006
        name = "lean_runtime_with_flatbuffer",
2007
        srcs = [
2008
            "aten/src/ATen/core/DeprecatedTypePropertiesRegistry.cpp",
2009
            "torch/csrc/jit/mobile/import.cpp",
2010
            "torch/csrc/jit/mobile/module.cpp",
2011
            "torch/csrc/jit/mobile/observer.cpp",
2012
            "torch/csrc/jit/serialization/import_read.cpp",
2013
        ],
2014
        header_namespace = "",
2015
        exported_headers = subdir_glob(
2016
            [
2017
                ("", "torch/csrc/jit/ir/*.h"),
2018
                ("", "caffe2/serialize/*.h"),
2019
                ("", "caffe2/utils/*.h"),
2020
                ("", "caffe2/core/*.h"),
2021
                ("", "torch/csrc/*.h"),
2022
                ("", "torch/csrc/api/include/torch/*.h"),
2023
                ("", "torch/csrc/autograd/*.h"),
2024
                ("", "torch/csrc/autograd/*/*.h"),
2025
                ("", "torch/csrc/jit/api/*.h"),
2026
                ("", "torch/csrc/jit/backends/*.h"),
2027
                ("", "torch/csrc/jit/mobile/*.h"),
2028
                ("", "torch/csrc/jit/runtime/*.h"),
2029
                ("", "torch/csrc/jit/passes/*.h"),
2030
                ("", "torch/csrc/jit/python/*.h"),
2031
                ("", "torch/csrc/jit/frontend/*.h"),
2032
                ("", "torch/csrc/jit/serialization/*.h"),
2033
                ("", "torch/csrc/profiler/**/*.h"),
2034
                ("", "torch/csrc/utils/*.h"),
2035
                ("", "aten/src/ATen/quantized/*.h"),
2036
            ] + ([
2037
                ("third_party/miniz-2.1.0", "*.h"),
2038
            ] if NOT_OSS else []),
2039
            exclude = [
2040
                "torch/csrc/jit/serialization/mobile_bytecode_generated.h",
2041
            ],
2042
        ),
2043
        compiler_flags = get_pt_compiler_flags() + select({
2044
            "DEFAULT": [],
2045
            "ovr_config//os:xtensa-xos": [
2046
                "-fdata-sections",
2047
                "-ffunction-sections",
2048
            ],
2049
        }),
2050
        exported_preprocessor_flags = get_pt_preprocessor_flags() + [
2051
            "-DMIN_EDGE_RUNTIME",
2052
        ],
2053
        linker_flags = [
2054
            "-Wl,--no-as-needed",
2055
        ] + select({
2056
            "DEFAULT": [],
2057
            "ovr_config//os:macos": [
2058
                "-dead_strip",
2059
            ],
2060
            "ovr_config//os:xtensa-xos": [
2061
                "-Wl,--gc-sections",
2062
            ],
2063
        }),
2064
        visibility = ["PUBLIC"],
2065
        exported_deps = [
2066
            ":lean_runtime_with_tensor",
2067
        ],
2068
    )
2069

2070
    pt_xplat_cxx_library(
2071
        name = "lean_runtime_with_tensor",
2072
        srcs = [
2073
            "aten/src/ATen/Context.cpp",
2074
            "aten/src/ATen/EmptyTensor.cpp",
2075
            "aten/src/ATen/Utils.cpp",
2076
            "aten/src/ATen/detail/CUDAHooksInterface.cpp",
2077
            "aten/src/ATen/detail/PrivateUse1HooksInterface.cpp",
2078
            ":gen_aten[Operators_0.cpp]",
2079
            ":gen_aten[Operators_1.cpp]",
2080
            ":gen_aten[Operators_2.cpp]",
2081
            ":gen_aten[Operators_3.cpp]",
2082
            ":gen_aten[Operators_4.cpp]",
2083
            ":gen_aten[core/TensorMethods.cpp]",
2084
        ],
2085
        header_namespace = "",
2086
        exported_headers = [
2087
            "torch/csrc/jit/runtime/custom_operator.h",
2088
            ":gen_aten[core/TensorBody.h]",
2089
        ],
2090
        compiler_flags = get_pt_compiler_flags() + select({
2091
            "DEFAULT": [],
2092
            "ovr_config//os:xtensa-xos": [
2093
                "-fdata-sections",
2094
                "-ffunction-sections",
2095
            ],
2096
        }),
2097
        exported_preprocessor_flags = get_pt_preprocessor_flags() + ["-DMIN_EDGE_RUNTIME"] + select({
2098
            "DEFAULT": [],
2099
            "ovr_config//os:xtensa-xos": [
2100
                "-Dthread_local=",
2101
            ],
2102
        }),
2103
        # @lint-ignore BUCKLINT link_whole
2104
        link_whole = True,
2105
        linker_flags = [
2106
            "-Wl,--no-as-needed",
2107
        ],
2108
        visibility = ["PUBLIC"],
2109
        exported_deps = [
2110
            ":generated_aten_config_header",
2111
            ":lean_runtime_with_op",
2112
            ":aten_header",
2113
            C10,
2114
        ] + (["//xplat/caffe2/fb/embedded:experimental"] if NOT_OSS else []),
2115
    )
2116

2117
    pt_xplat_cxx_library(
2118
        name = "lean_runtime_with_op",
2119
        srcs = [
2120
            "aten/src/ATen/SequenceNumber.cpp",
2121
            "aten/src/ATen/core/boxing/KernelFunction.cpp",
2122
            "aten/src/ATen/core/custom_class.cpp",
2123
            "aten/src/ATen/core/dispatch/DispatchKeyExtractor.cpp",
2124
            "aten/src/ATen/core/dispatch/Dispatcher.cpp",
2125
            "aten/src/ATen/core/dispatch/ObservedOperators.cpp",
2126
            "aten/src/ATen/core/dispatch/OperatorEntry.cpp",
2127
            "aten/src/ATen/core/PythonOpRegistrationTrampoline.cpp",
2128
            "aten/src/ATen/core/interned_strings.cpp",
2129
            "aten/src/ATen/core/library.cpp",
2130
            "aten/src/ATen/core/op_registration/infer_schema.cpp",
2131
            "aten/src/ATen/core/function_schema.cpp",
2132
            "aten/src/ATen/core/operator_name.cpp",
2133
            "aten/src/ATen/core/register_symbols.cpp",
2134
            "aten/src/ATen/core/tensor_type.cpp",
2135
            "aten/src/ATen/core/union_type.cpp",
2136
            "aten/src/ATen/record_function.cpp",
2137
            "torch/csrc/jit/frontend/edit_distance.cpp",
2138
            "torch/csrc/jit/frontend/error_report.cpp",
2139
            "torch/csrc/jit/frontend/function_schema_parser.cpp",
2140
            "torch/csrc/jit/frontend/lexer.cpp",
2141
            "torch/csrc/jit/frontend/schema_type_parser.cpp",
2142
            "torch/csrc/jit/frontend/source_range.cpp",
2143
            "torch/csrc/jit/frontend/strtod.cpp",
2144
            "torch/csrc/jit/mobile/parse_operators.cpp",
2145
            "torch/csrc/jit/mobile/prim_ops_registery.cpp",
2146
            "torch/csrc/jit/runtime/operator.cpp",
2147
            "torch/csrc/jit/runtime/slice_indices_adjust.cpp",
2148
        ],
2149
        header_namespace = "",
2150
        exported_headers = [
2151
            "torch/csrc/jit/frontend/edit_distance.h",
2152
            "torch/csrc/jit/runtime/slice_indices_adjust.h",
2153
        ],
2154
        compiler_flags = get_pt_compiler_flags() + select({
2155
            "DEFAULT": [],
2156
            "ovr_config//os:xtensa-xos": [
2157
                "-fdata-sections",
2158
                "-ffunction-sections",
2159
            ],
2160
        }),
2161
        exported_preprocessor_flags = get_pt_preprocessor_flags() + ["-DMIN_EDGE_RUNTIME"] + select({
2162
            "DEFAULT": [],
2163
            "ovr_config//os:xtensa-xos": [
2164
                "-Dthread_local=",
2165
            ],
2166
        }),
2167
        # @lint-ignore BUCKLINT link_whole
2168
        link_whole = True,
2169
        linker_flags = [
2170
            "-Wl,--no-as-needed",
2171
        ],
2172
        visibility = ["PUBLIC"],
2173
        exported_deps = [
2174
            ":min_runtime_lib",
2175
            C10,
2176
        ],
2177
    )
2178

2179
    pt_xplat_cxx_library(
2180
        name = "min_runtime_lib",
2181
        srcs = [
2182
            "aten/src/ATen/ScalarOps.cpp",
2183
            "aten/src/ATen/core/Dict.cpp",
2184
            "aten/src/ATen/core/List.cpp",
2185
            "aten/src/ATen/core/class_type.cpp",
2186
            "aten/src/ATen/core/dynamic_type.cpp",
2187
            "aten/src/ATen/core/ivalue.cpp",
2188
            "aten/src/ATen/core/type.cpp",
2189
            "aten/src/ATen/core/type_factory.cpp",
2190
            "aten/src/ATen/native/prim_native_functions.cpp",
2191
            "torch/csrc/jit/mobile/function.cpp",
2192
            "torch/csrc/jit/mobile/interpreter.cpp",
2193
            "torch/csrc/jit/mobile/parse_bytecode.cpp",
2194
            "torch/csrc/jit/mobile/promoted_prim_ops.cpp",
2195
            "torch/csrc/jit/mobile/register_ops_common_utils.cpp",
2196
            "torch/csrc/jit/mobile/type_parser.cpp",
2197
            "torch/csrc/jit/runtime/instruction.cpp",
2198
            "torch/csrc/jit/runtime/jit_exception.cpp",
2199
            "torch/csrc/jit/runtime/vararg_functions.cpp",
2200
        ],
2201
        header_namespace = "",
2202
        exported_headers = [
2203
            "caffe2/serialize/versions.h",
2204
            "torch/csrc/jit/backends/backend_exception.h",
2205
            "torch/csrc/jit/mobile/register_ops_common_utils.h",
2206
            "torch/csrc/jit/runtime/instruction.h",
2207
            "torch/csrc/jit/runtime/jit_exception.h",
2208
            "torch/csrc/jit/runtime/operator.h",
2209
            "torch/csrc/jit/runtime/operator_options.h",
2210
            "torch/csrc/jit/runtime/vararg_functions.h",
2211
            "torch/csrc/jit/serialization/import_export_constants.h",
2212
            "torch/csrc/jit/serialization/import_export_functions.h",
2213
        ],
2214
        compiler_flags = get_pt_compiler_flags() + select({
2215
            "DEFAULT": [],
2216
            "ovr_config//os:xtensa-xos": [
2217
                "-fexceptions",
2218
                "-fdata-sections",
2219
                "-ffunction-sections",
2220
            ],
2221
        }),
2222
        exported_preprocessor_flags = get_pt_preprocessor_flags() + ["-DMIN_EDGE_RUNTIME"] + select({
2223
            "DEFAULT": [],
2224
            "ovr_config//os:xtensa-xos": [
2225
                "-Dthread_local=",
2226
            ],
2227
        }),
2228
        # @lint-ignore BUCKLINT link_whole
2229
        link_whole = True,
2230
        linker_flags = [
2231
            "-Wl,--no-as-needed",
2232
        ],
2233
        visibility = ["PUBLIC"],
2234
        exported_deps = [
2235
            ":aten_header",
2236
            ":generated_aten_headers_cpu",
2237
            ":jit_core_headers",
2238
            ":torch_mobile_headers",
2239
            C10,
2240
        ],
2241
    )
2242