diff --git a/src/librustc_mir/interpret/memory.rs b/src/librustc_mir/interpret/memory.rs
index 9140c90bed37..934fa7f6f877 100644
--- a/src/librustc_mir/interpret/memory.rs
+++ b/src/librustc_mir/interpret/memory.rs
@@ -541,6 +541,8 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         match self.alloc_map.get_or(id, || Err(())) {
             Ok((_, alloc)) => Ok((Size::from_bytes(alloc.bytes.len() as u64), alloc.align)),
             Err(()) => {
+                // Not a local allocation, check the global `tcx.alloc_map`.
+
                 // Can't do this in the match argument, we may get cycle errors since the lock would
                 // be held throughout the match.
                 let alloc = self.tcx.alloc_map.lock().get(id);
@@ -549,20 +551,22 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
                         // Use size and align of the type
                         let ty = self.tcx.type_of(did);
                         let layout = self.tcx.layout_of(ParamEnv::empty().and(ty)).unwrap();
-                        return Ok((layout.size, layout.align.abi));
+                        Ok((layout.size, layout.align.abi))
                     },
                     Some(GlobalAlloc::Memory(alloc)) =>
                         // Need to duplicate the logic here, because the global allocations have
                         // different associated types than the interpreter-local ones
                         Ok((Size::from_bytes(alloc.bytes.len() as u64), alloc.align)),
-                    Some(GlobalAlloc::Function(_)) => if let AllocCheck::Dereferencable = liveness {
-                        // The caller requested no function pointers.
-                        return err!(DerefFunctionPointer);
-                    } else {
-                        return Ok((Size::ZERO, Align::from_bytes(1).unwrap()));
+                    Some(GlobalAlloc::Function(_)) => {
+                        if let AllocCheck::Dereferencable = liveness {
+                            // The caller requested no function pointers.
+                            err!(DerefFunctionPointer)
+                        } else {
+                            Ok((Size::ZERO, Align::from_bytes(1).unwrap()))
+                        }
                     },
                     // The rest must be dead.
-                    None => return if let AllocCheck::MaybeDead = liveness {
+                    None => if let AllocCheck::MaybeDead = liveness {
                         // Deallocated pointers are allowed, we should be able to find
                         // them in the map.
                         Ok(*self.dead_alloc_map.get(&id)