Powerpc64le linux_raw support.

This mostly follows other architectures, however Rust's inline asm is currently
considered experimental on PowerPC, so this uses outline asm by default even on
Rust nightly.

Fixes #188.

Author: sunfishcode

.github/workflows/main.yml

@@ -64,6 +64,7 @@ jobs:
         riscv64gc-unknown-linux-gnu
         aarch64-unknown-linux-gnu
         aarch64-unknown-linux-musl
+        powerpc64le-unknown-linux-gnu
         armv5te-unknown-linux-gnueabi
     - name: Install cross-compilation tools
       run: |
@@ -86,6 +87,7 @@ jobs:
     - run: cargo check --workspace --release -vv --target=riscv64gc-unknown-linux-gnu
     - run: cargo check --workspace --release -vv --target=aarch64-unknown-linux-gnu
     - run: cargo check --workspace --release -vv --target=aarch64-unknown-linux-musl
+    - run: cargo check --workspace --release -vv --target=powerpc64le-unknown-linux-gnu
     - run: cargo check --workspace --release -vv --target=armv5te-unknown-linux-gnueabi
 
   check_no_default_features:
@@ -168,7 +170,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        build: [ubuntu, ubuntu-18.04, i686-linux, aarch64-linux, riscv64-linux, arm-linux, ubuntu-stable, i686-linux-stable, aarch64-linux-stable, riscv64-linux-stable, arm-linux-stable, macos, macos-11, windows, windows-2016, windows-2022]
+        build: [ubuntu, ubuntu-18.04, i686-linux, aarch64-linux, powerpc64le-linux, riscv64-linux, arm-linux, ubuntu-stable, i686-linux-stable, aarch64-linux-stable, riscv64-linux-stable, arm-linux-stable, macos, macos-11, windows, windows-2016, windows-2022]
         include:
           - build: ubuntu
             os: ubuntu-latest
@@ -191,6 +193,14 @@ jobs:
             gcc: aarch64-linux-gnu-gcc
             qemu: qemu-aarch64 -L /usr/aarch64-linux-gnu
             qemu_target: aarch64-linux-user
+          - build: powerpc64le-linux
+            os: ubuntu-latest
+            rust: nightly
+            target: powerpc64le-unknown-linux-gnu
+            gcc_package: gcc-powerpc64le-linux-gnu
+            gcc: powerpc64le-linux-gnu-gcc
+            qemu: qemu-ppc64le -L /usr/powerpc64le-linux-gnu
+            qemu_target: ppc64le-linux-user
           - build: riscv64-linux
             os: ubuntu-latest
             rust: nightly
@@ -320,7 +330,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        build: [ubuntu, i686-linux, aarch64-linux, riscv64-linux, arm-linux]
+        build: [ubuntu, i686-linux, aarch64-linux, powerpc64le-linux, riscv64-linux, arm-linux]
         include:
           - build: ubuntu
             os: ubuntu-latest
@@ -340,6 +350,14 @@ jobs:
             gcc: aarch64-linux-gnu-gcc
             qemu: qemu-aarch64 -L /usr/aarch64-linux-gnu
             qemu_target: aarch64-linux-user
+          - build: powerpc64le-linux
+            os: ubuntu-latest
+            rust: stable
+            target: powerpc64le-unknown-linux-gnu
+            gcc_package: gcc-powerpc64le-linux-gnu
+            gcc: powerpc64le-linux-gnu-gcc
+            qemu: qemu-ppc64le -L /usr/powerpc64le-linux-gnu
+            qemu_target: ppc64le-linux-user
           - build: riscv64-linux
             os: ubuntu-latest
             rust: stable
@@ -363,6 +381,7 @@ jobs:
       CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUSTFLAGS: --cfg rustix_use_libc
       CARGO_TARGET_I686_UNKNOWN_LINUX_GNU_RUSTFLAGS: --cfg rustix_use_libc
       CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_RUSTFLAGS: --cfg rustix_use_libc
+      CARGO_TARGET_POWERPC64LE_UNKNOWN_LINUX_GNU_RUSTFLAGS: --cfg rustix_use_libc
       CARGO_TARGET_RISCV64_UNKNOWN_LINUX_GNU_RUSTFLAGS: --cfg rustix_use_libc
       CARGO_TARGET_ARM_UNKNOWN_LINUX_GNU_RUSTFLAGS: --cfg rustix_use_libc
     steps:
@@ -418,3 +437,77 @@ jobs:
         cargo test --verbose --features=all-impls,procfs --release --workspace -- --nocapture
       env:
         RUST_BACKTRACE: 1
