Extra lets bloat the IR, unfortunately :(

clarfonthey · clarfonthey · commit 3a8f4fad5a04 · 2024-02-23T23:30:45.000-05:00
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
@@ -516,8 +516,7 @@ macro_rules! int_impl {
             );
             // SAFETY: this is guaranteed to be safe by the caller.
             unsafe {
-                let lhs = self;
-                intrinsics::unchecked_add(lhs, rhs)
+                intrinsics::unchecked_add(self, rhs)
             }
         }
 
@@ -660,8 +659,7 @@ macro_rules! int_impl {
             );
             // SAFETY: this is guaranteed to be safe by the caller.
             unsafe {
-                let lhs = self;
-                intrinsics::unchecked_sub(lhs, rhs)
+                intrinsics::unchecked_sub(self, rhs)
             }
         }
 
@@ -804,8 +802,7 @@ macro_rules! int_impl {
             );
             // SAFETY: this is guaranteed to be safe by the caller.
             unsafe {
-                let lhs = self;
-                intrinsics::unchecked_mul(lhs, rhs)
+                intrinsics::unchecked_mul(self, rhs)
             }
         }
 
@@ -1272,9 +1269,7 @@ macro_rules! int_impl {
             // SAFETY: this is guaranteed to be safe by the caller.
             // Any legal shift amount is losslessly representable in the self type.
             unsafe {
-                let lhs = self;
-                let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs);
-                intrinsics::unchecked_shl(lhs, rhs)
+                intrinsics::unchecked_shl(self, conv_rhs_for_unchecked_shift!($SelfT, rhs))
             }
         }
 
@@ -1362,9 +1357,7 @@ macro_rules! int_impl {
             // SAFETY: this is guaranteed to be safe by the caller.
             // Any legal shift amount is losslessly representable in the self type.
             unsafe {
-                let lhs = self;
-                let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs);
-                intrinsics::unchecked_shr(lhs, rhs)
+                intrinsics::unchecked_shl(self, conv_rhs_for_unchecked_shift!($SelfT, rhs))
             }
         }
 
@@ -2031,8 +2024,7 @@ macro_rules! int_impl {
             unsafe {
                 // FIXME: we can't optimize out the extra check here,
                 // so, we can't just call the method for now
-                let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1));
-                intrinsics::unchecked_shl(self, rhs)
+                intrinsics::unchecked_shl(self, conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1)))
             }
         }
 
@@ -2064,8 +2056,7 @@ macro_rules! int_impl {
             unsafe {
                 // FIXME: we can't optimize out the extra check here,
                 // so, we can't just call the method for now
-                let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1));
-                intrinsics::unchecked_shr(self, rhs)
+                intrinsics::unchecked_shr(self, conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1)))
             }
         }
 
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
@@ -525,8 +525,7 @@ macro_rules! uint_impl {
 
             // SAFETY: this is guaranteed to be safe by the caller.
             unsafe {
-                let lhs = self;
-                intrinsics::unchecked_add(lhs, rhs)
+                intrinsics::unchecked_add(self, rhs)
             }
         }
 
@@ -675,8 +674,7 @@ macro_rules! uint_impl {
             );
             // SAFETY: this is guaranteed to be safe by the caller.
             unsafe {
-                let lhs = self;
-                intrinsics::unchecked_sub(lhs, rhs)
+                intrinsics::unchecked_sub(self, rhs)
             }
         }
 
@@ -763,8 +761,7 @@ macro_rules! uint_impl {
             );
             // SAFETY: this is guaranteed to be safe by the caller.
             unsafe {
-                let lhs = self;
-                intrinsics::unchecked_mul(lhs, rhs)
+                intrinsics::unchecked_mul(self, rhs)
             }
         }
 
@@ -1327,9 +1324,7 @@ macro_rules! uint_impl {
             // SAFETY: this is guaranteed to be safe by the caller.
             // Any legal shift amount is losslessly representable in the self type.
             unsafe {
-                let lhs = self;
-                let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs);
-                intrinsics::unchecked_shl(lhs, rhs)
+                intrinsics::unchecked_shl(self, conv_rhs_for_unchecked_shift!($SelfT, rhs))
             }
         }
 
@@ -1417,9 +1412,7 @@ macro_rules! uint_impl {
             // SAFETY: this is guaranteed to be safe by the caller.
             // Any legal shift amount is losslessly representable in the self type.
             unsafe {
-                let lhs = self;
-                let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs);
-                intrinsics::unchecked_shr(lhs, rhs)
+                intrinsics::unchecked_shr(self, conv_rhs_for_unchecked_shift!($SelfT, rhs))
             }
         }
 
