Const prop is only interested in immediate constants right now

Author: oli-obk

src/librustc_mir/interpret/operand.rs

@@ -359,7 +359,7 @@ pub(super) fn from_known_layout<'tcx>(
 impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
     /// Try reading a value in memory; this is interesting particularily for ScalarPair.
     /// Return None if the layout does not permit loading this as a value.
-    pub(super) fn try_read_value_from_mplace(
+    pub(crate) fn try_read_value_from_mplace(
         &self,
         mplace: MPlaceTy<'tcx, M::PointerTag>,
     ) -> EvalResult<'tcx, Option<Value<M::PointerTag>>> {
@@ -403,7 +403,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
     /// Note that for a given layout, this operation will either always fail or always
     /// succeed!  Whether it succeeds depends on whether the layout can be represented
     /// in a `Value`, not on which data is stored there currently.
-    pub(crate) fn try_read_value(
+    pub(super)fn try_read_value(
         &self,
         src: OpTy<'tcx, M::PointerTag>,
     ) -> EvalResult<'tcx, Result<Value<M::PointerTag>, MemPlace<M::PointerTag>>> {

src/librustc_mir/transform/const_prop.rs

@@ -259,24 +259,28 @@ impl<'a, 'mir, 'tcx> ConstPropagator<'a, 'mir, 'tcx> {
         source_info: SourceInfo,
     ) -> Option<Const<'tcx>> {
         self.ecx.tcx.span = source_info.span;
-        match self.ecx.const_to_mplace(c.literal) {
-            Ok(mplace) => {
-                Some((mplace.into(), c.span))
-            },
-            Err(error) => {
-                let (stacktrace, span) = self.ecx.generate_stacktrace(None);
-                let err = ConstEvalErr {
-                    span,
-                    error,
-                    stacktrace,
-                };
-                err.report_as_error(
-                    self.tcx.at(source_info.span),
-                    "could not evaluate constant",
-                );
-                None
+        let error = match self.ecx.const_to_mplace(c.literal) {
+            Ok(mplacety) => match self.ecx.try_read_value_from_mplace(mplacety) {
+                Err(error) => error,
+                Ok(Some(val)) => return Some((OpTy {
+                    op: interpret::Operand::Immediate(val),
+                    layout: mplacety.layout,
+                }, c.span)),
+                Ok(None) => return Some((mplacety.into(), c.span)),
             },
-        }
+            Err(error) => error,
+        };
+        let (stacktrace, span) = self.ecx.generate_stacktrace(None);
+        let err = ConstEvalErr {
+            span,
+            error,
+            stacktrace,
+        };
+        err.report_as_error(
+            self.tcx.at(source_info.span),
+            "could not evaluate constant",
+        );
+        None
     }
 
     fn eval_place(&mut self, place: &Place<'tcx>, source_info: SourceInfo) -> Option<Const<'tcx>> {