Add target u32/u64 backend override

As suggested in 453 it is sometimes feasible to
select the backend bits via an override.

This change provides an override via `cfg(dalek_bits)`
to override the used serial or fiat target backend.

.github/workflows/rust.yml

@@ -115,4 +115,7 @@ jobs:
     - uses: actions/checkout@v3
     - uses: dtolnay/rust-toolchain@stable
     # This filter selects no benchmarks, so we don't run any, only build them.
-    - run: cargo bench "nonexistentbenchmark"
+    - name: Build u32 bench
+      run: env RUSTFLAGS="--cfg dalek_bits=\"32\"" cargo bench "nonexistentbenchmark"
+    - name: Build u64 bench
+      run: env RUSTFLAGS="--cfg dalek_bits=\"64\"" cargo bench "nonexistentbenchmark"

CHANGELOG.md

@@ -5,6 +5,7 @@ major series.
 
 ## 4.x series
 
+* Add target u32/u64 backend overrides
 * Migrate documentation to docs.rs hosted
 * Fix backend documentation generation
 * Deprecate `EdwardsPoint::hash_from_bytes` and rename it `EdwardsPoint::nonspect_map_to_curve`

src/backend/serial/mod.rs

@@ -21,18 +21,23 @@
 use cfg_if::cfg_if;
 
 cfg_if! {
+
     if #[cfg(feature = "fiat_backend")] {
-        #[cfg(not(target_pointer_width = "64"))]
+
+        #[cfg(dalek_bits = "32")]
         pub mod fiat_u32;
 
-        #[cfg(target_pointer_width = "64")]
+        #[cfg(dalek_bits = "64")]
         pub mod fiat_u64;
+
     } else {
-        #[cfg(not(target_pointer_width = "64"))]
+
+        #[cfg(dalek_bits = "32")]
         pub mod u32;
 
-        #[cfg(target_pointer_width = "64")]
+        #[cfg(dalek_bits = "64")]
         pub mod u64;
+
     }
 }
 

src/constants.rs

@@ -38,14 +38,14 @@ use crate::scalar::Scalar;
 
 cfg_if! {
     if #[cfg(feature = "fiat_backend")] {
-        #[cfg(not(target_pointer_width = "64"))]
+        #[cfg(dalek_bits = "32")]
         pub use crate::backend::serial::fiat_u32::constants::*;
-        #[cfg(target_pointer_width = "64")]
+        #[cfg(dalek_bits = "64")]
         pub use crate::backend::serial::fiat_u64::constants::*;
     } else {
-        #[cfg(not(target_pointer_width = "64"))]
+        #[cfg(dalek_bits = "32")]
         pub use crate::backend::serial::u32::constants::*;
-        #[cfg(target_pointer_width = "64")]
+        #[cfg(dalek_bits = "64")]
         pub use crate::backend::serial::u64::constants::*;
     }
 }
