Overhaul FFI for creation of LLVM range attributes

Author: Zalathar

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1881,12 +1881,15 @@ unsafe extern "C" {
         C: &Context,
         effects: MemoryEffects,
     ) -> &Attribute;
-    pub(crate) fn LLVMRustCreateRangeAttribute(
-        C: &Context,
-        num_bits: c_uint,
-        lower_words: *const u64,
-        upper_words: *const u64,
-    ) -> &Attribute;
+    /// Lower and upper bounds are each passed as a `u128` broken into low and high 64-bit parts.
+    pub(crate) safe fn LLVMRustCreateRangeAttribute<'ll>(
+        C: &'ll Context,
+        NumBits: c_uint,
+        LowerBoundLo: u64,
+        LowerBoundHi: u64,
+        UpperBoundLo: u64,
+        UpperBoundHi: u64,
+    ) -> &'ll Attribute;
 
     // Operations on functions
     pub(crate) fn LLVMRustGetOrInsertFunction<'a>(

compiler/rustc_codegen_llvm/src/llvm/mod.rs

@@ -112,17 +112,27 @@ pub(crate) fn CreateAllocKindAttr(llcx: &Context, kind_arg: AllocKindFlags) -> &
 
 pub(crate) fn CreateRangeAttr(llcx: &Context, size: Size, range: WrappingRange) -> &Attribute {
     let lower = range.start;
+    // LLVM treats the upper bound as exclusive, but allows wrapping.
     let upper = range.end.wrapping_add(1);
-    let lower_words = [lower as u64, (lower >> 64) as u64];
-    let upper_words = [upper as u64, (upper >> 64) as u64];
-    unsafe {
-        LLVMRustCreateRangeAttribute(
-            llcx,
-            size.bits().try_into().unwrap(),
-            lower_words.as_ptr(),
-            upper_words.as_ptr(),
-        )
-    }
+
+    // Split each endpoint into a pair of u64 values to make FFI easier.
+    let as_lo_hi_pair = |x: u128| (x as u64, (x >> 64) as u64);
+    let (lower_bound_lo, lower_bound_hi) = as_lo_hi_pair(lower);
+    let (upper_bound_lo, upper_bound_hi) = as_lo_hi_pair(upper);
+
+    // Endpoints are given as u128, so make sure the given size isn't larger than that.
+    let size_bits = size.bits();
+    assert!(size_bits <= 128);
+    let size_bits = size_bits.try_into().unwrap();
+
+    LLVMRustCreateRangeAttribute(
+        llcx,
+        size_bits,
+        lower_bound_lo,
+        lower_bound_hi,
+        upper_bound_lo,
+        upper_bound_hi,
+    )
 }
 
 #[derive(Copy, Clone)]

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -486,10 +486,15 @@ LLVMRustCreateAllocSizeAttr(LLVMContextRef C, uint32_t ElementSizeArg) {
 
 extern "C" LLVMAttributeRef
 LLVMRustCreateRangeAttribute(LLVMContextRef C, unsigned NumBits,
-                             const uint64_t LowerWords[],
-                             const uint64_t UpperWords[]) {
-  return LLVMCreateConstantRangeAttribute(C, Attribute::Range, NumBits,
-                                          LowerWords, UpperWords);
+                             uint64_t LowerBoundLo, uint64_t LowerBoundHi,
+                             uint64_t UpperBoundLo, uint64_t UpperBoundHi) {
+  // For both endpoints, reassemble the lo/hi parts into into APInt values.
+  // APInt will automatically discard any excess bits.
+  ConstantRange RangeValue = {
+      APInt(NumBits, ArrayRef{LowerBoundLo, LowerBoundHi}),
+      APInt(NumBits, ArrayRef{UpperBoundLo, UpperBoundHi}),
+  };
+  return wrap(Attribute::get(*unwrap(C), llvm::Attribute::Range, RangeValue));
 }
 
 // These values **must** match ffi::AllocKindFlags.