add tests for thumb interworking by folkertdev · Pull Request #153153 · rust-lang/rust

folkertdev · 2026-02-26T20:53:54Z

fixes#151946

thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions.

cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things
r? jieyouxu because this is doing some interesting things testing-wise

I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

rustbot · 2026-02-26T20:53:57Z

The run-make-support library was changed

cc @jieyouxu

folkertdev · 2026-02-26T23:48:21Z

@theemathas why was this closed?

folkertdev · 2026-02-27T00:01:00Z

I'm assuming it was closed on accident then?

theemathas · 2026-02-27T00:55:56Z

I've never seen this PR before. Don't know what happened.

thejpster · 2026-02-27T07:25:23Z

I don’t know the details of the test infra so I can’t comment there. The examples look good but perhaps:

it could be renamed ‘thumb-interworking’ because that’s the target flag
The a32 and t32 files can be merged into one, with entry calling six functions
The test could be extended to all targets with thumb-interworking enabled?

I also wondered if the hash in the thunk name was stable or if we needed to Wildcard it?

jieyouxu · 2026-02-28T08:21:18Z

@rustbot author

rustbot · 2026-02-28T08:21:22Z

Reminder, once the PR becomes ready for a review, use @rustbot ready.

folkertdev

Good points @thejpster, I've renamed and added tests using the arm targets.

@rustbot ready

View changes since this review

thejpster · 2026-03-01T20:24:23Z

Looks good to me. You could also add:

armv6-none-eabi
armv6-none-eabihf
thumbv6-none-eabi
armv7r-none-eabi
armv7r-none-eabihf
thumbv7r-none-eabi
thumbv7r-none-eabihf
armv7a-none-eabi
armv7a-none-eabihf
thumbv7a-none-eabi
thumbv7a-none-eabihf
armv8r-none-eabihf
thumbv8r-none-eabihf

But I wouldn't block this PR on that - they can be added later.

and in particular for naked functions in that scenario

folkertdev · 2026-03-02T12:30:18Z

I think this is ready then

jieyouxu

Thanks
@bors r+ rollup=iffy

View changes since this review

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 5 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) Failed merges: - #151864 (Implement AST -> HIR generics propagation in delegation)

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 9 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute)

rust-bors · 2026-03-02T18:44:07Z

⌛ Testing commit 2d8ceee with merge 059ecc1...

Workflow: https://github.com/rust-lang/rust/actions/runs/22590534046

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T18:57:15Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T18:57:18Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22590534046

The next pull request likely to be tested is #153303.

…uwer Rollup of 11 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

rust-bors · 2026-03-02T19:09:32Z

⌛ Testing commit 2d8ceee with merge 3600963...

Workflow: https://github.com/rust-lang/rust/actions/runs/22591476163

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T19:11:21Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T19:11:25Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22591476163

The next pull request likely to be tested is #153304.

…uwer Rollup of 10 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

…eyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang#153153.

Rollup merge of #153396 - folkertdev:run-make-minicore, r=jieyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in #153153.

use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang/rust#153153.

…uwer Rollup of 10 pull requests Successful merges: - rust-lang/rust#153153 (add tests for thumb interworking) - rust-lang/rust#151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - rust-lang/rust#151962 (Fix next-solver ICE on PointeeSized goals) - rust-lang/rust#153015 (core: make atomic primitives type aliases of `Atomic<T>`) - rust-lang/rust#153161 (Rejig `rustc_with_all_queries!`) - rust-lang/rust#153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - rust-lang/rust#153273 (vec/mod.rs: add missing period in "ie." in docs) - rust-lang/rust#153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - rust-lang/rust#153293 (library: std: process: skip tests on Hermit) - rust-lang/rust#153301 (Do not ping kobzol on rustc-dev-guide changes)

folkertdev · 2026-02-26T20:53:54Z

fixes#151946

thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions.

cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things
r? jieyouxu because this is doing some interesting things testing-wise

I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

rustbot · 2026-02-26T20:53:57Z

The run-make-support library was changed

cc @jieyouxu

folkertdev · 2026-02-26T23:48:21Z

@theemathas why was this closed?

folkertdev · 2026-02-27T00:01:00Z

I'm assuming it was closed on accident then?

theemathas · 2026-02-27T00:55:56Z

