pytorch

1
load("//tools/build_defs:fb_xplat_cxx_library.bzl", "fb_xplat_cxx_library")
2
load("//tools/build_defs:fbsource_utils.bzl", "is_arvr_mode")
3
load("//tools/build_defs:glob_defs.bzl", "subdir_glob")
4
load("//tools/build_defs:platform_defs.bzl", "ANDROID", "APPLE", "APPLETVOS", "CXX", "IOS", "MACOSX", "WINDOWS")
5
load(
6
    ":xnnpack_src_defs.bzl",
7
    "JIT_SRCS",
8
    "LOGGING_SRCS",
9
    "OPERATOR_SRCS",
10
    "SUBGRAPH_SRCS",
11
    "TABLE_SRCS",
12
    "XNNPACK_SRCS",
13
)
14
load(
15
    ":xnnpack_wrapper_defs.bzl",
16
    "AARCH32_ASM_MICROKERNEL_SRCS",
17
    "AARCH64_ASM_MICROKERNEL_SRCS",
18
    "PROD_ARMSIMD32_MICROKERNEL_SRCS",
19
    "PROD_AVX2_MICROKERNEL_SRCS",
20
    "PROD_AVX512F_MICROKERNEL_SRCS",
21
    "PROD_AVX512SKX_MICROKERNEL_SRCS",
22
    "PROD_AVX512VBMI_MICROKERNEL_SRCS",
23
    "PROD_AVX512VNNI_MICROKERNEL_SRCS",
24
    "PROD_AVXVNNI_MICROKERNEL_SRCS",
25
    "PROD_AVX_MICROKERNEL_SRCS",
26
    "PROD_F16C_MICROKERNEL_SRCS",
27
    "PROD_FMA3_MICROKERNEL_SRCS",
28
    "PROD_FP16ARITH_MICROKERNEL_SRCS",
29
    "PROD_NEONDOTFP16ARITH_AARCH64_MICROKERNEL_SRCS",
30
    "PROD_NEONDOTFP16ARITH_MICROKERNEL_SRCS",
31
    "PROD_NEONDOT_AARCH64_MICROKERNEL_SRCS",
32
    "PROD_NEONDOT_MICROKERNEL_SRCS",
33
    "PROD_NEONFMA_MICROKERNEL_SRCS",
34
    "PROD_NEONFP16ARITH_AARCH64_MICROKERNEL_SRCS",
35
    "PROD_NEONFP16ARITH_MICROKERNEL_SRCS",
36
    "PROD_NEONFP16_MICROKERNEL_SRCS",
37
    "PROD_NEONI8MM_MICROKERNEL_SRCS",
38
    "PROD_NEONV8_MICROKERNEL_SRCS",
39
    "PROD_NEON_AARCH64_MICROKERNEL_SRCS",
40
    "PROD_NEON_MICROKERNEL_SRCS",
41
    "PROD_SCALAR_MICROKERNEL_SRCS",
42
    "PROD_SSE2_MICROKERNEL_SRCS",
43
    "PROD_SSE41_MICROKERNEL_SRCS",
44
    "PROD_SSE_MICROKERNEL_SRCS",
45
    "PROD_SSSE3_MICROKERNEL_SRCS",
46
    "PROD_XOP_MICROKERNEL_SRCS",
47
)
48

49
# This defines XNNPACK targets for both fbsource BUCK and OSS BUCK
50
# Note that the file path is relative to the BUCK file that called from, not to this bzl file.
51
# So for fbsource build it points to xplat/third-party/XNNPACK/XNNPACK,
52
# and for OSS it points to pytorch/third_party/XNNPACK
53
def define_xnnpack(third_party, labels = [], XNNPACK_WINDOWS_AVX512F_ENABLED = False):
54
    WINDOWS_FLAGS = [
55
        "/D__x86_64__",
56
        "/EHsc",
57
        "/wd4090",  # 'function': different 'const' qualifiers
58
        "/wd4146",  # unary minus operator applied to unsigned type, result still unsigned
59
    ] + ([
60
        "/D__AVX512F__",  # needed to avoid linkage errors
61
        "-mavx2",
62
        "/D__builtin_clz=__lzcnt",  # Intrinsics are spelled differently in MSVC
63
        "/Drestrict=",  # MSVC doesn't understand [restrict XNN_NUM_ELEMENTS(N)] syntax
64
    ] if XNNPACK_WINDOWS_AVX512F_ENABLED else [])
65

66
    WINDOWS_CLANG_COMPILER_FLAGS = [
67
        "-Wno-error",
68
        "-Wno-error=undef",
69
        "-Wno-error=incompatible-pointer-types",
70
        "-Wno-error=incompatible-pointer-types-discards-qualifiers",
71
    ]
72

73
    fb_xplat_cxx_library(
74
        name = "interface",
75
        header_namespace = "",
76
        exported_headers = {
77
            "xnnpack.h": "XNNPACK/include/xnnpack.h",
78
        },
79
        apple_sdks = (IOS, MACOSX, APPLETVOS),
80
        labels = labels,
81
        preprocessor_flags = [
82
            "-DXNN_LOG_LEVEL=0",
83
        ],
84
        visibility = ["PUBLIC"],
85
        exported_deps = [
86
            # Dependency only on pthreadpool interface
87
            third_party("pthreadpool_header"),
88
        ],
89
    )
90

91
    fb_xplat_cxx_library(
92
        name = "subgraph",
93
        srcs = SUBGRAPH_SRCS,
94
        headers = subdir_glob([
95
            ("XNNPACK/src", "**/*.h"),
96
        ]),
97
        header_namespace = "",
98
        apple_sdks = (IOS, MACOSX, APPLETVOS),
99
        compiler_flags = [
100
            "-O2",
101
        ],
102
        fbobjc_preprocessor_flags = [
103
            "-DXNN_PRIVATE=",
104
            "-DXNN_INTERNAL=",
105
        ],
106
        labels = labels,
107
        preferred_linkage = "static",
108
        preprocessor_flags = [
109
            "-DXNN_LOG_LEVEL=0",
110
            "-DXNN_ENABLE_JIT=0",
111
            "-DXNN_ENABLE_SPARSE=0",
112
            "-DXNN_ENABLE_MEMOPT",
113
        ],
114
        visibility = ["PUBLIC"],
115
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
116
        windows_compiler_flags_override = WINDOWS_FLAGS,
117
        deps = [
118
            ":interface",
119
            third_party("FP16"),
120
            third_party("FXdiv"),
121
            third_party("clog"),
122
        ],
123
    )
124

125
    fb_xplat_cxx_library(
126
        name = "tables",
127
        srcs = TABLE_SRCS,
128
        headers = subdir_glob([
129
            ("XNNPACK/src", "**/*.h"),
130
        ]),
131
        header_namespace = "",
132
        apple_sdks = (IOS, MACOSX, APPLETVOS),
133
        compiler_flags = [
134
            "-O2",
135
        ],
136
        fbobjc_preprocessor_flags = [
137
            "-DXNN_PRIVATE=",
138
            "-DXNN_INTERNAL=",
139
        ],
140
        labels = labels,
141
        preferred_linkage = "static",
142
        preprocessor_flags = [
143
            "-DXNN_LOG_LEVEL=0",
144
        ],
145
        visibility = ["PUBLIC"],
146
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
147
        windows_compiler_flags_override = WINDOWS_FLAGS,
148
        deps = [
149
            ":interface",
150
            third_party("FP16"),
151
            third_party("FXdiv"),
152
            third_party("clog"),
153
        ],
154
    )
155

156
    fb_xplat_cxx_library(
157
        name = "jit_memory",
158
        # srcs have to include HOT_SRCS to be able to build on ARVR
159
        srcs = JIT_SRCS,
160
        headers = subdir_glob([
161
            ("XNNPACK/src", "**/*.h"),
162
        ]),
163
        header_namespace = "",
164
        apple_sdks = (IOS, MACOSX, APPLETVOS),
165
        compiler_flags = [
166
            "-Oz",
167
        ],
168
        fbobjc_preprocessor_flags = [
169
            "-DXNN_PRIVATE=",
170
            "-DXNN_INTERNAL=",
171
        ],
172
        labels = labels,
173
        platforms = (APPLE, ANDROID, CXX, WINDOWS),
174
        preferred_linkage = "static",
175
        preprocessor_flags = [
176
            "-DXNN_LOG_LEVEL=0",
177
        ],
178
        visibility = ["PUBLIC"],
179
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
180
        windows_compiler_flags_override = WINDOWS_FLAGS,
181
        deps = [
182
            ":interface",
183
            third_party("clog"),
184
        ],
185
    )
186

187
    fb_xplat_cxx_library(
188
        name = "ukernels_scalar",
189
        srcs = PROD_SCALAR_MICROKERNEL_SRCS,
190
        headers = subdir_glob([
191
            ("XNNPACK/src", "**/*.c"),
192
            ("XNNPACK/src", "**/*.h"),
193
        ]),
194
        header_namespace = "",
195
        apple_sdks = (IOS, MACOSX, APPLETVOS),
196
        compiler_flags = [
197
            "-O2",
198
            "-fno-fast-math",
199
            "-fno-math-errno",
200
            "-ffp-contract=off",
201
        ],
202
        fbobjc_preprocessor_flags = [
203
            "-DXNN_PRIVATE=",
204
            "-DXNN_INTERNAL=",
205
        ],
206
        labels = labels,
207
        preferred_linkage = "static",
208
        preprocessor_flags = [
209
            "-DXNN_LOG_LEVEL=0",
210
        ],
211
        visibility = ["PUBLIC"],
212
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
213
        windows_compiler_flags_override = WINDOWS_FLAGS,
214
        deps = [
215
            ":interface",
216
            third_party("FP16"),
217
            third_party("FXdiv"),
218
        ],
219
    )
220

221
    fb_xplat_cxx_library(
222
        name = "ukernels_sse",
223
        srcs = PROD_SSE_MICROKERNEL_SRCS if is_arvr_mode() else [],
224
        headers = subdir_glob([
225
            ("XNNPACK/src", "**/*.c"),
226
            ("XNNPACK/src", "**/*.h"),
227
        ]),
228
        header_namespace = "",
229
        apple_sdks = (IOS, MACOSX, APPLETVOS),
230
        compiler_flags = [
231
            "-O2",
232
        ],
233
        fbobjc_preprocessor_flags = [
234
            "-DXNN_PRIVATE=",
235
            "-DXNN_INTERNAL=",
236
        ],
237
        labels = labels,
238
        platform_compiler_flags = [
239
            (
240
                "x86",
241
                [
242
                    "-msse",
243
                ],
244
            ),
245
        ],
246
        platform_srcs = ([
247
            (
248
                "x86|x86_64|platform009|platform010",
249
                PROD_SSE_MICROKERNEL_SRCS,
250
            ),
251
        ] if not is_arvr_mode() else []),
252
        preferred_linkage = "static",
253
        preprocessor_flags = [
254
            "-DXNN_LOG_LEVEL=0",
255
        ],
256
        visibility = ["PUBLIC"],
257
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-msse"],
258
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-msse"],
259
        deps = [
260
            ":interface",
261
        ],
262
    )
263

264
    fb_xplat_cxx_library(
265
        name = "ukernels_sse_ovr_win32",
266
        headers = subdir_glob([
267
            ("XNNPACK/src", "**/*.c"),
268
            ("XNNPACK/src", "**/*.h"),
269
        ]),
270
        header_namespace = "",
271
        apple_sdks = (IOS, MACOSX, APPLETVOS),
272
        compiler_flags = [
273
            "-O2",
274
        ],
275
        fbobjc_preprocessor_flags = [
276
            "-DXNN_PRIVATE=",
277
            "-DXNN_INTERNAL=",
278
        ],
279
        labels = labels,
280
        platform_compiler_flags = [
281
            (
282
                "x86",
283
                [
284
                    "-msse",
285
                ],
286
            ),
287
        ],
288
        preferred_linkage = "static",
289
        preprocessor_flags = [
290
            "-DXNN_LOG_LEVEL=0",
291
        ],
292
        visibility = ["PUBLIC"],
293
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-msse"],
294
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-msse"],
295
        windows_srcs = PROD_SSE_MICROKERNEL_SRCS,
296
        deps = [
297
            ":interface",
298
        ],
299
    )