+
+  test_rustix_use_experimental_asm:
+    name: Test rustix_use_experimental_asm
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        build: [powerpc64le-linux]
+        include:
+          - build: powerpc64le-linux
+            os: ubuntu-latest
+            rust: nightly
+            target: powerpc64le-unknown-linux-gnu
+            gcc_package: gcc-powerpc64le-linux-gnu
+            gcc: powerpc64le-linux-gnu-gcc
+            qemu: qemu-ppc64le -L /usr/powerpc64le-linux-gnu
+            qemu_target: ppc64le-linux-user
+    env:
+      # -D warnings is commented out in our install-rust action; re-add it here.
+      RUSTFLAGS: --cfg rustix_use_experimental_asm -D warnings
+      RUSTDOCFLAGS: --cfg rustix_use_experimental_asm
+      CARGO_TARGET_POWERPC64LE_UNKNOWN_LINUX_GNU_RUSTFLAGS: --cfg rustix_use_experimental_asm
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - uses: ./.github/actions/install-rust
+      with:
+        toolchain: ${{ matrix.rust }}
+
+    - name: Configure Cargo target
+      run: |
+        echo CARGO_BUILD_TARGET=${{ matrix.target }} >> $GITHUB_ENV
+        rustup target add ${{ matrix.target }}
+      if: matrix.target != ''
+
+    - name: Install cross-compilation tools
+      run: |
+        set -ex
+        sudo apt-get update
+        sudo apt-get install -y ${{ matrix.gcc_package }} ninja-build
+        upcase=$(echo ${{ matrix.target }} | awk '{ print toupper($0) }' | sed 's/-/_/g')
+        echo CARGO_TARGET_${upcase}_LINKER=${{ matrix.gcc }} >> $GITHUB_ENV
+      if: matrix.gcc_package != '' && matrix.os == 'ubuntu-latest'
+
+    - name: Install cross-compilation libraries
+      run: |
+        set -ex
+        sudo apt-get update
+        sudo apt-get install -y ${{ matrix.libc_package }}
+      if: matrix.libc_package != '' && matrix.os == 'ubuntu-latest'
+
+    - name: Install qemu
+      run: |
+        set -ex
+        # Download and build qemu from source since the most recent release is
+        # way faster at arm emulation than the current version github actions'
+        # ubuntu image uses. Disable as much as we can to get it to build
+        # quickly.
+        cd
+        curl https://download.qemu.org/qemu-6.1.0.tar.xz | tar xJf -
+        cd qemu-6.1.0
+        ./configure --target-list=${{ matrix.qemu_target }} --prefix=$HOME/qemu --disable-tools --disable-slirp --disable-fdt --disable-capstone --disable-docs
+        make -j$(nproc) install
+
+        # Configure Cargo for cross compilation and tell it how it can run
+        # cross executables
+        upcase=$(echo ${{ matrix.target }} | awk '{ print toupper($0) }' | sed 's/-/_/g')
+        echo CARGO_TARGET_${upcase}_RUNNER=$HOME/qemu/bin/${{ matrix.qemu }} >> $GITHUB_ENV
+      if: matrix.qemu != '' && matrix.os == 'ubuntu-latest'
+
+    - run: |
+        cargo test --verbose --features=all-impls,procfs --release --workspace -- --nocapture
+      env:
+        RUST_BACKTRACE: 1

Cargo.toml

@@ -32,12 +32,12 @@ compiler_builtins = { version = '0.1.49', optional = true }
 once_cell = { version = "1.5.2", optional = true }
 
 # For the linux_raw backend, linux-raw-sys provides Linux ABI details.
-[target.'cfg(all(not(rustix_use_libc), any(target_os = "linux"), any(target_arch = "x86", all(target_arch = "x86_64", not(target_pointer_width = "32")), target_arch = "arm", target_arch = "aarch64", target_arch = "riscv64")))'.dependencies]
+[target.'cfg(all(not(rustix_use_libc), any(target_os = "linux"), any(target_arch = "x86", all(target_arch = "x86_64", not(target_pointer_width = "32")), target_arch = "arm", target_arch = "aarch64", target_arch = "powerpc64", target_arch = "riscv64")))'.dependencies]
 linux-raw-sys = { version = "0.0.40", default-features = false, features = ["general", "errno", "ioctl", "no_std"] }
 
 # For the libc backend on Unix platforms, use the libc crate, and errno for
 # setting `errno`.
-[target.'cfg(any(rustix_use_libc, not(all(any(target_os = "linux"), any(target_arch = "x86", all(target_arch = "x86_64", not(target_pointer_width = "32")), target_arch = "arm", target_arch = "aarch64", target_arch = "riscv64")))))'.dependencies]
+[target.'cfg(any(rustix_use_libc, not(all(any(target_os = "linux"), any(target_arch = "x86", all(target_arch = "x86_64", not(target_pointer_width = "32")), target_arch = "arm", target_arch = "aarch64", target_arch = "powerpc64", target_arch = "riscv64")))))'.dependencies]
 errno = { version = "0.2.8", default-features = false }
 libc = { version = "0.2.114", features = ["extra_traits"] }
 