I've never seen this PR before. Don't know what happened.

thejpster · 2026-02-27T07:25:23Z

I don’t know the details of the test infra so I can’t comment there. The examples look good but perhaps:

it could be renamed ‘thumb-interworking’ because that’s the target flag
The a32 and t32 files can be merged into one, with entry calling six functions
The test could be extended to all targets with thumb-interworking enabled?

I also wondered if the hash in the thunk name was stable or if we needed to Wildcard it?

jieyouxu · 2026-02-28T08:21:18Z

@rustbot author

rustbot · 2026-02-28T08:21:22Z

Reminder, once the PR becomes ready for a review, use @rustbot ready.

folkertdev

Good points @thejpster, I've renamed and added tests using the arm targets.

@rustbot ready

View changes since this review

thejpster · 2026-03-01T20:24:23Z

Looks good to me. You could also add:

armv6-none-eabi
armv6-none-eabihf
thumbv6-none-eabi
armv7r-none-eabi
armv7r-none-eabihf
thumbv7r-none-eabi
thumbv7r-none-eabihf
armv7a-none-eabi
armv7a-none-eabihf
thumbv7a-none-eabi
thumbv7a-none-eabihf
armv8r-none-eabihf
thumbv8r-none-eabihf

But I wouldn't block this PR on that - they can be added later.

and in particular for naked functions in that scenario

folkertdev · 2026-03-02T12:30:18Z

I think this is ready then

jieyouxu

Thanks
@bors r+ rollup=iffy

View changes since this review

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 5 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) Failed merges: - #151864 (Implement AST -> HIR generics propagation in delegation)

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 9 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute)

rust-bors · 2026-03-02T18:44:07Z

⌛ Testing commit 2d8ceee with merge 059ecc1...

Workflow: https://github.com/rust-lang/rust/actions/runs/22590534046

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T18:57:15Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T18:57:18Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22590534046

The next pull request likely to be tested is #153303.

…uwer Rollup of 11 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

rust-bors · 2026-03-02T19:09:32Z

⌛ Testing commit 2d8ceee with merge 3600963...

Workflow: https://github.com/rust-lang/rust/actions/runs/22591476163

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T19:11:21Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T19:11:25Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22591476163

The next pull request likely to be tested is #153304.

…uwer Rollup of 10 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

…eyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang#153153.

Rollup merge of #153396 - folkertdev:run-make-minicore, r=jieyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in #153153.

use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang/rust#153153.

…uwer Rollup of 10 pull requests Successful merges: - rust-lang/rust#153153 (add tests for thumb interworking) - rust-lang/rust#151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - rust-lang/rust#151962 (Fix next-solver ICE on PointeeSized goals) - rust-lang/rust#153015 (core: make atomic primitives type aliases of `Atomic<T>`) - rust-lang/rust#153161 (Rejig `rustc_with_all_queries!`) - rust-lang/rust#153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - rust-lang/rust#153273 (vec/mod.rs: add missing period in "ie." in docs) - rust-lang/rust#153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - rust-lang/rust#153293 (library: std: process: skip tests on Hermit) - rust-lang/rust#153301 (Do not ping kobzol on rustc-dev-guide changes)

folkertdev · 2026-02-26T20:53:54Z

fixes#151946

thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions.

cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things
r? jieyouxu because this is doing some interesting things testing-wise

I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

rustbot · 2026-02-26T20:53:57Z

The run-make-support library was changed

cc @jieyouxu

folkertdev · 2026-02-26T23:48:21Z

@theemathas why was this closed?

folkertdev · 2026-02-27T00:01:00Z

I'm assuming it was closed on accident then?

theemathas · 2026-02-27T00:55:56Z

I've never seen this PR before. Don't know what happened.

thejpster · 2026-02-27T07:25:23Z

I don’t know the details of the test infra so I can’t comment there. The examples look good but perhaps:

it could be renamed ‘thumb-interworking’ because that’s the target flag
The a32 and t32 files can be merged into one, with entry calling six functions
The test could be extended to all targets with thumb-interworking enabled?

I also wondered if the hash in the thunk name was stable or if we needed to Wildcard it?

jieyouxu · 2026-02-28T08:21:18Z

@rustbot author

rustbot · 2026-02-28T08:21:22Z

