cmov: use #[inline] instead of #[inline(always)] (#924)

brxken128 · web-flow · commit 602240f1068d · 2023-07-08T10:30:26.000-06:00
diff --git a/cmov/src/aarch64.rs b/cmov/src/aarch64.rs
@@ -40,72 +40,72 @@ macro_rules! csel_eq {
 }
 
 impl Cmov for u16 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         csel!("csel {1:w}, {2:w}, {3:w}, NE", self, value, condition);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         csel!("csel {1:w}, {2:w}, {3:w}, EQ", self, value, condition);
     }
 }
 
 impl CmovEq for u16 {
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         csel_eq!("csel {3:w}, {4:w}, {5:w}, NE", self, rhs, input, output);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         csel_eq!("csel {3:w}, {4:w}, {5:w}, EQ", self, rhs, input, output);
     }
 }
 
 impl Cmov for u32 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         csel!("csel {1:w}, {2:w}, {3:w}, NE", self, value, condition);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         csel!("csel {1:w}, {2:w}, {3:w}, EQ", self, value, condition);
     }
 }
 
 impl CmovEq for u32 {
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         csel_eq!("csel {3:w}, {4:w}, {5:w}, NE", self, rhs, input, output);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         csel_eq!("csel {3:w}, {4:w}, {5:w}, EQ", self, rhs, input, output);
     }
 }
 
 impl Cmov for u64 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         csel!("csel {1:x}, {2:x}, {3:x}, NE", self, value, condition);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         csel!("csel {1:x}, {2:x}, {3:x}, EQ", self, value, condition);
     }
 }
 
 impl CmovEq for u64 {
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         csel_eq!("csel {3:w}, {4:w}, {5:w}, NE", self, rhs, input, output);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         csel_eq!("csel {3:w}, {4:w}, {5:w}, EQ", self, rhs, input, output);
     }
diff --git a/cmov/src/lib.rs b/cmov/src/lib.rs
@@ -60,14 +60,14 @@ pub trait CmovEq {
 }
 
 impl Cmov for u8 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         let mut tmp = *self as u16;
         tmp.cmovnz(&(*value as u16), condition);
         *self = tmp as u8;
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         let mut tmp = *self as u16;
         tmp.cmovz(&(*value as u16), condition);
@@ -76,19 +76,19 @@ impl Cmov for u8 {
 }
 
 impl CmovEq for u8 {
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         (*self as u16).cmoveq(&(*rhs as u16), input, output);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         (*self as u16).cmovne(&(*rhs as u16), input, output);
     }
 }
 
 impl Cmov for u128 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         let mut lo = (*self & u64::MAX as u128) as u64;
         let mut hi = (*self >> 64) as u64;
@@ -99,7 +99,7 @@ impl Cmov for u128 {
         *self = (lo as u128) | (hi as u128) << 64;
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         let mut lo = (*self & u64::MAX as u128) as u64;
         let mut hi = (*self >> 64) as u64;
@@ -112,7 +112,7 @@ impl Cmov for u128 {
 }
 
 impl CmovEq for u128 {
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         let lo = (*self & u64::MAX as u128) as u64;
         let hi = (*self >> 64) as u64;
@@ -123,7 +123,7 @@ impl CmovEq for u128 {
         tmp.cmoveq(&0, input, output);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         let lo = (*self & u64::MAX as u128) as u64;
         let hi = (*self >> 64) as u64;
diff --git a/cmov/src/portable.rs b/cmov/src/portable.rs
@@ -9,14 +9,14 @@
 use crate::{Cmov, CmovEq, Condition};
 
 impl Cmov for u16 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         let mut tmp = *self as u64;
         tmp.cmovnz(&(*value as u64), condition);
         *self = tmp as u16;
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         let mut tmp = *self as u64;
         tmp.cmovz(&(*value as u64), condition);
@@ -25,26 +25,26 @@ impl Cmov for u16 {
 }
 
 impl CmovEq for u16 {
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         (*self as u64).cmovne(&(*rhs as u64), input, output);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         (*self as u64).cmoveq(&(*rhs as u64), input, output);
     }
 }
 
 impl Cmov for u32 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         let mut tmp = *self as u64;
         tmp.cmovnz(&(*value as u64), condition);
         *self = tmp as u32;
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         let mut tmp = *self as u64;
         tmp.cmovz(&(*value as u64), condition);
@@ -53,38 +53,38 @@ impl Cmov for u32 {
 }
 
 impl CmovEq for u32 {
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         (*self as u64).cmovne(&(*rhs as u64), input, output);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         (*self as u64).cmoveq(&(*rhs as u64), input, output);
     }
 }
 
 impl Cmov for u64 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         let mask = is_non_zero(condition).wrapping_sub(1);
         *self = (*self & mask) | (*value & !mask);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         let mask = (1 ^ is_non_zero(condition)).wrapping_sub(1);
         *self = (*self & mask) | (*value & !mask);
     }
 }
 
 impl CmovEq for u64 {
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         output.cmovnz(&input, (self ^ rhs) as u8);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         output.cmovz(&input, (self ^ rhs) as u8);
     }