README.md

@@ -31,8 +31,8 @@ portable APIs built on this functionality, see the [`system-interface`],
 `rustix` currently has two backends available: `linux_raw` and `libc`.
 
 The `linux_raw` backend is enabled by default on Linux on x86-64, x86, aarch64,
-riscv64gc and arm (v5 onwards), and uses raw Linux system calls and vDSO calls.
-It supports stable as well as nightly and 1.48 Rust.
+riscv64gc, powerpc64le, and arm (v5 onwards), and uses raw Linux system calls
+and vDSO calls. It supports stable as well as nightly and 1.48 Rust.
  - By being implemented entirely in Rust, avoiding `libc`, `errno`, and pthread
    cancellation, and employing some specialized optimizations, most functions
    compile down to very efficient code. On nightly Rust, they can often be

build.rs

@@ -27,27 +27,40 @@ fn main() {
     let asm_name = format!("{}/{}.s", OUTLINE_PATH, arch);
     let os_name = var("CARGO_CFG_TARGET_OS").unwrap();
     let pointer_width = var("CARGO_CFG_TARGET_POINTER_WIDTH").unwrap();
+    let endian = var("CARGO_CFG_TARGET_ENDIAN").unwrap();
     let is_x32 = arch == "x86_64" && pointer_width == "32";
     let is_arm64_ilp32 = arch == "aarch64" && pointer_width == "32";
-    println!("cargo:rerun-if-env-changed=CARGO_CFG_TARGET_ARCH");
+    let is_powerpc64be = arch == "powerpc64" && endian == "big";
+    let rustix_use_libc = var("CARGO_CFG_RUSTIX_USE_LIBC").is_ok();
+    let rustix_use_experimental_asm = var("CARGO_CFG_RUSTIX_USE_EXPERIMENTAL_ASM").is_ok();
 
     // If rustix_use_libc is set, or if we're on an architecture/OS that doesn't
     // have raw syscall support, use libc.
-    if var("CARGO_CFG_RUSTIX_USE_LIBC").is_ok()
+    if rustix_use_libc
         || os_name != "linux"
         || std::fs::metadata(&asm_name).is_err()
         || is_x32
         || is_arm64_ilp32
+        || is_powerpc64be
     {
         use_feature("libc");
     } else {
         use_feature("linux_raw");
         use_feature_or_nothing("core_intrinsics");
-        use_feature_or_else("asm", || {
+
+        // On PowerPC, Rust's inline asm is considered experimental, so only
+        // use it if `--cfg=rustix_use_experimental_asm` is given.
+        if has_feature("asm") && (arch != "powerpc64" || rustix_use_experimental_asm) {
+            use_feature("asm");
+            if rustix_use_experimental_asm {
+                use_feature("asm_experimental_arch");
+            }
+        } else {
             link_in_librustix_outline(&arch, &asm_name);
-        });
+        }
     }
     println!("cargo:rerun-if-env-changed=CARGO_CFG_RUSTIX_USE_LIBC");
+    println!("cargo:rerun-if-env-changed=CARGO_CFG_RUSTIX_USE_EXPERIMENTAL_ASM");
 }
 
 fn link_in_librustix_outline(arch: &str, asm_name: &str) {
@@ -101,14 +114,6 @@ fn use_feature_or_nothing(feature: &str) {
     }
 }
 
-fn use_feature_or_else<F: FnOnce()>(feature: &str, or_else: F) {
-    if has_feature(feature) {
-        use_feature(feature);
-    } else {
-        or_else();
-    }
-}
-
 fn use_feature(feature: &str) {
     println!("cargo:rustc-cfg={}", feature);
 }

src/imp/linux_raw/arch/inline/mod.rs

@@ -6,6 +6,8 @@
 mod aarch64;
 #[cfg(target_arch = "arm")]
 mod arm;
+#[cfg(target_arch = "powerpc64")]
+mod powerpc64;
 #[cfg(target_arch = "riscv64")]
 mod riscv64;
 #[cfg(target_arch = "x86")]
@@ -17,6 +19,8 @@ mod x86_64;
 pub(in crate::imp) use self::aarch64::*;
 #[cfg(target_arch = "arm")]
 pub(in crate::imp) use self::arm::*;
+#[cfg(target_arch = "powerpc64")]
+pub(in crate::imp) use self::powerpc64::*;
 #[cfg(target_arch = "riscv64")]
 pub(in crate::imp) use self::riscv64::*;
 #[cfg(target_arch = "x86")]