Skip to main content

rustc_codegen_spirv/
symbols.rs

1use crate::attr::{IntrinsicType, SpirvAttribute};
2use crate::builder::libm_intrinsics;
3use rspirv::spirv::{BuiltIn, ExecutionMode, ExecutionModel, StorageClass};
4use rustc_data_structures::fx::FxHashMap;
5use rustc_span::symbol::Symbol;
6use spirv_std_types::spirv_attr_version::spirv_attr_with_version;
7use std::rc::Rc;
8
9/// Various places in the codebase (mostly attribute parsing) need to compare rustc Symbols to particular keywords.
10/// Symbols are interned, as in, they don't actually store the string itself inside them, but rather an index into a
11/// global table of strings. Then, whenever a new Symbol is created, the global table is checked to see if the string
12/// already exists, deduplicating it if so. This makes things like comparison and cloning really cheap. So, this struct
13/// is to allocate all our keywords up front and intern them all, so we can do comparisons really easily and fast.
14pub struct Symbols {
15    pub discriminant: Symbol,
16    pub rust_gpu: Symbol,
17    pub spirv_attr_with_version: Symbol,
18    pub vector: Symbol,
19    pub v1: Symbol,
20    pub libm: Symbol,
21    pub entry_point_name: Symbol,
22    pub spv_khr_vulkan_memory_model: Symbol,
23
24    pub descriptor_set: Symbol,
25    pub binding: Symbol,
26    pub location: Symbol,
27    pub input_attachment_index: Symbol,
28
29    pub spec_constant: Symbol,
30    pub id: Symbol,
31    pub default: Symbol,
32
33    pub attributes: FxHashMap<Symbol, SpirvAttribute>,
34    pub execution_modes: FxHashMap<Symbol, (ExecutionMode, ExecutionModeExtraDim)>,
35    pub libm_intrinsics: FxHashMap<Symbol, libm_intrinsics::LibmIntrinsic>,
36}
37
38const BUILTINS: &[(&str, BuiltIn)] = {
39    use BuiltIn::*;
40    &[
41        ("position", Position),
42        ("point_size", PointSize),
43        ("clip_distance", ClipDistance),
44        ("cull_distance", CullDistance),
45        ("vertex_id", VertexId),
46        ("instance_id", InstanceId),
47        ("primitive_id", PrimitiveId),
48        ("invocation_id", InvocationId),
49        ("layer", Layer),
50        ("viewport_index", ViewportIndex),
51        ("tess_level_outer", TessLevelOuter),
52        ("tess_level_inner", TessLevelInner),
53        ("tess_coord", TessCoord),
54        ("patch_vertices", PatchVertices),
55        ("frag_coord", FragCoord),
56        ("point_coord", PointCoord),
57        ("front_facing", FrontFacing),
58        ("sample_id", SampleId),
59        ("sample_position", SamplePosition),
60        ("sample_mask", SampleMask),
61        ("frag_depth", FragDepth),
62        ("helper_invocation", HelperInvocation),
63        ("num_workgroups", NumWorkgroups),
64        // ("workgroup_size", WorkgroupSize), -- constant
65        ("workgroup_id", WorkgroupId),
66        ("local_invocation_id", LocalInvocationId),
67        ("global_invocation_id", GlobalInvocationId),
68        ("local_invocation_index", LocalInvocationIndex),
69        // ("work_dim", WorkDim), -- Kernel-only
70        // ("global_size", GlobalSize), -- Kernel-only
71        // ("enqueued_workgroup_size", EnqueuedWorkgroupSize), -- Kernel-only
72        // ("global_offset", GlobalOffset), -- Kernel-only
73        // ("global_linear_id", GlobalLinearId), -- Kernel-only
74        ("subgroup_size", SubgroupSize),
75        // ("subgroup_max_size", SubgroupMaxSize), -- Kernel-only
76        ("num_subgroups", NumSubgroups),
77        // ("num_enqueued_subgroups", NumEnqueuedSubgroups), -- Kernel-only
78        ("subgroup_id", SubgroupId),
79        ("subgroup_local_invocation_id", SubgroupLocalInvocationId),
80        ("vertex_index", VertexIndex),
81        ("instance_index", InstanceIndex),
82        ("subgroup_eq_mask", SubgroupEqMask),
83        ("subgroup_ge_mask", SubgroupGeMask),
84        ("subgroup_gt_mask", SubgroupGtMask),
85        ("subgroup_le_mask", SubgroupLeMask),
86        ("subgroup_lt_mask", SubgroupLtMask),
87        ("base_vertex", BaseVertex),
88        ("base_instance", BaseInstance),
89        ("draw_index", DrawIndex),
90        ("device_index", DeviceIndex),
91        ("view_index", ViewIndex),
92        ("bary_coord_no_persp_amd", BaryCoordNoPerspAMD),
93        (
94            "bary_coord_no_persp_centroid_amd",
95            BaryCoordNoPerspCentroidAMD,
96        ),
97        ("bary_coord_no_persp_sample_amd", BaryCoordNoPerspSampleAMD),
98        ("bary_coord_smooth_amd", BaryCoordSmoothAMD),
99        ("bary_coord_smooth_centroid_amd", BaryCoordSmoothCentroidAMD),
100        ("bary_coord_smooth_sample_amd", BaryCoordSmoothSampleAMD),
101        ("bary_coord_pull_model_amd", BaryCoordPullModelAMD),
102        ("frag_stencil_ref_ext", FragStencilRefEXT),
103        ("viewport_mask_nv", ViewportMaskNV),
104        ("secondary_position_nv", SecondaryPositionNV),
105        ("secondary_viewport_mask_nv", SecondaryViewportMaskNV),
106        ("position_per_view_nv", PositionPerViewNV),
107        ("viewport_mask_per_view_nv", ViewportMaskPerViewNV),
108        ("fully_covered_ext", FullyCoveredEXT),
109        ("task_count_nv", TaskCountNV),
110        ("primitive_count_nv", PrimitiveCountNV),
111        ("primitive_indices_nv", PrimitiveIndicesNV),
112        ("clip_distance_per_view_nv", ClipDistancePerViewNV),
113        ("cull_distance_per_view_nv", CullDistancePerViewNV),
114        ("layer_per_view_nv", LayerPerViewNV),
115        ("mesh_view_count_nv", MeshViewCountNV),
116        ("mesh_view_indices_nv", MeshViewIndicesNV),
117        ("bary_coord_nv", BuiltIn::BaryCoordNV),
118        ("bary_coord_no_persp_nv", BuiltIn::BaryCoordNoPerspNV),
119        ("bary_coord", BaryCoordKHR),
120        ("bary_coord_no_persp", BaryCoordNoPerspKHR),
121        ("primitive_point_indices_ext", PrimitivePointIndicesEXT),
122        ("primitive_line_indices_ext", PrimitiveLineIndicesEXT),
123        (
124            "primitive_triangle_indices_ext",
125            PrimitiveTriangleIndicesEXT,
126        ),
127        ("cull_primitive_ext", CullPrimitiveEXT),
128        ("frag_size_ext", FragSizeEXT),
129        ("frag_invocation_count_ext", FragInvocationCountEXT),
130        ("launch_id", BuiltIn::LaunchIdKHR),
131        ("launch_size", BuiltIn::LaunchSizeKHR),
132        ("instance_custom_index", BuiltIn::InstanceCustomIndexKHR),
133        ("ray_geometry_index", BuiltIn::RayGeometryIndexKHR),
134        ("world_ray_origin", BuiltIn::WorldRayOriginKHR),
135        ("world_ray_direction", BuiltIn::WorldRayDirectionKHR),
136        ("object_ray_origin", BuiltIn::ObjectRayOriginKHR),
137        ("object_ray_direction", BuiltIn::ObjectRayDirectionKHR),
138        ("ray_tmin", BuiltIn::RayTminKHR),
139        ("ray_tmax", BuiltIn::RayTmaxKHR),
140        ("object_to_world", BuiltIn::ObjectToWorldKHR),
141        ("world_to_object", BuiltIn::WorldToObjectKHR),
142        (
143            "hit_triangle_vertex_positions",
144            BuiltIn::HitTriangleVertexPositionsKHR,
145        ),
146        ("hit_kind", BuiltIn::HitKindKHR),
147        ("incoming_ray_flags", BuiltIn::IncomingRayFlagsKHR),
148        ("warps_per_sm_nv", WarpsPerSMNV),
149        ("sm_count_nv", SMCountNV),
150        ("warp_id_nv", WarpIDNV),
151        ("SMIDNV", SMIDNV),
152    ]
153};
154
155const STORAGE_CLASSES: &[(&str, StorageClass)] = {
156    use StorageClass::*;
157    &[
158        ("uniform_constant", UniformConstant),
159        ("input", Input),
160        ("uniform", Uniform),
161        ("output", Output),
162        ("workgroup", Workgroup),
163        ("cross_workgroup", CrossWorkgroup),
164        ("private", Private),
165        ("function", Function),
166        ("generic", Generic),
167        ("push_constant", PushConstant),
168        ("atomic_counter", AtomicCounter),
169        ("image", Image),
170        ("storage_buffer", StorageBuffer),
171        ("callable_data", StorageClass::CallableDataKHR),
172        (
173            "incoming_callable_data",
174            StorageClass::IncomingCallableDataKHR,
175        ),
176        ("ray_payload", StorageClass::RayPayloadKHR),
177        ("hit_attribute", StorageClass::HitAttributeKHR),
178        ("incoming_ray_payload", StorageClass::IncomingRayPayloadKHR),
179        ("shader_record_buffer", StorageClass::ShaderRecordBufferKHR),
180        ("physical_storage_buffer", PhysicalStorageBuffer),
181        ("task_payload_workgroup_ext", TaskPayloadWorkgroupEXT),
182    ]
183};
184
185const EXECUTION_MODELS: &[(&str, ExecutionModel)] = {
186    use ExecutionModel::*;
187    &[
188        ("vertex", Vertex),
189        ("tessellation_control", TessellationControl),
190        ("tessellation_evaluation", TessellationEvaluation),
191        ("geometry", Geometry),
192        ("fragment", Fragment),
193        ("compute", GLCompute),
194        ("task_nv", TaskNV),
195        ("mesh_nv", MeshNV),
196        ("task_ext", TaskEXT),
197        ("mesh_ext", MeshEXT),
198        ("ray_generation", ExecutionModel::RayGenerationKHR),
199        ("intersection", ExecutionModel::IntersectionKHR),
200        ("any_hit", ExecutionModel::AnyHitKHR),
201        ("closest_hit", ExecutionModel::ClosestHitKHR),
202        ("miss", ExecutionModel::MissKHR),
203        ("callable", ExecutionModel::CallableKHR),
204    ]
205};
206
207#[derive(Copy, Clone, Debug)]
208pub enum ExecutionModeExtraDim {
209    None,
210    Value,
211    X,
212    Y,
213    Z,
214    Tuple,
215}
216
217const EXECUTION_MODES: &[(&str, ExecutionMode, ExecutionModeExtraDim)] = {
218    use ExecutionMode::*;
219    use ExecutionModeExtraDim::*;
220    &[
221        ("invocations", Invocations, Value),
222        ("spacing_equal", SpacingEqual, None),
223        ("spacing_fraction_even", SpacingFractionalEven, None),
224        ("spacing_fraction_odd", SpacingFractionalOdd, None),
225        ("vertex_order_cw", VertexOrderCw, None),
226        ("vertex_order_ccw", VertexOrderCcw, None),
227        ("pixel_center_integer", PixelCenterInteger, None),
228        ("origin_upper_left", OriginUpperLeft, None),
229        ("origin_lower_left", OriginLowerLeft, None),
230        ("early_fragment_tests", EarlyFragmentTests, None),
231        ("point_mode", PointMode, None),
232        ("xfb", Xfb, None),
233        ("depth_replacing", DepthReplacing, None),
234        ("depth_greater", DepthGreater, None),
235        ("depth_less", DepthLess, None),
236        ("depth_unchanged", DepthUnchanged, None),
237        ("threads", LocalSize, Tuple),
238        ("local_size_hint_x", LocalSizeHint, X),
239        ("local_size_hint_y", LocalSizeHint, Y),
240        ("local_size_hint_z", LocalSizeHint, Z),
241        ("input_points", InputPoints, None),
242        ("input_lines", InputLines, None),
243        ("input_lines_adjacency", InputLinesAdjacency, None),
244        ("triangles", Triangles, None),
245        ("input_triangles_adjacency", InputTrianglesAdjacency, None),
246        ("quads", Quads, None),
247        ("isolines", Isolines, None),
248        ("output_vertices", OutputVertices, Value),
249        ("output_points", OutputPoints, None),
250        ("output_line_strip", OutputLineStrip, None),
251        ("output_triangle_strip", OutputTriangleStrip, None),
252        ("vec_type_hint", VecTypeHint, Value),
253        ("contraction_off", ContractionOff, None),
254        ("initializer", Initializer, None),
255        ("finalizer", Finalizer, None),
256        ("subgroup_size", SubgroupSize, Value),
257        ("subgroups_per_workgroup", SubgroupsPerWorkgroup, Value),
258        ("subgroups_per_workgroup_id", SubgroupsPerWorkgroupId, Value),
259        ("local_size_id_x", LocalSizeId, X),
260        ("local_size_id_y", LocalSizeId, Y),
261        ("local_size_id_z", LocalSizeId, Z),
262        ("local_size_hint_id", LocalSizeHintId, Value),
263        ("post_depth_coverage", PostDepthCoverage, None),
264        ("denorm_preserve", DenormPreserve, None),
265        ("denorm_flush_to_zero", DenormFlushToZero, Value),
266        (
267            "signed_zero_inf_nan_preserve",
268            SignedZeroInfNanPreserve,
269            Value,
270        ),
271        ("rounding_mode_rte", RoundingModeRTE, Value),
272        ("rounding_mode_rtz", RoundingModeRTZ, Value),
273        ("stencil_ref_replacing_ext", StencilRefReplacingEXT, None),
274        ("output_lines_nv", OutputLinesEXT, None),
275        ("output_primitives_nv", OutputPrimitivesEXT, Value),
276        ("derivative_group_quads_nv", DerivativeGroupQuadsKHR, None),
277        ("output_triangles_nv", OutputTrianglesEXT, None),
278        ("output_lines_ext", ExecutionMode::OutputLinesEXT, None),
279        (
280            "output_triangles_ext",
281            ExecutionMode::OutputTrianglesEXT,
282            None,
283        ),
284        (
285            "output_primitives_ext",
286            ExecutionMode::OutputPrimitivesEXT,
287            Value,
288        ),
289        (
290            "pixel_interlock_ordered_ext",
291            PixelInterlockOrderedEXT,
292            None,
293        ),
294        (
295            "pixel_interlock_unordered_ext",
296            PixelInterlockUnorderedEXT,
297            None,
298        ),
299        (
300            "sample_interlock_ordered_ext",
301            SampleInterlockOrderedEXT,
302            None,
303        ),
304        (
305            "sample_interlock_unordered_ext",
306            SampleInterlockUnorderedEXT,
307            None,
308        ),
309        (
310            "shading_rate_interlock_ordered_ext",
311            ShadingRateInterlockOrderedEXT,
312            None,
313        ),
314        (
315            "shading_rate_interlock_unordered_ext",
316            ShadingRateInterlockUnorderedEXT,
317            None,
318        ),
319        // Reserved
320        /*("max_workgroup_size_intel_x", MaxWorkgroupSizeINTEL, X),
321        ("max_workgroup_size_intel_y", MaxWorkgroupSizeINTEL, Y),
322        ("max_workgroup_size_intel_z", MaxWorkgroupSizeINTEL, Z),
323        ("max_work_dim_intel", MaxWorkDimINTEL, Value),
324        ("no_global_offset_intel", NoGlobalOffsetINTEL, None),
325        ("num_simd_workitems_intel", NumSIMDWorkitemsINTEL, Value),*/
326    ]
327};
328
329impl Symbols {
330    fn new() -> Self {
331        let builtins = BUILTINS
332            .iter()
333            .map(|&(a, b)| (a, SpirvAttribute::Builtin(b)));
334        let storage_classes = STORAGE_CLASSES
335            .iter()
336            .map(|&(a, b)| (a, SpirvAttribute::StorageClass(b)));
337        let execution_models = EXECUTION_MODELS
338            .iter()
339            .map(|&(a, b)| (a, SpirvAttribute::Entry(b.into())));
340        let custom_attributes = [
341            (
342                "sampler",
343                SpirvAttribute::IntrinsicType(IntrinsicType::Sampler),
344            ),
345            (
346                "generic_image_type",
347                SpirvAttribute::IntrinsicType(IntrinsicType::GenericImageType),
348            ),
349            (
350                "acceleration_structure",
351                SpirvAttribute::IntrinsicType(IntrinsicType::AccelerationStructureKhr),
352            ),
353            (
354                "ray_query",
355                SpirvAttribute::IntrinsicType(IntrinsicType::RayQueryKhr),
356            ),
357            (
358                "cooperative_matrix",
359                SpirvAttribute::IntrinsicType(IntrinsicType::CooperativeMatrixKhr),
360            ),
361            ("block", SpirvAttribute::Block),
362            ("flat", SpirvAttribute::Flat),
363            ("invariant", SpirvAttribute::Invariant),
364            ("per_primitive_ext", SpirvAttribute::PerPrimitiveExt),
365            (
366                "sampled_image",
367                SpirvAttribute::IntrinsicType(IntrinsicType::SampledImage),
368            ),
369            (
370                "runtime_array",
371                SpirvAttribute::IntrinsicType(IntrinsicType::RuntimeArray),
372            ),
373            (
374                "typed_buffer",
375                SpirvAttribute::IntrinsicType(IntrinsicType::TypedBuffer),
376            ),
377            (
378                "matrix",
379                SpirvAttribute::IntrinsicType(IntrinsicType::Matrix),
380            ),
381            (
382                "vector",
383                SpirvAttribute::IntrinsicType(IntrinsicType::Vector),
384            ),
385            ("buffer_load_intrinsic", SpirvAttribute::BufferLoadIntrinsic),
386            (
387                "buffer_store_intrinsic",
388                SpirvAttribute::BufferStoreIntrinsic,
389            ),
390        ]
391        .iter()
392        .cloned();
393        let attributes_iter = builtins
394            .chain(storage_classes)
395            .chain(execution_models)
396            .chain(custom_attributes)
397            .map(|(a, b)| (Symbol::intern(a), b));
398        let mut attributes = FxHashMap::default();
399        for (a, b) in attributes_iter {
400            let old = attributes.insert(a, b);
401            // `.collect()` into a FxHashMap does not error on duplicates, so manually write out the
402            // loop here to error on duplicates.
403            assert!(old.is_none());
404        }
405        let mut execution_modes = FxHashMap::default();
406        for &(key, mode, dim) in EXECUTION_MODES {
407            let old = execution_modes.insert(Symbol::intern(key), (mode, dim));
408            assert!(old.is_none());
409        }
410
411        let mut libm_intrinsics = FxHashMap::default();
412        for &(a, b) in libm_intrinsics::LIBM_TABLE {
413            let old = libm_intrinsics.insert(Symbol::intern(a), b);
414            assert!(old.is_none());
415        }
416
417        Self {
418            discriminant: Symbol::intern("discriminant"),
419            rust_gpu: Symbol::intern("rust_gpu"),
420            spirv_attr_with_version: Symbol::intern(&spirv_attr_with_version()),
421            vector: Symbol::intern("vector"),
422            v1: Symbol::intern("v1"),
423            libm: Symbol::intern("libm"),
424            entry_point_name: Symbol::intern("entry_point_name"),
425            spv_khr_vulkan_memory_model: Symbol::intern("SPV_KHR_vulkan_memory_model"),
426
427            descriptor_set: Symbol::intern("descriptor_set"),
428            binding: Symbol::intern("binding"),
429            location: Symbol::intern("location"),
430            input_attachment_index: Symbol::intern("input_attachment_index"),
431
432            spec_constant: Symbol::intern("spec_constant"),
433            id: Symbol::intern("id"),
434            default: Symbol::intern("default"),
435
436            attributes,
437            execution_modes,
438            libm_intrinsics,
439        }
440    }
441
442    /// Obtain an `Rc` handle to the current thread's `Symbols` instance, which
443    /// will be shared between all `Symbols::get()` calls on the same thread.
444    ///
445    /// While this is relatively cheap, prefer caching it in e.g. `CodegenCx`,
446    /// rather than calling `get()` every time a field of `Symbols` is needed.
447    pub fn get() -> Rc<Self> {
448        thread_local!(static SYMBOLS: Rc<Symbols> = Rc::new(Symbols::new()));
449        SYMBOLS.with(Rc::clone)
450    }
451}