Reminder, once the PR becomes ready for a review, use @rustbot ready.

folkertdev

Good points @thejpster, I've renamed and added tests using the arm targets.

@rustbot ready

View changes since this review

thejpster · 2026-03-01T20:24:23Z

Looks good to me. You could also add:

armv6-none-eabi
armv6-none-eabihf
thumbv6-none-eabi
armv7r-none-eabi
armv7r-none-eabihf
thumbv7r-none-eabi
thumbv7r-none-eabihf
armv7a-none-eabi
armv7a-none-eabihf
thumbv7a-none-eabi
thumbv7a-none-eabihf
armv8r-none-eabihf
thumbv8r-none-eabihf

But I wouldn't block this PR on that - they can be added later.

and in particular for naked functions in that scenario

folkertdev · 2026-03-02T12:30:18Z

I think this is ready then

jieyouxu

Thanks
@bors r+ rollup=iffy

View changes since this review

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 5 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) Failed merges: - #151864 (Implement AST -> HIR generics propagation in delegation)

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 9 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute)

rust-bors · 2026-03-02T18:44:07Z

⌛ Testing commit 2d8ceee with merge 059ecc1...

Workflow: https://github.com/rust-lang/rust/actions/runs/22590534046

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T18:57:15Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T18:57:18Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22590534046

The next pull request likely to be tested is #153303.

…uwer Rollup of 11 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

rust-bors · 2026-03-02T19:09:32Z

⌛ Testing commit 2d8ceee with merge 3600963...

Workflow: https://github.com/rust-lang/rust/actions/runs/22591476163

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T19:11:21Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T19:11:25Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22591476163

The next pull request likely to be tested is #153304.

…uwer Rollup of 10 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

…eyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang#153153.

Rollup merge of #153396 - folkertdev:run-make-minicore, r=jieyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in #153153.

use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang/rust#153153.

…uwer Rollup of 10 pull requests Successful merges: - rust-lang/rust#153153 (add tests for thumb interworking) - rust-lang/rust#151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - rust-lang/rust#151962 (Fix next-solver ICE on PointeeSized goals) - rust-lang/rust#153015 (core: make atomic primitives type aliases of `Atomic<T>`) - rust-lang/rust#153161 (Rejig `rustc_with_all_queries!`) - rust-lang/rust#153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - rust-lang/rust#153273 (vec/mod.rs: add missing period in "ie." in docs) - rust-lang/rust#153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - rust-lang/rust#153293 (library: std: process: skip tests on Hermit) - rust-lang/rust#153301 (Do not ping kobzol on rustc-dev-guide changes)

folkertdev · 2026-02-26T20:53:54Z

fixes#151946

thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions.

cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things
r? jieyouxu because this is doing some interesting things testing-wise

I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

rustbot · 2026-02-26T20:53:57Z

The run-make-support library was changed

cc @jieyouxu

folkertdev · 2026-02-26T23:48:21Z

@theemathas why was this closed?

folkertdev · 2026-02-27T00:01:00Z

I'm assuming it was closed on accident then?

theemathas · 2026-02-27T00:55:56Z

I've never seen this PR before. Don't know what happened.

thejpster · 2026-02-27T07:25:23Z

I don’t know the details of the test infra so I can’t comment there. The examples look good but perhaps:

it could be renamed ‘thumb-interworking’ because that’s the target flag
The a32 and t32 files can be merged into one, with entry calling six functions
The test could be extended to all targets with thumb-interworking enabled?

I also wondered if the hash in the thunk name was stable or if we needed to Wildcard it?

jieyouxu · 2026-02-28T08:21:18Z

@rustbot author

rustbot · 2026-02-28T08:21:22Z

Reminder, once the PR becomes ready for a review, use @rustbot ready.

folkertdev

Good points @thejpster, I've renamed and added tests using the arm targets.

@rustbot ready

View changes since this review

thejpster · 2026-03-01T20:24:23Z

Looks good to me. You could also add:

armv6-none-eabi
armv6-none-eabihf
thumbv6-none-eabi
armv7r-none-eabi
armv7r-none-eabihf
thumbv7r-none-eabi
thumbv7r-none-eabihf
armv7a-none-eabi
armv7a-none-eabihf
thumbv7a-none-eabi
thumbv7a-none-eabihf
armv8r-none-eabihf
thumbv8r-none-eabihf

