forked from iree-org/iree
-
Notifications
You must be signed in to change notification settings - Fork 11
/
CMakeLists.txt
1161 lines (1000 loc) · 49.3 KB
/
CMakeLists.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# Copyright 2019 The IREE Authors
#
# Licensed under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
cmake_minimum_required(VERSION 3.21...3.24)
# LLVM requires CMP0116 for tblgen: https://reviews.llvm.org/D101083
# CMP0116: Ninja generators transform `DEPFILE`s from `add_custom_command()`
# New in CMake 3.20. https://cmake.org/cmake/help/latest/policy/CMP0116.html
set(CMAKE_POLICY_DEFAULT_CMP0116 OLD)
if(POLICY CMP0116)
cmake_policy(SET CMP0116 OLD)
endif()
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
project(IREE ASM C CXX)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
# LLVM defines this as a CACHE property and uses a policy that causes the
# cache value to take precedence. This is causing us to mix 17/14 across
# the boundary.
# TODO: Remove this once the LLVM mechanism is updated. See:
# https://discourse.llvm.org/t/important-new-toolchain-requirements-to-build-llvm-will-most-likely-be-landing-within-a-week-prepare-your-buildbots/61447/9
set(CMAKE_CXX_STANDARD 17 CACHE STRING "C++ standard to conform to" FORCE)
set(IREE_IDE_FOLDER IREE)
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
if(MSVC)
enable_language(ASM_MASM)
else()
enable_language(ASM)
endif()
# Set the default CMake build type so some of the build type dependent setting
# in the submodules and functions (IREE assertion) can be set properly.
set(DEFAULT_CMAKE_BUILD_TYPE "Release")
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
message(STATUS "No build type selected, default to ${DEFAULT_CMAKE_BUILD_TYPE}")
set(CMAKE_BUILD_TYPE "${DEFAULT_CMAKE_BUILD_TYPE}" CACHE STRING "Build type (default ${DEFAULT_CMAKE_BUILD_TYPE})" FORCE)
endif()
include(CMakeDependentOption)
#-------------------------------------------------------------------------------
# Project component configuration
#-------------------------------------------------------------------------------
option(IREE_ENABLE_RUNTIME_TRACING "Enables instrumented runtime tracing." OFF)
option(IREE_ENABLE_COMPILER_TRACING "Enables instrumented compiler tracing." OFF)
option(IREE_ENABLE_RENDERDOC_PROFILING "Enables profiling HAL devices with the RenderDoc tool." OFF)
option(IREE_ENABLE_THREADING "Builds IREE in with thread library support." ON)
option(IREE_ENABLE_CLANG_TIDY "Builds IREE in with clang tidy enabled on IREE's libraries." OFF)
set(IREE_TRACING_PROVIDER_DEFAULT "tracy" CACHE STRING "Default tracing implementation.")
set(IREE_TRACING_PROVIDER ${IREE_TRACING_PROVIDER_DEFAULT} CACHE STRING "Chooses which built-in tracing implementation is used when tracing is enabled.")
set(IREE_TRACING_PROVIDER_H "" CACHE STRING "Header file for custom tracing providers.")
set(IREE_TRACING_MODE_DEFAULT "2" CACHE STRING "Default tracing feature/verbosity mode. See iree/base/tracing.h for more.")
set(IREE_TRACING_MODE ${IREE_TRACING_MODE_DEFAULT} CACHE STRING "Tracing feature/verbosity mode. See iree/base/tracing.h for more.")
# TODO(#8469): remove the dependency on cpuinfo entirely.
set(IREE_ENABLE_CPUINFO_DEFAULT ON)
if(CMAKE_SYSTEM_NAME MATCHES "Darwin|Emscripten|Windows|WindowsStore")
set(IREE_ENABLE_CPUINFO_DEFAULT OFF)
endif()
option(IREE_ENABLE_CPUINFO "Enables runtime use of cpuinfo for processor topology detection." ${IREE_ENABLE_CPUINFO_DEFAULT})
option(IREE_BUILD_COMPILER "Builds the IREE compiler." ON)
option(IREE_BUILD_TESTS "Builds IREE unit tests." ON)
option(IREE_BUILD_DOCS "Builds IREE documentation files." OFF)
option(IREE_BUILD_SAMPLES "Builds IREE sample projects." ON)
option(IREE_BUILD_PYTHON_BINDINGS "Builds the IREE python bindings" OFF)
option(IREE_BUILD_TRACY "Builds tracy server tools." OFF)
option(IREE_BUILD_BUNDLED_LLVM "Builds the bundled llvm-project (vs using installed)" ON)
option(IREE_BYTECODE_MODULE_FORCE_LLVM_SYSTEM_LINKER "Use the system linker when generating IREE modules in tests/samples/benchmarks (useful for Tracy)." OFF)
# Properties controlling version and naming of release artifacts.
set(IREE_RELEASE_PACKAGE_SUFFIX "" CACHE STRING "Suffix to append to distributed package names")
set(IREE_RELEASE_VERSION "0.1a1" CACHE STRING "Version to embed in distributed packages")
set(IREE_RELEASE_REVISION "HEAD" CACHE STRING "Version control revision information to embed in distributed packages")
option(IREE_EMBED_RELEASE_INFO "Embed the IREE version information in built artifacts." OFF)
# Using already built host binaries, such as for cross-compilation.
set(IREE_HOST_BIN_DIR_DEFAULT "")
if(IREE_HOST_BINARY_ROOT)
message(WARNING "IREE_HOST_BINARY_ROOT is deprecated. Use IREE_HOST_BIN_DIR"
" pointing directly to the directory containing binaries"
" instead.")
set(IREE_HOST_BIN_DIR_DEFAULT "${IREE_HOST_BINARY_ROOT}/bin")
endif()
set(IREE_HOST_BIN_DIR "${IREE_HOST_BIN_DIR_DEFAULT}" CACHE STRING "Path to directory containing IREE binary tools to use instead of building them from source.")
option(IREE_BUILD_BINDINGS_TFLITE "Builds the IREE TFLite C API compatibility shim" ON)
option(IREE_BUILD_BINDINGS_TFLITE_JAVA "Builds the IREE TFLite Java bindings with the C API compatibility shim" ON)
option(IREE_BUILD_MICROBENCHMARKS "Builds IREE microbenchmark suites." OFF)
option(IREE_BUILD_ALL_CHECK_TEST_MODULES "Builds all modules for iree_check_test, regardless of which would be tested" ON)
option(IREE_BUILD_E2E_TEST_ARTIFACTS "Builds IREE E2E test artifacts suite generated by the e2e test framework." "${IREE_BUILD_EXPERIMENTAL_E2E_TEST_ARTIFACTS}")
set(IREE_E2E_TEST_ARTIFACTS_DIR "" CACHE STRING "Set external prebuilt E2E test artifacts directory")
if(IREE_BUILD_E2E_TEST_ARTIFACTS AND NOT "${IREE_E2E_TEST_ARTIFACTS_DIR}" STREQUAL "")
message(SEND_ERROR
"IREE_E2E_TEST_ARTIFACTS_DIR and IREE_BUILD_E2E_TEST_ARTIFACTS can't be"
" set at the same time."
)
endif()
option(IREE_ENABLE_COLLECTIVE_RUNTIME_TESTS "Enable runtime tests for collective operations." OFF)
# For development, builds LLVM (and in the future) the whole compiler as
# individual shared libraries similar to if passing -DBUILD_SHARED_LIBS=ON
# to a standalone LLVM build. This can dramatically reduce linking time and
# makes the management of some dependencies more strict.
# This option is considered experimental and should not be relied on until
# CI coverage is established.
option(IREE_COMPILER_BUILD_SHARED_LIBS "Enables BUILD_SHARED_LIBS CMake mode for LLVM and the compiler (this is only suitable for development)" OFF)
# Must be defined as an option (CMake does not do it automatically), even though
# we override it for different parts of the tree.
# This option is considered experimental and should not be relied on until
# CI coverage is established.
option(BUILD_SHARED_LIBS "Instructs CMake to build libraries as shared if possible" OFF)
#-------------------------------------------------------------------------------
# IREE command-line tooling configuration
#-------------------------------------------------------------------------------
# External user modules linked into IREE tooling (iree-run-module/etc).
# These are only available in the internal IREE tools and here for testing
# custom modules in standard workflows. This is not a deployment mechanism and
# users integrating IREE into their libraries or applications will need to
# manage the building and registering/resolving the modules themselves.
#
# See runtime/src/iree/tooling/modules/CMakeLists.txt for more information on
# how to declare external modules.
set(IREE_EXTERNAL_TOOLING_MODULES "" CACHE STRING "")
#-------------------------------------------------------------------------------
# IREE out of tree plugins
#
# IREE has multiple facilities for building with out of tree plugin sources.
# The entry-point is via the -DIREE_CMAKE_PLUGIN_PATHS=<dir1;dir2> setting.
# Each directory in this list can have any of the following files in it, which
# will be included at the appropriate point in the CMake build:
#
# iree_compiler_plugin.cmake : Included in the context of the compiler/
# directory before sources and bindings. Will execute with source and
# binary dir ${IREE_BUILD_DIR}/compiler/plugins (shared with all other
# dirs).
# iree_runtime_plugin.cmake : Included in the context of the runtime/
# directory before sources. Will execute with source and binary dir
# ${IREE_BUILD_DIR}/runtime/plugins (shared with all other dirs).
#
# Typically, these plugins will perform additional project setup, and
# eventually call registration functions to advertise additional capabilities
# to the build system.
#
# Super-projects can populate the list IREE_CMAKE_BUILTIN_PLUGIN_PATHS to
# statically configure more plugin directories to be used.
#
# Compiler Plugins
# ----------------
# Compiler plugins are advertised to the build system via the function
# iree_compiler_register_plugin(), which associated a plugin id to a build target
# and registration function. See samples/compiler_plugins for examples.
#
# External HAL Driver Plugins
# ---------------------------
# HAL driver implementations are advertised to the build system via
# iree_register_external_hal_driver(), which specifies the name, target,
# registration function and optional source/binary directory.
#-------------------------------------------------------------------------------
set(IREE_CMAKE_PLUGIN_PATHS "" CACHE STRING "Paths to be scanned for IREE CMake plugin includes")
list(APPEND IREE_CMAKE_BUILTIN_PLUGIN_PATHS "compiler/plugins")
if(IREE_BUILD_SAMPLES)
list(APPEND IREE_CMAKE_BUILTIN_PLUGIN_PATHS "samples/compiler_plugins")
endif()
#-------------------------------------------------------------------------------
# Experimental project flags
#-------------------------------------------------------------------------------
option(IREE_BUILD_EXPERIMENTAL_CPU_UKERNEL_PLUGINS "Build experimental plugins making builtin ukernels available to llvm-cpu modules compiled with --iree-llvmcpu-enable-ukernels" OFF)
option(IREE_BUILD_EXPERIMENTAL_WEB_SAMPLES "Builds experimental web samples." OFF)
#-------------------------------------------------------------------------------
# CUDA Toolkit.
#
# Using the (optional) CUDA support in the compiler and runtime requires the
# NVIDIA CUDA Toolkit. The toolkit can either be installed ahead of time or
# it can be automatically downloaded on certain host architectures.
#-------------------------------------------------------------------------------
set(IREE_CUDA_AVAILABLE OFF)
# The IREE cuda driver requires CUDA >= 12.
set(IREE_CUDA_MIN_VERSION_REQUIRED 12)
find_package(CUDAToolkit ${IREE_CUDA_MIN_VERSION_REQUIRED})
if(CUDAToolkit_FOUND)
set(IREE_CUDA_AVAILABLE ON)
else()
# We can download the SDK in build_tools/third_party/cuda/CMakeLists.txt, if
# on a supported platform/arch.
if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR WIN32)
if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "(x86_64)|(AMD64|amd64)")
set(IREE_CUDA_AVAILABLE ON)
endif()
endif()
endif()
#-------------------------------------------------------------------------------
# Runtime HAL Driver Options
# By default, all runtime drivers supported by the current platform which do
# not require external deps are enabled by default. This can be changed with:
# -DIREE_HAL_DRIVER_DEFAULTS=OFF
#-------------------------------------------------------------------------------
# External HAL drivers; see runtime/src/iree/hal/drivers/CMakeLists.txt for more
# information on how to declare external drivers.
set(IREE_EXTERNAL_HAL_DRIVERS "" CACHE STRING "")
# Additional executable loader deps to add dependent libraries to any target
# using the default executable loader registration utilities.
# TODO(benvanik): extend the deps to encompass the built-in loaders too so that
# we have one flag. We could also support a list of deps and automatically
# generate the registration from that via a configure file.
set(IREE_HAL_EXECUTABLE_LOADER_EXTRA_DEPS "" CACHE STRING "")
# Additional executable import provider deps to add dependent libraries to any
# target using the default executable import registration utilities.
# TODO(benvanik): extend the deps to encompass the built-in imports too so that
# we have one flag. We could also support a list of deps and automatically
# generate the registration from that via a configure file.
set(IREE_HAL_EXECUTABLE_PLUGIN_EXTRA_DEPS "" CACHE STRING "")
option(IREE_HAL_DRIVER_DEFAULTS "Sets the default value for all runtime HAL drivers" ON)
# CUDA support is enabled by default if the platform supports the CUDA SDK and
# not cross compiling. Note: a CUDA-compatible GPU with drivers is still
# required to actually run CUDA workloads.
set(IREE_HAL_DRIVER_CUDA_DEFAULT ${IREE_HAL_DRIVER_DEFAULTS})
if(NOT IREE_CUDA_AVAILABLE OR CMAKE_CROSSCOMPILING)
set(IREE_HAL_DRIVER_CUDA_DEFAULT OFF)
endif()
# Vulkan support is enabled by default if the platform might support Vulkan.
# Apple platforms support Metal instead of Vulkan, though MoltenVK may work.
set(IREE_HAL_DRIVER_VULKAN_DEFAULT ${IREE_HAL_DRIVER_DEFAULTS})
if(APPLE)
set(IREE_HAL_DRIVER_VULKAN_DEFAULT OFF)
endif()
# Metal support is enabled if it's one of the Apple platforms.
set(IREE_HAL_DRIVER_METAL_DEFAULT ${IREE_HAL_DRIVER_DEFAULTS})
# Right now only support Apple silicon devices.
if(NOT APPLE OR NOT ${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm64")
set(IREE_HAL_DRIVER_METAL_DEFAULT OFF)
endif()
option(IREE_HAL_DRIVER_CUDA "Enables the 'cuda' runtime HAL driver" ${IREE_HAL_DRIVER_CUDA_DEFAULT})
option(IREE_HAL_DRIVER_LOCAL_SYNC "Enables the 'local-sync' runtime HAL driver" ${IREE_HAL_DRIVER_DEFAULTS})
option(IREE_HAL_DRIVER_LOCAL_TASK "Enables the 'local-task' runtime HAL driver" ${IREE_HAL_DRIVER_DEFAULTS})
option(IREE_HAL_DRIVER_VULKAN "Enables the 'vulkan' runtime HAL driver" ${IREE_HAL_DRIVER_VULKAN_DEFAULT})
option(IREE_HAL_DRIVER_METAL "Enables the 'metal' runtime HAL driver" ${IREE_HAL_DRIVER_METAL_DEFAULT})
option(IREE_HAL_EXECUTABLE_LOADER_DEFAULTS "Sets the default value for all runtime HAL executable loaders" ON)
set(IREE_HAL_EXECUTABLE_LOADER_EMBEDDED_ELF_DEFAULT ${IREE_HAL_EXECUTABLE_LOADER_DEFAULTS})
set(IREE_HAL_EXECUTABLE_LOADER_SYSTEM_LIBRARY_DEFAULT ${IREE_HAL_EXECUTABLE_LOADER_DEFAULTS})
set(IREE_HAL_EXECUTABLE_LOADER_VMVX_MODULE_DEFAULT ${IREE_HAL_EXECUTABLE_LOADER_DEFAULTS})
option(IREE_HAL_EXECUTABLE_PLUGIN_DEFAULTS "Sets the default value for all runtime HAL executable plugin mechanisms" ON)
set(IREE_HAL_EXECUTABLE_PLUGIN_EMBEDDED_ELF_DEFAULT ${IREE_HAL_EXECUTABLE_PLUGIN_DEFAULTS})
set(IREE_HAL_EXECUTABLE_PLUGIN_SYSTEM_LIBRARY_DEFAULT ${IREE_HAL_EXECUTABLE_PLUGIN_DEFAULTS})
# Emscripten builds don't support embedded ELF libraries.
if(EMSCRIPTEN)
set(IREE_HAL_EXECUTABLE_LOADER_EMBEDDED_ELF_DEFAULT OFF)
set(IREE_HAL_EXECUTABLE_PLUGIN_EMBEDDED_ELF_DEFAULT OFF)
endif()
# If forcing system libraries (for TSAN/debugging tools/etc) then ensure the
# system library loader is linked in.
if(IREE_BYTECODE_MODULE_FORCE_LLVM_SYSTEM_LINKER)
set(IREE_HAL_EXECUTABLE_LOADER_SYSTEM_LIBRARY_DEFAULT ON)
set(IREE_HAL_EXECUTABLE_PLUGIN_SYSTEM_LIBRARY_DEFAULT ON)
endif()
# If no local driver is enabled then we force all the loaders/imports off; this
# allows for simpler checks that don't need to see if both the driver and
# feature is available.
if(NOT IREE_HAL_DRIVER_LOCAL_SYNC AND NOT IREE_HAL_DRIVER_LOCAL_TASK)
set(IREE_HAL_EXECUTABLE_LOADER_EMBEDDED_ELF_DEFAULT OFF)
set(IREE_HAL_EXECUTABLE_LOADER_SYSTEM_LIBRARY_DEFAULT OFF)
set(IREE_HAL_EXECUTABLE_LOADER_VMVX_MODULE_DEFAULT OFF)
set(IREE_HAL_EXECUTABLE_PLUGIN_EMBEDDED_ELF_DEFAULT OFF)
set(IREE_HAL_EXECUTABLE_PLUGIN_SYSTEM_LIBRARY_DEFAULT OFF)
endif()
option(IREE_HAL_EXECUTABLE_LOADER_EMBEDDED_ELF "Enables the embedded dynamic library loader for local HAL drivers" ${IREE_HAL_EXECUTABLE_LOADER_EMBEDDED_ELF_DEFAULT})
option(IREE_HAL_EXECUTABLE_LOADER_SYSTEM_LIBRARY "Enables the system dynamic library loader for local HAL drivers" ${IREE_HAL_EXECUTABLE_LOADER_SYSTEM_LIBRARY_DEFAULT})
option(IREE_HAL_EXECUTABLE_LOADER_VMVX_MODULE "Enables the VMVX module loader for local HAL drivers" ${IREE_HAL_EXECUTABLE_LOADER_VMVX_MODULE_DEFAULT})
option(IREE_HAL_EXECUTABLE_PLUGIN_EMBEDDED_ELF "Enables the embedded dynamic library plugin mechanism for local HAL drivers" ${IREE_HAL_EXECUTABLE_PLUGIN_EMBEDDED_ELF_DEFAULT})
option(IREE_HAL_EXECUTABLE_PLUGIN_SYSTEM_LIBRARY "Enables the system dynamic library plugin mechanism for local HAL drivers" ${IREE_HAL_EXECUTABLE_PLUGIN_SYSTEM_LIBRARY_DEFAULT})
if(IREE_BUILD_COMPILER)
# The compiler requires the local task driver with the VMVX loader.
set(IREE_HAL_DRIVER_LOCAL_TASK ON)
set(IREE_HAL_EXECUTABLE_LOADER_VMVX_MODULE ON)
endif()
message(STATUS "IREE HAL drivers:")
if(IREE_HAL_DRIVER_CUDA)
message(STATUS " - cuda")
endif()
if(IREE_HAL_DRIVER_LOCAL_SYNC)
message(STATUS " - local-sync")
endif()
if(IREE_HAL_DRIVER_LOCAL_TASK)
message(STATUS " - local-task")
endif()
if(IREE_HAL_DRIVER_VULKAN)
message(STATUS " - vulkan")
endif()
if(IREE_HAL_DRIVER_METAL)
message(STATUS " - metal")
endif()
if(IREE_EXTERNAL_HAL_DRIVERS)
message(STATUS " + external: ${IREE_EXTERNAL_HAL_DRIVERS}")
endif()
message(STATUS "IREE HAL local executable library loaders:")
if(IREE_HAL_EXECUTABLE_LOADER_EMBEDDED_ELF)
message(STATUS " - embedded-elf")
endif()
if(IREE_HAL_EXECUTABLE_LOADER_SYSTEM_LIBRARY)
message(STATUS " - system-library")
endif()
if(IREE_HAL_EXECUTABLE_LOADER_VMVX_MODULE)
message(STATUS " - vmvx-module")
endif()
message(STATUS "IREE HAL local executable plugin mechanisms:")
if(IREE_HAL_EXECUTABLE_PLUGIN_EMBEDDED_ELF)
message(STATUS " - embedded-elf")
endif()
if(IREE_HAL_EXECUTABLE_PLUGIN_SYSTEM_LIBRARY)
message(STATUS " - system-library")
endif()
#-------------------------------------------------------------------------------
# Compiler Target Options
# By default, all compiler targets supported by the current platform are
# enabled. Some compiler targets like CUDA will install external deps as
# needed at configure time. This can be changed with:
# -DIREE_TARGET_BACKEND_DEFAULTS=OFF
#-------------------------------------------------------------------------------
option(IREE_TARGET_BACKEND_DEFAULTS "Sets the default value for all compiler target backends" ON)
# The VMVX backend is always enabled.
cmake_dependent_option(IREE_TARGET_BACKEND_VMVX "Enables the 'vmvx' compiler target backend" ON ${IREE_BUILD_COMPILER} OFF)
# Supported default target backends.
cmake_dependent_option(IREE_TARGET_BACKEND_LLVM_CPU "Enables the 'llvm-cpu' compiler target backend" ${IREE_TARGET_BACKEND_DEFAULTS} ${IREE_BUILD_COMPILER} OFF)
cmake_dependent_option(IREE_TARGET_BACKEND_LLVM_CPU_WASM "Enables WebAssembly in the 'llvm-cpu' compiler target backend" ${IREE_TARGET_BACKEND_DEFAULTS} ${IREE_TARGET_BACKEND_LLVM_CPU} OFF)
cmake_dependent_option(IREE_TARGET_BACKEND_METAL_SPIRV "Enables the 'metal-spirv' compiler target backend" ${IREE_TARGET_BACKEND_DEFAULTS} ${IREE_BUILD_COMPILER} OFF)
cmake_dependent_option(IREE_TARGET_BACKEND_VULKAN_SPIRV "Enables the 'vulkan-spirv' compiler target backend" ${IREE_TARGET_BACKEND_DEFAULTS} ${IREE_BUILD_COMPILER} OFF)
# Default target backends that are not yet fully supported but are being brought up.
cmake_dependent_option(IREE_TARGET_BACKEND_ROCM "Enables the 'rocm' compiler target backend" ${IREE_TARGET_BACKEND_DEFAULTS} ${IREE_BUILD_COMPILER} OFF)
# Supported default target backends that are only available on certain
# platforms.
set(IREE_TARGET_BACKEND_CUDA_DEFAULT ${IREE_TARGET_BACKEND_DEFAULTS})
if(NOT IREE_CUDA_AVAILABLE)
set(IREE_TARGET_BACKEND_CUDA_DEFAULT OFF)
endif()
cmake_dependent_option(IREE_TARGET_BACKEND_CUDA "Enables the 'cuda' compiler target backend" ${IREE_TARGET_BACKEND_CUDA_DEFAULT} ${IREE_BUILD_COMPILER} OFF)
# Non-default target backends either have additional dependencies or are
# experimental/niche in some fashion.
# Disable WebGPU by default - it has complex deps and is under development.
cmake_dependent_option(IREE_TARGET_BACKEND_WEBGPU "Enables the 'webgpu' compiler target backend" OFF ${IREE_BUILD_COMPILER} OFF)
#-------------------------------------------------------------------------------
# Compiler Input Dialects
#-------------------------------------------------------------------------------
cmake_dependent_option(IREE_INPUT_STABLEHLO "Builds support for compiling StableHLO programs" ON ${IREE_BUILD_COMPILER} OFF)
cmake_dependent_option(IREE_INPUT_TORCH "Builds support for compiling Torch MLIR programs" ON ${IREE_BUILD_COMPILER} OFF)
cmake_dependent_option(IREE_INPUT_TOSA "Builds support for compiling TOSA programs" ON ${IREE_BUILD_COMPILER} OFF)
if(IREE_BUILD_COMPILER)
message(STATUS "IREE compiler input dialects:")
if(IREE_INPUT_STABLEHLO)
message(STATUS " - StableHLO")
endif()
if(IREE_INPUT_TORCH)
message(STATUS " - Torch MLIR")
endif()
if(IREE_INPUT_TOSA)
message(STATUS " - TOSA")
endif()
endif()
#-------------------------------------------------------------------------------
# Compiler Output Formats
#-------------------------------------------------------------------------------
cmake_dependent_option(IREE_OUTPUT_FORMAT_C "Enables the 'vm-c' output format, using MLIR EmitC" ON ${IREE_BUILD_COMPILER} OFF)
if(IREE_BUILD_COMPILER)
message(STATUS "IREE compiler output formats:")
if(IREE_OUTPUT_FORMAT_C)
message(STATUS " - 'vm-c': textual C source module")
endif()
# The 'vm-bytecode' and 'vm-asm' formats are always enabled.
message(STATUS " - 'vm-bytecode': VM bytecode")
message(STATUS " - 'vm-asm': VM MLIR assembly")
endif()
#-------------------------------------------------------------------------------
# IREE compilation toolchain configuration
#-------------------------------------------------------------------------------
option(IREE_ENABLE_ASAN "Enable address sanitizer" OFF)
option(IREE_ENABLE_MSAN "Enable memory sanitizer" OFF)
option(IREE_ENABLE_TSAN "Enable thread sanitizer" OFF)
option(IREE_BYTECODE_MODULE_ENABLE_ASAN "Enable address sanitizer in IREE modules in tests" OFF)
option(IREE_BYTECODE_MODULE_ENABLE_TSAN "Enable thread sanitizer in IREE modules in tests" OFF)
option(IREE_ENABLE_UBSAN "Enable undefined behavior sanitizer" OFF)
option(IREE_ENABLE_SPLIT_DWARF "Enable gsplit-dwarf for debug information if the platform supports it" OFF)
option(IREE_ENABLE_THIN_ARCHIVES "Enables thin ar archives (elf systems only). Disable for released static archives" OFF)
option(IREE_LINK_COMPILER_SHARED_LIBRARY "Links IREE tools using the compiler compiled into a shared library" ON)
option(IREE_ENABLE_WERROR_FLAG "Enable `-Werror` flag, treat error as warning" ON)
# STREQUAL feels wrong here - we don't care about the exact true-value used,
# ON or TRUE or something else. But we haven't been able to think of a less bad
# alternative. https://github.com/openxla/iree/pull/8474#discussion_r840790062
if(NOT IREE_ENABLE_TSAN STREQUAL IREE_BYTECODE_MODULE_ENABLE_TSAN)
message(SEND_ERROR
"IREE_ENABLE_TSAN and IREE_BYTECODE_MODULE_ENABLE_TSAN must be "
"simultaneously ON or OFF. "
"A discrepancy between the two would cause tests to crash as IREE "
"runtime code (controlled by IREE_ENABLE_TSAN) calls into test IREE "
"modules (controlled by IREE_BYTECODE_MODULE_ENABLE_TSAN)")
endif()
if(IREE_BUILD_COMPILER)
if(IREE_BYTECODE_MODULE_ENABLE_ASAN OR IREE_BYTECODE_MODULE_ENABLE_TSAN)
if(NOT IREE_BYTECODE_MODULE_FORCE_LLVM_SYSTEM_LINKER)
message(SEND_ERROR
"When IREE_BYTECODE_MODULE_ENABLE_ASAN or IREE_BYTECODE_MODULE_ENABLE_TSAN is ON, "
"IREE_BYTECODE_MODULE_FORCE_LLVM_SYSTEM_LINKER must also be ON. "
"ASAN/TSAN instrumentation is not currently supported in embedded modules.")
endif()
endif()
endif()
if(IREE_LINK_COMPILER_SHARED_LIBRARY AND IREE_ENABLE_COMPILER_TRACING)
message(SEND_ERROR
"IREE_ENABLE_COMPILER_TRACING requires "
"-DIREE_LINK_COMPILER_SHARED_LIBRARY=OFF (the compiler library must not "
"be unloaded before Tracy finishes, static linking is one workaround)")
endif()
option(IREE_ENABLE_CCACHE
"[DEPRECATED: Use CMAKE_<LANG>_COMPILER_LAUNCHER configure options or environment variables instead.] Use ccache if installed."
OFF)
if(IREE_ENABLE_CCACHE)
message(WARNING
"IREE_ENABLE_CCACHE is deprecated. Use CMAKE_<LANG>_COMPILER_LAUNCHER"
" configure options or environment variables instead.")
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
else()
message(SEND_ERROR
"IREE_ENABLE_CCACHE was set, but executable `ccache` was not found.")
endif()
endif()
option(IREE_DEV_MODE "Configure settings to optimize for IREE development (as opposed to CI or release)" OFF)
#-------------------------------------------------------------------------------
# IREE assertions
# We don't love the way this is done, but we have to line it up with how LLVM
# does it and not diverge, since all implementations and all header users must
# have the same definition of NDEBUG.
#
# LLVM defaults LLVM_ENABLE_ASSERTIONS to ON for Debug builds only but then
# conditions itself to only update flags if not building Debug. We just let
# IREE_ENABLE_ASSERTIONS be not conditioned on anything and only update the
# flags in appropriate build types.
#
# If IREE_ENABLE_ASSERTIONS is set ON manually, then
# - NDEBUG must be undefined
# - LLVM_ENABLE_ASSERTIONS is forced off in order to keep multiple parties
# from mucking with globals.
#
# Since CMake forces NDEBUG for !Debug builds, some surgery needs to be done
# at the top level to avoid divergence.
#-------------------------------------------------------------------------------
option(IREE_ENABLE_ASSERTIONS "Force unset of NDEBUG compile option" OFF)
# Filter -DNDEBUG from CMAKE_CXX_FLAGS_* and CMAKE_C_FLAGS_* (if
# CMAKE_BUILD_TYPE is not Debug).
function(iree_fix_ndebug)
string(TOUPPER "${CMAKE_BUILD_TYPE}" _UPPERCASE_CMAKE_BUILD_TYPE)
if(IREE_ENABLE_ASSERTIONS AND NOT "${_UPPERCASE_CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
# Also remove /D NDEBUG to avoid MSVC warnings about conflicting defines.
foreach(_FLAGS_VAR_TO_SCRUB
CMAKE_CXX_FLAGS_${_UPPERCASE_CMAKE_BUILD_TYPE}
CMAKE_C_FLAGS_${_UPPERCASE_CMAKE_BUILD_TYPE})
set(_ORIGINAL_FLAGS "${${_FLAGS_VAR_TO_SCRUB}}")
string(REGEX REPLACE "(^| )[/-]D *NDEBUG($| )" " " _ALTERED_FLAGS "${_ORIGINAL_FLAGS}")
if(NOT "${_ORIGINAL_FLAGS}" STREQUAL "${_ALTERED_FLAGS}")
message(STATUS
"IREE_ENABLE_ASSERTIONS force disabled NDEBUG for ${_FLAGS_VAR_TO_SCRUB}: '${_ORIGINAL_FLAGS}' -> '${_ALTERED_FLAGS}'")
set(${_FLAGS_VAR_TO_SCRUB} "${_ALTERED_FLAGS}" PARENT_SCOPE)
endif()
endforeach()
# Make sure that LLVM doesn't add its own logic for assertion disabling.
# We'd like to make sure that we are not dueling over globals.
set(LLVM_ENABLE_ASSERTIONS OFF PARENT_SCOPE)
endif()
endfunction()
iree_fix_ndebug()
#-------------------------------------------------------------------------------
# IREE utility definitions
#-------------------------------------------------------------------------------
list(APPEND CMAKE_MODULE_PATH
${CMAKE_CURRENT_LIST_DIR}/build_tools/cmake/
)
include(iree_macros)
include(iree_copts)
include(iree_cc_binary)
include(iree_cc_library)
include(iree_cc_test)
include(iree_import_binary)
include(iree_install_support)
include(iree_external_cmake_options)
include(iree_tablegen_library)
include(iree_tablegen_doc)
include(iree_c_embed_data)
include(iree_bitcode_library)
include(iree_bytecode_module)
include(iree_c_module)
include(iree_python)
include(iree_lit_test)
include(iree_llvm)
include(iree_add_all_subdirs)
include(iree_check_test)
include(iree_e2e_matmul_test)
include(iree_native_test)
include(iree_cc_binary_benchmark)
include(iree_benchmark_suite)
include(iree_microbenchmark_suite)
include(iree_hal_cts_test_suite)
include(iree_static_linker_test)
include(iree_fetch_artifact)
include(iree_run_module_test)
include(iree_plugin_register)
# Default any sub-tree which doesn't provide its own package namespacing
# to derive it relative to this directory and prefixed with iree/.
set(IREE_PACKAGE_ROOT_DIR "${CMAKE_CURRENT_LIST_DIR}")
set(IREE_PACKAGE_ROOT_PREFIX "iree")
set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
#-------------------------------------------------------------------------------
# Experimental ROCM HAL driver
# Enable with: -DIREE_EXTERNAL_HAL_DRIVERS=rocm
#-------------------------------------------------------------------------------
iree_register_external_hal_driver(
NAME
rocm
SOURCE_DIR
"${CMAKE_CURRENT_SOURCE_DIR}/experimental/rocm"
DRIVER_TARGET
iree::experimental::rocm::registration
REGISTER_FN
iree_hal_rocm_driver_module_register
)
#-------------------------------------------------------------------------------
# Experimental HIP HAL driver
# Enable with: -DIREE_EXTERNAL_HAL_DRIVERS=hip
#-------------------------------------------------------------------------------
iree_register_external_hal_driver(
NAME
hip
SOURCE_DIR
"${CMAKE_CURRENT_SOURCE_DIR}/experimental/hip"
DRIVER_TARGET
iree::experimental::hip::registration
REGISTER_FN
iree_hal_hip_driver_module_register
)
#-------------------------------------------------------------------------------
# Experimental WebGPU HAL driver
# Enable with: -DIREE_EXTERNAL_HAL_DRIVERS=webgpu
#-------------------------------------------------------------------------------
iree_register_external_hal_driver(
NAME
webgpu
SOURCE_DIR
"${CMAKE_CURRENT_SOURCE_DIR}/experimental/webgpu"
BINARY_DIR
"${CMAKE_CURRENT_BINARY_DIR}/experimental/webgpu"
DRIVER_TARGET
iree::experimental::webgpu::registration
REGISTER_FN
iree_hal_webgpu_driver_module_register
)
#-------------------------------------------------------------------------------
# IREE compilation flags
#-------------------------------------------------------------------------------
iree_append_list_to_string(CMAKE_C_FLAGS_DEBUG ${IREE_C_FLAGS_DEBUG_LIST})
iree_append_list_to_string(CMAKE_CXX_FLAGS_DEBUG ${IREE_CXX_FLAGS_DEBUG_LIST})
set(CMAKE_CXX_FLAGS_FASTBUILD "-gmlt" CACHE STRING "Flags used by the C++ compiler during fast builds." FORCE)
set(CMAKE_C_FLAGS_FASTBUILD "-gmlt" CACHE STRING "Flags used by the C compiler during fast builds." FORCE)
set(CMAKE_EXE_LINKER_FLAGS_FASTBUILD "-Wl,-S" CACHE STRING "Flags used for linking binaries during fast builds." FORCE)
set(CMAKE_SHARED_LINKER_FLAGS_FASTBUILD "-Wl,-S" CACHE STRING "Flags used by the shared libraries linker binaries during fast builds." FORCE)
mark_as_advanced(
CMAKE_CXX_FLAGS_FASTBUILD
CMAKE_C_FLAGS_FASTBUILD
CMAKE_EXE_LINKER_FLAGS_FASTBUILD
CMAKE_SHARED_LINKER_FLAGS_FASTBUILD
)
# Override the system's default linker.
# See also: https://llvm.org/docs/CMake.html#llvm-use-linker.
set(IREE_USE_LINKER "" CACHE STRING "")
# Equivalent to setting -DIREE_USE_LINKER=lld.
# Note that unlike LLVM's LLVM_ENABLE_LLD, this does _not_ build lld. You will
# need to either install a recent version of lld or build it from source prior
# to setting this option. See also: https://lld.llvm.org/#using-lld.
# This option is disabled on Apple platforms, where lld is not supported.
cmake_dependent_option(IREE_ENABLE_LLD "Override the system's default linker to lld" OFF "NOT APPLE" OFF)
include(iree_setup_toolchain)
#-------------------------------------------------------------------------------
# Python
# If building features that require Python development, find them early in
# one invocation (some CMake versions are sensitive to resolving out of order).
# Otherwise, for features that just require the interpreter, find that alone.
#-------------------------------------------------------------------------------
if(IREE_BUILD_PYTHON_BINDINGS)
# After CMake 3.18, we are able to limit the scope of the search to just
# Development.Module. Searching for Development will fail in situations where
# the Python libraries are not available. When possible, limit to just
# Development.Module.
# See https://pybind11.readthedocs.io/en/stable/compiling.html#findpython-mode
#
# Configuring the Development.Module is flaky in multi-project setups.
# "Bootstrapping" by first looking for the optional Development component
# seems to be robust generally.
# See: https://reviews.llvm.org/D118148
# If building Python packages, we have a hard requirement on 3.9+.
find_package(Python3 3.9 COMPONENTS Interpreter Development NumPy)
find_package(Python3 3.9 COMPONENTS Interpreter Development.Module NumPy REQUIRED)
# Some parts of the build use FindPython instead of FindPython3. Why? No
# one knows, but they are different. So make sure to bootstrap this one too.
# Not doing this here risks them diverging, which on multi-Python systems,
# can be troublesome. Note that nanobind requires FindPython.
set(Python_EXECUTABLE "${Python3_EXECUTABLE}")
find_package(Python 3.9 COMPONENTS Interpreter Development.Module NumPy REQUIRED)
elseif(IREE_BUILD_COMPILER OR IREE_BUILD_TESTS)
find_package(Python3 COMPONENTS Interpreter REQUIRED)
set(Python_EXECUTABLE "${Python3_EXECUTABLE}")
find_package(Python COMPONENTS Interpreter REQUIRED)
endif()
if(NOT "${Python_EXECUTABLE}" STREQUAL "${Python3_EXECUTABLE}")
message(WARNING "FindPython and FindPython3 found different executables. You may need to pin -DPython_EXECUTABLE and -DPython3_EXECUTABLE (${Python_EXECUTABLE} vs ${Python3_EXECUTABLE})")
endif()
#-------------------------------------------------------------------------------
# Check if git submodules have been initialized.
# This will only run if python3 is available.
#-------------------------------------------------------------------------------
option(IREE_ERROR_ON_MISSING_SUBMODULES "Error if submodules have not been initialized." ON)
find_package(Python3 COMPONENTS Interpreter QUIET)
find_package(Git)
if(IREE_ERROR_ON_MISSING_SUBMODULES AND Python3_FOUND AND Git_FOUND)
# Only check submodule status when the git commit changes.
execute_process(
COMMAND git rev-parse --short HEAD
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
RESULT_VARIABLE SHORT_HASH_RESULT
OUTPUT_VARIABLE SHORT_HASH)
string(REGEX REPLACE "\n$" "" SHORT_HASH "${SHORT_HASH}")
if(SHORT_HASH_RESULT EQUAL "0" AND NOT "${IREE_GIT_SHORT_HASH}" STREQUAL "${SHORT_HASH}")
if(NOT IREE_BUILD_COMPILER)
set(CHECK_SUBMODULE_ARGS "--runtime_only")
endif()
execute_process(
COMMAND ${Python3_EXECUTABLE} build_tools/scripts/git/check_submodule_init.py ${CHECK_SUBMODULE_ARGS}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
RESULT_VARIABLE SUBMODULE_INIT_RESULT
)
if(NOT SUBMODULE_INIT_RESULT EQUAL "0")
message(FATAL_ERROR "check_submodule_init.py failed, see the logs above")
else()
set(IREE_GIT_SHORT_HASH "${SHORT_HASH}" CACHE STRING "" FORCE)
endif()
endif()
endif()
#-------------------------------------------------------------------------------
# IREE top-level targets
# We define these here because various things in the build tree adds
# dependencies to them.
#-------------------------------------------------------------------------------
if(IREE_BUILD_MICROBENCHMARKS)
# Add top-level custom targets to drive generating microbenchmark suites.
add_custom_target(iree-microbenchmark-suites)
endif()
if(IREE_BUILD_DOCS)
# Define a top-level custom target to drive generating documentation files.
# Add to the default target given that docs were explicitly requested.
add_custom_target(iree-doc ALL)
endif()
# Samples may require additional files to be built/configured and will add
# dependencies to this target.
# Note: These will be automatically built with test dependencies
# (`iree-test-deps`).
add_custom_target(iree-sample-deps
COMMENT
"Building IREE sample data targets"
)
# Testing rules that require generation will add dependencies to this target.
# This allows them to be EXCLUDE_FROM_ALL but still invokable.
add_custom_target(iree-test-deps
COMMENT
"Building IREE test deps"
DEPENDS
iree-sample-deps
)
# Testing rules that generate test scripts for iree-run-module-test will add
# dependencies to this target. It is a subset of `iree-test-deps`.
add_custom_target(iree-run-module-test-deps
COMMENT
"Building IREE run module test targets"
)
# Convenience target for running IREE tests.
add_custom_target(iree-run-tests
COMMENT
"Run IREE unit tests"
WORKING_DIRECTORY
"${CMAKE_CURRENT_BINARY_DIR}"
USES_TERMINAL
COMMAND
"${CMAKE_COMMAND}" -E echo
"The 'iree-run-tests' target is a helper for running ctest. For advanced"
"options, build dependencies and invoke ctest independently as in:"
COMMAND
"${CMAKE_COMMAND}" -E echo
" \\(cd ${CMAKE_CURRENT_BINARY_DIR} \\&\\& cmake --build . --target iree-test-deps \\&\\& ctest --output-on-failure\\)"
COMMAND
"${CMAKE_COMMAND}" -E echo
"Run tests in parallel by setting a variable like CTEST_PARALLEL_LEVEL=25."
COMMAND
"${CMAKE_CTEST_COMMAND}"
--output-on-failure
)
add_dependencies(iree-run-tests iree-test-deps)
#-------------------------------------------------------------------------------
# CUDA configuration for both the compiler and runtime.
# We do this at the top level so that we can fail fast and make global
# decisions that effect both compiler and runtime. It also helps with error
# messaging to do this all in one place, since we can provide very targeted
# advice.
#-------------------------------------------------------------------------------
set(IREE_CUDA_LIBDEVICE_PATH "" CACHE FILEPATH "Absolute path to an appropriate libdevice.*.bc (needed to build the IREE cuda compiler target)")
# If any CUDA features are being built, try to locate a CUDA SDK. We will fall
# back to this as needed for specific features.
if(IREE_TARGET_BACKEND_CUDA OR IREE_HAL_DRIVER_CUDA)
add_subdirectory(build_tools/third_party/cuda EXCLUDE_FROM_ALL)
endif()
#-------------------------------------------------------------------------------
# MLIR/LLVM Dependency
#-------------------------------------------------------------------------------
if(NOT IREE_BUILD_COMPILER)
message(STATUS "Not adding LLVM/MLIR because the configuration does not require it")
else()
# Force enable BUILD_SHARED_LIBS for the compiler if instructed.
set(_IREE_ORIG_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
if(IREE_COMPILER_BUILD_SHARED_LIBS)
set(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
endif()
# Get the main LLVM deps.
if(IREE_BUILD_BUNDLED_LLVM)
iree_llvm_configure_bundled()
else()
iree_llvm_configure_installed()
endif()
# Also add a library that can be depended on to get LLVM includes setup
# properly. bazel_to_cmake targets this for some header only pseudo deps.
add_library(IREELLVMIncludeSetup INTERFACE)
foreach(_d ${LLVM_INCLUDE_DIRS} ${MLIR_INCLUDE_DIRS} ${LLD_INCLUDE_DIRS})
# BUILD_INTERFACE only works one at a time.
target_include_directories(IREELLVMIncludeSetup INTERFACE
$<BUILD_INTERFACE:${_d}>
)
endforeach()
iree_install_targets(
TARGETS IREELLVMIncludeSetup
COMPONENT IREEPublicLibraries-Compiler
EXPORT_SET Compiler
)
# Splice the includes setup into base LLVM libraries so that using them
# gets everything nice and tidy. It would be super if some day, LLVM
# libraries set their right usage requirements for includes. In the meantime
# we add usage requirements to libraries at the root of all things LLVM.
iree_llvm_add_usage_requirements(LLVMSupport IREELLVMIncludeSetup)
iree_llvm_add_usage_requirements(MLIRSupport IREELLVMIncludeSetup)
# Add external projects.
message(STATUS "Configuring llvm-external-projects/mlir-iree-dialects")
list(APPEND CMAKE_MESSAGE_INDENT " ")
iree_llvm_add_external_project(mlir-iree-dialects ${CMAKE_CURRENT_SOURCE_DIR}/llvm-external-projects/iree-dialects)
list(POP_BACK CMAKE_MESSAGE_INDENT)
if(IREE_INPUT_STABLEHLO)
message(STATUS "Configuring third_party/stablehlo")
list(APPEND CMAKE_MESSAGE_INDENT " ")
iree_llvm_add_external_project(stablehlo ${CMAKE_CURRENT_SOURCE_DIR}/third_party/stablehlo)
list(POP_BACK CMAKE_MESSAGE_INDENT)
endif()
# Ensure that LLVM-based dependencies needed for testing are included.
add_dependencies(iree-test-deps FileCheck)
if(IREE_LLD_TARGET)
add_dependencies(iree-test-deps ${IREE_LLD_TARGET})
endif()
if(IREE_CLANG_TARGET)
add_dependencies(iree-test-deps ${IREE_CLANG_TARGET})
endif()
set(BUILD_SHARED_LIBS ${_IREE_ORIG_BUILD_SHARED_LIBS} CACHE BOOL "" FORCE)
endif()
#-------------------------------------------------------------------------------
# Other dependencies
# By default we bundle a number of dependencies needed to build the project.
# When bundled like this, they are installed into the IREEBundledLibraries
# component and exported to their subsystem which requires them (if a static
# dep from the public API): "Runtime" or "Compiler".
#
# Some deps have a usable CMake build, and we add_subdirectory these, manually
# using iree_install_targets to include them in our installation. Others require
# custom CMake and these are in the build_tools/third_party directory.
#
# TODO: We should have a mode that purely uses find_package for OS friendly
# packaging/externalizing deps.
#-------------------------------------------------------------------------------
include(external_cc_library)
include(flatbuffer_c_library)
add_subdirectory(build_tools/third_party/llvm-project EXCLUDE_FROM_ALL)
add_subdirectory(build_tools/third_party/tracy_client EXCLUDE_FROM_ALL)
iree_set_googletest_cmake_options()
add_subdirectory(third_party/googletest EXCLUDE_FROM_ALL)
if(IREE_ENABLE_THREADING)
# Benchmark.
iree_set_benchmark_cmake_options()
add_subdirectory(third_party/benchmark EXCLUDE_FROM_ALL)
iree_install_targets(
TARGETS benchmark
COMPONENT IREEBundledLibraries
EXPORT_SET Runtime
)
if(IREE_ENABLE_CPUINFO)
iree_set_cpuinfo_cmake_options()
add_subdirectory(third_party/cpuinfo EXCLUDE_FROM_ALL)
iree_install_targets(
TARGETS cpuinfo
COMPONENT IREEBundledLibraries
EXPORT_SET Runtime
)
endif()
endif()
# This defines the iree-flatcc-cli target, so we don't use EXCLUDE_FROM_ALL.
add_subdirectory(build_tools/third_party/flatcc)
if(IREE_HAL_DRIVER_CUDA)
add_subdirectory(build_tools/third_party/nccl EXCLUDE_FROM_ALL)
endif()
if(IREE_HAL_DRIVER_VULKAN)
add_subdirectory(third_party/vulkan_headers EXCLUDE_FROM_ALL)
iree_install_targets(
TARGETS Vulkan-Headers
COMPONENT IREEBundledLibraries
EXPORT_SET Runtime
)
endif()
if(IREE_BUILD_COMPILER)
add_subdirectory(build_tools/third_party/stablehlo EXCLUDE_FROM_ALL)
endif()
if(IREE_BUILD_TESTS)
include(iree_configure_testing)
endif()
if(IREE_BUILD_PYTHON_BINDINGS)
# The compiler uses pybind11
if(IREE_BUILD_COMPILER)
if(NOT TARGET pybind11::module)
message(STATUS "Using bundled pybind11")
add_subdirectory(third_party/pybind11 EXCLUDE_FROM_ALL)
else()
message(STATUS "Not including bundled pybind11 (already configured)")
endif()
endif()
endif()
if(IREE_TARGET_BACKEND_METAL_SPIRV)
# SPIRV-Cross is needed to cross compile SPIR-V into MSL source code.
iree_set_spirv_cross_cmake_options()
add_subdirectory(third_party/spirv_cross EXCLUDE_FROM_ALL)
endif()
#-------------------------------------------------------------------------------
# IREE top-level libraries
#-------------------------------------------------------------------------------
if(IREE_ENABLE_CLANG_TIDY)
set(CMAKE_CXX_CLANG_TIDY clang-tidy -warnings-as-errors=*)
endif()
add_subdirectory(build_tools/embed_data/)
if(IREE_BUILD_E2E_TEST_ARTIFACTS)
find_program(IREE_IMPORT_TFLITE_PATH iree-import-tflite)
if(IREE_IMPORT_TFLITE_PATH)
message(STATUS "Found ${IREE_IMPORT_TFLITE_PATH} to generate benchmark artifacts")
else()
message(STATUS "iree-import-tflite not found. Some benchmarks may not configure")
endif()
find_program(IREE_IMPORT_TF_PATH iree-import-tf)
if(IREE_IMPORT_TF_PATH)
message(STATUS "Found ${IREE_IMPORT_TF_PATH} to generate benchmark artifacts")
else()
message(STATUS "iree-import-tf not found. Some benchmarks may not configure")
endif()
set(IREE_E2E_TEST_ARTIFACTS_DIR "${IREE_BINARY_DIR}/e2e_test_artifacts")
endif()
# tools/ can depend on compiler/ and runtime/.
# Note: tools sub directory is added before compiler/ so that phony targets for
# files with the same names from different rules are disambiguated towards
# those in tools/.