@@ -1913,8 +1906,7 @@ macro_rules! uint_impl {
             unsafe {
                 // FIXME: we can't optimize out the extra check here,
                 // so, we can't just call the method for now
-                let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1));
-                intrinsics::unchecked_shl(self, rhs)
+                intrinsics::unchecked_shl(self, conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1)))
             }
         }
 
@@ -1949,8 +1941,7 @@ macro_rules! uint_impl {
             unsafe {
                 // FIXME: we can't optimize out the extra check here,
                 // so, we can't just call the method for now
-                let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1));
-                intrinsics::unchecked_shr(self, rhs)
+                intrinsics::unchecked_shr(self, conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1)))
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -516,8 +516,7 @@ macro_rules! int_impl {`
`516`	`516`	`);`
`517`	`517`	`// SAFETY: this is guaranteed to be safe by the caller.`
`518`	`518`	`unsafe {`
`519`		`- let lhs = self;`
`520`		`- intrinsics::unchecked_add(lhs, rhs)`
	`519`	`+ intrinsics::unchecked_add(self, rhs)`
`521`	`520`	`}`
`522`	`521`	`}`
`523`	`522`
`@@ -660,8 +659,7 @@ macro_rules! int_impl {`
`660`	`659`	`);`
`661`	`660`	`// SAFETY: this is guaranteed to be safe by the caller.`
`662`	`661`	`unsafe {`
`663`		`- let lhs = self;`
`664`		`- intrinsics::unchecked_sub(lhs, rhs)`
	`662`	`+ intrinsics::unchecked_sub(self, rhs)`
`665`	`663`	`}`
`666`	`664`	`}`
`667`	`665`
`@@ -804,8 +802,7 @@ macro_rules! int_impl {`
`804`	`802`	`);`
`805`	`803`	`// SAFETY: this is guaranteed to be safe by the caller.`
`806`	`804`	`unsafe {`
`807`		`- let lhs = self;`
`808`		`- intrinsics::unchecked_mul(lhs, rhs)`
	`805`	`+ intrinsics::unchecked_mul(self, rhs)`
`809`	`806`	`}`
`810`	`807`	`}`
`811`	`808`
`@@ -1272,9 +1269,7 @@ macro_rules! int_impl {`
`1272`	`1269`	`// SAFETY: this is guaranteed to be safe by the caller.`
`1273`	`1270`	`// Any legal shift amount is losslessly representable in the self type.`
`1274`	`1271`	`unsafe {`
`1275`		`- let lhs = self;`
`1276`		`- let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs);`
`1277`		`- intrinsics::unchecked_shl(lhs, rhs)`
	`1272`	`+ intrinsics::unchecked_shl(self, conv_rhs_for_unchecked_shift!($SelfT, rhs))`
`1278`	`1273`	`}`
`1279`	`1274`	`}`
`1280`	`1275`
`@@ -1362,9 +1357,7 @@ macro_rules! int_impl {`
`1362`	`1357`	`// SAFETY: this is guaranteed to be safe by the caller.`
`1363`	`1358`	`// Any legal shift amount is losslessly representable in the self type.`
`1364`	`1359`	`unsafe {`
`1365`		`- let lhs = self;`
`1366`		`- let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs);`
`1367`		`- intrinsics::unchecked_shr(lhs, rhs)`
	`1360`	`+ intrinsics::unchecked_shl(self, conv_rhs_for_unchecked_shift!($SelfT, rhs))`
`1368`	`1361`	`}`
`1369`	`1362`	`}`
`1370`	`1363`
`@@ -2031,8 +2024,7 @@ macro_rules! int_impl {`
`2031`	`2024`	`unsafe {`
`2032`	`2025`	`// FIXME: we can't optimize out the extra check here,`
`2033`	`2026`	`// so, we can't just call the method for now`
`2034`		`- let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1));`
`2035`		`- intrinsics::unchecked_shl(self, rhs)`
	`2027`	`+ intrinsics::unchecked_shl(self, conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1)))`
`2036`	`2028`	`}`
`2037`	`2029`	`}`
`2038`	`2030`
`@@ -2064,8 +2056,7 @@ macro_rules! int_impl {`
`2064`	`2056`	`unsafe {`
`2065`	`2057`	`// FIXME: we can't optimize out the extra check here,`
`2066`	`2058`	`// so, we can't just call the method for now`
`2067`		`- let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1));`
`2068`		`- intrinsics::unchecked_shr(self, rhs)`
	`2059`	`+ intrinsics::unchecked_shr(self, conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1)))`
