Relax some more constraints

Author: bjorn3

src/librustc_codegen_llvm/builder.rs

@@ -441,6 +441,13 @@ impl MemoryBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
+    fn set_invariant_load(&mut self, load: &'ll Value) {
+        unsafe {
+            llvm::LLVMSetMetadata(load, llvm::MD_invariant_load as c_uint,
+                                  llvm::LLVMMDNodeInContext(self.cx.llcx, ptr::null(), 0));
+        }
+    }
+
     fn memcpy(&mut self, dst: &'ll Value, dst_align: Align,
                   src: &'ll Value, src_align: Align,
                   size: &'ll Value, flags: MemFlags) {
@@ -999,6 +1006,17 @@ impl NumBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
             llvm::LLVMBuildFCmp(self.llbuilder, op as c_uint, lhs, rhs, noname())
         }
     }
+
+    fn select(
+        &mut self, cond: &'ll Value,
+        then_val: &'ll Value,
+        else_val: &'ll Value,
+    ) -> &'ll Value {
+        self.count_insn("select");
+        unsafe {
+            llvm::LLVMBuildSelect(self.llbuilder, cond, then_val, else_val, noname())
+        }
+    }
 }
 
 impl UnwindBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
@@ -1125,17 +1143,6 @@ impl UnwindBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
 
 impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     /* Miscellaneous instructions */