300

301
    fb_xplat_cxx_library(
302
        name = "ukernels_sse2",
303
        srcs = PROD_SSE2_MICROKERNEL_SRCS if is_arvr_mode() else [],
304
        headers = subdir_glob([
305
            ("XNNPACK/src", "**/*.c"),
306
            ("XNNPACK/src", "**/*.h"),
307
        ]),
308
        header_namespace = "",
309
        apple_sdks = (IOS, MACOSX, APPLETVOS),
310
        compiler_flags = [
311
            "-O2",
312
        ],
313
        fbobjc_preprocessor_flags = [
314
            "-DXNN_PRIVATE=",
315
            "-DXNN_INTERNAL=",
316
        ],
317
        labels = labels,
318
        platform_compiler_flags = [
319
            (
320
                "x86",
321
                [
322
                    "-msse2",
323
                ],
324
            ),
325
        ],
326
        platform_srcs = ([
327
            (
328
                "x86|x86_64|platform009|platform010",
329
                PROD_SSE2_MICROKERNEL_SRCS,
330
            ),
331
        ] if not is_arvr_mode() else []),
332
        preferred_linkage = "static",
333
        preprocessor_flags = [
334
            "-DXNN_LOG_LEVEL=0",
335
        ],
336
        visibility = ["PUBLIC"],
337
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-msse2"],
338
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-msse2"],
339
        deps = [
340
            ":interface",
341
            third_party("FP16"),
342
        ],
343
    )
344

345
    fb_xplat_cxx_library(
346
        name = "ukernels_sse2_ovr_win32",
347
        headers = subdir_glob([
348
            ("XNNPACK/src", "**/*.c"),
349
            ("XNNPACK/src", "**/*.h"),
350
        ]),
351
        header_namespace = "",
352
        apple_sdks = (IOS, MACOSX, APPLETVOS),
353
        compiler_flags = [
354
            "-O2",
355
        ],
356
        fbobjc_preprocessor_flags = [
357
            "-DXNN_PRIVATE=",
358
            "-DXNN_INTERNAL=",
359
        ],
360
        labels = labels,
361
        platform_compiler_flags = [
362
            (
363
                "x86",
364
                [
365
                    "-msse2",
366
                ],
367
            ),
368
        ],
369
        preferred_linkage = "static",
370
        preprocessor_flags = [
371
            "-DXNN_LOG_LEVEL=0",
372
        ],
373
        visibility = ["PUBLIC"],
374
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-msse2"],
375
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-msse2"],
376
        windows_srcs = PROD_SSE2_MICROKERNEL_SRCS,
377
        deps = [
378
            ":interface",
379
            third_party("FP16"),
380
        ],
381
    )
382

383
    fb_xplat_cxx_library(
384
        name = "ukernels_ssse3",
385
        srcs = PROD_SSSE3_MICROKERNEL_SRCS if is_arvr_mode() else [],
386
        headers = subdir_glob([
387
            ("XNNPACK/src", "**/*.c"),
388
            ("XNNPACK/src", "**/*.h"),
389
        ]),
390
        header_namespace = "",
391
        apple_sdks = (IOS, MACOSX, APPLETVOS),
392
        compiler_flags = [
393
            "-O2",
394
        ],
395
        fbobjc_preprocessor_flags = [
396
            "-DXNN_PRIVATE=",
397
            "-DXNN_INTERNAL=",
398
        ],
399
        labels = labels,
400
        platform_compiler_flags = [
401
            (
402
                "x86",
403
                [
404
                    "-mssse3",
405
                ],
406
            ),
407
        ],
408
        platform_srcs = ([
409
            (
410
                "x86|x86_64|platform009|platform010",
411
                PROD_SSSE3_MICROKERNEL_SRCS,
412
            ),
413
        ] if not is_arvr_mode() else []),
414
        preferred_linkage = "static",
415
        preprocessor_flags = [
416
            "-DXNN_LOG_LEVEL=0",
417
        ],
418
        visibility = ["PUBLIC"],
419
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mssse3"],
420
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mssse3"],
421
        deps = [
422
            ":interface",
423
            third_party("FP16"),
424
        ],
425
    )
426

427
    fb_xplat_cxx_library(
428
        name = "ukernels_ssse3_ovr_win32",
429
        headers = subdir_glob([
430
            ("XNNPACK/src", "**/*.c"),
431
            ("XNNPACK/src", "**/*.h"),
432
        ]),
433
        header_namespace = "",
434
        apple_sdks = (IOS, MACOSX, APPLETVOS),
435
        compiler_flags = [
436
            "-O2",
437
        ],
438
        fbobjc_preprocessor_flags = [
439
            "-DXNN_PRIVATE=",
440
            "-DXNN_INTERNAL=",
441
        ],
442
        labels = labels,
443
        platform_compiler_flags = [
444
            (
445
                "x86",
446
                [
447
                    "-mssse3",
448
                ],
449
            ),
450
        ],
451
        preferred_linkage = "static",
452
        preprocessor_flags = [
453
            "-DXNN_LOG_LEVEL=0",
454
        ],
455
        visibility = ["PUBLIC"],
456
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mssse3"],
457
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mssse3"],
458
        windows_srcs = PROD_SSSE3_MICROKERNEL_SRCS,
459
        deps = [
460
            ":interface",
461
            third_party("FP16"),
462
        ],
463
    )
464

465
    fb_xplat_cxx_library(
466
        name = "ukernels_sse41",
467
        srcs = PROD_SSE41_MICROKERNEL_SRCS if is_arvr_mode() else [],
468
        headers = subdir_glob([
469
            ("XNNPACK/src", "**/*.c"),
470
            ("XNNPACK/src", "**/*.h"),
471
        ]),
472
        header_namespace = "",
473
        apple_sdks = (IOS, MACOSX, APPLETVOS),
474
        compiler_flags = [
475
            "-O2",
476
        ],
477
        fbobjc_preprocessor_flags = [
478
            "-DXNN_PRIVATE=",
479
            "-DXNN_INTERNAL=",
480
        ],
481
        labels = labels,
482
        platform_compiler_flags = [
483
            (
484
                "x86",
485
                [
486
                    "-msse4.1",
487
                ],
488
            ),
489
        ],
490
        platform_srcs = ([
491
            (
492
                "x86|x86_64|platform009|platform010",
493
                PROD_SSE41_MICROKERNEL_SRCS,
494
            ),
495
        ] if not is_arvr_mode() else []),
496
        preferred_linkage = "static",
497
        preprocessor_flags = [
498
            "-DXNN_LOG_LEVEL=0",
499
        ],
500
        visibility = ["PUBLIC"],
501
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-msse4.1"],
502
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-msse4.1"],
503
        deps = [
504
            ":interface",
505
            third_party("FP16"),
506
        ],
507
    )
508

509
    fb_xplat_cxx_library(
510
        name = "ukernels_sse41_ovr_win32",
511
        headers = subdir_glob([
512
            ("XNNPACK/src", "**/*.c"),
513
            ("XNNPACK/src", "**/*.h"),
514
        ]),
515
        header_namespace = "",
516
        apple_sdks = (IOS, MACOSX, APPLETVOS),
517
        compiler_flags = [
518
            "-O2",
519
        ],
520
        fbobjc_preprocessor_flags = [
521
            "-DXNN_PRIVATE=",
522
            "-DXNN_INTERNAL=",
523
        ],
524
        labels = labels,
525
        platform_compiler_flags = [
526
            (
527
                "x86",
528
                [
529
                    "-msse4.1",
530
                ],
531
            ),
532
        ],
533
        preferred_linkage = "static",
534
        preprocessor_flags = [
535
            "-DXNN_LOG_LEVEL=0",
536
        ],
537
        visibility = ["PUBLIC"],
538
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-msse4.1"],
539
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-msse4.1"],
540
        windows_srcs = PROD_SSE41_MICROKERNEL_SRCS,
541
        deps = [
542
            ":interface",
543
            third_party("FP16"),
544
        ],
545
    )
546

547
    fb_xplat_cxx_library(
548
        name = "ukernels_avx",
549
        srcs = PROD_AVX_MICROKERNEL_SRCS if is_arvr_mode() else [],
550
        headers = subdir_glob([
551
            ("XNNPACK/src", "**/*.h"),
552
            ("XNNPACK/src", "**/*.c"),
553
        ]),
554
        header_namespace = "",
555
        apple_sdks = (IOS, MACOSX, APPLETVOS),
556
        compiler_flags = [
557
            "-O2",
558
        ] + select({
559
            "DEFAULT": [],
560
            "ovr_config//cpu:x86_32": [
561
                "-mavx",
562
            ],
563
            "ovr_config//cpu:x86_64": [
564
                "-mavx",
565
            ],
566
        }),
567
        fbobjc_preprocessor_flags = [
568
            "-DXNN_PRIVATE=",
569
            "-DXNN_INTERNAL=",
570
        ],
571
        labels = labels,
572
        platform_compiler_flags = [
573
            (
574
                "x86|x86_64|platform009|platform010",
575
                [
576
                    "-mavx",
577
                ],
578
            ),
579
        ],
580
        platform_srcs = ([
581
            (
582
                "x86|x86_64|platform009|platform010",
583
                PROD_AVX_MICROKERNEL_SRCS,
584
            ),
585
        ] if not is_arvr_mode() else []),
586
        preferred_linkage = "static",
587
        preprocessor_flags = [
588
            "-DXNN_LOG_LEVEL=0",
589
        ],
590
        visibility = ["PUBLIC"],
591
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mavx"],
592
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mavx"],
593
        deps = [
594
            ":interface",
595
        ],
596
    )
597

598
    fb_xplat_cxx_library(
599
        name = "ukernels_avx_ovr_win32",
600
        headers = subdir_glob([
601
            ("XNNPACK/src", "**/*.h"),
602
            ("XNNPACK/src", "**/*.c"),
603
        ]),
604
        header_namespace = "",
605
        apple_sdks = (IOS, MACOSX, APPLETVOS),
606
        compiler_flags = [
607
            "-O2",
608
            "-mavx",
609
        ],
610
        fbobjc_preprocessor_flags = [
611
            "-DXNN_PRIVATE=",
612
            "-DXNN_INTERNAL=",
613
        ],
614
        labels = labels,
615
        platform_compiler_flags = [
616
            (
617
                "x86",
618
                [
619
                    "-mavx",
620
                ],
621
            ),
622
        ],
623
        preferred_linkage = "static",
624
        preprocessor_flags = [
625
            "-DXNN_LOG_LEVEL=0",
626
        ],
627
        visibility = ["PUBLIC"],
628
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mavx"],
629
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mavx"],
630
        windows_srcs = PROD_AVX_MICROKERNEL_SRCS,
631
        deps = [
632
            ":interface",
633
        ],
634
    )
635