`2069`	`2060`	`}`
`2070`	`2061`	`}`
`2071`	`2062`
Original file line number	Diff line number	Diff line change
`@@ -525,8 +525,7 @@ macro_rules! uint_impl {`
`525`	`525`
`526`	`526`	`// SAFETY: this is guaranteed to be safe by the caller.`
`527`	`527`	`unsafe {`
`528`		`- let lhs = self;`
`529`		`- intrinsics::unchecked_add(lhs, rhs)`
	`528`	`+ intrinsics::unchecked_add(self, rhs)`
`530`	`529`	`}`
`531`	`530`	`}`
`532`	`531`
`@@ -675,8 +674,7 @@ macro_rules! uint_impl {`
`675`	`674`	`);`
`676`	`675`	`// SAFETY: this is guaranteed to be safe by the caller.`
`677`	`676`	`unsafe {`
`678`		`- let lhs = self;`
`679`		`- intrinsics::unchecked_sub(lhs, rhs)`
	`677`	`+ intrinsics::unchecked_sub(self, rhs)`
`680`	`678`	`}`
`681`	`679`	`}`
`682`	`680`
`@@ -763,8 +761,7 @@ macro_rules! uint_impl {`
`763`	`761`	`);`
`764`	`762`	`// SAFETY: this is guaranteed to be safe by the caller.`
`765`	`763`	`unsafe {`
`766`		`- let lhs = self;`
`767`		`- intrinsics::unchecked_mul(lhs, rhs)`
	`764`	`+ intrinsics::unchecked_mul(self, rhs)`
`768`	`765`	`}`
`769`	`766`	`}`
`770`	`767`
`@@ -1327,9 +1324,7 @@ macro_rules! uint_impl {`
`1327`	`1324`	`// SAFETY: this is guaranteed to be safe by the caller.`
`1328`	`1325`	`// Any legal shift amount is losslessly representable in the self type.`
`1329`	`1326`	`unsafe {`
`1330`		`- let lhs = self;`
`1331`		`- let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs);`
`1332`		`- intrinsics::unchecked_shl(lhs, rhs)`
	`1327`	`+ intrinsics::unchecked_shl(self, conv_rhs_for_unchecked_shift!($SelfT, rhs))`
`1333`	`1328`	`}`
`1334`	`1329`	`}`
`1335`	`1330`
`@@ -1417,9 +1412,7 @@ macro_rules! uint_impl {`
`1417`	`1412`	`// SAFETY: this is guaranteed to be safe by the caller.`
`1418`	`1413`	`// Any legal shift amount is losslessly representable in the self type.`
`1419`	`1414`	`unsafe {`
`1420`		`- let lhs = self;`
`1421`		`- let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs);`
`1422`		`- intrinsics::unchecked_shr(lhs, rhs)`
	`1415`	`+ intrinsics::unchecked_shr(self, conv_rhs_for_unchecked_shift!($SelfT, rhs))`
`1423`	`1416`	`}`
`1424`	`1417`	`}`
`1425`	`1418`
`@@ -1913,8 +1906,7 @@ macro_rules! uint_impl {`
`1913`	`1906`	`unsafe {`
`1914`	`1907`	`// FIXME: we can't optimize out the extra check here,`
`1915`	`1908`	`// so, we can't just call the method for now`
`1916`		`- let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1));`
`1917`		`- intrinsics::unchecked_shl(self, rhs)`
	`1909`	`+ intrinsics::unchecked_shl(self, conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1)))`
`1918`	`1910`	`}`
`1919`	`1911`	`}`
`1920`	`1912`
`@@ -1949,8 +1941,7 @@ macro_rules! uint_impl {`
`1949`	`1941`	`unsafe {`
`1950`	`1942`	`// FIXME: we can't optimize out the extra check here,`
`1951`	`1943`	`// so, we can't just call the method for now`
`1952`		`- let rhs = conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1));`
`1953`		`- intrinsics::unchecked_shr(self, rhs)`
	`1944`	`+ intrinsics::unchecked_shr(self, conv_rhs_for_unchecked_shift!($SelfT, rhs & (Self::BITS - 1)))`
`1954`	`1945`	`}`
`1955`	`1946`	`}`
`1956`	`1947`