From 83dc7fe6691b5897b27cc9ca446d3841ed7d86de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Mi=C4=85sko?= <tomasz.miasko@gmail.com>
Date: Wed, 27 Jan 2021 00:00:00 +0000
Subject: [PATCH 1/2] Inline trivial implementation of rustc_target::abi::Align

---
 compiler/rustc_target/src/abi/mod.rs | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_target/src/abi/mod.rs b/compiler/rustc_target/src/abi/mod.rs
index 93868bed9b9..88b2923f6c4 100644
--- a/compiler/rustc_target/src/abi/mod.rs
+++ b/compiler/rustc_target/src/abi/mod.rs
@@ -441,16 +441,28 @@ pub struct Align {
 }
 
 impl Align {
+    #[inline]
     pub fn from_bits(bits: u64) -> Result<Align, String> {
         Align::from_bytes(Size::from_bits(bits).bytes())
     }
 
+    #[inline]
     pub fn from_bytes(align: u64) -> Result<Align, String> {
         // Treat an alignment of 0 bytes like 1-byte alignment.
         if align == 0 {
             return Ok(Align { pow2: 0 });
         }
 
+        #[cold]
+        fn not_power_of_2(align: u64) -> String {
+            format!("`{}` is not a power of 2", align)
+        }
+
+        #[cold]
+        fn too_large(align: u64) -> String {
+            format!("`{}` is too large", align)
+        }
+
         let mut bytes = align;
         let mut pow2: u8 = 0;
         while (bytes & 1) == 0 {
@@ -458,19 +470,21 @@ impl Align {
             bytes >>= 1;
         }
         if bytes != 1 {
-            return Err(format!("`{}` is not a power of 2", align));
+            return Err(not_power_of_2(align));
         }
         if pow2 > 29 {
-            return Err(format!("`{}` is too large", align));
+            return Err(too_large(align));
         }
 
         Ok(Align { pow2 })
     }
 
+    #[inline]
     pub fn bytes(self) -> u64 {
         1 << self.pow2
     }
 
+    #[inline]
     pub fn bits(self) -> u64 {
         self.bytes() * 8
     }
@@ -479,12 +493,14 @@ impl Align {
     /// (the largest power of two that the offset is a multiple of).
     ///
     /// N.B., for an offset of `0`, this happens to return `2^64`.
+    #[inline]
     pub fn max_for_offset(offset: Size) -> Align {
         Align { pow2: offset.bytes().trailing_zeros() as u8 }
     }
 
     /// Lower the alignment, if necessary, such that the given offset
     /// is aligned to it (the offset is a multiple of the alignment).
+    #[inline]
     pub fn restrict_for_offset(self, offset: Size) -> Align {
         self.min(Align::max_for_offset(offset))
     }

From 20982b386fa9908f11d4c0b6db8c9ccf53700f8b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20Mi=C4=85sko?= <tomasz.miasko@gmail.com>
Date: Wed, 27 Jan 2021 00:00:00 +0000
Subject: [PATCH 2/2] Inline MemPlace::offset

---
 compiler/rustc_mir/src/interpret/place.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_mir/src/interpret/place.rs b/compiler/rustc_mir/src/interpret/place.rs
index a003380dda7..efde7fe6948 100644
--- a/compiler/rustc_mir/src/interpret/place.rs
+++ b/compiler/rustc_mir/src/interpret/place.rs
@@ -153,6 +153,7 @@ impl<Tag> MemPlace<Tag> {
         }
     }
 
+    #[inline]
     pub fn offset(
         self,
         offset: Size,