@@ -149,7 +149,7 @@ mod test {
 
     /// Test that d = -121665/121666
     #[test]
-    #[cfg(all(not(target_pointer_width = "64"), not(feature = "fiat_backend")))]
+    #[cfg(all(dalek_bits = "32", not(feature = "fiat_backend")))]
     fn test_d_vs_ratio() {
         use crate::backend::serial::u32::field::FieldElement2625;
         let a = -&FieldElement2625([121665, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
@@ -162,7 +162,7 @@ mod test {
 
     /// Test that d = -121665/121666
     #[test]
-    #[cfg(all(target_pointer_width = "64", not(feature = "fiat_backend")))]
+    #[cfg(all(dalek_bits = "64", not(feature = "fiat_backend")))]
     fn test_d_vs_ratio() {
         use crate::backend::serial::u64::field::FieldElement51;
         let a = -&FieldElement51([121665, 0, 0, 0, 0]);

src/field.rs

@@ -37,9 +37,9 @@ use crate::constants;
 
 cfg_if! {
     if #[cfg(feature = "fiat_backend")] {
-        #[cfg(not(target_pointer_width = "64"))]
+        #[cfg(dalek_bits = "32")]
         pub use backend::serial::fiat_u32::field::*;
-        #[cfg(target_pointer_width = "64")]
+        #[cfg(dalek_bits = "64")]
         pub use backend::serial::fiat_u64::field::*;
 
         /// A `FieldElement` represents an element of the field
@@ -49,7 +49,7 @@ cfg_if! {
         /// implementations.
         ///
         /// Using formally-verified field arithmetic from fiat-crypto.
-        #[cfg(not(target_pointer_width = "64"))]
+        #[cfg(dalek_bits = "32")]
         pub type FieldElement = backend::serial::fiat_u32::field::FieldElement2625;
 
         /// A `FieldElement` represents an element of the field
@@ -59,9 +59,9 @@ cfg_if! {
         /// implementations.
         ///
         /// Using formally-verified field arithmetic from fiat-crypto.
-        #[cfg(target_pointer_width = "64")]
+        #[cfg(dalek_bits = "64")]
         pub type FieldElement = backend::serial::fiat_u64::field::FieldElement51;
-    } else if #[cfg(target_pointer_width = "64")] {
+    } else if #[cfg(dalek_bits = "64")] {
         pub use crate::backend::serial::u64::field::*;
 
         /// A `FieldElement` represents an element of the field

src/lib.rs

@@ -22,6 +22,23 @@
 )]
 #![doc(html_root_url = "https://docs.rs/curve25519-dalek/4.0.0-pre.2")]
 #![doc = include_str!("../README.md")]
+//------------------------------------------------------------------------
+// curve25519-dalek arithmetric default and overrides
+//------------------------------------------------------------------------
+#![cfg_attr(
+    any(
+        all(not(target_pointer_width = "64"), not(dalek_bits = "64")),
+        dalek_bits = "32"
+    ),
+    cfg(dalek_bits = "32")
+)]
+#![cfg_attr(
+    any(
+        all(target_pointer_width = "64", not(dalek_bits = "32")),
+        dalek_bits = "64"
+    ),
+    cfg(dalek_bits = "64")
+)]
 
 //------------------------------------------------------------------------
 // External dependencies:

src/scalar.rs

@@ -172,36 +172,36 @@ cfg_if! {
         ///
         /// This is a type alias for one of the scalar types in the `backend`
         /// module.
-        #[cfg(not(target_pointer_width = "64"))]
+        #[cfg(dalek_bits = "32")]
         #[cfg_attr(
             docsrs,
-            doc(cfg(all(feature = "fiat_backend", not(target_pointer_width = "64"))))
+            doc(cfg(all(feature = "fiat_backend", dalek_bits = "32")))
         )]
         type UnpackedScalar = backend::serial::fiat_u32::scalar::Scalar29;
 
         /// An `UnpackedScalar` represents an element of the field GF(l), optimized for speed.
         ///
         /// This is a type alias for one of the scalar types in the `backend`
         /// module.
-        #[cfg(target_pointer_width = "64")]
+        #[cfg(dalek_bits = "64")]
         #[cfg_attr(
             docsrs,
-            doc(cfg(all(feature = "fiat_backend", target_pointer_width = "64")))
+            doc(cfg(all(feature = "fiat_backend", dalek_bits = "64")))
         )]
         type UnpackedScalar = backend::serial::fiat_u64::scalar::Scalar52;
-    } else if #[cfg(target_pointer_width = "64")] {
+    } else if #[cfg(dalek_bits = "64")] {
         /// An `UnpackedScalar` represents an element of the field GF(l), optimized for speed.
         ///
         /// This is a type alias for one of the scalar types in the `backend`
         /// module.
-        #[cfg_attr(docsrs, doc(cfg(target_pointer_width = "64")))]
+        #[cfg_attr(docsrs, doc(cfg(dalek_bits = "64")))]
         type UnpackedScalar = backend::serial::u64::scalar::Scalar52;
     } else {
         /// An `UnpackedScalar` represents an element of the field GF(l), optimized for speed.
         ///
         /// This is a type alias for one of the scalar types in the `backend`
         /// module.
-        #[cfg_attr(docsrs, doc(cfg(not(target_pointer_width = "64"))))]
+        #[cfg_attr(docsrs, doc(cfg(dalek_bits = "64")))]
         type UnpackedScalar = backend::serial::u32::scalar::Scalar29;
     }
 }