636
    fb_xplat_cxx_library(
637
        name = "ukernels_avx512vnni",
638
        srcs = PROD_AVX512VNNI_MICROKERNEL_SRCS if is_arvr_mode() else [],
639
        headers = subdir_glob([
640
            ("XNNPACK/src", "**/*.h"),
641
            ("XNNPACK/src", "**/*.c"),
642
        ]),
643
        header_namespace = "",
644
        apple_sdks = (IOS, MACOSX, APPLETVOS),
645
        compiler_flags = [
646
            "-O2",
647
        ] + select({
648
            "DEFAULT": [],
649
            "ovr_config//cpu:x86_32": [
650
                "-mavx",
651
            ],
652
            "ovr_config//cpu:x86_64": [
653
                "-mavx",
654
            ],
655
        }),
656
        fbobjc_preprocessor_flags = [
657
            "-DXNN_PRIVATE=",
658
            "-DXNN_INTERNAL=",
659
        ],
660
        labels = labels,
661
        platform_compiler_flags = [
662
            (
663
                "x86|x86_64|platform009|platform010",
664
                [
665
                    "-mavx512f",
666
                    "-mavx512cd",
667
                    "-mavx512bw",
668
                    "-mavx512dq",
669
                    "-mavx512vl",
670
                    "-mavx512vnni",
671
                ],
672
            ),
673
        ],
674
        platform_srcs = ([
675
            (
676
                "x86|x86_64|platform009|platform010",
677
                PROD_AVX512VNNI_MICROKERNEL_SRCS,
678
            ),
679
        ] if not is_arvr_mode() else []),
680
        preferred_linkage = "static",
681
        preprocessor_flags = [
682
            "-DXNN_LOG_LEVEL=0",
683
        ],
684
        visibility = ["PUBLIC"],
685
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mavx"],
686
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mavx"],
687
        deps = [
688
            ":interface",
689
        ],
690
    )
691

692
    fb_xplat_cxx_library(
693
        name = "ukernels_avx512vnni_ovr_win32",
694
        headers = subdir_glob([
695
            ("XNNPACK/src", "**/*.h"),
696
            ("XNNPACK/src", "**/*.c"),
697
        ]),
698
        header_namespace = "",
699
        apple_sdks = (IOS, MACOSX, APPLETVOS),
700
        compiler_flags = [
701
            "-O2",
702
        ],
703
        fbobjc_preprocessor_flags = [
704
            "-DXNN_PRIVATE=",
705
            "-DXNN_INTERNAL=",
706
        ],
707
        labels = labels,
708
        platform_compiler_flags = [
709
            (
710
                "x86|x86_64|platform009|platform010",
711
                [
712
                    "-mavx512f",
713
                    "-mavx512cd",
714
                    "-mavx512bw",
715
                    "-mavx512dq",
716
                    "-mavx512vl",
717
                    "-mavx512vnni",
718
                ],
719
            ),
720
        ],
721
        preferred_linkage = "static",
722
        preprocessor_flags = [
723
            "-DXNN_LOG_LEVEL=0",
724
        ],
725
        visibility = ["PUBLIC"],
726
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mavx"],
727
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mavx"],
728
        windows_srcs = PROD_AVX512VNNI_MICROKERNEL_SRCS,
729
        deps = [
730
            ":interface",
731
        ],
732
    )
733

734
    fb_xplat_cxx_library(
735
        name = "ukernels_avxvnni",
736
        srcs = PROD_AVXVNNI_MICROKERNEL_SRCS if is_arvr_mode() else [],
737
        headers = subdir_glob([
738
            ("XNNPACK/src", "**/*.h"),
739
            ("XNNPACK/src", "**/*.c"),
740
        ]),
741
        header_namespace = "",
742
        apple_sdks = (IOS, MACOSX, APPLETVOS),
743
        compiler_flags = [
744
            "-O2",
745
        ],
746
        fbobjc_preprocessor_flags = [
747
            "-DXNN_PRIVATE=",
748
            "-DXNN_INTERNAL=",
749
        ],
750
        labels = labels,
751
        platform_compiler_flags = [
752
            (
753
                "x86|x86_64|platform009|platform010",
754
                [
755
                    "-mavx2",
756
                    "-mavxvnni",
757
                ],
758
            ),
759
        ],
760
        platform_srcs = ([
761
            (
762
                "x86|x86_64|platform009|platform010",
763
                PROD_AVXVNNI_MICROKERNEL_SRCS,
764
            ),
765
        ] if not is_arvr_mode() else []),
766
        preferred_linkage = "static",
767
        preprocessor_flags = [
768
            "-DXNN_LOG_LEVEL=0",
769
        ],
770
        visibility = ["PUBLIC"],
771
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mavx"],
772
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mavx"],
773
        deps = [
774
            ":interface",
775
        ],
776
    )
777

778
    fb_xplat_cxx_library(
779
        name = "ukernels_avxvnni_ovr_win32",
780
        headers = subdir_glob([
781
            ("XNNPACK/src", "**/*.h"),
782
            ("XNNPACK/src", "**/*.c"),
783
        ]),
784
        header_namespace = "",
785
        apple_sdks = (IOS, MACOSX, APPLETVOS),
786
        compiler_flags = [
787
            "-O2",
788
        ],
789
        fbobjc_preprocessor_flags = [
790
            "-DXNN_PRIVATE=",
791
            "-DXNN_INTERNAL=",
792
        ],
793
        labels = labels,
794
        platform_compiler_flags = [
795
            (
796
                "x86|x86_64|platform009|platform010",
797
                [
798
                    "-mavx2",
799
                    "-mavxvnni",
800
                ],
801
            ),
802
        ],
803
        preferred_linkage = "static",
804
        preprocessor_flags = [
805
            "-DXNN_LOG_LEVEL=0",
806
        ],
807
        visibility = ["PUBLIC"],
808
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mavx"],
809
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mavx"],
810
        windows_srcs = PROD_AVXVNNI_MICROKERNEL_SRCS,
811
        deps = [
812
            ":interface",
813
        ],
814
    )
815

816
    fb_xplat_cxx_library(
817
        name = "ukernels_f16c",
818
        srcs = PROD_F16C_MICROKERNEL_SRCS if is_arvr_mode() else [],
819
        headers = subdir_glob([
820
            ("XNNPACK/src", "**/*.h"),
821
            ("XNNPACK/src", "**/*.c"),
822
        ]),
823
        header_namespace = "",
824
        apple_sdks = (IOS, MACOSX, APPLETVOS),
825
        compiler_flags = [
826
            "-O2",
827
        ] + select({
828
            "DEFAULT": [],
829
            "ovr_config//cpu:x86_32": [
830
                "-mf16c",
831
            ],
832
            "ovr_config//cpu:x86_64": [
833
                "-mf16c",
834
            ],
835
        }),
836
        fbobjc_preprocessor_flags = [
837
            "-DXNN_PRIVATE=",
838
            "-DXNN_INTERNAL=",
839
        ],
840
        labels = labels,
841
        platform_compiler_flags = [
842
            (
843
                "x86|x86_64|platform009|platform010",
844
                [
845
                    "-mf16c",
846
                ],
847
            ),
848
        ],
849
        platform_srcs = ([
850
            (
851
                "x86|x86_64|platform009|platform010",
852
                PROD_F16C_MICROKERNEL_SRCS,
853
            ),
854
        ] if not is_arvr_mode() else []),
855
        platforms = (APPLE, ANDROID, CXX, WINDOWS),
856
        preferred_linkage = "static",
857
        preprocessor_flags = [
858
            "-DXNN_LOG_LEVEL=0",
859
        ],
860
        visibility = ["PUBLIC"],
861
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mf16c"],
862
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mf16c"],
863
        deps = [
864
            ":interface",
865
        ],
866
    )
867

868
    fb_xplat_cxx_library(
869
        name = "ukernels_f16c_ovr_win32",
870
        headers = subdir_glob([
871
            ("XNNPACK/src", "**/*.h"),
872
            ("XNNPACK/src", "**/*.c"),
873
        ]),
874
        header_namespace = "",
875
        apple_sdks = (IOS, MACOSX, APPLETVOS),
876
        compiler_flags = [
877
            "-O2",
878
            "-mf16c",
879
        ],
880
        fbobjc_preprocessor_flags = [
881
            "-DXNN_PRIVATE=",
882
            "-DXNN_INTERNAL=",
883
        ],
884
        labels = labels,
885
        platform_compiler_flags = [
886
            (
887
                "x86",
888
                [
889
                    "-mf16c",
890
                ],
891
            ),
892
        ],
893
        platforms = (APPLE, ANDROID, CXX, WINDOWS),
894
        preferred_linkage = "static",
895
        preprocessor_flags = [
896
            "-DXNN_LOG_LEVEL=0",
897
        ],
898
        visibility = ["PUBLIC"],
899
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mf16c"],
900
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mf16c"],
901
        windows_srcs = PROD_F16C_MICROKERNEL_SRCS,
902
        deps = [
903
            ":interface",
904
        ],
905
    )
906

907
    fb_xplat_cxx_library(
908
        name = "ukernels_xop",
909
        srcs = PROD_XOP_MICROKERNEL_SRCS if is_arvr_mode() else [],
910
        headers = subdir_glob([
911
            ("XNNPACK/src", "**/*.h"),
912
            ("XNNPACK/src", "**/*.c"),
913
        ]),
914
        header_namespace = "",
915
        apple_sdks = (IOS, MACOSX, APPLETVOS),
916
        compiler_flags = [
917
            "-O2",
918
        ] + select({
919
            "DEFAULT": [],
920
            "ovr_config//cpu:x86_32": [
921
                "-mxop",
922
            ],
923
            "ovr_config//cpu:x86_64": [
924
                "-mxop",
925
            ],
926
        }),
927
        platform_compiler_flags = [
928
            (
929
                "x86|x86_64|platform009|platform010",
930
                [
931
                    "-mxop",
932
                ],
933
            ),
934
        ],
935
        fbobjc_preprocessor_flags = [
936
            "-DXNN_PRIVATE=",
937
            "-DXNN_INTERNAL=",
938
        ],
939
        labels = labels,
940
        platform_preprocessor_flags = [
941
            (
942
                "windows-x86_64",
943
                [
944
                    "-Drestrict=",
945
                ],
946
            ),
947
        ],
948
        platform_srcs = ([
949
            (
950
                "x86|x86_64|platform009|platform010",
951
                PROD_XOP_MICROKERNEL_SRCS,
952
            ),
953
        ] if not is_arvr_mode() else []),
954
        preferred_linkage = "static",
955
        preprocessor_flags = [
956
            "-DXNN_LOG_LEVEL=0",
957
        ],
958
        visibility = ["PUBLIC"],
959
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mxop"],
960
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mxop"],
961
        deps = [
962
            ":interface",
963
        ],
964
    )
965

966
    fb_xplat_cxx_library(
967
        name = "ukernels_xop_ovr_win32",
968
        headers = subdir_glob([
969
            ("XNNPACK/src", "**/*.h"),
970
            ("XNNPACK/src", "**/*.c"),
971
        ]),
972
        header_namespace = "",
973
        apple_sdks = (IOS, MACOSX, APPLETVOS),
974
        compiler_flags = [
975
            "-O2",
976
            "-mxop",
977
        ],
978
        fbobjc_preprocessor_flags = [
979
            "-DXNN_PRIVATE=",
980
            "-DXNN_INTERNAL=",
981
        ],
982
        labels = labels,
983
        platform_preprocessor_flags = [
984
            (
985
                "windows-x86_64",
986
                [
987
                    "-Drestrict=",
988
                ],
989
            ),
990
        ],
991
        preferred_linkage = "static",
992
        preprocessor_flags = [
993
            "-DXNN_LOG_LEVEL=0",
994
        ],
995
        visibility = ["PUBLIC"],
996
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mxop"],
997
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mxop"],
998
        windows_srcs = PROD_XOP_MICROKERNEL_SRCS,
999
        deps = [
1000
            ":interface",
1001
        ],
1002
    )
1003

