jimzah/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2024-11-27 07:32:44 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity
579f572cf2
zig/CMakeLists.txt

950 lines
40 KiB
CMake
Raw Normal View History

build: update cmake_minimum_required to 3.5 CMake Deprecation Warning at CMakeLists.txt:1 (cmake_minimum_required): Compatibility with CMake < 3.5 will be removed from a future version of CMake. Update the VERSION argument <min> value or use a ...<max> suffix to tell CMake that the project does not need compatibility with older versions.
2023-07-27 02:06:55 +01:00
cmake_minimum_required(VERSION 3.5)
Add illumos OS tag - Adds `illumos` to the `Target.Os.Tag` enum. A new function, `isSolarish` has been added that returns true if the tag is either Solaris or Illumos. This matches the naming convention found in Rust's `libc` crate[1]. - Add the tag wherever `.solaris` is being checked against. - Check for the C pre-processor macro `__illumos__` in CMake to set the proper target tuple. Illumos distros patch their compilers to have this in the "built-in" set (verified with `echo | cc -dM -E -`). Alternatively you could check the output of `uname -o`. Right now, both Solaris and Illumos import from `c/solaris.zig`. In the future it may be worth putting the shared ABI bits in a base file, and mixing that in with specific `c/solaris.zig`/`c/illumos.zig` files. [1]: https://github.com/rust-lang/libc/tree/6e02a329a2a27f6887ea86952f389ca11e06448c/src/unix/solarish
2023-10-01 13:09:14 +01:00
include(CheckSymbolExists)
link against LLVM
2015-08-05 23:23:15 +01:00
build: fix release mode
2016-02-01 22:26:01 +00:00
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "Debug" CACHE STRING
stage1: fix cmake regression - add `None` as a valid CMAKE_BUILD_TYPE - this is a legitimate setting used by packagers regression was caused by c6df5deb3450e0d8a2ba449c34a0bd195fbce8ec
2020-02-05 13:24:50 +00:00
"Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." FORCE)
build: fix release mode
2016-02-01 22:26:01 +00:00
endif()
link against LLVM
2015-08-05 23:23:15 +01:00
cmake defaults stage1 to install in build directory
2018-04-11 01:57:37 +01:00
if(NOT CMAKE_INSTALL_PREFIX)
cmake: build stage3 by default This is a simplification of the cmake build script which introduces a new "stage3" target that is built by default, which builds and installs a stage3 zig. It greatly simplifies the build instructions for Zig, making it conform to the regular cmake routine, while still producing a stage3 artifact.
2022-08-20 06:06:15 +01:00
set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/stage3" CACHE STRING
cmake defaults stage1 to install in build directory
2018-04-11 01:57:37 +01:00
"Directory to install zig to" FORCE)
endif()
CMake: detect use of CMAKE_PREFIX_PATH env var CMake recognizes the CMAKE_PREFIX_PATH environment variable for some things, and also the CMAKE_PREFIX_PATH cache variable for other things. However, it does not relate these two things, i.e. if the environment variable is set, CMake does not populate the cache variable in a corresponding manner. Some package systems, such as Homebrew, set the environment variable but not the cache variable. Furthermore, the environment variable follows the system path separator, such as ':' on POSIX and ';' on Windows, but the cache variable follows CMake's array behavior, i.e. always ';' for a separator. Closes #13242
2022-10-23 01:46:25 +01:00
# CMake recognizes the CMAKE_PREFIX_PATH environment variable for some things,
# and also the CMAKE_PREFIX_PATH cache variable for other things. However, it
# does not relate these two things, i.e. if the environment variable is set,
# CMake does not populate the cache variable in a corresponding manner. Some
# package systems, such as Homebrew, set the environment variable but not the
# cache variable. Furthermore, the environment variable follows the system path
# separator, such as ':' on POSIX and ';' on Windows, but the cache variable
# follows CMake's array behavior, i.e. always ';' for a separator.
list(APPEND ZIG_CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH}")
if(WIN32)
list(APPEND ZIG_CMAKE_PREFIX_PATH $ENV{CMAKE_PREFIX_PATH})
else()
string(REGEX REPLACE ":" ";" ZIG_CMAKE_PREFIX_PATH_STRING "$ENV{CMAKE_PREFIX_PATH}")
list(APPEND ZIG_CMAKE_PREFIX_PATH "${ZIG_CMAKE_PREFIX_PATH_STRING}")
endif()
stage1: override cmake's default compilation flags to statically link the CRT on windows we want to use /MT instead of /MD for a fully static executable
2019-10-10 21:44:52 +01:00
set(CMAKE_USER_MAKE_RULES_OVERRIDE
${CMAKE_CURRENT_SOURCE_DIR}/cmake/c_flag_overrides.cmake)
set(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX
${CMAKE_CURRENT_SOURCE_DIR}/cmake/cxx_flag_overrides.cmake)
add Travis CI integration
2017-04-21 16:06:15 +01:00
project(zig C CXX)
link against LLVM
2015-08-05 23:23:15 +01:00
set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
set(ZIG_VERSION_MAJOR 0)
start the 0.12.0 release cycle
2023-08-03 19:22:40 +01:00
set(ZIG_VERSION_MINOR 12)
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-02 04:01:51 +00:00
set(ZIG_VERSION_PATCH 0)
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
set(ZIG_VERSION "" CACHE STRING "Override Zig version string. Default is to find out with git.")
if("${ZIG_VERSION}" STREQUAL "")
cmake: Mark <root>/.git/HEAD as a configure dependency This ensures that the Zig version will be re-computed when jumping through the source tree, which is especially important if bisecting across AstGen- or other changes that must not use the old cache.
2022-10-31 20:12:52 +00:00
set(RESOLVED_ZIG_VERSION "${ZIG_VERSION_MAJOR}.${ZIG_VERSION_MINOR}.${ZIG_VERSION_PATCH}")
CMake: Use NAMES_PER_DIR in all lookups CMake has a surprising default behavior where looking up a library by multiple names gives the name order higher priority than the directory search order. For example, if your system provides "llvm-config-14" and CMAKE_PREFIX_PATH includes "llvm-config", CMake will always end up choosing the system-provided llvm-config-14. This change add NAMES_PER_DIR to request the more sensible behavior: directory search order has higher priority than name order, so CMAKE_PREFIX_PATH always wins over system-provided tools/libraries.
2022-07-13 18:36:25 +01:00
find_program(GIT_EXE NAMES git NAMES_PER_DIR)
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
if(GIT_EXE)
execute_process(
build: pass --abbrev to git rather than relying on global config For computing the zig version number, pass --abbrev=9 rather than requiring the user to set their git configuration in order to make zig versions match the standard.
2023-12-18 21:43:07 +00:00
COMMAND ${GIT_EXE} -C ${CMAKE_SOURCE_DIR} describe --match *.*.* --tags --abbrev=9
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
RESULT_VARIABLE EXIT_STATUS
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-02 04:01:51 +00:00
OUTPUT_VARIABLE GIT_DESCRIBE
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_QUIET)
if(EXIT_STATUS EQUAL "0")
cmake: Mark <root>/.git/HEAD as a configure dependency This ensures that the Zig version will be re-computed when jumping through the source tree, which is especially important if bisecting across AstGen- or other changes that must not use the old cache.
2022-10-31 20:12:52 +00:00
set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/.git/HEAD)
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-02 04:01:51 +00:00
if(GIT_DESCRIBE MATCHES "^v?([0-9]+\\.[0-9]+\\.[0-9]+)$")
# Tagged release version.
set(GIT_TAG ${CMAKE_MATCH_1})
cmake: Mark <root>/.git/HEAD as a configure dependency This ensures that the Zig version will be re-computed when jumping through the source tree, which is especially important if bisecting across AstGen- or other changes that must not use the old cache.
2022-10-31 20:12:52 +00:00
if(NOT GIT_TAG VERSION_EQUAL RESOLVED_ZIG_VERSION)
message(SEND_ERROR "Zig version (${RESOLVED_ZIG_VERSION}) does not match Git tag (${GIT_TAG}).")
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
endif()
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-02 04:01:51 +00:00
elseif(GIT_DESCRIBE MATCHES "^v?([0-9]+\\.[0-9]+\\.[0-9]+)-([0-9]+)-g(.+)$")
# Untagged pre-release. The Zig version is updated to include the number of commits
# since the last tagged version and the commit hash. The version is formatted in
# accordance with the https://semver.org specification.
set(GIT_TAG ${CMAKE_MATCH_1})
set(GIT_COMMITS_AFTER_TAG ${CMAKE_MATCH_2})
set(GIT_COMMIT ${CMAKE_MATCH_3})
cmake: Mark <root>/.git/HEAD as a configure dependency This ensures that the Zig version will be re-computed when jumping through the source tree, which is especially important if bisecting across AstGen- or other changes that must not use the old cache.
2022-10-31 20:12:52 +00:00
if(NOT RESOLVED_ZIG_VERSION VERSION_GREATER GIT_TAG)
message(SEND_ERROR "Zig version (${RESOLVED_ZIG_VERSION}) must be greater than tagged ancestor (${GIT_TAG}).")
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-02 04:01:51 +00:00
endif()
cmake: Mark <root>/.git/HEAD as a configure dependency This ensures that the Zig version will be re-computed when jumping through the source tree, which is especially important if bisecting across AstGen- or other changes that must not use the old cache.
2022-10-31 20:12:52 +00:00
set(RESOLVED_ZIG_VERSION "${RESOLVED_ZIG_VERSION}-dev.${GIT_COMMITS_AFTER_TAG}+${GIT_COMMIT}")
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
else()
Restore the reverted semantic versioning commits restore "Comply with semantic versioning pre-release format" restore "stage2: SemVer compliance for development builds" restore "Remove 'g' prefix from commit hash in Zig semver" This reverts commit d96d8639e592b4bb4b2e330c4bd7412256b297d2. This reverts commit e8810f579406673edad0c9780c9d990f3034717a. This reverts commit 9afe5859a3e428b259a306c36a860e4d82dbb4bb.
2021-01-02 04:01:51 +00:00
message(WARNING "Failed to parse version from output of `git describe`.")
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
endif()
endif()
endif()
cmake: Mark <root>/.git/HEAD as a configure dependency This ensures that the Zig version will be re-computed when jumping through the source tree, which is especially important if bisecting across AstGen- or other changes that must not use the old cache.
2022-10-31 20:12:52 +00:00
else()
set(RESOLVED_ZIG_VERSION "${ZIG_VERSION}")
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
endif()
cmake: Mark <root>/.git/HEAD as a configure dependency This ensures that the Zig version will be re-computed when jumping through the source tree, which is especially important if bisecting across AstGen- or other changes that must not use the old cache.
2022-10-31 20:12:52 +00:00
message(STATUS "Configuring zig version ${RESOLVED_ZIG_VERSION}")
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
build: rename the "skip lib files" option * Old cmake option: `-DZIG_SKIP_INSTALL_LIB_FILES=ON` * New cmake option: `-DZIG_NO_LIB=ON` * Old build.zig option: `-Dskip-install-lib-files` * New build.zig option: `-Dno-lib` Motivation is making build commands easier to type.
2022-10-27 23:16:14 +01:00
set(ZIG_NO_LIB off CACHE BOOL
cmake: build stage3 by default This is a simplification of the cmake build script which introduces a new "stage3" target that is built by default, which builds and installs a stage3 zig. It greatly simplifies the build instructions for Zig, making it conform to the regular cmake routine, while still producing a stage3 artifact.
2022-08-20 06:06:15 +01:00
"Disable copying lib/ files to install prefix during the build phase")
cmake: don't ask zig2 to do hard things Apparently hard things: * run autodoc on the std lib * build the langref If any zig distros want these documentation, they'll need to get them from a stage3 `zig build` instead of stage2 (LLVM backend instead of C backend).
2023-07-22 19:03:01 +01:00
# This used to do something and it may or may not do something in the future.
# Right now it does nothing.
build: add option to not build langref on install
2023-04-11 20:05:53 +01:00
set(ZIG_NO_LANGREF off CACHE BOOL
"Disable copying of langref to the install prefix during the build phase")
add ZIG_STATIC cmake option it's not compatible with glibc but it works with musl
2018-03-30 18:20:13 +01:00
set(ZIG_STATIC off CACHE BOOL "Attempt to build a static zig executable (not compatible with glibc)")
CMake: Improve usage of `llvm-config`, esp. for consistent linking This commit reworks the LLVM/Clang/LLD discovery process for CMake. The biggest changes are that: 1. We search for LLVM from most preferred directory to least, skipping any `llvm-config` that is the wrong version, or that doesn't support the requested link mode ("static" or "shared"). 2. `ZIG_PREFER_CLANG_CPP_DYLIB` has been renamed to `ZIG_SHARED_LLVM`, to better align with `ZIG_STATIC_LLVM`. 3. We only search for LLVM in the same directory alongside LLVM. 4. LLVM's link mode is forwarded to Clang, so that we can look for the appropriate shared/static libraries. 5. We use `--link-static` when querying `--system-libs` from llvm-config, so that this will include libz and other dependencies for statically linking LLD
2022-07-16 02:51:41 +01:00
set(ZIG_SHARED_LLVM off CACHE BOOL "Prefer linking against shared LLVM libraries")
cmake: fix handling of transitive zstd dependency - Remove ZIG_ENABLE_ZSTD in favour of allowing ZIG_STATIC_ZSTD to be toggled off explicitly when ZIG_STATIC is on - Remove ZIG_ENABLE_LIBCPP (now unused)
2023-01-03 07:51:22 +00:00
set(ZIG_STATIC_LLVM ${ZIG_STATIC} CACHE BOOL "Prefer linking against static LLVM libraries")
set(ZIG_STATIC_ZLIB ${ZIG_STATIC} CACHE BOOL "Prefer linking against static zlib")
set(ZIG_STATIC_ZSTD ${ZIG_STATIC} CACHE BOOL "Prefer linking against static zstd")
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
set(ZIG_USE_CCACHE off CACHE BOOL "Use ccache")
Use ccache (optionally)
2020-05-26 14:36:55 +01:00
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
if(ZIG_USE_CCACHE)
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
else()
message(SEND_ERROR "ccache requested but not found")
endif()
Use ccache (optionally)
2020-05-26 14:36:55 +01:00
endif()
cmake: allow user to select static vs dynamic LLVM
2019-07-09 10:03:57 +01:00
CMake: Improve usage of `llvm-config`, esp. for consistent linking This commit reworks the LLVM/Clang/LLD discovery process for CMake. The biggest changes are that: 1. We search for LLVM from most preferred directory to least, skipping any `llvm-config` that is the wrong version, or that doesn't support the requested link mode ("static" or "shared"). 2. `ZIG_PREFER_CLANG_CPP_DYLIB` has been renamed to `ZIG_SHARED_LLVM`, to better align with `ZIG_STATIC_LLVM`. 3. We only search for LLVM in the same directory alongside LLVM. 4. LLVM's link mode is forwarded to Clang, so that we can look for the appropriate shared/static libraries. 5. We use `--link-static` when querying `--system-libs` from llvm-config, so that this will include libz and other dependencies for statically linking LLD
2022-07-16 02:51:41 +01:00
if (ZIG_SHARED_LLVM AND ZIG_STATIC_LLVM)
message(SEND_ERROR "-DZIG_SHARED_LLVM and -DZIG_STATIC_LLVM cannot both be enabled simultaneously")
endif()
cmake: support cross compiling
2020-03-28 03:43:21 +00:00
set(ZIG_TARGET_TRIPLE "native" CACHE STRING "arch-os-abi to output binaries for")
CMake: choose native CPU instead of baseline by default
2022-11-20 23:20:30 +00:00
set(ZIG_TARGET_MCPU "native" CACHE STRING "-mcpu parameter to output binaries for")
add an option to compile zig in single-threaded mode And enable it for Drone CI. I hate to do this, but I need to make progress on other fronts.
2020-12-20 22:37:58 +00:00
set(ZIG_SINGLE_THREADED off CACHE BOOL "limit the zig compiler to use only 1 thread")
CMake: add workaround for CMAKE_AR not supporting spaces This allows using `zig ar` for `CMAKE_AR`. Unfortunately, it requires a patch to CMakeLists.txt and cannot be done merely with flags to the cmake line.
2022-12-09 23:19:25 +00:00
set(ZIG_AR_WORKAROUND off CACHE BOOL "append 'ar' subcommand to CMAKE_AR")
cmake: support cross compiling
2020-03-28 03:43:21 +00:00
cmake build: allow overriding whether to use llvm-config Previously, there was an option ZIG_PREFER_LLVM_CONFIG which would override the default of not using llvm-config when cross compiling. That option is now removed in favor of the more powerful ZIG_USE_LLVM_CONFIG which defaults to OFF for cross compiling and ON for native compilation. The option overrides the default. This will be used in zig-bootstrap to improve support for native builds.
2021-03-13 21:30:56 +00:00
if("${ZIG_TARGET_TRIPLE}" STREQUAL "native")
set(ZIG_USE_LLVM_CONFIG ON CACHE BOOL "use llvm-config to find LLVM libraries")
else()
set(ZIG_USE_LLVM_CONFIG OFF CACHE BOOL "use llvm-config to find LLVM libraries")
endif()
CMake: add workaround for CMAKE_AR not supporting spaces This allows using `zig ar` for `CMAKE_AR`. Unfortunately, it requires a patch to CMakeLists.txt and cannot be done merely with flags to the cmake line.
2022-12-09 23:19:25 +00:00
if(ZIG_AR_WORKAROUND)
string(REPLACE "<CMAKE_AR>" "<CMAKE_AR> ar" CMAKE_C_ARCHIVE_CREATE ${CMAKE_C_ARCHIVE_CREATE})
string(REPLACE "<CMAKE_AR>" "<CMAKE_AR> ar" CMAKE_CXX_ARCHIVE_CREATE ${CMAKE_CXX_ARCHIVE_CREATE})
endif()
cmake: add ZIG_PIE toggle for -Dpie - add pkg-maintainer-friendly option to enable PIE when building zig - fix `ZIG_PIE_ARG` syntax
2023-04-29 18:14:51 +01:00
set(ZIG_PIE off CACHE BOOL "produce a position independent zig executable")
build stage3: detect system libcxx Detect system libcxx name with the CMake build system and convey that information to build.zig via config.h so that the same system libcxx is used for stage3. This undoes the hacky search 901457d173467c71b681a8c69f4b77c94d516da7 . closes #17018
2023-09-01 15:04:26 +01:00
# Detect system libcxx name.
if ("c++" IN_LIST CMAKE_CXX_IMPLICIT_LINK_LIBRARIES)
set(ZIG_SYSTEM_LIBCXX "c++" CACHE STRING "system libcxx name for build.zig")
else()
set(ZIG_SYSTEM_LIBCXX "stdc++" CACHE STRING "system libcxx name for build.zig")
endif()
update cmake files to LLVM 17
2023-08-11 01:08:59 +01:00
find_package(llvm 17)
find_package(clang 17)
find_package(lld 17)
Revert "delete parseh" This reverts commit 18374ea8f18b6b48c53e6e7bd23d536ac2e8a807.
2016-01-19 04:28:54 +00:00
cmake: LLVM needs to link against zlib For more details on why this dependency is needed, see https://github.com/ziglang/zig-bootstrap/issues/57
2021-05-29 04:51:18 +01:00
if(ZIG_STATIC_ZLIB)
build: first pass on geting stage3 building under x64_64-windows-msvc
2022-11-08 07:14:39 +00:00
if (MSVC)
build: simplify llvm-config provided system library parsing - Revert the addition of CLANG_SYSTEM_LIBARIES and LLVM_SYSTEM_LIBRARIES - Change addCMakeLibraryList to parse non-absolute path .lib dependencies as system libraries
2023-01-04 07:18:51 +00:00
list(REMOVE_ITEM LLVM_LIBRARIES "z.lib")
build: first pass on geting stage3 building under x64_64-windows-msvc
2022-11-08 07:14:39 +00:00
else()
build: simplify llvm-config provided system library parsing - Revert the addition of CLANG_SYSTEM_LIBARIES and LLVM_SYSTEM_LIBRARIES - Change addCMakeLibraryList to parse non-absolute path .lib dependencies as system libraries
2023-01-04 07:18:51 +00:00
list(REMOVE_ITEM LLVM_LIBRARIES "-lz")
build: first pass on geting stage3 building under x64_64-windows-msvc
2022-11-08 07:14:39 +00:00
endif()
CMake: Use NAMES_PER_DIR in all lookups CMake has a surprising default behavior where looking up a library by multiple names gives the name order higher priority than the directory search order. For example, if your system provides "llvm-config-14" and CMAKE_PREFIX_PATH includes "llvm-config", CMake will always end up choosing the system-provided llvm-config-14. This change add NAMES_PER_DIR to request the more sensible behavior: directory search order has higher priority than name order, so CMAKE_PREFIX_PATH always wins over system-provided tools/libraries.
2022-07-13 18:36:25 +01:00
find_library(ZLIB NAMES libz.a libzlibstatic.a z zlib libz NAMES_PER_DIR)
update macos static build for llvm8
2019-03-18 22:36:35 +00:00
list(APPEND LLVM_LIBRARIES "${ZLIB}")
cmake: LLVM needs to link against zlib For more details on why this dependency is needed, see https://github.com/ziglang/zig-bootstrap/issues/57
2021-05-29 04:51:18 +01:00
endif()
ci: macos: update to new cache tarball This tarball contains LLVM, Clang, LLD, Zig, and libz.a for macOS. This is everything we need for the CI to produce a working Zig executable.
2020-10-15 01:36:43 +01:00
cmake: fix handling of transitive zstd dependency - Remove ZIG_ENABLE_ZSTD in favour of allowing ZIG_STATIC_ZSTD to be toggled off explicitly when ZIG_STATIC is on - Remove ZIG_ENABLE_LIBCPP (now unused)
2023-01-03 07:51:22 +00:00
if(ZIG_STATIC_ZSTD)
if (MSVC)
build: simplify llvm-config provided system library parsing - Revert the addition of CLANG_SYSTEM_LIBARIES and LLVM_SYSTEM_LIBRARIES - Change addCMakeLibraryList to parse non-absolute path .lib dependencies as system libraries
2023-01-04 07:18:51 +00:00
list(REMOVE_ITEM LLVM_LIBRARIES "zstd.lib")
cmake: fix handling of transitive zstd dependency - Remove ZIG_ENABLE_ZSTD in favour of allowing ZIG_STATIC_ZSTD to be toggled off explicitly when ZIG_STATIC is on - Remove ZIG_ENABLE_LIBCPP (now unused)
2023-01-03 07:51:22 +00:00
else()
build: simplify llvm-config provided system library parsing - Revert the addition of CLANG_SYSTEM_LIBARIES and LLVM_SYSTEM_LIBRARIES - Change addCMakeLibraryList to parse non-absolute path .lib dependencies as system libraries
2023-01-04 07:18:51 +00:00
list(REMOVE_ITEM LLVM_LIBRARIES "-lzstd")
cmake: fix handling of transitive zstd dependency - Remove ZIG_ENABLE_ZSTD in favour of allowing ZIG_STATIC_ZSTD to be toggled off explicitly when ZIG_STATIC is on - Remove ZIG_ENABLE_LIBCPP (now unused)
2023-01-03 07:51:22 +00:00
endif()
CMake: handle zstd the same as zlib This is a new dependency of LLVM 15.
2022-10-26 02:29:39 +01:00
find_library(ZSTD NAMES libzstd.a libzstdstatic.a zstd NAMES_PER_DIR)
list(APPEND LLVM_LIBRARIES "${ZSTD}")
endif()
cmake: LLVM needs to link against zlib For more details on why this dependency is needed, see https://github.com/ziglang/zig-bootstrap/issues/57
2021-05-29 04:51:18 +01:00
if(APPLE AND ZIG_STATIC)
build: simplify llvm-config provided system library parsing - Revert the addition of CLANG_SYSTEM_LIBARIES and LLVM_SYSTEM_LIBRARIES - Change addCMakeLibraryList to parse non-absolute path .lib dependencies as system libraries
2023-01-04 07:18:51 +00:00
list(REMOVE_ITEM LLVM_LIBRARIES "-lcurses")
CMake: Use NAMES_PER_DIR in all lookups CMake has a surprising default behavior where looking up a library by multiple names gives the name order higher priority than the directory search order. For example, if your system provides "llvm-config-14" and CMAKE_PREFIX_PATH includes "llvm-config", CMake will always end up choosing the system-provided llvm-config-14. This change add NAMES_PER_DIR to request the more sensible behavior: directory search order has higher priority than name order, so CMAKE_PREFIX_PATH always wins over system-provided tools/libraries.
2022-07-13 18:36:25 +01:00
find_library(CURSES NAMES libcurses.a libncurses.a NAMES_PER_DIR
Force static libncurses in CMakeLists when static zig on macos Add additional search paths pointing at homebrew prefixes as Apple doesn't ship a static libncurses for linking - only a stub for dynamic linking `libncurses.tbd`.
2021-11-28 10:07:19 +00:00
PATHS
/usr/local/opt/ncurses/lib
/opt/homebrew/opt/ncurses/lib)
ci: macos: update to new cache tarball This tarball contains LLVM, Clang, LLD, Zig, and libz.a for macOS. This is everything we need for the CI to produce a working Zig executable.
2020-10-15 01:36:43 +01:00
list(APPEND LLVM_LIBRARIES "${CURSES}")
Include libxml2 and zlib as required libraries libxml2 is a required library, but we only find out that when the build fails to link against it, if it is not present. The same for zlib. We use find_library to find these two libraries and print nice fail messages if they are not found.
2018-03-20 11:46:31 +00:00
endif()
eliminate dependency of libzigcpp.a on libzigstage1.a This allows us to create a build of self-hosted with LLVM extensions enabled but without the stage1 backend.
2020-09-23 08:00:24 +01:00
set(ZIG_CPP_LIB_DIR "${CMAKE_BINARY_DIR}/zigcpp")
self-hosted: build against zig_llvm and embedded LLD Now the self-hosted compiler re-uses the same C++ code for interfacing with LLVM as the C++ code. It also links against the same LLD library files.
2017-12-27 00:44:08 +00:00
Don't install stage2 artifacts Fixes #2220.
2019-04-18 07:58:12 +01:00
# Handle multi-config builds and place each into a common lib. The VS generator
# for example will append a Debug folder by default if not explicitly specified.
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${ZIG_CPP_LIB_DIR})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${ZIG_CPP_LIB_DIR})
foreach(CONFIG_TYPE ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER ${CONFIG_TYPE} CONFIG_TYPE)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CONFIG_TYPE} ${ZIG_CPP_LIB_DIR})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CONFIG_TYPE} ${ZIG_CPP_LIB_DIR})
cmake: output binaries to the build directory (ie. instead of Release/Debug subfolders)
2022-11-02 14:12:22 +00:00
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CONFIG_TYPE} ${CMAKE_BINARY_DIR})
Don't install stage2 artifacts Fixes #2220.
2019-04-18 07:58:12 +01:00
endforeach(CONFIG_TYPE CMAKE_CONFIGURATION_TYPES)
remove embedded LLD we no longer have any patches against upstream LLD
2020-01-16 18:09:45 +00:00
include_directories(${LLVM_INCLUDE_DIRS})
include_directories(${LLD_INCLUDE_DIRS})
include_directories(${CLANG_INCLUDE_DIRS})
use lld instead of system linker
2017-03-13 15:54:56 +00:00
depend on embedded SoftFloat-3d instead of __float128 See #302 See #467
2017-09-14 06:44:22 +01:00
find_package(Threads)
input output
2015-08-05 23:46:40 +01:00
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
set(ZIG_LIB_DIR "lib/zig")
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
set(ZIG_CONFIG_H_OUT "${CMAKE_BINARY_DIR}/config.h")
set(ZIG_CONFIG_ZIG_OUT "${CMAKE_BINARY_DIR}/config.zig")
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
use zig-wasm2c for bootstrapping
2022-11-28 00:55:12 +00:00
set(ZIG_WASM2C_SOURCES
"${CMAKE_SOURCE_DIR}/stage1/wasm2c.c"
stage1: always optimize blake and softfloat even in debug mode
2018-09-10 14:46:15 +01:00
)
self-hosted: build against zig_llvm and embedded LLD Now the self-hosted compiler re-uses the same C++ code for interfacing with LLVM as the C++ code. It also links against the same LLD library files.
2017-12-27 00:44:08 +00:00
set(ZIG_CPP_SOURCES
delete all stage1 c++ code not directly related to compiling stage2 Deleted 16,000+ lines of c++ code, including: * an implementation of blake hashing * the cache hash system * compiler.cpp * all the linking code, and everything having to do with building glibc, musl, and mingw-w64 * much of the stage1 compiler internals got slimmed down since it now assumes it is always outputting an object file. More stuff: * stage1 is now built with a different strategy: we have a tiny zig0.cpp which is a slimmed down version of what stage1 main.cpp used to be. Its only purpose is to build stage2 zig code into an object file, which is then linked by the host build system (cmake) into stage1. zig0.cpp uses the same C API that stage2 now has access to, so that stage2 zig code can call into stage1 c++ code. - stage1.h is - stage2.h is - stage1.zig is the main entry point for the Zig/C++ hybrid compiler. It has the functions exported from Zig, called in C++, and bindings for the functions exported from C++, called from Zig. * removed the memory profiling instrumentation from stage1. Abandon ship! * Re-added the sections to the README about how to build stage2 and stage3. * stage2 now knows as a comptime boolean whether it is being compiled as part of stage1 or as stage2. - TODO use this flag to call into stage1 for compiling zig code. * introduce -fdll-export-fns and -fno-dll-export-fns and clarify its relationship to link_mode (static/dynamic) * implement depending on LLVM to detect native target cpu features when LLVM extensions are enabled and zig lacks CPU feature detection for that target architecture. * C importing is broken, will need some stage2 support to function again.
2020-09-18 02:29:38 +01:00
# These are planned to stay even when we are self-hosted.
write object file and fix void return type
2015-11-24 20:00:38 +00:00
"${CMAKE_SOURCE_DIR}/src/zig_llvm.cpp"
stage2: add `zig ar` subcommand The same entrypoint supports the following commands: * ar * ranlib * dlltool * lib For now, our strategy is to bundle the (renamed) `main()` function of llvm-ar, same as our strategy for `zig clang`. However, as Zig matures, a goal will be to replace the dependency on LLVM with our own implementation of this tool, so that it is available in builds of zig that do not have LLVM extensions enabled. This commit also categorizes the subcommands into categories in the --help menu.
2021-05-29 04:54:11 +01:00
"${CMAKE_SOURCE_DIR}/src/zig_llvm-ar.cpp"
translate-c: proof of concept for transitioning to userland See #1964
2019-02-16 20:14:51 +00:00
"${CMAKE_SOURCE_DIR}/src/zig_clang.cpp"
add `zig cc` command to act like a C compiler closes #490
2019-02-24 17:53:28 +00:00
"${CMAKE_SOURCE_DIR}/src/zig_clang_driver.cpp"
"${CMAKE_SOURCE_DIR}/src/zig_clang_cc1_main.cpp"
"${CMAKE_SOURCE_DIR}/src/zig_clang_cc1as_main.cpp"
link against LLVM
2015-08-05 23:23:15 +01:00
)
cmake: build stage3 by default This is a simplification of the cmake build script which introduces a new "stage3" target that is built by default, which builds and installs a stage3 zig. It greatly simplifies the build instructions for Zig, making it conform to the regular cmake routine, while still producing a stage3 artifact.
2022-08-20 06:06:15 +01:00
# Needed because we use cmake, not the zig build system, to build zig2.o.
CMake: try to avoid compilation for `install` target This is andrewrk's patch from ziglang#6724 (rebased) CMake: Fix dependency problem I don't know whether the error was expected cmake behavior or a bug. This change seems to fix the issue. See ziglang#6724 for details.
2020-11-11 15:12:17 +00:00
set(ZIG_STAGE2_SOURCES
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
"${ZIG_CONFIG_ZIG_OUT}"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/array_hash_map.zig"
"${CMAKE_SOURCE_DIR}/lib/std/array_list.zig"
"${CMAKE_SOURCE_DIR}/lib/std/ascii.zig"
"${CMAKE_SOURCE_DIR}/lib/std/atomic.zig"
"${CMAKE_SOURCE_DIR}/lib/std/base64.zig"
std.json: Unify stringify and writeStream (#16405)
2023-07-22 00:56:46 +01:00
"${CMAKE_SOURCE_DIR}/lib/std/BitStack.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/buf_map.zig"
move the cache system from compiler to std lib
2023-02-06 02:39:04 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/Build.zig"
"${CMAKE_SOURCE_DIR}/lib/std/Build/Cache.zig"
"${CMAKE_SOURCE_DIR}/lib/std/Build/Cache/DepTokenizer.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/builtin.zig"
"${CMAKE_SOURCE_DIR}/lib/std/c.zig"
"${CMAKE_SOURCE_DIR}/lib/std/c/linux.zig"
"${CMAKE_SOURCE_DIR}/lib/std/child_process.zig"
"${CMAKE_SOURCE_DIR}/lib/std/coff.zig"
"${CMAKE_SOURCE_DIR}/lib/std/comptime_string_map.zig"
"${CMAKE_SOURCE_DIR}/lib/std/crypto.zig"
"${CMAKE_SOURCE_DIR}/lib/std/crypto/blake3.zig"
"${CMAKE_SOURCE_DIR}/lib/std/crypto/siphash.zig"
"${CMAKE_SOURCE_DIR}/lib/std/debug.zig"
"${CMAKE_SOURCE_DIR}/lib/std/dwarf.zig"
move syntax tests out of behavior tests parser_test.zig is where the syntax tests go
2021-08-30 22:31:47 +01:00
"${CMAKE_SOURCE_DIR}/lib/std/dwarf/AT.zig"
cmake: add missing DWARF files to ZIG_STAGE2_SOURCES
2022-03-20 00:37:05 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/dwarf/ATE.zig"
"${CMAKE_SOURCE_DIR}/lib/std/dwarf/FORM.zig"
"${CMAKE_SOURCE_DIR}/lib/std/dwarf/LANG.zig"
move syntax tests out of behavior tests parser_test.zig is where the syntax tests go
2021-08-30 22:31:47 +01:00
"${CMAKE_SOURCE_DIR}/lib/std/dwarf/OP.zig"
"${CMAKE_SOURCE_DIR}/lib/std/dwarf/TAG.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/elf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/event.zig"
"${CMAKE_SOURCE_DIR}/lib/std/event/batch.zig"
"${CMAKE_SOURCE_DIR}/lib/std/event/loop.zig"
"${CMAKE_SOURCE_DIR}/lib/std/fifo.zig"
"${CMAKE_SOURCE_DIR}/lib/std/fmt.zig"
"${CMAKE_SOURCE_DIR}/lib/std/fmt/errol.zig"
"${CMAKE_SOURCE_DIR}/lib/std/fmt/errol/enum3.zig"
"${CMAKE_SOURCE_DIR}/lib/std/fmt/errol/lookup.zig"
"${CMAKE_SOURCE_DIR}/lib/std/fmt/parse_float.zig"
"${CMAKE_SOURCE_DIR}/lib/std/fs.zig"
std.fs: extract AtomicFile to separate file
2023-11-22 20:54:16 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/fs/AtomicFile.zig"
std.fs: extract Dir into separate file
2023-11-22 20:50:31 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/fs/Dir.zig"
std.fs.File: flatten struct
2023-11-22 21:12:53 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/fs/File.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/fs/get_app_data_dir.zig"
"${CMAKE_SOURCE_DIR}/lib/std/fs/path.zig"
"${CMAKE_SOURCE_DIR}/lib/std/hash.zig"
"${CMAKE_SOURCE_DIR}/lib/std/hash/auto_hash.zig"
"${CMAKE_SOURCE_DIR}/lib/std/hash/wyhash.zig"
"${CMAKE_SOURCE_DIR}/lib/std/hash_map.zig"
"${CMAKE_SOURCE_DIR}/lib/std/heap.zig"
"${CMAKE_SOURCE_DIR}/lib/std/heap/arena_allocator.zig"
"${CMAKE_SOURCE_DIR}/lib/std/io.zig"
"${CMAKE_SOURCE_DIR}/lib/std/io/buffered_atomic_file.zig"
"${CMAKE_SOURCE_DIR}/lib/std/io/buffered_writer.zig"
"${CMAKE_SOURCE_DIR}/lib/std/io/change_detection_stream.zig"
Added std.io.counting_reader
2020-12-22 14:30:48 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/io/counting_reader.zig"
std: add LimitedReader: reader that returns EOF early
2020-11-18 15:26:31 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/io/counting_writer.zig"
io: `FindByteOutStream` to `FindByteWriter` See #4917
2021-01-08 20:57:39 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/io/find_byte_writer.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/io/fixed_buffer_stream.zig"
std.EarlyEOFReader: rename to LimitedReader
2021-01-11 23:51:56 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/io/limited_reader.zig"
std: add type-erased reader; base GenericReader on it The idea here is to avoid code bloat by having only one actual io.Reader implementation, which is type erased, and then implement a GenericReader that preserves type information on top of that as thin glue code. The strategy here is for that glue code to `@errSetCast` the result of the type-erased reader functions, however, while trying to do that I ran into #17343.
2023-10-01 02:11:27 +01:00
"${CMAKE_SOURCE_DIR}/lib/std/io/Reader.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/io/seekable_stream.zig"
"${CMAKE_SOURCE_DIR}/lib/std/io/writer.zig"
"${CMAKE_SOURCE_DIR}/lib/std/json.zig"
std.json: Unify stringify and writeStream (#16405)
2023-07-22 00:56:46 +01:00
"${CMAKE_SOURCE_DIR}/lib/std/json/stringify.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/leb128.zig"
"${CMAKE_SOURCE_DIR}/lib/std/linked_list.zig"
"${CMAKE_SOURCE_DIR}/lib/std/log.zig"
"${CMAKE_SOURCE_DIR}/lib/std/macho.zig"
"${CMAKE_SOURCE_DIR}/lib/std/math.zig"
"${CMAKE_SOURCE_DIR}/lib/std/math/big.zig"
"${CMAKE_SOURCE_DIR}/lib/std/math/big/int.zig"
std.math: generalise `inf`, even simpler `isFinite`
2022-04-07 09:34:10 +01:00
"${CMAKE_SOURCE_DIR}/lib/std/math/float.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/math/frexp.zig"
"${CMAKE_SOURCE_DIR}/lib/std/math/isinf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/math/isnan.zig"
"${CMAKE_SOURCE_DIR}/lib/std/math/log.zig"
"${CMAKE_SOURCE_DIR}/lib/std/math/log10.zig"
"${CMAKE_SOURCE_DIR}/lib/std/math/log2.zig"
"${CMAKE_SOURCE_DIR}/lib/std/math/signbit.zig"
"${CMAKE_SOURCE_DIR}/lib/std/math/sqrt.zig"
"${CMAKE_SOURCE_DIR}/lib/std/mem.zig"
"${CMAKE_SOURCE_DIR}/lib/std/mem/Allocator.zig"
"${CMAKE_SOURCE_DIR}/lib/std/meta.zig"
"${CMAKE_SOURCE_DIR}/lib/std/meta/trailer_flags.zig"
MultiArrayList: use @memcpy as a workaround Reverts bf642204b373e01314ecfb0c50a643dc4b05746f and uses a different workaround, suggested by @LemonBoy. There is either a compiler bug or a design flaw somewhere around here. It does not have to block this branch, but I need to understand exactly what's going on here and make it so that nobody ever has to run into this problem again.
2021-02-24 19:49:12 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/multi_array_list.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/os.zig"
std.os reorganization, avoiding `usingnamespace` The main purpose of this branch is to explore avoiding the `usingnamespace` feature of the zig language, specifically with regards to `std.os` and related functionality. If this experiment is successful, it will provide a data point on whether or not it would be practical to entirely remove `usingnamespace` from the language. In this commit, `usingnamespace` has been completely eliminated from the Linux x86_64 compilation path, aside from io_uring. The behavior tests pass, however that's as far as this branch goes. It is very breaking, and a lot more work is needed before it could be considered mergeable. I wanted to put a pull requset up early so that zig programmers have time to provide feedback. This is progress towards closing #6600 since it clarifies where the actual "owner" of each declaration is, and reduces the number of different ways to import the same declarations. One of the main organizational strategies used here is to do namespacing with real namespaces (e.g. structs) rather than by having declarations share a common prefix (the C strategy). It's no coincidence that `usingnamespace` has similar semantics to `#include` and becomes much less necessary when using proper namespaces.
2021-08-24 21:43:41 +01:00
"${CMAKE_SOURCE_DIR}/lib/std/os/linux.zig"
"${CMAKE_SOURCE_DIR}/lib/std/os/linux/errno/generic.zig"
"${CMAKE_SOURCE_DIR}/lib/std/os/linux/x86_64.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/os/linux.zig"
"${CMAKE_SOURCE_DIR}/lib/std/os/linux/io_uring.zig"
"${CMAKE_SOURCE_DIR}/lib/std/os/linux/x86_64.zig"
"${CMAKE_SOURCE_DIR}/lib/std/os/windows.zig"
"${CMAKE_SOURCE_DIR}/lib/std/os/windows/ntstatus.zig"
"${CMAKE_SOURCE_DIR}/lib/std/os/windows/win32error.zig"
rework std.ResetEvent, improve std lib Darwin integration * split std.ResetEvent into: - ResetEvent - requires init() at runtime and it can fail. Also requires deinit(). - StaticResetEvent - can be statically initialized and requires no deinitialization. Initialization cannot fail. * the POSIX sem_t implementation can in fact fail on initialization because it is allowed to be implemented as a file descriptor. * Completely define, clarify, and explain in detail the semantics of these APIs. Remove the `isSet` function. * `ResetEvent.timedWait` returns an enum instead of a possible error. * `ResetEvent.init` takes a pointer to the ResetEvent instead of returning a copy. * On Darwin, `ResetEvent` is implemented using Grand Central Dispatch, which is exposed by libSystem. stage2 changes: * ThreadPool: use a single, pre-initialized `ResetEvent` per worker. * WaitGroup: now requires init() and deinit() and init() can fail. - Add a `reset` function. - Compilation initializes one for the work queue in creation and re-uses it for every update. - Rename `stop` to `finish`. - Simplify the implementation based on the usage pattern.
2020-12-24 00:57:18 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/Progress.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/pdb.zig"
"${CMAKE_SOURCE_DIR}/lib/std/process.zig"
"${CMAKE_SOURCE_DIR}/lib/std/rand.zig"
"${CMAKE_SOURCE_DIR}/lib/std/sort.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/absv.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/absvdi2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/absvsi2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/absvti2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/adddf3.zig"
compiler-rt: break up functions even more The purpose of this branch is to switch to using an object file for each independent function, in order to make linking simpler - instead of relying on `-ffunction-sections` and `--gc-sections`, which involves the linker doing the work of linking everything and then undoing work via garbage collection, this will allow the linker to only include the compilation units that are depended on in the first place. This commit makes progress towards that goal.
2022-06-16 07:09:56 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/addf3.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/addo.zig"
compiler-rt: break up functions even more The purpose of this branch is to switch to using an object file for each independent function, in order to make linking simpler - instead of relying on `-ffunction-sections` and `--gc-sections`, which involves the linker doing the work of linking everything and then undoing work via garbage collection, this will allow the linker to only include the compilation units that are depended on in the first place. This commit makes progress towards that goal.
2022-06-16 07:09:56 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/addsf3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/addtf3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/addxf3.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/arm.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/atomics.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/aulldiv.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/aullrem.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/bswap.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/ceil.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/clear_cache.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/cmp.zig"
compiler-rt: break up functions even more The purpose of this branch is to switch to using an object file for each independent function, in order to make linking simpler - instead of relying on `-ffunction-sections` and `--gc-sections`, which involves the linker doing the work of linking everything and then undoing work via garbage collection, this will allow the linker to only include the compilation units that are depended on in the first place. This commit makes progress towards that goal.
2022-06-16 07:09:56 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/cmpdf2.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/cmpsf2.zig"
compiler-rt: break up functions even more The purpose of this branch is to switch to using an object file for each independent function, in order to make linking simpler - instead of relying on `-ffunction-sections` and `--gc-sections`, which involves the linker doing the work of linking everything and then undoing work via garbage collection, this will allow the linker to only include the compilation units that are depended on in the first place. This commit makes progress towards that goal.
2022-06-16 07:09:56 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/cmptf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/cmpxf2.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/common.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/comparef.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/cos.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/count0bits.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/divdf3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/divsf3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/divtf3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/divti3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/divxf3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/emutls.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/exp.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/exp2.zig"
compiler-rt: break up functions even more The purpose of this branch is to switch to using an object file for each independent function, in order to make linking simpler - instead of relying on `-ffunction-sections` and `--gc-sections`, which involves the linker doing the work of linking everything and then undoing work via garbage collection, this will allow the linker to only include the compilation units that are depended on in the first place. This commit makes progress towards that goal.
2022-06-16 07:09:56 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/extenddftf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/extenddfxf2.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendf.zig"
compiler-rt: break up functions even more The purpose of this branch is to switch to using an object file for each independent function, in order to make linking simpler - instead of relying on `-ffunction-sections` and `--gc-sections`, which involves the linker doing the work of linking everything and then undoing work via garbage collection, this will allow the linker to only include the compilation units that are depended on in the first place. This commit makes progress towards that goal.
2022-06-16 07:09:56 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendhfsf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendhftf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendhfxf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendsfdf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendsftf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendsfxf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendxftf2.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fabs.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixdfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixdfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixdfti.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixhfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixhfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixhfti.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixsfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixsfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixsfti.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixtfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixtfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixtfti.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsdfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsdfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsdfti.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunshfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunshfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunshfti.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunssfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunssfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunssfti.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunstfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunstfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunstfti.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsxfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsxfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsxfti.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixxfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixxfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixxfti.zig"
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 08:14:16 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/int_from_float.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatdidf.zig"
compiler-rt: break up functions even more The purpose of this branch is to switch to using an object file for each independent function, in order to make linking simpler - instead of relying on `-ffunction-sections` and `--gc-sections`, which involves the linker doing the work of linking everything and then undoing work via garbage collection, this will allow the linker to only include the compilation units that are depended on in the first place. This commit makes progress towards that goal.
2022-06-16 07:09:56 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatdihf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatdisf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatditf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatdixf.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatsidf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatsihf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatsisf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatsitf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatsixf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floattidf.zig"
compiler-rt: break up functions even more The purpose of this branch is to switch to using an object file for each independent function, in order to make linking simpler - instead of relying on `-ffunction-sections` and `--gc-sections`, which involves the linker doing the work of linking everything and then undoing work via garbage collection, this will allow the linker to only include the compilation units that are depended on in the first place. This commit makes progress towards that goal.
2022-06-16 07:09:56 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floattihf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floattisf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floattitf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floattixf.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatundidf.zig"
compiler-rt: break up functions even more The purpose of this branch is to switch to using an object file for each independent function, in order to make linking simpler - instead of relying on `-ffunction-sections` and `--gc-sections`, which involves the linker doing the work of linking everything and then undoing work via garbage collection, this will allow the linker to only include the compilation units that are depended on in the first place. This commit makes progress towards that goal.
2022-06-16 07:09:56 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatundihf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatundisf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunditf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatundixf.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunsidf.zig"
compiler-rt: break up functions even more The purpose of this branch is to switch to using an object file for each independent function, in order to make linking simpler - instead of relying on `-ffunction-sections` and `--gc-sections`, which involves the linker doing the work of linking everything and then undoing work via garbage collection, this will allow the linker to only include the compilation units that are depended on in the first place. This commit makes progress towards that goal.
2022-06-16 07:09:56 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunsihf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunsisf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunsitf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunsixf.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatuntidf.zig"
compiler-rt: break up functions even more The purpose of this branch is to switch to using an object file for each independent function, in order to make linking simpler - instead of relying on `-ffunction-sections` and `--gc-sections`, which involves the linker doing the work of linking everything and then undoing work via garbage collection, this will allow the linker to only include the compilation units that are depended on in the first place. This commit makes progress towards that goal.
2022-06-16 07:09:56 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatuntihf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatuntisf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatuntitf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatuntixf.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/floor.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fma.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fmax.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fmin.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/fmod.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/gedf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/gesf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/getf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/gexf2.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/int.zig"
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 08:14:16 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/float_from_int.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/log.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/log10.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/log2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/modti3.zig"
compiler_rt: declutter int.zig, add mulXi3 tests (#14623) - Combine mulXi3 routines for follow-up cleanup. - DRY up Dwords and Twords - rename both to HalveInt and use instance * Justification: Not all processors have word size 32 bit. * remove test file from CMakeLists * DRY things.
2023-02-24 18:27:02 +00:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/mulXi3.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/muldf3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/mulf3.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/mulo.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/mulsf3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/multf3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/mulxf3.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/negXi2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/negv.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/os_version_check.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/parity.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/popcount.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/rem_pio2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/rem_pio2_large.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/rem_pio2f.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/round.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/shift.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/sin.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/sincos.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/sqrt.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/stack_probe.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/subo.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/subsf3.zig"
stage2: lower float negation explicitly Rather than lowering float negation as `0.0 - x`. * Add AIR instruction for float negation. * Add compiler-rt functions for f128, f80 negation closes #11853
2022-06-30 08:02:00 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/subdf3.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/subtf3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/subxf3.zig"
stage2: lower float negation explicitly Rather than lowering float negation as `0.0 - x`. * Add AIR instruction for float negation. * Add compiler-rt functions for f128, f80 negation closes #11853
2022-06-30 08:02:00 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/negsf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/negdf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/negtf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/negxf2.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/tan.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/trig.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/trunc.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/truncdfhf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/truncdfsf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/truncf.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/truncsfhf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/trunctfdf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/trunctfhf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/trunctfsf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/trunctfxf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/truncxfdf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/truncxfhf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/truncxfsf2.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/udivmod.zig"
compiler-rt: implement __udivei4 and __umodei4 (#14023) Allows dividing and formatting arbitrary-large unsigned integers.
2022-12-22 21:29:19 +00:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/udivmodei4.zig"
flatten lib/std/special and improve "pkg inside another" logic stage2: change logic for detecting whether the main package is inside the std package. Previously it relied on realpath() which is not portable. This uses resolve() which is how imports already work. * stage2: fix cleanup bug when creating Module * flatten lib/std/special/* to lib/* - this was motivated by making main_pkg_is_inside_std false for compiler_rt & friends. * rename "mini libc" to "universal libc"
2022-05-07 03:22:40 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/udivmodti4.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/udivti3.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/umodti3.zig"
update CMakeLists.txt source files
2022-06-18 02:24:57 +01:00
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/unorddf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/unordsf2.zig"
"${CMAKE_SOURCE_DIR}/lib/compiler_rt/unordtf2.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/start.zig"
"${CMAKE_SOURCE_DIR}/lib/std/std.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/aarch64.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/amdgpu.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/arm.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/avr.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/bpf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/hexagon.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/mips.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/msp430.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/nvptx.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/powerpc.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/riscv.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/sparc.zig"
std: rename std.Target.systemz to .s390x
2022-07-28 21:47:29 +01:00
"${CMAKE_SOURCE_DIR}/lib/std/target/s390x.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/target/wasm.zig"
"${CMAKE_SOURCE_DIR}/lib/std/target/x86.zig"
organize std lib concurrency primitives and add RwLock * move concurrency primitives that always operate on kernel threads to the std.Thread namespace * remove std.SpinLock. Nobody should use this in a non-freestanding environment; the other primitives are always preferable. In freestanding, it will be necessary to put custom spin logic in there, so there are no use cases for a std lib version. * move some std lib files to the top level fields convention * add std.Thread.spinLoopHint * add std.Thread.Condition * add std.Thread.Semaphore * new implementation of std.Thread.Mutex for Windows and non-pthreads Linux * add std.Thread.RwLock Implementations provided by @kprotty
2021-01-15 03:41:37 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/Thread.zig"
std.Thread.Futex addition (#9070) * std.Thread.Futex: implementation + tests * std.Thread.Futex: fix darwin compile errors * std.Thread.Futex: fix wait() documentation typo * std.Thread.Futex: fix darwin version check * std.Thread.Futex: remove unnecessary comptime keyword
2021-06-12 14:51:37 +01:00
"${CMAKE_SOURCE_DIR}/lib/std/Thread/Futex.zig"
organize std lib concurrency primitives and add RwLock * move concurrency primitives that always operate on kernel threads to the std.Thread namespace * remove std.SpinLock. Nobody should use this in a non-freestanding environment; the other primitives are always preferable. In freestanding, it will be necessary to put custom spin logic in there, so there are no use cases for a std lib version. * move some std lib files to the top level fields convention * add std.Thread.spinLoopHint * add std.Thread.Condition * add std.Thread.Semaphore * new implementation of std.Thread.Mutex for Windows and non-pthreads Linux * add std.Thread.RwLock Implementations provided by @kprotty
2021-01-15 03:41:37 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/Thread/Mutex.zig"
extract ThreadPool and WaitGroup from compiler to std lib
2023-02-13 20:39:06 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/Thread/Pool.zig"
organize std lib concurrency primitives and add RwLock * move concurrency primitives that always operate on kernel threads to the std.Thread namespace * remove std.SpinLock. Nobody should use this in a non-freestanding environment; the other primitives are always preferable. In freestanding, it will be necessary to put custom spin logic in there, so there are no use cases for a std lib version. * move some std lib files to the top level fields convention * add std.Thread.spinLoopHint * add std.Thread.Condition * add std.Thread.Semaphore * new implementation of std.Thread.Mutex for Windows and non-pthreads Linux * add std.Thread.RwLock Implementations provided by @kprotty
2021-01-15 03:41:37 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/Thread/ResetEvent.zig"
extract ThreadPool and WaitGroup from compiler to std lib
2023-02-13 20:39:06 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/Thread/WaitGroup.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/time.zig"
treap: initial implementation
2022-04-15 21:26:51 +01:00
"${CMAKE_SOURCE_DIR}/lib/std/treap.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/unicode.zig"
"${CMAKE_SOURCE_DIR}/lib/std/zig.zig"
rename std.zig.ast to std.zig.Ast; use top-level fields
2021-08-31 03:22:04 +01:00
"${CMAKE_SOURCE_DIR}/lib/std/zig/Ast.zig"
cmake: fix location of AstRlAnnotate.zig
2023-11-25 02:17:28 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/zig/AstRlAnnotate.zig"
std lib API deprecations for the upcoming 0.9.0 release See #3811
2021-11-30 07:13:07 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/zig/CrossTarget.zig"
translate-c: add missing builtins used by CRuby
2022-03-19 17:08:17 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/zig/c_builtins.zig"
introduce ZON: Zig Object Notation * std.zig.parse is moved to std.zig.Ast.parse * the new function has an additional parameter that requires passing Mode.zig or Mode.zon * moved parser.zig code to Parse.zig * added parseZon function next to parseRoot function
2023-02-03 00:32:06 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/zig/Parse.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/zig/render.zig"
make the build runner and test runner talk to each other std.Build.addTest creates a CompileStep as before, however, this kind of step no longer actually runs the unit tests. Instead it only compiles it, and one must additionally create a RunStep from the CompileStep in order to actually run the tests. RunStep gains integration with the default test runner, which now supports the standard --listen=- argument in order to communicate over stdin and stdout. It also reports test statistics; how many passed, failed, and leaked, as well as directly associating the relevant stderr with the particular test name that failed. This separation of CompileStep and RunStep means that `CompileStep.Kind.test_exe` is no longer needed, and therefore has been removed in this commit. * build runner: show unit test statistics in build summary * added Step.writeManifest since many steps want to treat it as a warning and emit the same message if it fails. * RunStep: fixed error message that prints the failed command printing the original argv and not the adjusted argv in case an interpreter was used. * RunStep: fixed not passing the command line arguments to the interpreter. * move src/Server.zig to std.zig.Server so that the default test runner can use it. * the simpler test runner function which is used by work-in-progress backends now no longer prints to stderr, which is necessary in order for the build runner to not print the stderr as a warning message.
2023-03-12 07:39:21 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/zig/Server.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/zig/string_literal.zig"
"${CMAKE_SOURCE_DIR}/lib/std/zig/system.zig"
improve detection of how to execute binaries on the host `getExternalExecutor` is moved from `std.zig.CrossTarget` to `std.zig.system.NativeTargetInfo.getExternalExecutor`. The function also now communicates a bit more information about *why* the host is unable to execute a binary. The CLI is updated to report this information in a useful manner. `getExternalExecutor` is also improved to detect such patterns as: * x86_64 is able to execute x86 binaries * aarch64 is able to execute arm binaries * etc. Added qemu-hexagon support to `getExternalExecutor`. `std.Target.canExecBinaries` of is removed; callers should use the more powerful `getExternalExecutor` instead. Now that `zig test` tries to run the resulting binary no matter what, this commit has a follow-up change to the build system and docgen to utilize the `getExternalExecutor` function and pass `--test-no-exec` in some cases to avoid getting the error. Additionally: * refactor: extract NativePaths and NativeTargetInfo into their own files named after the structs. * small improvement to langref to reduce the complexity of the `callconv` expression in a couple examples.
2021-12-03 04:51:14 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/zig/system/NativePaths.zig"
"${CMAKE_SOURCE_DIR}/lib/std/zig/system/NativeTargetInfo.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/lib/std/zig/system/x86.zig"
"${CMAKE_SOURCE_DIR}/lib/std/zig/tokenizer.zig"
stage2: extract ZIR printing code into print_zir.zig also implement textual printing of the ZIR instruction `atomic_rmw`.
2021-09-20 22:45:40 +01:00
"${CMAKE_SOURCE_DIR}/src/Air.zig"
"${CMAKE_SOURCE_DIR}/src/AstGen.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/Compilation.zig"
stage2: extract ZIR printing code into print_zir.zig also implement textual printing of the ZIR instruction `atomic_rmw`.
2021-09-20 22:45:40 +01:00
"${CMAKE_SOURCE_DIR}/src/Liveness.zig"
CMake: try to avoid compilation for `install` target This is andrewrk's patch from ziglang#6724 (rebased) CMake: Fix dependency problem I don't know whether the error was expected cmake behavior or a bug. This change seems to fix the issue. See ziglang#6724 for details.
2020-11-11 15:12:17 +00:00
"${CMAKE_SOURCE_DIR}/src/Module.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/Package.zig"
rework package manager Organize everything around a Fetch task which does a bunch of stuff in a worker thread without touching any shared state, and then queues up Fetch tasks for its dependencies. This isn't the theoretical optimal package fetching performance because CPU cores don't necessarily map 1:1 with I/O tasks, and each fetch task contains a mixture of computations and I/O. However, it is expected for this to significantly outperform master branch, which fetches everything recursively with only one thread. The logic is now a lot more linear and easy to follow. Everything that is embarassingly parallel is done on the thread pool, and then after everything is fetched, the worker threads are joined and the main thread does the finishing touches of stitching together the dependencies.zig import files. There is only one tiny little critical section and it does not even have any error handling in it. This also lays the groundwork for #14281 because in system mode, all this fetching logic will be skipped, but the "finishing touches" mentioned above still need to be done. With this branch, that logic is separated out and no longer recursively tangled with fetching stuff. Additionally, this branch: * Implements inclusion directives in `build.zig.zon` for deciding which files belong the package (#14311). * Adds basic documentation for `build.zig.zon` files. * Adds support for fetching dependencies with the `file://` protocol scheme (#17364). * Adds a workaround for a Linux/btrfs file system bug (#17282). This commit is a work-in-progress. Still todo: 1. Hook up the CLI to the new system. 2. Restore the module table creation logic after all the fetching is done. 3. Fix compilation errors, get the tests passing, and regression test against real world projects.
2023-10-04 07:27:17 +01:00
"${CMAKE_SOURCE_DIR}/src/Package/Fetch.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/RangeSet.zig"
stage2: extract ZIR printing code into print_zir.zig also implement textual printing of the ZIR instruction `atomic_rmw`.
2021-09-20 22:45:40 +01:00
"${CMAKE_SOURCE_DIR}/src/Sema.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/TypedValue.zig"
stage2: extract ZIR printing code into print_zir.zig also implement textual printing of the ZIR instruction `atomic_rmw`.
2021-09-20 22:45:40 +01:00
"${CMAKE_SOURCE_DIR}/src/Zir.zig"
add missing files to CMakeLists
2021-12-24 00:48:58 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/aarch64/CodeGen.zig"
"${CMAKE_SOURCE_DIR}/src/arch/aarch64/Emit.zig"
"${CMAKE_SOURCE_DIR}/src/arch/aarch64/Mir.zig"
stage2 codegen: move bit definitions to src/arch
2021-09-23 21:47:12 +01:00
"${CMAKE_SOURCE_DIR}/src/arch/aarch64/bits.zig"
stage2 regalloc: replace Register.allocIndex with generic indexOfReg * callee_preserved_regs and other ABI-specific information have been moved to the respective abi.zig files
2022-03-10 22:14:28 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/aarch64/abi.zig"
add missing files to CMakeLists
2021-12-24 00:48:58 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/arm/CodeGen.zig"
"${CMAKE_SOURCE_DIR}/src/arch/arm/Emit.zig"
"${CMAKE_SOURCE_DIR}/src/arch/arm/Mir.zig"
stage2 codegen: move bit definitions to src/arch
2021-09-23 21:47:12 +01:00
"${CMAKE_SOURCE_DIR}/src/arch/arm/bits.zig"
stage2 regalloc: replace Register.allocIndex with generic indexOfReg * callee_preserved_regs and other ABI-specific information have been moved to the respective abi.zig files
2022-03-10 22:14:28 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/arm/abi.zig"
add missing files to CMakeLists
2021-12-24 00:48:58 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/riscv64/CodeGen.zig"
"${CMAKE_SOURCE_DIR}/src/arch/riscv64/Emit.zig"
"${CMAKE_SOURCE_DIR}/src/arch/riscv64/Mir.zig"
stage2 codegen: move bit definitions to src/arch
2021-09-23 21:47:12 +01:00
"${CMAKE_SOURCE_DIR}/src/arch/riscv64/bits.zig"
stage2 regalloc: replace Register.allocIndex with generic indexOfReg * callee_preserved_regs and other ABI-specific information have been moved to the respective abi.zig files
2022-03-10 22:14:28 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/riscv64/abi.zig"
target: Rename sparcv9 -> sparc64 Rename all references of sparcv9 to sparc64, to make Zig align more with other projects. Also, added new function to convert glibc arch name to Zig arch name, since it refers to the architecture as sparcv9. This is based on the suggestion by @kubkon in PR 11847. (https://github.com/ziglang/zig/pull/11487#pullrequestreview-963761757)
2022-05-13 16:59:06 +01:00
"${CMAKE_SOURCE_DIR}/src/arch/sparc64/CodeGen.zig"
"${CMAKE_SOURCE_DIR}/src/arch/sparc64/Emit.zig"
"${CMAKE_SOURCE_DIR}/src/arch/sparc64/Mir.zig"
"${CMAKE_SOURCE_DIR}/src/arch/sparc64/bits.zig"
"${CMAKE_SOURCE_DIR}/src/arch/sparc64/abi.zig"
Stage2: wasm - Implement the MIR pass (#10153) * wasm: Move wasm's codegen to arch/wasm/CodeGen.zig * wasm: Define Wasm's Mir This declares the initial most-used instructions for wasm as well as the data that represents them. TODO: Add binary operand opcodes. By re-using the wasm opcode values, we can emit each opcode very easily by simply using `@enumToInt()`. However, this poses a possible problem: If we use all of wasm's opcodes, it leaves us no room to use synthetic opcodes such as debugging instructions. We could use reserved opcodes, but the wasm spec may use them at some point. TODO: Check if we should perhaps use a 16bit tag where the highest bits are used for synthetic opcodes. * wasm: Define basic Emit structure * wasm: Implement corresponding Emit functions for MIR * wasm: Initial lowering to MIR - This implements lowering to MIR from AIR for storing and loading of locals as well as emitting immediates. - Relocating function indexes has been simplified a lot as well as we no longer need to patch offsets and we write a relocatable value instead. - Locals are now emitted at the beginning of the function section entry meaning all offsets we generate are stable. * wasm: Lower all AIR instructions to MIR * wasm: Implement remaining MIR instructions * wasm: Fix function relocations * wasm: Get all tests working * wasm: Make `Data` 4 bytes instead of 8. - 64bit immediates are now stored in 2 seperate u32's. - 64bit floats are now stored in 2 seperate u32's. - `mem_arg` is now stored as a seperate payload in extra.
2021-11-15 17:02:24 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/wasm/CodeGen.zig"
add missing files to CMakeLists
2021-12-24 00:48:58 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/wasm/Emit.zig"
"${CMAKE_SOURCE_DIR}/src/arch/wasm/Mir.zig"
"${CMAKE_SOURCE_DIR}/src/arch/x86_64/CodeGen.zig"
cmake: add new zig source files
2023-09-13 21:40:01 +01:00
"${CMAKE_SOURCE_DIR}/src/arch/x86_64/Disassembler.zig"
stage2: rename Isel to Emit for x86_64 Clean up generated errors in Emit.
2022-01-15 17:36:13 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/x86_64/Emit.zig"
x86_64: add missing source files to CMakeLists.txt
2023-03-12 21:08:29 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/x86_64/Encoding.zig"
add missing files to CMakeLists
2021-12-24 00:48:58 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/x86_64/Mir.zig"
stage2 regalloc: replace Register.allocIndex with generic indexOfReg * callee_preserved_regs and other ABI-specific information have been moved to the respective abi.zig files
2022-03-10 22:14:28 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/x86_64/abi.zig"
x86_64: add missing source files to CMakeLists.txt
2023-03-12 21:08:29 +00:00
"${CMAKE_SOURCE_DIR}/src/arch/x86_64/bits.zig"
"${CMAKE_SOURCE_DIR}/src/arch/x86_64/encoder.zig"
"${CMAKE_SOURCE_DIR}/src/arch/x86_64/encodings.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/clang.zig"
"${CMAKE_SOURCE_DIR}/src/clang_options.zig"
"${CMAKE_SOURCE_DIR}/src/clang_options_data.zig"
"${CMAKE_SOURCE_DIR}/src/codegen.zig"
"${CMAKE_SOURCE_DIR}/src/codegen/c.zig"
CBE: add CType interning
2023-02-21 02:31:57 +00:00
"${CMAKE_SOURCE_DIR}/src/codegen/c/type.zig"
stage2: rename and move files related to LLVM backend
2021-01-06 00:27:06 +00:00
"${CMAKE_SOURCE_DIR}/src/codegen/llvm.zig"
"${CMAKE_SOURCE_DIR}/src/codegen/llvm/bindings.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/glibc.zig"
"${CMAKE_SOURCE_DIR}/src/introspect.zig"
"${CMAKE_SOURCE_DIR}/src/libc_installation.zig"
"${CMAKE_SOURCE_DIR}/src/libcxx.zig"
WIP start adding support for TSAN
2020-12-22 05:18:19 +00:00
"${CMAKE_SOURCE_DIR}/src/libtsan.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/libunwind.zig"
"${CMAKE_SOURCE_DIR}/src/link.zig"
"${CMAKE_SOURCE_DIR}/src/link/C.zig"
"${CMAKE_SOURCE_DIR}/src/link/Coff.zig"
coff: reorganize the linker
2022-08-26 13:11:14 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Coff/Atom.zig"
coff: move import table definition into a separate ImportTable.zig module
2023-03-28 13:13:39 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Coff/ImportTable.zig"
cmake: add runaway Coff/Object.zig path
2022-08-29 23:45:01 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Coff/Object.zig"
coff: reorganize the linker
2022-08-26 13:11:14 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Coff/lld.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/link/Elf.zig"
cmake: add new zig source files
2023-09-13 21:40:01 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Elf/Archive.zig"
elf: add missing input zig source files to cmake
2023-09-12 23:40:08 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Elf/Atom.zig"
elf: parse GNU ld script as system lib indirection
2023-10-18 11:38:15 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Elf/LdScript.zig"
elf: add missing input zig source files to cmake
2023-09-12 23:40:08 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Elf/LinkerDefined.zig"
"${CMAKE_SOURCE_DIR}/src/link/Elf/Object.zig"
elf: re-enable dynamic linking codepaths
2023-10-05 16:53:04 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Elf/SharedObject.zig"
elf: add missing input zig source files to cmake
2023-09-12 23:40:08 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Elf/Symbol.zig"
elf: rename ZigModule to ZigObject
2023-10-30 13:58:59 +00:00
"${CMAKE_SOURCE_DIR}/src/link/Elf/ZigObject.zig"
elf: add missing input zig source files to cmake
2023-09-12 23:40:08 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Elf/eh_frame.zig"
"${CMAKE_SOURCE_DIR}/src/link/Elf/file.zig"
elf: add garbage collection of sections
2023-10-04 14:14:45 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Elf/gc.zig"
elf: add missing input zig source files to cmake
2023-09-12 23:40:08 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Elf/synthetic_sections.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/link/MachO.zig"
zld: use zld when linking aarch64 by default and cross-comp
2021-03-17 21:14:55 +00:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/Archive.zig"
macho: init process of renaming TextBlock to Atom Initially, internally within the linker.
2021-09-09 17:32:03 +01:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/Atom.zig"
zld: use zld when linking aarch64 by default and cross-comp
2021-03-17 21:14:55 +00:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/CodeSignature.zig"
"${CMAKE_SOURCE_DIR}/src/link/MachO/DebugSymbols.zig"
macho: upstream rewritten traditional linker, zld kubkon/zld gitrev 5733ed87abe2f07e1330c3232a252e9defec638a
2022-10-18 21:10:00 +01:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/DwarfInfo.zig"
zld: add prelim way of linking dylibs The support is minimalistic in the sense that we only support actual dylib files and not stubs/tbds yet, and we also don't support re-exports just yet.
2021-05-16 15:32:27 +01:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/Dylib.zig"
zld: use zld when linking aarch64 by default and cross-comp
2021-03-17 21:14:55 +00:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/Object.zig"
macho: dedup LC emitting logic Fix path written to `LC_ID_DYLIB` to include the current CWD (if any).
2022-12-14 10:46:46 +00:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/Relocation.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/Trie.zig"
zld: parse, synthesise and emit unwind records
2023-01-20 17:26:21 +00:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/UnwindInfo.zig"
update CMakeLists.txt with new entries
2023-01-18 23:35:33 +00:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/dyld_info/bind.zig"
"${CMAKE_SOURCE_DIR}/src/link/MachO/dyld_info/Rebase.zig"
macho: move GC code into dead_strip.zig module Implement marking live atoms that reference other live atoms if required by the compiler (via section attribute).
2022-07-21 12:30:15 +01:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/dead_strip.zig"
zld: parse, synthesise and emit unwind records
2023-01-20 17:26:21 +00:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/eh_frame.zig"
macho: dedup LC emitting logic Fix path written to `LC_ID_DYLIB` to include the current CWD (if any).
2022-12-14 10:46:46 +00:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/fat.zig"
macho: extract parallel hasher into a generic helper struct
2023-06-19 09:29:14 +01:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/hasher.zig"
macho: dedup LC emitting logic Fix path written to `LC_ID_DYLIB` to include the current CWD (if any).
2022-12-14 10:46:46 +00:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/load_commands.zig"
macho: upstream rewritten traditional linker, zld kubkon/zld gitrev 5733ed87abe2f07e1330c3232a252e9defec638a
2022-10-18 21:10:00 +01:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/thunks.zig"
macho: calculate UUID chunk size based on available thread count
2023-06-19 11:53:26 +01:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/uuid.zig"
macho: upstream rewritten traditional linker, zld kubkon/zld gitrev 5733ed87abe2f07e1330c3232a252e9defec638a
2022-10-18 21:10:00 +01:00
"${CMAKE_SOURCE_DIR}/src/link/MachO/zld.zig"
stage2: extract ZIR printing code into print_zir.zig also implement textual printing of the ZIR instruction `atomic_rmw`.
2021-09-20 22:45:40 +01:00
"${CMAKE_SOURCE_DIR}/src/link/Plan9.zig"
"${CMAKE_SOURCE_DIR}/src/link/Plan9/aout.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/link/Wasm.zig"
stage2: extract ZIR printing code into print_zir.zig also implement textual printing of the ZIR instruction `atomic_rmw`.
2021-09-20 22:45:40 +01:00
"${CMAKE_SOURCE_DIR}/src/link/msdos-stub.bin"
elf: redo strings management in the linker * atom names - are stored locally and pulled from defining object's strtab * local symbols - same * global symbols - in principle, we could store them locally, but for better debugging experience - when things go wrong - we store the offsets in a global strtab used by the symbol resolver
2023-10-31 12:27:47 +00:00
"${CMAKE_SOURCE_DIR}/src/link/StringTable.zig"
link: add basic TAPI parser for linkers Parser uses kubkon/zig-yaml gitrev c3eae1e40a02aedd44ad1171e5c8b259896cbda0
2021-06-19 09:45:56 +01:00
"${CMAKE_SOURCE_DIR}/src/link/tapi.zig"
stage2: extract ZIR printing code into print_zir.zig also implement textual printing of the ZIR instruction `atomic_rmw`.
2021-09-20 22:45:40 +01:00
"${CMAKE_SOURCE_DIR}/src/link/tapi/Tokenizer.zig"
link: add basic TAPI parser for linkers Parser uses kubkon/zig-yaml gitrev c3eae1e40a02aedd44ad1171e5c8b259896cbda0
2021-06-19 09:45:56 +01:00
"${CMAKE_SOURCE_DIR}/src/link/tapi/parse.zig"
"${CMAKE_SOURCE_DIR}/src/link/tapi/yaml.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/main.zig"
"${CMAKE_SOURCE_DIR}/src/mingw.zig"
"${CMAKE_SOURCE_DIR}/src/musl.zig"
stage2: extract ZIR printing code into print_zir.zig also implement textual printing of the ZIR instruction `atomic_rmw`.
2021-09-20 22:45:40 +01:00
"${CMAKE_SOURCE_DIR}/src/print_air.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/print_env.zig"
"${CMAKE_SOURCE_DIR}/src/print_targets.zig"
stage2: extract ZIR printing code into print_zir.zig also implement textual printing of the ZIR instruction `atomic_rmw`.
2021-09-20 22:45:40 +01:00
"${CMAKE_SOURCE_DIR}/src/print_zir.zig"
add missing source file to CMakeLists.txt
2022-02-14 19:26:15 +00:00
"${CMAKE_SOURCE_DIR}/src/register_manager.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/target.zig"
"${CMAKE_SOURCE_DIR}/src/tracy.zig"
"${CMAKE_SOURCE_DIR}/src/translate_c.zig"
translate-c: fix using wrong slice and AST tag
2021-02-23 20:55:12 +00:00
"${CMAKE_SOURCE_DIR}/src/translate_c/ast.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/type.zig"
"${CMAKE_SOURCE_DIR}/src/value.zig"
wasi,cc: fix naming and add stubs for building Rename include dir to match the convention: from `wasm32-wasi` to `wasm-wasi-musl` Add building stubs which will be used to build and cache WASI libc sysroot.
2021-05-18 15:00:06 +01:00
"${CMAKE_SOURCE_DIR}/src/wasi_libc.zig"
cmake: add the correct set of zig stage2 sources
2020-11-17 00:57:22 +00:00
"${CMAKE_SOURCE_DIR}/src/windows_sdk.zig"
aro: Add stub definitions to enable bootstrapping Co-authored-by: Veikka Tuominen <git@vexu.eu>
2023-11-03 05:05:13 +00:00
"${CMAKE_SOURCE_DIR}/src/stubs/aro_builtins.zig"
"${CMAKE_SOURCE_DIR}/src/stubs/aro_names.zig"
CMake: try to avoid compilation for `install` target This is andrewrk's patch from ziglang#6724 (rebased) CMake: Fix dependency problem I don't know whether the error was expected cmake behavior or a bug. This change seems to fix the issue. See ziglang#6724 for details.
2020-11-11 15:12:17 +00:00
)
link against LLVM
2015-08-05 23:23:15 +01:00
update windows build to llvm 5.0.1 llvm-config.exe does not handle diaguids.lib for us so we have to duplicate the work.
2018-01-05 03:46:26 +00:00
if(MSVC)
set(MSVC_DIA_SDK_DIR "$ENV{VSINSTALLDIR}DIA SDK")
supress warnings for format strings on msys64
2019-06-23 02:21:48 +01:00
if(IS_DIRECTORY ${MSVC_DIA_SDK_DIR})
update windows build to llvm 5.0.1 llvm-config.exe does not handle diaguids.lib for us so we have to duplicate the work.
2018-01-05 03:46:26 +00:00
set(ZIG_DIA_GUIDS_LIB "${MSVC_DIA_SDK_DIR}/lib/amd64/diaguids.lib")
string(REGEX REPLACE "\\\\" "\\\\\\\\" ZIG_DIA_GUIDS_LIB_ESCAPED "${ZIG_DIA_GUIDS_LIB}")
endif()
endif()
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
configure_file (
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
"${CMAKE_SOURCE_DIR}/stage1/config.h.in"
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
"${ZIG_CONFIG_H_OUT}"
)
configure_file (
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
"${CMAKE_SOURCE_DIR}/stage1/config.zig.in"
restore the option to build with cmake restore cmake to be capable of figuring out the zig version restore config.h and config.zig. config.h is used to detect whether we should propagate cmake configuration information to build.zig; however it can be overridden with -Dstatic-llvm. fix not passing -DZIG_LINK_MODE with zig build. when using the cmake build path, build.zig no longer tries to call llvm-config. Instead it relies 100% on the LLVM_LIBRARIES cmake variable. build.zig logic reworked and simplified.
2020-12-08 00:23:17 +00:00
"${ZIG_CONFIG_ZIG_OUT}"
)
add tests
2015-11-26 08:29:52 +00:00
include_directories(
${CMAKE_SOURCE_DIR}
${CMAKE_BINARY_DIR}
"${CMAKE_SOURCE_DIR}/src"
)
Use correct compiler flags in MSVC bootstrap builds of Zig https://github.com/ziglang/zig/issues/4877 The CMake build of Zig from C++ uses hand-set compiler flags which are not compatible with the Microsoft C/C++ Optimizing Compiler (cl.exe) used by Visual Studio. This commit attempts to conform them to match the Clang/GCC options under MSVC builds. Note that CL does not have a concept of C99 or "-O3", and may imply other optimizations in "/O2" than are implied by Clang/GCC "-O3". Visual Studio 2019 documentation for cl.exe's optimization options: https://docs.microsoft.com/en-us/cpp/build/reference/o-options-optimize-code?view=vs-2019 Visual Studio 2019 doc for cl.exe's C++ standard options: https://docs.microsoft.com/en-us/cpp/build/reference/std-specify-language-standard-version?view=vs-2019
2020-03-31 15:13:31 +01:00
if(MSVC)
update clang and ar to llvm 16
2023-01-26 03:56:23 +00:00
set(EXE_CXX_FLAGS "/std:c++17")
cmake: no -Werror on the C++ code we copy from llvm
2023-01-26 19:22:39 +00:00
set(EXE_LDFLAGS "/STACK:16777216")
if(NOT "${CMAKE_BUILD_TYPE}" STREQUAL "Release" AND NOT "${CMAKE_BUILD_TYPE}" STREQUAL "MinSizeRel")
set(EXE_LDFLAGS "${EXE_LDFLAGS} /debug:fastlink")
endif()
fix up msvc stuff to make it work on linux and macos too
2017-09-13 05:17:19 +01:00
else()
Merge remote-tracking branch 'origin/master' into llvm16
2023-02-03 19:49:40 +00:00
set(EXE_CXX_FLAGS "-std=c++17 -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D_GNU_SOURCE -fvisibility-inlines-hidden -fno-exceptions -fno-rtti -Werror=type-limits -Wno-missing-braces -Wno-comment")
cmake: no -Werror on the C++ code we copy from llvm
2023-01-26 19:22:39 +00:00
set(EXE_LDFLAGS " ")
if(MINGW)
set(EXE_CXX_FLAGS "${EXE_CXX_FLAGS} -Wno-format")
increase stack size for mingw
2019-06-23 07:15:04 +01:00
set(EXE_LDFLAGS "${EXE_LDFLAGS} -Wl,--stack,16777216")
cmake: no -Werror on the C++ code we copy from llvm
2023-01-26 19:22:39 +00:00
endif()
increase stack size for mingw
2019-06-23 07:15:04 +01:00
endif()
if(ZIG_STATIC)
build: add support for ZIG_STATIC on MacOS
2018-09-27 20:07:51 +01:00
if(APPLE)
improved CMake file for MinGW
2019-07-26 22:26:01 +01:00
set(EXE_LDFLAGS "${EXE_LDFLAGS} -static-libgcc -static-libstdc++")
fixed static linking on mingw-w64
2019-07-13 23:44:05 +01:00
elseif(MINGW)
improved CMake file for MinGW
2019-07-26 22:26:01 +01:00
set(EXE_LDFLAGS "${EXE_LDFLAGS} -static-libgcc -static-libstdc++ -Wl,-Bstatic, -lwinpthread -lz3 -lz -lgomp")
avoid passing -static to msvc when static linking
2019-07-27 23:54:20 +01:00
elseif(NOT MSVC)
improved CMake file for MinGW
2019-07-26 22:26:01 +01:00
set(EXE_LDFLAGS "${EXE_LDFLAGS} -static")
build: add support for ZIG_STATIC on MacOS
2018-09-27 20:07:51 +01:00
endif()
build: add test coverage target
2016-04-23 17:57:38 +01:00
endif()
link against LLVM
2015-08-05 23:23:15 +01:00
eliminate dependency of libzigcpp.a on libzigstage1.a This allows us to create a build of self-hosted with LLVM extensions enabled but without the stage1 backend.
2020-09-23 08:00:24 +01:00
add_library(zigcpp STATIC ${ZIG_CPP_SOURCES})
cmake: add ZIG_PIE toggle for -Dpie - add pkg-maintainer-friendly option to enable PIE when building zig - fix `ZIG_PIE_ARG` syntax
2023-04-29 18:14:51 +01:00
if(ZIG_PIE)
Add `-fno-stack-protector` to flags when building libzigcpp This allows both debug and release builds to link to it without forcing release builds to link to libssp
2023-09-25 02:43:30 +01:00
set(ZIGCPP_CXX_FLAGS "${EXE_CXX_FLAGS} -fno-stack-protector -fPIC")
cmake: add ZIG_PIE toggle for -Dpie - add pkg-maintainer-friendly option to enable PIE when building zig - fix `ZIG_PIE_ARG` syntax
2023-04-29 18:14:51 +01:00
else()
Add `-fno-stack-protector` to flags when building libzigcpp This allows both debug and release builds to link to it without forcing release builds to link to libssp
2023-09-25 02:43:30 +01:00
set(ZIGCPP_CXX_FLAGS "${EXE_CXX_FLAGS} -fno-stack-protector")
cmake: add ZIG_PIE toggle for -Dpie - add pkg-maintainer-friendly option to enable PIE when building zig - fix `ZIG_PIE_ARG` syntax
2023-04-29 18:14:51 +01:00
endif()
set_target_properties(zigcpp PROPERTIES COMPILE_FLAGS ${ZIGCPP_CXX_FLAGS})
fix https://github.com/ziglang/zig/issues/4799
2020-04-18 01:22:00 +01:00
eliminate dependency of libzigcpp.a on libzigstage1.a This allows us to create a build of self-hosted with LLVM extensions enabled but without the stage1 backend.
2020-09-23 08:00:24 +01:00
target_link_libraries(zigcpp LINK_PUBLIC
fix undef clang library symbols when linking self-hosted
2020-02-04 08:39:20 +00:00
${CLANG_LIBRARIES}
${LLD_LIBRARIES}
${LLVM_LIBRARIES}
stage2: add CLI for `zig translate-c`
2020-09-18 09:33:32 +01:00
${CMAKE_THREAD_LIBS_INIT}
fix undef clang library symbols when linking self-hosted
2020-02-04 08:39:20 +00:00
)
self-hosted: build against zig_llvm and embedded LLD Now the self-hosted compiler re-uses the same C++ code for interfacing with LLVM as the C++ code. It also links against the same LLD library files.
2017-12-27 00:44:08 +00:00
solaris: set correct target tuple in CMake
2023-09-30 10:33:37 +01:00
string(TOLOWER "${CMAKE_HOST_SYSTEM_NAME}" ZIG_HOST_TARGET_OS)
if(ZIG_HOST_TARGET_OS STREQUAL "darwin")
set(ZIG_HOST_TARGET_OS "macos")
elseif(ZIG_HOST_TARGET_OS STREQUAL "sunos")
Add illumos OS tag - Adds `illumos` to the `Target.Os.Tag` enum. A new function, `isSolarish` has been added that returns true if the tag is either Solaris or Illumos. This matches the naming convention found in Rust's `libc` crate[1]. - Add the tag wherever `.solaris` is being checked against. - Check for the C pre-processor macro `__illumos__` in CMake to set the proper target tuple. Illumos distros patch their compilers to have this in the "built-in" set (verified with `echo | cc -dM -E -`). Alternatively you could check the output of `uname -o`. Right now, both Solaris and Illumos import from `c/solaris.zig`. In the future it may be worth putting the shared ABI bits in a base file, and mixing that in with specific `c/solaris.zig`/`c/illumos.zig` files. [1]: https://github.com/rust-lang/libc/tree/6e02a329a2a27f6887ea86952f389ca11e06448c/src/unix/solarish
2023-10-01 13:09:14 +01:00
check_symbol_exists(__illumos__ "" ZIG_HOST_TARGET_HAS_ILLUMOS_MACRO)
if (ZIG_HOST_TARGET_HAS_ILLUMOS_MACRO)
set(ZIG_HOST_TARGET_OS "illumos")
else()
set(ZIG_HOST_TARGET_OS "solaris")
endif()
solaris: set correct target tuple in CMake
2023-09-30 10:33:37 +01:00
endif()
bootstrap: support aarch64 in 32-bit mode * `CMakeLists.txt`: support the weird `uname -m` output. * `CMakeLists.txt`: detect and use the C compiler's default arm mode. * cbe: support gcc with both `f128` and `u128` emulated. * std.os.linux.thumb: fix incorrectly passed asm inputs.
2023-06-28 02:59:45 +01:00
string(TOLOWER "${CMAKE_HOST_SYSTEM_PROCESSOR}" ZIG_HOST_TARGET_ARCH)
cmake: fix auto-detection of various host targets Closes #16800
2023-08-13 11:23:46 +01:00
if(ZIG_HOST_TARGET_ARCH MATCHES "^i[3-9]86$")
Add illumos OS tag - Adds `illumos` to the `Target.Os.Tag` enum. A new function, `isSolarish` has been added that returns true if the tag is either Solaris or Illumos. This matches the naming convention found in Rust's `libc` crate[1]. - Add the tag wherever `.solaris` is being checked against. - Check for the C pre-processor macro `__illumos__` in CMake to set the proper target tuple. Illumos distros patch their compilers to have this in the "built-in" set (verified with `echo | cc -dM -E -`). Alternatively you could check the output of `uname -o`. Right now, both Solaris and Illumos import from `c/solaris.zig`. In the future it may be worth putting the shared ABI bits in a base file, and mixing that in with specific `c/solaris.zig`/`c/illumos.zig` files. [1]: https://github.com/rust-lang/libc/tree/6e02a329a2a27f6887ea86952f389ca11e06448c/src/unix/solarish
2023-10-01 13:09:14 +01:00
if (ZIG_HOST_TARGET_OS MATCHES "(solaris|illumos)")
solaris: set correct target tuple in CMake
2023-09-30 10:33:37 +01:00
set(ZIG_HOST_TARGET_ARCH "x86_64")
else()
set(ZIG_HOST_TARGET_ARCH "x86")
endif()
cmake: fix auto-detection of various host targets Closes #16800
2023-08-13 11:23:46 +01:00
elseif(ZIG_HOST_TARGET_ARCH STREQUAL "amd64")
bootstrap: support aarch64 in 32-bit mode * `CMakeLists.txt`: support the weird `uname -m` output. * `CMakeLists.txt`: detect and use the C compiler's default arm mode. * cbe: support gcc with both `f128` and `u128` emulated. * std.os.linux.thumb: fix incorrectly passed asm inputs.
2023-06-28 02:59:45 +01:00
set(ZIG_HOST_TARGET_ARCH "x86_64")
elseif(ZIG_HOST_TARGET_ARCH STREQUAL "arm64")
set(ZIG_HOST_TARGET_ARCH "aarch64")
elseif(ZIG_HOST_TARGET_ARCH STREQUAL "armv7l")
set(ZIG_HOST_TARGET_ARCH "arm")
elseif(ZIG_HOST_TARGET_ARCH STREQUAL "armv7b")
set(ZIG_HOST_TARGET_ARCH "armeb")
cmake: fix host target detection
2022-12-05 06:52:24 +00:00
endif()
cmake: fix auto-detection of various host targets Closes #16800
2023-08-13 11:23:46 +01:00
string(REGEX REPLACE "^((arm|thumb)(hf?)?)el$" "\\1" ZIG_HOST_TARGET_ARCH "${ZIG_HOST_TARGET_ARCH}")
if(ZIG_HOST_TARGET_ARCH MATCHES "^arm(hf?)?(eb)?$")
bootstrap: support aarch64 in 32-bit mode * `CMakeLists.txt`: support the weird `uname -m` output. * `CMakeLists.txt`: detect and use the C compiler's default arm mode. * cbe: support gcc with both `f128` and `u128` emulated. * std.os.linux.thumb: fix incorrectly passed asm inputs.
2023-06-28 02:59:45 +01:00
check_symbol_exists(__thumb__ "" ZIG_HOST_TARGET_DEFAULTS_TO_THUMB)
if(ZIG_HOST_TARGET_DEFAULTS_TO_THUMB)
string(REGEX REPLACE "^arm" "thumb" ZIG_HOST_TARGET_ARCH "${ZIG_HOST_TARGET_ARCH}")
endif()
endif()
cmake: fix auto-detection of various host targets Closes #16800
2023-08-13 11:23:46 +01:00
string(REGEX REPLACE "^ppc((64)?(le)?)$" "powerpc\\1" ZIG_HOST_TARGET_ARCH "${ZIG_HOST_TARGET_ARCH}")
cmake: fix early issues when bootstrapping on mingw This gets all the way to the final link, where `libssp` symbols are undefined, referenced by `libzstd.a`.
2023-08-03 01:37:14 +01:00
if(MSVC)
set(ZIG_HOST_TARGET_ABI "-msvc")
cmake: Fix typo: elif → elseif
2023-08-04 01:00:00 +01:00
elseif(MINGW)
cmake: fix early issues when bootstrapping on mingw This gets all the way to the final link, where `libssp` symbols are undefined, referenced by `libzstd.a`.
2023-08-03 01:37:14 +01:00
set(ZIG_HOST_TARGET_ABI "-gnu")
cmake: fix auto-detection of various host targets Closes #16800
2023-08-13 11:23:46 +01:00
elseif(ZIG_HOST_TARGET_ARCH MATCHES "^(arm|thumb)hf?(eb)?$")
string(REGEX REPLACE "^(arm|thumb)hf?((eb)?)$" "\\1\\2" ZIG_HOST_TARGET_ARCH "${ZIG_HOST_TARGET_ARCH}")
set(ZIG_HOST_TARGET_ABI "-eabihf")
cmake: fix early issues when bootstrapping on mingw This gets all the way to the final link, where `libssp` symbols are undefined, referenced by `libzstd.a`.
2023-08-03 01:37:14 +01:00
else()
set(ZIG_HOST_TARGET_ABI "")
endif()
set(ZIG_HOST_TARGET_TRIPLE "${ZIG_HOST_TARGET_ARCH}-${ZIG_HOST_TARGET_OS}${ZIG_HOST_TARGET_ABI}" CACHE STRING "Host zig target triple.")
cmake: fix host target detection
2022-12-05 06:52:24 +00:00
cmake: fix stack size linker argument on mac
2022-12-05 08:14:54 +00:00
if(MSVC)
fix building wasm2c output with msvc cmake tweaks to allow zig1 to compile successfully with msvc
2022-12-09 14:32:20 +00:00
set(ZIG_WASM2C_COMPILE_FLAGS "")
cmake: /std:c99 isn't a valid cl option
2022-12-13 06:30:03 +00:00
set(ZIG1_COMPILE_FLAGS "/Os")
cmake: /O0 -> /Od
2022-12-17 22:55:56 +00:00
set(ZIG2_COMPILE_FLAGS "/Od")
cmake: add /FORCE:MULTIPLE to handle fabsl being defined in compiler_rt as well as libcmpt
2022-12-28 07:11:12 +00:00
set(ZIG2_LINK_FLAGS "/STACK:16777216 /FORCE:MULTIPLE")
cmake: fix stack size linker argument on mac
2022-12-05 08:14:54 +00:00
else()
set(ZIG_WASM2C_COMPILE_FLAGS "-std=c99 -O2")
set(ZIG1_COMPILE_FLAGS "-std=c99 -Os")
cmake: disable stack protector for zig2 to avoid link errors on windows On windows we get: lld-link: error: undefined symbol: __stack_chk_fail >>> referenced by CMakeFiles/zig2.dir/zig2.c.obj:(main) >>> referenced by CMakeFiles/zig2.dir/zig2.c.obj:(main_main) >>> referenced by CMakeFiles/zig2.dir/zig2.c.obj:(log_scoped_28_default_29_err__anon_2764) >>> referenced 36192 more times lld-link: error: undefined symbol: __stack_chk_guard >>> referenced by CMakeFiles/zig2.dir/zig2.c.obj:(.refptr.__stack_chk_guard) >>> referenced by CMakeFiles/zig2.dir/compiler_rt.c.obj
2022-12-06 08:52:29 +00:00
set(ZIG2_COMPILE_FLAGS "-std=c99 -O0 -fno-stack-protector")
CMake: adjust apple clang compiler check Before it was checking if the compiler was AppleClang, however, this did not handle the case when using a compiled-from-source Clang on a macOS computer, in which case the linker is still Apple ld64, and it is in fact the linker that needs to have the different flag to communicate stack size.
2022-12-05 22:54:07 +00:00
if(APPLE)
cmake: fix stack size linker argument on mac
2022-12-05 08:14:54 +00:00
set(ZIG2_LINK_FLAGS "-Wl,-stack_size,0x10000000")
cmake: fix early issues when bootstrapping on mingw This gets all the way to the final link, where `libssp` symbols are undefined, referenced by `libzstd.a`.
2023-08-03 01:37:14 +01:00
elseif(MINGW)
set(ZIG2_LINK_FLAGS "-Wl,--stack,0x10000000")
solaris: ld does not have stack-size option
2023-09-26 22:52:35 +01:00
# Solaris/illumos ld(1) does not provide a --stack-size option.
elseif(CMAKE_HOST_SOLARIS)
unset(ZIG2_LINK_FLAGS)
cmake: fix stack size linker argument on mac
2022-12-05 08:14:54 +00:00
else()
set(ZIG2_LINK_FLAGS "-Wl,-z,stack-size=0x10000000")
endif()
endif()
remove the zstd mechanism from the build process
2022-12-09 23:33:32 +00:00
set(ZIG1_WASM_MODULE "${CMAKE_SOURCE_DIR}/stage1/zig1.wasm")
use zig-wasm2c for bootstrapping
2022-11-28 00:55:12 +00:00
set(ZIG1_C_SOURCE "${CMAKE_BINARY_DIR}/zig1.c")
set(ZIG2_C_SOURCE "${CMAKE_BINARY_DIR}/zig2.c")
set(ZIG_COMPILER_RT_C_SOURCE "${CMAKE_BINARY_DIR}/compiler_rt.c")
add_executable(zig-wasm2c ${ZIG_WASM2C_SOURCES})
fix building wasm2c output with msvc cmake tweaks to allow zig1 to compile successfully with msvc
2022-12-09 14:32:20 +00:00
set_target_properties(zig-wasm2c PROPERTIES COMPILE_FLAGS "${ZIG_WASM2C_COMPILE_FLAGS}")
use zig-wasm2c for bootstrapping
2022-11-28 00:55:12 +00:00
add_custom_command(
OUTPUT "${ZIG1_C_SOURCE}"
remove the zstd mechanism from the build process
2022-12-09 23:33:32 +00:00
COMMAND zig-wasm2c "${ZIG1_WASM_MODULE}" "${ZIG1_C_SOURCE}"
DEPENDS zig-wasm2c "${ZIG1_WASM_MODULE}"
COMMENT STATUS "Converting ${ZIG1_WASM_MODULE} to ${ZIG1_C_SOURCE}"
use zig-wasm2c for bootstrapping
2022-11-28 00:55:12 +00:00
WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
)
add_executable(zig1 ${ZIG1_C_SOURCE} "${CMAKE_SOURCE_DIR}/stage1/wasi.c")
CMake adjustments
2022-12-04 23:45:15 +00:00
set_target_properties(zig1 PROPERTIES COMPILE_FLAGS ${ZIG1_COMPILE_FLAGS})
fix building wasm2c output with msvc cmake tweaks to allow zig1 to compile successfully with msvc
2022-12-09 14:32:20 +00:00
if(MSVC)
target_link_options(zig1 PRIVATE /STACK:0x10000000)
else()
target_link_libraries(zig1 LINK_PUBLIC m)
cmake: fix early issues when bootstrapping on mingw This gets all the way to the final link, where `libssp` symbols are undefined, referenced by `libzstd.a`.
2023-08-03 01:37:14 +01:00
if(MINGW)
target_link_options(zig1 PRIVATE -Wl,--stack,0x10000000)
endif()
fix building wasm2c output with msvc cmake tweaks to allow zig1 to compile successfully with msvc
2022-12-09 14:32:20 +00:00
endif()
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
cmake: build stage3 by default This is a simplification of the cmake build script which introduces a new "stage3" target that is built by default, which builds and installs a stage3 zig. It greatly simplifies the build instructions for Zig, making it conform to the regular cmake routine, while still producing a stage3 artifact.
2022-08-20 06:06:15 +01:00
set(BUILD_ZIG2_ARGS
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
"${CMAKE_SOURCE_DIR}/lib"
build-exe src/main.zig -ofmt=c -lc
CMake: use ReleaseSmall instead of ReleaseFast When producing C source code. This enables strip, which should avoid bloat and save compilation time.
2022-12-03 21:21:35 +00:00
-OReleaseSmall
use zig-wasm2c for bootstrapping
2022-11-28 00:55:12 +00:00
--name zig2 -femit-bin="${ZIG2_C_SOURCE}"
Update std.Build to new module CLI, update zig1 and CMakeLists Resolves: #14667
2023-02-17 06:20:52 +00:00
--mod "build_options::${ZIG_CONFIG_ZIG_OUT}"
aro-translate-c: update to upstream changes
2023-11-15 09:30:26 +00:00
--mod "aro_options::src/stubs/aro_options.zig"
aro: Add stub definitions to enable bootstrapping Co-authored-by: Veikka Tuominen <git@vexu.eu>
2023-11-03 05:05:13 +00:00
--mod "Builtins/Builtin.def::src/stubs/aro_builtins.zig"
--mod "Attribute/names.def::src/stubs/aro_names.zig"
aro-translate-c: update to upstream changes
2023-11-15 09:30:26 +00:00
--mod "Diagnostics/messages.def::src/stubs/aro_messages.zig"
--mod "aro_backend:build_options=aro_options:deps/aro/backend.zig"
--mod "aro:Builtins/Builtin.def,Attribute/names.def,Diagnostics/messages.def,build_options=aro_options,backend=aro_backend:deps/aro/aro.zig"
add Aro sources as a dependency ref: 5688dbccfb58216468267a0f46b96bed7013715a
2023-09-29 11:06:49 +01:00
--deps build_options,aro
bootstrap: support aarch64 in 32-bit mode * `CMakeLists.txt`: support the weird `uname -m` output. * `CMakeLists.txt`: detect and use the C compiler's default arm mode. * cbe: support gcc with both `f128` and `u128` emulated. * std.os.linux.thumb: fix incorrectly passed asm inputs.
2023-06-28 02:59:45 +01:00
-target "${ZIG_HOST_TARGET_TRIPLE}"
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
)
compiler_rt: declutter int.zig, add mulXi3 tests (#14623) - Combine mulXi3 routines for follow-up cleanup. - DRY up Dwords and Twords - rename both to HalveInt and use instance * Justification: Not all processors have word size 32 bit. * remove test file from CMakeLists * DRY things.
2023-02-24 18:27:02 +00:00
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
add_custom_command(
OUTPUT "${ZIG2_C_SOURCE}"
COMMAND zig1 ${BUILD_ZIG2_ARGS}
cmake: fix bootstrap dependencies
2022-12-06 01:05:34 +00:00
DEPENDS zig1 "${ZIG_STAGE2_SOURCES}"
CMake adjustments
2022-12-04 23:45:15 +00:00
COMMENT STATUS "Running zig1.wasm to produce ${ZIG2_C_SOURCE}"
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
cmake: support `make` and `make install` (2nd attempt to get this right)
2020-01-18 00:39:43 +00:00
)
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
set(BUILD_COMPILER_RT_ARGS
"${CMAKE_SOURCE_DIR}/lib"
build-obj lib/compiler_rt.zig -ofmt=c
CMake: use ReleaseSmall instead of ReleaseFast When producing C source code. This enables strip, which should avoid bloat and save compilation time.
2022-12-03 21:21:35 +00:00
-OReleaseSmall
use zig-wasm2c for bootstrapping
2022-11-28 00:55:12 +00:00
--name compiler_rt -femit-bin="${ZIG_COMPILER_RT_C_SOURCE}"
Update std.Build to new module CLI, update zig1 and CMakeLists Resolves: #14667
2023-02-17 06:20:52 +00:00
--mod "build_options::${ZIG_CONFIG_ZIG_OUT}"
--deps build_options
bootstrap: support aarch64 in 32-bit mode * `CMakeLists.txt`: support the weird `uname -m` output. * `CMakeLists.txt`: detect and use the C compiler's default arm mode. * cbe: support gcc with both `f128` and `u128` emulated. * std.os.linux.thumb: fix incorrectly passed asm inputs.
2023-06-28 02:59:45 +01:00
-target "${ZIG_HOST_TARGET_TRIPLE}"
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
)
compiler_rt: declutter int.zig, add mulXi3 tests (#14623) - Combine mulXi3 routines for follow-up cleanup. - DRY up Dwords and Twords - rename both to HalveInt and use instance * Justification: Not all processors have word size 32 bit. * remove test file from CMakeLists * DRY things.
2023-02-24 18:27:02 +00:00
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
add_custom_command(
OUTPUT "${ZIG_COMPILER_RT_C_SOURCE}"
COMMAND zig1 ${BUILD_COMPILER_RT_ARGS}
cmake: fix bootstrap dependencies
2022-12-06 01:05:34 +00:00
DEPENDS zig1 "${ZIG_STAGE2_SOURCES}"
CMake adjustments
2022-12-04 23:45:15 +00:00
COMMENT STATUS "Running zig1.wasm to produce ${ZIG_COMPILER_RT_C_SOURCE}"
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
)
cmake: support cross compiling
2020-03-28 03:43:21 +00:00
interpret the WASI blob to produce zig2.c and compiler_rt.c * synchronize zig1.c from zig-wasi external project * change the way argv works to avoid absolute paths * autodetect isatty * compiler_rt: disable some functions when object format is C * add missing flag from config.zig.in The next problem is that compiling compiler_rt.c with gcc gives "conflicting types" errors for `__eqhf2` and friends.
2022-11-16 00:40:04 +00:00
add_executable(zig2 ${ZIG2_C_SOURCE} ${ZIG_COMPILER_RT_C_SOURCE})
cmake: build stage3 by default This is a simplification of the cmake build script which introduces a new "stage3" target that is built by default, which builds and installs a stage3 zig. It greatly simplifies the build instructions for Zig, making it conform to the regular cmake routine, while still producing a stage3 artifact.
2022-08-20 06:06:15 +01:00
set_target_properties(zig2 PROPERTIES
redo CMakeLists.txt to use WASI interpreter current status is that it hits error: OutOfMemory for unknown reasons, probably due to bugs in the C WASI interpreter port.
2022-11-15 07:33:05 +00:00
COMPILE_FLAGS ${ZIG2_COMPILE_FLAGS}
solaris: ld does not have stack-size option
2023-09-26 22:52:35 +01:00
LINK_FLAGS "${ZIG2_LINK_FLAGS}"
stage1 is now a hybrid of C++ and Zig This modifies the build process of Zig to put all of the source files into libcompiler.a, except main.cpp and userland.cpp. Next, the build process links main.cpp, userland.cpp, and libcompiler.a into zig1. userland.cpp is a shim for functions that will later be replaced with self-hosted implementations. Next, the build process uses zig1 to build src-self-hosted/stage1.zig into libuserland.a, which does not depend on any of the things that are shimmed in userland.cpp, such as translate-c. Finally, the build process re-links main.cpp and libcompiler.a, except with libuserland.a instead of userland.cpp. Now the shims are replaced with .zig code. This provides all of the Zig standard library to the stage1 C++ compiler, and enables us to move certain things to userland, such as translate-c. As a proof of concept I have made the `zig zen` command use text defined in userland. I added `zig translate-c-2` which is a work-in-progress reimplementation of translate-c in userland, which currently calls `std.debug.panic("unimplemented")` and you can see the stack trace makes it all the way back into the C++ main() function (Thanks LemonBoy for improving that!). This could potentially let us move other things into userland, such as hashing algorithms, the entire cache system, .d file parsing, pretty much anything that libuserland.a itself doesn't need to depend on. This can also let us have `zig fmt` in stage1 without the overhead of child process execution, and without the initial compilation delay before it gets cached. See #1964
2019-04-16 21:47:47 +01:00
)
CBE: use stdint.h types instead of `zig_` prefixes This requires manual defines before C99 which may not have stdint.h. Also have update-zig1 leave a copy of lib/zig.h in stage1/zig.h, which allows lib/zig.h to be updated without needing to update zig1.wasm. Note that since the object already existed with the exact same contents, this completely avoids repo bloat due to zig.h changes.
2023-02-21 01:52:26 +00:00
target_include_directories(zig2 PUBLIC "${CMAKE_SOURCE_DIR}/stage1")
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
target_link_libraries(zig2 LINK_PUBLIC zigcpp)
if(MSVC)
CI: make Windows build from source like everybody else Now that OOM is no longer a problem, the Windows CI can do the same process every other system does instead of building from a recent Zig binary.
2022-12-01 07:49:55 +00:00
target_link_libraries(zig2 LINK_PUBLIC ntdll.lib)
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
elseif(MINGW)
CI: make Windows build from source like everybody else Now that OOM is no longer a problem, the Windows CI can do the same process every other system does instead of building from a recent Zig binary.
2022-12-01 07:49:55 +00:00
target_link_libraries(zig2 LINK_PUBLIC ntdll)
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
endif()
if(NOT MSVC)
target_link_libraries(zig2 LINK_PUBLIC ${LIBXML2})
endif()
if(ZIG_DIA_GUIDS_LIB)
target_link_libraries(zig2 LINK_PUBLIC ${ZIG_DIA_GUIDS_LIB})
endif()
if(MSVC OR MINGW)
target_link_libraries(zig2 LINK_PUBLIC version)
endif()
if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
set(ZIG_RELEASE_ARG "")
elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo")
zig build: change "-Drelease" to "-Doptimize" I find myself quite often creating ReleaseSafe builds and putting them to production for certain experiments: - Debug info are for stack traces. An ongoing example where those would help is #14815. - Safety checks would have saved a couple of mine and @kubkon's hours in #15098. This is a breaking change for scripts that make Zig releases -- I will submit another PR to zig-bootstrap and release-cutter after this is merged.
2023-04-06 08:32:05 +01:00
set(ZIG_RELEASE_ARG -Doptimize=ReleaseFast)
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
else()
zig build: change "-Drelease" to "-Doptimize" I find myself quite often creating ReleaseSafe builds and putting them to production for certain experiments: - Debug info are for stack traces. An ongoing example where those would help is #14815. - Safety checks would have saved a couple of mine and @kubkon's hours in #15098. This is a breaking change for scripts that make Zig releases -- I will submit another PR to zig-bootstrap and release-cutter after this is merged.
2023-04-06 08:32:05 +01:00
set(ZIG_RELEASE_ARG -Doptimize=ReleaseFast -Dstrip)
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
endif()
if(ZIG_NO_LIB)
set(ZIG_NO_LIB_ARG "-Dno-lib")
else()
set(ZIG_NO_LIB_ARG "")
endif()
if(ZIG_SINGLE_THREADED)
cmake: fix typo in flag value for single threaded build
2023-06-24 16:18:35 +01:00
set(ZIG_SINGLE_THREADED_ARG "-Dsingle-threaded")
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
else()
set(ZIG_SINGLE_THREADED_ARG "")
endif()
build: first pass on geting stage3 building under x64_64-windows-msvc
2022-11-08 07:14:39 +00:00
if(ZIG_STATIC AND NOT MSVC)
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
set(ZIG_STATIC_ARG "-Duse-zig-libcxx")
else()
set(ZIG_STATIC_ARG "")
endif()
cmake: add ZIG_PIE toggle for -Dpie - add pkg-maintainer-friendly option to enable PIE when building zig - fix `ZIG_PIE_ARG` syntax
2023-04-29 18:14:51 +01:00
if(CMAKE_POSITION_INDEPENDENT_CODE OR ZIG_PIE)
set(ZIG_PIE_ARG "-Dpie")
build: add -Dpie option It is becoming increasingly common for distributions to want to enable PIE for all binaries and zig currently does not provide any way to do so aside from patching the build.zig.
2023-03-08 13:21:33 +00:00
else()
cmake: add ZIG_PIE toggle for -Dpie - add pkg-maintainer-friendly option to enable PIE when building zig - fix `ZIG_PIE_ARG` syntax
2023-04-29 18:14:51 +01:00
set(ZIG_PIE_ARG "")
build: add -Dpie option It is becoming increasingly common for distributions to want to enable PIE for all binaries and zig currently does not provide any way to do so aside from patching the build.zig.
2023-03-08 13:21:33 +00:00
endif()
cmake: don't ask zig2 to do hard things Apparently hard things: * run autodoc on the std lib * build the langref If any zig distros want these documentation, they'll need to get them from a stage3 `zig build` instead of stage2 (LLVM backend instead of C backend).
2023-07-22 19:03:01 +01:00
# -Dno-langref is currently hardcoded because building the langref takes too damn long
# -Dno-autodocs is currently hardcoded because the C backend generates a miscompilation
# that prevents it from working.
# To obtain these two forms of documentation, run zig build against stage3 rather than stage2.
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
set(ZIG_BUILD_ARGS
--zig-lib-dir "${CMAKE_SOURCE_DIR}/lib"
"-Dconfig_h=${ZIG_CONFIG_H_OUT}"
"-Denable-llvm"
${ZIG_RELEASE_ARG}
${ZIG_STATIC_ARG}
${ZIG_NO_LIB_ARG}
cmake: don't ask zig2 to do hard things Apparently hard things: * run autodoc on the std lib * build the langref If any zig distros want these documentation, they'll need to get them from a stage3 `zig build` instead of stage2 (LLVM backend instead of C backend).
2023-07-22 19:03:01 +01:00
"-Dno-langref"
"-Dno-autodocs"
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
${ZIG_SINGLE_THREADED_ARG}
build: add -Dpie option It is becoming increasingly common for distributions to want to enable PIE for all binaries and zig currently does not provide any way to do so aside from patching the build.zig.
2023-03-08 13:21:33 +00:00
${ZIG_PIE_ARG}
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
"-Dtarget=${ZIG_TARGET_TRIPLE}"
"-Dcpu=${ZIG_TARGET_MCPU}"
"-Dversion-string=${RESOLVED_ZIG_VERSION}"
)
add_custom_target(stage3 ALL
cmake: install zig to 'build_dir/stage3' during building This commit installs Zig to "build_dir/stage3" during building so that distros' can easily find binary and use it for testing/etc. This commit also splits "add_custom_target(stage3 ALL" and command that it invokes, so that it won't retry it during installation, as target will be considered not out-of-date. See also https://www.github.com/ziglang/zig/issues/14240#issuecomment-1374642063
2023-01-10 07:20:40 +00:00
DEPENDS "${CMAKE_BINARY_DIR}/stage3/bin/zig"
)
add_custom_command(
OUTPUT "${CMAKE_BINARY_DIR}/stage3/bin/zig"
COMMAND zig2 build --prefix "${CMAKE_BINARY_DIR}/stage3" ${ZIG_BUILD_ARGS}
enable the LLVM backend in stage2 This takes a bit longer since the interpreted part has to do more work but it saves a round trip through the compiler by allowing `zig2 build` to be the final step. 1-2-3, done. For me this is currently failing due to compilation errors generated by GCC when compiling zig2.c but in theory if those are fixed, it should work!
2022-11-16 06:04:18 +00:00
COMMENT STATUS "Building stage3"
WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
)
if(WIN32)
set(ZIG_EXECUTABLE "${CMAKE_BINARY_DIR}/zig2.exe")
else()
set(ZIG_EXECUTABLE "${CMAKE_BINARY_DIR}/zig2")
endif()
install(CODE "set(ZIG_EXECUTABLE \"${ZIG_EXECUTABLE}\")")
install(CODE "set(ZIG_BUILD_ARGS \"${ZIG_BUILD_ARGS}\")")
install(CODE "set(CMAKE_INSTALL_PREFIX \"${CMAKE_INSTALL_PREFIX}\")")
install(CODE "set(CMAKE_SOURCE_DIR \"${CMAKE_SOURCE_DIR}\")")
install(SCRIPT "${CMAKE_SOURCE_DIR}/cmake/install.cmake")
Reference in New Issue Copy Permalink