But I wouldn't block this PR on that - they can be added later.

and in particular for naked functions in that scenario

folkertdev · 2026-03-02T12:30:18Z

I think this is ready then

jieyouxu

Thanks
@bors r+ rollup=iffy

View changes since this review

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 5 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) Failed merges: - #151864 (Implement AST -> HIR generics propagation in delegation)

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 9 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute)

rust-bors · 2026-03-02T18:44:07Z

⌛ Testing commit 2d8ceee with merge 059ecc1...

Workflow: https://github.com/rust-lang/rust/actions/runs/22590534046

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T18:57:15Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T18:57:18Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22590534046

The next pull request likely to be tested is #153303.

…uwer Rollup of 11 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

rust-bors · 2026-03-02T19:09:32Z

⌛ Testing commit 2d8ceee with merge 3600963...

Workflow: https://github.com/rust-lang/rust/actions/runs/22591476163

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T19:11:21Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T19:11:25Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22591476163

The next pull request likely to be tested is #153304.

…uwer Rollup of 10 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

…eyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang#153153.

Rollup merge of #153396 - folkertdev:run-make-minicore, r=jieyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in #153153.

use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang/rust#153153.

…uwer Rollup of 10 pull requests Successful merges: - rust-lang/rust#153153 (add tests for thumb interworking) - rust-lang/rust#151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - rust-lang/rust#151962 (Fix next-solver ICE on PointeeSized goals) - rust-lang/rust#153015 (core: make atomic primitives type aliases of `Atomic<T>`) - rust-lang/rust#153161 (Rejig `rustc_with_all_queries!`) - rust-lang/rust#153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - rust-lang/rust#153273 (vec/mod.rs: add missing period in "ie." in docs) - rust-lang/rust#153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - rust-lang/rust#153293 (library: std: process: skip tests on Hermit) - rust-lang/rust#153301 (Do not ping kobzol on rustc-dev-guide changes)

folkertdev · 2026-02-26T20:53:54Z

fixes#151946

thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions.

cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things
r? jieyouxu because this is doing some interesting things testing-wise

I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

rustbot · 2026-02-26T20:53:57Z

The run-make-support library was changed

cc @jieyouxu

folkertdev · 2026-02-26T23:48:21Z

@theemathas why was this closed?

folkertdev · 2026-02-27T00:01:00Z

I'm assuming it was closed on accident then?

theemathas · 2026-02-27T00:55:56Z

I've never seen this PR before. Don't know what happened.

thejpster · 2026-02-27T07:25:23Z

I don’t know the details of the test infra so I can’t comment there. The examples look good but perhaps:

it could be renamed ‘thumb-interworking’ because that’s the target flag
The a32 and t32 files can be merged into one, with entry calling six functions
The test could be extended to all targets with thumb-interworking enabled?

I also wondered if the hash in the thunk name was stable or if we needed to Wildcard it?

jieyouxu · 2026-02-28T08:21:18Z

@rustbot author

rustbot · 2026-02-28T08:21:22Z

Reminder, once the PR becomes ready for a review, use @rustbot ready.

folkertdev

Good points @thejpster, I've renamed and added tests using the arm targets.

@rustbot ready

View changes since this review

thejpster · 2026-03-01T20:24:23Z

Looks good to me. You could also add:

armv6-none-eabi
armv6-none-eabihf
thumbv6-none-eabi
armv7r-none-eabi
armv7r-none-eabihf
thumbv7r-none-eabi
thumbv7r-none-eabihf
armv7a-none-eabi
armv7a-none-eabihf
thumbv7a-none-eabi
thumbv7a-none-eabihf
armv8r-none-eabihf
thumbv8r-none-eabihf

But I wouldn't block this PR on that - they can be added later.

and in particular for naked functions in that scenario

folkertdev · 2026-03-02T12:30:18Z

I think this is ready then

jieyouxu

Thanks
@bors r+ rollup=iffy

View changes since this review

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 5 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) Failed merges: - #151864 (Implement AST -> HIR generics propagation in delegation)

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 9 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute)

rust-bors · 2026-03-02T18:44:07Z

⌛ Testing commit 2d8ceee with merge 059ecc1...

