diff --git a/src/nouveau/compiler/nak_from_nir.rs b/src/nouveau/compiler/nak_from_nir.rs
index 9465d080206..abe54ba368b 100644
--- a/src/nouveau/compiler/nak_from_nir.rs
+++ b/src/nouveau/compiler/nak_from_nir.rs
@@ -1095,21 +1095,21 @@ impl<'a> ShaderFromNir<'a> {
             }
             nir_intrinsic_load_ubo => {
                 let idx = srcs[0];
-                let offset = srcs[1];
-                let dst = *self.get_dst(&intrin.def).as_ssa().unwrap();
-                if let Some(imm_idx) = idx.as_uint() {
-                    let imm_idx = u8::try_from(imm_idx).unwrap();
-                    if let Some(imm_offset) = offset.as_uint() {
-                        let imm_offset = u16::try_from(imm_offset).unwrap();
+                let (off, off_imm) = self.get_io_addr_offset(&srcs[1], 16);
+                let dst = self.get_dst(&intrin.def);
+                if let Some(idx_imm) = idx.as_uint() {
+                    let cb = CBufRef {
+                        buf: CBuf::Binding(idx_imm.try_into().unwrap()),
+                        offset: off_imm.try_into().unwrap(),
+                    };
+                    if off.is_zero() {
                         let mut pcopy = OpParCopy::new();
-                        for (i, dst) in dst.iter().enumerate() {
-                            let src = Src::new_cbuf(
-                                imm_idx,
-                                imm_offset + u16::try_from(i).unwrap() * 4,
-                            );
-                            pcopy.push(src, (*dst).into());
+                        let vec_dst = *dst.as_ssa().unwrap();
+                        for (i, dst) in vec_dst.iter().enumerate() {
+                            let i = u16::try_from(i).unwrap();
+                            pcopy.push(cb.offset(i * 4).into(), (*dst).into());
                         }
-                        self.instrs.push(Instr::new(Op::ParCopy(pcopy)));
+                        self.instrs.push(pcopy.into());
                     } else {
                         panic!("Indirect UBO offsets not yet supported");
                     }
diff --git a/src/nouveau/compiler/nak_ir.rs b/src/nouveau/compiler/nak_ir.rs
index 09e5aafeaaa..ec2fbb7950a 100644
--- a/src/nouveau/compiler/nak_ir.rs
+++ b/src/nouveau/compiler/nak_ir.rs
@@ -407,12 +407,37 @@ pub enum CBuf {
     BindlessGPR(RegRef),
 }
 
+impl fmt::Display for CBuf {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CBuf::Binding(idx) => write!(f, "c[{:#x}]", idx),
+            CBuf::BindlessSSA(v) => write!(f, "cx[{}]", v),
+            CBuf::BindlessGPR(r) => write!(f, "cx[{}]", r),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub struct CBufRef {
     pub buf: CBuf,
     pub offset: u16,
 }
 
+impl CBufRef {
+    pub fn offset(self, offset: u16) -> CBufRef {
+        CBufRef {
+            buf: self.buf,
+            offset: self.offset + offset,
+        }
+    }
+}
+
+impl fmt::Display for CBufRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}[{:#x}]", self.buf, self.offset)
+    }
+}
+
 #[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub enum SrcRef {
     Zero,
@@ -489,6 +514,12 @@ impl SrcRef {
     }
 }
 
+impl From<CBufRef> for SrcRef {
+    fn from(cb: CBufRef) -> SrcRef {
+        SrcRef::CBuf(cb)
+    }
+}
+
 impl From<RegRef> for SrcRef {
     fn from(reg: RegRef) -> SrcRef {
         SrcRef::Reg(reg)
@@ -504,22 +535,14 @@ impl<T: Into<SSARef>> From<T> for SrcRef {
 impl fmt::Display for SrcRef {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            SrcRef::Zero => write!(f, "ZERO")?,
-            SrcRef::True => write!(f, "TRUE")?,
-            SrcRef::False => write!(f, "FALSE")?,
-            SrcRef::Imm32(u) => write!(f, "{:#x}", u)?,
-            SrcRef::CBuf(r) => {
-                match r.buf {
-                    CBuf::Binding(idx) => write!(f, "c[{:#x}]", idx)?,
-                    CBuf::BindlessSSA(v) => write!(f, "cx[{}]", v)?,
-                    CBuf::BindlessGPR(r) => write!(f, "cx[{}]", r)?,
-                }
-                write!(f, "[{:#x}]", r.offset)?;
-            }
-            SrcRef::SSA(v) => v.fmt(f)?,
-            SrcRef::Reg(r) => r.fmt(f)?,
+            SrcRef::Zero => write!(f, "ZERO"),
+            SrcRef::True => write!(f, "TRUE"),
+            SrcRef::False => write!(f, "FALSE"),
+            SrcRef::Imm32(u) => write!(f, "{:#x}", u),
+            SrcRef::CBuf(c) => c.fmt(f),
+            SrcRef::SSA(v) => v.fmt(f),
+            SrcRef::Reg(r) => r.fmt(f),
         }
-        Ok(())
     }
 }
 
diff --git a/src/nouveau/compiler/nak_opt_copy_prop.rs b/src/nouveau/compiler/nak_opt_copy_prop.rs
index ddefb43087f..77fba7f283e 100644
--- a/src/nouveau/compiler/nak_opt_copy_prop.rs
+++ b/src/nouveau/compiler/nak_opt_copy_prop.rs
@@ -44,10 +44,7 @@ impl CopyPropPass {
             SrcRef::CBuf(cb) => {
                 let lo32 = Src::from(SrcRef::CBuf(cb));
                 let hi32 = Src {
-                    src_ref: SrcRef::CBuf(CBufRef {
-                        buf: cb.buf,
-                        offset: cb.offset + 4,
-                    }),
+                    src_ref: SrcRef::CBuf(cb.offset(4)),
                     src_mod: src.src_mod,
                 };
                 self.add_copy(dst[0], SrcType::ALU, lo32);