Rustup to rustc 1.44.0-nightly (537ccdf3a 2020-04-02)

bjorn3 · bjorn3 · commit ac1c5d695444 · 2020-04-03T11:54:18.000+02:00
diff --git a/build_sysroot/alloc_system/lib.rs b/build_sysroot/alloc_system/lib.rs
@@ -18,6 +18,7 @@
 #![feature(nll)]
 #![feature(staged_api)]
 #![feature(rustc_attrs)]
+#![feature(alloc_layout_extra)]
 #![cfg_attr(
     all(target_arch = "wasm32", not(target_os = "emscripten")),
     feature(integer_atomics, stdsimd)
@@ -41,8 +42,10 @@ const MIN_ALIGN: usize = 8;
               target_arch = "sparc64")))]
 #[allow(dead_code)]
 const MIN_ALIGN: usize = 16;
-use core::alloc::{AllocRef, GlobalAlloc, AllocErr, Layout};
+use core::alloc::*;
 use core::ptr::NonNull;
+use core::intrinsics;
+
 /// The default memory allocator provided by the operating system.
 ///
 /// This is based on `malloc` on Unix platforms and `HeapAlloc` on Windows,
@@ -72,29 +75,97 @@ pub struct System;
 #[unstable(feature = "allocator_api", issue = "32838")]
 unsafe impl AllocRef for System {
     #[inline]
-    fn alloc(&mut self, layout: Layout) -> Result<(NonNull<u8>, usize), AllocErr> {
-        NonNull::new(unsafe { GlobalAlloc::alloc(self, layout) })
-            .ok_or(AllocErr)
-            .map(|p| (p, layout.size()))
+    fn alloc(&mut self, layout: Layout, init: AllocInit) -> Result<MemoryBlock, AllocErr> {
+        unsafe {
+            let size = layout.size();
+            if size == 0 {
+                Ok(MemoryBlock { ptr: layout.dangling(), size: 0 })
+            } else {
+                let raw_ptr = match init {
+                    AllocInit::Uninitialized => GlobalAlloc::alloc(self, layout),
+                    AllocInit::Zeroed => GlobalAlloc::alloc_zeroed(self, layout),
+                };
+                let ptr = NonNull::new(raw_ptr).ok_or(AllocErr)?;
+                Ok(MemoryBlock { ptr, size })
+            }
+        }
     }
+
     #[inline]
-    fn alloc_zeroed(&mut self, layout: Layout) -> Result<(NonNull<u8>, usize), AllocErr> {
-        NonNull::new(unsafe { GlobalAlloc::alloc_zeroed(self, layout) })
-            .ok_or(AllocErr)
-            .map(|p| (p, layout.size()))
+    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {
+        if layout.size() != 0 {
+            GlobalAlloc::dealloc(self, ptr.as_ptr(), layout)
+        }
     }
+
     #[inline]
-    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {
-        GlobalAlloc::dealloc(self, ptr.as_ptr(), layout)
+    unsafe fn grow(
+        &mut self,
+        ptr: NonNull<u8>,
+        layout: Layout,
+        new_size: usize,
+        placement: ReallocPlacement,
+        init: AllocInit,
+    ) -> Result<MemoryBlock, AllocErr> {
+        let size = layout.size();
+        debug_assert!(
+            new_size >= size,
+            "`new_size` must be greater than or equal to `memory.size()`"
+        );
+
+        if size == new_size {
+            return Ok(MemoryBlock { ptr, size });
+        }
+
+        match placement {
+            ReallocPlacement::InPlace => Err(AllocErr),
+            ReallocPlacement::MayMove if layout.size() == 0 => {
+                let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());
+                self.alloc(new_layout, init)
+            }
+            ReallocPlacement::MayMove => {
+                // `realloc` probably checks for `new_size > size` or something similar.
+                intrinsics::assume(new_size > size);
+                let ptr = GlobalAlloc::realloc(self, ptr.as_ptr(), layout, new_size);
+                let memory =
+                    MemoryBlock { ptr: NonNull::new(ptr).ok_or(AllocErr)?, size: new_size };
+                init.init_offset(memory, size);
+                Ok(memory)
+            }
+        }
     }
+
     #[inline]
-    unsafe fn realloc(&mut self,
-                      ptr: NonNull<u8>,
-                      layout: Layout,
-                      new_size: usize) -> Result<(NonNull<u8>, usize), AllocErr> {
-        NonNull::new(GlobalAlloc::realloc(self, ptr.as_ptr(), layout, new_size))
-            .ok_or(AllocErr)
-            .map(|p| (p, layout.size()))
+    unsafe fn shrink(
+        &mut self,
+        ptr: NonNull<u8>,
+        layout: Layout,
+        new_size: usize,
+        placement: ReallocPlacement,
+    ) -> Result<MemoryBlock, AllocErr> {
+        let size = layout.size();
+        debug_assert!(
+            new_size <= size,
+            "`new_size` must be smaller than or equal to `memory.size()`"
+        );
+
+        if size == new_size {
+            return Ok(MemoryBlock { ptr, size });
+        }
+
+        match placement {
+            ReallocPlacement::InPlace => Err(AllocErr),
+            ReallocPlacement::MayMove if new_size == 0 => {
+                self.dealloc(ptr, layout);
+                Ok(MemoryBlock { ptr: layout.dangling(), size: 0 })
+            }
+            ReallocPlacement::MayMove => {
+                // `realloc` probably checks for `new_size < size` or something similar.
+                intrinsics::assume(new_size < size);
+                let ptr = GlobalAlloc::realloc(self, ptr.as_ptr(), layout, new_size);
+                Ok(MemoryBlock { ptr: NonNull::new(ptr).ok_or(AllocErr)?, size: new_size })
+            }
+        }
     }
 }
 #[cfg(any(windows, unix, target_os = "cloudabi", target_os = "redox"))]
diff --git a/rust-toolchain b/rust-toolchain
@@ -1 +1 @@
-nightly-2020-04-02
+nightly-2020-04-03
diff --git a/src/abi/comments.rs b/src/abi/comments.rs
@@ -62,7 +62,7 @@ pub(super) fn add_local_place_comments<'tcx>(
     local: Local,
 ) {
     let TyAndLayout { ty, layout } = place.layout();
-    let ty::layout::Layout {
+    let rustc_target::abi::Layout {
         size,
         align,
         abi: _,
diff --git a/src/abi/pass_mode.rs b/src/abi/pass_mode.rs
@@ -82,11 +82,11 @@ pub(super) fn get_pass_mode<'tcx>(tcx: TyCtxt<'tcx>, layout: TyAndLayout<'tcx>)
         PassMode::NoPass
     } else {
         match &layout.abi {
-            layout::Abi::Uninhabited => PassMode::NoPass,
-            layout::Abi::Scalar(scalar) => {
+            Abi::Uninhabited => PassMode::NoPass,
+            Abi::Scalar(scalar) => {
                 PassMode::ByVal(scalar_to_clif_type(tcx, scalar.clone()))
             }
-            layout::Abi::ScalarPair(a, b) => {
+            Abi::ScalarPair(a, b) => {
                 let a = scalar_to_clif_type(tcx, a.clone());
                 let b = scalar_to_clif_type(tcx, b.clone());
                 if a == types::I128 && b == types::I128 {
@@ -100,9 +100,9 @@ pub(super) fn get_pass_mode<'tcx>(tcx: TyCtxt<'tcx>, layout: TyAndLayout<'tcx>)
             }
 
             // FIXME implement Vector Abi in a cg_llvm compatible way
-            layout::Abi::Vector { .. } => PassMode::ByRef { sized: true },
+            Abi::Vector { .. } => PassMode::ByRef { sized: true },
 
-            &layout::Abi::Aggregate { sized } => PassMode::ByRef { sized },
+            &Abi::Aggregate { sized } => PassMode::ByRef { sized },
         }
     }
 }
diff --git a/src/base.rs b/src/base.rs
@@ -592,7 +592,7 @@ fn trans_stmt<'tcx>(
                     lval.write_cvalue(fx, CValue::by_val(len, usize_layout));
                 }
                 Rvalue::NullaryOp(NullOp::Box, content_ty) => {
-                    use rustc_middle::middle::lang_items::ExchangeMallocFnLangItem;
+                    use rustc_hir::lang_items::ExchangeMallocFnLangItem;
 
                     let usize_type = fx.clif_type(fx.tcx.types.usize).unwrap();
                     let content_ty = fx.monomorphize(content_ty);
diff --git a/src/common.rs b/src/common.rs
@@ -1,4 +1,4 @@
-use rustc_middle::ty::layout::{Integer, Primitive};
+use rustc_target::abi::{Integer, Primitive};
 use rustc_target::spec::{HasTargetSpec, Target};
 use rustc_index::vec::IndexVec;
 
@@ -304,8 +304,8 @@ impl<'tcx, B: Backend + 'static> layout::HasTyCtxt<'tcx> for FunctionCx<'_, 'tcx
     }
 }
 
-impl<'tcx, B: Backend + 'static> layout::HasDataLayout for FunctionCx<'_, 'tcx, B> {
-    fn data_layout(&self) -> &layout::TargetDataLayout {
+impl<'tcx, B: Backend + 'static> rustc_target::abi::HasDataLayout for FunctionCx<'_, 'tcx, B> {
+    fn data_layout(&self) -> &rustc_target::abi::TargetDataLayout {
         &self.tcx.data_layout
     }
 }
diff --git a/src/constant.rs b/src/constant.rs
@@ -6,7 +6,8 @@ use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mir::interpret::{
     read_target_uint, AllocId, Allocation, ConstValue, GlobalAlloc, InterpResult, Scalar,
 };
-use rustc_middle::ty::{layout::Align, Const, ConstKind};
+use rustc_middle::ty::{Const, ConstKind};
+use rustc_target::abi::Align;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_mir::interpret::{
     ImmTy, InterpCx, Machine, Memory, MemoryKind, OpTy, PlaceTy, Pointer,
diff --git a/src/debuginfo/mod.rs b/src/debuginfo/mod.rs
@@ -16,7 +16,7 @@ use gimli::{Encoding, Format, LineEncoding, RunTimeEndian, X86_64};
 pub(crate) use emit::{DebugReloc, DebugRelocName};
 
 fn target_endian(tcx: TyCtxt) -> RunTimeEndian {
-    use rustc_middle::ty::layout::Endian;
+    use rustc_target::abi::Endian;
 
     match tcx.data_layout.endian {
         Endian::Big => RunTimeEndian::Big,
diff --git a/src/discriminant.rs b/src/discriminant.rs
@@ -1,5 +1,7 @@
 //! Adapted from https://github.com/rust-lang/rust/blob/d760df5aea483aae041c9a241e7acacf48f75035/src/librustc_codegen_ssa/mir/place.rs
 
+use rustc_target::abi::{DiscriminantKind, Int, Variants};
+
 use crate::prelude::*;
 
 pub(crate) fn codegen_set_discriminant<'tcx>(
@@ -12,13 +14,13 @@ pub(crate) fn codegen_set_discriminant<'tcx>(
         return;
     }
     match layout.variants {
-        layout::Variants::Single { index } => {
+        Variants::Single { index } => {
             assert_eq!(index, variant_index);
         }
-        layout::Variants::Multiple {
+        Variants::Multiple {
             discr: _,
             discr_index,
-            discr_kind: layout::DiscriminantKind::Tag,
+            discr_kind: DiscriminantKind::Tag,
             variants: _,
         } => {
             let ptr = place.place_field(fx, mir::Field::new(discr_index));
@@ -30,11 +32,11 @@ pub(crate) fn codegen_set_discriminant<'tcx>(
             let discr = CValue::const_val(fx, ptr.layout(), to);
             ptr.write_cvalue(fx, discr);
         }
-        layout::Variants::Multiple {
+        Variants::Multiple {
             discr: _,
             discr_index,
             discr_kind:
-                layout::DiscriminantKind::Niche {
+                DiscriminantKind::Niche {
                     dataful_variant,
                     ref niche_variants,
                     niche_start,
@@ -59,7 +61,7 @@ pub(crate) fn codegen_get_discriminant<'tcx>(
 ) -> CValue<'tcx> {
     let layout = value.layout();
 
-    if layout.abi == layout::Abi::Uninhabited {
+    if layout.abi == Abi::Uninhabited {
         return trap_unreachable_ret_value(
             fx,
             dest_layout,
@@ -68,14 +70,14 @@ pub(crate) fn codegen_get_discriminant<'tcx>(
     }
 
     let (discr_scalar, discr_index, discr_kind) = match &layout.variants {
-        layout::Variants::Single { index } => {
+        Variants::Single { index } => {
             let discr_val = layout
                 .ty
                 .discriminant_for_variant(fx.tcx, *index)
                 .map_or(u128::from(index.as_u32()), |discr| discr.val);
             return CValue::const_val(fx, dest_layout, discr_val);
         }
-        layout::Variants::Multiple {
+        Variants::Multiple {
             discr,
             discr_index,
             discr_kind,
@@ -91,15 +93,15 @@ pub(crate) fn codegen_get_discriminant<'tcx>(
 
     // Decode the discriminant (specifically if it's niche-encoded).
     match *discr_kind {
-        layout::DiscriminantKind::Tag => {
+        DiscriminantKind::Tag => {
             let signed = match discr_scalar.value {
-                layout::Int(_, signed) => signed,
+                Int(_, signed) => signed,
                 _ => false,
             };
             let val = clif_intcast(fx, encoded_discr, cast_to, signed);
             return CValue::by_val(val, dest_layout);
         }
-        layout::DiscriminantKind::Niche {
+        DiscriminantKind::Niche {
             dataful_variant,
             ref niche_variants,
             niche_start,
diff --git a/src/intrinsics/mod.rs b/src/intrinsics/mod.rs
@@ -144,7 +144,7 @@ fn lane_type_and_count<'tcx>(
 ) -> (TyAndLayout<'tcx>, u16) {
     assert!(layout.ty.is_simd());
     let lane_count = match layout.fields {
-        layout::FieldsShape::Array { stride: _, count } => u16::try_from(count).unwrap(),
+        rustc_target::abi::FieldsShape::Array { stride: _, count } => u16::try_from(count).unwrap(),
         _ => unreachable!("lane_type_and_count({:?})", layout),
     };
     let lane_layout = layout.field(&ty::layout::LayoutCx {
diff --git a/src/lib.rs b/src/lib.rs
@@ -8,6 +8,7 @@ extern crate rustc_middle;
 extern crate rustc_codegen_ssa;
 extern crate rustc_data_structures;
 extern crate rustc_driver;
+extern crate rustc_errors;
 extern crate rustc_fs_util;
 extern crate rustc_hir;
 extern crate rustc_incremental;
@@ -21,11 +22,11 @@ extern crate rustc_ast;
 
 use std::any::Any;
 
+use rustc_errors::ErrorReported;
 use rustc_middle::dep_graph::{DepGraph, WorkProduct, WorkProductId};
 use rustc_middle::middle::cstore::{EncodedMetadata, MetadataLoader};
 use rustc_session::config::OutputFilenames;
 use rustc_middle::ty::query::Providers;
-use rustc_middle::util::common::ErrorReported;
 use rustc_codegen_ssa::traits::CodegenBackend;
 
 use cranelift_codegen::settings;
@@ -72,7 +73,8 @@ mod prelude {
     pub(crate) use rustc_hir::def_id::{DefId, LOCAL_CRATE};
     pub(crate) use rustc_middle::mir::{self, *};
     pub(crate) use rustc_session::Session;
-    pub(crate) use rustc_middle::ty::layout::{self, Abi, LayoutOf, Scalar, Size, TyAndLayout, VariantIdx};
+    pub(crate) use rustc_middle::ty::layout::{self, TyAndLayout};
+    pub(crate) use rustc_target::abi::{Abi, LayoutOf, Scalar, Size, VariantIdx};
     pub(crate) use rustc_middle::ty::{
         self, FnSig, Instance, InstanceDef, ParamEnv, Ty, TyCtxt, TypeAndMut, TypeFoldable,
     };
diff --git a/src/main_shim.rs b/src/main_shim.rs
@@ -3,7 +3,7 @@ use crate::prelude::*;
 /// Create the `main` function which will initialize the rust runtime and call
 /// users main function.
 pub(crate) fn maybe_create_entry_wrapper(tcx: TyCtxt<'_>, module: &mut Module<impl Backend + 'static>) {
-    use rustc_middle::middle::lang_items::StartFnLangItem;
+    use rustc_hir::lang_items::StartFnLangItem;
     use rustc_session::config::EntryFnType;
 
     let (main_def_id, use_start_lang_item) = match tcx.entry_fn(LOCAL_CRATE) {
diff --git a/src/value_and_place.rs b/src/value_and_place.rs
@@ -118,8 +118,8 @@ impl<'tcx> CValue<'tcx> {
         match self.0 {
             CValueInner::ByRef(ptr, None) => {
                 let clif_ty = match layout.abi {
-                    layout::Abi::Scalar(ref scalar) => scalar_to_clif_type(fx.tcx, scalar.clone()),
-                    layout::Abi::Vector { ref element, count } => {
+                    Abi::Scalar(ref scalar) => scalar_to_clif_type(fx.tcx, scalar.clone()),
+                    Abi::Vector { ref element, count } => {
                         scalar_to_clif_type(fx.tcx, element.clone())
                             .by(u16::try_from(count).unwrap()).unwrap()
                     }
@@ -142,7 +142,7 @@ impl<'tcx> CValue<'tcx> {
         match self.0 {
             CValueInner::ByRef(ptr, None) => {
                 let (a_scalar, b_scalar) = match &layout.abi {
-                    layout::Abi::ScalarPair(a, b) => (a, b),
+                    Abi::ScalarPair(a, b) => (a, b),
                     _ => unreachable!("load_scalar_pair({:?})", self),
                 };
                 let b_offset = scalar_pair_calculate_b_offset(fx.tcx, a_scalar, b_scalar);
@@ -167,7 +167,7 @@ impl<'tcx> CValue<'tcx> {
         match self.0 {
             CValueInner::ByVal(val) => {
                 match layout.abi {
-                    layout::Abi::Vector { element: _, count } => {
+                    Abi::Vector { element: _, count } => {
                         let count = u8::try_from(count).expect("SIMD type with more than 255 lanes???");
                         let field = u8::try_from(field.index()).unwrap();
                         assert!(field < count);
diff --git a/src/vtable.rs b/src/vtable.rs
@@ -177,8 +177,8 @@ fn write_usize(tcx: TyCtxt, buf: &mut [u8], idx: usize, num: u64) {
     let mut target = &mut buf[idx * usize_size..(idx + 1) * usize_size];
 
     match tcx.data_layout.endian {
-        layout::Endian::Little => target.write_uint::<LittleEndian>(num, usize_size),
-        layout::Endian::Big => target.write_uint::<BigEndian>(num, usize_size),
+        rustc_target::abi::Endian::Little => target.write_uint::<LittleEndian>(num, usize_size),
+        rustc_target::abi::Endian::Big => target.write_uint::<BigEndian>(num, usize_size),
     }
     .unwrap()
 }

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-nightly-2020-04-02`
	`1`	`+nightly-2020-04-03`
Original file line number	Diff line number	Diff line change
`@@ -82,11 +82,11 @@ pub(super) fn get_pass_mode<'tcx>(tcx: TyCtxt<'tcx>, layout: TyAndLayout<'tcx>)`
`82`	`82`	`PassMode::NoPass`
`83`	`83`	`} else {`
`84`	`84`	`match &layout.abi {`
`85`		`- layout::Abi::Uninhabited => PassMode::NoPass,`
`86`		`- layout::Abi::Scalar(scalar) => {`
	`85`	`+ Abi::Uninhabited => PassMode::NoPass,`
	`86`	`+ Abi::Scalar(scalar) => {`
`87`	`87`	`PassMode::ByVal(scalar_to_clif_type(tcx, scalar.clone()))`
`88`	`88`	`}`
`89`		`- layout::Abi::ScalarPair(a, b) => {`
	`89`	`+ Abi::ScalarPair(a, b) => {`
`90`	`90`	`let a = scalar_to_clif_type(tcx, a.clone());`
`91`	`91`	`let b = scalar_to_clif_type(tcx, b.clone());`
`92`	`92`	`if a == types::I128 && b == types::I128 {`
`@@ -100,9 +100,9 @@ pub(super) fn get_pass_mode<'tcx>(tcx: TyCtxt<'tcx>, layout: TyAndLayout<'tcx>)`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`// FIXME implement Vector Abi in a cg_llvm compatible way`
`103`		`- layout::Abi::Vector { .. } => PassMode::ByRef { sized: true },`
	`103`	`+ Abi::Vector { .. } => PassMode::ByRef { sized: true },`
`104`	`104`
`105`		`- &layout::Abi::Aggregate { sized } => PassMode::ByRef { sized },`
	`105`	`+ &Abi::Aggregate { sized } => PassMode::ByRef { sized },`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -592,7 +592,7 @@ fn trans_stmt<'tcx>(`
`592`	`592`	`lval.write_cvalue(fx, CValue::by_val(len, usize_layout));`
`593`	`593`	`}`
`594`	`594`	`Rvalue::NullaryOp(NullOp::Box, content_ty) => {`
`595`		`- use rustc_middle::middle::lang_items::ExchangeMallocFnLangItem;`
	`595`	`+ use rustc_hir::lang_items::ExchangeMallocFnLangItem;`
`596`	`596`
`597`	`597`	`let usize_type = fx.clif_type(fx.tcx.types.usize).unwrap();`
`598`	`598`	`let content_ty = fx.monomorphize(content_ty);`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use rustc_middle::ty::layout::{Integer, Primitive};`
	`1`	`+use rustc_target::abi::{Integer, Primitive};`
`2`	`2`	`use rustc_target::spec::{HasTargetSpec, Target};`
`3`	`3`	`use rustc_index::vec::IndexVec;`
`4`	`4`
`@@ -304,8 +304,8 @@ impl<'tcx, B: Backend + 'static> layout::HasTyCtxt<'tcx> for FunctionCx<'_, 'tcx`
`304`	`304`	`}`
`305`	`305`	`}`
`306`	`306`
`307`		`-impl<'tcx, B: Backend + 'static> layout::HasDataLayout for FunctionCx<'_, 'tcx, B> {`
`308`		`- fn data_layout(&self) -> &layout::TargetDataLayout {`
	`307`	`+impl<'tcx, B: Backend + 'static> rustc_target::abi::HasDataLayout for FunctionCx<'_, 'tcx, B> {`
	`308`	`+ fn data_layout(&self) -> &rustc_target::abi::TargetDataLayout {`
`309`	`309`	`&self.tcx.data_layout`
`310`	`310`	`}`
`311`	`311`	`}`