@@ -95,7 +95,7 @@ impl CmovEq for u64 {
 /// # Returns
 /// - `condition` is zero: `0`
 /// - `condition` is non-zero: `1`
-#[inline(always)]
+#[inline]
 fn is_non_zero(condition: Condition) -> u64 {
     const SHIFT_BITS: usize = core::mem::size_of::<u64>() - 1;
     let condition = condition as u64;
diff --git a/cmov/src/x86.rs b/cmov/src/x86.rs
@@ -26,56 +26,56 @@ macro_rules! cmov {
 }
 
 impl Cmov for u16 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         cmov!("cmovnz {1:e}, {2:e}", self, value, condition);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         cmov!("cmovz {1:e}, {2:e}", self, value, condition);
     }
 }
 
 impl CmovEq for u16 {
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         output.cmovz(&input, (self ^ rhs) as u8);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         output.cmovnz(&input, (self ^ rhs) as u8);
     }
 }
 
 impl Cmov for u32 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         cmov!("cmovnz {1:e}, {2:e}", self, value, condition);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         cmov!("cmovz {1:e}, {2:e}", self, value, condition);
     }
 }
 
 impl CmovEq for u32 {
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         output.cmovz(&input, (self ^ rhs) as u8);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         output.cmovnz(&input, (self ^ rhs) as u8);
     }
 }
 
 #[cfg(target_arch = "x86")]
 impl Cmov for u64 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         let mut lo = (*self & u32::MAX as u64) as u32;
         let mut hi = (*self >> 32) as u32;
