add arm targets

Author: mvolfik

compiler/rustc_target/src/spec/base/helenos.rs

@@ -1,4 +1,4 @@
-use crate::spec::{PanicStrategy, RelroLevel, TargetOptions};
+use crate::spec::{PanicStrategy, RelroLevel, StackProbeType, TargetOptions};
 
 pub(crate) fn opts() -> TargetOptions {
     TargetOptions {
@@ -10,6 +10,7 @@ pub(crate) fn opts() -> TargetOptions {
         has_rpath: true,
         relro_level: RelroLevel::Full,
         panic_strategy: PanicStrategy::Abort,
+        stack_probes: StackProbeType::Inline,
 
         ..Default::default()
     }

compiler/rustc_target/src/spec/mod.rs

@@ -1838,6 +1838,8 @@ supported_targets! {
     ("i686-unknown-haiku", i686_unknown_haiku),
     ("x86_64-unknown-haiku", x86_64_unknown_haiku),
 
+    ("aarch64-unknown-helenos", aarch64_unknown_helenos),
+    ("armv5te-unknown-helenos-eabi", armv5te_unknown_helenos_eabi),
     ("i686-unknown-helenos", i686_unknown_helenos),
     ("x86_64-unknown-helenos", x86_64_unknown_helenos),
 

compiler/rustc_target/src/spec/targets/aarch64_unknown_helenos.rs

@@ -0,0 +1,22 @@
+use crate::spec::{Target, base};
+
+pub(crate) fn target() -> Target {
+    let mut base = base::helenos::opts();
+    base.max_atomic_width = Some(128);
+    base.features = "+v8a".into();
+    base.linker = Some("aarch64-helenos-gcc".into());
+
+    Target {
+        llvm_target: "aarch64-unknown-helenos".into(),
+        metadata: crate::spec::TargetMetadata {
+            description: Some("ARM64 HelenOS".into()),
+            tier: Some(3),
+            host_tools: Some(false),
+            std: Some(true),
+        },
+        pointer_width: 64,
+        data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(),
+        arch: "aarch64".into(),
+        options: base,
+    }
+}

compiler/rustc_target/src/spec/targets/armv5te_unknown_helenos_eabi.rs

@@ -0,0 +1,35 @@
+use crate::spec::{Cc, FloatAbi, LinkerFlavor, Lld, Target, base};
+
+pub(crate) fn target() -> Target {
+    let mut base = base::helenos::opts();
+    base.abi = "eabi".into();
+    base.llvm_floatabi = Some(FloatAbi::Soft);
+    base.max_atomic_width = Some(32);
+    base.features = "+soft-float,+strict-align,+atomics-32".into();
+    base.has_thumb_interworking = true;
+    base.linker = Some("arm-helenos-gcc".into());
+    base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-march=armv5te"]);
+
+    // FIXME: these 3 flags are a hack to avoid generating R_*_RELATIVE relocations in code segment,
+    // which cause the HelenOS loader to segfault. I believe the underlying issue is that HelenOS
+    // doesn't map the code segment as writable, so the loader can't apply the relocations.
+    // The same issue was with the i686-helenos target, I don't recall why the current combination
+    // of flags avoids the issue there.
+    base.crt_static_default = true;
+    base.crt_static_respected = false;
+    base.crt_static_allows_dylibs = true;
+
+    Target {
+        llvm_target: "armv5te-unknown-helenos-eabi".into(),
+        metadata: crate::spec::TargetMetadata {
+            description: Some("ARMv5te HelenOS".into()),
+            tier: Some(3),
+            host_tools: Some(false),
+            std: Some(true),
+        },
+        pointer_width: 32,
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
+        arch: "arm".into(),
+        options: base,
+    }
+}

compiler/rustc_target/src/spec/targets/i686_unknown_helenos.rs

@@ -1,10 +1,9 @@
-use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, base};
+use crate::spec::{Cc, LinkerFlavor, Lld, Target, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::helenos::opts();
     base.cpu = "pentium4".into();
     base.max_atomic_width = Some(64);
-    base.stack_probes = StackProbeType::Inline;
     base.linker = Some("i686-helenos-gcc".into());
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]);
 
@@ -14,7 +13,7 @@ pub(crate) fn target() -> Target {
             description: Some("IA-32 (i686) HelenOS".into()),
             tier: Some(3),
             host_tools: Some(false),
-            std: None,
+            std: Some(true),
         },
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\

compiler/rustc_target/src/spec/targets/x86_64_unknown_helenos.rs

@@ -1,11 +1,10 @@
-use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, base};
+use crate::spec::{Cc, LinkerFlavor, Lld, Target, base};
 
 pub(crate) fn target() -> Target {
     let mut base = base::helenos::opts();
     base.cpu = "x86-64".into();
     base.plt_by_default = false;
     base.max_atomic_width = Some(64);
-    base.stack_probes = StackProbeType::Inline;
     base.linker = Some("amd64-helenos-gcc".into());
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]);
 
