Use portable-atomic and remove our own logic for now

Adopt the third idea of #573 (comment).

.github/workflows/ci.yml

@@ -113,40 +113,23 @@ jobs:
 
   # Build for no_std environment.
   no-std:
-    strategy:
-      fail-fast: false
-      matrix:
-        # thumbv7m-none-eabi supports atomic CAS.
-        # thumbv6m-none-eabi supports atomic, but not atomic CAS.
-        # riscv32i-unknown-none-elf does not support atomic at all.
-        target:
-          - thumbv7m-none-eabi
-          - thumbv6m-none-eabi
-          - riscv32i-unknown-none-elf
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - name: Install Rust
         run: rustup update stable
       - name: Install cargo-hack
         run: cargo install cargo-hack
-      - run: rustup target add ${{ matrix.target }}
-        # * --optional-deps is needed for serde feature
-        # * --no-dev-deps is needed to avoid https://github.com/rust-lang/cargo/issues/4866
-      - run: cargo hack build --target ${{ matrix.target }} --feature-powerset --skip std,default --optional-deps --no-dev-deps
-
-  # When this job failed, run ci/no_atomic_cas.sh and commit result changes.
-  # TODO(taiki-e): Ideally, this should be automated using a bot that creates
-  #                PR when failed, but there is no bandwidth to implement it
-  #                right now...
-  codegen:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust
-        run: rustup update nightly && rustup default nightly
-      - run: ci/no_atomic_cas.sh
-      - run: git diff --exit-code
+      # thumbv7m-none-eabi supports atomic CAS.
+      # thumbv6m-none-eabi supports atomic, but not atomic CAS.
+      - run: rustup target add thumbv7m-none-eabi
+      - run: rustup target add thumbv6m-none-eabi
+      # * --optional-deps is needed for serde feature
+      # * --no-dev-deps is needed to avoid https://github.com/rust-lang/cargo/issues/4866
+      - run: cargo hack build --target thumbv7m-none-eabi --feature-powerset --skip std,default --optional-deps --no-dev-deps
+      # A sound way to provide atomic CAS on platforms without native atomic CAS is system-dependent.
+      # portable-atomic provides major ways via cfgs and accepts user-defined implementations via critical-section features.
+      - run: cargo hack build --target thumbv6m-none-eabi --feature-powerset --skip std,default --optional-deps --no-dev-deps --features extra-platforms,portable-atomic/critical-section
 
   # Sanitizers
   tsan:

Cargo.toml

@@ -20,9 +20,13 @@ edition = "2018"
 [features]
 default = ["std"]
 std = []
+# Use portable-atomic crate to support platforms without atomic CAS.
+# See https://docs.rs/portable-atomic for more information.
+extra-platforms = ["portable-atomic"]
 
 [dependencies]
 serde = { version = "1.0.60", optional = true, default-features = false, features = ["alloc"] }
+portable-atomic = { version = "1", optional = true, default-features = false }
 
 [dev-dependencies]
 serde_test = "1.0"

src/buf/buf_impl.rs

@@ -1100,7 +1100,6 @@ pub trait Buf {
     /// let bytes = (&b"hello world"[..]).copy_to_bytes(5);
     /// assert_eq!(&bytes[..], &b"hello"[..]);
     /// ```
-    #[cfg(not(bytes_no_atomic_cas))]
     fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
         use super::BufMut;
 
@@ -1325,7 +1324,6 @@ macro_rules! deref_forward_buf {
             (**self).get_int_ne(nbytes)
         }
 
-        #[cfg(not(bytes_no_atomic_cas))]
         fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
             (**self).copy_to_bytes(len)
         }

src/buf/chain.rs

@@ -171,7 +171,6 @@ where
         n
     }
 
-    #[cfg(not(bytes_no_atomic_cas))]
     fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
         let a_rem = self.a.remaining();
         if a_rem >= len {

src/buf/take.rs

@@ -145,7 +145,6 @@ impl<T: Buf> Buf for Take<T> {
         self.limit -= cnt;
     }
 
-    #[cfg(not(bytes_no_atomic_cas))]
     fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
         assert!(len <= self.remaining(), "`len` greater than remaining");
 

src/lib.rs

@@ -84,24 +84,17 @@ extern crate std;
 pub mod buf;
 pub use crate::buf::{Buf, BufMut};
 
-#[cfg(not(bytes_no_atomic_cas))]
 mod bytes;
-#[cfg(not(bytes_no_atomic_cas))]
 mod bytes_mut;
-#[cfg(not(bytes_no_atomic_cas))]
 mod fmt;
 mod loom;
-#[cfg(not(bytes_no_atomic_cas))]
 pub use crate::bytes::Bytes;
-#[cfg(not(bytes_no_atomic_cas))]
 pub use crate::bytes_mut::BytesMut;
 
 // Optional Serde support
-#[cfg(not(bytes_no_atomic_cas))]
 #[cfg(feature = "serde")]
 mod serde;
 
-#[cfg(not(bytes_no_atomic_cas))]
 #[inline(never)]
 #[cold]
 fn abort() -> ! {

src/loom.rs

@@ -2,9 +2,11 @@
 
 #[cfg(not(all(test, loom)))]
 pub(crate) mod sync {
-    #[cfg(not(bytes_no_atomic_cas))]
     pub(crate) mod atomic {
+        #[cfg(not(feature = "extra-platforms"))]
         pub(crate) use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
+        #[cfg(feature = "extra-platforms")]
+        pub(crate) use portable_atomic::{AtomicPtr, AtomicUsize, Ordering};
 
         pub(crate) trait AtomicMut<T> {
             fn with_mut<F, R>(&mut self, f: F) -> R