Introduce Scalar::range_metadata

Author: nox

src/librustc/ty/layout.rs

@@ -23,7 +23,7 @@ use std::fmt;
 use std::i128;
 use std::iter;
 use std::mem;
-use std::ops::{Add, Sub, Mul, AddAssign, Deref, RangeInclusive};
+use std::ops::{Add, Sub, Mul, AddAssign, Deref, Range, RangeInclusive};
 
 use ich::StableHashingContext;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher,
@@ -648,6 +648,19 @@ impl Scalar {
             false
         }
     }
+
+    /// Returns a range suitable to be passed to LLVM for range metadata.
+    pub fn range_metadata<C: HasDataLayout>(&self, cx: C) -> Range<u128> {
+        // For a (max) value of -1, max will be `-1 as usize`, which overflows.
+        // However, that is fine here (it would still represent the full range),
+        // i.e., if the range is everything.
+        let bits = self.value.size(cx).bits();
+        assert!(bits <= 128);
+        let mask = !0u128 >> (128 - bits);
+        let start = self.valid_range.start & mask;
+        let end = self.valid_range.end.wrapping_add(1) & mask;
+        start..end
+    }
 }
 
 /// The first half of a fat pointer.

src/librustc_trans/abi.rs

@@ -1056,22 +1056,18 @@ impl<'a, 'tcx> FnType<'tcx> {
             _ => {}
         }
         if let layout::Abi::Scalar(ref scalar) = self.ret.layout.abi {
-            let (min, max) = (scalar.valid_range.start, scalar.valid_range.end);
-            let max_next = max.wrapping_add(1);
-            let bits = scalar.value.size(bx.cx).bits();
-            assert!(bits <= 128);
-            let mask = !0u128 >> (128 - bits);
-            // For a (max) value of -1, max will be `-1 as usize`, which overflows.
-            // However, that is fine here (it would still represent the full range),
-            // i.e., if the range is everything.  The lo==hi case would be
-            // rejected by the LLVM verifier (it would mean either an
-            // empty set, which is impossible, or the entire range of the
-            // type, which is pointless).
+            let range = scalar.range_metadata(bx.cx);
+            // The lo==hi case would be rejected by the LLVM verifier
+            // (it would mean either an empty set, which is impossible, or the
+            // entire range of the type, which is pointless).
+            //
+            // If the value is a boolean, the range is 0..2 and that ultimately
+            // become 0..0 when the type becomes i1.
             match scalar.value {
-                layout::Int(..) if !scalar.is_bool() && max_next & mask != min & mask => {
+                layout::Int(..) if !scalar.is_bool() && range.start != range.end => {
                     // llvm::ConstantRange can deal with ranges that wrap around,
                     // so an overflow on (max + 1) is fine.
-                    bx.range_metadata(callsite, min..max_next);
+                    bx.range_metadata(callsite, range);
                 }
                 _ => {}
             }

src/librustc_trans/mir/place.rs

@@ -91,24 +91,17 @@ impl<'a, 'tcx> PlaceRef<'tcx> {
         }
 
         let scalar_load_metadata = |load, scalar: &layout::Scalar| {
-            let (min, max) = (scalar.valid_range.start, scalar.valid_range.end);
-            let max_next = max.wrapping_add(1);
-            let bits = scalar.value.size(bx.cx).bits();
-            assert!(bits <= 128);
-            let mask = !0u128 >> (128 - bits);
-            // For a (max) value of -1, max will be `-1 as usize`, which overflows.
-            // However, that is fine here (it would still represent the full range),
-            // i.e., if the range is everything.  The lo==hi case would be
-            // rejected by the LLVM verifier (it would mean either an
-            // empty set, which is impossible, or the entire range of the
-            // type, which is pointless).
+            let range = scalar.range_metadata(bx.cx);
+            // The lo==hi case would be rejected by the LLVM verifier
+            // (it would mean either an empty set, which is impossible, or the
+            // entire range of the type, which is pointless).
             match scalar.value {
-                layout::Int(..) if max_next & mask != min & mask => {
+                layout::Int(..) if range.start != range.end => {
                     // llvm::ConstantRange can deal with ranges that wrap around,
                     // so an overflow on (max + 1) is fine.
-                    bx.range_metadata(load, min..max_next);
+                    bx.range_metadata(load, range);
                 }
-                layout::Pointer if 0 < min && min < max => {
+                layout::Pointer if 0 < range.start && range.start < range.end => {
                     bx.nonnull_metadata(load);
                 }
                 _ => {}