1004
    fb_xplat_cxx_library(
1005
        name = "ukernels_fma3",
1006
        srcs = PROD_FMA3_MICROKERNEL_SRCS if is_arvr_mode() else [],
1007
        headers = subdir_glob([
1008
            ("XNNPACK/src", "**/*.h"),
1009
            ("XNNPACK/src", "**/*.c"),
1010
        ]),
1011
        header_namespace = "",
1012
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1013
        compiler_flags = [
1014
            "-O2",
1015
        ] + select({
1016
            "DEFAULT": [],
1017
            "ovr_config//cpu:x86_32": [
1018
                "-mfma",
1019
                "-mf16c",
1020
            ],
1021
            "ovr_config//cpu:x86_64": [
1022
                "-mfma",
1023
                "-mf16c",
1024
            ],
1025
        }),
1026
        fbobjc_preprocessor_flags = [
1027
            "-DXNN_PRIVATE=",
1028
            "-DXNN_INTERNAL=",
1029
        ],
1030
        labels = labels,
1031
        platform_compiler_flags = [
1032
            (
1033
                "(i[3-6]86|x86|x86_64|AMD64)",
1034
                [
1035
                    "-mfma",
1036
                    "-mf16c",
1037
                ],
1038
            ),
1039
        ],
1040
        platform_srcs = ([
1041
            (
1042
                "x86|x86_64|platform009|platform010",
1043
                PROD_FMA3_MICROKERNEL_SRCS,
1044
            ),
1045
        ] if not is_arvr_mode() else []),
1046
        preferred_linkage = "static",
1047
        preprocessor_flags = [
1048
            "-DXNN_LOG_LEVEL=0",
1049
        ],
1050
        visibility = ["PUBLIC"],
1051
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + [
1052
            "-mfma",
1053
            "-mf16c",
1054
        ],
1055
        windows_compiler_flags_override = WINDOWS_FLAGS + [
1056
            "-mfma",
1057
            "-mf16c",
1058
        ],
1059
        deps = [
1060
            ":interface",
1061
        ],
1062
    )
1063

1064
    fb_xplat_cxx_library(
1065
        name = "ukernels_fma3_ovr_win32",
1066
        headers = subdir_glob([
1067
            ("XNNPACK/src", "**/*.h"),
1068
            ("XNNPACK/src", "**/*.c"),
1069
        ]),
1070
        header_namespace = "",
1071
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1072
        compiler_flags = [
1073
            "-O2",
1074
            "-mfma",
1075
            "-mf16c",
1076
        ],
1077
        fbobjc_preprocessor_flags = [
1078
            "-DXNN_PRIVATE=",
1079
            "-DXNN_INTERNAL=",
1080
        ],
1081
        labels = labels,
1082
        platform_compiler_flags = [
1083
            (
1084
                "^(i[3-6]86|x86|x86_64|AMD64)$",
1085
                [
1086
                    "-mfma",
1087
                    "-mf16c",
1088
                ],
1089
            ),
1090
        ],
1091
        preferred_linkage = "static",
1092
        preprocessor_flags = [
1093
            "-DXNN_LOG_LEVEL=0",
1094
        ],
1095
        visibility = ["PUBLIC"],
1096
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + [
1097
            "-mfma",
1098
            "-mf16c",
1099
        ],
1100
        windows_compiler_flags_override = WINDOWS_FLAGS + [
1101
            "-mfma",
1102
            "-mf16c",
1103
        ],
1104
        windows_srcs = PROD_FMA3_MICROKERNEL_SRCS,
1105
        deps = [
1106
            ":interface",
1107
        ],
1108
    )
1109

1110
    fb_xplat_cxx_library(
1111
        name = "ukernels_avx2",
1112
        srcs = PROD_AVX2_MICROKERNEL_SRCS if is_arvr_mode() else [],
1113
        headers = subdir_glob([
1114
            ("XNNPACK/src", "**/*.c"),
1115
            ("XNNPACK/src", "**/*.h"),
1116
        ]),
1117
        header_namespace = "",
1118
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1119
        compiler_flags = [
1120
            "-O2",
1121
        ] + select({
1122
            "DEFAULT": [],
1123
            "ovr_config//cpu:x86_32": [
1124
                "-mavx2",
1125
                "-mfma",
1126
                "-mf16c",
1127
            ],
1128
            "ovr_config//cpu:x86_64": [
1129
                "-mavx2",
1130
                "-mfma",
1131
                "-mf16c",
1132
            ],
1133
        }),
1134
        fbobjc_preprocessor_flags = [
1135
            "-DXNN_PRIVATE=",
1136
            "-DXNN_INTERNAL=",
1137
        ],
1138
        labels = labels,
1139
        platform_compiler_flags = [
1140
            (
1141
                "x86|x86_64|platform009|platform010",
1142
                [
1143
                    "-mavx2",
1144
                    "-mfma",
1145
                    "-mf16c",
1146
                ],
1147
            ),
1148
        ],
1149
        platform_srcs = ([
1150
            (
1151
                "x86|x86_64|platform009|platform010",
1152
                PROD_AVX2_MICROKERNEL_SRCS,
1153
            ),
1154
        ] if not is_arvr_mode() else []),
1155
        preferred_linkage = "static",
1156
        preprocessor_flags = [
1157
            "-DXNN_LOG_LEVEL=0",
1158
        ],
1159
        visibility = ["PUBLIC"],
1160
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + [
1161
            "-mavx2",
1162
            "-mfma",
1163
            "-mf16c",
1164
        ],
1165
        windows_compiler_flags_override = WINDOWS_FLAGS + [
1166
            "-mavx2",
1167
            "-mfma",
1168
            "-mf16c",
1169
        ],
1170
        deps = [
1171
            ":interface",
1172
        ],
1173
    )
1174

1175
    fb_xplat_cxx_library(
1176
        name = "ukernels_avx2_ovr_win32",
1177
        headers = subdir_glob([
1178
            ("XNNPACK/src", "**/*.c"),
1179
            ("XNNPACK/src", "**/*.h"),
1180
        ]),
1181
        header_namespace = "",
1182
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1183
        compiler_flags = [
1184
            "-O2",
1185
            "-mavx2",
1186
            "-mfma",
1187
            "-mf16c",
1188
        ],
1189
        fbobjc_preprocessor_flags = [
1190
            "-DXNN_PRIVATE=",
1191
            "-DXNN_INTERNAL=",
1192
        ],
1193
        labels = labels,
1194
        platform_compiler_flags = [
1195
            (
1196
                "x86",
1197
                [
1198
                    "-mavx2",
1199
                    "-mfma",
1200
                    "-mf16c",
1201
                ],
1202
            ),
1203
        ],
1204
        preferred_linkage = "static",
1205
        preprocessor_flags = [
1206
            "-DXNN_LOG_LEVEL=0",
1207
        ],
1208
        visibility = ["PUBLIC"],
1209
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + [
1210
            "-mavx2",
1211
            "-mfma",
1212
            "-mf16c",
1213
        ],
1214
        windows_compiler_flags_override = WINDOWS_FLAGS + [
1215
            "-mavx2",
1216
            "-mfma",
1217
            "-mf16c",
1218
        ],
1219
        windows_srcs = PROD_AVX2_MICROKERNEL_SRCS,
1220
        deps = [
1221
            ":interface",
1222
        ],
1223
    )
1224

1225
    fb_xplat_cxx_library(
1226
        name = "ukernels_avx512",
1227
        srcs = PROD_AVX512F_MICROKERNEL_SRCS if is_arvr_mode() else [],
1228
        headers = subdir_glob([
1229
            ("XNNPACK/src", "**/*.c"),
1230
            ("XNNPACK/src", "**/*.h"),
1231
        ]),
1232
        header_namespace = "",
1233
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1234
        compiler_flags = [
1235
            "-O2",
1236
        ] + select({
1237
            "DEFAULT": [],
1238
            "ovr_config//cpu:x86_32": [
1239
                "-mavx512f",
1240
            ],
1241
            "ovr_config//cpu:x86_64": [
1242
                "-mavx512f",
1243
            ],
1244
        }),
1245
        fbobjc_preprocessor_flags = [
1246
            "-DXNN_PRIVATE=",
1247
            "-DXNN_INTERNAL=",
1248
        ],
1249
        labels = labels,
1250
        platform_compiler_flags = [
1251
            (
1252
                "x86|x86_64|platform009|platform010",
1253
                [
1254
                    "-mavx512f",
1255
                ],
1256
            ),
1257
        ],
1258
        platform_srcs = ([
1259
            (
1260
                "x86|x86_64|platform009|platform010",
1261
                PROD_AVX512F_MICROKERNEL_SRCS,
1262
            ),
1263
        ] if not is_arvr_mode() else []),
1264
        preferred_linkage = "static",
1265
        preprocessor_flags = [
1266
            "-DXNN_LOG_LEVEL=0",
1267
        ],
1268
        visibility = ["PUBLIC"],
1269
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mavx512f"],
1270
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mavx512f"],
1271
        deps = [
1272
            ":interface",
1273
        ],
1274
    )
1275

1276
    fb_xplat_cxx_library(
1277
        name = "ukernels_avx512vbmi",
1278
        srcs = PROD_AVX512VBMI_MICROKERNEL_SRCS if is_arvr_mode() else [],
1279
        headers = subdir_glob([
1280
            ("XNNPACK/src", "**/*.c"),
1281
            ("XNNPACK/src", "**/*.h"),
1282
        ]),
1283
        header_namespace = "",
1284
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1285
        compiler_flags = [
1286
            "-O2",
1287
        ] + select({
1288
            "DEFAULT": [],
1289
            "ovr_config//cpu:x86_32": [
1290
                "-mavx512f",
1291
                "-mavx512cd",
1292
                "-mavx512bw",
1293
                "-mavx512dq",
1294
                "-mavx512vl",
1295
                "-mavx512vbmi",
1296
            ],
1297
            "ovr_config//cpu:x86_64": [
1298
                "-mavx512f",
1299
                "-mavx512cd",
1300
                "-mavx512bw",
1301
                "-mavx512dq",
1302
                "-mavx512vl",
1303
                "-mavx512vbmi",
1304
            ],
1305
        }),
1306
        fbobjc_preprocessor_flags = [
1307
            "-DXNN_PRIVATE=",
1308
            "-DXNN_INTERNAL=",
1309
        ],
1310
        labels = labels,
1311
        platform_compiler_flags = [
1312
            (
1313
                "(i[3-6]86|x86|x86_64|AMD64)",
1314
                [
1315
                    "-mavx512f",
1316
                    "-mavx512cd",
1317
                    "-mavx512bw",
1318
                    "-mavx512dq",
1319
                    "-mavx512vl",
1320
                    "-mavx512vbmi",
1321
                ],
1322
            ),
1323
        ],
1324
        platform_srcs = ([
1325
            (
1326
                "x86|x86_64|platform009|platform010",
1327
                PROD_AVX512VBMI_MICROKERNEL_SRCS,
1328
            ),
1329
        ] if not is_arvr_mode() else []),
1330
        preferred_linkage = "static",
1331
        preprocessor_flags = [
1332
            "-DXNN_LOG_LEVEL=0",
1333
        ],
1334
        visibility = ["PUBLIC"],
1335
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + [
1336
            "-mavx512f",
1337
            "-mavx512cd",
1338
            "-mavx512bw",
1339
            "-mavx512dq",
1340
            "-mavx512vl",
1341
            "-mavx512vbmi",
1342
        ],
1343
        windows_compiler_flags_override = WINDOWS_FLAGS + [
1344
            "-mavx512f",
1345
            "-mavx512cd",
1346
            "-mavx512bw",
1347
            "-mavx512dq",
1348
            "-mavx512vl",
1349
            "-mavx512vbmi",
1350
        ],
1351
        deps = [
1352
            ":interface",
1353
        ],
1354
    )
1355