@@ -86,7 +86,7 @@ impl Cmov for u64 {
         *self = (lo as u64) | (hi as u64) << 32;
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         let mut lo = (*self & u32::MAX as u64) as u32;
         let mut hi = (*self >> 32) as u32;
@@ -100,7 +100,7 @@ impl Cmov for u64 {
 
 #[cfg(target_arch = "x86")]
 impl CmovEq for u64 {
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         let lo = (*self & u32::MAX as u64) as u32;
         let hi = (*self >> 32) as u32;
@@ -111,7 +111,7 @@ impl CmovEq for u64 {
         tmp.cmoveq(&0, input, output);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         let lo = (*self & u32::MAX as u64) as u32;
         let hi = (*self >> 32) as u32;
@@ -125,25 +125,25 @@ impl CmovEq for u64 {
 
 #[cfg(target_arch = "x86_64")]
 impl Cmov for u64 {
-    #[inline(always)]
+    #[inline]
     fn cmovnz(&mut self, value: &Self, condition: Condition) {
         cmov!("cmovnz {1:r}, {2:r}", self, value, condition);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovz(&mut self, value: &Self, condition: Condition) {
         cmov!("cmovz {1:r}, {2:r}", self, value, condition);
     }
 }
 
 #[cfg(target_arch = "x86_64")]
 impl CmovEq for u64 {
-    #[inline(always)]
+    #[inline]
     fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         output.cmovz(&input, (self ^ rhs) as u8);
     }
 
-    #[inline(always)]
+    #[inline]
     fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {
         output.cmovnz(&input, (self ^ rhs) as u8);
     }

Original file line number	Diff line number	Diff line change
`@@ -40,72 +40,72 @@ macro_rules! csel_eq {`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`impl Cmov for u16 {`
`43`		`- #[inline(always)]`
	`43`	`+ #[inline]`
`44`	`44`	`fn cmovnz(&mut self, value: &Self, condition: Condition) {`
`45`	`45`	`csel!("csel {1:w}, {2:w}, {3:w}, NE", self, value, condition);`
`46`	`46`	`}`
`47`	`47`
`48`		`- #[inline(always)]`
	`48`	`+ #[inline]`
`49`	`49`	`fn cmovz(&mut self, value: &Self, condition: Condition) {`
`50`	`50`	`csel!("csel {1:w}, {2:w}, {3:w}, EQ", self, value, condition);`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`impl CmovEq for u16 {`
`55`		`- #[inline(always)]`
	`55`	`+ #[inline]`
`56`	`56`	`fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`57`	`57`	`csel_eq!("csel {3:w}, {4:w}, {5:w}, NE", self, rhs, input, output);`
`58`	`58`	`}`
`59`	`59`
`60`		`- #[inline(always)]`
	`60`	`+ #[inline]`
`61`	`61`	`fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`62`	`62`	`csel_eq!("csel {3:w}, {4:w}, {5:w}, EQ", self, rhs, input, output);`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`impl Cmov for u32 {`
`67`		`- #[inline(always)]`
	`67`	`+ #[inline]`
`68`	`68`	`fn cmovnz(&mut self, value: &Self, condition: Condition) {`
`69`	`69`	`csel!("csel {1:w}, {2:w}, {3:w}, NE", self, value, condition);`
`70`	`70`	`}`
`71`	`71`
`72`		`- #[inline(always)]`
	`72`	`+ #[inline]`
`73`	`73`	`fn cmovz(&mut self, value: &Self, condition: Condition) {`
`74`	`74`	`csel!("csel {1:w}, {2:w}, {3:w}, EQ", self, value, condition);`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`impl CmovEq for u32 {`
`79`		`- #[inline(always)]`
	`79`	`+ #[inline]`
`80`	`80`	`fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`81`	`81`	`csel_eq!("csel {3:w}, {4:w}, {5:w}, NE", self, rhs, input, output);`
`82`	`82`	`}`
`83`	`83`
`84`		`- #[inline(always)]`
	`84`	`+ #[inline]`
`85`	`85`	`fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`86`	`86`	`csel_eq!("csel {3:w}, {4:w}, {5:w}, EQ", self, rhs, input, output);`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`impl Cmov for u64 {`
`91`		`- #[inline(always)]`
	`91`	`+ #[inline]`
`92`	`92`	`fn cmovnz(&mut self, value: &Self, condition: Condition) {`
`93`	`93`	`csel!("csel {1:x}, {2:x}, {3:x}, NE", self, value, condition);`
`94`	`94`	`}`
`95`	`95`
`96`		`- #[inline(always)]`
	`96`	`+ #[inline]`
`97`	`97`	`fn cmovz(&mut self, value: &Self, condition: Condition) {`
`98`	`98`	`csel!("csel {1:x}, {2:x}, {3:x}, EQ", self, value, condition);`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`impl CmovEq for u64 {`
`103`		`- #[inline(always)]`
	`103`	`+ #[inline]`
`104`	`104`	`fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`105`	`105`	`csel_eq!("csel {3:w}, {4:w}, {5:w}, NE", self, rhs, input, output);`
`106`	`106`	`}`
`107`	`107`
`108`		`- #[inline(always)]`
	`108`	`+ #[inline]`
`109`	`109`	`fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`110`	`110`	`csel_eq!("csel {3:w}, {4:w}, {5:w}, EQ", self, rhs, input, output);`
`111`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,56 +26,56 @@ macro_rules! cmov {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`impl Cmov for u16 {`
`29`		`- #[inline(always)]`
	`29`	`+ #[inline]`
`30`	`30`	`fn cmovnz(&mut self, value: &Self, condition: Condition) {`
`31`	`31`	`cmov!("cmovnz {1:e}, {2:e}", self, value, condition);`
`32`	`32`	`}`
`33`	`33`
`34`		`- #[inline(always)]`
	`34`	`+ #[inline]`
`35`	`35`	`fn cmovz(&mut self, value: &Self, condition: Condition) {`
`36`	`36`	`cmov!("cmovz {1:e}, {2:e}", self, value, condition);`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`impl CmovEq for u16 {`
`41`		`- #[inline(always)]`
	`41`	`+ #[inline]`
`42`	`42`	`fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`43`	`43`	`output.cmovz(&input, (self ^ rhs) as u8);`
`44`	`44`	`}`
`45`	`45`
`46`		`- #[inline(always)]`
	`46`	`+ #[inline]`
`47`	`47`	`fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`48`	`48`	`output.cmovnz(&input, (self ^ rhs) as u8);`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`impl Cmov for u32 {`
`53`		`- #[inline(always)]`
	`53`	`+ #[inline]`
`54`	`54`	`fn cmovnz(&mut self, value: &Self, condition: Condition) {`
`55`	`55`	`cmov!("cmovnz {1:e}, {2:e}", self, value, condition);`
`56`	`56`	`}`
`57`	`57`
`58`		`- #[inline(always)]`
	`58`	`+ #[inline]`
`59`	`59`	`fn cmovz(&mut self, value: &Self, condition: Condition) {`
`60`	`60`	`cmov!("cmovz {1:e}, {2:e}", self, value, condition);`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`impl CmovEq for u32 {`
`65`		`- #[inline(always)]`
	`65`	`+ #[inline]`
`66`	`66`	`fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`67`	`67`	`output.cmovz(&input, (self ^ rhs) as u8);`
`68`	`68`	`}`
`69`	`69`
`70`		`- #[inline(always)]`
	`70`	`+ #[inline]`
`71`	`71`	`fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`72`	`72`	`output.cmovnz(&input, (self ^ rhs) as u8);`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`#[cfg(target_arch = "x86")]`
`77`	`77`	`impl Cmov for u64 {`
`78`		`- #[inline(always)]`
	`78`	`+ #[inline]`
`79`	`79`	`fn cmovnz(&mut self, value: &Self, condition: Condition) {`
`80`	`80`	`let mut lo = (*self & u32::MAX as u64) as u32;`
`81`	`81`	`let mut hi = (*self >> 32) as u32;`
`@@ -86,7 +86,7 @@ impl Cmov for u64 {`
`86`	`86`	`*self = (lo as u64) \| (hi as u64) << 32;`
`87`	`87`	`}`
`88`	`88`
`89`		`- #[inline(always)]`
	`89`	`+ #[inline]`
`90`	`90`	`fn cmovz(&mut self, value: &Self, condition: Condition) {`
`91`	`91`	`let mut lo = (*self & u32::MAX as u64) as u32;`
`92`	`92`	`let mut hi = (*self >> 32) as u32;`
`@@ -100,7 +100,7 @@ impl Cmov for u64 {`
`100`	`100`
`101`	`101`	`#[cfg(target_arch = "x86")]`
`102`	`102`	`impl CmovEq for u64 {`
`103`		`- #[inline(always)]`
	`103`	`+ #[inline]`
`104`	`104`	`fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`105`	`105`	`let lo = (*self & u32::MAX as u64) as u32;`
`106`	`106`	`let hi = (*self >> 32) as u32;`
`@@ -111,7 +111,7 @@ impl CmovEq for u64 {`
`111`	`111`	`tmp.cmoveq(&0, input, output);`
`112`	`112`	`}`
`113`	`113`
`114`		`- #[inline(always)]`
	`114`	`+ #[inline]`
`115`	`115`	`fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`116`	`116`	`let lo = (*self & u32::MAX as u64) as u32;`
`117`	`117`	`let hi = (*self >> 32) as u32;`
`@@ -125,25 +125,25 @@ impl CmovEq for u64 {`
`125`	`125`
`126`	`126`	`#[cfg(target_arch = "x86_64")]`
`127`	`127`	`impl Cmov for u64 {`
`128`		`- #[inline(always)]`
	`128`	`+ #[inline]`
`129`	`129`	`fn cmovnz(&mut self, value: &Self, condition: Condition) {`
`130`	`130`	`cmov!("cmovnz {1:r}, {2:r}", self, value, condition);`
`131`	`131`	`}`
`132`	`132`
`133`		`- #[inline(always)]`
	`133`	`+ #[inline]`
`134`	`134`	`fn cmovz(&mut self, value: &Self, condition: Condition) {`
`135`	`135`	`cmov!("cmovz {1:r}, {2:r}", self, value, condition);`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`#[cfg(target_arch = "x86_64")]`
`140`	`140`	`impl CmovEq for u64 {`
`141`		`- #[inline(always)]`
	`141`	`+ #[inline]`
`142`	`142`	`fn cmoveq(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`143`	`143`	`output.cmovz(&input, (self ^ rhs) as u8);`
`144`	`144`	`}`
`145`	`145`
`146`		`- #[inline(always)]`
	`146`	`+ #[inline]`
`147`	`147`	`fn cmovne(&self, rhs: &Self, input: Condition, output: &mut Condition) {`
`148`	`148`	`output.cmovnz(&input, (self ^ rhs) as u8);`
`149`	`149`	`}`