builder: rely on &mut self (instead of &self) on most methods.

Author: eddyb

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -127,7 +127,7 @@ fn memset_fill_u64(b: u8) -> u64 {
 }
 
 fn memset_dynamic_scalar(
-    builder: &Builder<'_, '_>,
+    builder: &mut Builder<'_, '_>,
     fill_var: Word,
     byte_width: usize,
     is_float: bool,
@@ -154,7 +154,7 @@ fn memset_dynamic_scalar(
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     #[instrument(level = "trace", skip(self))]
-    fn ordering_to_semantics_def(&self, ordering: AtomicOrdering) -> SpirvValue {
+    fn ordering_to_semantics_def(&mut self, ordering: AtomicOrdering) -> SpirvValue {
         let mut invalid_seq_cst = false;
         let semantics = match ordering {
             AtomicOrdering::Relaxed => MemorySemantics::NONE,
@@ -263,7 +263,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     }
 
     #[instrument(level = "trace", skip(self))]
-    fn memset_dynamic_pattern(&self, ty: &SpirvType<'tcx>, fill_var: Word) -> Word {
+    fn memset_dynamic_pattern(&mut self, ty: &SpirvType<'tcx>, fill_var: Word) -> Word {
         match *ty {
             SpirvType::Void => self.fatal("memset invalid on void pattern"),
             SpirvType::Bool => self.fatal("memset invalid on bool pattern"),
@@ -823,7 +823,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             )
         )]
     fn emit_access_chain(
-        &self,
+        &mut self,
         result_type: <Self as BackendTypes>::Type,
         pointer: Word,
         ptr_base_index: Option<SpirvValue>,
@@ -3091,18 +3091,20 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
             struct FormatArgsNotRecognized(String);
 
             // HACK(eddyb) this is basically a `try` block.
-            let try_decode_and_remove_format_args = || {
+            let mut try_decode_and_remove_format_args = || {
                 let mut decoded_format_args = DecodedFormatArgs::default();
 
-                let const_u32_as_usize = |ct_id| match self.builder.lookup_const_by_id(ct_id)? {
+                // HACK(eddyb) work around mutable borrowing conflicts.
+                let cx = self.cx;
+
+                let const_u32_as_usize = |ct_id| match cx.builder.lookup_const_by_id(ct_id)? {
                     SpirvConst::Scalar(x) => Some(u32::try_from(x).ok()? as usize),
                     _ => None,
                 };
                 let const_slice_as_elem_ids = |ptr_id: Word, len: usize| {
-                    if let SpirvConst::PtrTo { pointee } =
-                        self.builder.lookup_const_by_id(ptr_id)?
+                    if let SpirvConst::PtrTo { pointee } = cx.builder.lookup_const_by_id(ptr_id)?
                         && let SpirvConst::Composite(elems) =
-                            self.builder.lookup_const_by_id(pointee)?
+                            cx.builder.lookup_const_by_id(pointee)?
                         && elems.len() == len
                     {
                         return Some(elems);

crates/rustc_codegen_spirv/src/builder/ext_inst.rs

@@ -41,7 +41,7 @@ impl ExtInst {
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     pub fn custom_inst(
-        &self,
+        &mut self,
         result_type: Word,
         inst: custom_insts::CustomInst<Operand>,
     ) -> SpirvValue {
@@ -58,7 +58,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             .with_type(result_type)
     }
 
-    pub fn gl_op(&self, op: GLOp, result_type: Word, args: impl AsRef<[SpirvValue]>) -> SpirvValue {
+    pub fn gl_op(
+        &mut self,
+        op: GLOp,
+        result_type: Word,
+        args: impl AsRef<[SpirvValue]>,
+    ) -> SpirvValue {
         let args = args.as_ref();
         let glsl = self.ext_inst.borrow_mut().import_glsl(self);
         self.emit()

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

@@ -381,7 +381,7 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
 }
 
 impl Builder<'_, '_> {
-    pub fn count_ones(&self, arg: SpirvValue) -> SpirvValue {
+    pub fn count_ones(&mut self, arg: SpirvValue) -> SpirvValue {
         let ty = arg.ty;
         match self.cx.lookup_type(ty) {
             SpirvType::Integer(bits, false) => {
@@ -426,7 +426,7 @@ impl Builder<'_, '_> {
         }
     }
 
-    pub fn bit_reverse(&self, arg: SpirvValue) -> SpirvValue {
+    pub fn bit_reverse(&mut self, arg: SpirvValue) -> SpirvValue {
         let ty = arg.ty;
         match self.cx.lookup_type(ty) {
             SpirvType::Integer(bits, false) => {
@@ -489,7 +489,7 @@ impl Builder<'_, '_> {
     }
 
     pub fn count_leading_trailing_zeros(
-        &self,
+        &mut self,
         arg: SpirvValue,
         trailing: bool,
         non_zero: bool,
@@ -501,9 +501,9 @@ impl Builder<'_, '_> {
                 let u32 = SpirvType::Integer(32, false).def(self.span(), self);
 
                 let glsl = self.ext_inst.borrow_mut().import_glsl(self);
-                let find_xsb = |arg, offset: i32| {
+                let find_xsb = |this: &mut Self, arg, offset: i32| {
                     if trailing {
-                        let lsb = self
+                        let lsb = this
                             .emit()
                             .ext_inst(
                                 u32,
@@ -516,12 +516,12 @@ impl Builder<'_, '_> {
                         if offset == 0 {
                             lsb
                         } else {
-                            let const_offset = self.constant_i32(self.span(), offset).def(self);
-                            self.emit().i_add(u32, None, const_offset, lsb).unwrap()
+                            let const_offset = this.constant_i32(this.span(), offset).def(this);
+                            this.emit().i_add(u32, None, const_offset, lsb).unwrap()
                         }
                     } else {
                         // rust is always unsigned, so FindUMsb
-                        let msb_bit = self
+                        let msb_bit = this
                             .emit()
                             .ext_inst(
                                 u32,
@@ -533,21 +533,21 @@ impl Builder<'_, '_> {
                             .unwrap();
                         // the glsl op returns the Msb bit, not the amount of leading zeros of this u32
                         // leading zeros = 31 - Msb bit
-                        let const_offset = self.constant_i32(self.span(), 31 - offset).def(self);
-                        self.emit().i_sub(u32, None, const_offset, msb_bit).unwrap()
+                        let const_offset = this.constant_i32(this.span(), 31 - offset).def(this);
+                        this.emit().i_sub(u32, None, const_offset, msb_bit).unwrap()
                     }
                 };
 
                 let converted = match bits {
                     8 | 16 => {
                         let arg = self.emit().u_convert(u32, None, arg.def(self)).unwrap();
                         if trailing {
-                            find_xsb(arg, 0)
+                            find_xsb(self, arg, 0)
                         } else {
-                            find_xsb(arg, bits as i32 - 32)
+                            find_xsb(self, arg, bits as i32 - 32)
                         }
                     }
-                    32 => find_xsb(arg.def(self), 0),
+                    32 => find_xsb(self, arg.def(self), 0),
                     64 => {
                         let u32_0 = self.constant_int(u32, 0).def(self);
                         let u32_32 = self.constant_u32(self.span(), 32).def(self);
@@ -562,16 +562,16 @@ impl Builder<'_, '_> {
 
                         if trailing {
                             let use_lower = self.emit().i_equal(bool, None, lower, u32_0).unwrap();
-                            let lower_bits = find_xsb(lower, 32);
-                            let higher_bits = find_xsb(higher, 0);
+                            let lower_bits = find_xsb(self, lower, 32);
+                            let higher_bits = find_xsb(self, higher, 0);
                             self.emit()
                                 .select(u32, None, use_lower, higher_bits, lower_bits)
                                 .unwrap()
                         } else {
                             let use_higher =
                                 self.emit().i_equal(bool, None, higher, u32_0).unwrap();
-                            let lower_bits = find_xsb(lower, 0);
-                            let higher_bits = find_xsb(higher, 32);
+                            let lower_bits = find_xsb(self, lower, 0);
+                            let higher_bits = find_xsb(self, higher, 32);
                             self.emit()
                                 .select(u32, None, use_higher, lower_bits, higher_bits)
                                 .unwrap()

crates/rustc_codegen_spirv/src/builder/mod.rs

@@ -47,8 +47,12 @@ pub struct Builder<'a, 'tcx> {
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// See comment on `BuilderCursor`
-    pub fn emit(&self) -> std::cell::RefMut<'_, rspirv::dr::Builder> {
-        self.emit_with_cursor(self.cursor)
+    //
+    // FIXME(eddyb) take advantage of `&mut self` to avoid `RefCell` entirely
+    // (sadly it requires making `&CodegeCx`'s types/consts more like SPIR-T,
+    // and completely disjoint from mutably building functions).
+    pub fn emit(&mut self) -> std::cell::RefMut<'a, rspirv::dr::Builder> {
+        self.cx.emit_with_cursor(self.cursor)
     }
 
     pub fn zombie(&self, word: Word, reason: &str) {

crates/rustc_codegen_spirv/src/builder/spirv_asm.rs

@@ -538,7 +538,7 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
         };
         let inst_class = inst_name
             .strip_prefix("Op")
-            .and_then(|n| self.instruction_table.table.get(n));
+            .and_then(|n| self.cx.instruction_table.table.get(n));
         let inst_class = if let Some(inst) = inst_class {
             inst
         } else {