Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

11 files changed, 8814 insertions, 0 deletions

diff --git a/third_party/rust/naga/src/back/spv/block.rs b/third_party/rust/naga/src/back/spv/block.rs
new file mode 100644
index 0000000000..6c96fa09e3
--- /dev/null
+++ b/third_party/rust/naga/src/back/spv/block.rs
@@ -0,0 +1,2368 @@
+/*!
+Implementations for `BlockContext` methods.
+*/
+
+use super::{
+    helpers, index::BoundsCheckResult, make_local, selection::Selection, Block, BlockContext,
+    Dimension, Error, Instruction, LocalType, LookupType, LoopContext, ResultMember, Writer,
+    WriterFlags,
+};
+use crate::{arena::Handle, proc::TypeResolution, Statement};
+use spirv::Word;
+
+fn get_dimension(type_inner: &crate::TypeInner) -> Dimension {
+    match *type_inner {
+        crate::TypeInner::Scalar(_) => Dimension::Scalar,
+        crate::TypeInner::Vector { .. } => Dimension::Vector,
+        crate::TypeInner::Matrix { .. } => Dimension::Matrix,
+        _ => unreachable!(),
+    }
+}
+
+/// The results of emitting code for a left-hand-side expression.
+///
+/// On success, `write_expression_pointer` returns one of these.
+enum ExpressionPointer {
+    /// The pointer to the expression's value is available, as the value of the
+    /// expression with the given id.
+    Ready { pointer_id: Word },
+
+    /// The access expression must be conditional on the value of `condition`, a boolean
+    /// expression that is true if all indices are in bounds. If `condition` is true, then
+    /// `access` is an `OpAccessChain` instruction that will compute a pointer to the
+    /// expression's value. If `condition` is false, then executing `access` would be
+    /// undefined behavior.
+    Conditional {
+        condition: Word,
+        access: Instruction,
+    },
+}
+
+/// The termination statement to be added to the end of the block
+pub enum BlockExit {
+    /// Generates an OpReturn (void return)
+    Return,
+    /// Generates an OpBranch to the specified block
+    Branch {
+        /// The branch target block
+        target: Word,
+    },
+    /// Translates a loop `break if` into an `OpBranchConditional` to the
+    /// merge block if true (the merge block is passed through [`LoopContext::break_id`]
+    /// or else to the loop header (passed through [`preamble_id`])
+    ///
+    /// [`preamble_id`]: Self::BreakIf::preamble_id
+    BreakIf {
+        /// The condition of the `break if`
+        condition: Handle<crate::Expression>,
+        /// The loop header block id
+        preamble_id: Word,
+    },
+}
+
+#[derive(Debug)]
+pub(crate) struct DebugInfoInner<'a> {
+    pub source_code: &'a str,
+    pub source_file_id: Word,
+}
+
+impl Writer {
+    // Flip Y coordinate to adjust for coordinate space difference
+    // between SPIR-V and our IR.
+    // The `position_id` argument is a pointer to a `vecN<f32>`,
+    // whose `y` component we will negate.
+    fn write_epilogue_position_y_flip(
+        &mut self,
+        position_id: Word,
+        body: &mut Vec<Instruction>,
+    ) -> Result<(), Error> {
+        let float_ptr_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::F32,
+            pointer_space: Some(spirv::StorageClass::Output),
+        }));
+        let index_y_id = self.get_index_constant(1);
+        let access_id = self.id_gen.next();
+        body.push(Instruction::access_chain(
+            float_ptr_type_id,
+            access_id,
+            position_id,
+            &[index_y_id],
+        ));
+
+        let float_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::F32,
+            pointer_space: None,
+        }));
+        let load_id = self.id_gen.next();
+        body.push(Instruction::load(float_type_id, load_id, access_id, None));
+
+        let neg_id = self.id_gen.next();
+        body.push(Instruction::unary(
+            spirv::Op::FNegate,
+            float_type_id,
+            neg_id,
+            load_id,
+        ));
+
+        body.push(Instruction::store(access_id, neg_id, None));
+        Ok(())
+    }
+
+    // Clamp fragment depth between 0 and 1.
+    fn write_epilogue_frag_depth_clamp(
+        &mut self,
+        frag_depth_id: Word,
+        body: &mut Vec<Instruction>,
+    ) -> Result<(), Error> {
+        let float_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::F32,
+            pointer_space: None,
+        }));
+        let zero_scalar_id = self.get_constant_scalar(crate::Literal::F32(0.0));
+        let one_scalar_id = self.get_constant_scalar(crate::Literal::F32(1.0));
+
+        let original_id = self.id_gen.next();
+        body.push(Instruction::load(
+            float_type_id,
+            original_id,
+            frag_depth_id,
+            None,
+        ));
+
+        let clamp_id = self.id_gen.next();
+        body.push(Instruction::ext_inst(
+            self.gl450_ext_inst_id,
+            spirv::GLOp::FClamp,
+            float_type_id,
+            clamp_id,
+            &[original_id, zero_scalar_id, one_scalar_id],
+        ));
+
+        body.push(Instruction::store(frag_depth_id, clamp_id, None));
+        Ok(())
+    }
+
+    fn write_entry_point_return(
+        &mut self,
+        value_id: Word,
+        ir_result: &crate::FunctionResult,
+        result_members: &[ResultMember],
+        body: &mut Vec<Instruction>,
+    ) -> Result<(), Error> {
+        for (index, res_member) in result_members.iter().enumerate() {
+            let member_value_id = match ir_result.binding {
+                Some(_) => value_id,
+                None => {
+                    let member_value_id = self.id_gen.next();
+                    body.push(Instruction::composite_extract(
+                        res_member.type_id,
+                        member_value_id,
+                        value_id,
+                        &[index as u32],
+                    ));
+                    member_value_id
+                }
+            };
+
+            body.push(Instruction::store(res_member.id, member_value_id, None));
+
+            match res_member.built_in {
+                Some(crate::BuiltIn::Position { .. })
+                    if self.flags.contains(WriterFlags::ADJUST_COORDINATE_SPACE) =>
+                {
+                    self.write_epilogue_position_y_flip(res_member.id, body)?;
+                }
+                Some(crate::BuiltIn::FragDepth)
+                    if self.flags.contains(WriterFlags::CLAMP_FRAG_DEPTH) =>
+                {
+                    self.write_epilogue_frag_depth_clamp(res_member.id, body)?;
+                }
+                _ => {}
+            }
+        }
+        Ok(())
+    }
+}
+
+impl<'w> BlockContext<'w> {
+    /// Decide whether to put off emitting instructions for `expr_handle`.
+    ///
+    /// We would like to gather together chains of `Access` and `AccessIndex`
+    /// Naga expressions into a single `OpAccessChain` SPIR-V instruction. To do
+    /// this, we don't generate instructions for these exprs when we first
+    /// encounter them. Their ids in `self.writer.cached.ids` are left as zero. Then,
+    /// once we encounter a `Load` or `Store` expression that actually needs the
+    /// chain's value, we call `write_expression_pointer` to handle the whole
+    /// thing in one fell swoop.
+    fn is_intermediate(&self, expr_handle: Handle<crate::Expression>) -> bool {
+        match self.ir_function.expressions[expr_handle] {
+            crate::Expression::GlobalVariable(handle) => {
+                match self.ir_module.global_variables[handle].space {
+                    crate::AddressSpace::Handle => false,
+                    _ => true,
+                }
+            }
+            crate::Expression::LocalVariable(_) => true,
+            crate::Expression::FunctionArgument(index) => {
+                let arg = &self.ir_function.arguments[index as usize];
+                self.ir_module.types[arg.ty].inner.pointer_space().is_some()
+            }
+
+            // The chain rule: if this `Access...`'s `base` operand was
+            // previously omitted, then omit this one, too.
+            _ => self.cached.ids[expr_handle.index()] == 0,
+        }
+    }
+
+    /// Cache an expression for a value.
+    pub(super) fn cache_expression_value(
+        &mut self,
+        expr_handle: Handle<crate::Expression>,
+        block: &mut Block,
+    ) -> Result<(), Error> {
+        let is_named_expression = self
+            .ir_function
+            .named_expressions
+            .contains_key(&expr_handle);
+
+        if self.fun_info[expr_handle].ref_count == 0 && !is_named_expression {
+            return Ok(());
+        }
+
+        let result_type_id = self.get_expression_type_id(&self.fun_info[expr_handle].ty);
+        let id = match self.ir_function.expressions[expr_handle] {
+            crate::Expression::Literal(literal) => self.writer.get_constant_scalar(literal),
+            crate::Expression::Constant(handle) => {
+                let init = self.ir_module.constants[handle].init;
+                self.writer.constant_ids[init.index()]
+            }
+            crate::Expression::ZeroValue(_) => self.writer.get_constant_null(result_type_id),
+            crate::Expression::Compose { ty, ref components } => {
+                self.temp_list.clear();
+                if self.expression_constness.is_const(expr_handle) {
+                    self.temp_list.extend(
+                        crate::proc::flatten_compose(
+                            ty,
+                            components,
+                            &self.ir_function.expressions,
+                            &self.ir_module.types,
+                        )
+                        .map(|component| self.cached[component]),
+                    );
+                    self.writer
+                        .get_constant_composite(LookupType::Handle(ty), &self.temp_list)
+                } else {
+                    self.temp_list
+                        .extend(components.iter().map(|&component| self.cached[component]));
+
+                    let id = self.gen_id();
+                    block.body.push(Instruction::composite_construct(
+                        result_type_id,
+                        id,
+                        &self.temp_list,
+                    ));
+                    id
+                }
+            }
+            crate::Expression::Splat { size, value } => {
+                let value_id = self.cached[value];
+                let components = &[value_id; 4][..size as usize];
+
+                if self.expression_constness.is_const(expr_handle) {
+                    let ty = self
+                        .writer
+                        .get_expression_lookup_type(&self.fun_info[expr_handle].ty);
+                    self.writer.get_constant_composite(ty, components)
+                } else {
+                    let id = self.gen_id();
+                    block.body.push(Instruction::composite_construct(
+                        result_type_id,
+                        id,
+                        components,
+                    ));
+                    id
+                }
+            }
+            crate::Expression::Access { base, index: _ } if self.is_intermediate(base) => {
+                // See `is_intermediate`; we'll handle this later in
+                // `write_expression_pointer`.
+                0
+            }
+            crate::Expression::Access { base, index } => {
+                let base_ty_inner = self.fun_info[base].ty.inner_with(&self.ir_module.types);
+                match *base_ty_inner {
+                    crate::TypeInner::Vector { .. } => {
+                        self.write_vector_access(expr_handle, base, index, block)?
+                    }
+                    // Only binding arrays in the Handle address space will take this path (due to `is_intermediate`)
+                    crate::TypeInner::BindingArray {
+                        base: binding_type, ..
+                    } => {
+                        let space = match self.ir_function.expressions[base] {
+                            crate::Expression::GlobalVariable(gvar) => {
+                                self.ir_module.global_variables[gvar].space
+                            }
+                            _ => unreachable!(),
+                        };
+                        let binding_array_false_pointer = LookupType::Local(LocalType::Pointer {
+                            base: binding_type,
+                            class: helpers::map_storage_class(space),
+                        });
+
+                        let result_id = match self.write_expression_pointer(
+                            expr_handle,
+                            block,
+                            Some(binding_array_false_pointer),
+                        )? {
+                            ExpressionPointer::Ready { pointer_id } => pointer_id,
+                            ExpressionPointer::Conditional { .. } => {
+                                return Err(Error::FeatureNotImplemented(
+                                    "Texture array out-of-bounds handling",
+                                ));
+                            }
+                        };
+
+                        let binding_type_id = self.get_type_id(LookupType::Handle(binding_type));
+
+                        let load_id = self.gen_id();
+                        block.body.push(Instruction::load(
+                            binding_type_id,
+                            load_id,
+                            result_id,
+                            None,
+                        ));
+
+                        // Subsequent image operations require the image/sampler to be decorated as NonUniform
+                        // if the image/sampler binding array was accessed with a non-uniform index
+                        // see VUID-RuntimeSpirv-NonUniform-06274
+                        if self.fun_info[index].uniformity.non_uniform_result.is_some() {
+                            self.writer
+                                .decorate_non_uniform_binding_array_access(load_id)?;
+                        }
+
+                        load_id
+                    }
+                    ref other => {
+                        log::error!(
+                            "Unable to access base {:?} of type {:?}",
+                            self.ir_function.expressions[base],
+                            other
+                        );
+                        return Err(Error::Validation(
+                            "only vectors may be dynamically indexed by value",
+                        ));
+                    }
+                }
+            }
+            crate::Expression::AccessIndex { base, index: _ } if self.is_intermediate(base) => {
+                // See `is_intermediate`; we'll handle this later in
+                // `write_expression_pointer`.
+                0
+            }
+            crate::Expression::AccessIndex { base, index } => {
+                match *self.fun_info[base].ty.inner_with(&self.ir_module.types) {
+                    crate::TypeInner::Vector { .. }
+                    | crate::TypeInner::Matrix { .. }
+                    | crate::TypeInner::Array { .. }
+                    | crate::TypeInner::Struct { .. } => {
+                        // We never need bounds checks here: dynamically sized arrays can
+                        // only appear behind pointers, and are thus handled by the
+                        // `is_intermediate` case above. Everything else's size is
+                        // statically known and checked in validation.
+                        let id = self.gen_id();
+                        let base_id = self.cached[base];
+                        block.body.push(Instruction::composite_extract(
+                            result_type_id,
+                            id,
+                            base_id,
+                            &[index],
+                        ));
+                        id
+                    }
+                    // Only binding arrays in the Handle address space will take this path (due to `is_intermediate`)
+                    crate::TypeInner::BindingArray {
+                        base: binding_type, ..
+                    } => {
+                        let space = match self.ir_function.expressions[base] {
+                            crate::Expression::GlobalVariable(gvar) => {
+                                self.ir_module.global_variables[gvar].space
+                            }
+                            _ => unreachable!(),
+                        };
+                        let binding_array_false_pointer = LookupType::Local(LocalType::Pointer {
+                            base: binding_type,
+                            class: helpers::map_storage_class(space),
+                        });
+
+                        let result_id = match self.write_expression_pointer(
+                            expr_handle,
+                            block,
+                            Some(binding_array_false_pointer),
+                        )? {
+                            ExpressionPointer::Ready { pointer_id } => pointer_id,
+                            ExpressionPointer::Conditional { .. } => {
+                                return Err(Error::FeatureNotImplemented(
+                                    "Texture array out-of-bounds handling",
+                                ));
+                            }
+                        };
+
+                        let binding_type_id = self.get_type_id(LookupType::Handle(binding_type));
+
+                        let load_id = self.gen_id();
+                        block.body.push(Instruction::load(
+                            binding_type_id,
+                            load_id,
+                            result_id,
+                            None,
+                        ));
+
+                        load_id
+                    }
+                    ref other => {
+                        log::error!("Unable to access index of {:?}", other);
+                        return Err(Error::FeatureNotImplemented("access index for type"));
+                    }
+                }
+            }
+            crate::Expression::GlobalVariable(handle) => {
+                self.writer.global_variables[handle.index()].access_id
+            }
+            crate::Expression::Swizzle {
+                size,
+                vector,
+                pattern,
+            } => {
+                let vector_id = self.cached[vector];
+                self.temp_list.clear();
+                for &sc in pattern[..size as usize].iter() {
+                    self.temp_list.push(sc as Word);
+                }
+                let id = self.gen_id();
+                block.body.push(Instruction::vector_shuffle(
+                    result_type_id,
+                    id,
+                    vector_id,
+                    vector_id,
+                    &self.temp_list,
+                ));
+                id
+            }
+            crate::Expression::Unary { op, expr } => {
+                let id = self.gen_id();
+                let expr_id = self.cached[expr];
+                let expr_ty_inner = self.fun_info[expr].ty.inner_with(&self.ir_module.types);
+
+                let spirv_op = match op {
+                    crate::UnaryOperator::Negate => match expr_ty_inner.scalar_kind() {
+                        Some(crate::ScalarKind::Float) => spirv::Op::FNegate,
+                        Some(crate::ScalarKind::Sint) => spirv::Op::SNegate,
+                        _ => return Err(Error::Validation("Unexpected kind for negation")),
+                    },
+                    crate::UnaryOperator::LogicalNot => spirv::Op::LogicalNot,
+                    crate::UnaryOperator::BitwiseNot => spirv::Op::Not,
+                };
+
+                block
+                    .body
+                    .push(Instruction::unary(spirv_op, result_type_id, id, expr_id));
+                id
+            }
+            crate::Expression::Binary { op, left, right } => {
+                let id = self.gen_id();
+                let left_id = self.cached[left];
+                let right_id = self.cached[right];
+
+                let left_ty_inner = self.fun_info[left].ty.inner_with(&self.ir_module.types);
+                let right_ty_inner = self.fun_info[right].ty.inner_with(&self.ir_module.types);
+
+                let left_dimension = get_dimension(left_ty_inner);
+                let right_dimension = get_dimension(right_ty_inner);
+
+                let mut reverse_operands = false;
+
+                let spirv_op = match op {
+                    crate::BinaryOperator::Add => match *left_ty_inner {
+                        crate::TypeInner::Scalar(scalar)
+                        | crate::TypeInner::Vector { scalar, .. } => match scalar.kind {
+                            crate::ScalarKind::Float => spirv::Op::FAdd,
+                            _ => spirv::Op::IAdd,
+                        },
+                        crate::TypeInner::Matrix {
+                            columns,
+                            rows,
+                            scalar,
+                        } => {
+                            self.write_matrix_matrix_column_op(
+                                block,
+                                id,
+                                result_type_id,
+                                left_id,
+                                right_id,
+                                columns,
+                                rows,
+                                scalar.width,
+                                spirv::Op::FAdd,
+                            );
+
+                            self.cached[expr_handle] = id;
+                            return Ok(());
+                        }
+                        _ => unimplemented!(),
+                    },
+                    crate::BinaryOperator::Subtract => match *left_ty_inner {
+                        crate::TypeInner::Scalar(scalar)
+                        | crate::TypeInner::Vector { scalar, .. } => match scalar.kind {
+                            crate::ScalarKind::Float => spirv::Op::FSub,
+                            _ => spirv::Op::ISub,
+                        },
+                        crate::TypeInner::Matrix {
+                            columns,
+                            rows,
+                            scalar,
+                        } => {
+                            self.write_matrix_matrix_column_op(
+                                block,
+                                id,
+                                result_type_id,
+                                left_id,
+                                right_id,
+                                columns,
+                                rows,
+                                scalar.width,
+                                spirv::Op::FSub,
+                            );
+
+                            self.cached[expr_handle] = id;
+                            return Ok(());
+                        }
+                        _ => unimplemented!(),
+                    },
+                    crate::BinaryOperator::Multiply => match (left_dimension, right_dimension) {
+                        (Dimension::Scalar, Dimension::Vector) => {
+                            self.write_vector_scalar_mult(
+                                block,
+                                id,
+                                result_type_id,
+                                right_id,
+                                left_id,
+                                right_ty_inner,
+                            );
+
+                            self.cached[expr_handle] = id;
+                            return Ok(());
+                        }
+                        (Dimension::Vector, Dimension::Scalar) => {
+                            self.write_vector_scalar_mult(
+                                block,
+                                id,
+                                result_type_id,
+                                left_id,
+                                right_id,
+                                left_ty_inner,
+                            );
+
+                            self.cached[expr_handle] = id;
+                            return Ok(());
+                        }
+                        (Dimension::Vector, Dimension::Matrix) => spirv::Op::VectorTimesMatrix,
+                        (Dimension::Matrix, Dimension::Scalar) => spirv::Op::MatrixTimesScalar,
+                        (Dimension::Scalar, Dimension::Matrix) => {
+                            reverse_operands = true;
+                            spirv::Op::MatrixTimesScalar
+                        }
+                        (Dimension::Matrix, Dimension::Vector) => spirv::Op::MatrixTimesVector,
+                        (Dimension::Matrix, Dimension::Matrix) => spirv::Op::MatrixTimesMatrix,
+                        (Dimension::Vector, Dimension::Vector)
+                        | (Dimension::Scalar, Dimension::Scalar)
+                            if left_ty_inner.scalar_kind() == Some(crate::ScalarKind::Float) =>
+                        {
+                            spirv::Op::FMul
+                        }
+                        (Dimension::Vector, Dimension::Vector)
+                        | (Dimension::Scalar, Dimension::Scalar) => spirv::Op::IMul,
+                    },
+                    crate::BinaryOperator::Divide => match left_ty_inner.scalar_kind() {
+                        Some(crate::ScalarKind::Sint) => spirv::Op::SDiv,
+                        Some(crate::ScalarKind::Uint) => spirv::Op::UDiv,
+                        Some(crate::ScalarKind::Float) => spirv::Op::FDiv,
+                        _ => unimplemented!(),
+                    },
+                    crate::BinaryOperator::Modulo => match left_ty_inner.scalar_kind() {
+                        // TODO: handle undefined behavior
+                        // if right == 0 return 0
+                        // if left == min(type_of(left)) && right == -1 return 0
+                        Some(crate::ScalarKind::Sint) => spirv::Op::SRem,
+                        // TODO: handle undefined behavior
+                        // if right == 0 return 0
+                        Some(crate::ScalarKind::Uint) => spirv::Op::UMod,
+                        // TODO: handle undefined behavior
+                        // if right == 0 return ? see https://github.com/gpuweb/gpuweb/issues/2798
+                        Some(crate::ScalarKind::Float) => spirv::Op::FRem,
+                        _ => unimplemented!(),
+                    },
+                    crate::BinaryOperator::Equal => match left_ty_inner.scalar_kind() {
+                        Some(crate::ScalarKind::Sint | crate::ScalarKind::Uint) => {
+                            spirv::Op::IEqual
+                        }
+                        Some(crate::ScalarKind::Float) => spirv::Op::FOrdEqual,
+                        Some(crate::ScalarKind::Bool) => spirv::Op::LogicalEqual,
+                        _ => unimplemented!(),
+                    },
+                    crate::BinaryOperator::NotEqual => match left_ty_inner.scalar_kind() {
+                        Some(crate::ScalarKind::Sint | crate::ScalarKind::Uint) => {
+                            spirv::Op::INotEqual
+                        }
+                        Some(crate::ScalarKind::Float) => spirv::Op::FOrdNotEqual,
+                        Some(crate::ScalarKind::Bool) => spirv::Op::LogicalNotEqual,
+                        _ => unimplemented!(),
+                    },
+                    crate::BinaryOperator::Less => match left_ty_inner.scalar_kind() {
+                        Some(crate::ScalarKind::Sint) => spirv::Op::SLessThan,
+                        Some(crate::ScalarKind::Uint) => spirv::Op::ULessThan,
+                        Some(crate::ScalarKind::Float) => spirv::Op::FOrdLessThan,
+                        _ => unimplemented!(),
+                    },
+                    crate::BinaryOperator::LessEqual => match left_ty_inner.scalar_kind() {
+                        Some(crate::ScalarKind::Sint) => spirv::Op::SLessThanEqual,
+                        Some(crate::ScalarKind::Uint) => spirv::Op::ULessThanEqual,
+                        Some(crate::ScalarKind::Float) => spirv::Op::FOrdLessThanEqual,
+                        _ => unimplemented!(),
+                    },
+                    crate::BinaryOperator::Greater => match left_ty_inner.scalar_kind() {
+                        Some(crate::ScalarKind::Sint) => spirv::Op::SGreaterThan,
+                        Some(crate::ScalarKind::Uint) => spirv::Op::UGreaterThan,
+                        Some(crate::ScalarKind::Float) => spirv::Op::FOrdGreaterThan,
+                        _ => unimplemented!(),
+                    },
+                    crate::BinaryOperator::GreaterEqual => match left_ty_inner.scalar_kind() {
+                        Some(crate::ScalarKind::Sint) => spirv::Op::SGreaterThanEqual,
+                        Some(crate::ScalarKind::Uint) => spirv::Op::UGreaterThanEqual,
+                        Some(crate::ScalarKind::Float) => spirv::Op::FOrdGreaterThanEqual,
+                        _ => unimplemented!(),
+                    },
+                    crate::BinaryOperator::And => match left_ty_inner.scalar_kind() {
+                        Some(crate::ScalarKind::Bool) => spirv::Op::LogicalAnd,
+                        _ => spirv::Op::BitwiseAnd,
+                    },
+                    crate::BinaryOperator::ExclusiveOr => spirv::Op::BitwiseXor,
+                    crate::BinaryOperator::InclusiveOr => match left_ty_inner.scalar_kind() {
+                        Some(crate::ScalarKind::Bool) => spirv::Op::LogicalOr,
+                        _ => spirv::Op::BitwiseOr,
+                    },
+                    crate::BinaryOperator::LogicalAnd => spirv::Op::LogicalAnd,
+                    crate::BinaryOperator::LogicalOr => spirv::Op::LogicalOr,
+                    crate::BinaryOperator::ShiftLeft => spirv::Op::ShiftLeftLogical,
+                    crate::BinaryOperator::ShiftRight => match left_ty_inner.scalar_kind() {
+                        Some(crate::ScalarKind::Sint) => spirv::Op::ShiftRightArithmetic,
+                        Some(crate::ScalarKind::Uint) => spirv::Op::ShiftRightLogical,
+                        _ => unimplemented!(),
+                    },
+                };
+
+                block.body.push(Instruction::binary(
+                    spirv_op,
+                    result_type_id,
+                    id,
+                    if reverse_operands { right_id } else { left_id },
+                    if reverse_operands { left_id } else { right_id },
+                ));
+                id
+            }
+            crate::Expression::Math {
+                fun,
+                arg,
+                arg1,
+                arg2,
+                arg3,
+            } => {
+                use crate::MathFunction as Mf;
+                enum MathOp {
+                    Ext(spirv::GLOp),
+                    Custom(Instruction),
+                }
+
+                let arg0_id = self.cached[arg];
+                let arg_ty = self.fun_info[arg].ty.inner_with(&self.ir_module.types);
+                let arg_scalar_kind = arg_ty.scalar_kind();
+                let arg1_id = match arg1 {
+                    Some(handle) => self.cached[handle],
+                    None => 0,
+                };
+                let arg2_id = match arg2 {
+                    Some(handle) => self.cached[handle],
+                    None => 0,
+                };
+                let arg3_id = match arg3 {
+                    Some(handle) => self.cached[handle],
+                    None => 0,
+                };
+
+                let id = self.gen_id();
+                let math_op = match fun {
+                    // comparison
+                    Mf::Abs => {
+                        match arg_scalar_kind {
+                            Some(crate::ScalarKind::Float) => MathOp::Ext(spirv::GLOp::FAbs),
+                            Some(crate::ScalarKind::Sint) => MathOp::Ext(spirv::GLOp::SAbs),
+                            Some(crate::ScalarKind::Uint) => {
+                                MathOp::Custom(Instruction::unary(
+                                    spirv::Op::CopyObject, // do nothing
+                                    result_type_id,
+                                    id,
+                                    arg0_id,
+                                ))
+                            }
+                            other => unimplemented!("Unexpected abs({:?})", other),
+                        }
+                    }
+                    Mf::Min => MathOp::Ext(match arg_scalar_kind {
+                        Some(crate::ScalarKind::Float) => spirv::GLOp::FMin,
+                        Some(crate::ScalarKind::Sint) => spirv::GLOp::SMin,
+                        Some(crate::ScalarKind::Uint) => spirv::GLOp::UMin,
+                        other => unimplemented!("Unexpected min({:?})", other),
+                    }),
+                    Mf::Max => MathOp::Ext(match arg_scalar_kind {
+                        Some(crate::ScalarKind::Float) => spirv::GLOp::FMax,
+                        Some(crate::ScalarKind::Sint) => spirv::GLOp::SMax,
+                        Some(crate::ScalarKind::Uint) => spirv::GLOp::UMax,
+                        other => unimplemented!("Unexpected max({:?})", other),
+                    }),
+                    Mf::Clamp => MathOp::Ext(match arg_scalar_kind {
+                        Some(crate::ScalarKind::Float) => spirv::GLOp::FClamp,
+                        Some(crate::ScalarKind::Sint) => spirv::GLOp::SClamp,
+                        Some(crate::ScalarKind::Uint) => spirv::GLOp::UClamp,
+                        other => unimplemented!("Unexpected max({:?})", other),
+                    }),
+                    Mf::Saturate => {
+                        let (maybe_size, scalar) = match *arg_ty {
+                            crate::TypeInner::Vector { size, scalar } => (Some(size), scalar),
+                            crate::TypeInner::Scalar(scalar) => (None, scalar),
+                            ref other => unimplemented!("Unexpected saturate({:?})", other),
+                        };
+                        let scalar = crate::Scalar::float(scalar.width);
+                        let mut arg1_id = self.writer.get_constant_scalar_with(0, scalar)?;
+                        let mut arg2_id = self.writer.get_constant_scalar_with(1, scalar)?;
+
+                        if let Some(size) = maybe_size {
+                            let ty = LocalType::Value {
+                                vector_size: Some(size),
+                                scalar,
+                                pointer_space: None,
+                            }
+                            .into();
+
+                            self.temp_list.clear();
+                            self.temp_list.resize(size as _, arg1_id);
+
+                            arg1_id = self.writer.get_constant_composite(ty, &self.temp_list);
+
+                            self.temp_list.fill(arg2_id);
+
+                            arg2_id = self.writer.get_constant_composite(ty, &self.temp_list);
+                        }
+
+                        MathOp::Custom(Instruction::ext_inst(
+                            self.writer.gl450_ext_inst_id,
+                            spirv::GLOp::FClamp,
+                            result_type_id,
+                            id,
+                            &[arg0_id, arg1_id, arg2_id],
+                        ))
+                    }
+                    // trigonometry
+                    Mf::Sin => MathOp::Ext(spirv::GLOp::Sin),
+                    Mf::Sinh => MathOp::Ext(spirv::GLOp::Sinh),
+                    Mf::Asin => MathOp::Ext(spirv::GLOp::Asin),
+                    Mf::Cos => MathOp::Ext(spirv::GLOp::Cos),
+                    Mf::Cosh => MathOp::Ext(spirv::GLOp::Cosh),
+                    Mf::Acos => MathOp::Ext(spirv::GLOp::Acos),
+                    Mf::Tan => MathOp::Ext(spirv::GLOp::Tan),
+                    Mf::Tanh => MathOp::Ext(spirv::GLOp::Tanh),
+                    Mf::Atan => MathOp::Ext(spirv::GLOp::Atan),
+                    Mf::Atan2 => MathOp::Ext(spirv::GLOp::Atan2),
+                    Mf::Asinh => MathOp::Ext(spirv::GLOp::Asinh),
+                    Mf::Acosh => MathOp::Ext(spirv::GLOp::Acosh),
+                    Mf::Atanh => MathOp::Ext(spirv::GLOp::Atanh),
+                    Mf::Radians => MathOp::Ext(spirv::GLOp::Radians),
+                    Mf::Degrees => MathOp::Ext(spirv::GLOp::Degrees),
+                    // decomposition
+                    Mf::Ceil => MathOp::Ext(spirv::GLOp::Ceil),
+                    Mf::Round => MathOp::Ext(spirv::GLOp::RoundEven),
+                    Mf::Floor => MathOp::Ext(spirv::GLOp::Floor),
+                    Mf::Fract => MathOp::Ext(spirv::GLOp::Fract),
+                    Mf::Trunc => MathOp::Ext(spirv::GLOp::Trunc),
+                    Mf::Modf => MathOp::Ext(spirv::GLOp::ModfStruct),
+                    Mf::Frexp => MathOp::Ext(spirv::GLOp::FrexpStruct),
+                    Mf::Ldexp => MathOp::Ext(spirv::GLOp::Ldexp),
+                    // geometry
+                    Mf::Dot => match *self.fun_info[arg].ty.inner_with(&self.ir_module.types) {
+                        crate::TypeInner::Vector {
+                            scalar:
+                                crate::Scalar {
+                                    kind: crate::ScalarKind::Float,
+                                    ..
+                                },
+                            ..
+                        } => MathOp::Custom(Instruction::binary(
+                            spirv::Op::Dot,
+                            result_type_id,
+                            id,
+                            arg0_id,
+                            arg1_id,
+                        )),
+                        // TODO: consider using integer dot product if VK_KHR_shader_integer_dot_product is available
+                        crate::TypeInner::Vector { size, .. } => {
+                            self.write_dot_product(
+                                id,
+                                result_type_id,
+                                arg0_id,
+                                arg1_id,
+                                size as u32,
+                                block,
+                            );
+                            self.cached[expr_handle] = id;
+                            return Ok(());
+                        }
+                        _ => unreachable!(
+                            "Correct TypeInner for dot product should be already validated"
+                        ),
+                    },
+                    Mf::Outer => MathOp::Custom(Instruction::binary(
+                        spirv::Op::OuterProduct,
+                        result_type_id,
+                        id,
+                        arg0_id,
+                        arg1_id,
+                    )),
+                    Mf::Cross => MathOp::Ext(spirv::GLOp::Cross),
+                    Mf::Distance => MathOp::Ext(spirv::GLOp::Distance),
+                    Mf::Length => MathOp::Ext(spirv::GLOp::Length),
+                    Mf::Normalize => MathOp::Ext(spirv::GLOp::Normalize),
+                    Mf::FaceForward => MathOp::Ext(spirv::GLOp::FaceForward),
+                    Mf::Reflect => MathOp::Ext(spirv::GLOp::Reflect),
+                    Mf::Refract => MathOp::Ext(spirv::GLOp::Refract),
+                    // exponent
+                    Mf::Exp => MathOp::Ext(spirv::GLOp::Exp),
+                    Mf::Exp2 => MathOp::Ext(spirv::GLOp::Exp2),
+                    Mf::Log => MathOp::Ext(spirv::GLOp::Log),
+                    Mf::Log2 => MathOp::Ext(spirv::GLOp::Log2),
+                    Mf::Pow => MathOp::Ext(spirv::GLOp::Pow),
+                    // computational
+                    Mf::Sign => MathOp::Ext(match arg_scalar_kind {
+                        Some(crate::ScalarKind::Float) => spirv::GLOp::FSign,
+                        Some(crate::ScalarKind::Sint) => spirv::GLOp::SSign,
+                        other => unimplemented!("Unexpected sign({:?})", other),
+                    }),
+                    Mf::Fma => MathOp::Ext(spirv::GLOp::Fma),
+                    Mf::Mix => {
+                        let selector = arg2.unwrap();
+                        let selector_ty =
+                            self.fun_info[selector].ty.inner_with(&self.ir_module.types);
+                        match (arg_ty, selector_ty) {
+                            // if the selector is a scalar, we need to splat it
+                            (
+                                &crate::TypeInner::Vector { size, .. },
+                                &crate::TypeInner::Scalar(scalar),
+                            ) => {
+                                let selector_type_id =
+                                    self.get_type_id(LookupType::Local(LocalType::Value {
+                                        vector_size: Some(size),
+                                        scalar,
+                                        pointer_space: None,
+                                    }));
+                                self.temp_list.clear();
+                                self.temp_list.resize(size as usize, arg2_id);
+
+                                let selector_id = self.gen_id();
+                                block.body.push(Instruction::composite_construct(
+                                    selector_type_id,
+                                    selector_id,
+                                    &self.temp_list,
+                                ));
+
+                                MathOp::Custom(Instruction::ext_inst(
+                                    self.writer.gl450_ext_inst_id,
+                                    spirv::GLOp::FMix,
+                                    result_type_id,
+                                    id,
+                                    &[arg0_id, arg1_id, selector_id],
+                                ))
+                            }
+                            _ => MathOp::Ext(spirv::GLOp::FMix),
+                        }
+                    }
+                    Mf::Step => MathOp::Ext(spirv::GLOp::Step),
+                    Mf::SmoothStep => MathOp::Ext(spirv::GLOp::SmoothStep),
+                    Mf::Sqrt => MathOp::Ext(spirv::GLOp::Sqrt),
+                    Mf::InverseSqrt => MathOp::Ext(spirv::GLOp::InverseSqrt),
+                    Mf::Inverse => MathOp::Ext(spirv::GLOp::MatrixInverse),
+                    Mf::Transpose => MathOp::Custom(Instruction::unary(
+                        spirv::Op::Transpose,
+                        result_type_id,
+                        id,
+                        arg0_id,
+                    )),
+                    Mf::Determinant => MathOp::Ext(spirv::GLOp::Determinant),
+                    Mf::ReverseBits => MathOp::Custom(Instruction::unary(
+                        spirv::Op::BitReverse,
+                        result_type_id,
+                        id,
+                        arg0_id,
+                    )),
+                    Mf::CountTrailingZeros => {
+                        let uint_id = match *arg_ty {
+                            crate::TypeInner::Vector { size, mut scalar } => {
+                                scalar.kind = crate::ScalarKind::Uint;
+                                let ty = LocalType::Value {
+                                    vector_size: Some(size),
+                                    scalar,
+                                    pointer_space: None,
+                                }
+                                .into();
+
+                                self.temp_list.clear();
+                                self.temp_list.resize(
+                                    size as _,
+                                    self.writer.get_constant_scalar_with(32, scalar)?,
+                                );
+
+                                self.writer.get_constant_composite(ty, &self.temp_list)
+                            }
+                            crate::TypeInner::Scalar(mut scalar) => {
+                                scalar.kind = crate::ScalarKind::Uint;
+                                self.writer.get_constant_scalar_with(32, scalar)?
+                            }
+                            _ => unreachable!(),
+                        };
+
+                        let lsb_id = self.gen_id();
+                        block.body.push(Instruction::ext_inst(
+                            self.writer.gl450_ext_inst_id,
+                            spirv::GLOp::FindILsb,
+                            result_type_id,
+                            lsb_id,
+                            &[arg0_id],
+                        ));
+
+                        MathOp::Custom(Instruction::ext_inst(
+                            self.writer.gl450_ext_inst_id,
+                            spirv::GLOp::UMin,
+                            result_type_id,
+                            id,
+                            &[uint_id, lsb_id],
+                        ))
+                    }
+                    Mf::CountLeadingZeros => {
+                        let (int_type_id, int_id) = match *arg_ty {
+                            crate::TypeInner::Vector { size, mut scalar } => {
+                                scalar.kind = crate::ScalarKind::Sint;
+                                let ty = LocalType::Value {
+                                    vector_size: Some(size),
+                                    scalar,
+                                    pointer_space: None,
+                                }
+                                .into();
+
+                                self.temp_list.clear();
+                                self.temp_list.resize(
+                                    size as _,
+                                    self.writer.get_constant_scalar_with(31, scalar)?,
+                                );
+
+                                (
+                                    self.get_type_id(ty),
+                                    self.writer.get_constant_composite(ty, &self.temp_list),
+                                )
+                            }
+                            crate::TypeInner::Scalar(mut scalar) => {
+                                scalar.kind = crate::ScalarKind::Sint;
+                                (
+                                    self.get_type_id(LookupType::Local(LocalType::Value {
+                                        vector_size: None,
+                                        scalar,
+                                        pointer_space: None,
+                                    })),
+                                    self.writer.get_constant_scalar_with(31, scalar)?,
+                                )
+                            }
+                            _ => unreachable!(),
+                        };
+
+                        let msb_id = self.gen_id();
+                        block.body.push(Instruction::ext_inst(
+                            self.writer.gl450_ext_inst_id,
+                            spirv::GLOp::FindUMsb,
+                            int_type_id,
+                            msb_id,
+                            &[arg0_id],
+                        ));
+
+                        MathOp::Custom(Instruction::binary(
+                            spirv::Op::ISub,
+                            result_type_id,
+                            id,
+                            int_id,
+                            msb_id,
+                        ))
+                    }
+                    Mf::CountOneBits => MathOp::Custom(Instruction::unary(
+                        spirv::Op::BitCount,
+                        result_type_id,
+                        id,
+                        arg0_id,
+                    )),
+                    Mf::ExtractBits => {
+                        let op = match arg_scalar_kind {
+                            Some(crate::ScalarKind::Uint) => spirv::Op::BitFieldUExtract,
+                            Some(crate::ScalarKind::Sint) => spirv::Op::BitFieldSExtract,
+                            other => unimplemented!("Unexpected sign({:?})", other),
+                        };
+                        MathOp::Custom(Instruction::ternary(
+                            op,
+                            result_type_id,
+                            id,
+                            arg0_id,
+                            arg1_id,
+                            arg2_id,
+                        ))
+                    }
+                    Mf::InsertBits => MathOp::Custom(Instruction::quaternary(
+                        spirv::Op::BitFieldInsert,
+                        result_type_id,
+                        id,
+                        arg0_id,
+                        arg1_id,
+                        arg2_id,
+                        arg3_id,
+                    )),
+                    Mf::FindLsb => MathOp::Ext(spirv::GLOp::FindILsb),
+                    Mf::FindMsb => MathOp::Ext(match arg_scalar_kind {
+                        Some(crate::ScalarKind::Uint) => spirv::GLOp::FindUMsb,
+                        Some(crate::ScalarKind::Sint) => spirv::GLOp::FindSMsb,
+                        other => unimplemented!("Unexpected findMSB({:?})", other),
+                    }),
+                    Mf::Pack4x8unorm => MathOp::Ext(spirv::GLOp::PackUnorm4x8),
+                    Mf::Pack4x8snorm => MathOp::Ext(spirv::GLOp::PackSnorm4x8),
+                    Mf::Pack2x16float => MathOp::Ext(spirv::GLOp::PackHalf2x16),
+                    Mf::Pack2x16unorm => MathOp::Ext(spirv::GLOp::PackUnorm2x16),
+                    Mf::Pack2x16snorm => MathOp::Ext(spirv::GLOp::PackSnorm2x16),
+                    Mf::Unpack4x8unorm => MathOp::Ext(spirv::GLOp::UnpackUnorm4x8),
+                    Mf::Unpack4x8snorm => MathOp::Ext(spirv::GLOp::UnpackSnorm4x8),
+                    Mf::Unpack2x16float => MathOp::Ext(spirv::GLOp::UnpackHalf2x16),
+                    Mf::Unpack2x16unorm => MathOp::Ext(spirv::GLOp::UnpackUnorm2x16),
+                    Mf::Unpack2x16snorm => MathOp::Ext(spirv::GLOp::UnpackSnorm2x16),
+                };
+
+                block.body.push(match math_op {
+                    MathOp::Ext(op) => Instruction::ext_inst(
+                        self.writer.gl450_ext_inst_id,
+                        op,
+                        result_type_id,
+                        id,
+                        &[arg0_id, arg1_id, arg2_id, arg3_id][..fun.argument_count()],
+                    ),
+                    MathOp::Custom(inst) => inst,
+                });
+                id
+            }
+            crate::Expression::LocalVariable(variable) => self.function.variables[&variable].id,
+            crate::Expression::Load { pointer } => {
+                match self.write_expression_pointer(pointer, block, None)? {
+                    ExpressionPointer::Ready { pointer_id } => {
+                        let id = self.gen_id();
+                        let atomic_space =
+                            match *self.fun_info[pointer].ty.inner_with(&self.ir_module.types) {
+                                crate::TypeInner::Pointer { base, space } => {
+                                    match self.ir_module.types[base].inner {
+                                        crate::TypeInner::Atomic { .. } => Some(space),
+                                        _ => None,
+                                    }
+                                }
+                                _ => None,
+                            };
+                        let instruction = if let Some(space) = atomic_space {
+                            let (semantics, scope) = space.to_spirv_semantics_and_scope();
+                            let scope_constant_id = self.get_scope_constant(scope as u32);
+                            let semantics_id = self.get_index_constant(semantics.bits());
+                            Instruction::atomic_load(
+                                result_type_id,
+                                id,
+                                pointer_id,
+                                scope_constant_id,
+                                semantics_id,
+                            )
+                        } else {
+                            Instruction::load(result_type_id, id, pointer_id, None)
+                        };
+                        block.body.push(instruction);
+                        id
+                    }
+                    ExpressionPointer::Conditional { condition, access } => {
+                        //TODO: support atomics?
+                        self.write_conditional_indexed_load(
+                            result_type_id,
+                            condition,
+                            block,
+                            move |id_gen, block| {
+                                // The in-bounds path. Perform the access and the load.
+                                let pointer_id = access.result_id.unwrap();
+                                let value_id = id_gen.next();
+                                block.body.push(access);
+                                block.body.push(Instruction::load(
+                                    result_type_id,
+                                    value_id,
+                                    pointer_id,
+                                    None,
+                                ));
+                                value_id
+                            },
+                        )
+                    }
+                }
+            }
+            crate::Expression::FunctionArgument(index) => self.function.parameter_id(index),
+            crate::Expression::CallResult(_)
+            | crate::Expression::AtomicResult { .. }
+            | crate::Expression::WorkGroupUniformLoadResult { .. }
+            | crate::Expression::RayQueryProceedResult => self.cached[expr_handle],
+            crate::Expression::As {
+                expr,
+                kind,
+                convert,
+            } => {
+                use crate::ScalarKind as Sk;
+
+                let expr_id = self.cached[expr];
+                let (src_scalar, src_size, is_matrix) =
+                    match *self.fun_info[expr].ty.inner_with(&self.ir_module.types) {
+                        crate::TypeInner::Scalar(scalar) => (scalar, None, false),
+                        crate::TypeInner::Vector { scalar, size } => (scalar, Some(size), false),
+                        crate::TypeInner::Matrix { scalar, .. } => (scalar, None, true),
+                        ref other => {
+                            log::error!("As source {:?}", other);
+                            return Err(Error::Validation("Unexpected Expression::As source"));
+                        }
+                    };
+
+                enum Cast {
+                    Identity,
+                    Unary(spirv::Op),
+                    Binary(spirv::Op, Word),
+                    Ternary(spirv::Op, Word, Word),
+                }
+
+                let cast = if is_matrix {
+                    // we only support identity casts for matrices
+                    Cast::Unary(spirv::Op::CopyObject)
+                } else {
+                    match (src_scalar.kind, kind, convert) {
+                        // Filter out identity casts. Some Adreno drivers are
+                        // confused by no-op OpBitCast instructions.
+                        (src_kind, kind, convert)
+                            if src_kind == kind
+                                && convert.filter(|&width| width != src_scalar.width).is_none() =>
+                        {
+                            Cast::Identity
+                        }
+                        (Sk::Bool, Sk::Bool, _) => Cast::Unary(spirv::Op::CopyObject),
+                        (_, _, None) => Cast::Unary(spirv::Op::Bitcast),
+                        // casting to a bool - generate `OpXxxNotEqual`
+                        (_, Sk::Bool, Some(_)) => {
+                            let op = match src_scalar.kind {
+                                Sk::Sint | Sk::Uint => spirv::Op::INotEqual,
+                                Sk::Float => spirv::Op::FUnordNotEqual,
+                                Sk::Bool | Sk::AbstractInt | Sk::AbstractFloat => unreachable!(),
+                            };
+                            let zero_scalar_id =
+                                self.writer.get_constant_scalar_with(0, src_scalar)?;
+                            let zero_id = match src_size {
+                                Some(size) => {
+                                    let ty = LocalType::Value {
+                                        vector_size: Some(size),
+                                        scalar: src_scalar,
+                                        pointer_space: None,
+                                    }
+                                    .into();
+
+                                    self.temp_list.clear();
+                                    self.temp_list.resize(size as _, zero_scalar_id);
+
+                                    self.writer.get_constant_composite(ty, &self.temp_list)
+                                }
+                                None => zero_scalar_id,
+                            };
+
+                            Cast::Binary(op, zero_id)
+                        }
+                        // casting from a bool - generate `OpSelect`
+                        (Sk::Bool, _, Some(dst_width)) => {
+                            let dst_scalar = crate::Scalar {
+                                kind,
+                                width: dst_width,
+                            };
+                            let zero_scalar_id =
+                                self.writer.get_constant_scalar_with(0, dst_scalar)?;
+                            let one_scalar_id =
+                                self.writer.get_constant_scalar_with(1, dst_scalar)?;
+                            let (accept_id, reject_id) = match src_size {
+                                Some(size) => {
+                                    let ty = LocalType::Value {
+                                        vector_size: Some(size),
+                                        scalar: dst_scalar,
+                                        pointer_space: None,
+                                    }
+                                    .into();
+
+                                    self.temp_list.clear();
+                                    self.temp_list.resize(size as _, zero_scalar_id);
+
+                                    let vec0_id =
+                                        self.writer.get_constant_composite(ty, &self.temp_list);
+
+                                    self.temp_list.fill(one_scalar_id);
+
+                                    let vec1_id =
+                                        self.writer.get_constant_composite(ty, &self.temp_list);
+
+                                    (vec1_id, vec0_id)
+                                }
+                                None => (one_scalar_id, zero_scalar_id),
+                            };
+
+                            Cast::Ternary(spirv::Op::Select, accept_id, reject_id)
+                        }
+                        (Sk::Float, Sk::Uint, Some(_)) => Cast::Unary(spirv::Op::ConvertFToU),
+                        (Sk::Float, Sk::Sint, Some(_)) => Cast::Unary(spirv::Op::ConvertFToS),
+                        (Sk::Float, Sk::Float, Some(dst_width))
+                            if src_scalar.width != dst_width =>
+                        {
+                            Cast::Unary(spirv::Op::FConvert)
+                        }
+                        (Sk::Sint, Sk::Float, Some(_)) => Cast::Unary(spirv::Op::ConvertSToF),
+                        (Sk::Sint, Sk::Sint, Some(dst_width)) if src_scalar.width != dst_width => {
+                            Cast::Unary(spirv::Op::SConvert)
+                        }
+                        (Sk::Uint, Sk::Float, Some(_)) => Cast::Unary(spirv::Op::ConvertUToF),
+                        (Sk::Uint, Sk::Uint, Some(dst_width)) if src_scalar.width != dst_width => {
+                            Cast::Unary(spirv::Op::UConvert)
+                        }
+                        // We assume it's either an identity cast, or int-uint.
+                        _ => Cast::Unary(spirv::Op::Bitcast),
+                    }
+                };
+
+                let id = self.gen_id();
+                let instruction = match cast {
+                    Cast::Identity => None,
+                    Cast::Unary(op) => Some(Instruction::unary(op, result_type_id, id, expr_id)),
+                    Cast::Binary(op, operand) => Some(Instruction::binary(
+                        op,
+                        result_type_id,
+                        id,
+                        expr_id,
+                        operand,
+                    )),
+                    Cast::Ternary(op, op1, op2) => Some(Instruction::ternary(
+                        op,
+                        result_type_id,
+                        id,
+                        expr_id,
+                        op1,
+                        op2,
+                    )),
+                };
+                if let Some(instruction) = instruction {
+                    block.body.push(instruction);
+                    id
+                } else {
+                    expr_id
+                }
+            }
+            crate::Expression::ImageLoad {
+                image,
+                coordinate,
+                array_index,
+                sample,
+                level,
+            } => self.write_image_load(
+                result_type_id,
+                image,
+                coordinate,
+                array_index,
+                level,
+                sample,
+                block,
+            )?,
+            crate::Expression::ImageSample {
+                image,
+                sampler,
+                gather,
+                coordinate,
+                array_index,
+                offset,
+                level,
+                depth_ref,
+            } => self.write_image_sample(
+                result_type_id,
+                image,
+                sampler,
+                gather,
+                coordinate,
+                array_index,
+                offset,
+                level,
+                depth_ref,
+                block,
+            )?,
+            crate::Expression::Select {
+                condition,
+                accept,
+                reject,
+            } => {
+                let id = self.gen_id();
+                let mut condition_id = self.cached[condition];
+                let accept_id = self.cached[accept];
+                let reject_id = self.cached[reject];
+
+                let condition_ty = self.fun_info[condition]
+                    .ty
+                    .inner_with(&self.ir_module.types);
+                let object_ty = self.fun_info[accept].ty.inner_with(&self.ir_module.types);
+
+                if let (
+                    &crate::TypeInner::Scalar(
+                        condition_scalar @ crate::Scalar {
+                            kind: crate::ScalarKind::Bool,
+                            ..
+                        },
+                    ),
+                    &crate::TypeInner::Vector { size, .. },
+                ) = (condition_ty, object_ty)
+                {
+                    self.temp_list.clear();
+                    self.temp_list.resize(size as usize, condition_id);
+
+                    let bool_vector_type_id =
+                        self.get_type_id(LookupType::Local(LocalType::Value {
+                            vector_size: Some(size),
+                            scalar: condition_scalar,
+                            pointer_space: None,
+                        }));
+
+                    let id = self.gen_id();
+                    block.body.push(Instruction::composite_construct(
+                        bool_vector_type_id,
+                        id,
+                        &self.temp_list,
+                    ));
+                    condition_id = id
+                }
+
+                let instruction =
+                    Instruction::select(result_type_id, id, condition_id, accept_id, reject_id);
+                block.body.push(instruction);
+                id
+            }
+            crate::Expression::Derivative { axis, ctrl, expr } => {
+                use crate::{DerivativeAxis as Axis, DerivativeControl as Ctrl};
+                match ctrl {
+                    Ctrl::Coarse | Ctrl::Fine => {
+                        self.writer.require_any(
+                            "DerivativeControl",
+                            &[spirv::Capability::DerivativeControl],
+                        )?;
+                    }
+                    Ctrl::None => {}
+                }
+                let id = self.gen_id();
+                let expr_id = self.cached[expr];
+                let op = match (axis, ctrl) {
+                    (Axis::X, Ctrl::Coarse) => spirv::Op::DPdxCoarse,
+                    (Axis::X, Ctrl::Fine) => spirv::Op::DPdxFine,
+                    (Axis::X, Ctrl::None) => spirv::Op::DPdx,
+                    (Axis::Y, Ctrl::Coarse) => spirv::Op::DPdyCoarse,
+                    (Axis::Y, Ctrl::Fine) => spirv::Op::DPdyFine,
+                    (Axis::Y, Ctrl::None) => spirv::Op::DPdy,
+                    (Axis::Width, Ctrl::Coarse) => spirv::Op::FwidthCoarse,
+                    (Axis::Width, Ctrl::Fine) => spirv::Op::FwidthFine,
+                    (Axis::Width, Ctrl::None) => spirv::Op::Fwidth,
+                };
+                block
+                    .body
+                    .push(Instruction::derivative(op, result_type_id, id, expr_id));
+                id
+            }
+            crate::Expression::ImageQuery { image, query } => {
+                self.write_image_query(result_type_id, image, query, block)?
+            }
+            crate::Expression::Relational { fun, argument } => {
+                use crate::RelationalFunction as Rf;
+                let arg_id = self.cached[argument];
+                let op = match fun {
+                    Rf::All => spirv::Op::All,
+                    Rf::Any => spirv::Op::Any,
+                    Rf::IsNan => spirv::Op::IsNan,
+                    Rf::IsInf => spirv::Op::IsInf,
+                };
+                let id = self.gen_id();
+                block
+                    .body
+                    .push(Instruction::relational(op, result_type_id, id, arg_id));
+                id
+            }
+            crate::Expression::ArrayLength(expr) => self.write_runtime_array_length(expr, block)?,
+            crate::Expression::RayQueryGetIntersection { query, committed } => {
+                if !committed {
+                    return Err(Error::FeatureNotImplemented("candidate intersection"));
+                }
+                self.write_ray_query_get_intersection(query, block)
+            }
+        };
+
+        self.cached[expr_handle] = id;
+        Ok(())
+    }
+
+    /// Build an `OpAccessChain` instruction.
+    ///
+    /// Emit any needed bounds-checking expressions to `block`.
+    ///
+    /// Some cases we need to generate a different return type than what the IR gives us.
+    /// This is because pointers to binding arrays of handles (such as images or samplers)
+    /// don't exist in the IR, but we need to create them to create an access chain in SPIRV.
+    ///
+    /// On success, the return value is an [`ExpressionPointer`] value; see the
+    /// documentation for that type.
+    fn write_expression_pointer(
+        &mut self,
+        mut expr_handle: Handle<crate::Expression>,
+        block: &mut Block,
+        return_type_override: Option<LookupType>,
+    ) -> Result<ExpressionPointer, Error> {
+        let result_lookup_ty = match self.fun_info[expr_handle].ty {
+            TypeResolution::Handle(ty_handle) => match return_type_override {
+                // We use the return type override as a special case for handle binding arrays as the OpAccessChain
+                // needs to return a pointer, but indexing into a handle binding array just gives you the type of
+                // the binding in the IR.
+                Some(ty) => ty,
+                None => LookupType::Handle(ty_handle),
+            },
+            TypeResolution::Value(ref inner) => LookupType::Local(make_local(inner).unwrap()),
+        };
+        let result_type_id = self.get_type_id(result_lookup_ty);
+
+        // The id of the boolean `and` of all dynamic bounds checks up to this point. If
+        // `None`, then we haven't done any dynamic bounds checks yet.
+        //
+        // When we have a chain of bounds checks, we combine them with `OpLogicalAnd`, not
+        // a short-circuit branch. This means we might do comparisons we don't need to,
+        // but we expect these checks to almost always succeed, and keeping branches to a
+        // minimum is essential.
+        let mut accumulated_checks = None;
+        // Is true if we are accessing into a binding array with a non-uniform index.
+        let mut is_non_uniform_binding_array = false;
+
+        self.temp_list.clear();
+        let root_id = loop {
+            expr_handle = match self.ir_function.expressions[expr_handle] {
+                crate::Expression::Access { base, index } => {
+                    if let crate::Expression::GlobalVariable(var_handle) =
+                        self.ir_function.expressions[base]
+                    {
+                        // The access chain needs to be decorated as NonUniform
+                        // see VUID-RuntimeSpirv-NonUniform-06274
+                        let gvar = &self.ir_module.global_variables[var_handle];
+                        if let crate::TypeInner::BindingArray { .. } =
+                            self.ir_module.types[gvar.ty].inner
+                        {
+                            is_non_uniform_binding_array =
+                                self.fun_info[index].uniformity.non_uniform_result.is_some();
+                        }
+                    }
+
+                    let index_id = match self.write_bounds_check(base, index, block)? {
+                        BoundsCheckResult::KnownInBounds(known_index) => {
+                            // Even if the index is known, `OpAccessIndex`
+                            // requires expression operands, not literals.
+                            let scalar = crate::Literal::U32(known_index);
+                            self.writer.get_constant_scalar(scalar)
+                        }
+                        BoundsCheckResult::Computed(computed_index_id) => computed_index_id,
+                        BoundsCheckResult::Conditional(comparison_id) => {
+                            match accumulated_checks {
+                                Some(prior_checks) => {
+                                    let combined = self.gen_id();
+                                    block.body.push(Instruction::binary(
+                                        spirv::Op::LogicalAnd,
+                                        self.writer.get_bool_type_id(),
+                                        combined,
+                                        prior_checks,
+                                        comparison_id,
+                                    ));
+                                    accumulated_checks = Some(combined);
+                                }
+                                None => {
+                                    // Start a fresh chain of checks.
+                                    accumulated_checks = Some(comparison_id);
+                                }
+                            }
+
+                            // Either way, the index to use is unchanged.
+                            self.cached[index]
+                        }
+                    };
+                    self.temp_list.push(index_id);
+                    base
+                }
+                crate::Expression::AccessIndex { base, index } => {
+                    let const_id = self.get_index_constant(index);
+                    self.temp_list.push(const_id);
+                    base
+                }
+                crate::Expression::GlobalVariable(handle) => {
+                    let gv = &self.writer.global_variables[handle.index()];
+                    break gv.access_id;
+                }
+                crate::Expression::LocalVariable(variable) => {
+                    let local_var = &self.function.variables[&variable];
+                    break local_var.id;
+                }
+                crate::Expression::FunctionArgument(index) => {
+                    break self.function.parameter_id(index);
+                }
+                ref other => unimplemented!("Unexpected pointer expression {:?}", other),
+            }
+        };
+
+        let (pointer_id, expr_pointer) = if self.temp_list.is_empty() {
+            (
+                root_id,
+                ExpressionPointer::Ready {
+                    pointer_id: root_id,
+                },
+            )
+        } else {
+            self.temp_list.reverse();
+            let pointer_id = self.gen_id();
+            let access =
+                Instruction::access_chain(result_type_id, pointer_id, root_id, &self.temp_list);
+
+            // If we generated some bounds checks, we need to leave it to our
+            // caller to generate the branch, the access, the load or store, and
+            // the zero value (for loads). Otherwise, we can emit the access
+            // ourselves, and just hand them the id of the pointer.
+            let expr_pointer = match accumulated_checks {
+                Some(condition) => ExpressionPointer::Conditional { condition, access },
+                None => {
+                    block.body.push(access);
+                    ExpressionPointer::Ready { pointer_id }
+                }
+            };
+            (pointer_id, expr_pointer)
+        };
+        // Subsequent load, store and atomic operations require the pointer to be decorated as NonUniform
+        // if the binding array was accessed with a non-uniform index
+        // see VUID-RuntimeSpirv-NonUniform-06274
+        if is_non_uniform_binding_array {
+            self.writer
+                .decorate_non_uniform_binding_array_access(pointer_id)?;
+        }
+
+        Ok(expr_pointer)
+    }
+
+    /// Build the instructions for matrix - matrix column operations
+    #[allow(clippy::too_many_arguments)]
+    fn write_matrix_matrix_column_op(
+        &mut self,
+        block: &mut Block,
+        result_id: Word,
+        result_type_id: Word,
+        left_id: Word,
+        right_id: Word,
+        columns: crate::VectorSize,
+        rows: crate::VectorSize,
+        width: u8,
+        op: spirv::Op,
+    ) {
+        self.temp_list.clear();
+
+        let vector_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: Some(rows),
+            scalar: crate::Scalar::float(width),
+            pointer_space: None,
+        }));
+
+        for index in 0..columns as u32 {
+            let column_id_left = self.gen_id();
+            let column_id_right = self.gen_id();
+            let column_id_res = self.gen_id();
+
+            block.body.push(Instruction::composite_extract(
+                vector_type_id,
+                column_id_left,
+                left_id,
+                &[index],
+            ));
+            block.body.push(Instruction::composite_extract(
+                vector_type_id,
+                column_id_right,
+                right_id,
+                &[index],
+            ));
+            block.body.push(Instruction::binary(
+                op,
+                vector_type_id,
+                column_id_res,
+                column_id_left,
+                column_id_right,
+            ));
+
+            self.temp_list.push(column_id_res);
+        }
+
+        block.body.push(Instruction::composite_construct(
+            result_type_id,
+            result_id,
+            &self.temp_list,
+        ));
+    }
+
+    /// Build the instructions for vector - scalar multiplication
+    fn write_vector_scalar_mult(
+        &mut self,
+        block: &mut Block,
+        result_id: Word,
+        result_type_id: Word,
+        vector_id: Word,
+        scalar_id: Word,
+        vector: &crate::TypeInner,
+    ) {
+        let (size, kind) = match *vector {
+            crate::TypeInner::Vector {
+                size,
+                scalar: crate::Scalar { kind, .. },
+            } => (size, kind),
+            _ => unreachable!(),
+        };
+
+        let (op, operand_id) = match kind {
+            crate::ScalarKind::Float => (spirv::Op::VectorTimesScalar, scalar_id),
+            _ => {
+                let operand_id = self.gen_id();
+                self.temp_list.clear();
+                self.temp_list.resize(size as usize, scalar_id);
+                block.body.push(Instruction::composite_construct(
+                    result_type_id,
+                    operand_id,
+                    &self.temp_list,
+                ));
+                (spirv::Op::IMul, operand_id)
+            }
+        };
+
+        block.body.push(Instruction::binary(
+            op,
+            result_type_id,
+            result_id,
+            vector_id,
+            operand_id,
+        ));
+    }
+
+    /// Build the instructions for the arithmetic expression of a dot product
+    fn write_dot_product(
+        &mut self,
+        result_id: Word,
+        result_type_id: Word,
+        arg0_id: Word,
+        arg1_id: Word,
+        size: u32,
+        block: &mut Block,
+    ) {
+        let mut partial_sum = self.writer.get_constant_null(result_type_id);
+        let last_component = size - 1;
+        for index in 0..=last_component {
+            // compute the product of the current components
+            let a_id = self.gen_id();
+            block.body.push(Instruction::composite_extract(
+                result_type_id,
+                a_id,
+                arg0_id,
+                &[index],
+            ));
+            let b_id = self.gen_id();
+            block.body.push(Instruction::composite_extract(
+                result_type_id,
+                b_id,
+                arg1_id,
+                &[index],
+            ));
+            let prod_id = self.gen_id();
+            block.body.push(Instruction::binary(
+                spirv::Op::IMul,
+                result_type_id,
+                prod_id,
+                a_id,
+                b_id,
+            ));
+
+            // choose the id for the next sum, depending on current index
+            let id = if index == last_component {
+                result_id
+            } else {
+                self.gen_id()
+            };
+
+            // sum the computed product with the partial sum
+            block.body.push(Instruction::binary(
+                spirv::Op::IAdd,
+                result_type_id,
+                id,
+                partial_sum,
+                prod_id,
+            ));
+            // set the id of the result as the previous partial sum
+            partial_sum = id;
+        }
+    }
+
+    pub(super) fn write_block(
+        &mut self,
+        label_id: Word,
+        naga_block: &crate::Block,
+        exit: BlockExit,
+        loop_context: LoopContext,
+        debug_info: Option<&DebugInfoInner>,
+    ) -> Result<(), Error> {
+        let mut block = Block::new(label_id);
+        for (statement, span) in naga_block.span_iter() {
+            if let (Some(debug_info), false) = (
+                debug_info,
+                matches!(
+                    statement,
+                    &(Statement::Block(..)
+                        | Statement::Break
+                        | Statement::Continue
+                        | Statement::Kill
+                        | Statement::Return { .. }
+                        | Statement::Loop { .. })
+                ),
+            ) {
+                let loc: crate::SourceLocation = span.location(debug_info.source_code);
+                block.body.push(Instruction::line(
+                    debug_info.source_file_id,
+                    loc.line_number,
+                    loc.line_position,
+                ));
+            };
+            match *statement {
+                crate::Statement::Emit(ref range) => {
+                    for handle in range.clone() {
+                        // omit const expressions as we've already cached those
+                        if !self.expression_constness.is_const(handle) {
+                            self.cache_expression_value(handle, &mut block)?;
+                        }
+                    }
+                }
+                crate::Statement::Block(ref block_statements) => {
+                    let scope_id = self.gen_id();
+                    self.function.consume(block, Instruction::branch(scope_id));
+
+                    let merge_id = self.gen_id();
+                    self.write_block(
+                        scope_id,
+                        block_statements,
+                        BlockExit::Branch { target: merge_id },
+                        loop_context,
+                        debug_info,
+                    )?;
+
+                    block = Block::new(merge_id);
+                }
+                crate::Statement::If {
+                    condition,
+                    ref accept,
+                    ref reject,
+                } => {
+                    let condition_id = self.cached[condition];
+
+                    let merge_id = self.gen_id();
+                    block.body.push(Instruction::selection_merge(
+                        merge_id,
+                        spirv::SelectionControl::NONE,
+                    ));
+
+                    let accept_id = if accept.is_empty() {
+                        None
+                    } else {
+                        Some(self.gen_id())
+                    };
+                    let reject_id = if reject.is_empty() {
+                        None
+                    } else {
+                        Some(self.gen_id())
+                    };
+
+                    self.function.consume(
+                        block,
+                        Instruction::branch_conditional(
+                            condition_id,
+                            accept_id.unwrap_or(merge_id),
+                            reject_id.unwrap_or(merge_id),
+                        ),
+                    );
+
+                    if let Some(block_id) = accept_id {
+                        self.write_block(
+                            block_id,
+                            accept,
+                            BlockExit::Branch { target: merge_id },
+                            loop_context,
+                            debug_info,
+                        )?;
+                    }
+                    if let Some(block_id) = reject_id {
+                        self.write_block(
+                            block_id,
+                            reject,
+                            BlockExit::Branch { target: merge_id },
+                            loop_context,
+                            debug_info,
+                        )?;
+                    }
+
+                    block = Block::new(merge_id);
+                }
+                crate::Statement::Switch {
+                    selector,
+                    ref cases,
+                } => {
+                    let selector_id = self.cached[selector];
+
+                    let merge_id = self.gen_id();
+                    block.body.push(Instruction::selection_merge(
+                        merge_id,
+                        spirv::SelectionControl::NONE,
+                    ));
+
+                    let mut default_id = None;
+                    // id of previous empty fall-through case
+                    let mut last_id = None;
+
+                    let mut raw_cases = Vec::with_capacity(cases.len());
+                    let mut case_ids = Vec::with_capacity(cases.len());
+                    for case in cases.iter() {
+                        // take id of previous empty fall-through case or generate a new one
+                        let label_id = last_id.take().unwrap_or_else(|| self.gen_id());
+
+                        if case.fall_through && case.body.is_empty() {
+                            last_id = Some(label_id);
+                        }
+
+                        case_ids.push(label_id);
+
+                        match case.value {
+                            crate::SwitchValue::I32(value) => {
+                                raw_cases.push(super::instructions::Case {
+                                    value: value as Word,
+                                    label_id,
+                                });
+                            }
+                            crate::SwitchValue::U32(value) => {
+                                raw_cases.push(super::instructions::Case { value, label_id });
+                            }
+                            crate::SwitchValue::Default => {
+                                default_id = Some(label_id);
+                            }
+                        }
+                    }
+
+                    let default_id = default_id.unwrap();
+
+                    self.function.consume(
+                        block,
+                        Instruction::switch(selector_id, default_id, &raw_cases),
+                    );
+
+                    let inner_context = LoopContext {
+                        break_id: Some(merge_id),
+                        ..loop_context
+                    };
+
+                    for (i, (case, label_id)) in cases
+                        .iter()
+                        .zip(case_ids.iter())
+                        .filter(|&(case, _)| !(case.fall_through && case.body.is_empty()))
+                        .enumerate()
+                    {
+                        let case_finish_id = if case.fall_through {
+                            case_ids[i + 1]
+                        } else {
+                            merge_id
+                        };
+                        self.write_block(
+                            *label_id,
+                            &case.body,
+                            BlockExit::Branch {
+                                target: case_finish_id,
+                            },
+                            inner_context,
+                            debug_info,
+                        )?;
+                    }
+
+                    block = Block::new(merge_id);
+                }
+                crate::Statement::Loop {
+                    ref body,
+                    ref continuing,
+                    break_if,
+                } => {
+                    let preamble_id = self.gen_id();
+                    self.function
+                        .consume(block, Instruction::branch(preamble_id));
+
+                    let merge_id = self.gen_id();
+                    let body_id = self.gen_id();
+                    let continuing_id = self.gen_id();
+
+                    // SPIR-V requires the continuing to the `OpLoopMerge`,
+                    // so we have to start a new block with it.
+                    block = Block::new(preamble_id);
+                    // HACK the loop statement is begin with branch instruction,
+                    // so we need to put `OpLine` debug info before merge instruction
+                    if let Some(debug_info) = debug_info {
+                        let loc: crate::SourceLocation = span.location(debug_info.source_code);
+                        block.body.push(Instruction::line(
+                            debug_info.source_file_id,
+                            loc.line_number,
+                            loc.line_position,
+                        ))
+                    }
+                    block.body.push(Instruction::loop_merge(
+                        merge_id,
+                        continuing_id,
+                        spirv::SelectionControl::NONE,
+                    ));
+                    self.function.consume(block, Instruction::branch(body_id));
+
+                    self.write_block(
+                        body_id,
+                        body,
+                        BlockExit::Branch {
+                            target: continuing_id,
+                        },
+                        LoopContext {
+                            continuing_id: Some(continuing_id),
+                            break_id: Some(merge_id),
+                        },
+                        debug_info,
+                    )?;
+
+                    let exit = match break_if {
+                        Some(condition) => BlockExit::BreakIf {
+                            condition,
+                            preamble_id,
+                        },
+                        None => BlockExit::Branch {
+                            target: preamble_id,
+                        },
+                    };
+
+                    self.write_block(
+                        continuing_id,
+                        continuing,
+                        exit,
+                        LoopContext {
+                            continuing_id: None,
+                            break_id: Some(merge_id),
+                        },
+                        debug_info,
+                    )?;
+
+                    block = Block::new(merge_id);
+                }
+                crate::Statement::Break => {
+                    self.function
+                        .consume(block, Instruction::branch(loop_context.break_id.unwrap()));
+                    return Ok(());
+                }
+                crate::Statement::Continue => {
+                    self.function.consume(
+                        block,
+                        Instruction::branch(loop_context.continuing_id.unwrap()),
+                    );
+                    return Ok(());
+                }
+                crate::Statement::Return { value: Some(value) } => {
+                    let value_id = self.cached[value];
+                    let instruction = match self.function.entry_point_context {
+                        // If this is an entry point, and we need to return anything,
+                        // let's instead store the output variables and return `void`.
+                        Some(ref context) => {
+                            self.writer.write_entry_point_return(
+                                value_id,
+                                self.ir_function.result.as_ref().unwrap(),
+                                &context.results,
+                                &mut block.body,
+                            )?;
+                            Instruction::return_void()
+                        }
+                        None => Instruction::return_value(value_id),
+                    };
+                    self.function.consume(block, instruction);
+                    return Ok(());
+                }
+                crate::Statement::Return { value: None } => {
+                    self.function.consume(block, Instruction::return_void());
+                    return Ok(());
+                }
+                crate::Statement::Kill => {
+                    self.function.consume(block, Instruction::kill());
+                    return Ok(());
+                }
+                crate::Statement::Barrier(flags) => {
+                    self.writer.write_barrier(flags, &mut block);
+                }
+                crate::Statement::Store { pointer, value } => {
+                    let value_id = self.cached[value];
+                    match self.write_expression_pointer(pointer, &mut block, None)? {
+                        ExpressionPointer::Ready { pointer_id } => {
+                            let atomic_space = match *self.fun_info[pointer]
+                                .ty
+                                .inner_with(&self.ir_module.types)
+                            {
+                                crate::TypeInner::Pointer { base, space } => {
+                                    match self.ir_module.types[base].inner {
+                                        crate::TypeInner::Atomic { .. } => Some(space),
+                                        _ => None,
+                                    }
+                                }
+                                _ => None,
+                            };
+                            let instruction = if let Some(space) = atomic_space {
+                                let (semantics, scope) = space.to_spirv_semantics_and_scope();
+                                let scope_constant_id = self.get_scope_constant(scope as u32);
+                                let semantics_id = self.get_index_constant(semantics.bits());
+                                Instruction::atomic_store(
+                                    pointer_id,
+                                    scope_constant_id,
+                                    semantics_id,
+                                    value_id,
+                                )
+                            } else {
+                                Instruction::store(pointer_id, value_id, None)
+                            };
+                            block.body.push(instruction);
+                        }
+                        ExpressionPointer::Conditional { condition, access } => {
+                            let mut selection = Selection::start(&mut block, ());
+                            selection.if_true(self, condition, ());
+
+                            // The in-bounds path. Perform the access and the store.
+                            let pointer_id = access.result_id.unwrap();
+                            selection.block().body.push(access);
+                            selection
+                                .block()
+                                .body
+                                .push(Instruction::store(pointer_id, value_id, None));
+
+                            // Finish the in-bounds block and start the merge block. This
+                            // is the block we'll leave current on return.
+                            selection.finish(self, ());
+                        }
+                    };
+                }
+                crate::Statement::ImageStore {
+                    image,
+                    coordinate,
+                    array_index,
+                    value,
+                } => self.write_image_store(image, coordinate, array_index, value, &mut block)?,
+                crate::Statement::Call {
+                    function: local_function,
+                    ref arguments,
+                    result,
+                } => {
+                    let id = self.gen_id();
+                    self.temp_list.clear();
+                    for &argument in arguments {
+                        self.temp_list.push(self.cached[argument]);
+                    }
+
+                    let type_id = match result {
+                        Some(expr) => {
+                            self.cached[expr] = id;
+                            self.get_expression_type_id(&self.fun_info[expr].ty)
+                        }
+                        None => self.writer.void_type,
+                    };
+
+                    block.body.push(Instruction::function_call(
+                        type_id,
+                        id,
+                        self.writer.lookup_function[&local_function],
+                        &self.temp_list,
+                    ));
+                }
+                crate::Statement::Atomic {
+                    pointer,
+                    ref fun,
+                    value,
+                    result,
+                } => {
+                    let id = self.gen_id();
+                    let result_type_id = self.get_expression_type_id(&self.fun_info[result].ty);
+
+                    self.cached[result] = id;
+
+                    let pointer_id =
+                        match self.write_expression_pointer(pointer, &mut block, None)? {
+                            ExpressionPointer::Ready { pointer_id } => pointer_id,
+                            ExpressionPointer::Conditional { .. } => {
+                                return Err(Error::FeatureNotImplemented(
+                                    "Atomics out-of-bounds handling",
+                                ));
+                            }
+                        };
+
+                    let space = self.fun_info[pointer]
+                        .ty
+                        .inner_with(&self.ir_module.types)
+                        .pointer_space()
+                        .unwrap();
+                    let (semantics, scope) = space.to_spirv_semantics_and_scope();
+                    let scope_constant_id = self.get_scope_constant(scope as u32);
+                    let semantics_id = self.get_index_constant(semantics.bits());
+                    let value_id = self.cached[value];
+                    let value_inner = self.fun_info[value].ty.inner_with(&self.ir_module.types);
+
+                    let instruction = match *fun {
+                        crate::AtomicFunction::Add => Instruction::atomic_binary(
+                            spirv::Op::AtomicIAdd,
+                            result_type_id,
+                            id,
+                            pointer_id,
+                            scope_constant_id,
+                            semantics_id,
+                            value_id,
+                        ),
+                        crate::AtomicFunction::Subtract => Instruction::atomic_binary(
+                            spirv::Op::AtomicISub,
+                            result_type_id,
+                            id,
+                            pointer_id,
+                            scope_constant_id,
+                            semantics_id,
+                            value_id,
+                        ),
+                        crate::AtomicFunction::And => Instruction::atomic_binary(
+                            spirv::Op::AtomicAnd,
+                            result_type_id,
+                            id,
+                            pointer_id,
+                            scope_constant_id,
+                            semantics_id,
+                            value_id,
+                        ),
+                        crate::AtomicFunction::InclusiveOr => Instruction::atomic_binary(
+                            spirv::Op::AtomicOr,
+                            result_type_id,
+                            id,
+                            pointer_id,
+                            scope_constant_id,
+                            semantics_id,
+                            value_id,
+                        ),
+                        crate::AtomicFunction::ExclusiveOr => Instruction::atomic_binary(
+                            spirv::Op::AtomicXor,
+                            result_type_id,
+                            id,
+                            pointer_id,
+                            scope_constant_id,
+                            semantics_id,
+                            value_id,
+                        ),
+                        crate::AtomicFunction::Min => {
+                            let spirv_op = match *value_inner {
+                                crate::TypeInner::Scalar(crate::Scalar {
+                                    kind: crate::ScalarKind::Sint,
+                                    width: _,
+                                }) => spirv::Op::AtomicSMin,
+                                crate::TypeInner::Scalar(crate::Scalar {
+                                    kind: crate::ScalarKind::Uint,
+                                    width: _,
+                                }) => spirv::Op::AtomicUMin,
+                                _ => unimplemented!(),
+                            };
+                            Instruction::atomic_binary(
+                                spirv_op,
+                                result_type_id,
+                                id,
+                                pointer_id,
+                                scope_constant_id,
+                                semantics_id,
+                                value_id,
+                            )
+                        }
+                        crate::AtomicFunction::Max => {
+                            let spirv_op = match *value_inner {
+                                crate::TypeInner::Scalar(crate::Scalar {
+                                    kind: crate::ScalarKind::Sint,
+                                    width: _,
+                                }) => spirv::Op::AtomicSMax,
+                                crate::TypeInner::Scalar(crate::Scalar {
+                                    kind: crate::ScalarKind::Uint,
+                                    width: _,
+                                }) => spirv::Op::AtomicUMax,
+                                _ => unimplemented!(),
+                            };
+                            Instruction::atomic_binary(
+                                spirv_op,
+                                result_type_id,
+                                id,
+                                pointer_id,
+                                scope_constant_id,
+                                semantics_id,
+                                value_id,
+                            )
+                        }
+                        crate::AtomicFunction::Exchange { compare: None } => {
+                            Instruction::atomic_binary(
+                                spirv::Op::AtomicExchange,
+                                result_type_id,
+                                id,
+                                pointer_id,
+                                scope_constant_id,
+                                semantics_id,
+                                value_id,
+                            )
+                        }
+                        crate::AtomicFunction::Exchange { compare: Some(cmp) } => {
+                            let scalar_type_id = match *value_inner {
+                                crate::TypeInner::Scalar(scalar) => {
+                                    self.get_type_id(LookupType::Local(LocalType::Value {
+                                        vector_size: None,
+                                        scalar,
+                                        pointer_space: None,
+                                    }))
+                                }
+                                _ => unimplemented!(),
+                            };
+                            let bool_type_id =
+                                self.get_type_id(LookupType::Local(LocalType::Value {
+                                    vector_size: None,
+                                    scalar: crate::Scalar::BOOL,
+                                    pointer_space: None,
+                                }));
+
+                            let cas_result_id = self.gen_id();
+                            let equality_result_id = self.gen_id();
+                            let mut cas_instr = Instruction::new(spirv::Op::AtomicCompareExchange);
+                            cas_instr.set_type(scalar_type_id);
+                            cas_instr.set_result(cas_result_id);
+                            cas_instr.add_operand(pointer_id);
+                            cas_instr.add_operand(scope_constant_id);
+                            cas_instr.add_operand(semantics_id); // semantics if equal
+                            cas_instr.add_operand(semantics_id); // semantics if not equal
+                            cas_instr.add_operand(value_id);
+                            cas_instr.add_operand(self.cached[cmp]);
+                            block.body.push(cas_instr);
+                            block.body.push(Instruction::binary(
+                                spirv::Op::IEqual,
+                                bool_type_id,
+                                equality_result_id,
+                                cas_result_id,
+                                self.cached[cmp],
+                            ));
+                            Instruction::composite_construct(
+                                result_type_id,
+                                id,
+                                &[cas_result_id, equality_result_id],
+                            )
+                        }
+                    };
+
+                    block.body.push(instruction);
+                }
+                crate::Statement::WorkGroupUniformLoad { pointer, result } => {
+                    self.writer
+                        .write_barrier(crate::Barrier::WORK_GROUP, &mut block);
+                    let result_type_id = self.get_expression_type_id(&self.fun_info[result].ty);
+                    // Embed the body of
+                    match self.write_expression_pointer(pointer, &mut block, None)? {
+                        ExpressionPointer::Ready { pointer_id } => {
+                            let id = self.gen_id();
+                            block.body.push(Instruction::load(
+                                result_type_id,
+                                id,
+                                pointer_id,
+                                None,
+                            ));
+                            self.cached[result] = id;
+                        }
+                        ExpressionPointer::Conditional { condition, access } => {
+                            self.cached[result] = self.write_conditional_indexed_load(
+                                result_type_id,
+                                condition,
+                                &mut block,
+                                move |id_gen, block| {
+                                    // The in-bounds path. Perform the access and the load.
+                                    let pointer_id = access.result_id.unwrap();
+                                    let value_id = id_gen.next();
+                                    block.body.push(access);
+                                    block.body.push(Instruction::load(
+                                        result_type_id,
+                                        value_id,
+                                        pointer_id,
+                                        None,
+                                    ));
+                                    value_id
+                                },
+                            )
+                        }
+                    }
+                    self.writer
+                        .write_barrier(crate::Barrier::WORK_GROUP, &mut block);
+                }
+                crate::Statement::RayQuery { query, ref fun } => {
+                    self.write_ray_query_function(query, fun, &mut block);
+                }
+            }
+        }
+
+        let termination = match exit {
+            // We're generating code for the top-level Block of the function, so we
+            // need to end it with some kind of return instruction.
+            BlockExit::Return => match self.ir_function.result {
+                Some(ref result) if self.function.entry_point_context.is_none() => {
+                    let type_id = self.get_type_id(LookupType::Handle(result.ty));
+                    let null_id = self.writer.get_constant_null(type_id);
+                    Instruction::return_value(null_id)
+                }
+                _ => Instruction::return_void(),
+            },
+            BlockExit::Branch { target } => Instruction::branch(target),
+            BlockExit::BreakIf {
+                condition,
+                preamble_id,
+            } => {
+                let condition_id = self.cached[condition];
+
+                Instruction::branch_conditional(
+                    condition_id,
+                    loop_context.break_id.unwrap(),
+                    preamble_id,
+                )
+            }
+        };
+
+        self.function.consume(block, termination);
+        Ok(())
+    }
+}
diff --git a/third_party/rust/naga/src/back/spv/helpers.rs b/third_party/rust/naga/src/back/spv/helpers.rs
new file mode 100644
index 0000000000..5b6226db85
--- /dev/null
+++ b/third_party/rust/naga/src/back/spv/helpers.rs
@@ -0,0 +1,109 @@
+use crate::{Handle, UniqueArena};
+use spirv::Word;
+
+pub(super) fn bytes_to_words(bytes: &[u8]) -> Vec<Word> {
+    bytes
+        .chunks(4)
+        .map(|chars| chars.iter().rev().fold(0u32, |u, c| (u << 8) | *c as u32))
+        .collect()
+}
+
+pub(super) fn string_to_words(input: &str) -> Vec<Word> {
+    let bytes = input.as_bytes();
+    let mut words = bytes_to_words(bytes);
+
+    if bytes.len() % 4 == 0 {
+        // nul-termination
+        words.push(0x0u32);
+    }
+
+    words
+}
+
+pub(super) const fn map_storage_class(space: crate::AddressSpace) -> spirv::StorageClass {
+    match space {
+        crate::AddressSpace::Handle => spirv::StorageClass::UniformConstant,
+        crate::AddressSpace::Function => spirv::StorageClass::Function,
+        crate::AddressSpace::Private => spirv::StorageClass::Private,
+        crate::AddressSpace::Storage { .. } => spirv::StorageClass::StorageBuffer,
+        crate::AddressSpace::Uniform => spirv::StorageClass::Uniform,
+        crate::AddressSpace::WorkGroup => spirv::StorageClass::Workgroup,
+        crate::AddressSpace::PushConstant => spirv::StorageClass::PushConstant,
+    }
+}
+
+pub(super) fn contains_builtin(
+    binding: Option<&crate::Binding>,
+    ty: Handle<crate::Type>,
+    arena: &UniqueArena<crate::Type>,
+    built_in: crate::BuiltIn,
+) -> bool {
+    if let Some(&crate::Binding::BuiltIn(bi)) = binding {
+        bi == built_in
+    } else if let crate::TypeInner::Struct { ref members, .. } = arena[ty].inner {
+        members
+            .iter()
+            .any(|member| contains_builtin(member.binding.as_ref(), member.ty, arena, built_in))
+    } else {
+        false // unreachable
+    }
+}
+
+impl crate::AddressSpace {
+    pub(super) const fn to_spirv_semantics_and_scope(
+        self,
+    ) -> (spirv::MemorySemantics, spirv::Scope) {
+        match self {
+            Self::Storage { .. } => (spirv::MemorySemantics::UNIFORM_MEMORY, spirv::Scope::Device),
+            Self::WorkGroup => (
+                spirv::MemorySemantics::WORKGROUP_MEMORY,
+                spirv::Scope::Workgroup,
+            ),
+            _ => (spirv::MemorySemantics::empty(), spirv::Scope::Invocation),
+        }
+    }
+}
+
+/// Return true if the global requires a type decorated with `Block`.
+///
+/// Vulkan spec v1.3 §15.6.2, "Descriptor Set Interface", says:
+///
+/// > Variables identified with the `Uniform` storage class are used to
+/// > access transparent buffer backed resources. Such variables must
+/// > be:
+/// >
+/// > -   typed as `OpTypeStruct`, or an array of this type,
+/// >
+/// > -   identified with a `Block` or `BufferBlock` decoration, and
+/// >
+/// > -   laid out explicitly using the `Offset`, `ArrayStride`, and
+/// >     `MatrixStride` decorations as specified in §15.6.4, "Offset
+/// >     and Stride Assignment."
+// See `back::spv::GlobalVariable::access_id` for details.
+pub fn global_needs_wrapper(ir_module: &crate::Module, var: &crate::GlobalVariable) -> bool {
+    match var.space {
+        crate::AddressSpace::Uniform
+        | crate::AddressSpace::Storage { .. }
+        | crate::AddressSpace::PushConstant => {}
+        _ => return false,
+    };
+    match ir_module.types[var.ty].inner {
+        crate::TypeInner::Struct {
+            ref members,
+            span: _,
+        } => match members.last() {
+            Some(member) => match ir_module.types[member.ty].inner {
+                // Structs with dynamically sized arrays can't be copied and can't be wrapped.
+                crate::TypeInner::Array {
+                    size: crate::ArraySize::Dynamic,
+                    ..
+                } => false,
+                _ => true,
+            },
+            None => false,
+        },
+        crate::TypeInner::BindingArray { .. } => false,
+        // if it's not a structure or a binding array, let's wrap it to be able to put "Block"
+        _ => true,
+    }
+}
diff --git a/third_party/rust/naga/src/back/spv/image.rs b/third_party/rust/naga/src/back/spv/image.rs
new file mode 100644
index 0000000000..c0fc41cbb6
--- /dev/null
+++ b/third_party/rust/naga/src/back/spv/image.rs
@@ -0,0 +1,1210 @@
+/*!
+Generating SPIR-V for image operations.
+*/
+
+use super::{
+    selection::{MergeTuple, Selection},
+    Block, BlockContext, Error, IdGenerator, Instruction, LocalType, LookupType,
+};
+use crate::arena::Handle;
+use spirv::Word;
+
+/// Information about a vector of coordinates.
+///
+/// The coordinate vectors expected by SPIR-V `OpImageRead` and `OpImageFetch`
+/// supply the array index for arrayed images as an additional component at
+/// the end, whereas Naga's `ImageLoad`, `ImageStore`, and `ImageSample` carry
+/// the array index as a separate field.
+///
+/// In the process of generating code to compute the combined vector, we also
+/// produce SPIR-V types and vector lengths that are useful elsewhere. This
+/// struct gathers that information into one place, with standard names.
+struct ImageCoordinates {
+    /// The SPIR-V id of the combined coordinate/index vector value.
+    ///
+    /// Note: when indexing a non-arrayed 1D image, this will be a scalar.
+    value_id: Word,
+
+    /// The SPIR-V id of the type of `value`.
+    type_id: Word,
+
+    /// The number of components in `value`, if it is a vector, or `None` if it
+    /// is a scalar.
+    size: Option<crate::VectorSize>,
+}
+
+/// A trait for image access (load or store) code generators.
+///
+/// Types implementing this trait hold information about an `ImageStore` or
+/// `ImageLoad` operation that is not affected by the bounds check policy. The
+/// `generate` method emits code for the access, given the results of bounds
+/// checking.
+///
+/// The [`image`] bounds checks policy affects access coordinates, level of
+/// detail, and sample index, but never the image id, result type (if any), or
+/// the specific SPIR-V instruction used. Types that implement this trait gather
+/// together the latter category, so we don't have to plumb them through the
+/// bounds-checking code.
+///
+/// [`image`]: crate::proc::BoundsCheckPolicies::index
+trait Access {
+    /// The Rust type that represents SPIR-V values and types for this access.
+    ///
+    /// For operations like loads, this is `Word`. For operations like stores,
+    /// this is `()`.
+    ///
+    /// For `ReadZeroSkipWrite`, this will be the type of the selection
+    /// construct that performs the bounds checks, so it must implement
+    /// `MergeTuple`.
+    type Output: MergeTuple + Copy + Clone;
+
+    /// Write an image access to `block`.
+    ///
+    /// Access the texel at `coordinates_id`. The optional `level_id` indicates
+    /// the level of detail, and `sample_id` is the index of the sample to
+    /// access in a multisampled texel.
+    ///
+    /// This method assumes that `coordinates_id` has already had the image array
+    /// index, if any, folded in, as done by `write_image_coordinates`.
+    ///
+    /// Return the value id produced by the instruction, if any.
+    ///
+    /// Use `id_gen` to generate SPIR-V ids as necessary.
+    fn generate(
+        &self,
+        id_gen: &mut IdGenerator,
+        coordinates_id: Word,
+        level_id: Option<Word>,
+        sample_id: Option<Word>,
+        block: &mut Block,
+    ) -> Self::Output;
+
+    /// Return the SPIR-V type of the value produced by the code written by
+    /// `generate`. If the access does not produce a value, `Self::Output`
+    /// should be `()`.
+    fn result_type(&self) -> Self::Output;
+
+    /// Construct the SPIR-V 'zero' value to be returned for an out-of-bounds
+    /// access under the `ReadZeroSkipWrite` policy. If the access does not
+    /// produce a value, `Self::Output` should be `()`.
+    fn out_of_bounds_value(&self, ctx: &mut BlockContext<'_>) -> Self::Output;
+}
+
+/// Texel access information for an [`ImageLoad`] expression.
+///
+/// [`ImageLoad`]: crate::Expression::ImageLoad
+struct Load {
+    /// The specific opcode we'll use to perform the fetch. Storage images
+    /// require `OpImageRead`, while sampled images require `OpImageFetch`.
+    opcode: spirv::Op,
+
+    /// The type id produced by the actual image access instruction.
+    type_id: Word,
+
+    /// The id of the image being accessed.
+    image_id: Word,
+}
+
+impl Load {
+    fn from_image_expr(
+        ctx: &mut BlockContext<'_>,
+        image_id: Word,
+        image_class: crate::ImageClass,
+        result_type_id: Word,
+    ) -> Result<Load, Error> {
+        let opcode = match image_class {
+            crate::ImageClass::Storage { .. } => spirv::Op::ImageRead,
+            crate::ImageClass::Depth { .. } | crate::ImageClass::Sampled { .. } => {
+                spirv::Op::ImageFetch
+            }
+        };
+
+        // `OpImageRead` and `OpImageFetch` instructions produce vec4<f32>
+        // values. Most of the time, we can just use `result_type_id` for
+        // this. The exception is that `Expression::ImageLoad` from a depth
+        // image produces a scalar `f32`, so in that case we need to find
+        // the right SPIR-V type for the access instruction here.
+        let type_id = match image_class {
+            crate::ImageClass::Depth { .. } => {
+                ctx.get_type_id(LookupType::Local(LocalType::Value {
+                    vector_size: Some(crate::VectorSize::Quad),
+                    scalar: crate::Scalar::F32,
+                    pointer_space: None,
+                }))
+            }
+            _ => result_type_id,
+        };
+
+        Ok(Load {
+            opcode,
+            type_id,
+            image_id,
+        })
+    }
+}
+
+impl Access for Load {
+    type Output = Word;
+
+    /// Write an instruction to access a given texel of this image.
+    fn generate(
+        &self,
+        id_gen: &mut IdGenerator,
+        coordinates_id: Word,
+        level_id: Option<Word>,
+        sample_id: Option<Word>,
+        block: &mut Block,
+    ) -> Word {
+        let texel_id = id_gen.next();
+        let mut instruction = Instruction::image_fetch_or_read(
+            self.opcode,
+            self.type_id,
+            texel_id,
+            self.image_id,
+            coordinates_id,
+        );
+
+        match (level_id, sample_id) {
+            (None, None) => {}
+            (Some(level_id), None) => {
+                instruction.add_operand(spirv::ImageOperands::LOD.bits());
+                instruction.add_operand(level_id);
+            }
+            (None, Some(sample_id)) => {
+                instruction.add_operand(spirv::ImageOperands::SAMPLE.bits());
+                instruction.add_operand(sample_id);
+            }
+            // There's no such thing as a multi-sampled mipmap.
+            (Some(_), Some(_)) => unreachable!(),
+        }
+
+        block.body.push(instruction);
+
+        texel_id
+    }
+
+    fn result_type(&self) -> Word {
+        self.type_id
+    }
+
+    fn out_of_bounds_value(&self, ctx: &mut BlockContext<'_>) -> Word {
+        ctx.writer.get_constant_null(self.type_id)
+    }
+}
+
+/// Texel access information for a [`Store`] statement.
+///
+/// [`Store`]: crate::Statement::Store
+struct Store {
+    /// The id of the image being written to.
+    image_id: Word,
+
+    /// The value we're going to write to the texel.
+    value_id: Word,
+}
+
+impl Access for Store {
+    /// Stores don't generate any value.
+    type Output = ();
+
+    fn generate(
+        &self,
+        _id_gen: &mut IdGenerator,
+        coordinates_id: Word,
+        _level_id: Option<Word>,
+        _sample_id: Option<Word>,
+        block: &mut Block,
+    ) {
+        block.body.push(Instruction::image_write(
+            self.image_id,
+            coordinates_id,
+            self.value_id,
+        ));
+    }
+
+    /// Stores don't generate any value, so this just returns `()`.
+    fn result_type(&self) {}
+
+    /// Stores don't generate any value, so this just returns `()`.
+    fn out_of_bounds_value(&self, _ctx: &mut BlockContext<'_>) {}
+}
+
+impl<'w> BlockContext<'w> {
+    /// Extend image coordinates with an array index, if necessary.
+    ///
+    /// Whereas [`Expression::ImageLoad`] and [`ImageSample`] treat the array
+    /// index as a separate operand from the coordinates, SPIR-V image access
+    /// instructions include the array index in the `coordinates` operand. This
+    /// function builds a SPIR-V coordinate vector from a Naga coordinate vector
+    /// and array index, if one is supplied, and returns a `ImageCoordinates`
+    /// struct describing what it built.
+    ///
+    /// If `array_index` is `Some(expr)`, then this function constructs a new
+    /// vector that is `coordinates` with `array_index` concatenated onto the
+    /// end: a `vec2` becomes a `vec3`, a scalar becomes a `vec2`, and so on.
+    ///
+    /// If `array_index` is `None`, then the return value uses `coordinates`
+    /// unchanged. Note that, when indexing a non-arrayed 1D image, this will be
+    /// a scalar value.
+    ///
+    /// If needed, this function generates code to convert the array index,
+    /// always an integer scalar, to match the component type of `coordinates`.
+    /// Naga's `ImageLoad` and SPIR-V's `OpImageRead`, `OpImageFetch`, and
+    /// `OpImageWrite` all use integer coordinates, while Naga's `ImageSample`
+    /// and SPIR-V's `OpImageSample...` instructions all take floating-point
+    /// coordinate vectors.
+    ///
+    /// [`Expression::ImageLoad`]: crate::Expression::ImageLoad
+    /// [`ImageSample`]: crate::Expression::ImageSample
+    fn write_image_coordinates(
+        &mut self,
+        coordinates: Handle<crate::Expression>,
+        array_index: Option<Handle<crate::Expression>>,
+        block: &mut Block,
+    ) -> Result<ImageCoordinates, Error> {
+        use crate::TypeInner as Ti;
+        use crate::VectorSize as Vs;
+
+        let coordinates_id = self.cached[coordinates];
+        let ty = &self.fun_info[coordinates].ty;
+        let inner_ty = ty.inner_with(&self.ir_module.types);
+
+        // If there's no array index, the image coordinates are exactly the
+        // `coordinate` field of the `Expression::ImageLoad`. No work is needed.
+        let array_index = match array_index {
+            None => {
+                let value_id = coordinates_id;
+                let type_id = self.get_expression_type_id(ty);
+                let size = match *inner_ty {
+                    Ti::Scalar { .. } => None,
+                    Ti::Vector { size, .. } => Some(size),
+                    _ => return Err(Error::Validation("coordinate type")),
+                };
+                return Ok(ImageCoordinates {
+                    value_id,
+                    type_id,
+                    size,
+                });
+            }
+            Some(ix) => ix,
+        };
+
+        // Find the component type of `coordinates`, and figure out the size the
+        // combined coordinate vector will have.
+        let (component_scalar, size) = match *inner_ty {
+            Ti::Scalar(scalar @ crate::Scalar { width: 4, .. }) => (scalar, Some(Vs::Bi)),
+            Ti::Vector {
+                scalar: scalar @ crate::Scalar { width: 4, .. },
+                size: Vs::Bi,
+            } => (scalar, Some(Vs::Tri)),
+            Ti::Vector {
+                scalar: scalar @ crate::Scalar { width: 4, .. },
+                size: Vs::Tri,
+            } => (scalar, Some(Vs::Quad)),
+            Ti::Vector { size: Vs::Quad, .. } => {
+                return Err(Error::Validation("extending vec4 coordinate"));
+            }
+            ref other => {
+                log::error!("wrong coordinate type {:?}", other);
+                return Err(Error::Validation("coordinate type"));
+            }
+        };
+
+        // Convert the index to the coordinate component type, if necessary.
+        let array_index_id = self.cached[array_index];
+        let ty = &self.fun_info[array_index].ty;
+        let inner_ty = ty.inner_with(&self.ir_module.types);
+        let array_index_scalar = match *inner_ty {
+            Ti::Scalar(
+                scalar @ crate::Scalar {
+                    kind: crate::ScalarKind::Sint | crate::ScalarKind::Uint,
+                    width: 4,
+                },
+            ) => scalar,
+            _ => unreachable!("we only allow i32 and u32"),
+        };
+        let cast = match (component_scalar.kind, array_index_scalar.kind) {
+            (crate::ScalarKind::Sint, crate::ScalarKind::Sint)
+            | (crate::ScalarKind::Uint, crate::ScalarKind::Uint) => None,
+            (crate::ScalarKind::Sint, crate::ScalarKind::Uint)
+            | (crate::ScalarKind::Uint, crate::ScalarKind::Sint) => Some(spirv::Op::Bitcast),
+            (crate::ScalarKind::Float, crate::ScalarKind::Sint) => Some(spirv::Op::ConvertSToF),
+            (crate::ScalarKind::Float, crate::ScalarKind::Uint) => Some(spirv::Op::ConvertUToF),
+            (crate::ScalarKind::Bool, _) => unreachable!("we don't allow bool for component"),
+            (_, crate::ScalarKind::Bool | crate::ScalarKind::Float) => {
+                unreachable!("we don't allow bool or float for array index")
+            }
+            (crate::ScalarKind::AbstractInt | crate::ScalarKind::AbstractFloat, _)
+            | (_, crate::ScalarKind::AbstractInt | crate::ScalarKind::AbstractFloat) => {
+                unreachable!("abstract types should never reach backends")
+            }
+        };
+        let reconciled_array_index_id = if let Some(cast) = cast {
+            let component_ty_id = self.get_type_id(LookupType::Local(LocalType::Value {
+                vector_size: None,
+                scalar: component_scalar,
+                pointer_space: None,
+            }));
+            let reconciled_id = self.gen_id();
+            block.body.push(Instruction::unary(
+                cast,
+                component_ty_id,
+                reconciled_id,
+                array_index_id,
+            ));
+            reconciled_id
+        } else {
+            array_index_id
+        };
+
+        // Find the SPIR-V type for the combined coordinates/index vector.
+        let type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: size,
+            scalar: component_scalar,
+            pointer_space: None,
+        }));
+
+        // Schmear the coordinates and index together.
+        let value_id = self.gen_id();
+        block.body.push(Instruction::composite_construct(
+            type_id,
+            value_id,
+            &[coordinates_id, reconciled_array_index_id],
+        ));
+        Ok(ImageCoordinates {
+            value_id,
+            type_id,
+            size,
+        })
+    }
+
+    pub(super) fn get_handle_id(&mut self, expr_handle: Handle<crate::Expression>) -> Word {
+        let id = match self.ir_function.expressions[expr_handle] {
+            crate::Expression::GlobalVariable(handle) => {
+                self.writer.global_variables[handle.index()].handle_id
+            }
+            crate::Expression::FunctionArgument(i) => {
+                self.function.parameters[i as usize].handle_id
+            }
+            crate::Expression::Access { .. } | crate::Expression::AccessIndex { .. } => {
+                self.cached[expr_handle]
+            }
+            ref other => unreachable!("Unexpected image expression {:?}", other),
+        };
+
+        if id == 0 {
+            unreachable!(
+                "Image expression {:?} doesn't have a handle ID",
+                expr_handle
+            );
+        }
+
+        id
+    }
+
+    /// Generate a vector or scalar 'one' for arithmetic on `coordinates`.
+    ///
+    /// If `coordinates` is a scalar, return a scalar one. Otherwise, return
+    /// a vector of ones.
+    fn write_coordinate_one(&mut self, coordinates: &ImageCoordinates) -> Result<Word, Error> {
+        let one = self.get_scope_constant(1);
+        match coordinates.size {
+            None => Ok(one),
+            Some(vector_size) => {
+                let ones = [one; 4];
+                let id = self.gen_id();
+                Instruction::constant_composite(
+                    coordinates.type_id,
+                    id,
+                    &ones[..vector_size as usize],
+                )
+                .to_words(&mut self.writer.logical_layout.declarations);
+                Ok(id)
+            }
+        }
+    }
+
+    /// Generate code to restrict `input` to fall between zero and one less than
+    /// `size_id`.
+    ///
+    /// Both must be 32-bit scalar integer values, whose type is given by
+    /// `type_id`. The computed value is also of type `type_id`.
+    fn restrict_scalar(
+        &mut self,
+        type_id: Word,
+        input_id: Word,
+        size_id: Word,
+        block: &mut Block,
+    ) -> Result<Word, Error> {
+        let i32_one_id = self.get_scope_constant(1);
+
+        // Subtract one from `size` to get the largest valid value.
+        let limit_id = self.gen_id();
+        block.body.push(Instruction::binary(
+            spirv::Op::ISub,
+            type_id,
+            limit_id,
+            size_id,
+            i32_one_id,
+        ));
+
+        // Use an unsigned minimum, to handle both positive out-of-range values
+        // and negative values in a single instruction: negative values of
+        // `input_id` get treated as very large positive values.
+        let restricted_id = self.gen_id();
+        block.body.push(Instruction::ext_inst(
+            self.writer.gl450_ext_inst_id,
+            spirv::GLOp::UMin,
+            type_id,
+            restricted_id,
+            &[input_id, limit_id],
+        ));
+
+        Ok(restricted_id)
+    }
+
+    /// Write instructions to query the size of an image.
+    ///
+    /// This takes care of selecting the right instruction depending on whether
+    /// a level of detail parameter is present.
+    fn write_coordinate_bounds(
+        &mut self,
+        type_id: Word,
+        image_id: Word,
+        level_id: Option<Word>,
+        block: &mut Block,
+    ) -> Word {
+        let coordinate_bounds_id = self.gen_id();
+        match level_id {
+            Some(level_id) => {
+                // A level of detail was provided, so fetch the image size for
+                // that level.
+                let mut inst = Instruction::image_query(
+                    spirv::Op::ImageQuerySizeLod,
+                    type_id,
+                    coordinate_bounds_id,
+                    image_id,
+                );
+                inst.add_operand(level_id);
+                block.body.push(inst);
+            }
+            _ => {
+                // No level of detail was given.
+                block.body.push(Instruction::image_query(
+                    spirv::Op::ImageQuerySize,
+                    type_id,
+                    coordinate_bounds_id,
+                    image_id,
+                ));
+            }
+        }
+
+        coordinate_bounds_id
+    }
+
+    /// Write code to restrict coordinates for an image reference.
+    ///
+    /// First, clamp the level of detail or sample index to fall within bounds.
+    /// Then, obtain the image size, possibly using the clamped level of detail.
+    /// Finally, use an unsigned minimum instruction to force all coordinates
+    /// into range.
+    ///
+    /// Return a triple `(COORDS, LEVEL, SAMPLE)`, where `COORDS` is a coordinate
+    /// vector (including the array index, if any), `LEVEL` is an optional level
+    /// of detail, and `SAMPLE` is an optional sample index, all guaranteed to
+    /// be in-bounds for `image_id`.
+    ///
+    /// The result is usually a vector, but it is a scalar when indexing
+    /// non-arrayed 1D images.
+    fn write_restricted_coordinates(
+        &mut self,
+        image_id: Word,
+        coordinates: ImageCoordinates,
+        level_id: Option<Word>,
+        sample_id: Option<Word>,
+        block: &mut Block,
+    ) -> Result<(Word, Option<Word>, Option<Word>), Error> {
+        self.writer.require_any(
+            "the `Restrict` image bounds check policy",
+            &[spirv::Capability::ImageQuery],
+        )?;
+
+        let i32_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::I32,
+            pointer_space: None,
+        }));
+
+        // If `level` is `Some`, clamp it to fall within bounds. This must
+        // happen first, because we'll use it to query the image size for
+        // clamping the actual coordinates.
+        let level_id = level_id
+            .map(|level_id| {
+                // Find the number of mipmap levels in this image.
+                let num_levels_id = self.gen_id();
+                block.body.push(Instruction::image_query(
+                    spirv::Op::ImageQueryLevels,
+                    i32_type_id,
+                    num_levels_id,
+                    image_id,
+                ));
+
+                self.restrict_scalar(i32_type_id, level_id, num_levels_id, block)
+            })
+            .transpose()?;
+
+        // If `sample_id` is `Some`, clamp it to fall within bounds.
+        let sample_id = sample_id
+            .map(|sample_id| {
+                // Find the number of samples per texel.
+                let num_samples_id = self.gen_id();
+                block.body.push(Instruction::image_query(
+                    spirv::Op::ImageQuerySamples,
+                    i32_type_id,
+                    num_samples_id,
+                    image_id,
+                ));
+
+                self.restrict_scalar(i32_type_id, sample_id, num_samples_id, block)
+            })
+            .transpose()?;
+
+        // Obtain the image bounds, including the array element count.
+        let coordinate_bounds_id =
+            self.write_coordinate_bounds(coordinates.type_id, image_id, level_id, block);
+
+        // Compute maximum valid values from the bounds.
+        let ones = self.write_coordinate_one(&coordinates)?;
+        let coordinate_limit_id = self.gen_id();
+        block.body.push(Instruction::binary(
+            spirv::Op::ISub,
+            coordinates.type_id,
+            coordinate_limit_id,
+            coordinate_bounds_id,
+            ones,
+        ));
+
+        // Restrict the coordinates to fall within those bounds.
+        //
+        // Use an unsigned minimum, to handle both positive out-of-range values
+        // and negative values in a single instruction: negative values of
+        // `coordinates` get treated as very large positive values.
+        let restricted_coordinates_id = self.gen_id();
+        block.body.push(Instruction::ext_inst(
+            self.writer.gl450_ext_inst_id,
+            spirv::GLOp::UMin,
+            coordinates.type_id,
+            restricted_coordinates_id,
+            &[coordinates.value_id, coordinate_limit_id],
+        ));
+
+        Ok((restricted_coordinates_id, level_id, sample_id))
+    }
+
+    fn write_conditional_image_access<A: Access>(
+        &mut self,
+        image_id: Word,
+        coordinates: ImageCoordinates,
+        level_id: Option<Word>,
+        sample_id: Option<Word>,
+        block: &mut Block,
+        access: &A,
+    ) -> Result<A::Output, Error> {
+        self.writer.require_any(
+            "the `ReadZeroSkipWrite` image bounds check policy",
+            &[spirv::Capability::ImageQuery],
+        )?;
+
+        let bool_type_id = self.writer.get_bool_type_id();
+        let i32_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::I32,
+            pointer_space: None,
+        }));
+
+        let null_id = access.out_of_bounds_value(self);
+
+        let mut selection = Selection::start(block, access.result_type());
+
+        // If `level_id` is `Some`, check whether it is within bounds. This must
+        // happen first, because we'll be supplying this as an argument when we
+        // query the image size.
+        if let Some(level_id) = level_id {
+            // Find the number of mipmap levels in this image.
+            let num_levels_id = self.gen_id();
+            selection.block().body.push(Instruction::image_query(
+                spirv::Op::ImageQueryLevels,
+                i32_type_id,
+                num_levels_id,
+                image_id,
+            ));
+
+            let lod_cond_id = self.gen_id();
+            selection.block().body.push(Instruction::binary(
+                spirv::Op::ULessThan,
+                bool_type_id,
+                lod_cond_id,
+                level_id,
+                num_levels_id,
+            ));
+
+            selection.if_true(self, lod_cond_id, null_id);
+        }
+
+        // If `sample_id` is `Some`, check whether it is in bounds.
+        if let Some(sample_id) = sample_id {
+            // Find the number of samples per texel.
+            let num_samples_id = self.gen_id();
+            selection.block().body.push(Instruction::image_query(
+                spirv::Op::ImageQuerySamples,
+                i32_type_id,
+                num_samples_id,
+                image_id,
+            ));
+
+            let samples_cond_id = self.gen_id();
+            selection.block().body.push(Instruction::binary(
+                spirv::Op::ULessThan,
+                bool_type_id,
+                samples_cond_id,
+                sample_id,
+                num_samples_id,
+            ));
+
+            selection.if_true(self, samples_cond_id, null_id);
+        }
+
+        // Obtain the image bounds, including any array element count.
+        let coordinate_bounds_id = self.write_coordinate_bounds(
+            coordinates.type_id,
+            image_id,
+            level_id,
+            selection.block(),
+        );
+
+        // Compare the coordinates against the bounds.
+        let coords_bool_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: coordinates.size,
+            scalar: crate::Scalar::BOOL,
+            pointer_space: None,
+        }));
+        let coords_conds_id = self.gen_id();
+        selection.block().body.push(Instruction::binary(
+            spirv::Op::ULessThan,
+            coords_bool_type_id,
+            coords_conds_id,
+            coordinates.value_id,
+            coordinate_bounds_id,
+        ));
+
+        // If the comparison above was a vector comparison, then we need to
+        // check that all components of the comparison are true.
+        let coords_cond_id = if coords_bool_type_id != bool_type_id {
+            let id = self.gen_id();
+            selection.block().body.push(Instruction::relational(
+                spirv::Op::All,
+                bool_type_id,
+                id,
+                coords_conds_id,
+            ));
+            id
+        } else {
+            coords_conds_id
+        };
+
+        selection.if_true(self, coords_cond_id, null_id);
+
+        // All conditions are met. We can carry out the access.
+        let texel_id = access.generate(
+            &mut self.writer.id_gen,
+            coordinates.value_id,
+            level_id,
+            sample_id,
+            selection.block(),
+        );
+
+        // This, then, is the value of the 'true' branch.
+        Ok(selection.finish(self, texel_id))
+    }
+
+    /// Generate code for an `ImageLoad` expression.
+    ///
+    /// The arguments are the components of an `Expression::ImageLoad` variant.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn write_image_load(
+        &mut self,
+        result_type_id: Word,
+        image: Handle<crate::Expression>,
+        coordinate: Handle<crate::Expression>,
+        array_index: Option<Handle<crate::Expression>>,
+        level: Option<Handle<crate::Expression>>,
+        sample: Option<Handle<crate::Expression>>,
+        block: &mut Block,
+    ) -> Result<Word, Error> {
+        let image_id = self.get_handle_id(image);
+        let image_type = self.fun_info[image].ty.inner_with(&self.ir_module.types);
+        let image_class = match *image_type {
+            crate::TypeInner::Image { class, .. } => class,
+            _ => return Err(Error::Validation("image type")),
+        };
+
+        let access = Load::from_image_expr(self, image_id, image_class, result_type_id)?;
+        let coordinates = self.write_image_coordinates(coordinate, array_index, block)?;
+
+        let level_id = level.map(|expr| self.cached[expr]);
+        let sample_id = sample.map(|expr| self.cached[expr]);
+
+        // Perform the access, according to the bounds check policy.
+        let access_id = match self.writer.bounds_check_policies.image_load {
+            crate::proc::BoundsCheckPolicy::Restrict => {
+                let (coords, level_id, sample_id) = self.write_restricted_coordinates(
+                    image_id,
+                    coordinates,
+                    level_id,
+                    sample_id,
+                    block,
+                )?;
+                access.generate(&mut self.writer.id_gen, coords, level_id, sample_id, block)
+            }
+            crate::proc::BoundsCheckPolicy::ReadZeroSkipWrite => self
+                .write_conditional_image_access(
+                    image_id,
+                    coordinates,
+                    level_id,
+                    sample_id,
+                    block,
+                    &access,
+                )?,
+            crate::proc::BoundsCheckPolicy::Unchecked => access.generate(
+                &mut self.writer.id_gen,
+                coordinates.value_id,
+                level_id,
+                sample_id,
+                block,
+            ),
+        };
+
+        // For depth images, `ImageLoad` expressions produce a single f32,
+        // whereas the SPIR-V instructions always produce a vec4. So we may have
+        // to pull out the component we need.
+        let result_id = if result_type_id == access.result_type() {
+            // The instruction produced the type we expected. We can use
+            // its result as-is.
+            access_id
+        } else {
+            // For `ImageClass::Depth` images, SPIR-V gave us four components,
+            // but we only want the first one.
+            let component_id = self.gen_id();
+            block.body.push(Instruction::composite_extract(
+                result_type_id,
+                component_id,
+                access_id,
+                &[0],
+            ));
+            component_id
+        };
+
+        Ok(result_id)
+    }
+
+    /// Generate code for an `ImageSample` expression.
+    ///
+    /// The arguments are the components of an `Expression::ImageSample` variant.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn write_image_sample(
+        &mut self,
+        result_type_id: Word,
+        image: Handle<crate::Expression>,
+        sampler: Handle<crate::Expression>,
+        gather: Option<crate::SwizzleComponent>,
+        coordinate: Handle<crate::Expression>,
+        array_index: Option<Handle<crate::Expression>>,
+        offset: Option<Handle<crate::Expression>>,
+        level: crate::SampleLevel,
+        depth_ref: Option<Handle<crate::Expression>>,
+        block: &mut Block,
+    ) -> Result<Word, Error> {
+        use super::instructions::SampleLod;
+        // image
+        let image_id = self.get_handle_id(image);
+        let image_type = self.fun_info[image].ty.handle().unwrap();
+        // SPIR-V doesn't know about our `Depth` class, and it returns
+        // `vec4<f32>`, so we need to grab the first component out of it.
+        let needs_sub_access = match self.ir_module.types[image_type].inner {
+            crate::TypeInner::Image {
+                class: crate::ImageClass::Depth { .. },
+                ..
+            } => depth_ref.is_none() && gather.is_none(),
+            _ => false,
+        };
+        let sample_result_type_id = if needs_sub_access {
+            self.get_type_id(LookupType::Local(LocalType::Value {
+                vector_size: Some(crate::VectorSize::Quad),
+                scalar: crate::Scalar::F32,
+                pointer_space: None,
+            }))
+        } else {
+            result_type_id
+        };
+
+        // OpTypeSampledImage
+        let image_type_id = self.get_type_id(LookupType::Handle(image_type));
+        let sampled_image_type_id =
+            self.get_type_id(LookupType::Local(LocalType::SampledImage { image_type_id }));
+
+        let sampler_id = self.get_handle_id(sampler);
+        let coordinates_id = self
+            .write_image_coordinates(coordinate, array_index, block)?
+            .value_id;
+
+        let sampled_image_id = self.gen_id();
+        block.body.push(Instruction::sampled_image(
+            sampled_image_type_id,
+            sampled_image_id,
+            image_id,
+            sampler_id,
+        ));
+        let id = self.gen_id();
+
+        let depth_id = depth_ref.map(|handle| self.cached[handle]);
+        let mut mask = spirv::ImageOperands::empty();
+        mask.set(spirv::ImageOperands::CONST_OFFSET, offset.is_some());
+
+        let mut main_instruction = match (level, gather) {
+            (_, Some(component)) => {
+                let component_id = self.get_index_constant(component as u32);
+                let mut inst = Instruction::image_gather(
+                    sample_result_type_id,
+                    id,
+                    sampled_image_id,
+                    coordinates_id,
+                    component_id,
+                    depth_id,
+                );
+                if !mask.is_empty() {
+                    inst.add_operand(mask.bits());
+                }
+                inst
+            }
+            (crate::SampleLevel::Zero, None) => {
+                let mut inst = Instruction::image_sample(
+                    sample_result_type_id,
+                    id,
+                    SampleLod::Explicit,
+                    sampled_image_id,
+                    coordinates_id,
+                    depth_id,
+                );
+
+                let zero_id = self.writer.get_constant_scalar(crate::Literal::F32(0.0));
+
+                mask |= spirv::ImageOperands::LOD;
+                inst.add_operand(mask.bits());
+                inst.add_operand(zero_id);
+
+                inst
+            }
+            (crate::SampleLevel::Auto, None) => {
+                let mut inst = Instruction::image_sample(
+                    sample_result_type_id,
+                    id,
+                    SampleLod::Implicit,
+                    sampled_image_id,
+                    coordinates_id,
+                    depth_id,
+                );
+                if !mask.is_empty() {
+                    inst.add_operand(mask.bits());
+                }
+                inst
+            }
+            (crate::SampleLevel::Exact(lod_handle), None) => {
+                let mut inst = Instruction::image_sample(
+                    sample_result_type_id,
+                    id,
+                    SampleLod::Explicit,
+                    sampled_image_id,
+                    coordinates_id,
+                    depth_id,
+                );
+
+                let lod_id = self.cached[lod_handle];
+                mask |= spirv::ImageOperands::LOD;
+                inst.add_operand(mask.bits());
+                inst.add_operand(lod_id);
+
+                inst
+            }
+            (crate::SampleLevel::Bias(bias_handle), None) => {
+                let mut inst = Instruction::image_sample(
+                    sample_result_type_id,
+                    id,
+                    SampleLod::Implicit,
+                    sampled_image_id,
+                    coordinates_id,
+                    depth_id,
+                );
+
+                let bias_id = self.cached[bias_handle];
+                mask |= spirv::ImageOperands::BIAS;
+                inst.add_operand(mask.bits());
+                inst.add_operand(bias_id);
+
+                inst
+            }
+            (crate::SampleLevel::Gradient { x, y }, None) => {
+                let mut inst = Instruction::image_sample(
+                    sample_result_type_id,
+                    id,
+                    SampleLod::Explicit,
+                    sampled_image_id,
+                    coordinates_id,
+                    depth_id,
+                );
+
+                let x_id = self.cached[x];
+                let y_id = self.cached[y];
+                mask |= spirv::ImageOperands::GRAD;
+                inst.add_operand(mask.bits());
+                inst.add_operand(x_id);
+                inst.add_operand(y_id);
+
+                inst
+            }
+        };
+
+        if let Some(offset_const) = offset {
+            let offset_id = self.writer.constant_ids[offset_const.index()];
+            main_instruction.add_operand(offset_id);
+        }
+
+        block.body.push(main_instruction);
+
+        let id = if needs_sub_access {
+            let sub_id = self.gen_id();
+            block.body.push(Instruction::composite_extract(
+                result_type_id,
+                sub_id,
+                id,
+                &[0],
+            ));
+            sub_id
+        } else {
+            id
+        };
+
+        Ok(id)
+    }
+
+    /// Generate code for an `ImageQuery` expression.
+    ///
+    /// The arguments are the components of an `Expression::ImageQuery` variant.
+    pub(super) fn write_image_query(
+        &mut self,
+        result_type_id: Word,
+        image: Handle<crate::Expression>,
+        query: crate::ImageQuery,
+        block: &mut Block,
+    ) -> Result<Word, Error> {
+        use crate::{ImageClass as Ic, ImageDimension as Id, ImageQuery as Iq};
+
+        let image_id = self.get_handle_id(image);
+        let image_type = self.fun_info[image].ty.handle().unwrap();
+        let (dim, arrayed, class) = match self.ir_module.types[image_type].inner {
+            crate::TypeInner::Image {
+                dim,
+                arrayed,
+                class,
+            } => (dim, arrayed, class),
+            _ => {
+                return Err(Error::Validation("image type"));
+            }
+        };
+
+        self.writer
+            .require_any("image queries", &[spirv::Capability::ImageQuery])?;
+
+        let id = match query {
+            Iq::Size { level } => {
+                let dim_coords = match dim {
+                    Id::D1 => 1,
+                    Id::D2 | Id::Cube => 2,
+                    Id::D3 => 3,
+                };
+                let array_coords = usize::from(arrayed);
+                let vector_size = match dim_coords + array_coords {
+                    2 => Some(crate::VectorSize::Bi),
+                    3 => Some(crate::VectorSize::Tri),
+                    4 => Some(crate::VectorSize::Quad),
+                    _ => None,
+                };
+                let extended_size_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+                    vector_size,
+                    scalar: crate::Scalar::U32,
+                    pointer_space: None,
+                }));
+
+                let (query_op, level_id) = match class {
+                    Ic::Sampled { multi: true, .. }
+                    | Ic::Depth { multi: true }
+                    | Ic::Storage { .. } => (spirv::Op::ImageQuerySize, None),
+                    _ => {
+                        let level_id = match level {
+                            Some(expr) => self.cached[expr],
+                            None => self.get_index_constant(0),
+                        };
+                        (spirv::Op::ImageQuerySizeLod, Some(level_id))
+                    }
+                };
+
+                // The ID of the vector returned by SPIR-V, which contains the dimensions
+                // as well as the layer count.
+                let id_extended = self.gen_id();
+                let mut inst = Instruction::image_query(
+                    query_op,
+                    extended_size_type_id,
+                    id_extended,
+                    image_id,
+                );
+                if let Some(expr_id) = level_id {
+                    inst.add_operand(expr_id);
+                }
+                block.body.push(inst);
+
+                if result_type_id != extended_size_type_id {
+                    let id = self.gen_id();
+                    let components = match dim {
+                        // always pick the first component, and duplicate it for all 3 dimensions
+                        Id::Cube => &[0u32, 0][..],
+                        _ => &[0u32, 1, 2, 3][..dim_coords],
+                    };
+                    block.body.push(Instruction::vector_shuffle(
+                        result_type_id,
+                        id,
+                        id_extended,
+                        id_extended,
+                        components,
+                    ));
+
+                    id
+                } else {
+                    id_extended
+                }
+            }
+            Iq::NumLevels => {
+                let query_id = self.gen_id();
+                block.body.push(Instruction::image_query(
+                    spirv::Op::ImageQueryLevels,
+                    result_type_id,
+                    query_id,
+                    image_id,
+                ));
+
+                query_id
+            }
+            Iq::NumLayers => {
+                let vec_size = match dim {
+                    Id::D1 => crate::VectorSize::Bi,
+                    Id::D2 | Id::Cube => crate::VectorSize::Tri,
+                    Id::D3 => crate::VectorSize::Quad,
+                };
+                let extended_size_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+                    vector_size: Some(vec_size),
+                    scalar: crate::Scalar::U32,
+                    pointer_space: None,
+                }));
+                let id_extended = self.gen_id();
+                let mut inst = Instruction::image_query(
+                    spirv::Op::ImageQuerySizeLod,
+                    extended_size_type_id,
+                    id_extended,
+                    image_id,
+                );
+                inst.add_operand(self.get_index_constant(0));
+                block.body.push(inst);
+
+                let extract_id = self.gen_id();
+                block.body.push(Instruction::composite_extract(
+                    result_type_id,
+                    extract_id,
+                    id_extended,
+                    &[vec_size as u32 - 1],
+                ));
+
+                extract_id
+            }
+            Iq::NumSamples => {
+                let query_id = self.gen_id();
+                block.body.push(Instruction::image_query(
+                    spirv::Op::ImageQuerySamples,
+                    result_type_id,
+                    query_id,
+                    image_id,
+                ));
+
+                query_id
+            }
+        };
+
+        Ok(id)
+    }
+
+    pub(super) fn write_image_store(
+        &mut self,
+        image: Handle<crate::Expression>,
+        coordinate: Handle<crate::Expression>,
+        array_index: Option<Handle<crate::Expression>>,
+        value: Handle<crate::Expression>,
+        block: &mut Block,
+    ) -> Result<(), Error> {
+        let image_id = self.get_handle_id(image);
+        let coordinates = self.write_image_coordinates(coordinate, array_index, block)?;
+        let value_id = self.cached[value];
+
+        let write = Store { image_id, value_id };
+
+        match *self.fun_info[image].ty.inner_with(&self.ir_module.types) {
+            crate::TypeInner::Image {
+                class:
+                    crate::ImageClass::Storage {
+                        format: crate::StorageFormat::Bgra8Unorm,
+                        ..
+                    },
+                ..
+            } => self.writer.require_any(
+                "Bgra8Unorm storage write",
+                &[spirv::Capability::StorageImageWriteWithoutFormat],
+            )?,
+            _ => {}
+        }
+
+        match self.writer.bounds_check_policies.image_store {
+            crate::proc::BoundsCheckPolicy::Restrict => {
+                let (coords, _, _) =
+                    self.write_restricted_coordinates(image_id, coordinates, None, None, block)?;
+                write.generate(&mut self.writer.id_gen, coords, None, None, block);
+            }
+            crate::proc::BoundsCheckPolicy::ReadZeroSkipWrite => {
+                self.write_conditional_image_access(
+                    image_id,
+                    coordinates,
+                    None,
+                    None,
+                    block,
+                    &write,
+                )?;
+            }
+            crate::proc::BoundsCheckPolicy::Unchecked => {
+                write.generate(
+                    &mut self.writer.id_gen,
+                    coordinates.value_id,
+                    None,
+                    None,
+                    block,
+                );
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/third_party/rust/naga/src/back/spv/index.rs b/third_party/rust/naga/src/back/spv/index.rs
new file mode 100644
index 0000000000..92e0f88d9a
--- /dev/null
+++ b/third_party/rust/naga/src/back/spv/index.rs
@@ -0,0 +1,421 @@
+/*!
+Bounds-checking for SPIR-V output.
+*/
+
+use super::{
+    helpers::global_needs_wrapper, selection::Selection, Block, BlockContext, Error, IdGenerator,
+    Instruction, Word,
+};
+use crate::{arena::Handle, proc::BoundsCheckPolicy};
+
+/// The results of performing a bounds check.
+///
+/// On success, `write_bounds_check` returns a value of this type.
+pub(super) enum BoundsCheckResult {
+    /// The index is statically known and in bounds, with the given value.
+    KnownInBounds(u32),
+
+    /// The given instruction computes the index to be used.
+    Computed(Word),
+
+    /// The given instruction computes a boolean condition which is true
+    /// if the index is in bounds.
+    Conditional(Word),
+}
+
+/// A value that we either know at translation time, or need to compute at runtime.
+pub(super) enum MaybeKnown<T> {
+    /// The value is known at shader translation time.
+    Known(T),
+
+    /// The value is computed by the instruction with the given id.
+    Computed(Word),
+}
+
+impl<'w> BlockContext<'w> {
+    /// Emit code to compute the length of a run-time array.
+    ///
+    /// Given `array`, an expression referring a runtime-sized array, return the
+    /// instruction id for the array's length.
+    pub(super) fn write_runtime_array_length(
+        &mut self,
+        array: Handle<crate::Expression>,
+        block: &mut Block,
+    ) -> Result<Word, Error> {
+        // Naga IR permits runtime-sized arrays as global variables or as the
+        // final member of a struct that is a global variable. SPIR-V permits
+        // only the latter, so this back end wraps bare runtime-sized arrays
+        // in a made-up struct; see `helpers::global_needs_wrapper` and its uses.
+        // This code must handle both cases.
+        let (structure_id, last_member_index) = match self.ir_function.expressions[array] {
+            crate::Expression::AccessIndex { base, index } => {
+                match self.ir_function.expressions[base] {
+                    crate::Expression::GlobalVariable(handle) => (
+                        self.writer.global_variables[handle.index()].access_id,
+                        index,
+                    ),
+                    _ => return Err(Error::Validation("array length expression")),
+                }
+            }
+            crate::Expression::GlobalVariable(handle) => {
+                let global = &self.ir_module.global_variables[handle];
+                if !global_needs_wrapper(self.ir_module, global) {
+                    return Err(Error::Validation("array length expression"));
+                }
+
+                (self.writer.global_variables[handle.index()].var_id, 0)
+            }
+            _ => return Err(Error::Validation("array length expression")),
+        };
+
+        let length_id = self.gen_id();
+        block.body.push(Instruction::array_length(
+            self.writer.get_uint_type_id(),
+            length_id,
+            structure_id,
+            last_member_index,
+        ));
+
+        Ok(length_id)
+    }
+
+    /// Compute the length of a subscriptable value.
+    ///
+    /// Given `sequence`, an expression referring to some indexable type, return
+    /// its length. The result may either be computed by SPIR-V instructions, or
+    /// known at shader translation time.
+    ///
+    /// `sequence` may be a `Vector`, `Matrix`, or `Array`, a `Pointer` to any
+    /// of those, or a `ValuePointer`. An array may be fixed-size, dynamically
+    /// sized, or use a specializable constant as its length.
+    fn write_sequence_length(
+        &mut self,
+        sequence: Handle<crate::Expression>,
+        block: &mut Block,
+    ) -> Result<MaybeKnown<u32>, Error> {
+        let sequence_ty = self.fun_info[sequence].ty.inner_with(&self.ir_module.types);
+        match sequence_ty.indexable_length(self.ir_module) {
+            Ok(crate::proc::IndexableLength::Known(known_length)) => {
+                Ok(MaybeKnown::Known(known_length))
+            }
+            Ok(crate::proc::IndexableLength::Dynamic) => {
+                let length_id = self.write_runtime_array_length(sequence, block)?;
+                Ok(MaybeKnown::Computed(length_id))
+            }
+            Err(err) => {
+                log::error!("Sequence length for {:?} failed: {}", sequence, err);
+                Err(Error::Validation("indexable length"))
+            }
+        }
+    }
+
+    /// Compute the maximum valid index of a subscriptable value.
+    ///
+    /// Given `sequence`, an expression referring to some indexable type, return
+    /// its maximum valid index - one less than its length. The result may
+    /// either be computed, or known at shader translation time.
+    ///
+    /// `sequence` may be a `Vector`, `Matrix`, or `Array`, a `Pointer` to any
+    /// of those, or a `ValuePointer`. An array may be fixed-size, dynamically
+    /// sized, or use a specializable constant as its length.
+    fn write_sequence_max_index(
+        &mut self,
+        sequence: Handle<crate::Expression>,
+        block: &mut Block,
+    ) -> Result<MaybeKnown<u32>, Error> {
+        match self.write_sequence_length(sequence, block)? {
+            MaybeKnown::Known(known_length) => {
+                // We should have thrown out all attempts to subscript zero-length
+                // sequences during validation, so the following subtraction should never
+                // underflow.
+                assert!(known_length > 0);
+                // Compute the max index from the length now.
+                Ok(MaybeKnown::Known(known_length - 1))
+            }
+            MaybeKnown::Computed(length_id) => {
+                // Emit code to compute the max index from the length.
+                let const_one_id = self.get_index_constant(1);
+                let max_index_id = self.gen_id();
+                block.body.push(Instruction::binary(
+                    spirv::Op::ISub,
+                    self.writer.get_uint_type_id(),
+                    max_index_id,
+                    length_id,
+                    const_one_id,
+                ));
+                Ok(MaybeKnown::Computed(max_index_id))
+            }
+        }
+    }
+
+    /// Restrict an index to be in range for a vector, matrix, or array.
+    ///
+    /// This is used to implement `BoundsCheckPolicy::Restrict`. An in-bounds
+    /// index is left unchanged. An out-of-bounds index is replaced with some
+    /// arbitrary in-bounds index. Note,this is not necessarily clamping; for
+    /// example, negative indices might be changed to refer to the last element
+    /// of the sequence, not the first, as clamping would do.
+    ///
+    /// Either return the restricted index value, if known, or add instructions
+    /// to `block` to compute it, and return the id of the result. See the
+    /// documentation for `BoundsCheckResult` for details.
+    ///
+    /// The `sequence` expression may be a `Vector`, `Matrix`, or `Array`, a
+    /// `Pointer` to any of those, or a `ValuePointer`. An array may be
+    /// fixed-size, dynamically sized, or use a specializable constant as its
+    /// length.
+    pub(super) fn write_restricted_index(
+        &mut self,
+        sequence: Handle<crate::Expression>,
+        index: Handle<crate::Expression>,
+        block: &mut Block,
+    ) -> Result<BoundsCheckResult, Error> {
+        let index_id = self.cached[index];
+
+        // Get the sequence's maximum valid index. Return early if we've already
+        // done the bounds check.
+        let max_index_id = match self.write_sequence_max_index(sequence, block)? {
+            MaybeKnown::Known(known_max_index) => {
+                if let Ok(known_index) = self
+                    .ir_module
+                    .to_ctx()
+                    .eval_expr_to_u32_from(index, &self.ir_function.expressions)
+                {
+                    // Both the index and length are known at compile time.
+                    //
+                    // In strict WGSL compliance mode, out-of-bounds indices cannot be
+                    // reported at shader translation time, and must be replaced with
+                    // in-bounds indices at run time. So we cannot assume that
+                    // validation ensured the index was in bounds. Restrict now.
+                    let restricted = std::cmp::min(known_index, known_max_index);
+                    return Ok(BoundsCheckResult::KnownInBounds(restricted));
+                }
+
+                self.get_index_constant(known_max_index)
+            }
+            MaybeKnown::Computed(max_index_id) => max_index_id,
+        };
+
+        // One or the other of the index or length is dynamic, so emit code for
+        // BoundsCheckPolicy::Restrict.
+        let restricted_index_id = self.gen_id();
+        block.body.push(Instruction::ext_inst(
+            self.writer.gl450_ext_inst_id,
+            spirv::GLOp::UMin,
+            self.writer.get_uint_type_id(),
+            restricted_index_id,
+            &[index_id, max_index_id],
+        ));
+        Ok(BoundsCheckResult::Computed(restricted_index_id))
+    }
+
+    /// Write an index bounds comparison to `block`, if needed.
+    ///
+    /// If we're able to determine statically that `index` is in bounds for
+    /// `sequence`, return `KnownInBounds(value)`, where `value` is the actual
+    /// value of the index. (In principle, one could know that the index is in
+    /// bounds without knowing its specific value, but in our simple-minded
+    /// situation, we always know it.)
+    ///
+    /// If instead we must generate code to perform the comparison at run time,
+    /// return `Conditional(comparison_id)`, where `comparison_id` is an
+    /// instruction producing a boolean value that is true if `index` is in
+    /// bounds for `sequence`.
+    ///
+    /// The `sequence` expression may be a `Vector`, `Matrix`, or `Array`, a
+    /// `Pointer` to any of those, or a `ValuePointer`. An array may be
+    /// fixed-size, dynamically sized, or use a specializable constant as its
+    /// length.
+    fn write_index_comparison(
+        &mut self,
+        sequence: Handle<crate::Expression>,
+        index: Handle<crate::Expression>,
+        block: &mut Block,
+    ) -> Result<BoundsCheckResult, Error> {
+        let index_id = self.cached[index];
+
+        // Get the sequence's length. Return early if we've already done the
+        // bounds check.
+        let length_id = match self.write_sequence_length(sequence, block)? {
+            MaybeKnown::Known(known_length) => {
+                if let Ok(known_index) = self
+                    .ir_module
+                    .to_ctx()
+                    .eval_expr_to_u32_from(index, &self.ir_function.expressions)
+                {
+                    // Both the index and length are known at compile time.
+                    //
+                    // It would be nice to assume that, since we are using the
+                    // `ReadZeroSkipWrite` policy, we are not in strict WGSL
+                    // compliance mode, and thus we can count on the validator to have
+                    // rejected any programs with known out-of-bounds indices, and
+                    // thus just return `KnownInBounds` here without actually
+                    // checking.
+                    //
+                    // But it's also reasonable to expect that bounds check policies
+                    // and error reporting policies should be able to vary
+                    // independently without introducing security holes. So, we should
+                    // support the case where bad indices do not cause validation
+                    // errors, and are handled via `ReadZeroSkipWrite`.
+                    //
+                    // In theory, when `known_index` is bad, we could return a new
+                    // `KnownOutOfBounds` variant here. But it's simpler just to fall
+                    // through and let the bounds check take place. The shader is
+                    // broken anyway, so it doesn't make sense to invest in emitting
+                    // the ideal code for it.
+                    if known_index < known_length {
+                        return Ok(BoundsCheckResult::KnownInBounds(known_index));
+                    }
+                }
+
+                self.get_index_constant(known_length)
+            }
+            MaybeKnown::Computed(length_id) => length_id,
+        };
+
+        // Compare the index against the length.
+        let condition_id = self.gen_id();
+        block.body.push(Instruction::binary(
+            spirv::Op::ULessThan,
+            self.writer.get_bool_type_id(),
+            condition_id,
+            index_id,
+            length_id,
+        ));
+
+        // Indicate that we did generate the check.
+        Ok(BoundsCheckResult::Conditional(condition_id))
+    }
+
+    /// Emit a conditional load for `BoundsCheckPolicy::ReadZeroSkipWrite`.
+    ///
+    /// Generate code to load a value of `result_type` if `condition` is true,
+    /// and generate a null value of that type if it is false. Call `emit_load`
+    /// to emit the instructions to perform the load. Return the id of the
+    /// merged value of the two branches.
+    pub(super) fn write_conditional_indexed_load<F>(
+        &mut self,
+        result_type: Word,
+        condition: Word,
+        block: &mut Block,
+        emit_load: F,
+    ) -> Word
+    where
+        F: FnOnce(&mut IdGenerator, &mut Block) -> Word,
+    {
+        // For the out-of-bounds case, we produce a zero value.
+        let null_id = self.writer.get_constant_null(result_type);
+
+        let mut selection = Selection::start(block, result_type);
+
+        // As it turns out, we don't actually need a full 'if-then-else'
+        // structure for this: SPIR-V constants are declared up front, so the
+        // 'else' block would have no instructions. Instead we emit something
+        // like this:
+        //
+        //     result = zero;
+        //     if in_bounds {
+        //         result = do the load;
+        //     }
+        //     use result;
+
+        // Continue only if the index was in bounds. Otherwise, branch to the
+        // merge block.
+        selection.if_true(self, condition, null_id);
+
+        // The in-bounds path. Perform the access and the load.
+        let loaded_value = emit_load(&mut self.writer.id_gen, selection.block());
+
+        selection.finish(self, loaded_value)
+    }
+
+    /// Emit code for bounds checks for an array, vector, or matrix access.
+    ///
+    /// This implements either `index_bounds_check_policy` or
+    /// `buffer_bounds_check_policy`, depending on the address space of the
+    /// pointer being accessed.
+    ///
+    /// Return a `BoundsCheckResult` indicating how the index should be
+    /// consumed. See that type's documentation for details.
+    pub(super) fn write_bounds_check(
+        &mut self,
+        base: Handle<crate::Expression>,
+        index: Handle<crate::Expression>,
+        block: &mut Block,
+    ) -> Result<BoundsCheckResult, Error> {
+        let policy = self.writer.bounds_check_policies.choose_policy(
+            base,
+            &self.ir_module.types,
+            self.fun_info,
+        );
+
+        Ok(match policy {
+            BoundsCheckPolicy::Restrict => self.write_restricted_index(base, index, block)?,
+            BoundsCheckPolicy::ReadZeroSkipWrite => {
+                self.write_index_comparison(base, index, block)?
+            }
+            BoundsCheckPolicy::Unchecked => BoundsCheckResult::Computed(self.cached[index]),
+        })
+    }
+
+    /// Emit code to subscript a vector by value with a computed index.
+    ///
+    /// Return the id of the element value.
+    pub(super) fn write_vector_access(
+        &mut self,
+        expr_handle: Handle<crate::Expression>,
+        base: Handle<crate::Expression>,
+        index: Handle<crate::Expression>,
+        block: &mut Block,
+    ) -> Result<Word, Error> {
+        let result_type_id = self.get_expression_type_id(&self.fun_info[expr_handle].ty);
+
+        let base_id = self.cached[base];
+        let index_id = self.cached[index];
+
+        let result_id = match self.write_bounds_check(base, index, block)? {
+            BoundsCheckResult::KnownInBounds(known_index) => {
+                let result_id = self.gen_id();
+                block.body.push(Instruction::composite_extract(
+                    result_type_id,
+                    result_id,
+                    base_id,
+                    &[known_index],
+                ));
+                result_id
+            }
+            BoundsCheckResult::Computed(computed_index_id) => {
+                let result_id = self.gen_id();
+                block.body.push(Instruction::vector_extract_dynamic(
+                    result_type_id,
+                    result_id,
+                    base_id,
+                    computed_index_id,
+                ));
+                result_id
+            }
+            BoundsCheckResult::Conditional(comparison_id) => {
+                // Run-time bounds checks were required. Emit
+                // conditional load.
+                self.write_conditional_indexed_load(
+                    result_type_id,
+                    comparison_id,
+                    block,
+                    |id_gen, block| {
+                        // The in-bounds path. Generate the access.
+                        let element_id = id_gen.next();
+                        block.body.push(Instruction::vector_extract_dynamic(
+                            result_type_id,
+                            element_id,
+                            base_id,
+                            index_id,
+                        ));
+                        element_id
+                    },
+                )
+            }
+        };
+
+        Ok(result_id)
+    }
+}
diff --git a/third_party/rust/naga/src/back/spv/instructions.rs b/third_party/rust/naga/src/back/spv/instructions.rs
new file mode 100644
index 0000000000..b963793ad3
--- /dev/null
+++ b/third_party/rust/naga/src/back/spv/instructions.rs
@@ -0,0 +1,1100 @@
+use super::{block::DebugInfoInner, helpers};
+use spirv::{Op, Word};
+
+pub(super) enum Signedness {
+    Unsigned = 0,
+    Signed = 1,
+}
+
+pub(super) enum SampleLod {
+    Explicit,
+    Implicit,
+}
+
+pub(super) struct Case {
+    pub value: Word,
+    pub label_id: Word,
+}
+
+impl super::Instruction {
+    //
+    //  Debug Instructions
+    //
+
+    pub(super) fn string(name: &str, id: Word) -> Self {
+        let mut instruction = Self::new(Op::String);
+        instruction.set_result(id);
+        instruction.add_operands(helpers::string_to_words(name));
+        instruction
+    }
+
+    pub(super) fn source(
+        source_language: spirv::SourceLanguage,
+        version: u32,
+        source: &Option<DebugInfoInner>,
+    ) -> Self {
+        let mut instruction = Self::new(Op::Source);
+        instruction.add_operand(source_language as u32);
+        instruction.add_operands(helpers::bytes_to_words(&version.to_le_bytes()));
+        if let Some(source) = source.as_ref() {
+            instruction.add_operand(source.source_file_id);
+            instruction.add_operands(helpers::string_to_words(source.source_code));
+        }
+        instruction
+    }
+
+    pub(super) fn name(target_id: Word, name: &str) -> Self {
+        let mut instruction = Self::new(Op::Name);
+        instruction.add_operand(target_id);
+        instruction.add_operands(helpers::string_to_words(name));
+        instruction
+    }
+
+    pub(super) fn member_name(target_id: Word, member: Word, name: &str) -> Self {
+        let mut instruction = Self::new(Op::MemberName);
+        instruction.add_operand(target_id);
+        instruction.add_operand(member);
+        instruction.add_operands(helpers::string_to_words(name));
+        instruction
+    }
+
+    pub(super) fn line(file: Word, line: Word, column: Word) -> Self {
+        let mut instruction = Self::new(Op::Line);
+        instruction.add_operand(file);
+        instruction.add_operand(line);
+        instruction.add_operand(column);
+        instruction
+    }
+
+    pub(super) const fn no_line() -> Self {
+        Self::new(Op::NoLine)
+    }
+
+    //
+    //  Annotation Instructions
+    //
+
+    pub(super) fn decorate(
+        target_id: Word,
+        decoration: spirv::Decoration,
+        operands: &[Word],
+    ) -> Self {
+        let mut instruction = Self::new(Op::Decorate);
+        instruction.add_operand(target_id);
+        instruction.add_operand(decoration as u32);
+        for operand in operands {
+            instruction.add_operand(*operand)
+        }
+        instruction
+    }
+
+    pub(super) fn member_decorate(
+        target_id: Word,
+        member_index: Word,
+        decoration: spirv::Decoration,
+        operands: &[Word],
+    ) -> Self {
+        let mut instruction = Self::new(Op::MemberDecorate);
+        instruction.add_operand(target_id);
+        instruction.add_operand(member_index);
+        instruction.add_operand(decoration as u32);
+        for operand in operands {
+            instruction.add_operand(*operand)
+        }
+        instruction
+    }
+
+    //
+    //  Extension Instructions
+    //
+
+    pub(super) fn extension(name: &str) -> Self {
+        let mut instruction = Self::new(Op::Extension);
+        instruction.add_operands(helpers::string_to_words(name));
+        instruction
+    }
+
+    pub(super) fn ext_inst_import(id: Word, name: &str) -> Self {
+        let mut instruction = Self::new(Op::ExtInstImport);
+        instruction.set_result(id);
+        instruction.add_operands(helpers::string_to_words(name));
+        instruction
+    }
+
+    pub(super) fn ext_inst(
+        set_id: Word,
+        op: spirv::GLOp,
+        result_type_id: Word,
+        id: Word,
+        operands: &[Word],
+    ) -> Self {
+        let mut instruction = Self::new(Op::ExtInst);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(set_id);
+        instruction.add_operand(op as u32);
+        for operand in operands {
+            instruction.add_operand(*operand)
+        }
+        instruction
+    }
+
+    //
+    //  Mode-Setting Instructions
+    //
+
+    pub(super) fn memory_model(
+        addressing_model: spirv::AddressingModel,
+        memory_model: spirv::MemoryModel,
+    ) -> Self {
+        let mut instruction = Self::new(Op::MemoryModel);
+        instruction.add_operand(addressing_model as u32);
+        instruction.add_operand(memory_model as u32);
+        instruction
+    }
+
+    pub(super) fn entry_point(
+        execution_model: spirv::ExecutionModel,
+        entry_point_id: Word,
+        name: &str,
+        interface_ids: &[Word],
+    ) -> Self {
+        let mut instruction = Self::new(Op::EntryPoint);
+        instruction.add_operand(execution_model as u32);
+        instruction.add_operand(entry_point_id);
+        instruction.add_operands(helpers::string_to_words(name));
+
+        for interface_id in interface_ids {
+            instruction.add_operand(*interface_id);
+        }
+
+        instruction
+    }
+
+    pub(super) fn execution_mode(
+        entry_point_id: Word,
+        execution_mode: spirv::ExecutionMode,
+        args: &[Word],
+    ) -> Self {
+        let mut instruction = Self::new(Op::ExecutionMode);
+        instruction.add_operand(entry_point_id);
+        instruction.add_operand(execution_mode as u32);
+        for arg in args {
+            instruction.add_operand(*arg);
+        }
+        instruction
+    }
+
+    pub(super) fn capability(capability: spirv::Capability) -> Self {
+        let mut instruction = Self::new(Op::Capability);
+        instruction.add_operand(capability as u32);
+        instruction
+    }
+
+    //
+    //  Type-Declaration Instructions
+    //
+
+    pub(super) fn type_void(id: Word) -> Self {
+        let mut instruction = Self::new(Op::TypeVoid);
+        instruction.set_result(id);
+        instruction
+    }
+
+    pub(super) fn type_bool(id: Word) -> Self {
+        let mut instruction = Self::new(Op::TypeBool);
+        instruction.set_result(id);
+        instruction
+    }
+
+    pub(super) fn type_int(id: Word, width: Word, signedness: Signedness) -> Self {
+        let mut instruction = Self::new(Op::TypeInt);
+        instruction.set_result(id);
+        instruction.add_operand(width);
+        instruction.add_operand(signedness as u32);
+        instruction
+    }
+
+    pub(super) fn type_float(id: Word, width: Word) -> Self {
+        let mut instruction = Self::new(Op::TypeFloat);
+        instruction.set_result(id);
+        instruction.add_operand(width);
+        instruction
+    }
+
+    pub(super) fn type_vector(
+        id: Word,
+        component_type_id: Word,
+        component_count: crate::VectorSize,
+    ) -> Self {
+        let mut instruction = Self::new(Op::TypeVector);
+        instruction.set_result(id);
+        instruction.add_operand(component_type_id);
+        instruction.add_operand(component_count as u32);
+        instruction
+    }
+
+    pub(super) fn type_matrix(
+        id: Word,
+        column_type_id: Word,
+        column_count: crate::VectorSize,
+    ) -> Self {
+        let mut instruction = Self::new(Op::TypeMatrix);
+        instruction.set_result(id);
+        instruction.add_operand(column_type_id);
+        instruction.add_operand(column_count as u32);
+        instruction
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn type_image(
+        id: Word,
+        sampled_type_id: Word,
+        dim: spirv::Dim,
+        flags: super::ImageTypeFlags,
+        image_format: spirv::ImageFormat,
+    ) -> Self {
+        let mut instruction = Self::new(Op::TypeImage);
+        instruction.set_result(id);
+        instruction.add_operand(sampled_type_id);
+        instruction.add_operand(dim as u32);
+        instruction.add_operand(flags.contains(super::ImageTypeFlags::DEPTH) as u32);
+        instruction.add_operand(flags.contains(super::ImageTypeFlags::ARRAYED) as u32);
+        instruction.add_operand(flags.contains(super::ImageTypeFlags::MULTISAMPLED) as u32);
+        instruction.add_operand(if flags.contains(super::ImageTypeFlags::SAMPLED) {
+            1
+        } else {
+            2
+        });
+        instruction.add_operand(image_format as u32);
+        instruction
+    }
+
+    pub(super) fn type_sampler(id: Word) -> Self {
+        let mut instruction = Self::new(Op::TypeSampler);
+        instruction.set_result(id);
+        instruction
+    }
+
+    pub(super) fn type_acceleration_structure(id: Word) -> Self {
+        let mut instruction = Self::new(Op::TypeAccelerationStructureKHR);
+        instruction.set_result(id);
+        instruction
+    }
+
+    pub(super) fn type_ray_query(id: Word) -> Self {
+        let mut instruction = Self::new(Op::TypeRayQueryKHR);
+        instruction.set_result(id);
+        instruction
+    }
+
+    pub(super) fn type_sampled_image(id: Word, image_type_id: Word) -> Self {
+        let mut instruction = Self::new(Op::TypeSampledImage);
+        instruction.set_result(id);
+        instruction.add_operand(image_type_id);
+        instruction
+    }
+
+    pub(super) fn type_array(id: Word, element_type_id: Word, length_id: Word) -> Self {
+        let mut instruction = Self::new(Op::TypeArray);
+        instruction.set_result(id);
+        instruction.add_operand(element_type_id);
+        instruction.add_operand(length_id);
+        instruction
+    }
+
+    pub(super) fn type_runtime_array(id: Word, element_type_id: Word) -> Self {
+        let mut instruction = Self::new(Op::TypeRuntimeArray);
+        instruction.set_result(id);
+        instruction.add_operand(element_type_id);
+        instruction
+    }
+
+    pub(super) fn type_struct(id: Word, member_ids: &[Word]) -> Self {
+        let mut instruction = Self::new(Op::TypeStruct);
+        instruction.set_result(id);
+
+        for member_id in member_ids {
+            instruction.add_operand(*member_id)
+        }
+
+        instruction
+    }
+
+    pub(super) fn type_pointer(
+        id: Word,
+        storage_class: spirv::StorageClass,
+        type_id: Word,
+    ) -> Self {
+        let mut instruction = Self::new(Op::TypePointer);
+        instruction.set_result(id);
+        instruction.add_operand(storage_class as u32);
+        instruction.add_operand(type_id);
+        instruction
+    }
+
+    pub(super) fn type_function(id: Word, return_type_id: Word, parameter_ids: &[Word]) -> Self {
+        let mut instruction = Self::new(Op::TypeFunction);
+        instruction.set_result(id);
+        instruction.add_operand(return_type_id);
+
+        for parameter_id in parameter_ids {
+            instruction.add_operand(*parameter_id);
+        }
+
+        instruction
+    }
+
+    //
+    //  Constant-Creation Instructions
+    //
+
+    pub(super) fn constant_null(result_type_id: Word, id: Word) -> Self {
+        let mut instruction = Self::new(Op::ConstantNull);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction
+    }
+
+    pub(super) fn constant_true(result_type_id: Word, id: Word) -> Self {
+        let mut instruction = Self::new(Op::ConstantTrue);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction
+    }
+
+    pub(super) fn constant_false(result_type_id: Word, id: Word) -> Self {
+        let mut instruction = Self::new(Op::ConstantFalse);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction
+    }
+
+    pub(super) fn constant_32bit(result_type_id: Word, id: Word, value: Word) -> Self {
+        Self::constant(result_type_id, id, &[value])
+    }
+
+    pub(super) fn constant_64bit(result_type_id: Word, id: Word, low: Word, high: Word) -> Self {
+        Self::constant(result_type_id, id, &[low, high])
+    }
+
+    pub(super) fn constant(result_type_id: Word, id: Word, values: &[Word]) -> Self {
+        let mut instruction = Self::new(Op::Constant);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+
+        for value in values {
+            instruction.add_operand(*value);
+        }
+
+        instruction
+    }
+
+    pub(super) fn constant_composite(
+        result_type_id: Word,
+        id: Word,
+        constituent_ids: &[Word],
+    ) -> Self {
+        let mut instruction = Self::new(Op::ConstantComposite);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+
+        for constituent_id in constituent_ids {
+            instruction.add_operand(*constituent_id);
+        }
+
+        instruction
+    }
+
+    //
+    //  Memory Instructions
+    //
+
+    pub(super) fn variable(
+        result_type_id: Word,
+        id: Word,
+        storage_class: spirv::StorageClass,
+        initializer_id: Option<Word>,
+    ) -> Self {
+        let mut instruction = Self::new(Op::Variable);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(storage_class as u32);
+
+        if let Some(initializer_id) = initializer_id {
+            instruction.add_operand(initializer_id);
+        }
+
+        instruction
+    }
+
+    pub(super) fn load(
+        result_type_id: Word,
+        id: Word,
+        pointer_id: Word,
+        memory_access: Option<spirv::MemoryAccess>,
+    ) -> Self {
+        let mut instruction = Self::new(Op::Load);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(pointer_id);
+
+        if let Some(memory_access) = memory_access {
+            instruction.add_operand(memory_access.bits());
+        }
+
+        instruction
+    }
+
+    pub(super) fn atomic_load(
+        result_type_id: Word,
+        id: Word,
+        pointer_id: Word,
+        scope_id: Word,
+        semantics_id: Word,
+    ) -> Self {
+        let mut instruction = Self::new(Op::AtomicLoad);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(pointer_id);
+        instruction.add_operand(scope_id);
+        instruction.add_operand(semantics_id);
+        instruction
+    }
+
+    pub(super) fn store(
+        pointer_id: Word,
+        value_id: Word,
+        memory_access: Option<spirv::MemoryAccess>,
+    ) -> Self {
+        let mut instruction = Self::new(Op::Store);
+        instruction.add_operand(pointer_id);
+        instruction.add_operand(value_id);
+
+        if let Some(memory_access) = memory_access {
+            instruction.add_operand(memory_access.bits());
+        }
+
+        instruction
+    }
+
+    pub(super) fn atomic_store(
+        pointer_id: Word,
+        scope_id: Word,
+        semantics_id: Word,
+        value_id: Word,
+    ) -> Self {
+        let mut instruction = Self::new(Op::AtomicStore);
+        instruction.add_operand(pointer_id);
+        instruction.add_operand(scope_id);
+        instruction.add_operand(semantics_id);
+        instruction.add_operand(value_id);
+        instruction
+    }
+
+    pub(super) fn access_chain(
+        result_type_id: Word,
+        id: Word,
+        base_id: Word,
+        index_ids: &[Word],
+    ) -> Self {
+        let mut instruction = Self::new(Op::AccessChain);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(base_id);
+
+        for index_id in index_ids {
+            instruction.add_operand(*index_id);
+        }
+
+        instruction
+    }
+
+    pub(super) fn array_length(
+        result_type_id: Word,
+        id: Word,
+        structure_id: Word,
+        array_member: Word,
+    ) -> Self {
+        let mut instruction = Self::new(Op::ArrayLength);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(structure_id);
+        instruction.add_operand(array_member);
+        instruction
+    }
+
+    //
+    //  Function Instructions
+    //
+
+    pub(super) fn function(
+        return_type_id: Word,
+        id: Word,
+        function_control: spirv::FunctionControl,
+        function_type_id: Word,
+    ) -> Self {
+        let mut instruction = Self::new(Op::Function);
+        instruction.set_type(return_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(function_control.bits());
+        instruction.add_operand(function_type_id);
+        instruction
+    }
+
+    pub(super) fn function_parameter(result_type_id: Word, id: Word) -> Self {
+        let mut instruction = Self::new(Op::FunctionParameter);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction
+    }
+
+    pub(super) const fn function_end() -> Self {
+        Self::new(Op::FunctionEnd)
+    }
+
+    pub(super) fn function_call(
+        result_type_id: Word,
+        id: Word,
+        function_id: Word,
+        argument_ids: &[Word],
+    ) -> Self {
+        let mut instruction = Self::new(Op::FunctionCall);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(function_id);
+
+        for argument_id in argument_ids {
+            instruction.add_operand(*argument_id);
+        }
+
+        instruction
+    }
+
+    //
+    //  Image Instructions
+    //
+
+    pub(super) fn sampled_image(
+        result_type_id: Word,
+        id: Word,
+        image: Word,
+        sampler: Word,
+    ) -> Self {
+        let mut instruction = Self::new(Op::SampledImage);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(image);
+        instruction.add_operand(sampler);
+        instruction
+    }
+
+    pub(super) fn image_sample(
+        result_type_id: Word,
+        id: Word,
+        lod: SampleLod,
+        sampled_image: Word,
+        coordinates: Word,
+        depth_ref: Option<Word>,
+    ) -> Self {
+        let op = match (lod, depth_ref) {
+            (SampleLod::Explicit, None) => Op::ImageSampleExplicitLod,
+            (SampleLod::Implicit, None) => Op::ImageSampleImplicitLod,
+            (SampleLod::Explicit, Some(_)) => Op::ImageSampleDrefExplicitLod,
+            (SampleLod::Implicit, Some(_)) => Op::ImageSampleDrefImplicitLod,
+        };
+
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(sampled_image);
+        instruction.add_operand(coordinates);
+        if let Some(dref) = depth_ref {
+            instruction.add_operand(dref);
+        }
+
+        instruction
+    }
+
+    pub(super) fn image_gather(
+        result_type_id: Word,
+        id: Word,
+        sampled_image: Word,
+        coordinates: Word,
+        component_id: Word,
+        depth_ref: Option<Word>,
+    ) -> Self {
+        let op = match depth_ref {
+            None => Op::ImageGather,
+            Some(_) => Op::ImageDrefGather,
+        };
+
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(sampled_image);
+        instruction.add_operand(coordinates);
+        if let Some(dref) = depth_ref {
+            instruction.add_operand(dref);
+        } else {
+            instruction.add_operand(component_id);
+        }
+
+        instruction
+    }
+
+    pub(super) fn image_fetch_or_read(
+        op: Op,
+        result_type_id: Word,
+        id: Word,
+        image: Word,
+        coordinates: Word,
+    ) -> Self {
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(image);
+        instruction.add_operand(coordinates);
+        instruction
+    }
+
+    pub(super) fn image_write(image: Word, coordinates: Word, value: Word) -> Self {
+        let mut instruction = Self::new(Op::ImageWrite);
+        instruction.add_operand(image);
+        instruction.add_operand(coordinates);
+        instruction.add_operand(value);
+        instruction
+    }
+
+    pub(super) fn image_query(op: Op, result_type_id: Word, id: Word, image: Word) -> Self {
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(image);
+        instruction
+    }
+
+    //
+    //  Ray Query Instructions
+    //
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn ray_query_initialize(
+        query: Word,
+        acceleration_structure: Word,
+        ray_flags: Word,
+        cull_mask: Word,
+        ray_origin: Word,
+        ray_tmin: Word,
+        ray_dir: Word,
+        ray_tmax: Word,
+    ) -> Self {
+        let mut instruction = Self::new(Op::RayQueryInitializeKHR);
+        instruction.add_operand(query);
+        instruction.add_operand(acceleration_structure);
+        instruction.add_operand(ray_flags);
+        instruction.add_operand(cull_mask);
+        instruction.add_operand(ray_origin);
+        instruction.add_operand(ray_tmin);
+        instruction.add_operand(ray_dir);
+        instruction.add_operand(ray_tmax);
+        instruction
+    }
+
+    pub(super) fn ray_query_proceed(result_type_id: Word, id: Word, query: Word) -> Self {
+        let mut instruction = Self::new(Op::RayQueryProceedKHR);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(query);
+        instruction
+    }
+
+    pub(super) fn ray_query_get_intersection(
+        op: Op,
+        result_type_id: Word,
+        id: Word,
+        query: Word,
+        intersection: Word,
+    ) -> Self {
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(query);
+        instruction.add_operand(intersection);
+        instruction
+    }
+
+    //
+    //  Conversion Instructions
+    //
+    pub(super) fn unary(op: Op, result_type_id: Word, id: Word, value: Word) -> Self {
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(value);
+        instruction
+    }
+
+    //
+    //  Composite Instructions
+    //
+
+    pub(super) fn composite_construct(
+        result_type_id: Word,
+        id: Word,
+        constituent_ids: &[Word],
+    ) -> Self {
+        let mut instruction = Self::new(Op::CompositeConstruct);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+
+        for constituent_id in constituent_ids {
+            instruction.add_operand(*constituent_id);
+        }
+
+        instruction
+    }
+
+    pub(super) fn composite_extract(
+        result_type_id: Word,
+        id: Word,
+        composite_id: Word,
+        indices: &[Word],
+    ) -> Self {
+        let mut instruction = Self::new(Op::CompositeExtract);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+
+        instruction.add_operand(composite_id);
+        for index in indices {
+            instruction.add_operand(*index);
+        }
+
+        instruction
+    }
+
+    pub(super) fn vector_extract_dynamic(
+        result_type_id: Word,
+        id: Word,
+        vector_id: Word,
+        index_id: Word,
+    ) -> Self {
+        let mut instruction = Self::new(Op::VectorExtractDynamic);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+
+        instruction.add_operand(vector_id);
+        instruction.add_operand(index_id);
+
+        instruction
+    }
+
+    pub(super) fn vector_shuffle(
+        result_type_id: Word,
+        id: Word,
+        v1_id: Word,
+        v2_id: Word,
+        components: &[Word],
+    ) -> Self {
+        let mut instruction = Self::new(Op::VectorShuffle);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(v1_id);
+        instruction.add_operand(v2_id);
+
+        for &component in components {
+            instruction.add_operand(component);
+        }
+
+        instruction
+    }
+
+    //
+    // Arithmetic Instructions
+    //
+    pub(super) fn binary(
+        op: Op,
+        result_type_id: Word,
+        id: Word,
+        operand_1: Word,
+        operand_2: Word,
+    ) -> Self {
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(operand_1);
+        instruction.add_operand(operand_2);
+        instruction
+    }
+
+    pub(super) fn ternary(
+        op: Op,
+        result_type_id: Word,
+        id: Word,
+        operand_1: Word,
+        operand_2: Word,
+        operand_3: Word,
+    ) -> Self {
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(operand_1);
+        instruction.add_operand(operand_2);
+        instruction.add_operand(operand_3);
+        instruction
+    }
+
+    pub(super) fn quaternary(
+        op: Op,
+        result_type_id: Word,
+        id: Word,
+        operand_1: Word,
+        operand_2: Word,
+        operand_3: Word,
+        operand_4: Word,
+    ) -> Self {
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(operand_1);
+        instruction.add_operand(operand_2);
+        instruction.add_operand(operand_3);
+        instruction.add_operand(operand_4);
+        instruction
+    }
+
+    pub(super) fn relational(op: Op, result_type_id: Word, id: Word, expr_id: Word) -> Self {
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(expr_id);
+        instruction
+    }
+
+    pub(super) fn atomic_binary(
+        op: Op,
+        result_type_id: Word,
+        id: Word,
+        pointer: Word,
+        scope_id: Word,
+        semantics_id: Word,
+        value: Word,
+    ) -> Self {
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(pointer);
+        instruction.add_operand(scope_id);
+        instruction.add_operand(semantics_id);
+        instruction.add_operand(value);
+        instruction
+    }
+
+    //
+    // Bit Instructions
+    //
+
+    //
+    // Relational and Logical Instructions
+    //
+
+    //
+    // Derivative Instructions
+    //
+
+    pub(super) fn derivative(op: Op, result_type_id: Word, id: Word, expr_id: Word) -> Self {
+        let mut instruction = Self::new(op);
+        instruction.set_type(result_type_id);
+        instruction.set_result(id);
+        instruction.add_operand(expr_id);
+        instruction
+    }
+
+    //
+    // Control-Flow Instructions
+    //
+
+    pub(super) fn phi(
+        result_type_id: Word,
+        result_id: Word,
+        var_parent_pairs: &[(Word, Word)],
+    ) -> Self {
+        let mut instruction = Self::new(Op::Phi);
+        instruction.add_operand(result_type_id);
+        instruction.add_operand(result_id);
+        for &(variable, parent) in var_parent_pairs {
+            instruction.add_operand(variable);
+            instruction.add_operand(parent);
+        }
+        instruction
+    }
+
+    pub(super) fn selection_merge(
+        merge_id: Word,
+        selection_control: spirv::SelectionControl,
+    ) -> Self {
+        let mut instruction = Self::new(Op::SelectionMerge);
+        instruction.add_operand(merge_id);
+        instruction.add_operand(selection_control.bits());
+        instruction
+    }
+
+    pub(super) fn loop_merge(
+        merge_id: Word,
+        continuing_id: Word,
+        selection_control: spirv::SelectionControl,
+    ) -> Self {
+        let mut instruction = Self::new(Op::LoopMerge);
+        instruction.add_operand(merge_id);
+        instruction.add_operand(continuing_id);
+        instruction.add_operand(selection_control.bits());
+        instruction
+    }
+
+    pub(super) fn label(id: Word) -> Self {
+        let mut instruction = Self::new(Op::Label);
+        instruction.set_result(id);
+        instruction
+    }
+
+    pub(super) fn branch(id: Word) -> Self {
+        let mut instruction = Self::new(Op::Branch);
+        instruction.add_operand(id);
+        instruction
+    }
+
+    // TODO Branch Weights not implemented.
+    pub(super) fn branch_conditional(
+        condition_id: Word,
+        true_label: Word,
+        false_label: Word,
+    ) -> Self {
+        let mut instruction = Self::new(Op::BranchConditional);
+        instruction.add_operand(condition_id);
+        instruction.add_operand(true_label);
+        instruction.add_operand(false_label);
+        instruction
+    }
+
+    pub(super) fn switch(selector_id: Word, default_id: Word, cases: &[Case]) -> Self {
+        let mut instruction = Self::new(Op::Switch);
+        instruction.add_operand(selector_id);
+        instruction.add_operand(default_id);
+        for case in cases {
+            instruction.add_operand(case.value);
+            instruction.add_operand(case.label_id);
+        }
+        instruction
+    }
+
+    pub(super) fn select(
+        result_type_id: Word,
+        id: Word,
+        condition_id: Word,
+        accept_id: Word,
+        reject_id: Word,
+    ) -> Self {
+        let mut instruction = Self::new(Op::Select);
+        instruction.add_operand(result_type_id);
+        instruction.add_operand(id);
+        instruction.add_operand(condition_id);
+        instruction.add_operand(accept_id);
+        instruction.add_operand(reject_id);
+        instruction
+    }
+
+    pub(super) const fn kill() -> Self {
+        Self::new(Op::Kill)
+    }
+
+    pub(super) const fn return_void() -> Self {
+        Self::new(Op::Return)
+    }
+
+    pub(super) fn return_value(value_id: Word) -> Self {
+        let mut instruction = Self::new(Op::ReturnValue);
+        instruction.add_operand(value_id);
+        instruction
+    }
+
+    //
+    //  Atomic Instructions
+    //
+
+    //
+    //  Primitive Instructions
+    //
+
+    // Barriers
+
+    pub(super) fn control_barrier(
+        exec_scope_id: Word,
+        mem_scope_id: Word,
+        semantics_id: Word,
+    ) -> Self {
+        let mut instruction = Self::new(Op::ControlBarrier);
+        instruction.add_operand(exec_scope_id);
+        instruction.add_operand(mem_scope_id);
+        instruction.add_operand(semantics_id);
+        instruction
+    }
+}
+
+impl From<crate::StorageFormat> for spirv::ImageFormat {
+    fn from(format: crate::StorageFormat) -> Self {
+        use crate::StorageFormat as Sf;
+        match format {
+            Sf::R8Unorm => Self::R8,
+            Sf::R8Snorm => Self::R8Snorm,
+            Sf::R8Uint => Self::R8ui,
+            Sf::R8Sint => Self::R8i,
+            Sf::R16Uint => Self::R16ui,
+            Sf::R16Sint => Self::R16i,
+            Sf::R16Float => Self::R16f,
+            Sf::Rg8Unorm => Self::Rg8,
+            Sf::Rg8Snorm => Self::Rg8Snorm,
+            Sf::Rg8Uint => Self::Rg8ui,
+            Sf::Rg8Sint => Self::Rg8i,
+            Sf::R32Uint => Self::R32ui,
+            Sf::R32Sint => Self::R32i,
+            Sf::R32Float => Self::R32f,
+            Sf::Rg16Uint => Self::Rg16ui,
+            Sf::Rg16Sint => Self::Rg16i,
+            Sf::Rg16Float => Self::Rg16f,
+            Sf::Rgba8Unorm => Self::Rgba8,
+            Sf::Rgba8Snorm => Self::Rgba8Snorm,
+            Sf::Rgba8Uint => Self::Rgba8ui,
+            Sf::Rgba8Sint => Self::Rgba8i,
+            Sf::Bgra8Unorm => Self::Unknown,
+            Sf::Rgb10a2Uint => Self::Rgb10a2ui,
+            Sf::Rgb10a2Unorm => Self::Rgb10A2,
+            Sf::Rg11b10Float => Self::R11fG11fB10f,
+            Sf::Rg32Uint => Self::Rg32ui,
+            Sf::Rg32Sint => Self::Rg32i,
+            Sf::Rg32Float => Self::Rg32f,
+            Sf::Rgba16Uint => Self::Rgba16ui,
+            Sf::Rgba16Sint => Self::Rgba16i,
+            Sf::Rgba16Float => Self::Rgba16f,
+            Sf::Rgba32Uint => Self::Rgba32ui,
+            Sf::Rgba32Sint => Self::Rgba32i,
+            Sf::Rgba32Float => Self::Rgba32f,
+            Sf::R16Unorm => Self::R16,
+            Sf::R16Snorm => Self::R16Snorm,
+            Sf::Rg16Unorm => Self::Rg16,
+            Sf::Rg16Snorm => Self::Rg16Snorm,
+            Sf::Rgba16Unorm => Self::Rgba16,
+            Sf::Rgba16Snorm => Self::Rgba16Snorm,
+        }
+    }
+}
+
+impl From<crate::ImageDimension> for spirv::Dim {
+    fn from(dim: crate::ImageDimension) -> Self {
+        use crate::ImageDimension as Id;
+        match dim {
+            Id::D1 => Self::Dim1D,
+            Id::D2 => Self::Dim2D,
+            Id::D3 => Self::Dim3D,
+            Id::Cube => Self::DimCube,
+        }
+    }
+}
diff --git a/third_party/rust/naga/src/back/spv/layout.rs b/third_party/rust/naga/src/back/spv/layout.rs
new file mode 100644
index 0000000000..39117a3d2a
--- /dev/null
+++ b/third_party/rust/naga/src/back/spv/layout.rs
@@ -0,0 +1,210 @@
+use super::{Instruction, LogicalLayout, PhysicalLayout};
+use spirv::{Op, Word, MAGIC_NUMBER};
+use std::iter;
+
+// https://github.com/KhronosGroup/SPIRV-Headers/pull/195
+const GENERATOR: Word = 28;
+
+impl PhysicalLayout {
+    pub(super) const fn new(version: Word) -> Self {
+        PhysicalLayout {
+            magic_number: MAGIC_NUMBER,
+            version,
+            generator: GENERATOR,
+            bound: 0,
+            instruction_schema: 0x0u32,
+        }
+    }
+
+    pub(super) fn in_words(&self, sink: &mut impl Extend<Word>) {
+        sink.extend(iter::once(self.magic_number));
+        sink.extend(iter::once(self.version));
+        sink.extend(iter::once(self.generator));
+        sink.extend(iter::once(self.bound));
+        sink.extend(iter::once(self.instruction_schema));
+    }
+}
+
+impl super::recyclable::Recyclable for PhysicalLayout {
+    fn recycle(self) -> Self {
+        PhysicalLayout {
+            magic_number: self.magic_number,
+            version: self.version,
+            generator: self.generator,
+            instruction_schema: self.instruction_schema,
+            bound: 0,
+        }
+    }
+}
+
+impl LogicalLayout {
+    pub(super) fn in_words(&self, sink: &mut impl Extend<Word>) {
+        sink.extend(self.capabilities.iter().cloned());
+        sink.extend(self.extensions.iter().cloned());
+        sink.extend(self.ext_inst_imports.iter().cloned());
+        sink.extend(self.memory_model.iter().cloned());
+        sink.extend(self.entry_points.iter().cloned());
+        sink.extend(self.execution_modes.iter().cloned());
+        sink.extend(self.debugs.iter().cloned());
+        sink.extend(self.annotations.iter().cloned());
+        sink.extend(self.declarations.iter().cloned());
+        sink.extend(self.function_declarations.iter().cloned());
+        sink.extend(self.function_definitions.iter().cloned());
+    }
+}
+
+impl super::recyclable::Recyclable for LogicalLayout {
+    fn recycle(self) -> Self {
+        Self {
+            capabilities: self.capabilities.recycle(),
+            extensions: self.extensions.recycle(),
+            ext_inst_imports: self.ext_inst_imports.recycle(),
+            memory_model: self.memory_model.recycle(),
+            entry_points: self.entry_points.recycle(),
+            execution_modes: self.execution_modes.recycle(),
+            debugs: self.debugs.recycle(),
+            annotations: self.annotations.recycle(),
+            declarations: self.declarations.recycle(),
+            function_declarations: self.function_declarations.recycle(),
+            function_definitions: self.function_definitions.recycle(),
+        }
+    }
+}
+
+impl Instruction {
+    pub(super) const fn new(op: Op) -> Self {
+        Instruction {
+            op,
+            wc: 1, // Always start at 1 for the first word (OP + WC),
+            type_id: None,
+            result_id: None,
+            operands: vec![],
+        }
+    }
+
+    #[allow(clippy::panic)]
+    pub(super) fn set_type(&mut self, id: Word) {
+        assert!(self.type_id.is_none(), "Type can only be set once");
+        self.type_id = Some(id);
+        self.wc += 1;
+    }
+
+    #[allow(clippy::panic)]
+    pub(super) fn set_result(&mut self, id: Word) {
+        assert!(self.result_id.is_none(), "Result can only be set once");
+        self.result_id = Some(id);
+        self.wc += 1;
+    }
+
+    pub(super) fn add_operand(&mut self, operand: Word) {
+        self.operands.push(operand);
+        self.wc += 1;
+    }
+
+    pub(super) fn add_operands(&mut self, operands: Vec<Word>) {
+        for operand in operands.into_iter() {
+            self.add_operand(operand)
+        }
+    }
+
+    pub(super) fn to_words(&self, sink: &mut impl Extend<Word>) {
+        sink.extend(Some(self.wc << 16 | self.op as u32));
+        sink.extend(self.type_id);
+        sink.extend(self.result_id);
+        sink.extend(self.operands.iter().cloned());
+    }
+}
+
+impl Instruction {
+    #[cfg(test)]
+    fn validate(&self, words: &[Word]) {
+        let mut inst_index = 0;
+        let (wc, op) = ((words[inst_index] >> 16) as u16, words[inst_index] as u16);
+        inst_index += 1;
+
+        assert_eq!(wc, words.len() as u16);
+        assert_eq!(op, self.op as u16);
+
+        if self.type_id.is_some() {
+            assert_eq!(words[inst_index], self.type_id.unwrap());
+            inst_index += 1;
+        }
+
+        if self.result_id.is_some() {
+            assert_eq!(words[inst_index], self.result_id.unwrap());
+            inst_index += 1;
+        }
+
+        for (op_index, i) in (inst_index..wc as usize).enumerate() {
+            assert_eq!(words[i], self.operands[op_index]);
+        }
+    }
+}
+
+#[test]
+fn test_physical_layout_in_words() {
+    let bound = 5;
+    let version = 0x10203;
+
+    let mut output = vec![];
+    let mut layout = PhysicalLayout::new(version);
+    layout.bound = bound;
+
+    layout.in_words(&mut output);
+
+    assert_eq!(&output, &[MAGIC_NUMBER, version, GENERATOR, bound, 0,]);
+}
+
+#[test]
+fn test_logical_layout_in_words() {
+    let mut output = vec![];
+    let mut layout = LogicalLayout::default();
+    let layout_vectors = 11;
+    let mut instructions = Vec::with_capacity(layout_vectors);
+
+    let vector_names = &[
+        "Capabilities",
+        "Extensions",
+        "External Instruction Imports",
+        "Memory Model",
+        "Entry Points",
+        "Execution Modes",
+        "Debugs",
+        "Annotations",
+        "Declarations",
+        "Function Declarations",
+        "Function Definitions",
+    ];
+
+    for (i, _) in vector_names.iter().enumerate().take(layout_vectors) {
+        let mut dummy_instruction = Instruction::new(Op::Constant);
+        dummy_instruction.set_type((i + 1) as u32);
+        dummy_instruction.set_result((i + 2) as u32);
+        dummy_instruction.add_operand((i + 3) as u32);
+        dummy_instruction.add_operands(super::helpers::string_to_words(
+            format!("This is the vector: {}", vector_names[i]).as_str(),
+        ));
+        instructions.push(dummy_instruction);
+    }
+
+    instructions[0].to_words(&mut layout.capabilities);
+    instructions[1].to_words(&mut layout.extensions);
+    instructions[2].to_words(&mut layout.ext_inst_imports);
+    instructions[3].to_words(&mut layout.memory_model);
+    instructions[4].to_words(&mut layout.entry_points);
+    instructions[5].to_words(&mut layout.execution_modes);
+    instructions[6].to_words(&mut layout.debugs);
+    instructions[7].to_words(&mut layout.annotations);
+    instructions[8].to_words(&mut layout.declarations);
+    instructions[9].to_words(&mut layout.function_declarations);
+    instructions[10].to_words(&mut layout.function_definitions);
+
+    layout.in_words(&mut output);
+
+    let mut index: usize = 0;
+    for instruction in instructions {
+        let wc = instruction.wc as usize;
+        instruction.validate(&output[index..index + wc]);
+        index += wc;
+    }
+}
diff --git a/third_party/rust/naga/src/back/spv/mod.rs b/third_party/rust/naga/src/back/spv/mod.rs
new file mode 100644
index 0000000000..b7d57be0d4
--- /dev/null
+++ b/third_party/rust/naga/src/back/spv/mod.rs
@@ -0,0 +1,748 @@
+/*!
+Backend for [SPIR-V][spv] (Standard Portable Intermediate Representation).
+
+[spv]: https://www.khronos.org/registry/SPIR-V/
+*/
+
+mod block;
+mod helpers;
+mod image;
+mod index;
+mod instructions;
+mod layout;
+mod ray;
+mod recyclable;
+mod selection;
+mod writer;
+
+pub use spirv::Capability;
+
+use crate::arena::Handle;
+use crate::proc::{BoundsCheckPolicies, TypeResolution};
+
+use spirv::Word;
+use std::ops;
+use thiserror::Error;
+
+#[derive(Clone)]
+struct PhysicalLayout {
+    magic_number: Word,
+    version: Word,
+    generator: Word,
+    bound: Word,
+    instruction_schema: Word,
+}
+
+#[derive(Default)]
+struct LogicalLayout {
+    capabilities: Vec<Word>,
+    extensions: Vec<Word>,
+    ext_inst_imports: Vec<Word>,
+    memory_model: Vec<Word>,
+    entry_points: Vec<Word>,
+    execution_modes: Vec<Word>,
+    debugs: Vec<Word>,
+    annotations: Vec<Word>,
+    declarations: Vec<Word>,
+    function_declarations: Vec<Word>,
+    function_definitions: Vec<Word>,
+}
+
+struct Instruction {
+    op: spirv::Op,
+    wc: u32,
+    type_id: Option<Word>,
+    result_id: Option<Word>,
+    operands: Vec<Word>,
+}
+
+const BITS_PER_BYTE: crate::Bytes = 8;
+
+#[derive(Clone, Debug, Error)]
+pub enum Error {
+    #[error("The requested entry point couldn't be found")]
+    EntryPointNotFound,
+    #[error("target SPIRV-{0}.{1} is not supported")]
+    UnsupportedVersion(u8, u8),
+    #[error("using {0} requires at least one of the capabilities {1:?}, but none are available")]
+    MissingCapabilities(&'static str, Vec<Capability>),
+    #[error("unimplemented {0}")]
+    FeatureNotImplemented(&'static str),
+    #[error("module is not validated properly: {0}")]
+    Validation(&'static str),
+}
+
+#[derive(Default)]
+struct IdGenerator(Word);
+
+impl IdGenerator {
+    fn next(&mut self) -> Word {
+        self.0 += 1;
+        self.0
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct DebugInfo<'a> {
+    pub source_code: &'a str,
+    pub file_name: &'a std::path::Path,
+}
+
+/// A SPIR-V block to which we are still adding instructions.
+///
+/// A `Block` represents a SPIR-V block that does not yet have a termination
+/// instruction like `OpBranch` or `OpReturn`.
+///
+/// The `OpLabel` that starts the block is implicit. It will be emitted based on
+/// `label_id` when we write the block to a `LogicalLayout`.
+///
+/// To terminate a `Block`, pass the block and the termination instruction to
+/// `Function::consume`. This takes ownership of the `Block` and transforms it
+/// into a `TerminatedBlock`.
+struct Block {
+    label_id: Word,
+    body: Vec<Instruction>,
+}
+
+/// A SPIR-V block that ends with a termination instruction.
+struct TerminatedBlock {
+    label_id: Word,
+    body: Vec<Instruction>,
+}
+
+impl Block {
+    const fn new(label_id: Word) -> Self {
+        Block {
+            label_id,
+            body: Vec::new(),
+        }
+    }
+}
+
+struct LocalVariable {
+    id: Word,
+    instruction: Instruction,
+}
+
+struct ResultMember {
+    id: Word,
+    type_id: Word,
+    built_in: Option<crate::BuiltIn>,
+}
+
+struct EntryPointContext {
+    argument_ids: Vec<Word>,
+    results: Vec<ResultMember>,
+}
+
+#[derive(Default)]
+struct Function {
+    signature: Option<Instruction>,
+    parameters: Vec<FunctionArgument>,
+    variables: crate::FastHashMap<Handle<crate::LocalVariable>, LocalVariable>,
+    blocks: Vec<TerminatedBlock>,
+    entry_point_context: Option<EntryPointContext>,
+}
+
+impl Function {
+    fn consume(&mut self, mut block: Block, termination: Instruction) {
+        block.body.push(termination);
+        self.blocks.push(TerminatedBlock {
+            label_id: block.label_id,
+            body: block.body,
+        })
+    }
+
+    fn parameter_id(&self, index: u32) -> Word {
+        match self.entry_point_context {
+            Some(ref context) => context.argument_ids[index as usize],
+            None => self.parameters[index as usize]
+                .instruction
+                .result_id
+                .unwrap(),
+        }
+    }
+}
+
+/// Characteristics of a SPIR-V `OpTypeImage` type.
+///
+/// SPIR-V requires non-composite types to be unique, including images. Since we
+/// use `LocalType` for this deduplication, it's essential that `LocalImageType`
+/// be equal whenever the corresponding `OpTypeImage`s would be. To reduce the
+/// likelihood of mistakes, we use fields that correspond exactly to the
+/// operands of an `OpTypeImage` instruction, using the actual SPIR-V types
+/// where practical.
+#[derive(Debug, PartialEq, Hash, Eq, Copy, Clone)]
+struct LocalImageType {
+    sampled_type: crate::ScalarKind,
+    dim: spirv::Dim,
+    flags: ImageTypeFlags,
+    image_format: spirv::ImageFormat,
+}
+
+bitflags::bitflags! {
+    /// Flags corresponding to the boolean(-ish) parameters to OpTypeImage.
+    #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+    pub struct ImageTypeFlags: u8 {
+        const DEPTH = 0x1;
+        const ARRAYED = 0x2;
+        const MULTISAMPLED = 0x4;
+        const SAMPLED = 0x8;
+    }
+}
+
+impl LocalImageType {
+    /// Construct a `LocalImageType` from the fields of a `TypeInner::Image`.
+    fn from_inner(dim: crate::ImageDimension, arrayed: bool, class: crate::ImageClass) -> Self {
+        let make_flags = |multi: bool, other: ImageTypeFlags| -> ImageTypeFlags {
+            let mut flags = other;
+            flags.set(ImageTypeFlags::ARRAYED, arrayed);
+            flags.set(ImageTypeFlags::MULTISAMPLED, multi);
+            flags
+        };
+
+        let dim = spirv::Dim::from(dim);
+
+        match class {
+            crate::ImageClass::Sampled { kind, multi } => LocalImageType {
+                sampled_type: kind,
+                dim,
+                flags: make_flags(multi, ImageTypeFlags::SAMPLED),
+                image_format: spirv::ImageFormat::Unknown,
+            },
+            crate::ImageClass::Depth { multi } => LocalImageType {
+                sampled_type: crate::ScalarKind::Float,
+                dim,
+                flags: make_flags(multi, ImageTypeFlags::DEPTH | ImageTypeFlags::SAMPLED),
+                image_format: spirv::ImageFormat::Unknown,
+            },
+            crate::ImageClass::Storage { format, access: _ } => LocalImageType {
+                sampled_type: crate::ScalarKind::from(format),
+                dim,
+                flags: make_flags(false, ImageTypeFlags::empty()),
+                image_format: format.into(),
+            },
+        }
+    }
+}
+
+/// A SPIR-V type constructed during code generation.
+///
+/// This is the variant of [`LookupType`] used to represent types that might not
+/// be available in the arena. Variants are present here for one of two reasons:
+///
+/// -   They represent types synthesized during code generation, as explained
+///     in the documentation for [`LookupType`].
+///
+/// -   They represent types for which SPIR-V forbids duplicate `OpType...`
+///     instructions, requiring deduplication.
+///
+/// This is not a complete copy of [`TypeInner`]: for example, SPIR-V generation
+/// never synthesizes new struct types, so `LocalType` has nothing for that.
+///
+/// Each `LocalType` variant should be handled identically to its analogous
+/// `TypeInner` variant. You can use the [`make_local`] function to help with
+/// this, by converting everything possible to a `LocalType` before inspecting
+/// it.
+///
+/// ## `Localtype` equality and SPIR-V `OpType` uniqueness
+///
+/// The definition of `Eq` on `LocalType` is carefully chosen to help us follow
+/// certain SPIR-V rules. SPIR-V §2.8 requires some classes of `OpType...`
+/// instructions to be unique; for example, you can't have two `OpTypeInt 32 1`
+/// instructions in the same module. All 32-bit signed integers must use the
+/// same type id.
+///
+/// All SPIR-V types that must be unique can be represented as a `LocalType`,
+/// and two `LocalType`s are always `Eq` if SPIR-V would require them to use the
+/// same `OpType...` instruction. This lets us avoid duplicates by recording the
+/// ids of the type instructions we've already generated in a hash table,
+/// [`Writer::lookup_type`], keyed by `LocalType`.
+///
+/// As another example, [`LocalImageType`], stored in the `LocalType::Image`
+/// variant, is designed to help us deduplicate `OpTypeImage` instructions. See
+/// its documentation for details.
+///
+/// `LocalType` also includes variants like `Pointer` that do not need to be
+/// unique - but it is harmless to avoid the duplication.
+///
+/// As it always must, the `Hash` implementation respects the `Eq` relation.
+///
+/// [`TypeInner`]: crate::TypeInner
+#[derive(Debug, PartialEq, Hash, Eq, Copy, Clone)]
+enum LocalType {
+    /// A scalar, vector, or pointer to one of those.
+    Value {
+        /// If `None`, this represents a scalar type. If `Some`, this represents
+        /// a vector type of the given size.
+        vector_size: Option<crate::VectorSize>,
+        scalar: crate::Scalar,
+        pointer_space: Option<spirv::StorageClass>,
+    },
+    /// A matrix of floating-point values.
+    Matrix {
+        columns: crate::VectorSize,
+        rows: crate::VectorSize,
+        width: crate::Bytes,
+    },
+    Pointer {
+        base: Handle<crate::Type>,
+        class: spirv::StorageClass,
+    },
+    Image(LocalImageType),
+    SampledImage {
+        image_type_id: Word,
+    },
+    Sampler,
+    /// Equivalent to a [`LocalType::Pointer`] whose `base` is a Naga IR [`BindingArray`]. SPIR-V
+    /// permits duplicated `OpTypePointer` ids, so it's fine to have two different [`LocalType`]
+    /// representations for pointer types.
+    ///
+    /// [`BindingArray`]: crate::TypeInner::BindingArray
+    PointerToBindingArray {
+        base: Handle<crate::Type>,
+        size: u32,
+        space: crate::AddressSpace,
+    },
+    BindingArray {
+        base: Handle<crate::Type>,
+        size: u32,
+    },
+    AccelerationStructure,
+    RayQuery,
+}
+
+/// A type encountered during SPIR-V generation.
+///
+/// In the process of writing SPIR-V, we need to synthesize various types for
+/// intermediate results and such: pointer types, vector/matrix component types,
+/// or even booleans, which usually appear in SPIR-V code even when they're not
+/// used by the module source.
+///
+/// However, we can't use `crate::Type` or `crate::TypeInner` for these, as the
+/// type arena may not contain what we need (it only contains types used
+/// directly by other parts of the IR), and the IR module is immutable, so we
+/// can't add anything to it.
+///
+/// So for local use in the SPIR-V writer, we use this type, which holds either
+/// a handle into the arena, or a [`LocalType`] containing something synthesized
+/// locally.
+///
+/// This is very similar to the [`proc::TypeResolution`] enum, with `LocalType`
+/// playing the role of `TypeInner`. However, `LocalType` also has other
+/// properties needed for SPIR-V generation; see the description of
+/// [`LocalType`] for details.
+///
+/// [`proc::TypeResolution`]: crate::proc::TypeResolution
+#[derive(Debug, PartialEq, Hash, Eq, Copy, Clone)]
+enum LookupType {
+    Handle(Handle<crate::Type>),
+    Local(LocalType),
+}
+
+impl From<LocalType> for LookupType {
+    fn from(local: LocalType) -> Self {
+        Self::Local(local)
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Hash, Eq)]
+struct LookupFunctionType {
+    parameter_type_ids: Vec<Word>,
+    return_type_id: Word,
+}
+
+fn make_local(inner: &crate::TypeInner) -> Option<LocalType> {
+    Some(match *inner {
+        crate::TypeInner::Scalar(scalar) | crate::TypeInner::Atomic(scalar) => LocalType::Value {
+            vector_size: None,
+            scalar,
+            pointer_space: None,
+        },
+        crate::TypeInner::Vector { size, scalar } => LocalType::Value {
+            vector_size: Some(size),
+            scalar,
+            pointer_space: None,
+        },
+        crate::TypeInner::Matrix {
+            columns,
+            rows,
+            scalar,
+        } => LocalType::Matrix {
+            columns,
+            rows,
+            width: scalar.width,
+        },
+        crate::TypeInner::Pointer { base, space } => LocalType::Pointer {
+            base,
+            class: helpers::map_storage_class(space),
+        },
+        crate::TypeInner::ValuePointer {
+            size,
+            scalar,
+            space,
+        } => LocalType::Value {
+            vector_size: size,
+            scalar,
+            pointer_space: Some(helpers::map_storage_class(space)),
+        },
+        crate::TypeInner::Image {
+            dim,
+            arrayed,
+            class,
+        } => LocalType::Image(LocalImageType::from_inner(dim, arrayed, class)),
+        crate::TypeInner::Sampler { comparison: _ } => LocalType::Sampler,
+        crate::TypeInner::AccelerationStructure => LocalType::AccelerationStructure,
+        crate::TypeInner::RayQuery => LocalType::RayQuery,
+        crate::TypeInner::Array { .. }
+        | crate::TypeInner::Struct { .. }
+        | crate::TypeInner::BindingArray { .. } => return None,
+    })
+}
+
+#[derive(Debug)]
+enum Dimension {
+    Scalar,
+    Vector,
+    Matrix,
+}
+
+/// A map from evaluated [`Expression`](crate::Expression)s to their SPIR-V ids.
+///
+/// When we emit code to evaluate a given `Expression`, we record the
+/// SPIR-V id of its value here, under its `Handle<Expression>` index.
+///
+/// A `CachedExpressions` value can be indexed by a `Handle<Expression>` value.
+///
+/// [emit]: index.html#expression-evaluation-time-and-scope
+#[derive(Default)]
+struct CachedExpressions {
+    ids: Vec<Word>,
+}
+impl CachedExpressions {
+    fn reset(&mut self, length: usize) {
+        self.ids.clear();
+        self.ids.resize(length, 0);
+    }
+}
+impl ops::Index<Handle<crate::Expression>> for CachedExpressions {
+    type Output = Word;
+    fn index(&self, h: Handle<crate::Expression>) -> &Word {
+        let id = &self.ids[h.index()];
+        if *id == 0 {
+            unreachable!("Expression {:?} is not cached!", h);
+        }
+        id
+    }
+}
+impl ops::IndexMut<Handle<crate::Expression>> for CachedExpressions {
+    fn index_mut(&mut self, h: Handle<crate::Expression>) -> &mut Word {
+        let id = &mut self.ids[h.index()];
+        if *id != 0 {
+            unreachable!("Expression {:?} is already cached!", h);
+        }
+        id
+    }
+}
+impl recyclable::Recyclable for CachedExpressions {
+    fn recycle(self) -> Self {
+        CachedExpressions {
+            ids: self.ids.recycle(),
+        }
+    }
+}
+
+#[derive(Eq, Hash, PartialEq)]
+enum CachedConstant {
+    Literal(crate::Literal),
+    Composite {
+        ty: LookupType,
+        constituent_ids: Vec<Word>,
+    },
+    ZeroValue(Word),
+}
+
+#[derive(Clone)]
+struct GlobalVariable {
+    /// ID of the OpVariable that declares the global.
+    ///
+    /// If you need the variable's value, use [`access_id`] instead of this
+    /// field. If we wrapped the Naga IR `GlobalVariable`'s type in a struct to
+    /// comply with Vulkan's requirements, then this points to the `OpVariable`
+    /// with the synthesized struct type, whereas `access_id` points to the
+    /// field of said struct that holds the variable's actual value.
+    ///
+    /// This is used to compute the `access_id` pointer in function prologues,
+    /// and used for `ArrayLength` expressions, which do need the struct.
+    ///
+    /// [`access_id`]: GlobalVariable::access_id
+    var_id: Word,
+
+    /// For `AddressSpace::Handle` variables, this ID is recorded in the function
+    /// prelude block (and reset before every function) as `OpLoad` of the variable.
+    /// It is then used for all the global ops, such as `OpImageSample`.
+    handle_id: Word,
+
+    /// Actual ID used to access this variable.
+    /// For wrapped buffer variables, this ID is `OpAccessChain` into the
+    /// wrapper. Otherwise, the same as `var_id`.
+    ///
+    /// Vulkan requires that globals in the `StorageBuffer` and `Uniform` storage
+    /// classes must be structs with the `Block` decoration, but WGSL and Naga IR
+    /// make no such requirement. So for such variables, we generate a wrapper struct
+    /// type with a single element of the type given by Naga, generate an
+    /// `OpAccessChain` for that member in the function prelude, and use that pointer
+    /// to refer to the global in the function body. This is the id of that access,
+    /// updated for each function in `write_function`.
+    access_id: Word,
+}
+
+impl GlobalVariable {
+    const fn dummy() -> Self {
+        Self {
+            var_id: 0,
+            handle_id: 0,
+            access_id: 0,
+        }
+    }
+
+    const fn new(id: Word) -> Self {
+        Self {
+            var_id: id,
+            handle_id: 0,
+            access_id: 0,
+        }
+    }
+
+    /// Prepare `self` for use within a single function.
+    fn reset_for_function(&mut self) {
+        self.handle_id = 0;
+        self.access_id = 0;
+    }
+}
+
+struct FunctionArgument {
+    /// Actual instruction of the argument.
+    instruction: Instruction,
+    handle_id: Word,
+}
+
+/// General information needed to emit SPIR-V for Naga statements.
+struct BlockContext<'w> {
+    /// The writer handling the module to which this code belongs.
+    writer: &'w mut Writer,
+
+    /// The [`Module`](crate::Module) for which we're generating code.
+    ir_module: &'w crate::Module,
+
+    /// The [`Function`](crate::Function) for which we're generating code.
+    ir_function: &'w crate::Function,
+
+    /// Information module validation produced about
+    /// [`ir_function`](BlockContext::ir_function).
+    fun_info: &'w crate::valid::FunctionInfo,
+
+    /// The [`spv::Function`](Function) to which we are contributing SPIR-V instructions.
+    function: &'w mut Function,
+
+    /// SPIR-V ids for expressions we've evaluated.
+    cached: CachedExpressions,
+
+    /// The `Writer`'s temporary vector, for convenience.
+    temp_list: Vec<Word>,
+
+    /// Tracks the constness of `Expression`s residing in `self.ir_function.expressions`
+    expression_constness: crate::proc::ExpressionConstnessTracker,
+}
+
+impl BlockContext<'_> {
+    fn gen_id(&mut self) -> Word {
+        self.writer.id_gen.next()
+    }
+
+    fn get_type_id(&mut self, lookup_type: LookupType) -> Word {
+        self.writer.get_type_id(lookup_type)
+    }
+
+    fn get_expression_type_id(&mut self, tr: &TypeResolution) -> Word {
+        self.writer.get_expression_type_id(tr)
+    }
+
+    fn get_index_constant(&mut self, index: Word) -> Word {
+        self.writer.get_constant_scalar(crate::Literal::U32(index))
+    }
+
+    fn get_scope_constant(&mut self, scope: Word) -> Word {
+        self.writer
+            .get_constant_scalar(crate::Literal::I32(scope as _))
+    }
+}
+
+#[derive(Clone, Copy, Default)]
+struct LoopContext {
+    continuing_id: Option<Word>,
+    break_id: Option<Word>,
+}
+
+pub struct Writer {
+    physical_layout: PhysicalLayout,
+    logical_layout: LogicalLayout,
+    id_gen: IdGenerator,
+
+    /// The set of capabilities modules are permitted to use.
+    ///
+    /// This is initialized from `Options::capabilities`.
+    capabilities_available: Option<crate::FastHashSet<Capability>>,
+
+    /// The set of capabilities used by this module.
+    ///
+    /// If `capabilities_available` is `Some`, then this is always a subset of
+    /// that.
+    capabilities_used: crate::FastIndexSet<Capability>,
+
+    /// The set of spirv extensions used.
+    extensions_used: crate::FastIndexSet<&'static str>,
+
+    debugs: Vec<Instruction>,
+    annotations: Vec<Instruction>,
+    flags: WriterFlags,
+    bounds_check_policies: BoundsCheckPolicies,
+    zero_initialize_workgroup_memory: ZeroInitializeWorkgroupMemoryMode,
+    void_type: Word,
+    //TODO: convert most of these into vectors, addressable by handle indices
+    lookup_type: crate::FastHashMap<LookupType, Word>,
+    lookup_function: crate::FastHashMap<Handle<crate::Function>, Word>,
+    lookup_function_type: crate::FastHashMap<LookupFunctionType, Word>,
+    /// Indexed by const-expression handle indexes
+    constant_ids: Vec<Word>,
+    cached_constants: crate::FastHashMap<CachedConstant, Word>,
+    global_variables: Vec<GlobalVariable>,
+    binding_map: BindingMap,
+
+    // Cached expressions are only meaningful within a BlockContext, but we
+    // retain the table here between functions to save heap allocations.
+    saved_cached: CachedExpressions,
+
+    gl450_ext_inst_id: Word,
+
+    // Just a temporary list of SPIR-V ids
+    temp_list: Vec<Word>,
+}
+
+bitflags::bitflags! {
+    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+    pub struct WriterFlags: u32 {
+        /// Include debug labels for everything.
+        const DEBUG = 0x1;
+        /// Flip Y coordinate of `BuiltIn::Position` output.
+        const ADJUST_COORDINATE_SPACE = 0x2;
+        /// Emit `OpName` for input/output locations.
+        /// Contrary to spec, some drivers treat it as semantic, not allowing
+        /// any conflicts.
+        const LABEL_VARYINGS = 0x4;
+        /// Emit `PointSize` output builtin to vertex shaders, which is
+        /// required for drawing with `PointList` topology.
+        const FORCE_POINT_SIZE = 0x8;
+        /// Clamp `BuiltIn::FragDepth` output between 0 and 1.
+        const CLAMP_FRAG_DEPTH = 0x10;
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
+pub struct BindingInfo {
+    /// If the binding is an unsized binding array, this overrides the size.
+    pub binding_array_size: Option<u32>,
+}
+
+// Using `BTreeMap` instead of `HashMap` so that we can hash itself.
+pub type BindingMap = std::collections::BTreeMap<crate::ResourceBinding, BindingInfo>;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ZeroInitializeWorkgroupMemoryMode {
+    /// Via `VK_KHR_zero_initialize_workgroup_memory` or Vulkan 1.3
+    Native,
+    /// Via assignments + barrier
+    Polyfill,
+    None,
+}
+
+#[derive(Debug, Clone)]
+pub struct Options<'a> {
+    /// (Major, Minor) target version of the SPIR-V.
+    pub lang_version: (u8, u8),
+
+    /// Configuration flags for the writer.
+    pub flags: WriterFlags,
+
+    /// Map of resources to information about the binding.
+    pub binding_map: BindingMap,
+
+    /// If given, the set of capabilities modules are allowed to use. Code that
+    /// requires capabilities beyond these is rejected with an error.
+    ///
+    /// If this is `None`, all capabilities are permitted.
+    pub capabilities: Option<crate::FastHashSet<Capability>>,
+
+    /// How should generate code handle array, vector, matrix, or image texel
+    /// indices that are out of range?
+    pub bounds_check_policies: BoundsCheckPolicies,
+
+    /// Dictates the way workgroup variables should be zero initialized
+    pub zero_initialize_workgroup_memory: ZeroInitializeWorkgroupMemoryMode,
+
+    pub debug_info: Option<DebugInfo<'a>>,
+}
+
+impl<'a> Default for Options<'a> {
+    fn default() -> Self {
+        let mut flags = WriterFlags::ADJUST_COORDINATE_SPACE
+            | WriterFlags::LABEL_VARYINGS
+            | WriterFlags::CLAMP_FRAG_DEPTH;
+        if cfg!(debug_assertions) {
+            flags |= WriterFlags::DEBUG;
+        }
+        Options {
+            lang_version: (1, 0),
+            flags,
+            binding_map: BindingMap::default(),
+            capabilities: None,
+            bounds_check_policies: crate::proc::BoundsCheckPolicies::default(),
+            zero_initialize_workgroup_memory: ZeroInitializeWorkgroupMemoryMode::Polyfill,
+            debug_info: None,
+        }
+    }
+}
+
+// A subset of options meant to be changed per pipeline.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
+pub struct PipelineOptions {
+    /// The stage of the entry point.
+    pub shader_stage: crate::ShaderStage,
+    /// The name of the entry point.
+    ///
+    /// If no entry point that matches is found while creating a [`Writer`], a error will be thrown.
+    pub entry_point: String,
+}
+
+pub fn write_vec(
+    module: &crate::Module,
+    info: &crate::valid::ModuleInfo,
+    options: &Options,
+    pipeline_options: Option<&PipelineOptions>,
+) -> Result<Vec<u32>, Error> {
+    let mut words: Vec<u32> = Vec::new();
+    let mut w = Writer::new(options)?;
+
+    w.write(
+        module,
+        info,
+        pipeline_options,
+        &options.debug_info,
+        &mut words,
+    )?;
+    Ok(words)
+}
diff --git a/third_party/rust/naga/src/back/spv/ray.rs b/third_party/rust/naga/src/back/spv/ray.rs
new file mode 100644
index 0000000000..bc2c4ce3c6
--- /dev/null
+++ b/third_party/rust/naga/src/back/spv/ray.rs
@@ -0,0 +1,261 @@
+/*!
+Generating SPIR-V for ray query operations.
+*/
+
+use super::{Block, BlockContext, Instruction, LocalType, LookupType};
+use crate::arena::Handle;
+
+impl<'w> BlockContext<'w> {
+    pub(super) fn write_ray_query_function(
+        &mut self,
+        query: Handle<crate::Expression>,
+        function: &crate::RayQueryFunction,
+        block: &mut Block,
+    ) {
+        let query_id = self.cached[query];
+        match *function {
+            crate::RayQueryFunction::Initialize {
+                acceleration_structure,
+                descriptor,
+            } => {
+                //Note: composite extract indices and types must match `generate_ray_desc_type`
+                let desc_id = self.cached[descriptor];
+                let acc_struct_id = self.get_handle_id(acceleration_structure);
+
+                let flag_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+                    vector_size: None,
+                    scalar: crate::Scalar::U32,
+                    pointer_space: None,
+                }));
+                let ray_flags_id = self.gen_id();
+                block.body.push(Instruction::composite_extract(
+                    flag_type_id,
+                    ray_flags_id,
+                    desc_id,
+                    &[0],
+                ));
+                let cull_mask_id = self.gen_id();
+                block.body.push(Instruction::composite_extract(
+                    flag_type_id,
+                    cull_mask_id,
+                    desc_id,
+                    &[1],
+                ));
+
+                let scalar_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+                    vector_size: None,
+                    scalar: crate::Scalar::F32,
+                    pointer_space: None,
+                }));
+                let tmin_id = self.gen_id();
+                block.body.push(Instruction::composite_extract(
+                    scalar_type_id,
+                    tmin_id,
+                    desc_id,
+                    &[2],
+                ));
+                let tmax_id = self.gen_id();
+                block.body.push(Instruction::composite_extract(
+                    scalar_type_id,
+                    tmax_id,
+                    desc_id,
+                    &[3],
+                ));
+
+                let vector_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+                    vector_size: Some(crate::VectorSize::Tri),
+                    scalar: crate::Scalar::F32,
+                    pointer_space: None,
+                }));
+                let ray_origin_id = self.gen_id();
+                block.body.push(Instruction::composite_extract(
+                    vector_type_id,
+                    ray_origin_id,
+                    desc_id,
+                    &[4],
+                ));
+                let ray_dir_id = self.gen_id();
+                block.body.push(Instruction::composite_extract(
+                    vector_type_id,
+                    ray_dir_id,
+                    desc_id,
+                    &[5],
+                ));
+
+                block.body.push(Instruction::ray_query_initialize(
+                    query_id,
+                    acc_struct_id,
+                    ray_flags_id,
+                    cull_mask_id,
+                    ray_origin_id,
+                    tmin_id,
+                    ray_dir_id,
+                    tmax_id,
+                ));
+            }
+            crate::RayQueryFunction::Proceed { result } => {
+                let id = self.gen_id();
+                self.cached[result] = id;
+                let result_type_id = self.get_expression_type_id(&self.fun_info[result].ty);
+
+                block
+                    .body
+                    .push(Instruction::ray_query_proceed(result_type_id, id, query_id));
+            }
+            crate::RayQueryFunction::Terminate => {}
+        }
+    }
+
+    pub(super) fn write_ray_query_get_intersection(
+        &mut self,
+        query: Handle<crate::Expression>,
+        block: &mut Block,
+    ) -> spirv::Word {
+        let query_id = self.cached[query];
+        let intersection_id = self.writer.get_constant_scalar(crate::Literal::U32(
+            spirv::RayQueryIntersection::RayQueryCommittedIntersectionKHR as _,
+        ));
+
+        let flag_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::U32,
+            pointer_space: None,
+        }));
+        let kind_id = self.gen_id();
+        block.body.push(Instruction::ray_query_get_intersection(
+            spirv::Op::RayQueryGetIntersectionTypeKHR,
+            flag_type_id,
+            kind_id,
+            query_id,
+            intersection_id,
+        ));
+        let instance_custom_index_id = self.gen_id();
+        block.body.push(Instruction::ray_query_get_intersection(
+            spirv::Op::RayQueryGetIntersectionInstanceCustomIndexKHR,
+            flag_type_id,
+            instance_custom_index_id,
+            query_id,
+            intersection_id,
+        ));
+        let instance_id = self.gen_id();
+        block.body.push(Instruction::ray_query_get_intersection(
+            spirv::Op::RayQueryGetIntersectionInstanceIdKHR,
+            flag_type_id,
+            instance_id,
+            query_id,
+            intersection_id,
+        ));
+        let sbt_record_offset_id = self.gen_id();
+        block.body.push(Instruction::ray_query_get_intersection(
+            spirv::Op::RayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR,
+            flag_type_id,
+            sbt_record_offset_id,
+            query_id,
+            intersection_id,
+        ));
+        let geometry_index_id = self.gen_id();
+        block.body.push(Instruction::ray_query_get_intersection(
+            spirv::Op::RayQueryGetIntersectionGeometryIndexKHR,
+            flag_type_id,
+            geometry_index_id,
+            query_id,
+            intersection_id,
+        ));
+        let primitive_index_id = self.gen_id();
+        block.body.push(Instruction::ray_query_get_intersection(
+            spirv::Op::RayQueryGetIntersectionPrimitiveIndexKHR,
+            flag_type_id,
+            primitive_index_id,
+            query_id,
+            intersection_id,
+        ));
+
+        let scalar_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::F32,
+            pointer_space: None,
+        }));
+        let t_id = self.gen_id();
+        block.body.push(Instruction::ray_query_get_intersection(
+            spirv::Op::RayQueryGetIntersectionTKHR,
+            scalar_type_id,
+            t_id,
+            query_id,
+            intersection_id,
+        ));
+
+        let barycentrics_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: Some(crate::VectorSize::Bi),
+            scalar: crate::Scalar::F32,
+            pointer_space: None,
+        }));
+        let barycentrics_id = self.gen_id();
+        block.body.push(Instruction::ray_query_get_intersection(
+            spirv::Op::RayQueryGetIntersectionBarycentricsKHR,
+            barycentrics_type_id,
+            barycentrics_id,
+            query_id,
+            intersection_id,
+        ));
+
+        let bool_type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::BOOL,
+            pointer_space: None,
+        }));
+        let front_face_id = self.gen_id();
+        block.body.push(Instruction::ray_query_get_intersection(
+            spirv::Op::RayQueryGetIntersectionFrontFaceKHR,
+            bool_type_id,
+            front_face_id,
+            query_id,
+            intersection_id,
+        ));
+
+        let transform_type_id = self.get_type_id(LookupType::Local(LocalType::Matrix {
+            columns: crate::VectorSize::Quad,
+            rows: crate::VectorSize::Tri,
+            width: 4,
+        }));
+        let object_to_world_id = self.gen_id();
+        block.body.push(Instruction::ray_query_get_intersection(
+            spirv::Op::RayQueryGetIntersectionObjectToWorldKHR,
+            transform_type_id,
+            object_to_world_id,
+            query_id,
+            intersection_id,
+        ));
+        let world_to_object_id = self.gen_id();
+        block.body.push(Instruction::ray_query_get_intersection(
+            spirv::Op::RayQueryGetIntersectionWorldToObjectKHR,
+            transform_type_id,
+            world_to_object_id,
+            query_id,
+            intersection_id,
+        ));
+
+        let id = self.gen_id();
+        let intersection_type_id = self.get_type_id(LookupType::Handle(
+            self.ir_module.special_types.ray_intersection.unwrap(),
+        ));
+        //Note: the arguments must match `generate_ray_intersection_type` layout
+        block.body.push(Instruction::composite_construct(
+            intersection_type_id,
+            id,
+            &[
+                kind_id,
+                t_id,
+                instance_custom_index_id,
+                instance_id,
+                sbt_record_offset_id,
+                geometry_index_id,
+                primitive_index_id,
+                barycentrics_id,
+                front_face_id,
+                object_to_world_id,
+                world_to_object_id,
+            ],
+        ));
+        id
+    }
+}
diff --git a/third_party/rust/naga/src/back/spv/recyclable.rs b/third_party/rust/naga/src/back/spv/recyclable.rs
new file mode 100644
index 0000000000..cd1466e3c7
--- /dev/null
+++ b/third_party/rust/naga/src/back/spv/recyclable.rs
@@ -0,0 +1,67 @@
+/*!
+Reusing collections' previous allocations.
+*/
+
+/// A value that can be reset to its initial state, retaining its current allocations.
+///
+/// Naga attempts to lower the cost of SPIR-V generation by allowing clients to
+/// reuse the same `Writer` for multiple Module translations. Reusing a `Writer`
+/// means that the `Vec`s, `HashMap`s, and other heap-allocated structures the
+/// `Writer` uses internally begin the translation with heap-allocated buffers
+/// ready to use.
+///
+/// But this approach introduces the risk of `Writer` state leaking from one
+/// module to the next. When a developer adds fields to `Writer` or its internal
+/// types, they must remember to reset their contents between modules.
+///
+/// One trick to ensure that every field has been accounted for is to use Rust's
+/// struct literal syntax to construct a new, reset value. If a developer adds a
+/// field, but neglects to update the reset code, the compiler will complain
+/// that a field is missing from the literal. This trait's `recycle` method
+/// takes `self` by value, and returns `Self` by value, encouraging the use of
+/// struct literal expressions in its implementation.
+pub trait Recyclable {
+    /// Clear `self`, retaining its current memory allocations.
+    ///
+    /// Shrink the buffer if it's currently much larger than was actually used.
+    /// This prevents a module with exceptionally large allocations from causing
+    /// the `Writer` to retain more memory than it needs indefinitely.
+    fn recycle(self) -> Self;
+}
+
+// Stock values for various collections.
+
+impl<T> Recyclable for Vec<T> {
+    fn recycle(mut self) -> Self {
+        self.clear();
+        self
+    }
+}
+
+impl<K, V, S: Clone> Recyclable for std::collections::HashMap<K, V, S> {
+    fn recycle(mut self) -> Self {
+        self.clear();
+        self
+    }
+}
+
+impl<K, S: Clone> Recyclable for std::collections::HashSet<K, S> {
+    fn recycle(mut self) -> Self {
+        self.clear();
+        self
+    }
+}
+
+impl<K, S: Clone> Recyclable for indexmap::IndexSet<K, S> {
+    fn recycle(mut self) -> Self {
+        self.clear();
+        self
+    }
+}
+
+impl<K: Ord, V> Recyclable for std::collections::BTreeMap<K, V> {
+    fn recycle(mut self) -> Self {
+        self.clear();
+        self
+    }
+}
diff --git a/third_party/rust/naga/src/back/spv/selection.rs b/third_party/rust/naga/src/back/spv/selection.rs
new file mode 100644
index 0000000000..788b1f10ab
--- /dev/null
+++ b/third_party/rust/naga/src/back/spv/selection.rs
@@ -0,0 +1,257 @@
+/*!
+Generate SPIR-V conditional structures.
+
+Builders for `if` structures with `and`s.
+
+The types in this module track the information needed to emit SPIR-V code
+for complex conditional structures, like those whose conditions involve
+short-circuiting 'and' and 'or' structures. These track labels and can emit
+`OpPhi` instructions to merge values produced along different paths.
+
+This currently only supports exactly the forms Naga uses, so it doesn't
+support `or` or `else`, and only supports zero or one merged values.
+
+Naga needs to emit code roughly like this:
+
+```ignore
+
+    value = DEFAULT;
+    if COND1 && COND2 {
+        value = THEN_VALUE;
+    }
+    // use value
+
+```
+
+Assuming `ctx` and `block` are a mutable references to a [`BlockContext`]
+and the current [`Block`], and `merge_type` is the SPIR-V type for the
+merged value `value`, we can build SPIR-V for the code above like so:
+
+```ignore
+
+    let cond = Selection::start(block, merge_type);
+        // ... compute `cond1` ...
+    cond.if_true(ctx, cond1, DEFAULT);
+        // ... compute `cond2` ...
+    cond.if_true(ctx, cond2, DEFAULT);
+        // ... compute THEN_VALUE
+    let merged_value = cond.finish(ctx, THEN_VALUE);
+
+```
+
+After this, `merged_value` is either `DEFAULT` or `THEN_VALUE`, depending on
+the path by which the merged block was reached.
+
+This takes care of writing all branch instructions, including an
+`OpSelectionMerge` annotation in the header block; starting new blocks and
+assigning them labels; and emitting the `OpPhi` that gathers together the
+right sources for the merged values, for every path through the selection
+construct.
+
+When there is no merged value to produce, you can pass `()` for `merge_type`
+and the merge values. In this case no `OpPhi` instructions are produced, and
+the `finish` method returns `()`.
+
+To enforce proper nesting, a `Selection` takes ownership of the `&mut Block`
+pointer for the duration of its lifetime. To obtain the block for generating
+code in the selection's body, call the `Selection::block` method.
+*/
+
+use super::{Block, BlockContext, Instruction};
+use spirv::Word;
+
+/// A private struct recording what we know about the selection construct so far.
+pub(super) struct Selection<'b, M: MergeTuple> {
+    /// The block pointer we're emitting code into.
+    block: &'b mut Block,
+
+    /// The label of the selection construct's merge block, or `None` if we
+    /// haven't yet written the `OpSelectionMerge` merge instruction.
+    merge_label: Option<Word>,
+
+    /// A set of `(VALUES, PARENT)` pairs, used to build `OpPhi` instructions in
+    /// the merge block. Each `PARENT` is the label of a predecessor block of
+    /// the merge block. The corresponding `VALUES` holds the ids of the values
+    /// that `PARENT` contributes to the merged values.
+    ///
+    /// We emit all branches to the merge block, so we know all its
+    /// predecessors. And we refuse to emit a branch unless we're given the
+    /// values the branching block contributes to the merge, so we always have
+    /// everything we need to emit the correct phis, by construction.
+    values: Vec<(M, Word)>,
+
+    /// The types of the values in each element of `values`.
+    merge_types: M,
+}
+
+impl<'b, M: MergeTuple> Selection<'b, M> {
+    /// Start a new selection construct.
+    ///
+    /// The `block` argument indicates the selection's header block.
+    ///
+    /// The `merge_types` argument should be a `Word` or tuple of `Word`s, each
+    /// value being the SPIR-V result type id of an `OpPhi` instruction that
+    /// will be written to the selection's merge block when this selection's
+    /// [`finish`] method is called. This argument may also be `()`, for
+    /// selections that produce no values.
+    ///
+    /// (This function writes no code to `block` itself; it simply constructs a
+    /// fresh `Selection`.)
+    ///
+    /// [`finish`]: Selection::finish
+    pub(super) fn start(block: &'b mut Block, merge_types: M) -> Self {
+        Selection {
+            block,
+            merge_label: None,
+            values: vec![],
+            merge_types,
+        }
+    }
+
+    pub(super) fn block(&mut self) -> &mut Block {
+        self.block
+    }
+
+    /// Branch to a successor block if `cond` is true, otherwise merge.
+    ///
+    /// If `cond` is false, branch to the merge block, using `values` as the
+    /// merged values. Otherwise, proceed to a new block.
+    ///
+    /// The `values` argument must be the same shape as the `merge_types`
+    /// argument passed to `Selection::start`.
+    pub(super) fn if_true(&mut self, ctx: &mut BlockContext, cond: Word, values: M) {
+        self.values.push((values, self.block.label_id));
+
+        let merge_label = self.make_merge_label(ctx);
+        let next_label = ctx.gen_id();
+        ctx.function.consume(
+            std::mem::replace(self.block, Block::new(next_label)),
+            Instruction::branch_conditional(cond, next_label, merge_label),
+        );
+    }
+
+    /// Emit an unconditional branch to the merge block, and compute merged
+    /// values.
+    ///
+    /// Use `final_values` as the merged values contributed by the current
+    /// block, and transition to the merge block, emitting `OpPhi` instructions
+    /// to produce the merged values. This must be the same shape as the
+    /// `merge_types` argument passed to [`Selection::start`].
+    ///
+    /// Return the SPIR-V ids of the merged values. This value has the same
+    /// shape as the `merge_types` argument passed to `Selection::start`.
+    pub(super) fn finish(self, ctx: &mut BlockContext, final_values: M) -> M {
+        match self {
+            Selection {
+                merge_label: None, ..
+            } => {
+                // We didn't actually emit any branches, so `self.values` must
+                // be empty, and `final_values` are the only sources we have for
+                // the merged values. Easy peasy.
+                final_values
+            }
+
+            Selection {
+                block,
+                merge_label: Some(merge_label),
+                mut values,
+                merge_types,
+            } => {
+                // Emit the final branch and transition to the merge block.
+                values.push((final_values, block.label_id));
+                ctx.function.consume(
+                    std::mem::replace(block, Block::new(merge_label)),
+                    Instruction::branch(merge_label),
+                );
+
+                // Now that we're in the merge block, build the phi instructions.
+                merge_types.write_phis(ctx, block, &values)
+            }
+        }
+    }
+
+    /// Return the id of the merge block, writing a merge instruction if needed.
+    fn make_merge_label(&mut self, ctx: &mut BlockContext) -> Word {
+        match self.merge_label {
+            None => {
+                let merge_label = ctx.gen_id();
+                self.block.body.push(Instruction::selection_merge(
+                    merge_label,
+                    spirv::SelectionControl::NONE,
+                ));
+                self.merge_label = Some(merge_label);
+                merge_label
+            }
+            Some(merge_label) => merge_label,
+        }
+    }
+}
+
+/// A trait to help `Selection` manage any number of merged values.
+///
+/// Some selection constructs, like a `ReadZeroSkipWrite` bounds check on a
+/// [`Load`] expression, produce a single merged value. Others produce no merged
+/// value, like a bounds check on a [`Store`] statement.
+///
+/// To let `Selection` work nicely with both cases, we let the merge type
+/// argument passed to [`Selection::start`] be any type that implements this
+/// `MergeTuple` trait. `MergeTuple` is then implemented for `()`, `Word`,
+/// `(Word, Word)`, and so on.
+///
+/// A `MergeTuple` type can represent either a bunch of SPIR-V types or values;
+/// the `merge_types` argument to `Selection::start` are type ids, whereas the
+/// `values` arguments to the [`if_true`] and [`finish`] methods are value ids.
+/// The set of merged value returned by `finish` is a tuple of value ids.
+///
+/// In fact, since Naga only uses zero- and single-valued selection constructs
+/// at present, we only implement `MergeTuple` for `()` and `Word`. But if you
+/// add more cases, feel free to add more implementations. Once const generics
+/// are available, we could have a single implementation of `MergeTuple` for all
+/// lengths of arrays, and be done with it.
+///
+/// [`Load`]: crate::Expression::Load
+/// [`Store`]: crate::Statement::Store
+/// [`if_true`]: Selection::if_true
+/// [`finish`]: Selection::finish
+pub(super) trait MergeTuple: Sized {
+    /// Write OpPhi instructions for the given set of predecessors.
+    ///
+    /// The `predecessors` vector should be a vector of `(LABEL, VALUES)` pairs,
+    /// where each `VALUES` holds the values contributed by the branch from
+    /// `LABEL`, which should be one of the current block's predecessors.
+    fn write_phis(
+        self,
+        ctx: &mut BlockContext,
+        block: &mut Block,
+        predecessors: &[(Self, Word)],
+    ) -> Self;
+}
+
+/// Selections that produce a single merged value.
+///
+/// For example, `ImageLoad` with `BoundsCheckPolicy::ReadZeroSkipWrite` either
+/// returns a texel value or zeros.
+impl MergeTuple for Word {
+    fn write_phis(
+        self,
+        ctx: &mut BlockContext,
+        block: &mut Block,
+        predecessors: &[(Word, Word)],
+    ) -> Word {
+        let merged_value = ctx.gen_id();
+        block
+            .body
+            .push(Instruction::phi(self, merged_value, predecessors));
+        merged_value
+    }
+}
+
+/// Selections that produce no merged values.
+///
+/// For example, `ImageStore` under `BoundsCheckPolicy::ReadZeroSkipWrite`
+/// either does the store or skips it, but in neither case does it produce a
+/// value.
+impl MergeTuple for () {
+    /// No phis need to be generated.
+    fn write_phis(self, _: &mut BlockContext, _: &mut Block, _: &[((), Word)]) {}
+}
diff --git a/third_party/rust/naga/src/back/spv/writer.rs b/third_party/rust/naga/src/back/spv/writer.rs
new file mode 100644
index 0000000000..4db86c93a7
--- /dev/null
+++ b/third_party/rust/naga/src/back/spv/writer.rs
@@ -0,0 +1,2063 @@
+use super::{
+    block::DebugInfoInner,
+    helpers::{contains_builtin, global_needs_wrapper, map_storage_class},
+    make_local, Block, BlockContext, CachedConstant, CachedExpressions, DebugInfo,
+    EntryPointContext, Error, Function, FunctionArgument, GlobalVariable, IdGenerator, Instruction,
+    LocalType, LocalVariable, LogicalLayout, LookupFunctionType, LookupType, LoopContext, Options,
+    PhysicalLayout, PipelineOptions, ResultMember, Writer, WriterFlags, BITS_PER_BYTE,
+};
+use crate::{
+    arena::{Handle, UniqueArena},
+    back::spv::BindingInfo,
+    proc::{Alignment, TypeResolution},
+    valid::{FunctionInfo, ModuleInfo},
+};
+use spirv::Word;
+use std::collections::hash_map::Entry;
+
+struct FunctionInterface<'a> {
+    varying_ids: &'a mut Vec<Word>,
+    stage: crate::ShaderStage,
+}
+
+impl Function {
+    fn to_words(&self, sink: &mut impl Extend<Word>) {
+        self.signature.as_ref().unwrap().to_words(sink);
+        for argument in self.parameters.iter() {
+            argument.instruction.to_words(sink);
+        }
+        for (index, block) in self.blocks.iter().enumerate() {
+            Instruction::label(block.label_id).to_words(sink);
+            if index == 0 {
+                for local_var in self.variables.values() {
+                    local_var.instruction.to_words(sink);
+                }
+            }
+            for instruction in block.body.iter() {
+                instruction.to_words(sink);
+            }
+        }
+    }
+}
+
+impl Writer {
+    pub fn new(options: &Options) -> Result<Self, Error> {
+        let (major, minor) = options.lang_version;
+        if major != 1 {
+            return Err(Error::UnsupportedVersion(major, minor));
+        }
+        let raw_version = ((major as u32) << 16) | ((minor as u32) << 8);
+
+        let mut capabilities_used = crate::FastIndexSet::default();
+        capabilities_used.insert(spirv::Capability::Shader);
+
+        let mut id_gen = IdGenerator::default();
+        let gl450_ext_inst_id = id_gen.next();
+        let void_type = id_gen.next();
+
+        Ok(Writer {
+            physical_layout: PhysicalLayout::new(raw_version),
+            logical_layout: LogicalLayout::default(),
+            id_gen,
+            capabilities_available: options.capabilities.clone(),
+            capabilities_used,
+            extensions_used: crate::FastIndexSet::default(),
+            debugs: vec![],
+            annotations: vec![],
+            flags: options.flags,
+            bounds_check_policies: options.bounds_check_policies,
+            zero_initialize_workgroup_memory: options.zero_initialize_workgroup_memory,
+            void_type,
+            lookup_type: crate::FastHashMap::default(),
+            lookup_function: crate::FastHashMap::default(),
+            lookup_function_type: crate::FastHashMap::default(),
+            constant_ids: Vec::new(),
+            cached_constants: crate::FastHashMap::default(),
+            global_variables: Vec::new(),
+            binding_map: options.binding_map.clone(),
+            saved_cached: CachedExpressions::default(),
+            gl450_ext_inst_id,
+            temp_list: Vec::new(),
+        })
+    }
+
+    /// Reset `Writer` to its initial state, retaining any allocations.
+    ///
+    /// Why not just implement `Recyclable` for `Writer`? By design,
+    /// `Recyclable::recycle` requires ownership of the value, not just
+    /// `&mut`; see the trait documentation. But we need to use this method
+    /// from functions like `Writer::write`, which only have `&mut Writer`.
+    /// Workarounds include unsafe code (`std::ptr::read`, then `write`, ugh)
+    /// or something like a `Default` impl that returns an oddly-initialized
+    /// `Writer`, which is worse.
+    fn reset(&mut self) {
+        use super::recyclable::Recyclable;
+        use std::mem::take;
+
+        let mut id_gen = IdGenerator::default();
+        let gl450_ext_inst_id = id_gen.next();
+        let void_type = id_gen.next();
+
+        // Every field of the old writer that is not determined by the `Options`
+        // passed to `Writer::new` should be reset somehow.
+        let fresh = Writer {
+            // Copied from the old Writer:
+            flags: self.flags,
+            bounds_check_policies: self.bounds_check_policies,
+            zero_initialize_workgroup_memory: self.zero_initialize_workgroup_memory,
+            capabilities_available: take(&mut self.capabilities_available),
+            binding_map: take(&mut self.binding_map),
+
+            // Initialized afresh:
+            id_gen,
+            void_type,
+            gl450_ext_inst_id,
+
+            // Recycled:
+            capabilities_used: take(&mut self.capabilities_used).recycle(),
+            extensions_used: take(&mut self.extensions_used).recycle(),
+            physical_layout: self.physical_layout.clone().recycle(),
+            logical_layout: take(&mut self.logical_layout).recycle(),
+            debugs: take(&mut self.debugs).recycle(),
+            annotations: take(&mut self.annotations).recycle(),
+            lookup_type: take(&mut self.lookup_type).recycle(),
+            lookup_function: take(&mut self.lookup_function).recycle(),
+            lookup_function_type: take(&mut self.lookup_function_type).recycle(),
+            constant_ids: take(&mut self.constant_ids).recycle(),
+            cached_constants: take(&mut self.cached_constants).recycle(),
+            global_variables: take(&mut self.global_variables).recycle(),
+            saved_cached: take(&mut self.saved_cached).recycle(),
+            temp_list: take(&mut self.temp_list).recycle(),
+        };
+
+        *self = fresh;
+
+        self.capabilities_used.insert(spirv::Capability::Shader);
+    }
+
+    /// Indicate that the code requires any one of the listed capabilities.
+    ///
+    /// If nothing in `capabilities` appears in the available capabilities
+    /// specified in the [`Options`] from which this `Writer` was created,
+    /// return an error. The `what` string is used in the error message to
+    /// explain what provoked the requirement. (If no available capabilities were
+    /// given, assume everything is available.)
+    ///
+    /// The first acceptable capability will be added to this `Writer`'s
+    /// [`capabilities_used`] table, and an `OpCapability` emitted for it in the
+    /// result. For this reason, more specific capabilities should be listed
+    /// before more general.
+    ///
+    /// [`capabilities_used`]: Writer::capabilities_used
+    pub(super) fn require_any(
+        &mut self,
+        what: &'static str,
+        capabilities: &[spirv::Capability],
+    ) -> Result<(), Error> {
+        match *capabilities {
+            [] => Ok(()),
+            [first, ..] => {
+                // Find the first acceptable capability, or return an error if
+                // there is none.
+                let selected = match self.capabilities_available {
+                    None => first,
+                    Some(ref available) => {
+                        match capabilities.iter().find(|cap| available.contains(cap)) {
+                            Some(&cap) => cap,
+                            None => {
+                                return Err(Error::MissingCapabilities(what, capabilities.to_vec()))
+                            }
+                        }
+                    }
+                };
+                self.capabilities_used.insert(selected);
+                Ok(())
+            }
+        }
+    }
+
+    /// Indicate that the code uses the given extension.
+    pub(super) fn use_extension(&mut self, extension: &'static str) {
+        self.extensions_used.insert(extension);
+    }
+
+    pub(super) fn get_type_id(&mut self, lookup_ty: LookupType) -> Word {
+        match self.lookup_type.entry(lookup_ty) {
+            Entry::Occupied(e) => *e.get(),
+            Entry::Vacant(e) => {
+                let local = match lookup_ty {
+                    LookupType::Handle(_handle) => unreachable!("Handles are populated at start"),
+                    LookupType::Local(local) => local,
+                };
+
+                let id = self.id_gen.next();
+                e.insert(id);
+                self.write_type_declaration_local(id, local);
+                id
+            }
+        }
+    }
+
+    pub(super) fn get_expression_lookup_type(&mut self, tr: &TypeResolution) -> LookupType {
+        match *tr {
+            TypeResolution::Handle(ty_handle) => LookupType::Handle(ty_handle),
+            TypeResolution::Value(ref inner) => LookupType::Local(make_local(inner).unwrap()),
+        }
+    }
+
+    pub(super) fn get_expression_type_id(&mut self, tr: &TypeResolution) -> Word {
+        let lookup_ty = self.get_expression_lookup_type(tr);
+        self.get_type_id(lookup_ty)
+    }
+
+    pub(super) fn get_pointer_id(
+        &mut self,
+        arena: &UniqueArena<crate::Type>,
+        handle: Handle<crate::Type>,
+        class: spirv::StorageClass,
+    ) -> Result<Word, Error> {
+        let ty_id = self.get_type_id(LookupType::Handle(handle));
+        if let crate::TypeInner::Pointer { .. } = arena[handle].inner {
+            return Ok(ty_id);
+        }
+        let lookup_type = LookupType::Local(LocalType::Pointer {
+            base: handle,
+            class,
+        });
+        Ok(if let Some(&id) = self.lookup_type.get(&lookup_type) {
+            id
+        } else {
+            let id = self.id_gen.next();
+            let instruction = Instruction::type_pointer(id, class, ty_id);
+            instruction.to_words(&mut self.logical_layout.declarations);
+            self.lookup_type.insert(lookup_type, id);
+            id
+        })
+    }
+
+    pub(super) fn get_uint_type_id(&mut self) -> Word {
+        let local_type = LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::U32,
+            pointer_space: None,
+        };
+        self.get_type_id(local_type.into())
+    }
+
+    pub(super) fn get_float_type_id(&mut self) -> Word {
+        let local_type = LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::F32,
+            pointer_space: None,
+        };
+        self.get_type_id(local_type.into())
+    }
+
+    pub(super) fn get_uint3_type_id(&mut self) -> Word {
+        let local_type = LocalType::Value {
+            vector_size: Some(crate::VectorSize::Tri),
+            scalar: crate::Scalar::U32,
+            pointer_space: None,
+        };
+        self.get_type_id(local_type.into())
+    }
+
+    pub(super) fn get_float_pointer_type_id(&mut self, class: spirv::StorageClass) -> Word {
+        let lookup_type = LookupType::Local(LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::F32,
+            pointer_space: Some(class),
+        });
+        if let Some(&id) = self.lookup_type.get(&lookup_type) {
+            id
+        } else {
+            let id = self.id_gen.next();
+            let ty_id = self.get_float_type_id();
+            let instruction = Instruction::type_pointer(id, class, ty_id);
+            instruction.to_words(&mut self.logical_layout.declarations);
+            self.lookup_type.insert(lookup_type, id);
+            id
+        }
+    }
+
+    pub(super) fn get_uint3_pointer_type_id(&mut self, class: spirv::StorageClass) -> Word {
+        let lookup_type = LookupType::Local(LocalType::Value {
+            vector_size: Some(crate::VectorSize::Tri),
+            scalar: crate::Scalar::U32,
+            pointer_space: Some(class),
+        });
+        if let Some(&id) = self.lookup_type.get(&lookup_type) {
+            id
+        } else {
+            let id = self.id_gen.next();
+            let ty_id = self.get_uint3_type_id();
+            let instruction = Instruction::type_pointer(id, class, ty_id);
+            instruction.to_words(&mut self.logical_layout.declarations);
+            self.lookup_type.insert(lookup_type, id);
+            id
+        }
+    }
+
+    pub(super) fn get_bool_type_id(&mut self) -> Word {
+        let local_type = LocalType::Value {
+            vector_size: None,
+            scalar: crate::Scalar::BOOL,
+            pointer_space: None,
+        };
+        self.get_type_id(local_type.into())
+    }
+
+    pub(super) fn get_bool3_type_id(&mut self) -> Word {
+        let local_type = LocalType::Value {
+            vector_size: Some(crate::VectorSize::Tri),
+            scalar: crate::Scalar::BOOL,
+            pointer_space: None,
+        };
+        self.get_type_id(local_type.into())
+    }
+
+    pub(super) fn decorate(&mut self, id: Word, decoration: spirv::Decoration, operands: &[Word]) {
+        self.annotations
+            .push(Instruction::decorate(id, decoration, operands));
+    }
+
+    fn write_function(
+        &mut self,
+        ir_function: &crate::Function,
+        info: &FunctionInfo,
+        ir_module: &crate::Module,
+        mut interface: Option<FunctionInterface>,
+        debug_info: &Option<DebugInfoInner>,
+    ) -> Result<Word, Error> {
+        let mut function = Function::default();
+
+        let prelude_id = self.id_gen.next();
+        let mut prelude = Block::new(prelude_id);
+        let mut ep_context = EntryPointContext {
+            argument_ids: Vec::new(),
+            results: Vec::new(),
+        };
+
+        let mut local_invocation_id = None;
+
+        let mut parameter_type_ids = Vec::with_capacity(ir_function.arguments.len());
+        for argument in ir_function.arguments.iter() {
+            let class = spirv::StorageClass::Input;
+            let handle_ty = ir_module.types[argument.ty].inner.is_handle();
+            let argument_type_id = match handle_ty {
+                true => self.get_pointer_id(
+                    &ir_module.types,
+                    argument.ty,
+                    spirv::StorageClass::UniformConstant,
+                )?,
+                false => self.get_type_id(LookupType::Handle(argument.ty)),
+            };
+
+            if let Some(ref mut iface) = interface {
+                let id = if let Some(ref binding) = argument.binding {
+                    let name = argument.name.as_deref();
+
+                    let varying_id = self.write_varying(
+                        ir_module,
+                        iface.stage,
+                        class,
+                        name,
+                        argument.ty,
+                        binding,
+                    )?;
+                    iface.varying_ids.push(varying_id);
+                    let id = self.id_gen.next();
+                    prelude
+                        .body
+                        .push(Instruction::load(argument_type_id, id, varying_id, None));
+
+                    if binding == &crate::Binding::BuiltIn(crate::BuiltIn::LocalInvocationId) {
+                        local_invocation_id = Some(id);
+                    }
+
+                    id
+                } else if let crate::TypeInner::Struct { ref members, .. } =
+                    ir_module.types[argument.ty].inner
+                {
+                    let struct_id = self.id_gen.next();
+                    let mut constituent_ids = Vec::with_capacity(members.len());
+                    for member in members {
+                        let type_id = self.get_type_id(LookupType::Handle(member.ty));
+                        let name = member.name.as_deref();
+                        let binding = member.binding.as_ref().unwrap();
+                        let varying_id = self.write_varying(
+                            ir_module,
+                            iface.stage,
+                            class,
+                            name,
+                            member.ty,
+                            binding,
+                        )?;
+                        iface.varying_ids.push(varying_id);
+                        let id = self.id_gen.next();
+                        prelude
+                            .body
+                            .push(Instruction::load(type_id, id, varying_id, None));
+                        constituent_ids.push(id);
+
+                        if binding == &crate::Binding::BuiltIn(crate::BuiltIn::GlobalInvocationId) {
+                            local_invocation_id = Some(id);
+                        }
+                    }
+                    prelude.body.push(Instruction::composite_construct(
+                        argument_type_id,
+                        struct_id,
+                        &constituent_ids,
+                    ));
+                    struct_id
+                } else {
+                    unreachable!("Missing argument binding on an entry point");
+                };
+                ep_context.argument_ids.push(id);
+            } else {
+                let argument_id = self.id_gen.next();
+                let instruction = Instruction::function_parameter(argument_type_id, argument_id);
+                if self.flags.contains(WriterFlags::DEBUG) {
+                    if let Some(ref name) = argument.name {
+                        self.debugs.push(Instruction::name(argument_id, name));
+                    }
+                }
+                function.parameters.push(FunctionArgument {
+                    instruction,
+                    handle_id: if handle_ty {
+                        let id = self.id_gen.next();
+                        prelude.body.push(Instruction::load(
+                            self.get_type_id(LookupType::Handle(argument.ty)),
+                            id,
+                            argument_id,
+                            None,
+                        ));
+                        id
+                    } else {
+                        0
+                    },
+                });
+                parameter_type_ids.push(argument_type_id);
+            };
+        }
+
+        let return_type_id = match ir_function.result {
+            Some(ref result) => {
+                if let Some(ref mut iface) = interface {
+                    let mut has_point_size = false;
+                    let class = spirv::StorageClass::Output;
+                    if let Some(ref binding) = result.binding {
+                        has_point_size |=
+                            *binding == crate::Binding::BuiltIn(crate::BuiltIn::PointSize);
+                        let type_id = self.get_type_id(LookupType::Handle(result.ty));
+                        let varying_id = self.write_varying(
+                            ir_module,
+                            iface.stage,
+                            class,
+                            None,
+                            result.ty,
+                            binding,
+                        )?;
+                        iface.varying_ids.push(varying_id);
+                        ep_context.results.push(ResultMember {
+                            id: varying_id,
+                            type_id,
+                            built_in: binding.to_built_in(),
+                        });
+                    } else if let crate::TypeInner::Struct { ref members, .. } =
+                        ir_module.types[result.ty].inner
+                    {
+                        for member in members {
+                            let type_id = self.get_type_id(LookupType::Handle(member.ty));
+                            let name = member.name.as_deref();
+                            let binding = member.binding.as_ref().unwrap();
+                            has_point_size |=
+                                *binding == crate::Binding::BuiltIn(crate::BuiltIn::PointSize);
+                            let varying_id = self.write_varying(
+                                ir_module,
+                                iface.stage,
+                                class,
+                                name,
+                                member.ty,
+                                binding,
+                            )?;
+                            iface.varying_ids.push(varying_id);
+                            ep_context.results.push(ResultMember {
+                                id: varying_id,
+                                type_id,
+                                built_in: binding.to_built_in(),
+                            });
+                        }
+                    } else {
+                        unreachable!("Missing result binding on an entry point");
+                    }
+
+                    if self.flags.contains(WriterFlags::FORCE_POINT_SIZE)
+                        && iface.stage == crate::ShaderStage::Vertex
+                        && !has_point_size
+                    {
+                        // add point size artificially
+                        let varying_id = self.id_gen.next();
+                        let pointer_type_id = self.get_float_pointer_type_id(class);
+                        Instruction::variable(pointer_type_id, varying_id, class, None)
+                            .to_words(&mut self.logical_layout.declarations);
+                        self.decorate(
+                            varying_id,
+                            spirv::Decoration::BuiltIn,
+                            &[spirv::BuiltIn::PointSize as u32],
+                        );
+                        iface.varying_ids.push(varying_id);
+
+                        let default_value_id = self.get_constant_scalar(crate::Literal::F32(1.0));
+                        prelude
+                            .body
+                            .push(Instruction::store(varying_id, default_value_id, None));
+                    }
+                    self.void_type
+                } else {
+                    self.get_type_id(LookupType::Handle(result.ty))
+                }
+            }
+            None => self.void_type,
+        };
+
+        let lookup_function_type = LookupFunctionType {
+            parameter_type_ids,
+            return_type_id,
+        };
+
+        let function_id = self.id_gen.next();
+        if self.flags.contains(WriterFlags::DEBUG) {
+            if let Some(ref name) = ir_function.name {
+                self.debugs.push(Instruction::name(function_id, name));
+            }
+        }
+
+        let function_type = self.get_function_type(lookup_function_type);
+        function.signature = Some(Instruction::function(
+            return_type_id,
+            function_id,
+            spirv::FunctionControl::empty(),
+            function_type,
+        ));
+
+        if interface.is_some() {
+            function.entry_point_context = Some(ep_context);
+        }
+
+        // fill up the `GlobalVariable::access_id`
+        for gv in self.global_variables.iter_mut() {
+            gv.reset_for_function();
+        }
+        for (handle, var) in ir_module.global_variables.iter() {
+            if info[handle].is_empty() {
+                continue;
+            }
+
+            let mut gv = self.global_variables[handle.index()].clone();
+            if let Some(ref mut iface) = interface {
+                // Have to include global variables in the interface
+                if self.physical_layout.version >= 0x10400 {
+                    iface.varying_ids.push(gv.var_id);
+                }
+            }
+
+            // Handle globals are pre-emitted and should be loaded automatically.
+            //
+            // Any that are binding arrays we skip as we cannot load the array, we must load the result after indexing.
+            let is_binding_array = match ir_module.types[var.ty].inner {
+                crate::TypeInner::BindingArray { .. } => true,
+                _ => false,
+            };
+
+            if var.space == crate::AddressSpace::Handle && !is_binding_array {
+                let var_type_id = self.get_type_id(LookupType::Handle(var.ty));
+                let id = self.id_gen.next();
+                prelude
+                    .body
+                    .push(Instruction::load(var_type_id, id, gv.var_id, None));
+                gv.access_id = gv.var_id;
+                gv.handle_id = id;
+            } else if global_needs_wrapper(ir_module, var) {
+                let class = map_storage_class(var.space);
+                let pointer_type_id = self.get_pointer_id(&ir_module.types, var.ty, class)?;
+                let index_id = self.get_index_constant(0);
+
+                let id = self.id_gen.next();
+                prelude.body.push(Instruction::access_chain(
+                    pointer_type_id,
+                    id,
+                    gv.var_id,
+                    &[index_id],
+                ));
+                gv.access_id = id;
+            } else {
+                // by default, the variable ID is accessed as is
+                gv.access_id = gv.var_id;
+            };
+
+            // work around borrow checking in the presence of `self.xxx()` calls
+            self.global_variables[handle.index()] = gv;
+        }
+
+        // Create a `BlockContext` for generating SPIR-V for the function's
+        // body.
+        let mut context = BlockContext {
+            ir_module,
+            ir_function,
+            fun_info: info,
+            function: &mut function,
+            // Re-use the cached expression table from prior functions.
+            cached: std::mem::take(&mut self.saved_cached),
+
+            // Steal the Writer's temp list for a bit.
+            temp_list: std::mem::take(&mut self.temp_list),
+            writer: self,
+            expression_constness: crate::proc::ExpressionConstnessTracker::from_arena(
+                &ir_function.expressions,
+            ),
+        };
+
+        // fill up the pre-emitted and const expressions
+        context.cached.reset(ir_function.expressions.len());
+        for (handle, expr) in ir_function.expressions.iter() {
+            if (expr.needs_pre_emit() && !matches!(*expr, crate::Expression::LocalVariable(_)))
+                || context.expression_constness.is_const(handle)
+            {
+                context.cache_expression_value(handle, &mut prelude)?;
+            }
+        }
+
+        for (handle, variable) in ir_function.local_variables.iter() {
+            let id = context.gen_id();
+
+            if context.writer.flags.contains(WriterFlags::DEBUG) {
+                if let Some(ref name) = variable.name {
+                    context.writer.debugs.push(Instruction::name(id, name));
+                }
+            }
+
+            let init_word = variable.init.map(|constant| context.cached[constant]);
+            let pointer_type_id = context.writer.get_pointer_id(
+                &ir_module.types,
+                variable.ty,
+                spirv::StorageClass::Function,
+            )?;
+            let instruction = Instruction::variable(
+                pointer_type_id,
+                id,
+                spirv::StorageClass::Function,
+                init_word.or_else(|| match ir_module.types[variable.ty].inner {
+                    crate::TypeInner::RayQuery => None,
+                    _ => {
+                        let type_id = context.get_type_id(LookupType::Handle(variable.ty));
+                        Some(context.writer.write_constant_null(type_id))
+                    }
+                }),
+            );
+            context
+                .function
+                .variables
+                .insert(handle, LocalVariable { id, instruction });
+        }
+
+        // cache local variable expressions
+        for (handle, expr) in ir_function.expressions.iter() {
+            if matches!(*expr, crate::Expression::LocalVariable(_)) {
+                context.cache_expression_value(handle, &mut prelude)?;
+            }
+        }
+
+        let next_id = context.gen_id();
+
+        context
+            .function
+            .consume(prelude, Instruction::branch(next_id));
+
+        let workgroup_vars_init_exit_block_id =
+            match (context.writer.zero_initialize_workgroup_memory, interface) {
+                (
+                    super::ZeroInitializeWorkgroupMemoryMode::Polyfill,
+                    Some(
+                        ref mut interface @ FunctionInterface {
+                            stage: crate::ShaderStage::Compute,
+                            ..
+                        },
+                    ),
+                ) => context.writer.generate_workgroup_vars_init_block(
+                    next_id,
+                    ir_module,
+                    info,
+                    local_invocation_id,
+                    interface,
+                    context.function,
+                ),
+                _ => None,
+            };
+
+        let main_id = if let Some(exit_id) = workgroup_vars_init_exit_block_id {
+            exit_id
+        } else {
+            next_id
+        };
+
+        context.write_block(
+            main_id,
+            &ir_function.body,
+            super::block::BlockExit::Return,
+            LoopContext::default(),
+            debug_info.as_ref(),
+        )?;
+
+        // Consume the `BlockContext`, ending its borrows and letting the
+        // `Writer` steal back its cached expression table and temp_list.
+        let BlockContext {
+            cached, temp_list, ..
+        } = context;
+        self.saved_cached = cached;
+        self.temp_list = temp_list;
+
+        function.to_words(&mut self.logical_layout.function_definitions);
+        Instruction::function_end().to_words(&mut self.logical_layout.function_definitions);
+
+        Ok(function_id)
+    }
+
+    fn write_execution_mode(
+        &mut self,
+        function_id: Word,
+        mode: spirv::ExecutionMode,
+    ) -> Result<(), Error> {
+        //self.check(mode.required_capabilities())?;
+        Instruction::execution_mode(function_id, mode, &[])
+            .to_words(&mut self.logical_layout.execution_modes);
+        Ok(())
+    }
+
+    // TODO Move to instructions module
+    fn write_entry_point(
+        &mut self,
+        entry_point: &crate::EntryPoint,
+        info: &FunctionInfo,
+        ir_module: &crate::Module,
+        debug_info: &Option<DebugInfoInner>,
+    ) -> Result<Instruction, Error> {
+        let mut interface_ids = Vec::new();
+        let function_id = self.write_function(
+            &entry_point.function,
+            info,
+            ir_module,
+            Some(FunctionInterface {
+                varying_ids: &mut interface_ids,
+                stage: entry_point.stage,
+            }),
+            debug_info,
+        )?;
+
+        let exec_model = match entry_point.stage {
+            crate::ShaderStage::Vertex => spirv::ExecutionModel::Vertex,
+            crate::ShaderStage::Fragment => {
+                self.write_execution_mode(function_id, spirv::ExecutionMode::OriginUpperLeft)?;
+                if let Some(ref result) = entry_point.function.result {
+                    if contains_builtin(
+                        result.binding.as_ref(),
+                        result.ty,
+                        &ir_module.types,
+                        crate::BuiltIn::FragDepth,
+                    ) {
+                        self.write_execution_mode(
+                            function_id,
+                            spirv::ExecutionMode::DepthReplacing,
+                        )?;
+                    }
+                }
+                spirv::ExecutionModel::Fragment
+            }
+            crate::ShaderStage::Compute => {
+                let execution_mode = spirv::ExecutionMode::LocalSize;
+                //self.check(execution_mode.required_capabilities())?;
+                Instruction::execution_mode(
+                    function_id,
+                    execution_mode,
+                    &entry_point.workgroup_size,
+                )
+                .to_words(&mut self.logical_layout.execution_modes);
+                spirv::ExecutionModel::GLCompute
+            }
+        };
+        //self.check(exec_model.required_capabilities())?;
+
+        Ok(Instruction::entry_point(
+            exec_model,
+            function_id,
+            &entry_point.name,
+            interface_ids.as_slice(),
+        ))
+    }
+
+    fn make_scalar(&mut self, id: Word, scalar: crate::Scalar) -> Instruction {
+        use crate::ScalarKind as Sk;
+
+        let bits = (scalar.width * BITS_PER_BYTE) as u32;
+        match scalar.kind {
+            Sk::Sint | Sk::Uint => {
+                let signedness = if scalar.kind == Sk::Sint {
+                    super::instructions::Signedness::Signed
+                } else {
+                    super::instructions::Signedness::Unsigned
+                };
+                let cap = match bits {
+                    8 => Some(spirv::Capability::Int8),
+                    16 => Some(spirv::Capability::Int16),
+                    64 => Some(spirv::Capability::Int64),
+                    _ => None,
+                };
+                if let Some(cap) = cap {
+                    self.capabilities_used.insert(cap);
+                }
+                Instruction::type_int(id, bits, signedness)
+            }
+            Sk::Float => {
+                if bits == 64 {
+                    self.capabilities_used.insert(spirv::Capability::Float64);
+                }
+                Instruction::type_float(id, bits)
+            }
+            Sk::Bool => Instruction::type_bool(id),
+            Sk::AbstractInt | Sk::AbstractFloat => {
+                unreachable!("abstract types should never reach the backend");
+            }
+        }
+    }
+
+    fn request_type_capabilities(&mut self, inner: &crate::TypeInner) -> Result<(), Error> {
+        match *inner {
+            crate::TypeInner::Image {
+                dim,
+                arrayed,
+                class,
+            } => {
+                let sampled = match class {
+                    crate::ImageClass::Sampled { .. } => true,
+                    crate::ImageClass::Depth { .. } => true,
+                    crate::ImageClass::Storage { format, .. } => {
+                        self.request_image_format_capabilities(format.into())?;
+                        false
+                    }
+                };
+
+                match dim {
+                    crate::ImageDimension::D1 => {
+                        if sampled {
+                            self.require_any("sampled 1D images", &[spirv::Capability::Sampled1D])?;
+                        } else {
+                            self.require_any("1D storage images", &[spirv::Capability::Image1D])?;
+                        }
+                    }
+                    crate::ImageDimension::Cube if arrayed => {
+                        if sampled {
+                            self.require_any(
+                                "sampled cube array images",
+                                &[spirv::Capability::SampledCubeArray],
+                            )?;
+                        } else {
+                            self.require_any(
+                                "cube array storage images",
+                                &[spirv::Capability::ImageCubeArray],
+                            )?;
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            crate::TypeInner::AccelerationStructure => {
+                self.require_any("Acceleration Structure", &[spirv::Capability::RayQueryKHR])?;
+            }
+            crate::TypeInner::RayQuery => {
+                self.require_any("Ray Query", &[spirv::Capability::RayQueryKHR])?;
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn write_type_declaration_local(&mut self, id: Word, local_ty: LocalType) {
+        let instruction = match local_ty {
+            LocalType::Value {
+                vector_size: None,
+                scalar,
+                pointer_space: None,
+            } => self.make_scalar(id, scalar),
+            LocalType::Value {
+                vector_size: Some(size),
+                scalar,
+                pointer_space: None,
+            } => {
+                let scalar_id = self.get_type_id(LookupType::Local(LocalType::Value {
+                    vector_size: None,
+                    scalar,
+                    pointer_space: None,
+                }));
+                Instruction::type_vector(id, scalar_id, size)
+            }
+            LocalType::Matrix {
+                columns,
+                rows,
+                width,
+            } => {
+                let vector_id = self.get_type_id(LookupType::Local(LocalType::Value {
+                    vector_size: Some(rows),
+                    scalar: crate::Scalar::float(width),
+                    pointer_space: None,
+                }));
+                Instruction::type_matrix(id, vector_id, columns)
+            }
+            LocalType::Pointer { base, class } => {
+                let type_id = self.get_type_id(LookupType::Handle(base));
+                Instruction::type_pointer(id, class, type_id)
+            }
+            LocalType::Value {
+                vector_size,
+                scalar,
+                pointer_space: Some(class),
+            } => {
+                let type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+                    vector_size,
+                    scalar,
+                    pointer_space: None,
+                }));
+                Instruction::type_pointer(id, class, type_id)
+            }
+            LocalType::Image(image) => {
+                let local_type = LocalType::Value {
+                    vector_size: None,
+                    scalar: crate::Scalar {
+                        kind: image.sampled_type,
+                        width: 4,
+                    },
+                    pointer_space: None,
+                };
+                let type_id = self.get_type_id(LookupType::Local(local_type));
+                Instruction::type_image(id, type_id, image.dim, image.flags, image.image_format)
+            }
+            LocalType::Sampler => Instruction::type_sampler(id),
+            LocalType::SampledImage { image_type_id } => {
+                Instruction::type_sampled_image(id, image_type_id)
+            }
+            LocalType::BindingArray { base, size } => {
+                let inner_ty = self.get_type_id(LookupType::Handle(base));
+                let scalar_id = self.get_constant_scalar(crate::Literal::U32(size));
+                Instruction::type_array(id, inner_ty, scalar_id)
+            }
+            LocalType::PointerToBindingArray { base, size, space } => {
+                let inner_ty =
+                    self.get_type_id(LookupType::Local(LocalType::BindingArray { base, size }));
+                let class = map_storage_class(space);
+                Instruction::type_pointer(id, class, inner_ty)
+            }
+            LocalType::AccelerationStructure => Instruction::type_acceleration_structure(id),
+            LocalType::RayQuery => Instruction::type_ray_query(id),
+        };
+
+        instruction.to_words(&mut self.logical_layout.declarations);
+    }
+
+    fn write_type_declaration_arena(
+        &mut self,
+        arena: &UniqueArena<crate::Type>,
+        handle: Handle<crate::Type>,
+    ) -> Result<Word, Error> {
+        let ty = &arena[handle];
+        let id = if let Some(local) = make_local(&ty.inner) {
+            // This type can be represented as a `LocalType`, so check if we've
+            // already written an instruction for it. If not, do so now, with
+            // `write_type_declaration_local`.
+            match self.lookup_type.entry(LookupType::Local(local)) {
+                // We already have an id for this `LocalType`.
+                Entry::Occupied(e) => *e.get(),
+
+                // It's a type we haven't seen before.
+                Entry::Vacant(e) => {
+                    let id = self.id_gen.next();
+                    e.insert(id);
+
+                    self.write_type_declaration_local(id, local);
+
+                    // If it's a type that needs SPIR-V capabilities, request them now,
+                    // so write_type_declaration_local can stay infallible.
+                    self.request_type_capabilities(&ty.inner)?;
+
+                    id
+                }
+            }
+        } else {
+            use spirv::Decoration;
+
+            let id = self.id_gen.next();
+            let instruction = match ty.inner {
+                crate::TypeInner::Array { base, size, stride } => {
+                    self.decorate(id, Decoration::ArrayStride, &[stride]);
+
+                    let type_id = self.get_type_id(LookupType::Handle(base));
+                    match size {
+                        crate::ArraySize::Constant(length) => {
+                            let length_id = self.get_index_constant(length.get());
+                            Instruction::type_array(id, type_id, length_id)
+                        }
+                        crate::ArraySize::Dynamic => Instruction::type_runtime_array(id, type_id),
+                    }
+                }
+                crate::TypeInner::BindingArray { base, size } => {
+                    let type_id = self.get_type_id(LookupType::Handle(base));
+                    match size {
+                        crate::ArraySize::Constant(length) => {
+                            let length_id = self.get_index_constant(length.get());
+                            Instruction::type_array(id, type_id, length_id)
+                        }
+                        crate::ArraySize::Dynamic => Instruction::type_runtime_array(id, type_id),
+                    }
+                }
+                crate::TypeInner::Struct {
+                    ref members,
+                    span: _,
+                } => {
+                    let mut has_runtime_array = false;
+                    let mut member_ids = Vec::with_capacity(members.len());
+                    for (index, member) in members.iter().enumerate() {
+                        let member_ty = &arena[member.ty];
+                        match member_ty.inner {
+                            crate::TypeInner::Array {
+                                base: _,
+                                size: crate::ArraySize::Dynamic,
+                                stride: _,
+                            } => {
+                                has_runtime_array = true;
+                            }
+                            _ => (),
+                        }
+                        self.decorate_struct_member(id, index, member, arena)?;
+                        let member_id = self.get_type_id(LookupType::Handle(member.ty));
+                        member_ids.push(member_id);
+                    }
+                    if has_runtime_array {
+                        self.decorate(id, Decoration::Block, &[]);
+                    }
+                    Instruction::type_struct(id, member_ids.as_slice())
+                }
+
+                // These all have TypeLocal representations, so they should have been
+                // handled by `write_type_declaration_local` above.
+                crate::TypeInner::Scalar(_)
+                | crate::TypeInner::Atomic(_)
+                | crate::TypeInner::Vector { .. }
+                | crate::TypeInner::Matrix { .. }
+                | crate::TypeInner::Pointer { .. }
+                | crate::TypeInner::ValuePointer { .. }
+                | crate::TypeInner::Image { .. }
+                | crate::TypeInner::Sampler { .. }
+                | crate::TypeInner::AccelerationStructure
+                | crate::TypeInner::RayQuery => unreachable!(),
+            };
+
+            instruction.to_words(&mut self.logical_layout.declarations);
+            id
+        };
+
+        // Add this handle as a new alias for that type.
+        self.lookup_type.insert(LookupType::Handle(handle), id);
+
+        if self.flags.contains(WriterFlags::DEBUG) {
+            if let Some(ref name) = ty.name {
+                self.debugs.push(Instruction::name(id, name));
+            }
+        }
+
+        Ok(id)
+    }
+
+    fn request_image_format_capabilities(
+        &mut self,
+        format: spirv::ImageFormat,
+    ) -> Result<(), Error> {
+        use spirv::ImageFormat as If;
+        match format {
+            If::Rg32f
+            | If::Rg16f
+            | If::R11fG11fB10f
+            | If::R16f
+            | If::Rgba16
+            | If::Rgb10A2
+            | If::Rg16
+            | If::Rg8
+            | If::R16
+            | If::R8
+            | If::Rgba16Snorm
+            | If::Rg16Snorm
+            | If::Rg8Snorm
+            | If::R16Snorm
+            | If::R8Snorm
+            | If::Rg32i
+            | If::Rg16i
+            | If::Rg8i
+            | If::R16i
+            | If::R8i
+            | If::Rgb10a2ui
+            | If::Rg32ui
+            | If::Rg16ui
+            | If::Rg8ui
+            | If::R16ui
+            | If::R8ui => self.require_any(
+                "storage image format",
+                &[spirv::Capability::StorageImageExtendedFormats],
+            ),
+            If::R64ui | If::R64i => self.require_any(
+                "64-bit integer storage image format",
+                &[spirv::Capability::Int64ImageEXT],
+            ),
+            If::Unknown
+            | If::Rgba32f
+            | If::Rgba16f
+            | If::R32f
+            | If::Rgba8
+            | If::Rgba8Snorm
+            | If::Rgba32i
+            | If::Rgba16i
+            | If::Rgba8i
+            | If::R32i
+            | If::Rgba32ui
+            | If::Rgba16ui
+            | If::Rgba8ui
+            | If::R32ui => Ok(()),
+        }
+    }
+
+    pub(super) fn get_index_constant(&mut self, index: Word) -> Word {
+        self.get_constant_scalar(crate::Literal::U32(index))
+    }
+
+    pub(super) fn get_constant_scalar_with(
+        &mut self,
+        value: u8,
+        scalar: crate::Scalar,
+    ) -> Result<Word, Error> {
+        Ok(
+            self.get_constant_scalar(crate::Literal::new(value, scalar).ok_or(
+                Error::Validation("Unexpected kind and/or width for Literal"),
+            )?),
+        )
+    }
+
+    pub(super) fn get_constant_scalar(&mut self, value: crate::Literal) -> Word {
+        let scalar = CachedConstant::Literal(value);
+        if let Some(&id) = self.cached_constants.get(&scalar) {
+            return id;
+        }
+        let id = self.id_gen.next();
+        self.write_constant_scalar(id, &value, None);
+        self.cached_constants.insert(scalar, id);
+        id
+    }
+
+    fn write_constant_scalar(
+        &mut self,
+        id: Word,
+        value: &crate::Literal,
+        debug_name: Option<&String>,
+    ) {
+        if self.flags.contains(WriterFlags::DEBUG) {
+            if let Some(name) = debug_name {
+                self.debugs.push(Instruction::name(id, name));
+            }
+        }
+        let type_id = self.get_type_id(LookupType::Local(LocalType::Value {
+            vector_size: None,
+            scalar: value.scalar(),
+            pointer_space: None,
+        }));
+        let instruction = match *value {
+            crate::Literal::F64(value) => {
+                let bits = value.to_bits();
+                Instruction::constant_64bit(type_id, id, bits as u32, (bits >> 32) as u32)
+            }
+            crate::Literal::F32(value) => Instruction::constant_32bit(type_id, id, value.to_bits()),
+            crate::Literal::U32(value) => Instruction::constant_32bit(type_id, id, value),
+            crate::Literal::I32(value) => Instruction::constant_32bit(type_id, id, value as u32),
+            crate::Literal::I64(value) => {
+                Instruction::constant_64bit(type_id, id, value as u32, (value >> 32) as u32)
+            }
+            crate::Literal::Bool(true) => Instruction::constant_true(type_id, id),
+            crate::Literal::Bool(false) => Instruction::constant_false(type_id, id),
+            crate::Literal::AbstractInt(_) | crate::Literal::AbstractFloat(_) => {
+                unreachable!("Abstract types should not appear in IR presented to backends");
+            }
+        };
+
+        instruction.to_words(&mut self.logical_layout.declarations);
+    }
+
+    pub(super) fn get_constant_composite(
+        &mut self,
+        ty: LookupType,
+        constituent_ids: &[Word],
+    ) -> Word {
+        let composite = CachedConstant::Composite {
+            ty,
+            constituent_ids: constituent_ids.to_vec(),
+        };
+        if let Some(&id) = self.cached_constants.get(&composite) {
+            return id;
+        }
+        let id = self.id_gen.next();
+        self.write_constant_composite(id, ty, constituent_ids, None);
+        self.cached_constants.insert(composite, id);
+        id
+    }
+
+    fn write_constant_composite(
+        &mut self,
+        id: Word,
+        ty: LookupType,
+        constituent_ids: &[Word],
+        debug_name: Option<&String>,
+    ) {
+        if self.flags.contains(WriterFlags::DEBUG) {
+            if let Some(name) = debug_name {
+                self.debugs.push(Instruction::name(id, name));
+            }
+        }
+        let type_id = self.get_type_id(ty);
+        Instruction::constant_composite(type_id, id, constituent_ids)
+            .to_words(&mut self.logical_layout.declarations);
+    }
+
+    pub(super) fn get_constant_null(&mut self, type_id: Word) -> Word {
+        let null = CachedConstant::ZeroValue(type_id);
+        if let Some(&id) = self.cached_constants.get(&null) {
+            return id;
+        }
+        let id = self.write_constant_null(type_id);
+        self.cached_constants.insert(null, id);
+        id
+    }
+
+    pub(super) fn write_constant_null(&mut self, type_id: Word) -> Word {
+        let null_id = self.id_gen.next();
+        Instruction::constant_null(type_id, null_id)
+            .to_words(&mut self.logical_layout.declarations);
+        null_id
+    }
+
+    fn write_constant_expr(
+        &mut self,
+        handle: Handle<crate::Expression>,
+        ir_module: &crate::Module,
+        mod_info: &ModuleInfo,
+    ) -> Result<Word, Error> {
+        let id = match ir_module.const_expressions[handle] {
+            crate::Expression::Literal(literal) => self.get_constant_scalar(literal),
+            crate::Expression::Constant(constant) => {
+                let constant = &ir_module.constants[constant];
+                self.constant_ids[constant.init.index()]
+            }
+            crate::Expression::ZeroValue(ty) => {
+                let type_id = self.get_type_id(LookupType::Handle(ty));
+                self.get_constant_null(type_id)
+            }
+            crate::Expression::Compose { ty, ref components } => {
+                let component_ids: Vec<_> = crate::proc::flatten_compose(
+                    ty,
+                    components,
+                    &ir_module.const_expressions,
+                    &ir_module.types,
+                )
+                .map(|component| self.constant_ids[component.index()])
+                .collect();
+                self.get_constant_composite(LookupType::Handle(ty), component_ids.as_slice())
+            }
+            crate::Expression::Splat { size, value } => {
+                let value_id = self.constant_ids[value.index()];
+                let component_ids = &[value_id; 4][..size as usize];
+
+                let ty = self.get_expression_lookup_type(&mod_info[handle]);
+
+                self.get_constant_composite(ty, component_ids)
+            }
+            _ => unreachable!(),
+        };
+
+        self.constant_ids[handle.index()] = id;
+
+        Ok(id)
+    }
+
+    pub(super) fn write_barrier(&mut self, flags: crate::Barrier, block: &mut Block) {
+        let memory_scope = if flags.contains(crate::Barrier::STORAGE) {
+            spirv::Scope::Device
+        } else {
+            spirv::Scope::Workgroup
+        };
+        let mut semantics = spirv::MemorySemantics::ACQUIRE_RELEASE;
+        semantics.set(
+            spirv::MemorySemantics::UNIFORM_MEMORY,
+            flags.contains(crate::Barrier::STORAGE),
+        );
+        semantics.set(
+            spirv::MemorySemantics::WORKGROUP_MEMORY,
+            flags.contains(crate::Barrier::WORK_GROUP),
+        );
+        let exec_scope_id = self.get_index_constant(spirv::Scope::Workgroup as u32);
+        let mem_scope_id = self.get_index_constant(memory_scope as u32);
+        let semantics_id = self.get_index_constant(semantics.bits());
+        block.body.push(Instruction::control_barrier(
+            exec_scope_id,
+            mem_scope_id,
+            semantics_id,
+        ));
+    }
+
+    fn generate_workgroup_vars_init_block(
+        &mut self,
+        entry_id: Word,
+        ir_module: &crate::Module,
+        info: &FunctionInfo,
+        local_invocation_id: Option<Word>,
+        interface: &mut FunctionInterface,
+        function: &mut Function,
+    ) -> Option<Word> {
+        let body = ir_module
+            .global_variables
+            .iter()
+            .filter(|&(handle, var)| {
+                !info[handle].is_empty() && var.space == crate::AddressSpace::WorkGroup
+            })
+            .map(|(handle, var)| {
+                // It's safe to use `var_id` here, not `access_id`, because only
+                // variables in the `Uniform` and `StorageBuffer` address spaces
+                // get wrapped, and we're initializing `WorkGroup` variables.
+                let var_id = self.global_variables[handle.index()].var_id;
+                let var_type_id = self.get_type_id(LookupType::Handle(var.ty));
+                let init_word = self.get_constant_null(var_type_id);
+                Instruction::store(var_id, init_word, None)
+            })
+            .collect::<Vec<_>>();
+
+        if body.is_empty() {
+            return None;
+        }
+
+        let uint3_type_id = self.get_uint3_type_id();
+
+        let mut pre_if_block = Block::new(entry_id);
+
+        let local_invocation_id = if let Some(local_invocation_id) = local_invocation_id {
+            local_invocation_id
+        } else {
+            let varying_id = self.id_gen.next();
+            let class = spirv::StorageClass::Input;
+            let pointer_type_id = self.get_uint3_pointer_type_id(class);
+
+            Instruction::variable(pointer_type_id, varying_id, class, None)
+                .to_words(&mut self.logical_layout.declarations);
+
+            self.decorate(
+                varying_id,
+                spirv::Decoration::BuiltIn,
+                &[spirv::BuiltIn::LocalInvocationId as u32],
+            );
+
+            interface.varying_ids.push(varying_id);
+            let id = self.id_gen.next();
+            pre_if_block
+                .body
+                .push(Instruction::load(uint3_type_id, id, varying_id, None));
+
+            id
+        };
+
+        let zero_id = self.get_constant_null(uint3_type_id);
+        let bool3_type_id = self.get_bool3_type_id();
+
+        let eq_id = self.id_gen.next();
+        pre_if_block.body.push(Instruction::binary(
+            spirv::Op::IEqual,
+            bool3_type_id,
+            eq_id,
+            local_invocation_id,
+            zero_id,
+        ));
+
+        let condition_id = self.id_gen.next();
+        let bool_type_id = self.get_bool_type_id();
+        pre_if_block.body.push(Instruction::relational(
+            spirv::Op::All,
+            bool_type_id,
+            condition_id,
+            eq_id,
+        ));
+
+        let merge_id = self.id_gen.next();
+        pre_if_block.body.push(Instruction::selection_merge(
+            merge_id,
+            spirv::SelectionControl::NONE,
+        ));
+
+        let accept_id = self.id_gen.next();
+        function.consume(
+            pre_if_block,
+            Instruction::branch_conditional(condition_id, accept_id, merge_id),
+        );
+
+        let accept_block = Block {
+            label_id: accept_id,
+            body,
+        };
+        function.consume(accept_block, Instruction::branch(merge_id));
+
+        let mut post_if_block = Block::new(merge_id);
+
+        self.write_barrier(crate::Barrier::WORK_GROUP, &mut post_if_block);
+
+        let next_id = self.id_gen.next();
+        function.consume(post_if_block, Instruction::branch(next_id));
+        Some(next_id)
+    }
+
+    /// Generate an `OpVariable` for one value in an [`EntryPoint`]'s IO interface.
+    ///
+    /// The [`Binding`]s of the arguments and result of an [`EntryPoint`]'s
+    /// [`Function`] describe a SPIR-V shader interface. In SPIR-V, the
+    /// interface is represented by global variables in the `Input` and `Output`
+    /// storage classes, with decorations indicating which builtin or location
+    /// each variable corresponds to.
+    ///
+    /// This function emits a single global `OpVariable` for a single value from
+    /// the interface, and adds appropriate decorations to indicate which
+    /// builtin or location it represents, how it should be interpolated, and so
+    /// on. The `class` argument gives the variable's SPIR-V storage class,
+    /// which should be either [`Input`] or [`Output`].
+    ///
+    /// [`Binding`]: crate::Binding
+    /// [`Function`]: crate::Function
+    /// [`EntryPoint`]: crate::EntryPoint
+    /// [`Input`]: spirv::StorageClass::Input
+    /// [`Output`]: spirv::StorageClass::Output
+    fn write_varying(
+        &mut self,
+        ir_module: &crate::Module,
+        stage: crate::ShaderStage,
+        class: spirv::StorageClass,
+        debug_name: Option<&str>,
+        ty: Handle<crate::Type>,
+        binding: &crate::Binding,
+    ) -> Result<Word, Error> {
+        let id = self.id_gen.next();
+        let pointer_type_id = self.get_pointer_id(&ir_module.types, ty, class)?;
+        Instruction::variable(pointer_type_id, id, class, None)
+            .to_words(&mut self.logical_layout.declarations);
+
+        if self
+            .flags
+            .contains(WriterFlags::DEBUG | WriterFlags::LABEL_VARYINGS)
+        {
+            if let Some(name) = debug_name {
+                self.debugs.push(Instruction::name(id, name));
+            }
+        }
+
+        use spirv::{BuiltIn, Decoration};
+
+        match *binding {
+            crate::Binding::Location {
+                location,
+                interpolation,
+                sampling,
+                second_blend_source,
+            } => {
+                self.decorate(id, Decoration::Location, &[location]);
+
+                let no_decorations =
+                    // VUID-StandaloneSpirv-Flat-06202
+                    // > The Flat, NoPerspective, Sample, and Centroid decorations
+                    // > must not be used on variables with the Input storage class in a vertex shader
+                    (class == spirv::StorageClass::Input && stage == crate::ShaderStage::Vertex) ||
+                    // VUID-StandaloneSpirv-Flat-06201
+                    // > The Flat, NoPerspective, Sample, and Centroid decorations
+                    // > must not be used on variables with the Output storage class in a fragment shader
+                    (class == spirv::StorageClass::Output && stage == crate::ShaderStage::Fragment);
+
+                if !no_decorations {
+                    match interpolation {
+                        // Perspective-correct interpolation is the default in SPIR-V.
+                        None | Some(crate::Interpolation::Perspective) => (),
+                        Some(crate::Interpolation::Flat) => {
+                            self.decorate(id, Decoration::Flat, &[]);
+                        }
+                        Some(crate::Interpolation::Linear) => {
+                            self.decorate(id, Decoration::NoPerspective, &[]);
+                        }
+                    }
+                    match sampling {
+                        // Center sampling is the default in SPIR-V.
+                        None | Some(crate::Sampling::Center) => (),
+                        Some(crate::Sampling::Centroid) => {
+                            self.decorate(id, Decoration::Centroid, &[]);
+                        }
+                        Some(crate::Sampling::Sample) => {
+                            self.require_any(
+                                "per-sample interpolation",
+                                &[spirv::Capability::SampleRateShading],
+                            )?;
+                            self.decorate(id, Decoration::Sample, &[]);
+                        }
+                    }
+                }
+                if second_blend_source {
+                    self.decorate(id, Decoration::Index, &[1]);
+                }
+            }
+            crate::Binding::BuiltIn(built_in) => {
+                use crate::BuiltIn as Bi;
+                let built_in = match built_in {
+                    Bi::Position { invariant } => {
+                        if invariant {
+                            self.decorate(id, Decoration::Invariant, &[]);
+                        }
+
+                        if class == spirv::StorageClass::Output {
+                            BuiltIn::Position
+                        } else {
+                            BuiltIn::FragCoord
+                        }
+                    }
+                    Bi::ViewIndex => {
+                        self.require_any("`view_index` built-in", &[spirv::Capability::MultiView])?;
+                        BuiltIn::ViewIndex
+                    }
+                    // vertex
+                    Bi::BaseInstance => BuiltIn::BaseInstance,
+                    Bi::BaseVertex => BuiltIn::BaseVertex,
+                    Bi::ClipDistance => {
+                        self.require_any(
+                            "`clip_distance` built-in",
+                            &[spirv::Capability::ClipDistance],
+                        )?;
+                        BuiltIn::ClipDistance
+                    }
+                    Bi::CullDistance => {
+                        self.require_any(
+                            "`cull_distance` built-in",
+                            &[spirv::Capability::CullDistance],
+                        )?;
+                        BuiltIn::CullDistance
+                    }
+                    Bi::InstanceIndex => BuiltIn::InstanceIndex,
+                    Bi::PointSize => BuiltIn::PointSize,
+                    Bi::VertexIndex => BuiltIn::VertexIndex,
+                    // fragment
+                    Bi::FragDepth => BuiltIn::FragDepth,
+                    Bi::PointCoord => BuiltIn::PointCoord,
+                    Bi::FrontFacing => BuiltIn::FrontFacing,
+                    Bi::PrimitiveIndex => {
+                        self.require_any(
+                            "`primitive_index` built-in",
+                            &[spirv::Capability::Geometry],
+                        )?;
+                        BuiltIn::PrimitiveId
+                    }
+                    Bi::SampleIndex => {
+                        self.require_any(
+                            "`sample_index` built-in",
+                            &[spirv::Capability::SampleRateShading],
+                        )?;
+
+                        BuiltIn::SampleId
+                    }
+                    Bi::SampleMask => BuiltIn::SampleMask,
+                    // compute
+                    Bi::GlobalInvocationId => BuiltIn::GlobalInvocationId,
+                    Bi::LocalInvocationId => BuiltIn::LocalInvocationId,
+                    Bi::LocalInvocationIndex => BuiltIn::LocalInvocationIndex,
+                    Bi::WorkGroupId => BuiltIn::WorkgroupId,
+                    Bi::WorkGroupSize => BuiltIn::WorkgroupSize,
+                    Bi::NumWorkGroups => BuiltIn::NumWorkgroups,
+                };
+
+                self.decorate(id, Decoration::BuiltIn, &[built_in as u32]);
+
+                use crate::ScalarKind as Sk;
+
+                // Per the Vulkan spec, `VUID-StandaloneSpirv-Flat-04744`:
+                //
+                // > Any variable with integer or double-precision floating-
+                // > point type and with Input storage class in a fragment
+                // > shader, must be decorated Flat
+                if class == spirv::StorageClass::Input && stage == crate::ShaderStage::Fragment {
+                    let is_flat = match ir_module.types[ty].inner {
+                        crate::TypeInner::Scalar(scalar)
+                        | crate::TypeInner::Vector { scalar, .. } => match scalar.kind {
+                            Sk::Uint | Sk::Sint | Sk::Bool => true,
+                            Sk::Float => false,
+                            Sk::AbstractInt | Sk::AbstractFloat => {
+                                return Err(Error::Validation(
+                                    "Abstract types should not appear in IR presented to backends",
+                                ))
+                            }
+                        },
+                        _ => false,
+                    };
+
+                    if is_flat {
+                        self.decorate(id, Decoration::Flat, &[]);
+                    }
+                }
+            }
+        }
+
+        Ok(id)
+    }
+
+    fn write_global_variable(
+        &mut self,
+        ir_module: &crate::Module,
+        global_variable: &crate::GlobalVariable,
+    ) -> Result<Word, Error> {
+        use spirv::Decoration;
+
+        let id = self.id_gen.next();
+        let class = map_storage_class(global_variable.space);
+
+        //self.check(class.required_capabilities())?;
+
+        if self.flags.contains(WriterFlags::DEBUG) {
+            if let Some(ref name) = global_variable.name {
+                self.debugs.push(Instruction::name(id, name));
+            }
+        }
+
+        let storage_access = match global_variable.space {
+            crate::AddressSpace::Storage { access } => Some(access),
+            _ => match ir_module.types[global_variable.ty].inner {
+                crate::TypeInner::Image {
+                    class: crate::ImageClass::Storage { access, .. },
+                    ..
+                } => Some(access),
+                _ => None,
+            },
+        };
+        if let Some(storage_access) = storage_access {
+            if !storage_access.contains(crate::StorageAccess::LOAD) {
+                self.decorate(id, Decoration::NonReadable, &[]);
+            }
+            if !storage_access.contains(crate::StorageAccess::STORE) {
+                self.decorate(id, Decoration::NonWritable, &[]);
+            }
+        }
+
+        // Note: we should be able to substitute `binding_array<Foo, 0>`,
+        // but there is still code that tries to register the pre-substituted type,
+        // and it is failing on 0.
+        let mut substitute_inner_type_lookup = None;
+        if let Some(ref res_binding) = global_variable.binding {
+            self.decorate(id, Decoration::DescriptorSet, &[res_binding.group]);
+            self.decorate(id, Decoration::Binding, &[res_binding.binding]);
+
+            if let Some(&BindingInfo {
+                binding_array_size: Some(remapped_binding_array_size),
+            }) = self.binding_map.get(res_binding)
+            {
+                if let crate::TypeInner::BindingArray { base, .. } =
+                    ir_module.types[global_variable.ty].inner
+                {
+                    substitute_inner_type_lookup =
+                        Some(LookupType::Local(LocalType::PointerToBindingArray {
+                            base,
+                            size: remapped_binding_array_size,
+                            space: global_variable.space,
+                        }))
+                }
+            }
+        };
+
+        let init_word = global_variable
+            .init
+            .map(|constant| self.constant_ids[constant.index()]);
+        let inner_type_id = self.get_type_id(
+            substitute_inner_type_lookup.unwrap_or(LookupType::Handle(global_variable.ty)),
+        );
+
+        // generate the wrapping structure if needed
+        let pointer_type_id = if global_needs_wrapper(ir_module, global_variable) {
+            let wrapper_type_id = self.id_gen.next();
+
+            self.decorate(wrapper_type_id, Decoration::Block, &[]);
+            let member = crate::StructMember {
+                name: None,
+                ty: global_variable.ty,
+                binding: None,
+                offset: 0,
+            };
+            self.decorate_struct_member(wrapper_type_id, 0, &member, &ir_module.types)?;
+
+            Instruction::type_struct(wrapper_type_id, &[inner_type_id])
+                .to_words(&mut self.logical_layout.declarations);
+
+            let pointer_type_id = self.id_gen.next();
+            Instruction::type_pointer(pointer_type_id, class, wrapper_type_id)
+                .to_words(&mut self.logical_layout.declarations);
+
+            pointer_type_id
+        } else {
+            // This is a global variable in the Storage address space. The only
+            // way it could have `global_needs_wrapper() == false` is if it has
+            // a runtime-sized or binding array.
+            // Runtime-sized arrays were decorated when iterating through struct content.
+            // Now binding arrays require Block decorating.
+            if let crate::AddressSpace::Storage { .. } = global_variable.space {
+                match ir_module.types[global_variable.ty].inner {
+                    crate::TypeInner::BindingArray { base, .. } => {
+                        let decorated_id = self.get_type_id(LookupType::Handle(base));
+                        self.decorate(decorated_id, Decoration::Block, &[]);
+                    }
+                    _ => (),
+                };
+            }
+            if substitute_inner_type_lookup.is_some() {
+                inner_type_id
+            } else {
+                self.get_pointer_id(&ir_module.types, global_variable.ty, class)?
+            }
+        };
+
+        let init_word = match (global_variable.space, self.zero_initialize_workgroup_memory) {
+            (crate::AddressSpace::Private, _)
+            | (crate::AddressSpace::WorkGroup, super::ZeroInitializeWorkgroupMemoryMode::Native) => {
+                init_word.or_else(|| Some(self.get_constant_null(inner_type_id)))
+            }
+            _ => init_word,
+        };
+
+        Instruction::variable(pointer_type_id, id, class, init_word)
+            .to_words(&mut self.logical_layout.declarations);
+        Ok(id)
+    }
+
+    /// Write the necessary decorations for a struct member.
+    ///
+    /// Emit decorations for the `index`'th member of the struct type
+    /// designated by `struct_id`, described by `member`.
+    fn decorate_struct_member(
+        &mut self,
+        struct_id: Word,
+        index: usize,
+        member: &crate::StructMember,
+        arena: &UniqueArena<crate::Type>,
+    ) -> Result<(), Error> {
+        use spirv::Decoration;
+
+        self.annotations.push(Instruction::member_decorate(
+            struct_id,
+            index as u32,
+            Decoration::Offset,
+            &[member.offset],
+        ));
+
+        if self.flags.contains(WriterFlags::DEBUG) {
+            if let Some(ref name) = member.name {
+                self.debugs
+                    .push(Instruction::member_name(struct_id, index as u32, name));
+            }
+        }
+
+        // Matrices and arrays of matrices both require decorations,
+        // so "see through" an array to determine if they're needed.
+        let member_array_subty_inner = match arena[member.ty].inner {
+            crate::TypeInner::Array { base, .. } => &arena[base].inner,
+            ref other => other,
+        };
+        if let crate::TypeInner::Matrix {
+            columns: _,
+            rows,
+            scalar,
+        } = *member_array_subty_inner
+        {
+            let byte_stride = Alignment::from(rows) * scalar.width as u32;
+            self.annotations.push(Instruction::member_decorate(
+                struct_id,
+                index as u32,
+                Decoration::ColMajor,
+                &[],
+            ));
+            self.annotations.push(Instruction::member_decorate(
+                struct_id,
+                index as u32,
+                Decoration::MatrixStride,
+                &[byte_stride],
+            ));
+        }
+
+        Ok(())
+    }
+
+    fn get_function_type(&mut self, lookup_function_type: LookupFunctionType) -> Word {
+        match self
+            .lookup_function_type
+            .entry(lookup_function_type.clone())
+        {
+            Entry::Occupied(e) => *e.get(),
+            Entry::Vacant(_) => {
+                let id = self.id_gen.next();
+                let instruction = Instruction::type_function(
+                    id,
+                    lookup_function_type.return_type_id,
+                    &lookup_function_type.parameter_type_ids,
+                );
+                instruction.to_words(&mut self.logical_layout.declarations);
+                self.lookup_function_type.insert(lookup_function_type, id);
+                id
+            }
+        }
+    }
+
+    fn write_physical_layout(&mut self) {
+        self.physical_layout.bound = self.id_gen.0 + 1;
+    }
+
+    fn write_logical_layout(
+        &mut self,
+        ir_module: &crate::Module,
+        mod_info: &ModuleInfo,
+        ep_index: Option<usize>,
+        debug_info: &Option<DebugInfo>,
+    ) -> Result<(), Error> {
+        fn has_view_index_check(
+            ir_module: &crate::Module,
+            binding: Option<&crate::Binding>,
+            ty: Handle<crate::Type>,
+        ) -> bool {
+            match ir_module.types[ty].inner {
+                crate::TypeInner::Struct { ref members, .. } => members.iter().any(|member| {
+                    has_view_index_check(ir_module, member.binding.as_ref(), member.ty)
+                }),
+                _ => binding == Some(&crate::Binding::BuiltIn(crate::BuiltIn::ViewIndex)),
+            }
+        }
+
+        let has_storage_buffers =
+            ir_module
+                .global_variables
+                .iter()
+                .any(|(_, var)| match var.space {
+                    crate::AddressSpace::Storage { .. } => true,
+                    _ => false,
+                });
+        let has_view_index = ir_module
+            .entry_points
+            .iter()
+            .flat_map(|entry| entry.function.arguments.iter())
+            .any(|arg| has_view_index_check(ir_module, arg.binding.as_ref(), arg.ty));
+        let has_ray_query = ir_module.special_types.ray_desc.is_some()
+            | ir_module.special_types.ray_intersection.is_some();
+
+        if self.physical_layout.version < 0x10300 && has_storage_buffers {
+            // enable the storage buffer class on < SPV-1.3
+            Instruction::extension("SPV_KHR_storage_buffer_storage_class")
+                .to_words(&mut self.logical_layout.extensions);
+        }
+        if has_view_index {
+            Instruction::extension("SPV_KHR_multiview")
+                .to_words(&mut self.logical_layout.extensions)
+        }
+        if has_ray_query {
+            Instruction::extension("SPV_KHR_ray_query")
+                .to_words(&mut self.logical_layout.extensions)
+        }
+        Instruction::type_void(self.void_type).to_words(&mut self.logical_layout.declarations);
+        Instruction::ext_inst_import(self.gl450_ext_inst_id, "GLSL.std.450")
+            .to_words(&mut self.logical_layout.ext_inst_imports);
+
+        let mut debug_info_inner = None;
+        if self.flags.contains(WriterFlags::DEBUG) {
+            if let Some(debug_info) = debug_info.as_ref() {
+                let source_file_id = self.id_gen.next();
+                self.debugs.push(Instruction::string(
+                    &debug_info.file_name.display().to_string(),
+                    source_file_id,
+                ));
+
+                debug_info_inner = Some(DebugInfoInner {
+                    source_code: debug_info.source_code,
+                    source_file_id,
+                });
+                self.debugs.push(Instruction::source(
+                    spirv::SourceLanguage::Unknown,
+                    0,
+                    &debug_info_inner,
+                ));
+            }
+        }
+
+        // write all types
+        for (handle, _) in ir_module.types.iter() {
+            self.write_type_declaration_arena(&ir_module.types, handle)?;
+        }
+
+        // write all const-expressions as constants
+        self.constant_ids
+            .resize(ir_module.const_expressions.len(), 0);
+        for (handle, _) in ir_module.const_expressions.iter() {
+            self.write_constant_expr(handle, ir_module, mod_info)?;
+        }
+        debug_assert!(self.constant_ids.iter().all(|&id| id != 0));
+
+        // write the name of constants on their respective const-expression initializer
+        if self.flags.contains(WriterFlags::DEBUG) {
+            for (_, constant) in ir_module.constants.iter() {
+                if let Some(ref name) = constant.name {
+                    let id = self.constant_ids[constant.init.index()];
+                    self.debugs.push(Instruction::name(id, name));
+                }
+            }
+        }
+
+        // write all global variables
+        for (handle, var) in ir_module.global_variables.iter() {
+            // If a single entry point was specified, only write `OpVariable` instructions
+            // for the globals it actually uses. Emit dummies for the others,
+            // to preserve the indices in `global_variables`.
+            let gvar = match ep_index {
+                Some(index) if mod_info.get_entry_point(index)[handle].is_empty() => {
+                    GlobalVariable::dummy()
+                }
+                _ => {
+                    let id = self.write_global_variable(ir_module, var)?;
+                    GlobalVariable::new(id)
+                }
+            };
+            self.global_variables.push(gvar);
+        }
+
+        // write all functions
+        for (handle, ir_function) in ir_module.functions.iter() {
+            let info = &mod_info[handle];
+            if let Some(index) = ep_index {
+                let ep_info = mod_info.get_entry_point(index);
+                // If this function uses globals that we omitted from the SPIR-V
+                // because the entry point and its callees didn't use them,
+                // then we must skip it.
+                if !ep_info.dominates_global_use(info) {
+                    log::info!("Skip function {:?}", ir_function.name);
+                    continue;
+                }
+
+                // Skip functions that that are not compatible with this entry point's stage.
+                //
+                // When validation is enabled, it rejects modules whose entry points try to call
+                // incompatible functions, so if we got this far, then any functions incompatible
+                // with our selected entry point must not be used.
+                //
+                // When validation is disabled, `fun_info.available_stages` is always just
+                // `ShaderStages::all()`, so this will write all functions in the module, and
+                // the downstream GLSL compiler will catch any problems.
+                if !info.available_stages.contains(ep_info.available_stages) {
+                    continue;
+                }
+            }
+            let id = self.write_function(ir_function, info, ir_module, None, &debug_info_inner)?;
+            self.lookup_function.insert(handle, id);
+        }
+
+        // write all or one entry points
+        for (index, ir_ep) in ir_module.entry_points.iter().enumerate() {
+            if ep_index.is_some() && ep_index != Some(index) {
+                continue;
+            }
+            let info = mod_info.get_entry_point(index);
+            let ep_instruction =
+                self.write_entry_point(ir_ep, info, ir_module, &debug_info_inner)?;
+            ep_instruction.to_words(&mut self.logical_layout.entry_points);
+        }
+
+        for capability in self.capabilities_used.iter() {
+            Instruction::capability(*capability).to_words(&mut self.logical_layout.capabilities);
+        }
+        for extension in self.extensions_used.iter() {
+            Instruction::extension(extension).to_words(&mut self.logical_layout.extensions);
+        }
+        if ir_module.entry_points.is_empty() {
+            // SPIR-V doesn't like modules without entry points
+            Instruction::capability(spirv::Capability::Linkage)
+                .to_words(&mut self.logical_layout.capabilities);
+        }
+
+        let addressing_model = spirv::AddressingModel::Logical;
+        let memory_model = spirv::MemoryModel::GLSL450;
+        //self.check(addressing_model.required_capabilities())?;
+        //self.check(memory_model.required_capabilities())?;
+
+        Instruction::memory_model(addressing_model, memory_model)
+            .to_words(&mut self.logical_layout.memory_model);
+
+        if self.flags.contains(WriterFlags::DEBUG) {
+            for debug in self.debugs.iter() {
+                debug.to_words(&mut self.logical_layout.debugs);
+            }
+        }
+
+        for annotation in self.annotations.iter() {
+            annotation.to_words(&mut self.logical_layout.annotations);
+        }
+
+        Ok(())
+    }
+
+    pub fn write(
+        &mut self,
+        ir_module: &crate::Module,
+        info: &ModuleInfo,
+        pipeline_options: Option<&PipelineOptions>,
+        debug_info: &Option<DebugInfo>,
+        words: &mut Vec<Word>,
+    ) -> Result<(), Error> {
+        self.reset();
+
+        // Try to find the entry point and corresponding index
+        let ep_index = match pipeline_options {
+            Some(po) => {
+                let index = ir_module
+                    .entry_points
+                    .iter()
+                    .position(|ep| po.shader_stage == ep.stage && po.entry_point == ep.name)
+                    .ok_or(Error::EntryPointNotFound)?;
+                Some(index)
+            }
+            None => None,
+        };
+
+        self.write_logical_layout(ir_module, info, ep_index, debug_info)?;
+        self.write_physical_layout();
+
+        self.physical_layout.in_words(words);
+        self.logical_layout.in_words(words);
+        Ok(())
+    }
+
+    /// Return the set of capabilities the last module written used.
+    pub const fn get_capabilities_used(&self) -> &crate::FastIndexSet<spirv::Capability> {
+        &self.capabilities_used
+    }
+
+    pub fn decorate_non_uniform_binding_array_access(&mut self, id: Word) -> Result<(), Error> {
+        self.require_any("NonUniformEXT", &[spirv::Capability::ShaderNonUniform])?;
+        self.use_extension("SPV_EXT_descriptor_indexing");
+        self.decorate(id, spirv::Decoration::NonUniform, &[]);
+        Ok(())
+    }
+}
+
+#[test]
+fn test_write_physical_layout() {
+    let mut writer = Writer::new(&Options::default()).unwrap();
+    assert_eq!(writer.physical_layout.bound, 0);
+    writer.write_physical_layout();
+    assert_eq!(writer.physical_layout.bound, 3);
+}