@@ -15,7 +14,7 @@ pub(crate) fn target() -> Target {
             description: Some("64-bit HelenOS".into()),
             tier: Some(3),
             host_tools: Some(false),
-            std: None,
+            std: Some(true),
         },
         pointer_width: 64,
         data_layout:

src/bootstrap/src/core/sanity.rs

@@ -33,6 +33,8 @@ pub struct Finder {
 //
 // Targets can be removed from this list once they are present in the stage0 compiler (usually by updating the beta compiler of the bootstrap).
 const STAGE0_MISSING_TARGETS: &[&str] = &[
+    "aarch64-unknown-helenos",
+    "armv5te-unknown-helenos-eabi",
     "i686-unknown-helenos",
     "x86_64-unknown-helenos",
     // just a dummy comment so the list doesn't get onelined

src/doc/rustc/src/platform-support.md

@@ -253,6 +253,7 @@ target | std | host | notes
 [`aarch64-kmc-solid_asp3`](platform-support/kmc-solid.md) | ✓ |  | ARM64 SOLID with TOPPERS/ASP3
 [`aarch64-nintendo-switch-freestanding`](platform-support/aarch64-nintendo-switch-freestanding.md) | * |  | ARM64 Nintendo Switch, Horizon
 [`aarch64-unknown-freebsd`](platform-support/freebsd.md) | ✓ | ✓ | ARM64 FreeBSD
+[`aarch64-unknown-helenos`](platform-support/helenos.md) | ? |  | ARM64 HelenOS
 [`aarch64-unknown-hermit`](platform-support/hermit.md) | ✓ |  | ARM64 Hermit
 [`aarch64-unknown-illumos`](platform-support/illumos.md) | ✓ | ✓ | ARM64 illumos
 `aarch64-unknown-linux-gnu_ilp32` | ✓ | ✓ | ARM64 Linux (ILP32 ABI)
@@ -280,6 +281,7 @@ target | std | host | notes
 [`armv4t-none-eabi`](platform-support/armv4t-none-eabi.md) | * |  | Bare Armv4T
 `armv4t-unknown-linux-gnueabi` | ? |  | Armv4T Linux
 [`armv5te-none-eabi`](platform-support/armv5te-none-eabi.md) | * |  | Bare Armv5TE
+[`armv5te-unknown-helenos-eabi`](platform-support/helenos.md) | ? |  | Armv5TE HelenOS
 `armv5te-unknown-linux-uclibceabi` | ? |  | Armv5TE Linux with uClibc
 [`armv6-unknown-freebsd`](platform-support/freebsd.md) | ✓ | ✓ | Armv6 FreeBSD
 [`armv6-unknown-netbsd-eabihf`](platform-support/netbsd.md) | ✓ | ✓ | Armv6 NetBSD w/hard-float
@@ -313,7 +315,7 @@ target | std | host | notes
 [`i686-apple-darwin`](platform-support/apple-darwin.md) | ✓ | ✓ | 32-bit macOS (10.12+, Sierra+, Penryn) [^x86_32-floats-return-ABI]
 [`i686-pc-nto-qnx700`](platform-support/nto-qnx.md) | * |  | 32-bit x86 QNX Neutrino 7.0 RTOS (Pentium 4) [^x86_32-floats-return-ABI]
 `i686-unknown-haiku` | ✓ | ✓ | 32-bit Haiku (Pentium 4) [^x86_32-floats-return-ABI]
-[`i686-unknown-helenos`](platform-support/helenos.md) | ? |  | HelenOS IA-32
+[`i686-unknown-helenos`](platform-support/helenos.md) | ? |  | 32-bit (IA-32) HelenOS
 [`i686-unknown-hurd-gnu`](platform-support/hurd.md) | ✓ | ✓ | 32-bit GNU/Hurd (Pentium 4) [^x86_32-floats-return-ABI]
 [`i686-unknown-netbsd`](platform-support/netbsd.md) | ✓ | ✓ | NetBSD/i386 (Pentium 4) [^x86_32-floats-return-ABI]
 [`i686-unknown-openbsd`](platform-support/openbsd.md) | ✓ | ✓ | 32-bit OpenBSD (Pentium 4) [^x86_32-floats-return-ABI]

src/doc/rustc/src/platform-support/helenos.md

@@ -26,28 +26,36 @@ You need to have a local clone of the HelenOS repository and the HelenOS toolcha
 
 ### HelenOS toolchain setup
 
-For compilation of standard library, you need to build the HelenOS toolchain (because Rust needs to use `*-helenos-gcc` as linker) and shared libraries. See [this HelenOS wiki page](https://www.helenos.org/wiki/UsersGuide/CompilingFromSource#a2.Buildasupportedcross-compiler) for instruction on setting up the build. At the end of step 4 (_Configure and build_), invoke `ninja export-dev` to build the shared libraries.
+For compilation of standard library, you need to build the HelenOS toolchain (because Rust needs to use `*-helenos-gcc` as linker) and its libraries (libc and a few others). See [this HelenOS wiki page](https://www.helenos.org/wiki/UsersGuide/CompilingFromSource#a2.Buildasupportedcross-compiler) for instruction on setting up the build. At the end of step 4 (_Configure and build_), after `ninja image_path`, invoke `ninja export-dev` to build the shared libraries.
 
-Then copy these shared libraries from `export-dev/lib` to the path where the compiler automatically searches for them. This will be the directory where you installed the toolchain (for example `~/.local/share/HelenOS/cross/i686-helenos/lib`). You can see this path with this command:
+Copy the libraries to the path where the compiler automatically searches for them. This will be the directory where you installed the toolchain (for example `~/.local/share/HelenOS/cross/i686-helenos/lib`). In the folder where you built HelenOS, you can run these commands:
 
 ```sh
 touch /tmp/test.c
-i686-helenos-gcc -v -c /tmp/test.c 2>&1 | grep LIBRARY_PATH
+HELENOS_LIB_PATH="$(realpath "$(i686-helenos-gcc -v -c /tmp/test.c 2>&1 | grep LIBRARY_PATH | cut -d= -f2 | cut -d: -f3)")"
+# use amd64-helenos-gcc above for x86_64 toolchain, etc
+cp export-dev/lib/* dist/lib/libc.so.0 dist/lib/libposix.so.0 "$HELENOS_LIB_PATH"
+ln -s libposix.so.0 "$HELENOS_LIB_PATH/libposix.so"
+ln -s libc.so.0 "$HELENOS_LIB_PATH/libc.so"
 ```
 
+This automatically determines the library path, copies the libraries, and creates the necessary unversioned shared library symlinks.
+
 ### Building the target
 
 When you have the HelenOS toolchain set up and installed in your path, you can build the Rust toolchain using the standard procedure. See [rustc dev guide](https://rustc-dev-guide.rust-lang.org/building/how-to-build-and-run.html).
 
+In the most simple case, this means that you can run `./x build library --stage 1 --target x86_64-unknown-linux-gnu,i686-unknown-helenos` (the first target triple should be your host machine, adjust accordingly). Then run `rustup toolchain link mytoolchain build/host/stage1` to allow using your toolchain for building Rust programs.
+
 ### Building Rust programs
 
-Use the toolchain that you have built above and run `cargo build --target <arch>-unknown-helenos`.
+If you linked the toolchain above as `mytoolchain`, run `cargo +mytoolchain build --target <arch>-unknown-helenos`.
 
 ## Testing
 
 After you build a Rust program for HelenOS, you can put it into the `dist` directory of the HelenOS build, build the ISO image, and then run it either in an emulator, or on real hardware. See HelenOS wiki for further instructions on running the OS.
 
-Running the Rust testsuite has not been attempted yet due to missing host tools and networking code.
+Running the Rust testsuite has not been attempted yet due to missing host tools (thus the test suite can't be run natively) and insufficient networking support (thus we can't use the `remote-test-server` tool).
 
 ## Cross-compilation toolchains and C code