1356
    fb_xplat_cxx_library(
1357
        name = "ukernels_avx512_ovr_win32",
1358
        headers = subdir_glob([
1359
            ("XNNPACK/src", "**/*.c"),
1360
            ("XNNPACK/src", "**/*.h"),
1361
        ]),
1362
        header_namespace = "",
1363
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1364
        compiler_flags = [
1365
            "-O2",
1366
            "-mavx512f",
1367
        ],
1368
        fbobjc_preprocessor_flags = [
1369
            "-DXNN_PRIVATE=",
1370
            "-DXNN_INTERNAL=",
1371
        ],
1372
        labels = labels,
1373
        platform_compiler_flags = [
1374
            (
1375
                "x86",
1376
                [
1377
                    "-mavx512f",
1378
                ],
1379
            ),
1380
        ],
1381
        preferred_linkage = "static",
1382
        preprocessor_flags = [
1383
            "-DXNN_LOG_LEVEL=0",
1384
        ],
1385
        visibility = ["PUBLIC"],
1386
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + ["-mavx512f"],
1387
        windows_compiler_flags_override = WINDOWS_FLAGS + ["-mavx512f"],
1388
        windows_srcs = PROD_AVX512F_MICROKERNEL_SRCS,
1389
        deps = [
1390
            ":interface",
1391
        ],
1392
    )
1393

1394
    fb_xplat_cxx_library(
1395
        name = "ukernels_avx512skx",
1396
        srcs = PROD_AVX512SKX_MICROKERNEL_SRCS if is_arvr_mode() else [],
1397
        headers = subdir_glob([
1398
            ("XNNPACK/src", "**/*.c"),
1399
            ("XNNPACK/src", "**/*.h"),
1400
        ]),
1401
        header_namespace = "",
1402
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1403
        compiler_flags = [
1404
            "-O2",
1405
        ] + select({
1406
            "DEFAULT": [],
1407
            "ovr_config//cpu:x86_32": [
1408
                "-mavx512f",
1409
                "-mavx512cd",
1410
                "-mavx512bw",
1411
                "-mavx512dq",
1412
                "-mavx512vl",
1413
            ],
1414
            "ovr_config//cpu:x86_64": [
1415
                "-mavx512f",
1416
                "-mavx512cd",
1417
                "-mavx512bw",
1418
                "-mavx512dq",
1419
                "-mavx512vl",
1420
            ],
1421
        }),
1422
        fbobjc_preprocessor_flags = [
1423
            "-DXNN_PRIVATE=",
1424
            "-DXNN_INTERNAL=",
1425
        ],
1426
        labels = labels,
1427
        platform_compiler_flags = [
1428
            (
1429
                "(i[3-6]86|x86|x86_64|AMD64)",
1430
                [
1431
                    "-mavx512f",
1432
                    "-mavx512cd",
1433
                    "-mavx512bw",
1434
                    "-mavx512dq",
1435
                    "-mavx512vl",
1436
                ],
1437
            ),
1438
        ],
1439
        platform_srcs = ([
1440
            (
1441
                "x86|x86_64|platform009|platform010",
1442
                PROD_AVX512SKX_MICROKERNEL_SRCS,
1443
            ),
1444
        ] if not is_arvr_mode() else []),
1445
        preferred_linkage = "static",
1446
        preprocessor_flags = [
1447
            "-DXNN_LOG_LEVEL=0",
1448
        ],
1449
        visibility = ["PUBLIC"],
1450
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + [
1451
            "-mavx512f",
1452
            "-mavx512cd",
1453
            "-mavx512bw",
1454
            "-mavx512dq",
1455
            "-mavx512vl",
1456
        ],
1457
        windows_compiler_flags_override = WINDOWS_FLAGS + [
1458
            "-mavx512f",
1459
            "-mavx512cd",
1460
            "-mavx512bw",
1461
            "-mavx512dq",
1462
            "-mavx512vl",
1463
        ],
1464
        deps = [
1465
            ":interface",
1466
        ],
1467
    )
1468

1469
    fb_xplat_cxx_library(
1470
        name = "ukernels_avx512skx_ovr_win32",
1471
        headers = subdir_glob([
1472
            ("XNNPACK/src", "**/*.c"),
1473
            ("XNNPACK/src", "**/*.h"),
1474
        ]),
1475
        header_namespace = "",
1476
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1477
        compiler_flags = [
1478
            "-O2",
1479
            "-mavx512f",
1480
            "-mavx512cd",
1481
            "-mavx512bw",
1482
            "-mavx512dq",
1483
            "-mavx512vl",
1484
        ],
1485
        fbobjc_preprocessor_flags = [
1486
            "-DXNN_PRIVATE=",
1487
            "-DXNN_INTERNAL=",
1488
        ],
1489
        labels = labels,
1490
        platform_compiler_flags = [
1491
            (
1492
                "^(i[3-6]86|x86|x86_64|AMD64)$",
1493
                [
1494
                    "-mavx512f",
1495
                    "-mavx512cd",
1496
                    "-mavx512bw",
1497
                    "-mavx512dq",
1498
                    "-mavx512vl",
1499
                ],
1500
            ),
1501
        ],
1502
        preferred_linkage = "static",
1503
        preprocessor_flags = [
1504
            "-DXNN_LOG_LEVEL=0",
1505
        ],
1506
        visibility = ["PUBLIC"],
1507
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS + [
1508
            "-mavx512f",
1509
            "-mavx512cd",
1510
            "-mavx512bw",
1511
            "-mavx512dq",
1512
            "-mavx512vl",
1513
        ],
1514
        windows_compiler_flags_override = WINDOWS_FLAGS + [
1515
            "-mavx512f",
1516
            "-mavx512cd",
1517
            "-mavx512bw",
1518
            "-mavx512dq",
1519
            "-mavx512vl",
1520
        ],
1521
        windows_srcs = PROD_AVX512SKX_MICROKERNEL_SRCS,
1522
        deps = [
1523
            ":interface",
1524
        ],
1525
    )
1526

1527
    fb_xplat_cxx_library(
1528
        name = "ukernels_armsimd32",
1529
        srcs = PROD_ARMSIMD32_MICROKERNEL_SRCS,
1530
        headers = subdir_glob([
1531
            ("XNNPACK/src", "**/*.c"),
1532
            ("XNNPACK/src", "**/*.h"),
1533
        ]),
1534
        header_namespace = "",
1535
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1536
        compiler_flags = [
1537
            "-O2",
1538
            "-fno-fast-math",
1539
            "-fno-math-errno",
1540
        ],
1541
        fbobjc_preprocessor_flags = [
1542
            "-DXNN_PRIVATE=",
1543
            "-DXNN_INTERNAL=",
1544
        ],
1545
        labels = labels,
1546
        platform_compiler_flags = [
1547
            (
1548
                "(arm32|aarch32|armv7)",
1549
                [
1550
                    "-marm",
1551
                    "-march=armv6",
1552
                    "-mfpu=vfp",
1553
                    "-munaligned-access",
1554
                ],
1555
            ),
1556
        ],
1557
        preferred_linkage = "static",
1558
        preprocessor_flags = [
1559
            "-DXNN_LOG_LEVEL=0",
1560
        ],
1561
        visibility = ["PUBLIC"],
1562
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
1563
        windows_compiler_flags_override = WINDOWS_FLAGS,
1564
        deps = [
1565
            ":interface",
1566
            third_party("FP16"),
1567
        ],
1568
    )
1569

1570
    fb_xplat_cxx_library(
1571
        name = "ukernels_neon",
1572
        srcs = select({
1573
            "DEFAULT": [],
1574
            "ovr_config//cpu:arm32": PROD_NEON_MICROKERNEL_SRCS,
1575
        }) if is_arvr_mode() else [],
1576
        headers = subdir_glob([
1577
            ("XNNPACK/src", "**/*.c"),
1578
            ("XNNPACK/src", "**/*.h"),
1579
        ]),
1580
        header_namespace = "",
1581
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1582
        compiler_flags = [
1583
            "-O2",
1584
        ] + select({
1585
            "DEFAULT": [],
1586
            "ovr_config//cpu:arm32": [
1587
                "-marm",
1588
                "-march=armv7-a",
1589
                "-mfpu=neon",
1590
            ],
1591
        }),
1592
        fbobjc_preprocessor_flags = [
1593
            "-DXNN_PRIVATE=",
1594
            "-DXNN_INTERNAL=",
1595
        ],
1596
        labels = labels,
1597
        platform_compiler_flags = [
1598
            (
1599
                "(aarch32|arm32|armv7)",
1600
                [
1601
                    "-marm",
1602
                    "-march=armv7-a",
1603
                    "-mfpu=neon",
1604
                ],
1605
            ),
1606
        ],
1607
        platform_srcs = [
1608
            (
1609
                "(aarch32|arm32|armv7)",
1610
                PROD_NEON_MICROKERNEL_SRCS,
1611
            ),
1612
        ] if not is_arvr_mode() else [],
1613
        preferred_linkage = "static",
1614
        preprocessor_flags = [
1615
            "-DXNN_LOG_LEVEL=0",
1616
        ],
1617
        visibility = ["PUBLIC"],
1618
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
1619
        windows_compiler_flags_override = WINDOWS_FLAGS,
1620
        deps = [
1621
            ":interface",
1622
            third_party("FP16"),
1623
        ],
1624
    )
1625

1626
    fb_xplat_cxx_library(
1627
        name = "ukernels_neon_aarch64",
1628
        srcs = select({
1629
            "DEFAULT": [],
1630
            "ovr_config//cpu:arm64": PROD_NEON_MICROKERNEL_SRCS + [PROD_NEON_AARCH64_MICROKERNEL_SRCS[0]],
1631
        }) if is_arvr_mode() else [],
1632
        headers = subdir_glob([
1633
            ("XNNPACK/src", "**/*.c"),
1634
            ("XNNPACK/src", "**/*.h"),
1635
        ]),
1636
        header_namespace = "",
1637
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1638
        compiler_flags = [
1639
            "-O2",
1640
        ],
1641
        fbobjc_preprocessor_flags = [
1642
            "-DXNN_PRIVATE=",
1643
            "-DXNN_INTERNAL=",
1644
        ],
1645
        platform_srcs = [
1646
            (
1647
                "(aarch64|arm64)",
1648
                PROD_NEON_MICROKERNEL_SRCS + [PROD_NEON_AARCH64_MICROKERNEL_SRCS[0]],
1649
            ),
1650
        ] if not is_arvr_mode() else [],
1651
        labels = labels,
1652
        preferred_linkage = "static",
1653
        preprocessor_flags = [
1654
            "-DXNN_LOG_LEVEL=0",
1655
        ],
1656
        visibility = ["PUBLIC"],
1657
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
1658
        windows_compiler_flags_override = WINDOWS_FLAGS,
1659
        deps = [
1660
            ":interface",
1661
            third_party("FP16"),
1662
        ],
1663
    )
1664

1665
    fb_xplat_cxx_library(
1666
        name = "ukernels_neon_fma",
1667
        srcs = select({
1668
            "DEFAULT": [],
1669
            "ovr_config//cpu:arm32": PROD_NEONFMA_MICROKERNEL_SRCS,
1670
        }) if is_arvr_mode() else [],
1671
        headers = subdir_glob([
1672
            ("XNNPACK/src", "**/*.c"),
1673
            ("XNNPACK/src", "**/*.h"),
1674
        ]),
1675
        header_namespace = "",
1676
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1677
        compiler_flags = [
1678
            "-O2",
1679
        ] + select({
1680
            "DEFAULT": [],
1681
            "ovr_config//cpu:arm32": [
1682
                "-marm",
1683
                "-march=armv7-a",
1684
                "-mfpu=neon-vfpv4",
1685
            ],
1686
        }),
1687
        fbobjc_preprocessor_flags = [
1688
            "-DXNN_PRIVATE=",
1689
            "-DXNN_INTERNAL=",
1690
        ],
1691
        labels = labels,
1692
        platform_compiler_flags = [
1693
            (
1694
                "^iphoneos-armv7$",
1695
                [
1696
                    "-mcpu=cyclone",
1697
                    "-mtune=generic",
1698
                ],
1699
            ),
1700
            (
1701
                "(aarch32|arm32|armv7)",
1702
                [
1703
                    "-marm",
1704
                    "-march=armv7-a",
1705
                    "-mfpu=neon-vfpv4",
1706
                ],
1707
            ),
1708
        ],
1709
        platform_srcs = [
1710
            (
1711
                "(aarch32|arm32|armv7)",
1712
                PROD_NEONFMA_MICROKERNEL_SRCS,
1713
            ),
1714
        ] if not is_arvr_mode() else [],
1715
        preferred_linkage = "static",
1716
        preprocessor_flags = [
1717
            "-DXNN_LOG_LEVEL=0",
1718
        ],
1719
        visibility = ["PUBLIC"],
1720
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
1721
        windows_compiler_flags_override = WINDOWS_FLAGS,
1722
        deps = [
1723
            ":interface",
1724
            third_party("FP16"),
1725
        ],
1726
    )