Workflow: https://github.com/rust-lang/rust/actions/runs/22590534046

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T18:57:15Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T18:57:18Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22590534046

The next pull request likely to be tested is #153303.

…uwer Rollup of 11 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

rust-bors · 2026-03-02T19:09:32Z

⌛ Testing commit 2d8ceee with merge 3600963...

Workflow: https://github.com/rust-lang/rust/actions/runs/22591476163

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T19:11:21Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T19:11:25Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22591476163

The next pull request likely to be tested is #153304.

…uwer Rollup of 10 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

…eyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang#153153.

Rollup merge of #153396 - folkertdev:run-make-minicore, r=jieyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in #153153.

use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang/rust#153153.

…uwer Rollup of 10 pull requests Successful merges: - rust-lang/rust#153153 (add tests for thumb interworking) - rust-lang/rust#151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - rust-lang/rust#151962 (Fix next-solver ICE on PointeeSized goals) - rust-lang/rust#153015 (core: make atomic primitives type aliases of `Atomic<T>`) - rust-lang/rust#153161 (Rejig `rustc_with_all_queries!`) - rust-lang/rust#153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - rust-lang/rust#153273 (vec/mod.rs: add missing period in "ie." in docs) - rust-lang/rust#153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - rust-lang/rust#153293 (library: std: process: skip tests on Hermit) - rust-lang/rust#153301 (Do not ping kobzol on rustc-dev-guide changes)

folkertdev · 2026-02-26T20:53:54Z

fixes#151946

thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions.

cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things
r? jieyouxu because this is doing some interesting things testing-wise

I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

rustbot · 2026-02-26T20:53:57Z

The run-make-support library was changed

cc @jieyouxu

folkertdev · 2026-02-26T23:48:21Z

@theemathas why was this closed?

folkertdev · 2026-02-27T00:01:00Z

I'm assuming it was closed on accident then?

theemathas · 2026-02-27T00:55:56Z

I've never seen this PR before. Don't know what happened.

thejpster · 2026-02-27T07:25:23Z

I don’t know the details of the test infra so I can’t comment there. The examples look good but perhaps:

it could be renamed ‘thumb-interworking’ because that’s the target flag
The a32 and t32 files can be merged into one, with entry calling six functions
The test could be extended to all targets with thumb-interworking enabled?

I also wondered if the hash in the thunk name was stable or if we needed to Wildcard it?

jieyouxu · 2026-02-28T08:21:18Z

@rustbot author

rustbot · 2026-02-28T08:21:22Z

Reminder, once the PR becomes ready for a review, use @rustbot ready.

folkertdev

Good points @thejpster, I've renamed and added tests using the arm targets.

@rustbot ready

View changes since this review

thejpster · 2026-03-01T20:24:23Z

Looks good to me. You could also add:

armv6-none-eabi
armv6-none-eabihf
thumbv6-none-eabi
armv7r-none-eabi
armv7r-none-eabihf
thumbv7r-none-eabi
thumbv7r-none-eabihf
armv7a-none-eabi
armv7a-none-eabihf
thumbv7a-none-eabi
thumbv7a-none-eabihf
armv8r-none-eabihf
thumbv8r-none-eabihf

But I wouldn't block this PR on that - they can be added later.

and in particular for naked functions in that scenario

folkertdev · 2026-03-02T12:30:18Z

I think this is ready then

jieyouxu

Thanks
@bors r+ rollup=iffy

View changes since this review

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 5 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) Failed merges: - #151864 (Implement AST -> HIR generics propagation in delegation)

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 9 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute)

rust-bors · 2026-03-02T18:44:07Z

⌛ Testing commit 2d8ceee with merge 059ecc1...

Workflow: https://github.com/rust-lang/rust/actions/runs/22590534046

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T18:57:15Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T18:57:18Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22590534046

The next pull request likely to be tested is #153303.

…uwer Rollup of 11 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

rust-bors · 2026-03-02T19:09:32Z

⌛ Testing commit 2d8ceee with merge 3600963...

Workflow: https://github.com/rust-lang/rust/actions/runs/22591476163

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T19:11:21Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T19:11:25Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22591476163

The next pull request likely to be tested is #153304.

…uwer Rollup of 10 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

…eyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang#153153.

Rollup merge of #153396 - folkertdev:run-make-minicore, r=jieyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in #153153.