-    fn select(
-        &mut self, cond: &'ll Value,
-        then_val: &'ll Value,
-        else_val: &'ll Value,
-    ) -> &'ll Value {
-        self.count_insn("select");
-        unsafe {
-            llvm::LLVMBuildSelect(self.llbuilder, cond, then_val, else_val, noname())
-        }
-    }
-
     fn extract_element(&mut self, vec: &'ll Value, idx: &'ll Value) -> &'ll Value {
         self.count_insn("extractelement");
         unsafe {
@@ -1171,13 +1178,6 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
-    fn set_invariant_load(&mut self, load: &'ll Value) {
-        unsafe {
-            llvm::LLVMSetMetadata(load, llvm::MD_invariant_load as c_uint,
-                                  llvm::LLVMMDNodeInContext(self.cx.llcx, ptr::null(), 0));
-        }
-    }
-
     fn lifetime_start(&mut self, ptr: &'ll Value, size: Size) {
         self.call_lifetime_intrinsic("llvm.lifetime.start", ptr, size);
     }

src/librustc_codegen_ssa/glue.rs

@@ -7,10 +7,14 @@ use crate::common::IntPredicate;
 use crate::meth;
 use crate::traits::*;
 
-pub fn size_and_align_of_dst<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
+pub fn size_and_align_of_dst<
+    'a,
+    'tcx: 'a,
+    Bx: MemoryBuilderMethods<'tcx> + NumBuilderMethods<'tcx>,
+>(
     bx: &mut Bx,
     t: Ty<'tcx>,
-    info: Option<Bx::Value>
+    info: Option<Bx::Value>,
 ) -> (Bx::Value, Bx::Value) {
     let layout = bx.layout_of(t);
     debug!("size_and_align_of_dst(ty={}, info={:?}): layout: {:?}",

src/librustc_codegen_ssa/meth.rs

@@ -18,7 +18,7 @@ impl<'a, 'tcx: 'a> VirtualIndex {
         VirtualIndex(index as u64 + 3)
     }
 
-    pub fn get_fn<Bx: BuilderMethods<'a, 'tcx>>(
+    pub fn get_fn<Bx: MemoryBuilderMethods<'tcx>>(
         self,
         bx: &mut Bx,
         llvtable: Bx::Value,
@@ -40,7 +40,7 @@ impl<'a, 'tcx: 'a> VirtualIndex {
         ptr
     }
 
-    pub fn get_usize<Bx: BuilderMethods<'a, 'tcx>>(
+    pub fn get_usize<Bx: MemoryBuilderMethods<'tcx>>(
         self,
         bx: &mut Bx,
         llvtable: Bx::Value

src/librustc_codegen_ssa/mir/operand.rs

@@ -261,39 +261,39 @@ impl<'a, 'tcx: 'a, V: CodegenObject> OperandRef<'tcx, V> {
 }
 
 impl<'a, 'tcx: 'a, V: CodegenObject> OperandValue<V> {
-    pub fn store<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
+    pub fn store<Bx: MemoryBuilderMethods<'tcx, Value = V> + NumBuilderMethods<'tcx>>(
         self,
         bx: &mut Bx,
         dest: PlaceRef<'tcx, V>
     ) {
         self.store_with_flags(bx, dest, MemFlags::empty());
     }
 
-    pub fn volatile_store<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
+    pub fn volatile_store<Bx: MemoryBuilderMethods<'tcx, Value = V> + NumBuilderMethods<'tcx>>(
         self,
         bx: &mut Bx,
         dest: PlaceRef<'tcx, V>
     ) {
         self.store_with_flags(bx, dest, MemFlags::VOLATILE);
     }
 
-    pub fn unaligned_volatile_store<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
+    pub fn unaligned_volatile_store<Bx: MemoryBuilderMethods<'tcx, Value = V> + NumBuilderMethods<'tcx>>(
         self,
         bx: &mut Bx,
         dest: PlaceRef<'tcx, V>,
     ) {
         self.store_with_flags(bx, dest, MemFlags::VOLATILE | MemFlags::UNALIGNED);
     }
 
-    pub fn nontemporal_store<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
+    pub fn nontemporal_store<Bx: MemoryBuilderMethods<'tcx, Value = V> + NumBuilderMethods<'tcx>>(
         self,
         bx: &mut Bx,
         dest: PlaceRef<'tcx, V>
     ) {
         self.store_with_flags(bx, dest, MemFlags::NONTEMPORAL);
     }
 
-    fn store_with_flags<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
+    fn store_with_flags<Bx: MemoryBuilderMethods<'tcx, Value = V> + NumBuilderMethods<'tcx>>(
         self,
         bx: &mut Bx,
         dest: PlaceRef<'tcx, V>,

src/librustc_codegen_ssa/mir/place.rs

@@ -100,7 +100,7 @@ impl<'a, 'tcx: 'a, V: CodegenObject> PlaceRef<'tcx, V> {
 
 impl<'a, 'tcx: 'a, V: CodegenObject> PlaceRef<'tcx, V> {
     /// Access a field, at a point when the value's case is known.
-    pub fn project_field<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
+    pub fn project_field<Bx: MemoryBuilderMethods<'tcx, Value = V> + NumBuilderMethods<'tcx>>(
         self, bx: &mut Bx,
         ix: usize,
     ) -> Self {

src/librustc_codegen_ssa/traits/builder.rs

@@ -81,8 +81,10 @@ pub trait MemoryBuilderMethods<'tcx>: HasCodegen<'tcx> {
     fn ptrtoint(&mut self, val: Self::Value, dest_ty: Self::Type) -> Self::Value;
     fn inttoptr(&mut self, val: Self::Value, dest_ty: Self::Type) -> Self::Value;
 
+    // Optimization metadata
     fn range_metadata(&mut self, load: Self::Value, range: Range<u128>);
     fn nonnull_metadata(&mut self, load: Self::Value);
+    fn set_invariant_load(&mut self, load: Self::Value);
 
     // Bulk memory operations
     fn memcpy(
@@ -205,6 +207,14 @@ pub trait NumBuilderMethods<'tcx>: HasCodegen<'tcx> {
     fn fptrunc(&mut self, val: Self::Value, dest_ty: Self::Type) -> Self::Value;
     fn fpext(&mut self, val: Self::Value, dest_ty: Self::Type) -> Self::Value;
     fn fcmp(&mut self, op: RealPredicate, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
+
+    /// This is not really only for numbers, but often used functions which also use numbers
+    fn select(
+        &mut self,
+        cond: Self::Value,
+        then_val: Self::Value,
+        else_val: Self::Value,
+    ) -> Self::Value;
 }
 
 pub trait UnwindBuilderMethods<'tcx>: HasCodegen<'tcx> {
@@ -255,20 +265,11 @@ pub trait BuilderMethods<'a, 'tcx: 'a>:
     + NumBuilderMethods<'tcx>
     + UnwindBuilderMethods<'tcx>
 {
-    fn select(
-        &mut self,
-        cond: Self::Value,
-        then_val: Self::Value,
-        else_val: Self::Value,
-    ) -> Self::Value;
-
     fn extract_element(&mut self, vec: Self::Value, idx: Self::Value) -> Self::Value;
     fn vector_splat(&mut self, num_elts: usize, elt: Self::Value) -> Self::Value;
     fn extract_value(&mut self, agg_val: Self::Value, idx: u64) -> Self::Value;
     fn insert_value(&mut self, agg_val: Self::Value, elt: Self::Value, idx: u64) -> Self::Value;
 
-    fn set_invariant_load(&mut self, load: Self::Value);
-
     /// Called for `StorageLive`
     fn lifetime_start(&mut self, ptr: Self::Value, size: Size);