1727

1728
    fb_xplat_cxx_library(
1729
        name = "ukernels_neonfma_aarch64",
1730
        srcs = select({
1731
            "DEFAULT": [],
1732
            "ovr_config//cpu:arm64": PROD_NEONFMA_MICROKERNEL_SRCS + [PROD_NEON_AARCH64_MICROKERNEL_SRCS[1]],
1733
        }) if is_arvr_mode() else [],
1734
        headers = subdir_glob([
1735
            ("XNNPACK/src", "**/*.h"),
1736
            ("XNNPACK/src", "**/*.c"),
1737
        ]),
1738
        header_namespace = "",
1739
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1740
        compiler_flags = [
1741
            "-O2",
1742
        ],
1743
        fbobjc_preprocessor_flags = [
1744
            "-DXNN_PRIVATE=",
1745
            "-DXNN_INTERNAL=",
1746
        ],
1747
        labels = labels,
1748
        platform_srcs = [
1749
            (
1750
                "(arm64|aarch64)$",
1751
                PROD_NEONFMA_MICROKERNEL_SRCS + [PROD_NEON_AARCH64_MICROKERNEL_SRCS[1]],
1752
            ),
1753
        ] if not is_arvr_mode() else [],
1754
        platforms = (APPLE, ANDROID, CXX, WINDOWS),
1755
        preferred_linkage = "static",
1756
        preprocessor_flags = [
1757
            "-DXNN_LOG_LEVEL=0",
1758
        ],
1759
        visibility = ["PUBLIC"],
1760
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
1761
        windows_compiler_flags_override = WINDOWS_FLAGS,
1762
        deps = [
1763
            ":interface",
1764
            third_party("FP16"),
1765
        ],
1766
    )
1767

1768
    fb_xplat_cxx_library(
1769
        name = "ukernels_fp16arith",
1770
        srcs = PROD_FP16ARITH_MICROKERNEL_SRCS,
1771
        headers = subdir_glob([
1772
            ("XNNPACK/src", "**/*.c"),
1773
            ("XNNPACK/src", "**/*.h"),
1774
        ]),
1775
        header_namespace = "",
1776
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1777
        compiler_flags = [
1778
            "-O2",
1779
            "-Wno-error=missing-braces",  # required since the SGX toolchain does not have this by default
1780
            "-fno-fast-math",
1781
            "-fno-math-errno",
1782
        ] + select({
1783
            "DEFAULT": [],
1784
            "ovr_config//cpu:arm32": [
1785
                "-marm",
1786
                "-march=armv8.2-a+fp16",
1787
                # GCC emits wrong directives for assembler with -mfpu=fp-armv8
1788
                "-mfpu=neon-fp-armv8",
1789
                # For vsqrth_f16 polyfill using sqrtf
1790
                "-fno-math-errno",
1791
                # For vminh_f16/vmaxh_f16 polyfills using compare + select
1792
                "-ffinite-math-only",
1793
            ],
1794
        }),
1795
        fbobjc_preprocessor_flags = [
1796
            "-DXNN_PRIVATE=",
1797
            "-DXNN_INTERNAL=",
1798
        ],
1799
        labels = labels,
1800
        platform_compiler_flags = [
1801
            (
1802
                "(aarch32|arm32|armv7)",
1803
                [
1804
                    "-marm",
1805
                    "-march=armv8.2-a+fp16",
1806
                    # GCC emits wrong directives for assembler with -mfpu=fp-armv8
1807
                    "-mfpu=neon-fp-armv8",
1808
                    # For vsqrth_f16 polyfill using sqrtf
1809
                    "-fno-math-errno",
1810
                    # For vminh_f16/vmaxh_f16 polyfills using compare + select
1811
                    "-ffinite-math-only",
1812
                ],
1813
            ),
1814
        ],
1815
        preferred_linkage = "static",
1816
        preprocessor_flags = [
1817
            "-DXNN_LOG_LEVEL=0",
1818
        ],
1819
        visibility = ["PUBLIC"],
1820
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
1821
        windows_compiler_flags_override = WINDOWS_FLAGS,
1822
        deps = [
1823
            ":interface",
1824
        ],
1825
    )
1826

1827
    fb_xplat_cxx_library(
1828
        name = "ukernels_neon_fp16",
1829
        srcs = PROD_NEONFP16_MICROKERNEL_SRCS,
1830
        headers = subdir_glob([
1831
            ("XNNPACK/src", "**/*.c"),
1832
            ("XNNPACK/src", "**/*.h"),
1833
        ]),
1834
        header_namespace = "",
1835
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1836
        compiler_flags = [
1837
            "-O2",
1838
        ] + select({
1839
            "DEFAULT": [],
1840
            "ovr_config//cpu:arm32": [
1841
                "-marm",
1842
                "-march=armv7-a",
1843
                "-mfpu=neon-fp16",
1844
            ],
1845
        }),
1846
        fbobjc_preprocessor_flags = [
1847
            "-DXNN_PRIVATE=",
1848
            "-DXNN_INTERNAL=",
1849
        ],
1850
        labels = labels,
1851
        platform_compiler_flags = [
1852
            (
1853
                "(aarch32|arm32|armv7)",
1854
                [
1855
                    "-marm",
1856
                    "-march=armv7-a",
1857
                    "-mfpu=neon-fp16",
1858
                ],
1859
            ),
1860
        ],
1861
        preferred_linkage = "static",
1862
        preprocessor_flags = [
1863
            "-DXNN_LOG_LEVEL=0",
1864
        ],
1865
        visibility = ["PUBLIC"],
1866
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
1867
        windows_compiler_flags_override = WINDOWS_FLAGS,
1868
        deps = [
1869
            ":interface",
1870
        ],
1871
    )
1872

1873
    fb_xplat_cxx_library(
1874
        name = "ukernels_neon_v8",
1875
        srcs = PROD_NEONV8_MICROKERNEL_SRCS,
1876
        headers = subdir_glob([
1877
            ("XNNPACK/src", "**/*.c"),
1878
            ("XNNPACK/src", "**/*.h"),
1879
        ]),
1880
        header_namespace = "",
1881
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1882
        compiler_flags = [
1883
            "-O2",
1884
        ] + select({
1885
            "DEFAULT": [],
1886
            "ovr_config//cpu:arm64": ["-march=armv8-a"],
1887
        }),
1888
        fbobjc_preprocessor_flags = [
1889
            "-DXNN_PRIVATE=",
1890
            "-DXNN_INTERNAL=",
1891
        ],
1892
        labels = labels,
1893
        platform_compiler_flags = [
1894
            (
1895
                "(aarch64|arm64)",
1896
                [
1897
                    "-march=armv8-a",
1898
                ],
1899
            ),
1900
            (
1901
                "^android-armv7$",
1902
                [
1903
                    "-march=armv8-a",
1904
                    "-mfpu=neon-fp-armv8",
1905
                    "-mfloat-abi=softfp",
1906
                ],
1907
            ),
1908
            (
1909
                "^iphoneos-armv7$",
1910
                [
1911
                    "-mcpu=cyclone",
1912
                    "-mtune=generic",
1913
                ],
1914
            ),
1915
        ],
1916
        preferred_linkage = "static",
1917
        preprocessor_flags = [
1918
            "-DXNN_LOG_LEVEL=0",
1919
        ],
1920
        visibility = ["PUBLIC"],
1921
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
1922
        windows_compiler_flags_override = WINDOWS_FLAGS,
1923
        deps = [
1924
            ":interface",
1925
            third_party("FP16"),
1926
        ],
1927
    )
1928

1929
    fb_xplat_cxx_library(
1930
        name = "ukernels_neon_dot",
1931
        srcs = select({
1932
            "DEFAULT": [],
1933
            "ovr_config//cpu:arm32": PROD_NEONDOT_MICROKERNEL_SRCS,
1934
        }) if is_arvr_mode() else [],
1935
        headers = subdir_glob([
1936
            ("XNNPACK/src", "**/*.c"),
1937
            ("XNNPACK/src", "**/*.h"),
1938
        ]),
1939
        header_namespace = "",
1940
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1941
        compiler_flags = [
1942
            "-O2",
1943
        ] + select({
1944
            "DEFAULT": [],
1945
            "ovr_config//cpu:arm32": [
1946
                "-march=armv8.2-a+dotprod",
1947
                "-mfpu=neon-fp-armv8",
1948
                "-mfloat-abi=softfp",
1949
            ],
1950
        }),
1951
        fbobjc_preprocessor_flags = [
1952
            "-DXNN_PRIVATE=",
1953
            "-DXNN_INTERNAL=",
1954
        ],
1955
        labels = labels,
1956
        platform_compiler_flags = [
1957
            (
1958
                "(aarch32|arm32|armv7)",
1959
                [
1960
                    "-march=armv8.2-a+dotprod",
1961
                    "-mfpu=neon-fp-armv8",
1962
                    "-mfloat-abi=softfp",
1963
                ],
1964
            ),
1965
        ],
1966
        platform_srcs = [
1967
            (
1968
                "(aarch32|arm32|armv7)",
1969
                PROD_NEONDOT_MICROKERNEL_SRCS,
1970
            ),
1971
        ] if not is_arvr_mode() else [],
1972
        preferred_linkage = "static",
1973
        preprocessor_flags = [
1974
            "-DXNN_LOG_LEVEL=0",
1975
        ],
1976
        visibility = ["PUBLIC"],
1977
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
1978
        windows_compiler_flags_override = WINDOWS_FLAGS,
1979
        deps = [
1980
            ":interface",
1981
            third_party("FP16"),
1982
        ],
1983
    )
1984

1985
    fb_xplat_cxx_library(
1986
        name = "ukernels_neon_dot_aarch64",
1987
        srcs = select({
1988
            "DEFAULT": [],
1989
            "ovr_config//cpu:arm64": PROD_NEONDOT_MICROKERNEL_SRCS + PROD_NEONDOT_AARCH64_MICROKERNEL_SRCS,
1990
        }) if is_arvr_mode() else [],
1991
        headers = subdir_glob([
1992
            ("XNNPACK/src", "**/*.c"),
1993
            ("XNNPACK/src", "**/*.h"),
1994
        ]),
1995
        header_namespace = "",
1996
        apple_sdks = (IOS, MACOSX, APPLETVOS),
1997
        compiler_flags = [
1998
            "-O2",
1999
        ] + select({
2000
            "DEFAULT": [],
2001
            "ovr_config//cpu:arm64": ["-march=armv8.2-a+dotprod"],
2002
        }),
2003
        fbobjc_preprocessor_flags = [
2004
            "-DXNN_PRIVATE=",
2005
            "-DXNN_INTERNAL=",
2006
        ],
2007
        labels = labels,
2008
        platform_compiler_flags = [
2009
            (
2010
                "(aarch64|arm64)",
2011
                [
2012
                    "-march=armv8.2-a+dotprod",
2013
                ],
2014
            ),
2015
        ],
2016
        platform_srcs = [
2017
            (
2018
                "(aarch64|arm64)",
2019
                PROD_NEONDOT_MICROKERNEL_SRCS + PROD_NEONDOT_AARCH64_MICROKERNEL_SRCS,
2020
            ),
2021
        ] if not is_arvr_mode() else [],
2022
        preferred_linkage = "static",
2023
        preprocessor_flags = [
2024
            "-DXNN_LOG_LEVEL=0",
2025
        ],
2026
        visibility = ["PUBLIC"],
2027
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
2028
        windows_compiler_flags_override = WINDOWS_FLAGS,
2029
        deps = [
2030
            ":interface",
2031
            third_party("FP16"),
2032
        ],
2033
    )
