Cool! Let me know when you need a review. I can also aid in testing as I have an Apple Silicon ARM PC at hand.

@Teufelchen1 PR is ready for review :)

Thanks for waiting.

I noticed a few things, maybe I have an invalid setup for testing or this PR need more work.
My setup:

• MacOS Ventura 13.2.1
• ARM64 / Apple M2
• Docker
  • Ubuntu (latest) for --platform linux/arm64
• Within docker, running BOARD=native64 make all term

Does that sound reasonable to you? Would you expect everything to work with the given setup?

Following things did not work as expected:

• The ipc_pingpong example, indefinitely hangs after both threads are created.
• The default example, crashes immediately after hitting an assertion within gnrc.
• Building for 32 bit native does not work (the issue marked in your PR description). I think we should handle that case more gracefully.

If needed, I can also arrange a plain linux on ARM64 environment.

Thank‘s for testing. These issues definitely need to be resolved first, I’m going to try and figure out what’s going on there with these non-functional examples..

On ARM 64 bit, building for 32 bit platforms with gcc seems to be inherently impossible due to lacking gcc multilib support, at least to my knowledge.. Your setup seems fine and similar to mine.
(edit: haven’t tried compiling with clang)

What is it exactly you had in mind when you said »we should handle that case more gracefully«? A pretty error message with a reference to RIOT‘s doc perhaps..

carl

This branch also works for the Raspberry Pi devices used by for the exercises. Skimming the discussion I'm afraid we won't get this merged by tomorrow so it could go into this summit's tutorials :-)

Could you add a branch to cpu/native/Makefile.include already in this PR so that on matching platforms, the RUST_TARGET can be aarch64-unknown-linux-gnu? (You can verify that by building and running examples/rust-gcoap or any other Rust example).

Any update on this? I think it would be super cool to have native support on a RPi.

Any update on this? I think it would be super cool to have native support on a RPi.

There‘s still some investigating needed to find out why some of the examples fail.. also, networking with gnrc does not work for me (maybe a threading issue?). Perhaps the ISR logic can‘t be that naively ported to arm from x86? I still want to get arm64 support working eventually, but I don’t have the time at the moment. If somebody wants to dig into this or has some insights to share as to why this isn’t working as it should, your help would be greatly appreciated 🚀.

Figured it out last week: ucontext_t has a PC field which is ignored on arm64 (see glibc and libplatform). This makes sense given PC cannot even be set in assembly. Instead, you need to set LR. That's the C part. Given the freedom of assembly, you can decide between blr/br x16 (x16 contains addr) and ret (lr=x30 contains addr).

Also, when setting ints from assembly, you'll need to use w0 (32-bit reg view) instead of x0 (64-bit register) or otherwise you'll corrupt the 3 bytes following the first 32-bit integer value.

@Teufelchen1 can you check, please?

If Murdock looks at this PR, the result will actually just indicate nothing has been broken but won't tell us if native on arm64 works, right? Because the CI currently does not know about arm64, does it?

@chrysn why does

That's the part that sets the Rust target triple

Looks super promising! Overall review is very cluttered, I will go through it by commits then. When do you need my review? Are you blocked or can I take my time?

Ah no, 21283 has been merged, if you rebase, the PR should shrink and look rather clean! Neat!

Rebased. #21289 builds on this, but does not block me.

I have successfully tested this on a Raspberry Pi Zero 2 W (with few examples & driver tests, gnrc_networking, spi, sx127x)

Murdock results

✔️ PASSED

df84d12 cpu/native: add support for aarch64/arm64 on Linux

Artifacts

• Documentation preview