fix determinig the size of foreign static allocations

Author: RalfJung

src/librustc_mir/interpret/memory.rs

@@ -10,7 +10,7 @@ use std::collections::VecDeque;
 use std::ptr;
 use std::borrow::Cow;
 
-use rustc::ty::{self, Instance, query::TyCtxtAt};
+use rustc::ty::{self, Instance, ParamEnv, query::TyCtxtAt};
 use rustc::ty::layout::{Align, TargetDataLayout, Size, HasDataLayout};
 use rustc_data_structures::fx::{FxHashSet, FxHashMap};
 
@@ -536,19 +536,33 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
     ) -> InterpResult<'static, (Size, Align)> {
         // Regular allocations.
         if let Ok(alloc) = self.get(id) {
-            Ok((Size::from_bytes(alloc.bytes.len() as u64), alloc.align))
+            return Ok((Size::from_bytes(alloc.bytes.len() as u64), alloc.align));
         }
         // Function pointers.
-        else if let Ok(_) = self.get_fn_alloc(id) {
-            if let AllocCheck::Dereferencable = liveness {
+        if let Ok(_) = self.get_fn_alloc(id) {
+            return if let AllocCheck::Dereferencable = liveness {
                 // The caller requested no function pointers.
                 err!(DerefFunctionPointer)
             } else {
                 Ok((Size::ZERO, Align::from_bytes(1).unwrap()))
+            };
+        }
+        // Foreign statics.
+        // 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);
+        match alloc {
+            Some(GlobalAlloc::Static(did)) => {
+                assert!(self.tcx.is_foreign_item(did));
+                // 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));
             }
+            _ => {}
         }
         // The rest must be dead.
-        else if let AllocCheck::MaybeDead = liveness {
+        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)