2034

2035
    fb_xplat_cxx_library(
2036
        name = "ukernels_neon_dot_fp16arith",
2037
        srcs = select({
2038
            "DEFAULT": [],
2039
            "ovr_config//cpu:arm32": PROD_NEONDOTFP16ARITH_MICROKERNEL_SRCS,
2040
        }) if is_arvr_mode() else [],
2041
        headers = subdir_glob([
2042
            ("XNNPACK/src", "**/*.c"),
2043
            ("XNNPACK/src", "**/*.h"),
2044
        ]),
2045
        header_namespace = "",
2046
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2047
        compiler_flags = [
2048
            "-O2",
2049
        ] + select({
2050
            "DEFAULT": [],
2051
            "ovr_config//cpu:arm32": [
2052
                "-marm",
2053
                "-march=armv8.2-a+dotprod+fp16",
2054
                "-mfpu=neon-fp-armv8",
2055
            ],
2056
        }),
2057
        platform_compiler_flags = [
2058
            (
2059
                "(aarch32|arm32|armv7)",
2060
                [
2061
                    "-marm",
2062
                    "-march=armv8.2-a+dotprod+fp16",
2063
                    "-mfpu=neon-fp-armv8",
2064
                ],
2065
            ),
2066
        ],
2067
        platform_srcs = [
2068
            (
2069
                "(aarch32|arm32|armv7)",
2070
                PROD_NEONDOTFP16ARITH_MICROKERNEL_SRCS,
2071
            ),
2072
        ] if not is_arvr_mode() else [],
2073
        fbobjc_preprocessor_flags = [
2074
            "-DXNN_PRIVATE=",
2075
            "-DXNN_INTERNAL=",
2076
        ],
2077
        labels = labels,
2078
        preferred_linkage = "static",
2079
        preprocessor_flags = [
2080
            "-DXNN_LOG_LEVEL=0",
2081
        ],
2082
        visibility = ["PUBLIC"],
2083
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
2084
        windows_compiler_flags_override = WINDOWS_FLAGS,
2085
        deps = [
2086
            ":interface",
2087
            third_party("FP16"),
2088
        ],
2089
    )
2090

2091
    fb_xplat_cxx_library(
2092
        name = "ukernels_neon_dot_fp16arith_aarch64",
2093
        srcs = select({
2094
            "DEFAULT": [],
2095
            "ovr_config//cpu:arm64": PROD_NEONDOTFP16ARITH_MICROKERNEL_SRCS + PROD_NEONDOTFP16ARITH_AARCH64_MICROKERNEL_SRCS,
2096
        }) if is_arvr_mode() else [],
2097
        headers = subdir_glob([
2098
            ("XNNPACK/src", "**/*.c"),
2099
            ("XNNPACK/src", "**/*.h"),
2100
        ]),
2101
        header_namespace = "",
2102
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2103
        compiler_flags = [
2104
            "-O2",
2105
        ] + select({
2106
            "DEFAULT": [],
2107
            "ovr_config//cpu:arm64": [
2108
                "-march=armv8.2-a+dotprod+fp16",
2109
            ],
2110
        }),
2111
        fbobjc_preprocessor_flags = [
2112
            "-DXNN_PRIVATE=",
2113
            "-DXNN_INTERNAL=",
2114
        ],
2115
        platform_compiler_flags = [
2116
            (
2117
                "(aarch64|arm64)",
2118
                [
2119
                    "-march=armv8.2-a+dotprod+fp16",
2120
                ],
2121
            ),
2122
        ],
2123
        platform_srcs = [
2124
            (
2125
                "(aarch64|arm64)",
2126
                PROD_NEONDOTFP16ARITH_MICROKERNEL_SRCS + PROD_NEONDOTFP16ARITH_AARCH64_MICROKERNEL_SRCS,
2127
            ),
2128
        ] if not is_arvr_mode() else [],
2129
        labels = labels,
2130
        preferred_linkage = "static",
2131
        preprocessor_flags = [
2132
            "-DXNN_LOG_LEVEL=0",
2133
        ],
2134
        visibility = ["PUBLIC"],
2135
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
2136
        windows_compiler_flags_override = WINDOWS_FLAGS,
2137
        deps = [
2138
            ":interface",
2139
            third_party("FP16"),
2140
        ],
2141
    )
2142

2143
    fb_xplat_cxx_library(
2144
        name = "ukernels_neon_fp16arith",
2145
        srcs = select({
2146
            "DEFAULT": [],
2147
            "ovr_config//cpu:arm32": PROD_NEONFP16ARITH_MICROKERNEL_SRCS,
2148
        }) if is_arvr_mode() else [],
2149
        headers = subdir_glob([
2150
            ("XNNPACK/src", "**/*.c"),
2151
            ("XNNPACK/src", "**/*.h"),
2152
        ]),
2153
        header_namespace = "",
2154
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2155
        compiler_flags = [
2156
            "-O2",
2157
        ] + select({
2158
            "DEFAULT": [],
2159
            "ovr_config//cpu:arm32": [
2160
                "-marm",
2161
                "-march=armv8.2-a+fp16",
2162
                "-mfpu=neon-fp-armv8",
2163
            ],
2164
        }),
2165
        fbobjc_preprocessor_flags = [
2166
            "-DXNN_PRIVATE=",
2167
            "-DXNN_INTERNAL=",
2168
        ],
2169
        labels = labels,
2170
        platform_compiler_flags = [
2171
            (
2172
                "(aarch32|arm32|armv7)",
2173
                [
2174
                    "-marm",
2175
                    "-march=armv8.2-a+fp16",
2176
                    "-mfpu=neon-fp-armv8",
2177
                ],
2178
            ),
2179
        ],
2180
        platform_srcs = [
2181
            (
2182
                "(aarch32|arm32|armv7)",
2183
                PROD_NEONFP16ARITH_MICROKERNEL_SRCS,
2184
            ),
2185
        ] if not is_arvr_mode() else [],
2186
        preferred_linkage = "static",
2187
        preprocessor_flags = [
2188
            "-DXNN_LOG_LEVEL=0",
2189
        ],
2190
        visibility = ["PUBLIC"],
2191
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
2192
        windows_compiler_flags_override = WINDOWS_FLAGS,
2193
        deps = [
2194
            ":interface",
2195
            third_party("FP16"),
2196
        ],
2197
    )
2198

2199
    fb_xplat_cxx_library(
2200
        name = "ukernels_neon_fp16arith_aarch64",
2201
        srcs = select({
2202
            "DEFAULT": [],
2203
            "ovr_config//cpu:arm64": PROD_NEONFP16ARITH_MICROKERNEL_SRCS + PROD_NEONFP16ARITH_AARCH64_MICROKERNEL_SRCS,
2204
        }) if is_arvr_mode() else [],
2205
        headers = subdir_glob([
2206
            ("XNNPACK/src", "**/*.c"),
2207
            ("XNNPACK/src", "**/*.h"),
2208
        ]),
2209
        header_namespace = "",
2210
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2211
        compiler_flags = [
2212
            "-O2",
2213
        ] + select({
2214
            "DEFAULT": [],
2215
            "ovr_config//cpu:arm64": ["-march=armv8.2-a+fp16"],
2216
        }),
2217
        fbobjc_preprocessor_flags = [
2218
            "-DXNN_PRIVATE=",
2219
            "-DXNN_INTERNAL=",
2220
        ],
2221
        labels = labels,
2222
        platform_compiler_flags = [
2223
            (
2224
                "(aarch64|arm64)",
2225
                [
2226
                    "-march=armv8.2-a+fp16",
2227
                ],
2228
            ),
2229
        ],
2230
        platform_srcs = [
2231
            (
2232
                "(aarch64|arm64)",
2233
                PROD_NEONFP16ARITH_MICROKERNEL_SRCS + PROD_NEONFP16ARITH_AARCH64_MICROKERNEL_SRCS,
2234
            ),
2235
        ] if not is_arvr_mode() else [],
2236
        preferred_linkage = "static",
2237
        preprocessor_flags = [
2238
            "-DXNN_LOG_LEVEL=0",
2239
        ],
2240
        visibility = ["PUBLIC"],
2241
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
2242
        windows_compiler_flags_override = WINDOWS_FLAGS,
2243
        deps = [
2244
            ":interface",
2245
            third_party("FP16"),
2246
        ],
2247
    )
2248

2249
    fb_xplat_cxx_library(
2250
        name = "ukernels_neonfma_i8mm",
2251
        srcs = PROD_NEONI8MM_MICROKERNEL_SRCS,
2252
        headers = subdir_glob([
2253
            ("XNNPACK/src", "**/*.h"),
2254
            ("XNNPACK/src", "**/*.c"),
2255
        ]),
2256
        header_namespace = "",
2257
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2258
        compiler_flags = [
2259
            "-O2",
2260
        ] + select({
2261
            "DEFAULT": [],
2262
            "ovr_config//cpu:arm32": [
2263
                "-marm",
2264
                "-march=armv8.2-a+i8mm+fp16",
2265
                "-mfpu=neon-fp-armv8",
2266
            ],
2267
            "ovr_config//cpu:arm64": [
2268
                "-march=armv8.2-a+i8mm+fp16",
2269
            ],
2270
        }),
2271
        fbobjc_preprocessor_flags = [
2272
            "-DXNN_PRIVATE=",
2273
            "-DXNN_INTERNAL=",
2274
        ],
2275
        labels = labels,
2276
        platform_compiler_flags = [
2277
            (
2278
                "(aarch32|arm32|armv7)$",
2279
                [
2280
                    "-marm",
2281
                    "-march=armv8.2-a+i8mm+fp16",
2282
                    "-mfpu=neon-fp-armv8",
2283
                ],
2284
            ),
2285
            (
2286
                "(arm64|aarch64)",
2287
                [
2288
                    "-march=armv8.2-a+i8mm+fp16",
2289
                ],
2290
            ),
2291
        ],
2292
        platforms = (APPLE, ANDROID, CXX, WINDOWS),
2293
        preferred_linkage = "static",
2294
        preprocessor_flags = [
2295
            "-DXNN_LOG_LEVEL=0",
2296
        ],
2297
        visibility = ["PUBLIC"],
2298
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
2299
        windows_compiler_flags_override = WINDOWS_FLAGS,
2300
        deps = [
2301
            ":interface",
2302
            third_party("FP16"),
2303
        ],
2304
    )
2305

