Update the arm-* and aarch64-* platform docs. #146419
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
Some changes occurred in src/doc/rustc/src/platform-support cc @Noratrieb |
rustbot
added
the
S-waiting-on-review
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
This comment has been minimized.
The Rust Embedded Devices Working Group (wg-embedded) Arm Team (t-arm) agreed to listed as maintainers of: * aarch64-unknown-none * aarch64-unknown-none-softfloat * armv7a-none-eabi * armv7r-none-eabi * armv7r-none-eabihf The aarch64-unknown-none* target didn't have a page so I added it. wg-embedded t-arm did not want to take over: * armebv7r-none-eabi * armebv7r-none-eabihf So I gave them their own target page. The current maintainer remains.
thejpster
force-pushed
the
update-arm-target-docs
branch
from
8a54175 to
faf0e14
Compare
|
Force-pushed with fixed markdown formatting. |
fbstj
reviewed
Sep 10, 2025
This comment has been minimized.
This comment has been minimized.
thejpster
force-pushed
the
update-arm-target-docs
branch
from
827e2cd to
f1abb70
Compare
This comment has been minimized.
This comment has been minimized.
workingjubilee
requested changes
Sep 10, 2025
|
r? @workingjubilee maybe? |
|
|
workingjubilee
requested changes
Sep 11, 2025
|
|
||
| ## Target maintainers | ||
|
|
||
| * [@chrisnc](https://github.com/chrisnc) |
There was a problem hiding this comment.
Uhm. Hrm.
@chrisnc Do you assent?
@thejpster I am not sure I have seen an assent by Chris to maintain this specific target variant.
There was a problem hiding this comment.
The armebv7r and armv7r targets were on the same page, and so I concluded Chris was the maintainer for both. Pretty sure he wrote the page back in 90893e4.
https://doc.rust-lang.org/beta/rustc/platform-support/armv7r-none-eabi.html
There was a problem hiding this comment.
The format for these was updated a while ago to drop the bullet points for ease of copy-pasting the usernames in GitHub issues and PRs. Please drop those, no matter who's being listed here (and in all the other files) :)
There was a problem hiding this comment.
Oh, you're right, I got confused.
I think it would still be helpful to have assent here on this new split and shared responsibility and such.
There was a problem hiding this comment.
I have been provided with more information on the context it was assented to, that @chrisnc both is fine with the EDWG helping out and does not want to impede them but neither is he interested in definitely becoming part of that team. I am deciding it is trustworthy enough for this to go ahead, as we can always roll back changes if more information comes to light, I just wanted enough information to be able to presume the situation was correct.
There was a problem hiding this comment.
I confirm what @thejpster has said (we corresponded on this topic over email a while back). I personally possess and develop on little- and big-endian v7r platforms with Rust and am available to support the community with these targets as-needed. Thanks for checking!
rustbot
added
S-waiting-on-author
Gelbpunkt
suggested changes
Sep 12, 2025
Comment on lines
+106
to
+115
| ## Start-up and Low-Level Code | ||
|
|
||
| The [Rust Embedded Devices Working Group Arm Team] maintain the | ||
| [`aarch64-cpu`] crate, which may be useful for writing bare-metal code using | ||
| this target. | ||
|
|
||
| The *TrustedFirmware* group also maintain [Rust crates for this | ||
| target](https://github.com/ArmFirmwareCrates). | ||
|
|
||
| [`aarch64-cpu`]: https://docs.rs/aarch64-cpu |
There was a problem hiding this comment.
I'm not really sure how the maintainers feel about endorsing third-party crates like this. I think this section could just be dropped and, if you really want to have some start-up code, replaced with a tiny linker script + assembly + Rust entrypoint example when e.g. booting with the Linux boot protocol.
There was a problem hiding this comment.
For many targets the code required is more than can fit into a target doc, and often involves multiple files that would be tedious and error prone to copy-paste into a new project. ArmFirmwareCrates is from Arm themselves, so it seemed legit to refer to it. But I can take it out.
I personally find it pretty hard to get started with many of these targets so I think giving people links to code that works and runs is very useful. I’m happy to not have it here, but I don’t know where else it would go.
There was a problem hiding this comment.
For a target, if the maintainers think it worthwhile to recommend a crate that deals with the special needs of that target, then we generally do not impede such. Often, external software is required anyways for a target, e.g. specialty linkers or compilers or headers or... whatever. If quite a lot of such supplemental material is needed, it may come as an advisory against maintaining the target at all, but this doesn't seem to rise to such a threshold.
|
|
||
| ## Target maintainers | ||
|
|
||
| * [@chrisnc](https://github.com/chrisnc) |
There was a problem hiding this comment.
The format for these was updated a while ago to drop the bullet points for ease of copy-pasting the usernames in GitHub issues and PRs. Please drop those, no matter who's being listed here (and in all the other files) :)
It seems the existing target docs were not updated when this rule came in. I'm removed the bullets for all the targets maintained by the Rust Embedded Devices Working Group's Arm Team as requested. |
This is important to note, as it affects how easy it is to build a binary, and that `#![no_std]` is mandatory. A different PR should probably add this to all the other platform pages.
|
Notes added to all the arm-none-, thumb-none-* and aarch64-unknown-none-* pages noting that they are |
|
looks good to me! @bors r+ rollup |
bors
added
S-waiting-on-bors
This was referenced Sep 13, 2025
bors
added a commit
that referenced
this pull request
Sep 13, 2025
Rollup of 8 pull requests Successful merges: - #113095 (Document `become` keyword) - #146159 (Some hygiene doc improvements) - #146171 (tidy: check that error messages don't start with a capitalized letter) - #146419 (Update the arm-* and aarch64-* platform docs.) - #146473 (Revert "Constify SystemTime methods") - #146506 (Fix small typo in check-cfg.md) - #146517 (fix Condvar::wait_timeout docs) - #146521 (document `core::ffi::VaArgSafe`) r? `@ghost` `@rustbot` modify labels: rollup
rust-timer
added a commit
that referenced
this pull request
Sep 14, 2025
Rollup merge of #146419 - thejpster:update-arm-target-docs, r=workingjubilee Update the arm-* and aarch64-* platform docs. This PR updates some of the arm*-unknown-none target docs, and adds some missing target pages. ## aarch64-none-elf and aarch64-none-elf-softfloat The Rust Embedded Devices Working Group's Arm Team is added as a maintainer, and a target page is added. Links are added to the EDWG's support crates for this target. ## armv7a-none-eabi and armv7a-none-eabihf The Rust Embedded Devices Working Group's Arm Team is added as a maintainer, and a target page is added. Links are added to the EDWG's support crates for this target. ## armv7r-none-eabi and armv7r-none-eabihf The Rust Embedded Devices Working Group's Arm Team is added as a maintainer, and the target page is split from the Big Endian versions. Links are added to the EDWG's support crates for this target. ## armebv7r-none-eabi and armveb7r-none-eabihf The target page is split from the Little Endian versions. No change in maintainers. I have agreement to add EDWG/T-Arm as maintainers, which was voted upon in [their repo](rust-embedded/wg#851).
matthiaskrgr
added a commit
to matthiaskrgr/rust
that referenced
this pull request
Sep 26, 2025
… r=jackh726 Demote both armebv7r-none-* targets. OK, slightly more controversial than rust-lang#146520 and rust-lang#146522 - I'd like to drop the bare-metal **big-endian** Armv7-R targets down to Tier 3. The reason is simple - we cannot test them in https://github.com/rust-embedded/cortex-ar/. This because QEMU support for Big Endian Armv7-R is broken. I tried quite hard, but all the strings I printed with semihosting came out byte swapped (or "etybawa depp") because of how QEMU kludges the access to memory in big-endian mode. The target also has only a single maintainer. Although, if `@chrisnc` wants to put up a case for keeping it at Tier 2 though, I'm happy to hear it! This PR wil be rebased once rust-lang#146419 completes the queue.
matthiaskrgr
added a commit
to matthiaskrgr/rust
that referenced
this pull request
Sep 26, 2025
… r=jackh726 Demote both armebv7r-none-* targets. OK, slightly more controversial than rust-lang#146520 and rust-lang#146522 - I'd like to drop the bare-metal **big-endian** Armv7-R targets down to Tier 3. The reason is simple - we cannot test them in https://github.com/rust-embedded/cortex-ar/. This because QEMU support for Big Endian Armv7-R is broken. I tried quite hard, but all the strings I printed with semihosting came out byte swapped (or "etybawa depp") because of how QEMU kludges the access to memory in big-endian mode. The target also has only a single maintainer. Although, if ``@chrisnc`` wants to put up a case for keeping it at Tier 2 though, I'm happy to hear it! This PR wil be rebased once rust-lang#146419 completes the queue.
matthiaskrgr
added a commit
to matthiaskrgr/rust
that referenced
this pull request
Sep 26, 2025
… r=jackh726 Demote both armebv7r-none-* targets. OK, slightly more controversial than rust-lang#146520 and rust-lang#146522 - I'd like to drop the bare-metal **big-endian** Armv7-R targets down to Tier 3. The reason is simple - we cannot test them in https://github.com/rust-embedded/cortex-ar/. This because QEMU support for Big Endian Armv7-R is broken. I tried quite hard, but all the strings I printed with semihosting came out byte swapped (or "etybawa depp") because of how QEMU kludges the access to memory in big-endian mode. The target also has only a single maintainer. Although, if ```@chrisnc``` wants to put up a case for keeping it at Tier 2 though, I'm happy to hear it! This PR wil be rebased once rust-lang#146419 completes the queue.
matthiaskrgr
added a commit
to matthiaskrgr/rust
that referenced
this pull request
Sep 26, 2025
… r=jackh726 Demote both armebv7r-none-* targets. OK, slightly more controversial than rust-lang#146520 and rust-lang#146522 - I'd like to drop the bare-metal **big-endian** Armv7-R targets down to Tier 3. The reason is simple - we cannot test them in https://github.com/rust-embedded/cortex-ar/. This because QEMU support for Big Endian Armv7-R is broken. I tried quite hard, but all the strings I printed with semihosting came out byte swapped (or "etybawa depp") because of how QEMU kludges the access to memory in big-endian mode. The target also has only a single maintainer. Although, if ````@chrisnc```` wants to put up a case for keeping it at Tier 2 though, I'm happy to hear it! This PR wil be rebased once rust-lang#146419 completes the queue.
rust-timer
added a commit
that referenced
this pull request
Sep 27, 2025
Rollup merge of #146523 - thejpster:demote-armebv7r-targets, r=jackh726 Demote both armebv7r-none-* targets. OK, slightly more controversial than #146520 and #146522 - I'd like to drop the bare-metal **big-endian** Armv7-R targets down to Tier 3. The reason is simple - we cannot test them in https://github.com/rust-embedded/cortex-ar/. This because QEMU support for Big Endian Armv7-R is broken. I tried quite hard, but all the strings I printed with semihosting came out byte swapped (or "etybawa depp") because of how QEMU kludges the access to memory in big-endian mode. The target also has only a single maintainer. Although, if ````@chrisnc```` wants to put up a case for keeping it at Tier 2 though, I'm happy to hear it! This PR wil be rebased once #146419 completes the queue.
github-actions bot
pushed a commit
to rust-lang/rust-analyzer
that referenced
this pull request
Sep 29, 2025
Demote both armebv7r-none-* targets. OK, slightly more controversial than rust-lang/rust#146520 and rust-lang/rust#146522 - I'd like to drop the bare-metal **big-endian** Armv7-R targets down to Tier 3. The reason is simple - we cannot test them in https://github.com/rust-embedded/cortex-ar/. This because QEMU support for Big Endian Armv7-R is broken. I tried quite hard, but all the strings I printed with semihosting came out byte swapped (or "etybawa depp") because of how QEMU kludges the access to memory in big-endian mode. The target also has only a single maintainer. Although, if ````@chrisnc```` wants to put up a case for keeping it at Tier 2 though, I'm happy to hear it! This PR wil be rebased once rust-lang/rust#146419 completes the queue.
dianqk
added a commit
to dianqk/rust
that referenced
this pull request
Oct 10, 2025
…, r=petrochenkov Promote armv8r-none-eabihf target to Tier 2 This PR promotes armv8r-none-eabihf to Tier 2, joining armv7r-none-eabi, armv7r-none-eabihf and armv7a-none-eabi. This PR wil be rebased once rust-lang#146419 completes the queue. > - A tier 2 target must have value to people other than its maintainers. (It may > still be a niche target, but it must not be exclusively useful for an > inherently closed group.) The `armv8r-none-eabihf` target is for the Arm Cortex-R52 processor, as found in a number of Automotive SoCs that have just been released, or are about to be released. Currently SoCs are available from NXP and Renesas. >- A tier 2 target must have a designated team of developers (the "target > maintainers") available to consult on target-specific build-breaking issues, > or if necessary to develop target-specific language or library implementation > details. This team must have at least 2 developers. The Embedded Devices Working Group's Arm Team have just started maintaining this target. > - The target must not place undue burden on Rust developers not specifically > concerned with that target. Rust developers are expected to not gratuitously > break a tier 2 target, but are not expected to become experts in every tier 2 > target, and are not expected to provide target-specific implementations for > every tier 2 target. This target is highly similar to a number of existing Tier 2 targets, including `armv7r-none-eabihf` and so it should not add undue burden. > - The target must provide documentation for the Rust community explaining how > to build for the target using cross-compilation, and explaining how to run > tests for the target. If at all possible, this documentation should show how > to run Rust programs and tests for the target using emulation, to allow > anyone to do so. If the target cannot be feasibly emulated, the documentation > should explain how to obtain and work with physical hardware, cloud systems, > or equivalent. https://doc.rust-lang.org/nightly/rustc/platform-support/armv8r-none-eabihf.html exists and was updated in rust-lang#146419 > - The target must document its baseline expectations for the features or > versions of CPUs, operating systems, libraries, runtime environments, and > similar. I believe it does. > - If introducing a new tier 2 or higher target that is identical to an existing > Rust target except for the baseline expectations for the features or versions > of CPUs, operating systems, libraries, runtime environments, and similar, > then the proposed target must document to the satisfaction of the approving > teams why the specific difference in baseline expectations provides > sufficient value to justify a separate target. The Armv8-R architecture introduces a new FPU type, the fp-armv8, and so this requires a unique target. > - Tier 2 targets must not leave any significant portions of `core` or the > standard library unimplemented or stubbed out, unless they cannot possibly be > supported on the target. It has a full libcore, as per the other arm*-none-* targets. > - The code generation backend for the target should not have deficiencies that > invalidate Rust safety properties, as evaluated by the Rust compiler team. It should be the same backend as `armv7r-none-eabihf` and friends, except for FPU support, which is already covered in `thumbv8m.main-none-eabihf`. There are no issues that I know of. > - If the target supports C code, and the target has an interoperable calling > convention for C code, the Rust target must support that C calling convention > for the platform via `extern "C"`. The C calling convention does not need to > be the default Rust calling convention for the target, however. The ABI is EABI, the same as many other Arm targets. > - The target must build reliably in CI, for all components that Rust's CI > considers mandatory. The https://github.com/rust-embedded/cortex-ar repository regularly builds this target with `-Zbuild-std=core` and it seems fine. > - The approving teams may additionally require that a subset of tests pass in > CI, such as enough to build a functional "hello world" program, `./x.py test > --no-run`, or equivalent "smoke tests". In particular, this requirement may > apply if the target builds host tools, or if the tests in question provide > substantial value via early detection of critical problems. There are no no-std tests in the tree that I'm aware of. > - Building the target in CI must not take substantially longer than the current > slowest target in CI, and should not substantially raise the maintenance > burden of the CI infrastructure. This requirement is subjective, to be > evaluated by the infrastructure team, and will take the community importance > of the target into account. Building libcore is quite fast. > - Tier 2 targets should, if at all possible, support cross-compiling. Tier 2 > targets should not require using the target as the host for builds, even if > the target supports host tools. It does. > - In addition to the legal requirements for all targets (specified in the tier > 3 requirements), because a tier 2 target typically involves the Rust project > building and supplying various compiled binaries, incorporating the target > and redistributing any resulting compiled binaries (e.g. built libraries, > host tools if any) must not impose any onerous license requirements on any > members of the Rust project, including infrastructure team members and those > operating CI systems. This is a subjective requirement, to be evaluated by > the approving teams. Just libcore required (and liballoc). No known issues here. > - Tier 2 targets must not impose burden on the authors of pull requests, or > other developers in the community, to ensure that tests pass for the target. Noted > - The target maintainers should regularly run the testsuite for the target The https://github.com/rust-embedded/cortex-ar repository will be changed to use the rustup component when available. > and should fix any test failures in a reasonably timely fashion. Noted
dianqk
added a commit
to dianqk/rust
that referenced
this pull request
Oct 10, 2025
…hf, r=petrochenkov Promote armv7a-none-eabihf to Tier 2 This PR promotes armv7a-none-eabihf to Tier 2, to join armv7r-none-eabihf and armv7a-none-eabi. I believe it was simply an oversight that it wasn't made Tier 2 before, as most Armv7-A targets have an FPU and it often makes sense to use it. This PR wil be rebased once rust-lang#146419 completes the queue. > - A tier 2 target must have value to people other than its maintainers. (It may > still be a niche target, but it must not be exclusively useful for an > inherently closed group.) The `armv7a-none-eabihf` target is for all Arm Cortex-A processors (either 32-bit only, or in 32-bit mode) where the user wants to use the FPU. >- A tier 2 target must have a designated team of developers (the "target > maintainers") available to consult on target-specific build-breaking issues, > or if necessary to develop target-specific language or library implementation > details. This team must have at least 2 developers. The Embedded Devices Working Group's Arm Team have just started maintaining this target. > - The target must not place undue burden on Rust developers not specifically > concerned with that target. Rust developers are expected to not gratuitously > break a tier 2 target, but are not expected to become experts in every tier 2 > target, and are not expected to provide target-specific implementations for > every tier 2 target. This target is highly similar to a number of existing Tier 2 targets, including `armv7r-none-eabihf` and `armv7a-none-eabi` and so it should not add undue burden. > - The target must provide documentation for the Rust community explaining how > to build for the target using cross-compilation, and explaining how to run > tests for the target. If at all possible, this documentation should show how > to run Rust programs and tests for the target using emulation, to allow > anyone to do so. If the target cannot be feasibly emulated, the documentation > should explain how to obtain and work with physical hardware, cloud systems, > or equivalent. https://doc.rust-lang.org/nightly/rustc/platform-support/armv7a-none-eabi.html was added in rust-lang#146419. It covers the `-eabi` and the `-eabihf` targets. > - The target must document its baseline expectations for the features or > versions of CPUs, operating systems, libraries, runtime environments, and > similar. I believe it does. > - If introducing a new tier 2 or higher target that is identical to an existing > Rust target except for the baseline expectations for the features or versions > of CPUs, operating systems, libraries, runtime environments, and similar, > then the proposed target must document to the satisfaction of the approving > teams why the specific difference in baseline expectations provides > sufficient value to justify a separate target. It uses very similar FPUs to `armv7r-none-eabihf` but is otherwise the same as `armv7a-none-eabi`. > - Tier 2 targets must not leave any significant portions of `core` or the > standard library unimplemented or stubbed out, unless they cannot possibly be > supported on the target. It has a full libcore, as per the other arm*-none-* targets. > - The code generation backend for the target should not have deficiencies that > invalidate Rust safety properties, as evaluated by the Rust compiler team. It should be the same backend as `armv7r-none-eabihf` and friends, except for FPU support, which is already covered in `thumbv8m.main-none-eabihf`. There are no issues that I know of. > - If the target supports C code, and the target has an interoperable calling > convention for C code, the Rust target must support that C calling convention > for the platform via `extern "C"`. The C calling convention does not need to > be the default Rust calling convention for the target, however. The ABI is EABI, the same as many other Arm targets. > - The target must build reliably in CI, for all components that Rust's CI > considers mandatory. The https://github.com/rust-embedded/cortex-ar repository has been changed in rust-embedded/cortex-ar#57 to build this target with `-Zbuild-std=core`. Locally it seems fine. > - The approving teams may additionally require that a subset of tests pass in > CI, such as enough to build a functional "hello world" program, `./x.py test > --no-run`, or equivalent "smoke tests". In particular, this requirement may > apply if the target builds host tools, or if the tests in question provide > substantial value via early detection of critical problems. There are no no-std tests in the tree that I'm aware of. > - Building the target in CI must not take substantially longer than the current > slowest target in CI, and should not substantially raise the maintenance > burden of the CI infrastructure. This requirement is subjective, to be > evaluated by the infrastructure team, and will take the community importance > of the target into account. Building libcore is quite fast. > - Tier 2 targets should, if at all possible, support cross-compiling. Tier 2 > targets should not require using the target as the host for builds, even if > the target supports host tools. It does. > - In addition to the legal requirements for all targets (specified in the tier > 3 requirements), because a tier 2 target typically involves the Rust project > building and supplying various compiled binaries, incorporating the target > and redistributing any resulting compiled binaries (e.g. built libraries, > host tools if any) must not impose any onerous license requirements on any > members of the Rust project, including infrastructure team members and those > operating CI systems. This is a subjective requirement, to be evaluated by > the approving teams. Just libcore required (and liballoc). No known issues here. > - Tier 2 targets must not impose burden on the authors of pull requests, or > other developers in the community, to ensure that tests pass for the target. Noted > - The target maintainers should regularly run the testsuite for the target The https://github.com/rust-embedded/cortex-ar repository will be changed to use the rustup component when available. > and should fix any test failures in a reasonably timely fashion. Noted
rust-timer
added a commit
that referenced
this pull request
Oct 11, 2025
Rollup merge of #146522 - thejpster:promote-armv7a-none-eabihf, r=petrochenkov Promote armv7a-none-eabihf to Tier 2 This PR promotes armv7a-none-eabihf to Tier 2, to join armv7r-none-eabihf and armv7a-none-eabi. I believe it was simply an oversight that it wasn't made Tier 2 before, as most Armv7-A targets have an FPU and it often makes sense to use it. This PR wil be rebased once #146419 completes the queue. > - A tier 2 target must have value to people other than its maintainers. (It may > still be a niche target, but it must not be exclusively useful for an > inherently closed group.) The `armv7a-none-eabihf` target is for all Arm Cortex-A processors (either 32-bit only, or in 32-bit mode) where the user wants to use the FPU. >- A tier 2 target must have a designated team of developers (the "target > maintainers") available to consult on target-specific build-breaking issues, > or if necessary to develop target-specific language or library implementation > details. This team must have at least 2 developers. The Embedded Devices Working Group's Arm Team have just started maintaining this target. > - The target must not place undue burden on Rust developers not specifically > concerned with that target. Rust developers are expected to not gratuitously > break a tier 2 target, but are not expected to become experts in every tier 2 > target, and are not expected to provide target-specific implementations for > every tier 2 target. This target is highly similar to a number of existing Tier 2 targets, including `armv7r-none-eabihf` and `armv7a-none-eabi` and so it should not add undue burden. > - The target must provide documentation for the Rust community explaining how > to build for the target using cross-compilation, and explaining how to run > tests for the target. If at all possible, this documentation should show how > to run Rust programs and tests for the target using emulation, to allow > anyone to do so. If the target cannot be feasibly emulated, the documentation > should explain how to obtain and work with physical hardware, cloud systems, > or equivalent. https://doc.rust-lang.org/nightly/rustc/platform-support/armv7a-none-eabi.html was added in #146419. It covers the `-eabi` and the `-eabihf` targets. > - The target must document its baseline expectations for the features or > versions of CPUs, operating systems, libraries, runtime environments, and > similar. I believe it does. > - If introducing a new tier 2 or higher target that is identical to an existing > Rust target except for the baseline expectations for the features or versions > of CPUs, operating systems, libraries, runtime environments, and similar, > then the proposed target must document to the satisfaction of the approving > teams why the specific difference in baseline expectations provides > sufficient value to justify a separate target. It uses very similar FPUs to `armv7r-none-eabihf` but is otherwise the same as `armv7a-none-eabi`. > - Tier 2 targets must not leave any significant portions of `core` or the > standard library unimplemented or stubbed out, unless they cannot possibly be > supported on the target. It has a full libcore, as per the other arm*-none-* targets. > - The code generation backend for the target should not have deficiencies that > invalidate Rust safety properties, as evaluated by the Rust compiler team. It should be the same backend as `armv7r-none-eabihf` and friends, except for FPU support, which is already covered in `thumbv8m.main-none-eabihf`. There are no issues that I know of. > - If the target supports C code, and the target has an interoperable calling > convention for C code, the Rust target must support that C calling convention > for the platform via `extern "C"`. The C calling convention does not need to > be the default Rust calling convention for the target, however. The ABI is EABI, the same as many other Arm targets. > - The target must build reliably in CI, for all components that Rust's CI > considers mandatory. The https://github.com/rust-embedded/cortex-ar repository has been changed in rust-embedded/cortex-ar#57 to build this target with `-Zbuild-std=core`. Locally it seems fine. > - The approving teams may additionally require that a subset of tests pass in > CI, such as enough to build a functional "hello world" program, `./x.py test > --no-run`, or equivalent "smoke tests". In particular, this requirement may > apply if the target builds host tools, or if the tests in question provide > substantial value via early detection of critical problems. There are no no-std tests in the tree that I'm aware of. > - Building the target in CI must not take substantially longer than the current > slowest target in CI, and should not substantially raise the maintenance > burden of the CI infrastructure. This requirement is subjective, to be > evaluated by the infrastructure team, and will take the community importance > of the target into account. Building libcore is quite fast. > - Tier 2 targets should, if at all possible, support cross-compiling. Tier 2 > targets should not require using the target as the host for builds, even if > the target supports host tools. It does. > - In addition to the legal requirements for all targets (specified in the tier > 3 requirements), because a tier 2 target typically involves the Rust project > building and supplying various compiled binaries, incorporating the target > and redistributing any resulting compiled binaries (e.g. built libraries, > host tools if any) must not impose any onerous license requirements on any > members of the Rust project, including infrastructure team members and those > operating CI systems. This is a subjective requirement, to be evaluated by > the approving teams. Just libcore required (and liballoc). No known issues here. > - Tier 2 targets must not impose burden on the authors of pull requests, or > other developers in the community, to ensure that tests pass for the target. Noted > - The target maintainers should regularly run the testsuite for the target The https://github.com/rust-embedded/cortex-ar repository will be changed to use the rustup component when available. > and should fix any test failures in a reasonably timely fashion. Noted
rust-timer
added a commit
that referenced
this pull request
Oct 11, 2025
Rollup merge of #146520 - thejpster:promote-armv8r-none-eabi, r=petrochenkov Promote armv8r-none-eabihf target to Tier 2 This PR promotes armv8r-none-eabihf to Tier 2, joining armv7r-none-eabi, armv7r-none-eabihf and armv7a-none-eabi. This PR wil be rebased once #146419 completes the queue. > - A tier 2 target must have value to people other than its maintainers. (It may > still be a niche target, but it must not be exclusively useful for an > inherently closed group.) The `armv8r-none-eabihf` target is for the Arm Cortex-R52 processor, as found in a number of Automotive SoCs that have just been released, or are about to be released. Currently SoCs are available from NXP and Renesas. >- A tier 2 target must have a designated team of developers (the "target > maintainers") available to consult on target-specific build-breaking issues, > or if necessary to develop target-specific language or library implementation > details. This team must have at least 2 developers. The Embedded Devices Working Group's Arm Team have just started maintaining this target. > - The target must not place undue burden on Rust developers not specifically > concerned with that target. Rust developers are expected to not gratuitously > break a tier 2 target, but are not expected to become experts in every tier 2 > target, and are not expected to provide target-specific implementations for > every tier 2 target. This target is highly similar to a number of existing Tier 2 targets, including `armv7r-none-eabihf` and so it should not add undue burden. > - The target must provide documentation for the Rust community explaining how > to build for the target using cross-compilation, and explaining how to run > tests for the target. If at all possible, this documentation should show how > to run Rust programs and tests for the target using emulation, to allow > anyone to do so. If the target cannot be feasibly emulated, the documentation > should explain how to obtain and work with physical hardware, cloud systems, > or equivalent. https://doc.rust-lang.org/nightly/rustc/platform-support/armv8r-none-eabihf.html exists and was updated in #146419 > - The target must document its baseline expectations for the features or > versions of CPUs, operating systems, libraries, runtime environments, and > similar. I believe it does. > - If introducing a new tier 2 or higher target that is identical to an existing > Rust target except for the baseline expectations for the features or versions > of CPUs, operating systems, libraries, runtime environments, and similar, > then the proposed target must document to the satisfaction of the approving > teams why the specific difference in baseline expectations provides > sufficient value to justify a separate target. The Armv8-R architecture introduces a new FPU type, the fp-armv8, and so this requires a unique target. > - Tier 2 targets must not leave any significant portions of `core` or the > standard library unimplemented or stubbed out, unless they cannot possibly be > supported on the target. It has a full libcore, as per the other arm*-none-* targets. > - The code generation backend for the target should not have deficiencies that > invalidate Rust safety properties, as evaluated by the Rust compiler team. It should be the same backend as `armv7r-none-eabihf` and friends, except for FPU support, which is already covered in `thumbv8m.main-none-eabihf`. There are no issues that I know of. > - If the target supports C code, and the target has an interoperable calling > convention for C code, the Rust target must support that C calling convention > for the platform via `extern "C"`. The C calling convention does not need to > be the default Rust calling convention for the target, however. The ABI is EABI, the same as many other Arm targets. > - The target must build reliably in CI, for all components that Rust's CI > considers mandatory. The https://github.com/rust-embedded/cortex-ar repository regularly builds this target with `-Zbuild-std=core` and it seems fine. > - The approving teams may additionally require that a subset of tests pass in > CI, such as enough to build a functional "hello world" program, `./x.py test > --no-run`, or equivalent "smoke tests". In particular, this requirement may > apply if the target builds host tools, or if the tests in question provide > substantial value via early detection of critical problems. There are no no-std tests in the tree that I'm aware of. > - Building the target in CI must not take substantially longer than the current > slowest target in CI, and should not substantially raise the maintenance > burden of the CI infrastructure. This requirement is subjective, to be > evaluated by the infrastructure team, and will take the community importance > of the target into account. Building libcore is quite fast. > - Tier 2 targets should, if at all possible, support cross-compiling. Tier 2 > targets should not require using the target as the host for builds, even if > the target supports host tools. It does. > - In addition to the legal requirements for all targets (specified in the tier > 3 requirements), because a tier 2 target typically involves the Rust project > building and supplying various compiled binaries, incorporating the target > and redistributing any resulting compiled binaries (e.g. built libraries, > host tools if any) must not impose any onerous license requirements on any > members of the Rust project, including infrastructure team members and those > operating CI systems. This is a subjective requirement, to be evaluated by > the approving teams. Just libcore required (and liballoc). No known issues here. > - Tier 2 targets must not impose burden on the authors of pull requests, or > other developers in the community, to ensure that tests pass for the target. Noted > - The target maintainers should regularly run the testsuite for the target The https://github.com/rust-embedded/cortex-ar repository will be changed to use the rustup component when available. > and should fix any test failures in a reasonably timely fashion. Noted
rust-cloud-vms bot
pushed a commit
to makai410/rustc_public
that referenced
this pull request
Oct 12, 2025
…chenkov Promote armv8r-none-eabihf target to Tier 2 This PR promotes armv8r-none-eabihf to Tier 2, joining armv7r-none-eabi, armv7r-none-eabihf and armv7a-none-eabi. This PR wil be rebased once rust-lang/rust#146419 completes the queue. > - A tier 2 target must have value to people other than its maintainers. (It may > still be a niche target, but it must not be exclusively useful for an > inherently closed group.) The `armv8r-none-eabihf` target is for the Arm Cortex-R52 processor, as found in a number of Automotive SoCs that have just been released, or are about to be released. Currently SoCs are available from NXP and Renesas. >- A tier 2 target must have a designated team of developers (the "target > maintainers") available to consult on target-specific build-breaking issues, > or if necessary to develop target-specific language or library implementation > details. This team must have at least 2 developers. The Embedded Devices Working Group's Arm Team have just started maintaining this target. > - The target must not place undue burden on Rust developers not specifically > concerned with that target. Rust developers are expected to not gratuitously > break a tier 2 target, but are not expected to become experts in every tier 2 > target, and are not expected to provide target-specific implementations for > every tier 2 target. This target is highly similar to a number of existing Tier 2 targets, including `armv7r-none-eabihf` and so it should not add undue burden. > - The target must provide documentation for the Rust community explaining how > to build for the target using cross-compilation, and explaining how to run > tests for the target. If at all possible, this documentation should show how > to run Rust programs and tests for the target using emulation, to allow > anyone to do so. If the target cannot be feasibly emulated, the documentation > should explain how to obtain and work with physical hardware, cloud systems, > or equivalent. https://doc.rust-lang.org/nightly/rustc/platform-support/armv8r-none-eabihf.html exists and was updated in rust-lang/rust#146419 > - The target must document its baseline expectations for the features or > versions of CPUs, operating systems, libraries, runtime environments, and > similar. I believe it does. > - If introducing a new tier 2 or higher target that is identical to an existing > Rust target except for the baseline expectations for the features or versions > of CPUs, operating systems, libraries, runtime environments, and similar, > then the proposed target must document to the satisfaction of the approving > teams why the specific difference in baseline expectations provides > sufficient value to justify a separate target. The Armv8-R architecture introduces a new FPU type, the fp-armv8, and so this requires a unique target. > - Tier 2 targets must not leave any significant portions of `core` or the > standard library unimplemented or stubbed out, unless they cannot possibly be > supported on the target. It has a full libcore, as per the other arm*-none-* targets. > - The code generation backend for the target should not have deficiencies that > invalidate Rust safety properties, as evaluated by the Rust compiler team. It should be the same backend as `armv7r-none-eabihf` and friends, except for FPU support, which is already covered in `thumbv8m.main-none-eabihf`. There are no issues that I know of. > - If the target supports C code, and the target has an interoperable calling > convention for C code, the Rust target must support that C calling convention > for the platform via `extern "C"`. The C calling convention does not need to > be the default Rust calling convention for the target, however. The ABI is EABI, the same as many other Arm targets. > - The target must build reliably in CI, for all components that Rust's CI > considers mandatory. The https://github.com/rust-embedded/cortex-ar repository regularly builds this target with `-Zbuild-std=core` and it seems fine. > - The approving teams may additionally require that a subset of tests pass in > CI, such as enough to build a functional "hello world" program, `./x.py test > --no-run`, or equivalent "smoke tests". In particular, this requirement may > apply if the target builds host tools, or if the tests in question provide > substantial value via early detection of critical problems. There are no no-std tests in the tree that I'm aware of. > - Building the target in CI must not take substantially longer than the current > slowest target in CI, and should not substantially raise the maintenance > burden of the CI infrastructure. This requirement is subjective, to be > evaluated by the infrastructure team, and will take the community importance > of the target into account. Building libcore is quite fast. > - Tier 2 targets should, if at all possible, support cross-compiling. Tier 2 > targets should not require using the target as the host for builds, even if > the target supports host tools. It does. > - In addition to the legal requirements for all targets (specified in the tier > 3 requirements), because a tier 2 target typically involves the Rust project > building and supplying various compiled binaries, incorporating the target > and redistributing any resulting compiled binaries (e.g. built libraries, > host tools if any) must not impose any onerous license requirements on any > members of the Rust project, including infrastructure team members and those > operating CI systems. This is a subjective requirement, to be evaluated by > the approving teams. Just libcore required (and liballoc). No known issues here. > - Tier 2 targets must not impose burden on the authors of pull requests, or > other developers in the community, to ensure that tests pass for the target. Noted > - The target maintainers should regularly run the testsuite for the target The https://github.com/rust-embedded/cortex-ar repository will be changed to use the rustup component when available. > and should fix any test failures in a reasonably timely fashion. Noted
rust-cloud-vms bot
pushed a commit
to makai410/rustc_public
that referenced
this pull request
Oct 12, 2025
…rochenkov Promote armv7a-none-eabihf to Tier 2 This PR promotes armv7a-none-eabihf to Tier 2, to join armv7r-none-eabihf and armv7a-none-eabi. I believe it was simply an oversight that it wasn't made Tier 2 before, as most Armv7-A targets have an FPU and it often makes sense to use it. This PR wil be rebased once rust-lang/rust#146419 completes the queue. > - A tier 2 target must have value to people other than its maintainers. (It may > still be a niche target, but it must not be exclusively useful for an > inherently closed group.) The `armv7a-none-eabihf` target is for all Arm Cortex-A processors (either 32-bit only, or in 32-bit mode) where the user wants to use the FPU. >- A tier 2 target must have a designated team of developers (the "target > maintainers") available to consult on target-specific build-breaking issues, > or if necessary to develop target-specific language or library implementation > details. This team must have at least 2 developers. The Embedded Devices Working Group's Arm Team have just started maintaining this target. > - The target must not place undue burden on Rust developers not specifically > concerned with that target. Rust developers are expected to not gratuitously > break a tier 2 target, but are not expected to become experts in every tier 2 > target, and are not expected to provide target-specific implementations for > every tier 2 target. This target is highly similar to a number of existing Tier 2 targets, including `armv7r-none-eabihf` and `armv7a-none-eabi` and so it should not add undue burden. > - The target must provide documentation for the Rust community explaining how > to build for the target using cross-compilation, and explaining how to run > tests for the target. If at all possible, this documentation should show how > to run Rust programs and tests for the target using emulation, to allow > anyone to do so. If the target cannot be feasibly emulated, the documentation > should explain how to obtain and work with physical hardware, cloud systems, > or equivalent. https://doc.rust-lang.org/nightly/rustc/platform-support/armv7a-none-eabi.html was added in rust-lang/rust#146419. It covers the `-eabi` and the `-eabihf` targets. > - The target must document its baseline expectations for the features or > versions of CPUs, operating systems, libraries, runtime environments, and > similar. I believe it does. > - If introducing a new tier 2 or higher target that is identical to an existing > Rust target except for the baseline expectations for the features or versions > of CPUs, operating systems, libraries, runtime environments, and similar, > then the proposed target must document to the satisfaction of the approving > teams why the specific difference in baseline expectations provides > sufficient value to justify a separate target. It uses very similar FPUs to `armv7r-none-eabihf` but is otherwise the same as `armv7a-none-eabi`. > - Tier 2 targets must not leave any significant portions of `core` or the > standard library unimplemented or stubbed out, unless they cannot possibly be > supported on the target. It has a full libcore, as per the other arm*-none-* targets. > - The code generation backend for the target should not have deficiencies that > invalidate Rust safety properties, as evaluated by the Rust compiler team. It should be the same backend as `armv7r-none-eabihf` and friends, except for FPU support, which is already covered in `thumbv8m.main-none-eabihf`. There are no issues that I know of. > - If the target supports C code, and the target has an interoperable calling > convention for C code, the Rust target must support that C calling convention > for the platform via `extern "C"`. The C calling convention does not need to > be the default Rust calling convention for the target, however. The ABI is EABI, the same as many other Arm targets. > - The target must build reliably in CI, for all components that Rust's CI > considers mandatory. The https://github.com/rust-embedded/cortex-ar repository has been changed in rust-embedded/cortex-ar#57 to build this target with `-Zbuild-std=core`. Locally it seems fine. > - The approving teams may additionally require that a subset of tests pass in > CI, such as enough to build a functional "hello world" program, `./x.py test > --no-run`, or equivalent "smoke tests". In particular, this requirement may > apply if the target builds host tools, or if the tests in question provide > substantial value via early detection of critical problems. There are no no-std tests in the tree that I'm aware of. > - Building the target in CI must not take substantially longer than the current > slowest target in CI, and should not substantially raise the maintenance > burden of the CI infrastructure. This requirement is subjective, to be > evaluated by the infrastructure team, and will take the community importance > of the target into account. Building libcore is quite fast. > - Tier 2 targets should, if at all possible, support cross-compiling. Tier 2 > targets should not require using the target as the host for builds, even if > the target supports host tools. It does. > - In addition to the legal requirements for all targets (specified in the tier > 3 requirements), because a tier 2 target typically involves the Rust project > building and supplying various compiled binaries, incorporating the target > and redistributing any resulting compiled binaries (e.g. built libraries, > host tools if any) must not impose any onerous license requirements on any > members of the Rust project, including infrastructure team members and those > operating CI systems. This is a subjective requirement, to be evaluated by > the approving teams. Just libcore required (and liballoc). No known issues here. > - Tier 2 targets must not impose burden on the authors of pull requests, or > other developers in the community, to ensure that tests pass for the target. Noted > - The target maintainers should regularly run the testsuite for the target The https://github.com/rust-embedded/cortex-ar repository will be changed to use the rustup component when available. > and should fix any test failures in a reasonably timely fashion. Noted
flip1995
pushed a commit
to flip1995/rust-clippy
that referenced
this pull request
Oct 18, 2025
Demote both armebv7r-none-* targets. OK, slightly more controversial than rust-lang/rust#146520 and rust-lang/rust#146522 - I'd like to drop the bare-metal **big-endian** Armv7-R targets down to Tier 3. The reason is simple - we cannot test them in https://github.com/rust-embedded/cortex-ar/. This because QEMU support for Big Endian Armv7-R is broken. I tried quite hard, but all the strings I printed with semihosting came out byte swapped (or "etybawa depp") because of how QEMU kludges the access to memory in big-endian mode. The target also has only a single maintainer. Although, if ````@chrisnc```` wants to put up a case for keeping it at Tier 2 though, I'm happy to hear it! This PR wil be rebased once rust-lang/rust#146419 completes the queue.
flip1995
pushed a commit
to flip1995/rust-clippy
that referenced
this pull request
Oct 18, 2025
…chenkov Promote armv8r-none-eabihf target to Tier 2 This PR promotes armv8r-none-eabihf to Tier 2, joining armv7r-none-eabi, armv7r-none-eabihf and armv7a-none-eabi. This PR wil be rebased once rust-lang/rust#146419 completes the queue. > - A tier 2 target must have value to people other than its maintainers. (It may > still be a niche target, but it must not be exclusively useful for an > inherently closed group.) The `armv8r-none-eabihf` target is for the Arm Cortex-R52 processor, as found in a number of Automotive SoCs that have just been released, or are about to be released. Currently SoCs are available from NXP and Renesas. >- A tier 2 target must have a designated team of developers (the "target > maintainers") available to consult on target-specific build-breaking issues, > or if necessary to develop target-specific language or library implementation > details. This team must have at least 2 developers. The Embedded Devices Working Group's Arm Team have just started maintaining this target. > - The target must not place undue burden on Rust developers not specifically > concerned with that target. Rust developers are expected to not gratuitously > break a tier 2 target, but are not expected to become experts in every tier 2 > target, and are not expected to provide target-specific implementations for > every tier 2 target. This target is highly similar to a number of existing Tier 2 targets, including `armv7r-none-eabihf` and so it should not add undue burden. > - The target must provide documentation for the Rust community explaining how > to build for the target using cross-compilation, and explaining how to run > tests for the target. If at all possible, this documentation should show how > to run Rust programs and tests for the target using emulation, to allow > anyone to do so. If the target cannot be feasibly emulated, the documentation > should explain how to obtain and work with physical hardware, cloud systems, > or equivalent. https://doc.rust-lang.org/nightly/rustc/platform-support/armv8r-none-eabihf.html exists and was updated in rust-lang/rust#146419 > - The target must document its baseline expectations for the features or > versions of CPUs, operating systems, libraries, runtime environments, and > similar. I believe it does. > - If introducing a new tier 2 or higher target that is identical to an existing > Rust target except for the baseline expectations for the features or versions > of CPUs, operating systems, libraries, runtime environments, and similar, > then the proposed target must document to the satisfaction of the approving > teams why the specific difference in baseline expectations provides > sufficient value to justify a separate target. The Armv8-R architecture introduces a new FPU type, the fp-armv8, and so this requires a unique target. > - Tier 2 targets must not leave any significant portions of `core` or the > standard library unimplemented or stubbed out, unless they cannot possibly be > supported on the target. It has a full libcore, as per the other arm*-none-* targets. > - The code generation backend for the target should not have deficiencies that > invalidate Rust safety properties, as evaluated by the Rust compiler team. It should be the same backend as `armv7r-none-eabihf` and friends, except for FPU support, which is already covered in `thumbv8m.main-none-eabihf`. There are no issues that I know of. > - If the target supports C code, and the target has an interoperable calling > convention for C code, the Rust target must support that C calling convention > for the platform via `extern "C"`. The C calling convention does not need to > be the default Rust calling convention for the target, however. The ABI is EABI, the same as many other Arm targets. > - The target must build reliably in CI, for all components that Rust's CI > considers mandatory. The https://github.com/rust-embedded/cortex-ar repository regularly builds this target with `-Zbuild-std=core` and it seems fine. > - The approving teams may additionally require that a subset of tests pass in > CI, such as enough to build a functional "hello world" program, `./x.py test > --no-run`, or equivalent "smoke tests". In particular, this requirement may > apply if the target builds host tools, or if the tests in question provide > substantial value via early detection of critical problems. There are no no-std tests in the tree that I'm aware of. > - Building the target in CI must not take substantially longer than the current > slowest target in CI, and should not substantially raise the maintenance > burden of the CI infrastructure. This requirement is subjective, to be > evaluated by the infrastructure team, and will take the community importance > of the target into account. Building libcore is quite fast. > - Tier 2 targets should, if at all possible, support cross-compiling. Tier 2 > targets should not require using the target as the host for builds, even if > the target supports host tools. It does. > - In addition to the legal requirements for all targets (specified in the tier > 3 requirements), because a tier 2 target typically involves the Rust project > building and supplying various compiled binaries, incorporating the target > and redistributing any resulting compiled binaries (e.g. built libraries, > host tools if any) must not impose any onerous license requirements on any > members of the Rust project, including infrastructure team members and those > operating CI systems. This is a subjective requirement, to be evaluated by > the approving teams. Just libcore required (and liballoc). No known issues here. > - Tier 2 targets must not impose burden on the authors of pull requests, or > other developers in the community, to ensure that tests pass for the target. Noted > - The target maintainers should regularly run the testsuite for the target The https://github.com/rust-embedded/cortex-ar repository will be changed to use the rustup component when available. > and should fix any test failures in a reasonably timely fashion. Noted
flip1995
pushed a commit
to flip1995/rust-clippy
that referenced
this pull request
Oct 18, 2025
…rochenkov Promote armv7a-none-eabihf to Tier 2 This PR promotes armv7a-none-eabihf to Tier 2, to join armv7r-none-eabihf and armv7a-none-eabi. I believe it was simply an oversight that it wasn't made Tier 2 before, as most Armv7-A targets have an FPU and it often makes sense to use it. This PR wil be rebased once rust-lang/rust#146419 completes the queue. > - A tier 2 target must have value to people other than its maintainers. (It may > still be a niche target, but it must not be exclusively useful for an > inherently closed group.) The `armv7a-none-eabihf` target is for all Arm Cortex-A processors (either 32-bit only, or in 32-bit mode) where the user wants to use the FPU. >- A tier 2 target must have a designated team of developers (the "target > maintainers") available to consult on target-specific build-breaking issues, > or if necessary to develop target-specific language or library implementation > details. This team must have at least 2 developers. The Embedded Devices Working Group's Arm Team have just started maintaining this target. > - The target must not place undue burden on Rust developers not specifically > concerned with that target. Rust developers are expected to not gratuitously > break a tier 2 target, but are not expected to become experts in every tier 2 > target, and are not expected to provide target-specific implementations for > every tier 2 target. This target is highly similar to a number of existing Tier 2 targets, including `armv7r-none-eabihf` and `armv7a-none-eabi` and so it should not add undue burden. > - The target must provide documentation for the Rust community explaining how > to build for the target using cross-compilation, and explaining how to run > tests for the target. If at all possible, this documentation should show how > to run Rust programs and tests for the target using emulation, to allow > anyone to do so. If the target cannot be feasibly emulated, the documentation > should explain how to obtain and work with physical hardware, cloud systems, > or equivalent. https://doc.rust-lang.org/nightly/rustc/platform-support/armv7a-none-eabi.html was added in rust-lang/rust#146419. It covers the `-eabi` and the `-eabihf` targets. > - The target must document its baseline expectations for the features or > versions of CPUs, operating systems, libraries, runtime environments, and > similar. I believe it does. > - If introducing a new tier 2 or higher target that is identical to an existing > Rust target except for the baseline expectations for the features or versions > of CPUs, operating systems, libraries, runtime environments, and similar, > then the proposed target must document to the satisfaction of the approving > teams why the specific difference in baseline expectations provides > sufficient value to justify a separate target. It uses very similar FPUs to `armv7r-none-eabihf` but is otherwise the same as `armv7a-none-eabi`. > - Tier 2 targets must not leave any significant portions of `core` or the > standard library unimplemented or stubbed out, unless they cannot possibly be > supported on the target. It has a full libcore, as per the other arm*-none-* targets. > - The code generation backend for the target should not have deficiencies that > invalidate Rust safety properties, as evaluated by the Rust compiler team. It should be the same backend as `armv7r-none-eabihf` and friends, except for FPU support, which is already covered in `thumbv8m.main-none-eabihf`. There are no issues that I know of. > - If the target supports C code, and the target has an interoperable calling > convention for C code, the Rust target must support that C calling convention > for the platform via `extern "C"`. The C calling convention does not need to > be the default Rust calling convention for the target, however. The ABI is EABI, the same as many other Arm targets. > - The target must build reliably in CI, for all components that Rust's CI > considers mandatory. The https://github.com/rust-embedded/cortex-ar repository has been changed in rust-embedded/cortex-ar#57 to build this target with `-Zbuild-std=core`. Locally it seems fine. > - The approving teams may additionally require that a subset of tests pass in > CI, such as enough to build a functional "hello world" program, `./x.py test > --no-run`, or equivalent "smoke tests". In particular, this requirement may > apply if the target builds host tools, or if the tests in question provide > substantial value via early detection of critical problems. There are no no-std tests in the tree that I'm aware of. > - Building the target in CI must not take substantially longer than the current > slowest target in CI, and should not substantially raise the maintenance > burden of the CI infrastructure. This requirement is subjective, to be > evaluated by the infrastructure team, and will take the community importance > of the target into account. Building libcore is quite fast. > - Tier 2 targets should, if at all possible, support cross-compiling. Tier 2 > targets should not require using the target as the host for builds, even if > the target supports host tools. It does. > - In addition to the legal requirements for all targets (specified in the tier > 3 requirements), because a tier 2 target typically involves the Rust project > building and supplying various compiled binaries, incorporating the target > and redistributing any resulting compiled binaries (e.g. built libraries, > host tools if any) must not impose any onerous license requirements on any > members of the Rust project, including infrastructure team members and those > operating CI systems. This is a subjective requirement, to be evaluated by > the approving teams. Just libcore required (and liballoc). No known issues here. > - Tier 2 targets must not impose burden on the authors of pull requests, or > other developers in the community, to ensure that tests pass for the target. Noted > - The target maintainers should regularly run the testsuite for the target The https://github.com/rust-embedded/cortex-ar repository will be changed to use the rustup component when available. > and should fix any test failures in a reasonably timely fashion. Noted
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
9 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This PR updates some of the arm*-unknown-none target docs, and adds some missing target pages.
aarch64-none-elf and aarch64-none-elf-softfloat
The Rust Embedded Devices Working Group's Arm Team is added as a maintainer, and a target page is added. Links are added to the EDWG's support crates for this target.
armv7a-none-eabi and armv7a-none-eabihf
The Rust Embedded Devices Working Group's Arm Team is added as a maintainer, and a target page is added. Links are added to the EDWG's support crates for this target.
armv7r-none-eabi and armv7r-none-eabihf
The Rust Embedded Devices Working Group's Arm Team is added as a maintainer, and the target page is split from the Big Endian versions. Links are added to the EDWG's support crates for this target.
armebv7r-none-eabi and armveb7r-none-eabihf
The target page is split from the Little Endian versions. No change in maintainers.
I have agreement to add EDWG/T-Arm as maintainers, which was voted upon in their repo.