Probe for SOH symbols

Author: justsmth

.github/workflows/sys-bindings-generator.yml

@@ -278,16 +278,16 @@ jobs:
           AWS_LC_SYS_PREGENERATING_BINDINGS: "1"
         run: |
           cargo test -p aws-lc-sys --no-default-features --features bindgen
-      - name: Create bindings with the \u{1} stripped
+      - name: Create SOH-stripped bindings
         if: matrix.os == 'ubuntu-latest'
         working-directory: aws-lc-sys/src
         run: |
-          sed 's/#\[link_name = "\\u{1}aws_lc_/#[link_name = "aws_lc_/g' universal_crypto.rs > universal_no_u1_crypto.rs
-      - name: Create prefixed bindings with the \u{1} stripped
+          sed 's/#\[link_name = "\\u{1}aws_lc_/#[link_name = "aws_lc_/g' universal_crypto.rs > universal_no_soh_crypto.rs
+      - name: Create SOH-stripped prefixed bindings
         if: matrix.os == 'macos-latest'
         working-directory: aws-lc-sys/src
         run: |
-          sed 's/#\[link_name = "\\u{1}_aws_lc_/#[link_name = "aws_lc_/g' universal_prefixed_crypto.rs > universal_no_u1_prefixed_crypto.rs
+          sed 's/#\[link_name = "\\u{1}_aws_lc_/#[link_name = "aws_lc_/g' universal_prefixed_crypto.rs > universal_no_soh_prefixed_crypto.rs
       - name: Commit & Push changes
         run: ./scripts/ci/ci_add_commit_rebase_push.sh "Generated bindings from ${{ matrix.os }}"
   collect-src-and-commit:

.github/workflows/tests.yml

@@ -702,12 +702,12 @@ jobs:
       - name: Run tests
         run: cargo test -p aws-lc-rs --all-targets
 
-  build-env-no-u1-bindings-test:
+  build-env-no-soh-bindings-test:
     if: github.repository_owner == 'aws'
-    name: aws-lc-rs build-env-no-u1-bindings-test
+    name: aws-lc-rs build-env-no-soh-bindings-test
     runs-on: ${{ matrix.os }}
     env:
-      AWS_LC_SYS_NO_U1_BINDINGS: 1
+      AWS_LC_SYS_NO_SOH_BINDINGS: 1
     strategy:
       fail-fast: false
       matrix:
@@ -731,10 +731,6 @@ jobs:
     if: github.repository_owner == 'aws'
     name: aws-lc-rs cranelift-backend-test (${{ matrix.target }})
     runs-on: ${{ matrix.os }}
-    env:
-      # Cranelift requires panic=abort as it doesn't fully support unwinding.
-      # -Zpanic_abort_tests is required to run tests with panic=abort.
-      RUSTFLAGS: -Zcodegen-backend=cranelift -Cpanic=abort -Zpanic_abort_tests
     strategy:
       fail-fast: false
       matrix:
@@ -756,6 +752,25 @@ jobs:
           components: rustc-codegen-cranelift-preview
       - name: Set Rust toolchain override
         run: rustup override set ${{ steps.toolchain.outputs.name }}
+      - name: Configure Cranelift via .cargo/config.toml
+        shell: bash
+        run: |
+          mkdir -p .cargo
+          cat > .cargo/config.toml << 'EOF'
+          [unstable]
+          codegen-backend = true
+
+          [profile.dev]
+          codegen-backend = "cranelift"
+          panic = "abort"
+
+          [profile.test]
+          codegen-backend = "cranelift"
+          panic = "abort"
+
+          [build]
+          rustflags = ["-Zpanic_abort_tests"]
+          EOF
       - name: Remove other universal bindings
         shell: bash
         run: |

aws-lc-sys/builder/main.rs

@@ -266,22 +266,93 @@ fn target_has_prefixed_symbols() -> bool {
     target_vendor() == "apple" || (target_arch() == "x86" && target_os() == "windows")
 }
 
+/// Probes whether the current `rustc` and codegen backend supports the
+/// `\u{1}` prefix in `#[link_name]` attributes. This prefix is an
+/// LLVM-specific mechanism that instructs the backend to emit the symbol
+/// name verbatim (without platform-specific prefixes). Backends such as
+/// Cranelift do not support this.
+///
+/// Returns `true` if the `\u{1}` prefix is supported, `false` otherwise.
 #[cfg(not(feature = "all-bindings"))]