2306
    fb_xplat_cxx_library(
2307
        name = "ukernels_asm_aarch32",
2308
        srcs = AARCH32_ASM_MICROKERNEL_SRCS,
2309
        headers = subdir_glob([
2310
            ("XNNPACK/src", "xnnpack/assembly.h"),
2311
            ("XNNPACK/src", "**/*.S"),
2312
        ]),
2313
        header_namespace = "",
2314
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2315
        compiler_flags = [
2316
            "-O2",
2317
        ] + select({
2318
            "DEFAULT": [],
2319
            "ovr_config//cpu:arm32": [
2320
                "-marm",
2321
                "-march=armv8.2-a+dotprod+fp16",
2322
                "-mfpu=neon-fp-armv8",
2323
            ],
2324
        }),
2325
        fbobjc_preprocessor_flags = [
2326
            "-DXNN_PRIVATE=",
2327
            "-DXNN_INTERNAL=",
2328
        ],
2329
        labels = labels,
2330
        platform_compiler_flags = [
2331
            (
2332
                "(aarch32|arm32|armv7)",
2333
                [
2334
                    "-marm",
2335
                    "-march=armv8.2-a+dotprod+fp16",
2336
                    "-mfpu=neon-fp-armv8",
2337
                ],
2338
            ),
2339
        ],
2340
        platforms = (APPLE, ANDROID, CXX, WINDOWS),
2341
        preferred_linkage = "static",
2342
        preprocessor_flags = [
2343
            "-DXNN_LOG_LEVEL=0",
2344
        ],
2345
        visibility = ["PUBLIC"],
2346
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
2347
        windows_compiler_flags_override = WINDOWS_FLAGS,
2348
        deps = [
2349
            ":interface",
2350
            ":jit_memory",
2351
            third_party("FP16"),
2352
        ],
2353
    )
2354

2355
    fb_xplat_cxx_library(
2356
        name = "ukernels_asm_aarch64",
2357
        srcs = AARCH64_ASM_MICROKERNEL_SRCS,
2358
        headers = subdir_glob([
2359
            ("XNNPACK/src", "xnnpack/assembly.h"),
2360
            ("XNNPACK/src", "**/*.S"),
2361
        ]),
2362
        header_namespace = "",
2363
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2364
        compiler_flags = [
2365
            "-O2",
2366
        ] + select({
2367
            "DEFAULT": [],
2368
            "ovr_config//cpu:arm64": [
2369
                "-march=armv8.2-a+fp16+dotprod",
2370
            ],
2371
        }),
2372
        fbobjc_preprocessor_flags = [
2373
            "-DXNN_PRIVATE=",
2374
            "-DXNN_INTERNAL=",
2375
        ],
2376
        labels = labels,
2377
        platform_compiler_flags = [
2378
            (
2379
                "(aarch64|arm64)",
2380
                [
2381
                    "-march=armv8.2-a+fp16+dotprod",
2382
                ],
2383
            ),
2384
        ],
2385
        preferred_linkage = "static",
2386
        preprocessor_flags = [
2387
            "-DXNN_LOG_LEVEL=0",
2388
        ],
2389
        visibility = ["PUBLIC"],
2390
        windows_clang_compiler_flags_override = WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS,
2391
        windows_compiler_flags_override = WINDOWS_FLAGS,
2392
        deps = [
2393
            ":interface",
2394
            ":jit_memory",
2395
            third_party("FP16"),
2396
        ],
2397
    )
2398

2399
    fb_xplat_cxx_library(
2400
        name = "arm64_lib",
2401
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2402
        labels = labels,
2403
        preferred_linkage = "static",
2404
        visibility = ["PUBLIC"],
2405
        deps = [
2406
            ":jit_memory",
2407
            ":ukernels_asm_aarch64",
2408
            ":ukernels_neon",
2409
            ":ukernels_neon_aarch64",
2410
            ":ukernels_neon_dot_fp16arith",
2411
            ":ukernels_neon_dot_fp16arith_aarch64",
2412
            ":ukernels_neon_dot",
2413
            ":ukernels_neon_dot_aarch64",
2414
            ":ukernels_neon_fma",
2415
            ":ukernels_neon_fp16",
2416
            ":ukernels_neon_fp16arith",
2417
            ":ukernels_neon_fp16arith_aarch64",
2418
            ":ukernels_neon_v8",
2419
            ":ukernels_neonfma_aarch64",
2420
            ":ukernels_neonfma_i8mm",
2421
        ],
2422
    )
2423

2424
    fb_xplat_cxx_library(
2425
        name = "x86_and_x86_64_lib",
2426
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2427
        labels = labels,
2428
        preferred_linkage = "static",
2429
        visibility = ["PUBLIC"],
2430
        deps = [
2431
            ":ukernels_avx",
2432
            ":ukernels_avx2",
2433
            ":ukernels_avx512",
2434
            ":ukernels_avx512skx",
2435
            ":ukernels_f16c",
2436
            ":ukernels_fma3",
2437
            ":ukernels_sse",
2438
            ":ukernels_sse2",
2439
            ":ukernels_sse41",
2440
            ":ukernels_ssse3",
2441
            ":ukernels_xop",
2442
            ":ukernels_avx512vbmi",
2443
            ":ukernels_avx512vnni",
2444
            # ":ukernels_avxvnni" Excluding avxvnni microkernels because they fail on older compilers
2445
        ],
2446
    )
2447

2448
    fb_xplat_cxx_library(
2449
        name = "x86_and_x86_64_lib_ovr_win32",
2450
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2451
        labels = labels,
2452
        preferred_linkage = "static",
2453
        visibility = ["PUBLIC"],
2454
        deps = [
2455
            ":ukernels_avx2_ovr_win32",
2456
            ":ukernels_avx512_ovr_win32",
2457
            ":ukernels_avx512skx_ovr_win32",
2458
            ":ukernels_avx_ovr_win32",
2459
            ":ukernels_f16c_ovr_win32",
2460
            ":ukernels_fma3_ovr_win32",
2461
            ":ukernels_sse2_ovr_win32",
2462
            ":ukernels_sse41_ovr_win32",
2463
            ":ukernels_sse_ovr_win32",
2464
            ":ukernels_ssse3_ovr_win32",
2465
            ":ukernels_xop_ovr_win32",
2466
            ":ukernels_avx512vbmi",
2467
            ":ukernels_avx512vnni_ovr_win32",
2468
            # ":ukernels_avxvnni_ovr_win32" Excluding avxvnni microkernels because they fail on older compilers
2469
        ],
2470
    )
2471

2472
    fb_xplat_cxx_library(
2473
        name = "arm_lib",
2474
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2475
        labels = labels,
2476
        preferred_linkage = "static",
2477
        visibility = ["PUBLIC"],
2478
        deps = [
2479
            ":jit_memory",
2480
            ":ukernels_armsimd32",
2481
            ":ukernels_asm_aarch32",
2482
            ":ukernels_asm_aarch64",
2483
            ":ukernels_neon",
2484
            ":ukernels_neon_aarch64",
2485
            ":ukernels_neon_dot",
2486
            ":ukernels_neon_dot_aarch64",
2487
            ":ukernels_neon_dot_fp16arith",
2488
            ":ukernels_neon_dot_fp16arith_aarch64",
2489
            ":ukernels_neon_fma",
2490
            ":ukernels_neon_fp16",
2491
            ":ukernels_neon_fp16arith",
2492
            ":ukernels_neon_fp16arith_aarch64",
2493
            ":ukernels_neon_v8",
2494
            ":ukernels_neonfma_aarch64",
2495
            ":ukernels_neonfma_i8mm",
2496
            ":ukernels_fp16arith",
2497
        ],
2498
    )
2499

2500
    fb_xplat_cxx_library(
2501
        name = "armv7_lib",
2502
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2503
        labels = labels,
2504
        preferred_linkage = "static",
2505
        visibility = ["PUBLIC"],
2506
        deps = [
2507
            ":jit_memory",
2508
            ":ukernels_asm_aarch32",
2509
            ":ukernels_neon",
2510
            ":ukernels_neon_dot",
2511
            ":ukernels_neon_fma",
2512
            ":ukernels_neon_v8",
2513
        ],
2514
    )
2515

2516
    fb_xplat_cxx_library(
2517
        name = "prod_ukernels",
2518
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2519
        labels = labels,
2520
        preferred_linkage = "static",
2521
        visibility = ["PUBLIC"],
2522
        deps = [
2523
            ":ukernels_scalar",
2524
        ] + select({
2525
            "DEFAULT": [
2526
                ":arm_lib",
2527
                ":x86_and_x86_64_lib",
2528
            ],
2529
            "ovr_config//os:windows": [":x86_and_x86_64_lib_ovr_win32"] if XNNPACK_WINDOWS_AVX512F_ENABLED else [
2530
                ":arm_lib",
2531
                ":x86_and_x86_64_lib",
2532
            ],
2533
            # doesn't cover iphonesimulator-x86_64
2534
            "ovr_config//runtime:arm64-linux-ubuntu-neon": [":arm64_lib"],
2535
            "ovr_config//runtime:platform010": [":x86_and_x86_64_lib"],
2536
        }),
2537
    )
2538

2539
    fb_xplat_cxx_library(
2540
        name = "XNNPACK",
2541
        apple_sdks = (IOS, MACOSX, APPLETVOS),
2542
        labels = labels,
2543
        deps = [
2544
            ":subgraph",
2545
            ":tables",
2546
            ":prod_ukernels",
2547
            third_party("cpuinfo"),
2548
            third_party("pthreadpool"),
2549
        ],
2550
        exported_headers = {
2551
            "xnnpack.h": "XNNPACK/include/xnnpack.h",
2552
        },
2553
        fbobjc_preprocessor_flags = [
2554
            "-DXNN_PRIVATE=",
2555
            "-DXNN_INTERNAL=",
2556
        ],
2557
        header_namespace = "",
2558
        headers = subdir_glob([
2559
            ("XNNPACK/src", "**/*.h"),
2560
            ("XNNPACK/include", "**/*.h"),
2561
        ]),
2562
        platforms = (APPLE, ANDROID, CXX, WINDOWS),
2563
        preferred_linkage = "static",
2564
        preprocessor_flags = [
2565
            "-DXNN_LOG_LEVEL=0",
2566
            "-DXNN_NO_Q8_OPERATORS",
2567
            "-DXNN_NO_F16_OPERATORS",
2568
            "-DXNN_NO_NCHW_OPERATORS",
2569
            "-DXNN_NO_QU8_OPERATORS",
2570
            "-DXNN_NO_U8_OPERATORS",
2571
            "-DXNN_NO_X32_OPERATORS",
2572
            "-DXNN_NO_X8_OPERATORS",
2573
            "-DXNN_ENABLE_MEMOPT",
2574
            "-DXNN_ENABLE_SPARSE=0",
2575
            "-DXNN_ENABLE_JIT=0",
2576
            "-DXNN_ENABLE_ASSEMBLY",
2577
            "-DXNN_ENABLE_GEMM_M_SPECIALIZATION",
2578
            "-DXNN_ENABLE_ARM_DOTPROD",
2579
            "-DXNN_ENABLE_CPUINFO",
2580
            "-DXNN_ENABLE_ARM_I8MM=1",
2581
            "-DXNN_ENABLE_ARM_FP16_VECTOR=1",
2582
            "-DXNN_ENABLE_AVXVNNI=0",
2583
        ],
2584
        srcs = XNNPACK_SRCS + LOGGING_SRCS + OPERATOR_SRCS + [
2585
            "XNNPACK/src/configs/hardware-config.c",
2586
            "XNNPACK/src/microkernel-utils.c",
2587
            "XNNPACK/src/operator-run.c",
2588
            "XNNPACK/src/packing.c",
2589
            "XNNPACK/src/cache.c",
2590
            "XNNPACK/src/indirection.c",
2591
            "XNNPACK/src/operator-utils.c",
2592
            "XNNPACK/src/normalization.c",
2593
            "XNNPACK/src/allocator.c",
2594
            "XNNPACK/src/memory.c",
2595
            "XNNPACK/src/mutex.c",
2596
            "XNNPACK/src/microparams-init.c",
2597
            "XNNPACK/src/operators/post-operation.c",
2598
        ],
2599
        visibility = ["PUBLIC"],
2600
        windows_clang_compiler_flags_override = (WINDOWS_FLAGS + WINDOWS_CLANG_COMPILER_FLAGS) if XNNPACK_WINDOWS_AVX512F_ENABLED else WINDOWS_FLAGS,
2601
        windows_compiler_flags_override = WINDOWS_FLAGS if XNNPACK_WINDOWS_AVX512F_ENABLED else [],
2602
    )
2603