use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang/rust#153153.

…uwer Rollup of 10 pull requests Successful merges: - rust-lang/rust#153153 (add tests for thumb interworking) - rust-lang/rust#151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - rust-lang/rust#151962 (Fix next-solver ICE on PointeeSized goals) - rust-lang/rust#153015 (core: make atomic primitives type aliases of `Atomic<T>`) - rust-lang/rust#153161 (Rejig `rustc_with_all_queries!`) - rust-lang/rust#153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - rust-lang/rust#153273 (vec/mod.rs: add missing period in "ie." in docs) - rust-lang/rust#153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - rust-lang/rust#153293 (library: std: process: skip tests on Hermit) - rust-lang/rust#153301 (Do not ping kobzol on rustc-dev-guide changes)

folkertdev · 2026-02-26T20:53:54Z

fixes#151946

thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions.

cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things
r? jieyouxu because this is doing some interesting things testing-wise

I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

rustbot · 2026-02-26T20:53:57Z

The run-make-support library was changed

cc @jieyouxu

folkertdev · 2026-02-26T23:48:21Z

@theemathas why was this closed?

folkertdev · 2026-02-27T00:01:00Z

I'm assuming it was closed on accident then?

theemathas · 2026-02-27T00:55:56Z

I've never seen this PR before. Don't know what happened.

thejpster · 2026-02-27T07:25:23Z

I don’t know the details of the test infra so I can’t comment there. The examples look good but perhaps:

it could be renamed ‘thumb-interworking’ because that’s the target flag
The a32 and t32 files can be merged into one, with entry calling six functions
The test could be extended to all targets with thumb-interworking enabled?

I also wondered if the hash in the thunk name was stable or if we needed to Wildcard it?

jieyouxu · 2026-02-28T08:21:18Z

@rustbot author

rustbot · 2026-02-28T08:21:22Z

Reminder, once the PR becomes ready for a review, use @rustbot ready.

folkertdev

Good points @thejpster, I've renamed and added tests using the arm targets.

@rustbot ready

View changes since this review

thejpster · 2026-03-01T20:24:23Z

Looks good to me. You could also add:

armv6-none-eabi
armv6-none-eabihf
thumbv6-none-eabi
armv7r-none-eabi
armv7r-none-eabihf
thumbv7r-none-eabi
thumbv7r-none-eabihf
armv7a-none-eabi
armv7a-none-eabihf
thumbv7a-none-eabi
thumbv7a-none-eabihf
armv8r-none-eabihf
thumbv8r-none-eabihf

But I wouldn't block this PR on that - they can be added later.

and in particular for naked functions in that scenario

folkertdev · 2026-03-02T12:30:18Z

I think this is ready then

jieyouxu

Thanks
@bors r+ rollup=iffy

View changes since this review

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 5 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) Failed merges: - #151864 (Implement AST -> HIR generics propagation in delegation)

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 9 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute)

rust-bors · 2026-03-02T18:44:07Z

⌛ Testing commit 2d8ceee with merge 059ecc1...

Workflow: https://github.com/rust-lang/rust/actions/runs/22590534046

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T18:57:15Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T18:57:18Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22590534046

The next pull request likely to be tested is #153303.

…uwer Rollup of 11 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

rust-bors · 2026-03-02T19:09:32Z

⌛ Testing commit 2d8ceee with merge 3600963...

Workflow: https://github.com/rust-lang/rust/actions/runs/22591476163

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T19:11:21Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T19:11:25Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22591476163

The next pull request likely to be tested is #153304.

…uwer Rollup of 10 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

…eyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang#153153.

Rollup merge of #153396 - folkertdev:run-make-minicore, r=jieyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in #153153.

use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang/rust#153153.

…uwer Rollup of 10 pull requests Successful merges: - rust-lang/rust#153153 (add tests for thumb interworking) - rust-lang/rust#151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - rust-lang/rust#151962 (Fix next-solver ICE on PointeeSized goals) - rust-lang/rust#153015 (core: make atomic primitives type aliases of `Atomic<T>`) - rust-lang/rust#153161 (Rejig `rustc_with_all_queries!`) - rust-lang/rust#153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - rust-lang/rust#153273 (vec/mod.rs: add missing period in "ie." in docs) - rust-lang/rust#153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - rust-lang/rust#153293 (library: std: process: skip tests on Hermit) - rust-lang/rust#153301 (Do not ping kobzol on rustc-dev-guide changes)

