Auto merge of rust-lang#122728 - DianQK:range_metadata, r=<try>

[WIP] Use assume rather than range metadata

Fixes rust-lang#122726.

Currently, range can only be used in load, call and invoke instructions. Due to SROA being run before other passes, even in the simplest IR, LLVM cannot infer that `%i1` is 0.

```llvm
define noundef i32 `@src(i32` noundef %arg) {
  %i = alloca i32, align 4
  store i32 %arg, ptr %i, align 4
  %i1 = load i32, ptr %i, align 4, !range !0
  ret i32 %i1
}
```

https://alive2.llvm.org/ce/z/MjsH9b

r? `@ghost`

Author: bors

compiler/rustc_codegen_llvm/src/builder.rs

@@ -2,7 +2,7 @@ use crate::abi::FnAbiLlvmExt;
 use crate::attributes;
 use crate::common::Funclet;
 use crate::context::CodegenCx;
-use crate::llvm::{self, AtomicOrdering, AtomicRmwBinOp, BasicBlock, False, True};
+use crate::llvm::{self, AtomicOrdering, AtomicRmwBinOp, BasicBlock, False, LLVMIsALoadInst, True};
 use crate::llvm_util;
 use crate::type_::Type;
 use crate::type_of::LayoutLlvmExt;
@@ -662,12 +662,38 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
             // optimization.
             return;
         }
+        let abi::WrappingRange { start, end } = range;
+        let llty = self.cx.val_ty(load);
+        if unsafe { LLVMIsALoadInst(load) }.is_some() {
+            if start <= end {
+                if start > 0 {
+                    let low = self.cx.const_uint_big(llty, start);
+                    let cmp = self.icmp(IntPredicate::IntUGE, load, low);
+                    self.assume(cmp);
+                }
+                let type_max = Size::from_bits(self.cx.int_width(llty)).unsigned_int_max();
+                if end < type_max {
+                    let high = self.cx.const_uint_big(llty, end);
+                    let cmp = self.icmp(IntPredicate::IntULE, load, high);
+                    self.assume(cmp);
+                }
+            } else {
+                let low = self.cx.const_uint_big(llty, start);
+                let cmp_low = self.icmp(IntPredicate::IntUGE, load, low);
+
+                let high = self.cx.const_uint_big(llty, end);
+                let cmp_high = self.icmp(IntPredicate::IntULE, load, high);
+
+                let or = self.or(cmp_low, cmp_high);
+                self.assume(or);
+            }
+            return;
+        }
 
         unsafe {
-            let llty = self.cx.val_ty(load);
             let v = [
-                self.cx.const_uint_big(llty, range.start),
-                self.cx.const_uint_big(llty, range.end.wrapping_add(1)),
+                self.cx.const_uint_big(llty, start),
+                self.cx.const_uint_big(llty, end.wrapping_add(1)),
             ];
 
             llvm::LLVMSetMetadata(

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1017,6 +1017,7 @@ extern "C" {
 
     // Operations on instructions
     pub fn LLVMIsAInstruction(Val: &Value) -> Option<&Value>;
+    pub fn LLVMIsALoadInst(Val: &Value) -> Option<&Value>;
     pub fn LLVMGetFirstBasicBlock(Fn: &Value) -> &BasicBlock;
 
     // Operations on call sites