-fn is_cranelift_backend() -> bool {
-    // CARGO_ENCODED_RUSTFLAGS contains flags separated by 0x1f (ASCII Unit Separator)
-    if let Some(rustflags) = optional_env("CARGO_ENCODED_RUSTFLAGS") {
-        for flag in rustflags.split('\x1f') {
-            if flag.contains("codegen-backend=cranelift") {
-                return true;
+fn probe_soh_link_name_support() -> bool {
+    let probe_dir = out_dir();
+    let probe_src = probe_dir.join("probe_soh_link_name.rs");
+    let probe_out = probe_dir.join("probe_soh_link_name.o");
+
+    if std::fs::write(
+        &probe_src,
+        r#"
+extern "C" { #[link_name = "\u{1}probe_soh_prefix"] fn probe(); }
+pub fn force_codegen() { unsafe { probe() } }
+"#,
+    )
+    .is_err()
+    {
+        return false;
+    }
+
+    let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".to_string());
+
+    let mut cmd = Command::new(&rustc);
+    cmd.arg(&probe_src)
+        .arg("--target")
+        .arg(&target())
+        .arg("--crate-type")
+        .arg("lib")
+        .arg("--emit=obj")
+        .arg("-o")
+        .arg(&probe_out)
+        .arg("--edition=2021");
+
+    if let Ok(flags) = env::var("CARGO_ENCODED_RUSTFLAGS") {
+        for flag in flags.split('\x1f') {
+            if !flag.is_empty() {
+                cmd.arg(flag);
             }
         }
     }
-    false
+
+    let compiled = cmd.status().map(|s| s.success()).unwrap_or(false);
+    if !compiled {
+        return false;
+    }
+
+    // Read the object file and verify the SOH byte was actually stripped.
+    // If the backend supports the \u{1} convention (LLVM), the object file
+    // will contain the symbol "probe_soh_prefix" without a leading \x01.
+    // If the backend does NOT support it (Cranelift), the object file will
+    // contain "\x01probe_soh_prefix" — the SOH byte preserved literally.
+    match std::fs::read(&probe_out) {
+        Ok(bytes) => {
+            let marker = b"probe_soh_prefix";
+            // Search for every occurrence of the marker string in the object file.
+            // If ANY occurrence is preceded by the SOH byte, the backend did not
+            // strip it, so we report no support.
+            let mut i = 0;
+            let mut found = false;
+            while i + marker.len() <= bytes.len() {
+                if &bytes[i..i + marker.len()] == marker {
+                    found = true;
+                    if i > 0 && bytes[i - 1] == b'\x01' {
+                        // SOH byte still present — backend doesn't strip it.
+                        return false;
+                    }
+                    i += marker.len();
+                } else {
+                    i += 1;
+                }
+            }
+            // The marker string should appear at least once (as an undefined symbol
+            // reference). If it doesn't, something unexpected happened.
+            found
+        }
+        Err(_) => false,
+    }
 }
 
 #[cfg(not(feature = "all-bindings"))]
-fn target_chokes_on_u1() -> bool {
-    target_arch() == "mips" || target_arch() == "mips64" || is_cranelift_backend()
+fn target_chokes_on_soh() -> bool {
+    target_arch() == "mips" || target_arch() == "mips64" || !probe_soh_link_name_support()
 }
 
 #[cfg(all(feature = "bindgen", not(feature = "all-bindings")))]
@@ -509,7 +580,7 @@ static mut AWS_LC_SYS_CMAKE_BUILDER: Option<bool> = None;
 static mut AWS_LC_SYS_NO_PREGENERATED_SRC: bool = false;
 static mut AWS_LC_SYS_EFFECTIVE_TARGET: String = String::new();
 static mut AWS_LC_SYS_NO_JITTER_ENTROPY: Option<bool> = None;
-static mut AWS_LC_SYS_NO_U1_BINDINGS: Option<bool> = None;
+static mut AWS_LC_SYS_NO_SOH_BINDINGS: Option<bool> = None;
 
 static mut AWS_LC_SYS_C_STD: CStdRequested = CStdRequested::None;
 
@@ -528,7 +599,7 @@ fn initialize() {
         AWS_LC_SYS_EFFECTIVE_TARGET =
             optional_env_crate_target("EFFECTIVE_TARGET").unwrap_or_default();
         AWS_LC_SYS_NO_JITTER_ENTROPY = env_crate_var_to_bool("NO_JITTER_ENTROPY");
-        AWS_LC_SYS_NO_U1_BINDINGS = env_crate_var_to_bool("NO_U1_BINDINGS");
+        AWS_LC_SYS_NO_SOH_BINDINGS = env_crate_var_to_bool("NO_SOH_BINDINGS");
     }
 
     if !is_external_bindgen_requested().unwrap_or(false)
@@ -537,7 +608,7 @@ fn initialize() {
         #[cfg(feature = "all-bindings")]
         {
             assert!(
-                use_no_u1_bindings() != Some(true),
+                use_no_soh_bindings() != Some(true),
                 "Bindgen currently cannot generate prefixed bindings w/o the \\x01 prefix.",
             );
             let target = effective_target();
@@ -566,18 +637,18 @@ fn initialize() {
         }
         #[cfg(not(feature = "all-bindings"))]
         {
-            if use_no_u1_bindings() == Some(true)
-                || (target_chokes_on_u1() && use_no_u1_bindings().is_none())
+            if use_no_soh_bindings() == Some(true)
+                || (target_chokes_on_soh() && use_no_soh_bindings().is_none())
             {
-                if is_cranelift_backend() {
+                if !probe_soh_link_name_support() {
                     emit_warning(
-                        "Cranelift codegen backend detected. Using universal_no_u1 bindings.",
+                        "Codegen backend does not support the \\u{1} link_name prefix. Using universal_no_soh bindings.",
                     );
                 }
                 if target_has_prefixed_symbols() {
-                    emit_rustc_cfg("universal-no-u1-prefixed");
+                    emit_rustc_cfg("universal-no-soh-prefixed");
                 } else {
-                    emit_rustc_cfg("universal-no-u1");
+                    emit_rustc_cfg("universal-no-soh");
                 }
             } else if target_has_prefixed_symbols() {
                 emit_rustc_cfg("universal-prefixed");
@@ -638,8 +709,8 @@ fn disable_jitter_entropy() -> Option<bool> {
     unsafe { AWS_LC_SYS_NO_JITTER_ENTROPY }
 }
 
-fn use_no_u1_bindings() -> Option<bool> {
-    unsafe { AWS_LC_SYS_NO_U1_BINDINGS }
+fn use_no_soh_bindings() -> Option<bool> {
+    unsafe { AWS_LC_SYS_NO_SOH_BINDINGS }
 }
 
 fn get_crate_cc() -> Option<String> {
@@ -711,8 +782,8 @@ fn prepare_cargo_cfg() {
         println!("cargo:rustc-check-cfg=cfg(x86_64_unknown_linux_gnu)");
         println!("cargo:rustc-check-cfg=cfg(x86_64_unknown_linux_musl)");
         println!("cargo:rustc-check-cfg=cfg(universal)");
-        println!("cargo:rustc-check-cfg=cfg(universal_no_u1)");
-        println!("cargo:rustc-check-cfg=cfg(universal_no_u1_prefixed)");
+        println!("cargo:rustc-check-cfg=cfg(universal_no_soh)");
+        println!("cargo:rustc-check-cfg=cfg(universal_no_soh_prefixed)");
         println!("cargo:rustc-check-cfg=cfg(universal_prefixed)");
     }
 }

aws-lc-sys/src/lib.rs

@@ -20,8 +20,8 @@ macro_rules! platform_binding {
 }
 
 platform_binding!(universal_prefixed, universal_prefixed_crypto);
-platform_binding!(universal_no_u1_prefixed, universal_no_u1_prefixed_crypto);
-platform_binding!(universal_no_u1, universal_no_u1_crypto);
+platform_binding!(universal_no_soh_prefixed, universal_no_soh_prefixed_crypto);
+platform_binding!(universal_no_soh, universal_no_soh_crypto);
 platform_binding!(universal, universal_crypto);
 
 platform_binding!(aarch64_linux_android, aarch64_linux_android_crypto);

aws-lc-sys/src/universal_no_u1_crypto.rs aws-lc-sys/src/universal_no_soh_crypto.rsaws-lc-sys/src/universal_no_u1_crypto.rs renamed to aws-lc-sys/src/universal_no_soh_crypto.rs

@@ -67,9 +67,9 @@ The target-specific variant takes precedence when both are set.
   it contains. This may be useful in certain linking scenarios but can cause symbol conflicts
   if multiple versions are linked.
 
-* **`AWS_LC_SYS_NO_U1_BINDINGS`**
+* **`AWS_LC_SYS_NO_SOH_BINDINGS`**
 
-  When set to `1`, uses bindings that don't include the `\x01` prefix on symbol names.
+  When set to `1`, uses bindings that don't include the `\x01` (SOH) prefix on symbol names.
   This is automatically enabled for certain backends (like Cranelift) and architectures
   (like MIPS) that don't support the prefixed symbols.