Get rid of the Scalar and ScalarPair variants of ConstValue...

src/librustc/mir/interpret/mod.rs

@@ -684,24 +684,24 @@ impl<Tag: Copy, Extra: Default> Allocation<Tag, Extra> {
         offset: Size,
         size: Size,
     ) -> EvalResult<'tcx> {
-        if self.relocations(hdl, offset, size)?.len() != 0 {
+        if self.relocations(hdl, offset, size).len() != 0 {
             err!(ReadPointerAsBytes)
         } else {
             Ok(())
         }
     }
 
-    pub fn relocations(
+    fn relocations(
         &self,
         hdl: impl HasDataLayout,
         offset: Size,
         size: Size,
-    ) -> EvalResult<'tcx, &[(Size, (Tag, AllocId))]> {
+    ) -> &[(Size, (Tag, AllocId))] {
         // We have to go back `pointer_size - 1` bytes, as that one would still overlap with
         // the beginning of this range.
-        let start = offset.bytes().saturating_sub(hdl.pointer_size().bytes() - 1);
+        let start = offset.bytes().saturating_sub(hdl.data_layout().pointer_size.bytes() - 1);
         let end = offset + size; // this does overflow checking
-        Ok(self.relocations.range(Size::from_bytes(start)..end))
+        self.relocations.range(Size::from_bytes(start)..end)
     }
 
     pub fn get_bytes(
@@ -736,22 +736,23 @@ impl<Tag: Copy, Extra: Default> Allocation<Tag, Extra> {
         &self,
         hdl: impl HasDataLayout,
         offset: Size,
+        size: Size,
+        align: Align,
     ) -> EvalResult<'tcx, Scalar<Tag>> {
-        let size = hdl.data_layout().pointer_size;
-        let required_align = hdl.data_layout().pointer_align;
-        self.check_align(offset, required_align)?;
+        self.check_align(offset, align)?;
         self.check_bounds(offset, size, true)?;
         self.check_defined(offset, size)?;
         let bytes = self.bytes_ignoring_relocations_and_undef(offset, size);
-        let offset = read_target_uint(hdl.data_layout().endian, &bytes).unwrap();
-        let offset = Size::from_bytes(offset as u64);
-        if let Some(&(tag, alloc_id)) = self.relocations.get(&offset) {
-            Ok(Pointer::new_with_tag(alloc_id, offset, tag).into())
-        } else {
-            Ok(Scalar::Bits {
-                bits: offset.bytes() as u128,
+        let int = read_target_uint(hdl.data_layout().endian, &bytes).unwrap();
+        match self.relocations(hdl, offset, size) {
+            &[(_, (tag, alloc_id))] if size == hdl.data_layout().pointer_size => {
+                Ok(Pointer::new_with_tag(alloc_id, Size::from_bytes(int as u64), tag).into())
+            },
+            &[] => Ok(Scalar::Bits {
+                bits: int,
                 size: size.bytes() as u8,
-            })
+            }),
+            _ => err!(ReadPointerAsBytes),
         }
     }
 

src/librustc/mir/interpret/value.rs

@@ -75,7 +75,9 @@ impl<'tcx> ConstValue<'tcx> {
         hdl: impl HasDataLayout,
     ) -> Option<Pointer> {
         let (_, alloc, offset) = self.try_as_by_ref()?;
-        alloc.read_scalar(hdl, offset).ok()?.to_ptr().ok()
+        let size = hdl.data_layout().pointer_size;
+        let required_align = hdl.data_layout().pointer_align;
+        alloc.read_scalar(hdl, offset, size, required_align).ok()?.to_ptr().ok()
     }
 
     /// e.g. for vtables, fat pointers or single pointers

src/librustc/mir/mod.rs

@@ -2487,7 +2487,9 @@ pub fn fmt_const_val(f: &mut impl Write, const_val: &ty::Const<'_>) -> fmt::Resu
             },
             // print string literals
             Ref(_, &ty::TyS { sty: Str, .. }, _) => {
-                let ptr = ty::tls::with(|tcx| alloc.read_scalar(tcx, offset));
+                let ptr = ty::tls::with(|tcx| alloc.read_scalar(
+                    tcx, offset, tcx.data_layout.pointer_size, tcx.data_layout.pointer_align,
+                ));
                 let ptr = ptr.and_then(Scalar::to_ptr);
                 if let Ok(ptr) = ptr {
                     let len = ty::tls::with(|tcx| alloc.read_bits(

src/librustc_codegen_llvm/mir/constant.rs

@@ -181,6 +181,7 @@ impl FunctionCx<'a, 'll, 'tcx> {
         constant
             .and_then(|c| {
                 let field_ty = c.ty.builtin_index().unwrap();
+                let layout = bx.cx.layout_of(field_ty);
                 let fields = match c.ty.sty {
                     ty::Array(_, n) => n.unwrap_usize(bx.tcx()),
                     ref other => bug!("invalid simd shuffle type: {}", other),
@@ -195,8 +196,7 @@ impl FunctionCx<'a, 'll, 'tcx> {
                         c,
                     )?;
                     // FIXME(oli-obk): are these indices always usize?
-                    if let Some(prim) = field.val.try_to_usize(bx.tcx()) {
-                        let layout = bx.cx.layout_of(field_ty);
+                    if let Some(prim) = field.val.try_to_bits(bx.tcx(), layout) {
                         let scalar = match layout.abi {
                             layout::Abi::Scalar(ref x) => x,
                             _ => bug!("from_const: invalid ByVal layout: {:#?}", layout)

src/librustc_codegen_llvm/mir/operand.rs

@@ -13,6 +13,7 @@ use rustc::mir;
 use rustc::ty;
 use rustc::ty::layout::{self, Align, LayoutOf, TyLayout};
 use rustc_data_structures::sync::Lrc;
+use syntax_pos::Span;
 
 use base;
 use common::{CodegenCx, C_undef, C_usize};
@@ -25,6 +26,7 @@ use glue;
 use std::fmt;
 
 use super::{FunctionCx, LocalRef};
+use super::constant::scalar_to_llvm;
 use super::place::PlaceRef;
 
 /// The representation of a Rust value. The enum variant is in fact
@@ -77,6 +79,7 @@ impl OperandRef<'ll, 'tcx> {
     }
 
     pub fn from_const(bx: &Builder<'a, 'll, 'tcx>,
+                      span: Span,
                       val: &'tcx ty::Const<'tcx>)
                       -> Result<OperandRef<'ll, 'tcx>, Lrc<ConstEvalErr<'tcx>>> {
         let layout = bx.cx.layout_of(val.ty);
@@ -85,12 +88,65 @@ impl OperandRef<'ll, 'tcx> {
             return Ok(OperandRef::new_zst(bx.cx, layout));
         }
 
-        match val.val {
+        let econv = |err| ConstEvalErr {
+            error: err,
+            stacktrace: Vec::new(),
+            span,
+        };
+
+        let val = match val.val {
             ConstValue::Unevaluated(..) => bug!(),
             ConstValue::ByRef(_, alloc, offset) => {
-                Ok(PlaceRef::from_const_alloc(bx, layout, alloc, offset).load(bx))
+                // FIXME: the first two arms are needed for simd_simple_float_intrinsic which reads
+                // the constants back from llvm values. We can probably do better.
+                match layout.abi {
+                    layout::Abi::Scalar(ref scalar) => {
+                        let x = alloc.read_scalar(
+                            bx.tcx(), offset, layout.size, layout.align,
+                        ).map_err(econv)?;
+                        let llval = scalar_to_llvm(
+                            bx.cx,
+                            x,
+                            scalar,
+                            layout.immediate_llvm_type(bx.cx),
+                        );
+                        OperandValue::Immediate(llval)
+                    },
+                    layout::Abi::ScalarPair(ref a_scalar, ref b_scalar) => {
+                        let a_size = a_scalar.value.size(bx.tcx());
+                        let a = alloc.read_scalar(
+                            bx.tcx(), offset, a_size, a_scalar.value.align(bx.tcx()),
+                        ).map_err(econv)?;
+                        let b_align = b_scalar.value.align(bx.tcx());
+                        let b_offset = offset + a_size.abi_align(b_align);
+                        let b_size = b_scalar.value.size(bx.tcx());
+                        let b = alloc.read_scalar(
+                            bx.tcx(), b_offset, b_size, b_align,
+                        ).map_err(econv)?;
+                        let a_llval = scalar_to_llvm(
+                            bx.cx,
+                            a,
+                            a_scalar,
+                            layout.scalar_pair_element_llvm_type(bx.cx, 0, true),
+                        );
+                        let b_layout = layout.scalar_pair_element_llvm_type(bx.cx, 1, true);
+                        let b_llval = scalar_to_llvm(
+                            bx.cx,
+                            b,
+                            b_scalar,
+                            b_layout,
+                        );
+                        OperandValue::Pair(a_llval, b_llval)
+                    },
+                    _ => return Ok(PlaceRef::from_const_alloc(bx, layout, alloc, offset).load(bx)),
+                }
             },
-        }
+        };
+
+        Ok(OperandRef {
+            val,
+            layout
+        })
     }
 
     /// Asserts that this operand refers to a scalar and returns
@@ -383,7 +439,7 @@ impl FunctionCx<'a, 'll, 'tcx> {
             mir::Operand::Constant(ref constant) => {
                 let ty = self.monomorphize(&constant.ty);
                 self.eval_mir_constant(bx, constant)
-                    .and_then(|c| OperandRef::from_const(bx, c))
+                    .and_then(|c| OperandRef::from_const(bx, constant.span, c))
                     .unwrap_or_else(|err| {
                         err.report_as_error(
                             bx.tcx().at(constant.span),