Remove SpirvValueKind::IllegalConst.

Author: eddyb

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -2381,13 +2381,6 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
 
     #[instrument(level = "trace", skip(self), fields(ptr, ptr_ty = ?self.debug_type(ptr.ty), dest_ty = ?self.debug_type(dest_ty)))]
     fn pointercast(&mut self, ptr: Self::Value, dest_ty: Self::Type) -> Self::Value {
-        // HACK(eddyb) reuse the special-casing in `const_bitcast`, which relies
-        // on adding a pointer type to an untyped pointer (to some const data).
-        if let SpirvValueKind::IllegalConst(_) = ptr.kind {
-            trace!("illegal const");
-            return self.const_bitcast(ptr, dest_ty);
-        }
-
         if ptr.ty == dest_ty {
             trace!("ptr.ty == dest_ty");
             return ptr;
@@ -2446,6 +2439,19 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                 self.debug_type(ptr_pointee),
                 self.debug_type(dest_pointee),
             );
+
+            // HACK(eddyb) reuse the special-casing in `const_bitcast`, which relies
+            // on adding a pointer type to an untyped pointer (to some const data).
+            if self.builder.lookup_const(ptr).is_some() {
+                // FIXME(eddyb) remove the condition on `zombie_waiting_for_span`,
+                // and constant-fold all pointer bitcasts, regardless of "legality",
+                // once `strip_ptrcasts` can undo `const_bitcast`, as well.
+                if ptr.zombie_waiting_for_span {
+                    trace!("illegal const");
+                    return self.const_bitcast(ptr, dest_ty);
+                }
+            }
+
             // Defer the cast so that it has a chance to be avoided.
             let original_ptr = ptr.def(self);
             let bitcast_result_id = self.emit().bitcast(dest_ty, None, original_ptr).unwrap();

crates/rustc_codegen_spirv/src/builder_spirv.rs

@@ -35,11 +35,6 @@ use std::{fs::File, io::Write, path::Path};
 pub enum SpirvValueKind {
     Def(Word),
 
-    /// The ID of a global instruction matching a `SpirvConst`, but which cannot
-    /// pass validation. Used to error (or attach zombie spans), at the usesites
-    /// of such constants, instead of where they're generated (and cached).
-    IllegalConst(Word),
-
     // FIXME(eddyb) this shouldn't be needed, but `rustc_codegen_ssa` still relies
     // on converting `Function`s to `Value`s even for direct calls, the `Builder`
     // should just have direct and indirect `call` variants (or a `Callee` enum).
@@ -96,23 +91,17 @@ impl SpirvValue {
 
     pub fn const_fold_load(self, cx: &CodegenCx<'_>) -> Option<Self> {
         match self.kind {
-            SpirvValueKind::Def(id) | SpirvValueKind::IllegalConst(id) => {
+            SpirvValueKind::Def(id) => {
                 let &entry = cx.builder.id_to_const.borrow().get(&id)?;
                 match entry.val {
                     SpirvConst::PtrTo { pointee } => {
                         let ty = match cx.lookup_type(self.ty) {
                             SpirvType::Pointer { pointee } => pointee,
                             ty => bug!("load called on value that wasn't a pointer: {:?}", ty),
                         };
-                        // FIXME(eddyb) deduplicate this `if`-`else` and its other copies.
-                        let kind = if entry.legal.is_ok() {
-                            SpirvValueKind::Def(pointee)
-                        } else {
-                            SpirvValueKind::IllegalConst(pointee)
-                        };
                         Some(SpirvValue {
                             zombie_waiting_for_span: entry.legal.is_err(),
-                            kind,
+                            kind: SpirvValueKind::Def(pointee),
                             ty,
                         })
                     }
@@ -152,7 +141,6 @@ impl SpirvValue {
             }
 
             SpirvValueKind::Def(id)
-            | SpirvValueKind::IllegalConst(id)
             | SpirvValueKind::LogicalPtrCast {
                 original_ptr: _,
                 original_ptr_ty: _,
@@ -573,15 +561,9 @@ impl<'tcx> BuilderSpirv<'tcx> {
 
         let val_with_type = WithType { ty, val };
         if let Some(entry) = self.const_to_id.borrow().get(&val_with_type) {
-            // FIXME(eddyb) deduplicate this `if`-`else` and its other copies.
-            let kind = if entry.legal.is_ok() {
-                SpirvValueKind::Def(entry.val)
-            } else {
-                SpirvValueKind::IllegalConst(entry.val)
-            };
             return SpirvValue {
                 zombie_waiting_for_span: entry.legal.is_err(),
-                kind,
+                kind: SpirvValueKind::Def(entry.val),
                 ty,
             };
         }
@@ -784,15 +766,9 @@ impl<'tcx> BuilderSpirv<'tcx> {
                 .insert(id, WithConstLegality { val, legal }),
             None
         );
-        // FIXME(eddyb) deduplicate this `if`-`else` and its other copies.
-        let kind = if legal.is_ok() {
-            SpirvValueKind::Def(id)
-        } else {
-            SpirvValueKind::IllegalConst(id)
-        };
         SpirvValue {
             zombie_waiting_for_span: legal.is_err(),
-            kind,
+            kind: SpirvValueKind::Def(id),
             ty,
         }
     }
@@ -803,9 +779,7 @@ impl<'tcx> BuilderSpirv<'tcx> {
 
     pub fn lookup_const(&self, def: SpirvValue) -> Option<SpirvConst<'tcx, 'tcx>> {
         match def.kind {
-            SpirvValueKind::Def(id) | SpirvValueKind::IllegalConst(id) => {
-                self.lookup_const_by_id(id)
-            }
+            SpirvValueKind::Def(id) => self.lookup_const_by_id(id),
             _ => None,
         }
     }

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -3,7 +3,7 @@ use crate::maybe_pqp_cg_ssa as rustc_codegen_ssa;
 
 use super::CodegenCx;
 use crate::abi::ConvSpirvType;
-use crate::builder_spirv::{SpirvConst, SpirvValue, SpirvValueExt, SpirvValueKind};
+use crate::builder_spirv::{SpirvConst, SpirvValue, SpirvValueExt};
 use crate::spirv_type::SpirvType;
 use itertools::Itertools as _;
 use rspirv::spirv::Word;
@@ -334,8 +334,7 @@ impl<'tcx> CodegenCx<'tcx> {
     pub fn const_bitcast(&self, val: SpirvValue, ty: Word) -> SpirvValue {
         // HACK(eddyb) special-case `const_data_from_alloc` + `static_addr_of`
         // as the old `from_const_alloc` (now `OperandRef::from_const_alloc`).
-        if let SpirvValueKind::IllegalConst(_) = val.kind
-            && let Some(SpirvConst::PtrTo { pointee }) = self.builder.lookup_const(val)
+        if let Some(SpirvConst::PtrTo { pointee }) = self.builder.lookup_const(val)
             && let Some(SpirvConst::ConstDataFromAlloc(alloc)) =
                 self.builder.lookup_const_by_id(pointee)
             && let SpirvType::Pointer { pointee } = self.lookup_type(ty)