folkertdev · 2026-02-26T20:53:54Z

fixes#151946

thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions.

cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things
r? jieyouxu because this is doing some interesting things testing-wise

I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

rustbot · 2026-02-26T20:53:57Z

The run-make-support library was changed

cc @jieyouxu

folkertdev · 2026-02-26T23:48:21Z

@theemathas why was this closed?

folkertdev · 2026-02-27T00:01:00Z

I'm assuming it was closed on accident then?

theemathas · 2026-02-27T00:55:56Z

I've never seen this PR before. Don't know what happened.

thejpster · 2026-02-27T07:25:23Z

I don’t know the details of the test infra so I can’t comment there. The examples look good but perhaps:

it could be renamed ‘thumb-interworking’ because that’s the target flag
The a32 and t32 files can be merged into one, with entry calling six functions
The test could be extended to all targets with thumb-interworking enabled?

I also wondered if the hash in the thunk name was stable or if we needed to Wildcard it?

jieyouxu · 2026-02-28T08:21:18Z

@rustbot author

rustbot · 2026-02-28T08:21:22Z

Reminder, once the PR becomes ready for a review, use @rustbot ready.

folkertdev

Good points @thejpster, I've renamed and added tests using the arm targets.

@rustbot ready

View changes since this review

thejpster · 2026-03-01T20:24:23Z

Looks good to me. You could also add:

armv6-none-eabi
armv6-none-eabihf
thumbv6-none-eabi
armv7r-none-eabi
armv7r-none-eabihf
thumbv7r-none-eabi
thumbv7r-none-eabihf
armv7a-none-eabi
armv7a-none-eabihf
thumbv7a-none-eabi
thumbv7a-none-eabihf
armv8r-none-eabihf
thumbv8r-none-eabihf

But I wouldn't block this PR on that - they can be added later.

and in particular for naked functions in that scenario

folkertdev · 2026-03-02T12:30:18Z

I think this is ready then

jieyouxu

Thanks
@bors r+ rollup=iffy

View changes since this review

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 5 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) Failed merges: - #151864 (Implement AST -> HIR generics propagation in delegation)

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

…uwer Rollup of 9 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute)

rust-bors · 2026-03-02T18:44:07Z

⌛ Testing commit 2d8ceee with merge 059ecc1...

Workflow: https://github.com/rust-lang/rust/actions/runs/22590534046

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

@thejpster

add tests for thumb interworking fixesrust-lang#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T18:57:15Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T18:57:18Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22590534046

The next pull request likely to be tested is #153303.

…uwer Rollup of 11 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #149328 (Add `String<A>` type with custom allocator parameter) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

rust-bors · 2026-03-02T19:09:32Z

⌛ Testing commit 2d8ceee with merge 3600963...

Workflow: https://github.com/rust-lang/rust/actions/runs/22591476163

@thejpster

add tests for thumb interworking fixes#151946 thumb programs (using a 16-bit instruction encoding) can call arm (32-bit instruction encoding) code. Doing so requires switching from thumb mode to arm mode, executing, then switching back. Test that this happens correctly, in particular for naked functions. cc @thejpster can you confirm the output looks good here and that we're testing all of the relevant things r? jieyouxu because this is doing some interesting things testing-wise I believe that we need run-make here because we need to look at the assembly after the linker has run. It will correct calls from thumb to arm: depending on the thumb version this either uses a special instruction or inserts a call to a thunk that handles switching between thumb and arm mode.

JonathanBrouwer · 2026-03-02T19:11:21Z

@bors yield
Yielding to enclosing rollup

rust-bors · 2026-03-02T19:11:25Z

Auto build cancelled. Cancelled workflows:

https://github.com/rust-lang/rust/actions/runs/22591476163

The next pull request likely to be tested is #153304.

…uwer Rollup of 10 pull requests Successful merges: - #153153 (add tests for thumb interworking) - #151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - #151962 (Fix next-solver ICE on PointeeSized goals) - #153015 (core: make atomic primitives type aliases of `Atomic<T>`) - #153161 (Rejig `rustc_with_all_queries!`) - #153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - #153273 (vec/mod.rs: add missing period in "ie." in docs) - #153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - #153293 (library: std: process: skip tests on Hermit) - #153301 (Do not ping kobzol on rustc-dev-guide changes)

…eyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang#153153.

Rollup merge of #153396 - folkertdev:run-make-minicore, r=jieyouxu use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in #153153.

use `minicore` in some `run-make` tests r? jieyouxu This manually builds `minicore` in two more `rmake` tests that rolled their own before, and adds a helper for the path of the minicore source. I tried adding a true minicore helper in `run_make_support` but unfortunately the minicore build needs to inherit some (but probably not all) arguments of the final rustc invocation (notably `target` and `target_cpu`), so a one-size-fits-all helper doesn't really work as far as I can see. For now with 3 uses this is probably fine, but there are probably other `run-make` tests that could use `minicore` but didn't document/simulate that. follow-up to discussion in rust-lang/rust#153153.

…uwer Rollup of 10 pull requests Successful merges: - rust-lang/rust#153153 (add tests for thumb interworking) - rust-lang/rust#151780 (Updated slice tests to pass for big endian hosts for `multiple-option-or-permutations.rs`) - rust-lang/rust#151962 (Fix next-solver ICE on PointeeSized goals) - rust-lang/rust#153015 (core: make atomic primitives type aliases of `Atomic<T>`) - rust-lang/rust#153161 (Rejig `rustc_with_all_queries!`) - rust-lang/rust#153191 ( don't emit `unused_results` lint for tuples of "trivial" types ) - rust-lang/rust#153273 (vec/mod.rs: add missing period in "ie." in docs) - rust-lang/rust#153292 (tests: codegen-llvm: vec-calloc: do not require the uwtable attribute) - rust-lang/rust#153293 (library: std: process: skip tests on Hermit) - rust-lang/rust#153301 (Do not ping kobzol on rustc-dev-guide changes)

rustbot added A-run-make Area: port run-make Makefiles to rmake.rs S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. labels Feb 26, 2026

rustbot assigned jieyouxu Feb 26, 2026

This comment has been minimized.
Sign in to view

folkertdev force-pushed the thumb-and-arm branch from b3d5462 to 1977b19Compare February 26, 2026 21:56

theemathas closed this Feb 26, 2026

rustbot removed the S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. label Feb 26, 2026

folkertdev reopened this Feb 27, 2026

rustbot added the S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. label Feb 27, 2026

jieyouxu reviewed Feb 28, 2026
View reviewed changes

Comment threadtests/run-make/thumb-calling-arm/rmake.rs Outdated

rustbot added S-waiting-on-author Status: This is awaiting some action (such as code changes or more information) from the author. and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. labels Feb 28, 2026

folkertdev force-pushed the thumb-and-arm branch from 1977b19 to bbe9f23Compare March 1, 2026 15:48

folkertdev commented Mar 1, 2026
View reviewed changes

Comment threadtests/run-make/thumb-interworking/rmake.rs

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. and removed S-waiting-on-author Status: This is awaiting some action (such as code changes or more information) from the author. labels Mar 1, 2026

add tests for a thumb program calling arm code
2d8ceee
and in particular for naked functions in that scenario

folkertdev force-pushed the thumb-and-arm branch from bbe9f23 to 2d8ceeeCompare March 2, 2026 09:54

folkertdev changed the title ~~add tests for thumb calling arm code~~add tests for thumb interworkingMar 2, 2026

jieyouxu approved these changes Mar 2, 2026
View reviewed changes

JonathanBrouwer mentioned this pull request Mar 2, 2026
Rollup of 5 pull requests #153296
Closed

JonathanBrouwer mentioned this pull request Mar 2, 2026
Rollup of 9 pull requests #153299
Closed

JonathanBrouwer mentioned this pull request Mar 2, 2026
Rollup of 11 pull requests #153303
Closed

JonathanBrouwer mentioned this pull request Mar 2, 2026
Rollup of 10 pull requests #153304
Merged

rust-borsBot merged commit 6d16e3b into rust-lang:mainMar 2, 2026
11 of 12 checks passed

rustbot added this to the 1.96.0 milestone Mar 2, 2026

folkertdev mentioned this pull request Mar 4, 2026
use minicore in some run-make tests #153396
Merged