From fd5cde82bbaa5555b7094ea322a353ed6d030a92 Mon Sep 17 00:00:00 2001 From: sisungo Date: Fri, 14 Aug 2026 16:55:50 +0800 Subject: [PATCH] feat: add package rust Signed-off-by: sisungo --- packages/rust/bootstrap.toml.in | 740 ++++++++++++++++++++++++++++++++ packages/rust/pkgbuild.py | 77 ++++ 2 files changed, 817 insertions(+) create mode 100644 packages/rust/bootstrap.toml.in create mode 100644 packages/rust/pkgbuild.py diff --git a/packages/rust/bootstrap.toml.in b/packages/rust/bootstrap.toml.in new file mode 100644 index 0000000..585e6cb --- /dev/null +++ b/packages/rust/bootstrap.toml.in @@ -0,0 +1,740 @@ +# bootstrap.toml.in: Bootstrap Config Template +# +# Replacing Stubs: +# - %RUSTVERSION%: Version of rust +# - %CARGOPATH%: Absolute path of cargo +# - %RUSTCPATH%: Absolute path of rustc +# - %INSTALLPREFIX%: Install prefix + +# ============================================================================= +# Global Settings +# ============================================================================= + +# Use different pre-set defaults than the global defaults. +# +# See `src/bootstrap/defaults` for more information. +# Note that this has no default value (x.py uses the defaults in `bootstrap.example.toml`). +profile = "dist" + +# ============================================================================= +# Tweaking how LLVM is compiled +# ============================================================================= + +# Don't download Rust CI LLVM, instead, we compile it by our own. +llvm.download-ci-llvm = false + +# Indicates whether the LLVM build is a Release or Debug build +llvm.optimize = true + +# Indicates whether LLVM should be built with ThinLTO. Note that this will +# only succeed if you use clang, lld, llvm-ar, and llvm-ranlib in your C/C++ +# toolchain (see the `cc`, `cxx`, `linker`, `ar`, and `ranlib` options below). +# More info at: https://clang.llvm.org/docs/ThinLTO.html#clang-bootstrap +llvm.thin-lto = true + +# Indicates whether an LLVM Release build should include debug info +llvm.release-debuginfo = false + +# Indicates whether the LLVM assertions are enabled or not +# NOTE: When assertions are disabled, bugs in the integration between rustc and LLVM can lead to +# unsoundness (segfaults, etc.) in the rustc process itself, not just in the generated code. +llvm.assertions = false + +# Indicates whether the LLVM testsuite is enabled in the build or not. Does +# not execute the tests as part of the build as part of x.py build et al, +# just makes it possible to do `ninja check-llvm` in the staged LLVM build +# directory when doing LLVM development as part of Rust development. +llvm.tests = false + +# Indicates whether the LLVM plugin is enabled or not +llvm.plugins = false + +# Whether to build Enzyme as AutoDiff backend. +llvm.enzyme = false + +# Whether to build LLVM with support for it's gpu offload runtime. +llvm.offload = false + +# Absolute path to the directory containing ClangConfig.cmake +llvm.offload-clang-dir = "" + +# When true, link libstdc++ statically into the rustc_llvm. +# This is useful if you don't want to use the dynamic version of that +# library provided by LLVM. +llvm.static-libstdcpp = false + +# Enable LLVM to use zstd for compression. +llvm.libzstd = false + +# Whether to use Ninja to build LLVM. This runs much faster than make. +llvm.ninja = true + +# LLVM targets to build support for. +#llvm.targets = + +# LLVM experimental targets to build support for. +#llvm.experimental-targets = + +# Cap the number of parallel linker invocations when compiling LLVM. +#llvm.link-jobs = + +# Whether to build LLVM as a dynamically linked library (as opposed to statically linked). +# Under the hood, this passes `--shared` to llvm-config. +# NOTE: To avoid performing LTO multiple times, we suggest setting this to `true` when `thin-lto` is enabled. +llvm.link-shared = true + +# When building llvm, this configures what is being appended to the version. +llvm.version-suffix = "-rust-%RUSTVERSION%" + +# Use libc++ when building LLVM instead of libstdc++. This is the default on +# platforms already use libc++ as the default C++ library, but this option +# allows you to use libc++ even on platforms when it's not. You need to ensure +# that your host compiler ships with libc++. +llvm.use-libcxx = true + +# The value specified here will be passed as `-DLLVM_USE_LINKER` to CMake. +#llvm.use-linker = (path) + +# Whether or not to specify `-DLLVM_TEMPORARILY_ALLOW_OLD_TOOLCHAIN=YES` +#llvm.allow-old-toolchain = false + +# Whether to include the Polly optimizer. +llvm.polly = false + +# Whether to build the clang compiler. +llvm.clang = false + +# Whether to enable llvm compilation warnings. +llvm.enable-warnings = false + +# Custom CMake defines to set when building LLVM. +llvm.build-config = {"LLVM_ENABLE_LIBCXX" = "ON"} + +# ============================================================================= +# General build configuration options +# ============================================================================= + +# The default stage to use for the `check` subcommand +#build.check-stage = 0 + +# The default stage to use for the `doc` subcommand +#build.doc-stage = 0 + +# The default stage to use for the `build` subcommand +#build.build-stage = 1 + +# The default stage to use for the `test` subcommand +#build.test-stage = 1 + +# The default stage to use for the `dist` subcommand +#build.dist-stage = 2 + +# The default stage to use for the `install` subcommand +#build.install-stage = 2 + +# The default stage to use for the `bench` subcommand +#build.bench-stage = 2 + +# A descriptive string to be appended to version output (e.g., `rustc --version`), +# which is also used in places like debuginfo `DW_AT_producer`. This may be useful for +# supplementary build information, like distro-specific package versions. +# +# IMPORTANT: Changing this value changes crate IDs and symbol name mangling, making +# compiled artifacts incompatible. PGO profiles cannot be reused across different +# descriptions, and incremental compilation caches are invalidated. Keep this value +# consistent when reusing build artifacts. +# +# The Rust compiler will differentiate between versions of itself, including +# based on this string, which means that if you wish to be compatible with +# upstream Rust you need to set this to "". However, note that if you set this to "" but +# are not actually compatible -- for example if you've backported patches that change +# behavior -- this may lead to miscompilations or other bugs. +#build.description = "" + +# Build triple for the pre-compiled snapshot compiler. If `rustc` is set, this must match its host +# triple (see `rustc --version --verbose`; cross-compiling the rust build system itself is NOT +# supported). If `rustc` is unset, this must be a platform with pre-compiled host tools +# (https://doc.rust-lang.org/nightly/rustc/platform-support.html). The current platform must be +# able to run binaries of this build triple. +# +# If `rustc` is present in path, this defaults to the host it was compiled for. +# Otherwise, `x.py` will try to infer it from the output of `uname`. +# If `uname` is not found in PATH, we assume this is `x86_64-pc-windows-msvc`. +# This may be changed in the future. +#build.build = "x86_64-unknown-linux-gnu" (as an example) + +# Which triples to produce a compiler toolchain for. Each of these triples will be bootstrapped from +# the build triple themselves. In other words, this is the list of triples for which to build a +# compiler that can RUN on that triple. +# +# Defaults to just the `build` triple. +#build.host = [build.build] (list of triples) + +# Which triples to build libraries (core/alloc/std/test/proc_macro) for. Each of these triples will +# be bootstrapped from the build triple themselves. In other words, this is the list of triples for +# which to build a library that can CROSS-COMPILE to that triple. +# +# Defaults to `host`. If you set this explicitly, you likely want to add all +# host triples to this list as well in order for those host toolchains to be +# able to compile programs for their native target. +#build.target = build.host (list of triples) + +# Use this directory to store build artifacts. Paths are relative to the current directory, not to +# the root of the repository. +#build.build-dir = "build" + +# Instead of downloading the src/stage0 version of Cargo specified, use +# this Cargo binary instead to build all Rust code +# If you set this, you likely want to set `rustc` as well. +build.cargo = "%CARGOPATH%" + +# Instead of downloading the src/stage0 version of the compiler +# specified, use this rustc binary instead as the stage0 snapshot compiler. +# If you set this, you likely want to set `cargo` as well. +build.rustc = "%RUSTCPATH%" + +# Use this rustdoc binary as the stage0 snapshot rustdoc. +# If unspecified, then the binary "rustdoc" (with platform-specific extension, e.g. ".exe") +# in the same directory as "rustc" will be used. +#build.rustdoc = "/path/to/rustdoc" + +# Instead of downloading the src/stage0 version of rustfmt specified, +# use this rustfmt binary instead as the stage0 snapshot rustfmt. +#build.rustfmt = "/path/to/rustfmt" + +# Instead of downloading the src/stage0 version of cargo-clippy specified, +# use this cargo-clippy binary instead as the stage0 snapshot cargo-clippy. +# +# Note that this option should be used with the same toolchain as the `rustc` option above. +# Otherwise, clippy is likely to fail due to a toolchain conflict. +#build.cargo-clippy = "/path/to/cargo-clippy" + +# Whether to build documentation by default. If false, rustdoc and +# friends will still be compiled but they will not be used to generate any +# documentation. +# +# You can still build documentation when this is disabled by explicitly passing paths, +# e.g. `x doc library`. +build.docs = true + +# Flag to specify whether CSS, JavaScript, and HTML are minified when +# docs are generated. JSON is always minified, because it's enormous, +# and generated in already-minified form from the beginning. +build.docs-minification = true + +# Flag to specify whether private items should be included in the library docs. +build.library-docs-private-items = false + +# Indicate whether to build compiler documentation by default. +# You can still build documentation when this is disabled by explicitly passing a path: `x doc compiler`. +build.compiler-docs = false + +# Indicate whether git submodules are managed and updated automatically. +build.submodules = false + +# The path to (or name of) the GDB executable to use. This is only used for +# executing the debuginfo test suite. +#build.gdb = + +# The path to (or name of) the LLDB executable to use. This is only used for +# executing the debuginfo test suite. +#build.lldb = + +# The node.js executable to use. Note that this is only used for the emscripten +# target when running tests, otherwise this can be omitted. +#build.nodejs = + +# The yarn executable to use. Note that this is used for rustdoc-gui tests and +# tidy js extra-checks, otherwise this can be omitted. +# +# Under Windows this should be `yarn.cmd` or path to it (verified on nodejs v18.06), or +# error will be emitted. +#build.yarn = + +# Python interpreter to use for various tasks throughout the build, notably +# rustdoc tests, and some dist bits and pieces. +# +# Defaults to the Python interpreter used to execute x.py. +#build.python = + +# The path to the REUSE executable to use. Note that REUSE is not required in +# most cases, as our tooling relies on a cached (and shrunk) copy of the +# REUSE output present in the git repository and in our source tarballs. +# +# REUSE is only needed if your changes caused the overall licensing of the +# repository to change, and the cached copy has to be regenerated. +# +# Defaults to the "reuse" command in the system path. +#build.reuse = + +# Force Cargo to check that Cargo.lock describes the precise dependency +# set that all the Cargo.toml files create, instead of updating it. +build.locked-deps = false + +# Indicate whether the vendored sources are used for Rust dependencies or not. +# +# Vendoring requires additional setup. We recommend using the pre-generated source tarballs if you +# want to use vendoring. See https://forge.rust-lang.org/infra/other-installation-methods.html#source-code. +#build.vendor = + +# If you build the compiler more than twice (stage3+) or the standard library more than once +# (stage 2+), the third compiler and second library will get uplifted from stage2 and stage1, +# respectively. If you would like to disable this uplifting, and rather perform a full bootstrap, +# then you can set this option to true. +# +# This is only useful for verifying that rustc generates reproducible builds. +build.full-bootstrap = false + +# Set the bootstrap/download cache path. It is useful when building rust +# repeatedly in a CI environment. +#build.bootstrap-cache-path = /path/to/shared/cache + +# Enable a build of the extended Rust tool set which is not only the compiler +# but also tools such as Cargo. This will also produce "combined installers" +# which are used to install Rust and Cargo together. +# The `tools` (check `bootstrap.example.toml` to see its default value) option specifies +# which tools should be built if `extended = true`. +# +# This is disabled by default. +build.extended = false + +# Set of tools to be included in the installation. +# +# If `extended = false`, the only one of these built by default is rustdoc. +# +# If `extended = true`, they are all included. +# +# If any enabled tool fails to build, the installation fails. +#build.tools = + +# Specify build configuration specific for some tool, such as enabled features. +# This option has no effect on which tools are enabled: refer to the `tools` option for that. +# +# For example, to build Miri with tracing support, use `tool.miri.features = ["tracing"]` +# +# The default value for the `features` array is `[]`. However, please note that other flags in +# `bootstrap.toml` might influence the features enabled for some tools. Also, enabling features +# in tools which are not part of the internal "extra-features" preset might not always work. +#build.tool.TOOL_NAME.features = [FEATURE1, FEATURE2] + +# Verbosity level: 0 == not verbose, 1 == verbose, 2 == very verbose, 3 == print environment variables on each rustc invocation +#build.verbose = + +# Build the sanitizer runtimes +build.sanitizers = false + +# Build the profiler runtime (required when compiling with options that depend +# on this runtime, such as `-C profile-generate` or `-C instrument-coverage`). +build.profiler = false + +# Use the optimized LLVM C intrinsics for `compiler_builtins`, rather than Rust intrinsics. +# Choosing true requires the LLVM submodule to be managed by bootstrap (i.e. not external) +# so that `compiler-rt` sources are available. +# +# Setting this to a path removes the requirement for a C toolchain, but requires setting the +# path to an existing library containing the builtins library from LLVM's compiler-rt. +# +# Setting this to `false` generates slower code, but removes the requirement for a C toolchain in +# order to run `x check`. +build.optimized-compiler-builtins = true + +# Indicates whether the native libraries linked into Cargo will be statically +# linked or not. +build.cargo-native-static = false + +# Number of parallel jobs to be used for building and testing. If set to `0` or +# omitted, it will be automatically determined. This is the `-j`/`--jobs` flag +# passed to cargo invocations. +#build.jobs = + +# Default value for the `--extra-checks` flag of tidy. +# +# See `./x test tidy --help` for details. +# +# Note that if any value is manually given to bootstrap such as +# `./x test tidy --extra-checks=js`, this value is ignored. +# Use `--extra-checks=''` to temporarily disable all extra checks. +# +# Automatically enabled in the "tools" profile. +# Set to the empty string to force disable (recommended for hdd systems). +#build.tidy-extra-checks = "" + +# Indicates whether ccache is used when building certain artifacts (e.g. LLVM). +# Set to `true` to use the first `ccache` in PATH, or set an absolute path to use +# a specific version. +build.ccache = false + +# List of paths to exclude from the build and test processes. +# For example, exclude = ["tests/ui", "src/tools/tidy"]. +#build.exclude = [] + +# ============================================================================= +# General install configuration options +# ============================================================================= + +# Where to install the generated toolchain. Must be an absolute path. +install.prefix = "%INSTALLPREFIX%" + +# Where to install system configuration files. +# If this is a relative path, it will get installed in `prefix` above +install.sysconfdir = "/var/config" + +# Where to install documentation in `prefix` above +install.docdir = "share/doc/rust" + +# Where to install binaries in `prefix` above +install.bindir = "bin" + +# Where to install libraries in `prefix` above +install.libdir = "lib" + +# Where to install man pages in `prefix` above +install.mandir = "share/man" + +# Where to install data in `prefix` above +install.datadir = "share" + +# ============================================================================= +# Options for compiling Rust code itself +# ============================================================================= + +# Whether or not to optimize when compiling the compiler and standard library, +# and what level of optimization to use. +# WARNING: Building with optimize = false is NOT SUPPORTED. Due to bootstrapping, +# building without optimizations takes much longer than optimizing. Further, some platforms +# fail to build without this optimization (c.f. #65352). +# The valid options are: +# true - Enable optimizations (same as 3). +# false - Disable optimizations. +# 0 - Disable optimizations. +# 1 - Basic optimizations. +# 2 - Some optimizations. +# 3 - All optimizations. +# "s" - Optimize for binary size. +# "z" - Optimize for binary size, but also turn off loop vectorization. +#rust.optimize = true + +# Indicates that the build should be configured for debugging Rust. A +# `debug`-enabled compiler and standard library will be somewhat +# slower (due to e.g. checking of debug assertions) but should remain +# usable. +# +# Note: If this value is set to `true`, it will affect a number of +# configuration options below as well, if they have been left +# unconfigured in this file. +# +# Note: changes to the `debug` setting do *not* affect `optimize` +# above. In theory, a "maximally debuggable" environment would +# set `optimize` to `false` above to assist the introspection +# facilities of debuggers like lldb and gdb. To recreate such an +# environment, explicitly set `optimize` to `false` and `debug` +# to `true`. In practice, everyone leaves `optimize` set to +# `true`, because an unoptimized rustc with debugging +# enabled becomes *unusably slow* (e.g. rust-lang/rust#24840 +# reported a 25x slowdown) and bootstrapping the supposed +# "maximally debuggable" environment (notably libstd) takes +# hours to build. +# +rust.debug = false + +# Whether to download the stage 1 and 2 compilers from CI. This is useful if you +# are working on tools, doc-comments, or library (you will be able to build the +# standard library without needing to build the compiler). +# +# Set this to "if-unchanged" if you are working on `src/tools`, `tests` or +# `library` (on CI, `library` changes triggers in-tree compiler build) to speed +# up the build process if you don't need to build a compiler from the latest +# commit from `master`. +# +# Set this to `true` to always download or `false` to always use the in-tree +# compiler. +rust.download-rustc = false + +# Number of codegen units to use for each compiler invocation. A value of 0 +# means "the number of cores on this machine", and 1+ is passed through to the +# compiler. +# +# Uses the rustc defaults: https://doc.rust-lang.org/rustc/codegen-options/index.html#codegen-units +rust.codegen-units = 1 + +# Sets the number of codegen units to build the standard library with, +# regardless of what the codegen-unit setting for the rest of the compiler is. +# NOTE: building with anything other than 1 is known to occasionally have bugs. +rust.codegen-units-std = 1 + +# Whether or not debug assertions are enabled for the compiler and standard library. +# These can help find bugs at the cost of a small runtime slowdown. +# +# Defaults to rust.debug value +rust.debug-assertions = false + +# Whether or not debug assertions are enabled for the standard library. +# Overrides the `debug-assertions` option, if defined. +# +# Defaults to rust.debug-assertions value +rust.debug-assertions-std = false + +# Whether or not debug assertions are enabled for the tools built by bootstrap. +# Overrides the `debug-assertions` option, if defined. +# +# Defaults to rust.debug-assertions value +rust.debug-assertions-tools = false + +# Whether or not to leave debug! and trace! calls in the rust binary. +# +# Defaults to rust.debug-assertions value +# +# If you see a message from `tracing` saying "some trace filter directives would enable traces that +# are disabled statically" because `max_level_info` is enabled, set this value to `true`. +rust.debug-logging = false + +# Whether or not to build rustc, tools and the libraries with randomized type layout +rust.randomize-layout = false + +# Whether or not overflow checks are enabled for the compiler and standard +# library. +# +# Defaults to rust.debug value +rust.overflow-checks = false + +# Whether or not overflow checks are enabled for the standard library. +# Overrides the `overflow-checks` option, if defined. +# +# Defaults to rust.overflow-checks value +rust.overflow-checks-std = false + +# Debuginfo level for most of Rust code, corresponds to the `-C debuginfo=N` option of `rustc`. +# See https://doc.rust-lang.org/rustc/codegen-options/index.html#debuginfo for available options. +# +# Can be overridden for specific subsets of Rust code (rustc, std or tools). +# Debuginfo for tests run with compiletest is not controlled by this option +# and needs to be enabled separately with `debuginfo-level-tests`. +# +# Note that debuginfo-level = 2 generates several gigabytes of debuginfo +# and will slow down the linking process significantly. +rust.debuginfo-level = 0 + +# Debuginfo level for the compiler. +rust.debuginfo-level-rustc = 0 + +# Debuginfo level for the standard library. +rust.debuginfo-level-std = 0 + +# Debuginfo level for the tools. +rust.debuginfo-level-tools = 0 + +# Debuginfo level for the test suites run with compiletest. +# FIXME(#61117): Some tests fail when this option is enabled. +#rust.debuginfo-level-tests = 0 + +# Whether or not `panic!`s generate backtraces (RUST_BACKTRACE) +rust.backtrace = true + +# Whether to always use incremental compilation when building rustc +rust.incremental = false + +# The default linker that will be hard-coded into the generated +# compiler for targets that don't specify a default linker explicitly +# in their target specifications. Note that this is not the linker +# used to link said compiler. It can also be set per-target (via the +# `[target.]` block), which may be useful in a cross-compilation +# setting. +# +# See https://doc.rust-lang.org/rustc/codegen-options/index.html#linker for more information. +#rust.default-linker = + +# The "channel" for the Rust build to produce. The stable/beta channels only +# allow using stable features, whereas the nightly and dev channels allow using +# nightly features. +# +# You can set the channel to "auto-detect" to load the channel name from `src/ci/channel`. +# +# If using tarball sources, default value is "auto-detect", otherwise, it's "dev". +rust.channel = "auto-detect" + +# The root location of the musl installation directory. The library directory +# will also need to contain libunwind.a for an unwinding implementation. Note +# that this option only makes sense for musl targets that produce statically +# linked binaries. +# +# Defaults to /usr on musl hosts. Has no default otherwise. +#rust.musl-root = + +# By default the `rustc` executable is built with `-Wl,-rpath` flags on Unix +# platforms to ensure that the compiler is usable by default from the build +# directory (as it links to a number of dynamic libraries). This may not be +# desired in distributions, for example. +rust.rpath = true + +# Additional flags to pass to `rustc`. +# Takes precedence over bootstrap's own flags but not over per target rustflags nor env. vars. like RUSTFLAGS. +# Applies to all stages and targets. +# +#rust.rustflags = [] + +# Indicates whether symbols should be stripped using `-Cstrip=symbols`. +rust.strip = true + +# Forces frame pointers to be used with `-Cforce-frame-pointers`. +# This can be helpful for profiling at a small performance cost. +rust.frame-pointers = false + +# Indicates whether stack protectors should be used +# via the unstable option `-Zstack-protector`. +# +# Valid options are : `none`(default),`basic`,`strong`, or `all`. +# `strong` and `basic` options may be buggy and are not recommended, see rust-lang/rust#114903. +rust.stack-protector = "none" + +# Prints each test name as it is executed, to help debug issues in the test harness itself. +rust.verbose-tests = false + +# Flag indicating whether tests are compiled with optimizations (the -O flag). +rust.optimize-tests = true + +# Flag indicating whether codegen tests will be run or not. If you get an error +# saying that the FileCheck executable is missing, you may want to disable this. +# Also see the target's llvm-filecheck option. +rust.codegen-tests = false + +# Flag indicating whether git info will be retrieved from .git automatically. +# Having the git information can cause a lot of rebuilds during development. +rust.omit-git-hash = false + +# Whether to create a source tarball by default when running `x dist`. +# +# You can still build a source tarball when this is disabled by explicitly passing `x dist rustc-src`. +rust.dist-src = false + +# After building or testing an optional component (e.g. the nomicon or reference), append the +# result (broken, compiling, testing) into this JSON file. +#rust.save-toolstates = (path) + +# This array serves three distinct purposes: +# - Backends in this list will be automatically compiled and included in the sysroot of each +# rustc compiled by bootstrap. +# - The first backend in this list will be configured as the **default codegen backend** by each +# rustc compiled by bootstrap. In other words, if the first backend is e.g. cranelift, then when +# we build a stage 1 rustc, it will by default compile Rust programs using the Cranelift backend. +# This also means that stage 2 rustc would get built by the Cranelift backend. +# - Running `x dist` (without additional arguments, or with `--include-default-paths`) will produce +# a dist component/tarball for the Cranelift backend if it is included in this array. +# +# Note that the LLVM codegen backend is special and will always be built and distributed. +# +# Currently, the only standard options supported here are `"llvm"`, `"cranelift"` and `"gcc"`. +rust.codegen-backends = ["llvm"] + +# Indicates whether LLD will be compiled and made available in the sysroot for rustc to execute, +rust.lld = false + +# Indicates if we should override the linker used to link Rust crates during bootstrap to be LLD. +# If set to `true` or `"external"`, a global `lld` binary that has to be in $PATH +# will be used. +# If set to `"self-contained"`, rust-lld from the snapshot compiler will be used. +# +# On MSVC, LLD will not be used if we're cross linking. +# +# Explicitly setting the linker for a target will override this option when targeting MSVC. +rust.bootstrap-override-lld = false + +# Indicates whether some LLVM tools, like llvm-objdump, will be made available in the +# sysroot. +rust.llvm-tools = false + +# Indicates whether the `self-contained` llvm-bitcode-linker, will be made available +# in the sysroot. It is required for running nvptx tests. +rust.llvm-bitcode-linker = false + +# Whether to deny warnings in crates. Set to `false` to avoid +# error: warnings are denied by `build.warnings` configuration +rust.deny-warnings = false + +# Print backtrace on internal compiler errors during bootstrap +rust.backtrace-on-ice = false + +# Whether to verify generated LLVM IR +rust.verify-llvm-ir = false + +# Compile the compiler with a non-default ThinLTO import limit. This import +# limit controls the maximum size of functions imported by ThinLTO. Decreasing +# will make code compile faster at the expense of lower runtime performance. +#rust.thin-lto-import-instr-limit = + +# Map debuginfo paths to `/rust/$sha/...`. +# Useful for reproducible builds. Generally only set for releases +rust.remap-debuginfo = true + +# Link the compiler and LLVM against `jemalloc` instead of the default libc allocator. +# This option is only tested on Linux and OSX. It can also be configured per-target in the +# [target.] section. +rust.jemalloc = false + +# Run tests in various test suites with the "nll compare mode" in addition to +# running the tests in normal mode. Largely only used on CI and during local +# development of NLL +rust.test-compare-mode = false + +# Global default for llvm-libunwind for all targets. See the target-specific +# documentation for llvm-libunwind below. Note that the target-specific +# option will override this if set. +rust.llvm-libunwind = 'system' + +# Enable symbol-mangling-version v0. This can be helpful when profiling rustc, +# as generics will be preserved in symbols (rather than erased into opaque T). +# When no setting is given, the new scheme will be used when compiling the +# compiler and its tools and the legacy scheme will be used when compiling the +# standard library. +# If an explicit setting is given, it will be used for all parts of the codebase. +rust.new-symbol-mangling = true + +# Size limit in bytes for move/copy annotations (-Zannotate-moves). Only types +# at or above this size will be annotated. If not specified, uses the default +# limit (65 bytes). +#rust.annotate-moves-size-limit = + +# Select LTO mode that will be used for compiling rustc. By default, thin local LTO +# (LTO within a single crate) is used (like for any Rust crate). You can also select +# "thin" or "fat" to apply Thin/Fat LTO to the `rustc_driver` dylib, or "off" to disable +# LTO entirely. +rust.lto = "thin-local" + +# Build compiler with the optimization enabled and -Zvalidate-mir, currently only for `std` +#rust.validate-mir-opts = 3 + +# Configure `std` features used during bootstrap. +# +# Default features will be expanded in the following cases: +# - If `rust.llvm-libunwind` or `target.llvm-libunwind` is enabled: +# - "llvm-libunwind" will be added for in-tree LLVM builds. +# - "system-llvm-libunwind" will be added for system LLVM builds. +# - If `rust.backtrace` is enabled, "backtrace" will be added. +# - If `rust.profiler` or `target.profiler` is enabled, "profiler" will be added. +# - If building for a zkvm target, "compiler-builtins-mem" will be added. +# +# Since libstd also builds libcore and liballoc as dependencies and all their features are mirrored +# as libstd features, this option can also be used to configure features such as optimize_for_size. +#rust.std-features = + +# Set the number of threads for the compiler frontend used during compilation of Rust code (passed to `-Zthreads`). +# The valid options are: +# 0 - Set the number of threads according to the detected number of threads of the host system +# 1 - Use a single thread for compilation of Rust code (the default) +# N - Number of threads used for compilation of Rust code +# +rust.parallel-frontend-threads = 1 + +[target.x86_64-unknown-linux-musl] +llvm-libunwind = "system" +crt-static = false +musl-libdir = "/lib/x86_64-semios-linux" + +[target.aarch64-unknown-linux-musl] +llvm-libunwind = "system" +crt-static = false +musl-libdir = "/lib/aarch64-semios-linux" + +[target.riscv64-unknown-linux-musl] +llvm-libunwind = "system" +crt-static = false +musl-libdir = "/lib/riscv64-semios-linux" diff --git a/packages/rust/pkgbuild.py b/packages/rust/pkgbuild.py new file mode 100644 index 0000000..d51f897 --- /dev/null +++ b/packages/rust/pkgbuild.py @@ -0,0 +1,77 @@ +import os +import shutil +import subprocess + +from lib.make import * +from lib import arch + + +upstream_version = "1.97.1" + +version(upstream_version) +description("A language empowering everyone to build reliable and efficient software") +maintainer("sisungo ") +source_url(f"https://static.rust-lang.org/dist/rustc-{upstream_version}-src.tar.xz") + +builddep("shortcut/cmake") +builddep("shortcut/c++") +builddep("python") +builddep(f"libz-ng-dev @{arch.get_target()}") +builddep(f"linux-dev @{arch.get_target()}") +builddep(f"libunwind-dev @{arch.get_target()}") +builddep("curl") +builddep("grep") +builddep("sed") + + +def setup_musl_root(): + os.makedirs("../musl_root/lib", exist_ok=True) + for i in ["libc.a", "crt1.o", "Scrt1.o", "rcrt1.o", "crti.o", "crtn.o", "libunwind.a"]: + shutil.copy2(f"/lib/{arch.get_target()}/{i}", f"../musl_root/lib/{i}") + +def configure(): + with open("../../bootstrap.toml.in") as file: + content = file.read() + content = content.replace("%RUSTVERSION%", upstream_version) + content = content.replace("%CARGOPATH%", shutil.which("cargo") or "cargo") + content = content.replace("%RUSTCPATH%", shutil.which("rustc") or "rustc") + content = content.replace("%INSTALLPREFIX%", get_prefix("rust")) + content = content.replace("%MUSLROOT%", os.getcwd() + "/../musl_root") + with open("bootstrap.toml", "wt+") as file: + file.write(content) + +def run_build(): + subprocess.run(["python3", "x.py", "build"], check=True) + +def run_install(): + os.environ["DESTDIR"] = os.getcwd() + "/../install_destdir" + subprocess.run(["python3", "x.py", "install"], check=True) + os.chdir(os.environ["DESTDIR"]) + # FIXME: Rust seemed not to process our directory name correctly, it is installed to pkg/rust. + os.chdir("pkg/rust") + + +def build(): + setup_musl_root() + configure() + run_build() + run_install() + +on_build(build) + + +def pack_rust(composer): + composer.makedir("lib") + composer.makedir("bin") + for i in os.listdir("."): + if ".so" in i: + composer.addfile(i, f"lib/{i}") + elif i in ["rustc", "rust-gdb", "rust-gdbgui", "rust-lldb", "rustdoc"]: + composer.addfile(i, f"bin/{i}") + composer.add_dir("rustlib", "lib/rustlib") + +package("rust") +dep("semi-libc @same-arch") +dep("libz @same-arch") +dep("libcxx @same-arch") +on_pack(pack_rust)